F8/src/mmc.js

var Memory = require('src/memory');

class Switch{
  constructor(mem){
    this.__mem = [mem];
    this.__idx = 0;
  }

  get mem(){return this.__mem[this.__idx];}

  get idx(){return this.__idx;}
  set idx(i){
    if (i >= 0 && i < this.__mem.length)
      this.__idx = i;
  }

  addMemModule(mem){
    if (!(mem instanceof Memory))
      throw new ValueError("Only Memory instances can be added to MMC Banks.");
    if (this.__mem.length >= 4)
      throw new RangeError("Bank handling maximum memory modules.");
    if (this.__mem.length > 0 && mem.size !== this.__mem[0].size)
      throw new RangeError("Memory module does not match size of already connected memory modules on this bank.");
    this.__mem.push(mem);
  }
}



class MMC extends Memory{
  constructor(){
    super();
    this.__switches = [];
    this.__addr = 0;
    this.__sidx = 0;
  }

  get size(){
    return this.__switches.reduce((acc, s)=>{
      acc += s.mem.size;
    }, 0);
  }

  get switches(){return this.__switches.length;}

  get address(){return this.__addr;}
  set address(a){
    if (a >= 0 && a < this.size){
      this.__addr = a;
      offset = 0;
      for (let s=0; s < this.__switches.length; s++){
        if (a >= offset && a < offset + this.__switches[s].mem.size){
          this.__sidx = b;
          this.__switches[s].mem.address = a - offset;
          break;
        } else {
          offset += this.__switches[s].mem.size;
        }
      }
    }
  }

  get byte(){return (this.__switches.length > 0) ? this.__switches[this.__sidx].mem.byte : -1;}
  set byte(b){
    if (this.__switches.length > 0){
      this.__switches[this.__sidx].mem.byte = b;
    }
  }

  connectMemory(mem, addroff){
    addroff = (typeof(addroff) === 'number' && addroff >= 0) ? addroff : -1;
    if (addroff < 0 || addroff === this.size){
      this.__switches.push(new Switch(mem));
    } else {
      offset = 0;
      for (let s=0; s < this.__switches.length; s++){
        if (addroff === offset){
          if (this.__switches[s].mem.size !== mem.size)
            throw new RangeError("Memory modules assigned to the same bank must be the same byte size.");
          this.__switches[s].addMemModule(mem);
          offset = -1;
          break;
        } else {
          offset += this.__switches[s].mem.size;
        }
      }
      if (offset >= 0)
        throw new RangeError("Cannot align memory module to bank at address " + addroff);
    }
    return this;
  }
  
  mmSwitchRegister(){
    return (function(byte){
      let mmcidx = (byte & 0xF0) >> 4;
      if (mmcidx < this.__switches.length){
        this.__switches[mmcidx].idx = (byte & 0x0F);
      }
    }).bind(this);
  }
}

module.exports = MMC;