gameboy.html

<!--
https://github.com/juchi/gameboy.js

The MIT License (MIT)

Copyright (c) 2015 Julien Chichignoud

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

-->
<script>
function loadboot(p) {
  var boot = [
    0x31, 0xFE, 0xFF, 0xAF, 0x21, 0xFF, 0x9F, 0x32, 0xCB, 0x7C, 0x20, 0xFB, 0x21, 0x26, 0xFF, 0x0E,
    0x11, 0x3E, 0x80, 0x32, 0xE2, 0x0C, 0x3E, 0xF3, 0xE2, 0x32, 0x3E, 0x77, 0x77, 0x3E, 0xFC, 0xE0,
    0x47, 0x11, 0x04, 0x01, 0x21, 0x10, 0x80, 0x1A, 0xCD, 0x95, 0x00, 0xCD, 0x96, 0x00, 0x13, 0x7B,
    0xFE, 0x34, 0x20, 0xF3, 0x11, 0xD8, 0x00, 0x06, 0x08, 0x1A, 0x13, 0x22, 0x23, 0x05, 0x20, 0xF9,
    0x3E, 0x19, 0xEA, 0x10, 0x99, 0x21, 0x2F, 0x99, 0x0E, 0x0C, 0x3D, 0x28, 0x08, 0x32, 0x0D, 0x20,
    0xF9, 0x2E, 0x0F, 0x18, 0xF3, 0x67, 0x3E, 0x64, 0x57, 0xE0, 0x42, 0x3E, 0x91, 0xE0, 0x40, 0x04,
    0x1E, 0x02, 0x0E, 0x0C, 0xF0, 0x44, 0xFE, 0x90, 0x20, 0xFA, 0x0D, 0x20, 0xF7, 0x1D, 0x20, 0xF2,
    0x0E, 0x13, 0x24, 0x7C, 0x1E, 0x83, 0xFE, 0x62, 0x28, 0x06, 0x1E, 0xC1, 0xFE, 0x64, 0x20, 0x06,
    0x7B, 0xE2, 0x0C, 0x3E, 0x87, 0xE2, 0xF0, 0x42, 0x90, 0xE0, 0x42, 0x15, 0x20, 0xD2, 0x05, 0x20,
    0x4F, 0x16, 0x20, 0x18, 0xCB, 0x4F, 0x06, 0x04, 0xC5, 0xCB, 0x11, 0x17, 0xC1, 0xCB, 0x11, 0x17,
    0x05, 0x20, 0xF5, 0x22, 0x23, 0x22, 0x23, 0xC9, 0xCE, 0xED, 0x66, 0x66, 0xCC, 0x0D, 0x00, 0x0B,
    0x03, 0x73, 0x00, 0x83, 0x00, 0x0C, 0x00, 0x0D, 0x00, 0x08, 0x11, 0x1F, 0x88, 0x89, 0x00, 0x0E,
    0xDC, 0xCC, 0x6E, 0xE6, 0xDD, 0xDD, 0xD9, 0x99, 0xBB, 0xBB, 0x67, 0x63, 0x6E, 0x0E, 0xEC, 0xCC,
    0xDD, 0xDC, 0x99, 0x9F, 0xBB, 0xB9, 0x33, 0x3E, 0x3C, 0x42, 0xB9, 0xA5, 0xB9, 0xA5, 0x42, 0x3C,
    0x21, 0x04, 0x01, 0x11, 0xA8, 0x00, 0x1A, 0x13, 0xBE, 0x00, 0x00, 0x23, 0x7D, 0xFE, 0x34, 0x20,
    0xF5, 0x06, 0x19, 0x78, 0x86, 0x23, 0x05, 0x20, 0xFB, 0x86, 0x00, 0x00, 0x3E, 0x01, 0xE0, 0x50
  ];

  for (var i in boot) {
    p.memory[i] = boot[i];
  }
  p.r.pc = 0;
  p.usingBootRom = true;
}

var GameboyJS;
(function (GameboyJS) {
  "use strict";

// CPU class
  var CPU = function(gameboy) {
    this.gameboy = gameboy;

    this.r = {A:0, F: 0, B:0, C:0, D:0, E:0, H:0, L:0, pc:0, sp:0};
    this.IME = true;
    this.clock = {c: 0, serial: 0};
    this.isHalted = false;
    this.isPaused = false;
    this.usingBootRom = false;

    this.createDevices();
  };

  CPU.INTERRUPTS = {
    VBLANK: 0,
    LCDC:   1,
    TIMER:  2,
    SERIAL: 3,
    HILO:   4
  };
  CPU.interruptRoutines = {
    0: function(p){GameboyJS.cpuOps.RSTn(p, 0x40);},
    1: function(p){GameboyJS.cpuOps.RSTn(p, 0x48);},
    2: function(p){GameboyJS.cpuOps.RSTn(p, 0x50);},
    3: function(p){GameboyJS.cpuOps.RSTn(p, 0x58);},
    4: function(p){GameboyJS.cpuOps.RSTn(p, 0x60);}
  };

  CPU.prototype.createDevices = function() {
    this.memory = new GameboyJS.Memory(this);
    this.timer = new GameboyJS.Timer(this, this.memory);
    this.apu = new GameboyJS.APU(this.memory);

    this.SERIAL_INTERNAL_INSTR = 512; // instr to wait per bit if internal clock
    this.enableSerial = 0;
    this.serialHandler = GameboyJS.ConsoleSerial;
  };

  CPU.prototype.reset = function() {
    this.memory.reset();

    this.r.sp = 0xFFFE;
  };

  CPU.prototype.loadRom = function(data) {
    this.memory.setRomData(data);
  };

  CPU.prototype.getRamSize = function() {
    var size = 0;
    switch (this.memory.rb(0x149)) {
      case 1:
        size = 2048;
        break;
      case 2:
        size = 2048 * 4;
        break;
      case 3:
        size = 2048 * 16;
        break;
    }

    return size;
  };

  CPU.prototype.getGameName = function() {
    var name = '';
    for (var i = 0x134; i < 0x143; i++) {
      var char = this.memory.rb(i) || 32;
      name += String.fromCharCode(char);
    }

    return name;
  };

// Start the execution of the emulator
  CPU.prototype.run = function() {
    if (this.usingBootRom) {
      this.r.pc = 0x0000;
    } else {
      this.r.pc = 0x0100;
    }
    this.frame();
  };

  CPU.prototype.stop = function() {
    clearTimeout(this.nextFrameTimer);
  };

// Fetch-and-execute loop
// Will execute instructions for the duration of a frame
//
// The screen unit will notify the vblank period which
// is considered the end of a frame
//
// The function is called on a regular basis with a timeout
  CPU.prototype.frame = function() {
    if (!this.isPaused) {
      this.nextFrameTimer = setTimeout(this.frame.bind(this), 1000 / GameboyJS.Screen.physics.FREQUENCY);
    }

    try {
      var vblank = false;
      while (!vblank) {
        var oldInstrCount = this.clock.c;
        if (!this.isHalted) {
          var opcode = this.fetchOpcode();
          GameboyJS.opcodeMap[opcode](this);
          this.r.F &= 0xF0; // tmp fix

          if (this.enableSerial) {
            var instr = this.clock.c - oldInstrCount;
            this.clock.serial += instr;
            if (this.clock.serial >= 8 * this.SERIAL_INTERNAL_INSTR) {
              this.endSerialTransfer();
            }
          }
        } else {
          this.clock.c += 4;
        }

        var elapsed = this.clock.c - oldInstrCount;
        vblank = this.gpu.update(elapsed);
        this.timer.update(elapsed);
        this.input.update();
        this.apu.update(elapsed);
        this.checkInterrupt();
      }
      this.clock.c = 0;
    } catch (e) {
      this.gameboy.handleException(e);
    }
  };

  CPU.prototype.fetchOpcode = function() {
    var opcode = this.memory.rb(this.r.pc++);
    if (opcode === undefined) {console.log(opcode + ' at ' + (this.r.pc-1).toString(16));this.stop();return;}
    if (!GameboyJS.opcodeMap[opcode]) {
      console.error('Unknown opcode '+opcode.toString(16)+' at address '+(this.r.pc-1).toString(16)+', stopping execution...');
      this.stop();
      return null;
    }

    return opcode;
  };

// read register
  CPU.prototype.rr = function(register) {
    return this.r[register];
  };

// write register
  CPU.prototype.wr = function(register, value) {
    this.r[register] = value;
  };

  CPU.prototype.halt = function() {
    this.isHalted = true;
  };
  CPU.prototype.unhalt = function() {
    this.isHalted = false;
  };
  CPU.prototype.pause = function() {
    this.isPaused = true;
  };
  CPU.prototype.unpause = function() {
    if (this.isPaused) {
      this.isPaused = false;
      this.frame();
    }
  };

// Look for interrupt flags
  CPU.prototype.checkInterrupt = function() {
    if (!this.IME) {
      return;
    }
    for (var i = 0; i < 5; i++) {
      var IFval = this.memory.rb(0xFF0F);
      if (GameboyJS.Util.readBit(IFval, i) && this.isInterruptEnable(i)) {
        IFval &= (0xFF - (1<<i));
        this.memory.wb(0xFF0F, IFval);
        this.disableInterrupts();
        this.clock.c += 4; // 20 clocks to serve interrupt, with 16 for RSTn
        CPU.interruptRoutines[i](this);
        break;
      }
    }
  };

// Set an interrupt flag
  CPU.prototype.requestInterrupt = function(type) {
    var IFval = this.memory.rb(0xFF0F);
    IFval |= (1 << type)
    this.memory.wb(0xFF0F, IFval) ;
    this.unhalt();
  };

  CPU.prototype.isInterruptEnable = function(type) {
    return GameboyJS.Util.readBit(this.memory.rb(0xFFFF), type) != 0;
  };

  CPU.prototype.enableInterrupts = function() {
    this.IME = true;
  };
  CPU.prototype.disableInterrupts = function() {
    this.IME = false;
  };

  CPU.prototype.enableSerialTransfer = function() {
    this.enableSerial = 1;
    this.clock.serial = 0;
  };

  CPU.prototype.endSerialTransfer = function() {
    this.enableSerial = 0;
    var data = this.memory.rb(0xFF01);
    this.memory.wb(0xFF02, 0);
    this.serialHandler.out(data);
    this.memory.wb(0xFF01, this.serialHandler.in());
  };

  CPU.prototype.resetDivTimer = function() {
    this.timer.resetDiv();
  };
  GameboyJS.CPU = CPU;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
  "use strict";

  var Debug = {};
// Output a range of 16 memory addresses
  Debug.view_memory = function(addr, gameboy) {
    var memory = gameboy.cpu.memory;
    addr = addr & 0xFFF0;
    var pad = '00';
    var str = addr.toString(16) + ':';
    for (var i = addr; i < addr + 0x10; i++) {
      if ((i & 0x1) == 0) {
        str += ' ';
      }
      var val = memory[i] || 0;

      val = val.toString(16);
      str += pad.substring(val.length) + val;
    }

    return str;
  };

  Debug.view_tile = function(gameboy, index, dataStart) {
    var memory = gameboy.cpu.memory;
    var screen = gameboy.screen;
    var LCDC = screen.deviceram(screen.LCDC);
    if (typeof dataStart === 'undefined') {
      dataStart = 0x8000;
      if (!GameboyJS.Util.readBit(LCDC, 4)) {
        dataStart = 0x8800;
        index = GameboyJS.cpuOps._getSignedValue(index) + 128;
      }
    }

    var tileData = screen.readTileData(index, dataStart);

    var pixelData = new Array(8 * 8)
    for (var line = 0; line < 8; line++) {
      var b1 = tileData.shift();
      var b2 = tileData.shift();

      for (var pixel = 0; pixel < 8; pixel++) {
        var mask = (1 << (7-pixel));
        var colorValue = ((b1 & mask) >> (7-pixel)) + ((b2 & mask) >> (7-pixel))*2;
        pixelData[line * 8 + pixel] = colorValue;
      }
    }

    var i = 0;
    while (pixelData.length) {
      console.log(i++ + ' ' + pixelData.splice(0, 8).join(''));
    }
  };

  Debug.list_visible_sprites = function(gameboy) {
    var memory = gameboy.cpu.memory;
    var indexes = new Array();
    for (var i = 0xFE00; i < 0xFE9F; i += 4) {
      var x = memory.oamram(i + 1);
      var y = memory.oamram(i);
      var tileIndex = memory.oamram(i + 2);
      if (x == 0 || x >= 168) {
        continue;
      }
      indexes.push({oamIndex:i, x:x, y:y, tileIndex:tileIndex});
    }

    return indexes;
  };
  GameboyJS.Debug = Debug;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
  "use strict";
  var Screen;
  var GPU = function(screen, cpu) {
    this.cpu = cpu;
    this.screen = screen;

    this.LCDC= 0xFF40;
    this.STAT= 0xFF41;
    this.SCY = 0xFF42;
    this.SCX = 0xFF43;
    this.LY  = 0xFF44;
    this.LYC = 0xFF45;
    this.BGP = 0xFF47;
    this.OBP0= 0xFF48;
    this.OBP1= 0xFF49;
    this.WY  = 0xFF4A;
    this.WX  = 0xFF4B;

    this.vram = cpu.memory.vram.bind(cpu.memory);

    this.OAM_START = 0xFE00;
    this.OAM_END   = 0xFE9F;
    this.deviceram = cpu.memory.deviceram.bind(cpu.memory);
    this.oamram = cpu.memory.oamram.bind(cpu.memory);
    this.VBLANK_TIME = 70224;
    this.clock = 0;
    this.mode = 2;
    this.line = 0;

    Screen = GameboyJS.Screen;
    this.buffer = new Array(Screen.physics.WIDTH * Screen.physics.HEIGHT);
    this.tileBuffer = new Array(8);
    this.bgTileCache = {};
  };

  GPU.tilemap = {
    HEIGHT: 32,
    WIDTH: 32,
    START_0: 0x9800,
    START_1: 0x9C00,
    LENGTH: 0x0400 // 1024 bytes = 32*32
  };

  GPU.prototype.update = function(clockElapsed) {
    this.clock += clockElapsed;
    var vblank = false;

    switch (this.mode) {
      case 0: // HBLANK
        if (this.clock >= 204) {
          this.clock -= 204;
          this.line++;
          this.updateLY();
          if (this.line == 144) {
            this.setMode(1);
            vblank = true;
            this.cpu.requestInterrupt(GameboyJS.CPU.INTERRUPTS.VBLANK);
            this.drawFrame();
          } else {
            this.setMode(2);
          }
        }
        break;
      case 1: // VBLANK
        if (this.clock >= 456) {
          this.clock -= 456;
          this.line++;
          if (this.line > 153) {
            this.line = 0;
            this.setMode(2);
          }
          this.updateLY();
        }

        break;
      case 2: // SCANLINE OAM
        if (this.clock >= 80) {
          this.clock -= 80;
          this.setMode(3);
        }
        break;
      case 3: // SCANLINE VRAM
        if (this.clock >= 172) {
          this.clock -= 172;
          this.drawScanLine(this.line);
          this.setMode(0);
        }
        break;
    }

    return vblank;
  };

  GPU.prototype.updateLY = function() {
    this.deviceram(this.LY, this.line);
    var STAT = this.deviceram(this.STAT);
    if (this.deviceram(this.LY) == this.deviceram(this.LYC)) {
      this.deviceram(this.STAT, STAT | (1 << 2));
      if (STAT & (1 << 6)) {
        this.cpu.requestInterrupt(GameboyJS.CPU.INTERRUPTS.LCDC);
      }
    } else {
      this.deviceram(this.STAT, STAT & (0xFF - (1 << 2)));
    }
  };

  GPU.prototype.setMode = function(mode) {
    this.mode = mode;
    var newSTAT = this.deviceram(this.STAT);
    newSTAT &= 0xFC;
    newSTAT |= mode;
    this.deviceram(this.STAT, newSTAT);

    if (mode < 3) {
      if (newSTAT & (1 << (3+mode))) {
        this.cpu.requestInterrupt(GameboyJS.CPU.INTERRUPTS.LCDC);
      }
    }
  };

// Push one scanline into the main buffer
  GPU.prototype.drawScanLine = function(line) {
    var LCDC = this.deviceram(this.LCDC);
    var enable = GameboyJS.Util.readBit(LCDC, 7);
    if (enable) {
      var lineBuffer = new Array(Screen.physics.WIDTH);
      this.drawBackground(LCDC, line, lineBuffer);
      this.drawSprites(LCDC, line, lineBuffer);
      // TODO draw a line for the window here too
    }
  };

  GPU.prototype.drawFrame = function() {
    var LCDC = this.deviceram(this.LCDC);
    var enable = GameboyJS.Util.readBit(LCDC, 7);
    if (enable) {
      //this.drawSprites(LCDC);
      this.drawWindow(LCDC);
    }
    this.bgTileCache = {};
    this.screen.render(this.buffer);
  };

  GPU.prototype.drawBackground = function(LCDC, line, lineBuffer) {
    if (!GameboyJS.Util.readBit(LCDC, 0)) {
      return;
    }

    var mapStart = GameboyJS.Util.readBit(LCDC, 3) ? GPU.tilemap.START_1 : GPU.tilemap.START_0;

    var dataStart, signedIndex = false;
    if (GameboyJS.Util.readBit(LCDC, 4)) {
      dataStart = 0x8000;
    } else {
      dataStart = 0x8800;
      signedIndex = true;
    }

    var bgx = this.deviceram(this.SCX);
    var bgy = this.deviceram(this.SCY);
    var tileLine = ((line + bgy) & 7);

    // browse BG tilemap for the line to render
    var tileRow = ((((bgy + line) / 8) | 0) & 0x1F);
    var firstTile = ((bgx / 8) | 0) + 32 * tileRow;
    var lastTile = firstTile + Screen.physics.WIDTH / 8 + 1;
    if ((lastTile & 0x1F) < (firstTile & 0x1F)) {
      lastTile -= 32;
    }
    var x = (firstTile & 0x1F) * 8 - bgx; // x position of the first tile's leftmost pixel
    for (var i = firstTile; i != lastTile; i++, (i & 0x1F) == 0 ? i-=32 : null) {
      var tileIndex = this.vram(i + mapStart);

      if (signedIndex) {
        tileIndex = GameboyJS.Util.getSignedValue(tileIndex) + 128;
      }

      // try to retrieve the tile data from the cache, or use readTileData() to read from ram
      // TODO find a better cache system now that the BG is rendered line by line
      var tileData = this.bgTileCache[tileIndex] || (this.bgTileCache[tileIndex] = this.readTileData(tileIndex, dataStart));

      this.drawTileLine(tileData, tileLine);
      this.copyBGTileLine(lineBuffer, this.tileBuffer, x);
      x += 8;
    }

    this.copyLineToBuffer(lineBuffer, line);
  };

// Copy a tile line from a tileBuffer to a line buffer, at a given x position
  GPU.prototype.copyBGTileLine = function(lineBuffer, tileBuffer, x) {
    // copy tile line to buffer
    for (var k = 0; k < 8; k++, x++) {
      if (x < 0 || x >= Screen.physics.WIDTH) continue;
      lineBuffer[x] = tileBuffer[k];
    }
  };

// Copy a scanline into the main buffer
  GPU.prototype.copyLineToBuffer = function(lineBuffer, line) {
    var bgPalette = GPU.getPalette(this.deviceram(this.BGP));

    for (var x = 0; x < Screen.physics.WIDTH; x++) {
      var color = lineBuffer[x];
      this.drawPixel(x, line, bgPalette[color]);
    }
  };

// Write a line of a tile (8 pixels) into a buffer array
  GPU.prototype.drawTileLine = function(tileData, line, xflip, yflip) {
    xflip = xflip | 0;
    yflip = yflip | 0;
    var l = yflip ? 7 - line : line;
    var byteIndex = l * 2;
    var b1 = tileData[byteIndex++];
    var b2 = tileData[byteIndex++];

    var offset = 8;
    for (var pixel = 0; pixel < 8; pixel++) {
      offset--;
      var mask = (1 << offset);
      var colorValue = ((b1 & mask) >> offset) + ((b2 & mask) >> offset)*2;
      var p = xflip ? offset : pixel;
      this.tileBuffer[p] = colorValue;
    }
  };

  GPU.prototype.drawSprites = function(LCDC, line, lineBuffer) {
    if (!GameboyJS.Util.readBit(LCDC, 1)) {
      return;
    }
    var spriteHeight = GameboyJS.Util.readBit(LCDC, 2) ? 16 : 8;

    var sprites = new Array();
    for (var i = this.OAM_START; i < this.OAM_END && sprites.length < 10; i += 4) {
      var y = this.oamram(i);
      var x = this.oamram(i+1);
      var index = this.oamram(i+2);
      var flags = this.oamram(i+3);

      if (y - 16 > line || y - 16 < line - spriteHeight) {
        continue;
      }
      sprites.push({x:x, y:y, index:index, flags:flags})
    }

    if (sprites.length == 0) return;

    // cache object to store read tiles from this frame
    var cacheTile = {};
    var spriteLineBuffer = new Array(Screen.physics.WIDTH);

    for (var i = 0; i < sprites.length; i++) {
      var sprite = sprites[i];
      var tileLine = line - sprite.y + 16;
      var paletteNumber = GameboyJS.Util.readBit(flags, 4);
      var xflip = GameboyJS.Util.readBit(sprite.flags, 5);
      var yflip = GameboyJS.Util.readBit(sprite.flags, 6);
      var tileData = cacheTile[sprite.index] || (cacheTile[sprite.index] = this.readTileData(sprite.index, 0x8000, spriteHeight * 2));
      this.drawTileLine(tileData, tileLine, xflip, yflip);
      this.copySpriteTileLine(spriteLineBuffer, this.tileBuffer, sprite.x - 8, paletteNumber);
    }

    this.copySpriteLineToBuffer(spriteLineBuffer, line);
  };

// Copy a tile line from a tileBuffer to a line buffer, at a given x position
  GPU.prototype.copySpriteTileLine = function(lineBuffer, tileBuffer, x, palette) {
    // copy tile line to buffer
    for (var k = 0; k < 8; k++, x++) {
      if (x < 0 || x >= Screen.physics.WIDTH || tileBuffer[k] == 0) continue;
      lineBuffer[x] = {color:tileBuffer[k], palette: palette};
    }
  };

// Copy a sprite scanline into the main buffer
  GPU.prototype.copySpriteLineToBuffer = function(spriteLineBuffer, line) {
    var spritePalettes = {};
    spritePalettes[0] = GPU.getPalette(this.deviceram(this.OBP0));
    spritePalettes[1] = GPU.getPalette(this.deviceram(this.OBP1));

    for (var x = 0; x < Screen.physics.WIDTH; x++) {
      if (!spriteLineBuffer[x]) continue;
      var color = spriteLineBuffer[x].color;
      if (color === 0) continue;
      var paletteNumber = spriteLineBuffer[x].palette;
      this.drawPixel(x, line, spritePalettes[paletteNumber][color]);
    }
  };

  GPU.prototype.drawTile = function(tileData, x, y, buffer, bufferWidth, xflip, yflip, spriteMode) {
    xflip = xflip | 0;
    yflip = yflip | 0;
    spriteMode = spriteMode | 0;
    var byteIndex = 0;
    for (var line = 0; line < 8; line++) {
      var l = yflip ? 7 - line : line;
      var b1 = tileData[byteIndex++];
      var b2 = tileData[byteIndex++];

      for (var pixel = 0; pixel < 8; pixel++) {
        var mask = (1 << (7-pixel));
        var colorValue = ((b1 & mask) >> (7-pixel)) + ((b2 & mask) >> (7-pixel))*2;
        if (spriteMode && colorValue == 0) continue;
        var p = xflip ? 7 - pixel : pixel;
        var bufferIndex = (x + p) + (y + l) * bufferWidth;
        buffer[bufferIndex] = colorValue;
      }
    }
  };

// get an array of tile bytes data (16 entries for 8*8px)
  GPU.prototype.readTileData = function(tileIndex, dataStart, tileSize) {
    tileSize = tileSize || 0x10; // 16 bytes / tile by default (8*8 px)
    var tileData = new Array();

    var tileAddressStart = dataStart + (tileIndex * 0x10);
    for (var i = tileAddressStart; i < tileAddressStart + tileSize; i++) {
      tileData.push(this.vram(i));
    }

    return tileData;
  };

  GPU.prototype.drawWindow = function(LCDC) {
    if (!GameboyJS.Util.readBit(LCDC, 5)) {
      return;
    }

    var buffer = new Array(256*256);
    var mapStart = GameboyJS.Util.readBit(LCDC, 6) ? GPU.tilemap.START_1 : GPU.tilemap.START_0;

    var dataStart, signedIndex = false;
    if (GameboyJS.Util.readBit(LCDC, 4)) {
      dataStart = 0x8000;
    } else {
      dataStart = 0x8800;
      signedIndex = true;
    }

    // browse Window tilemap
    for (var i = 0; i < GPU.tilemap.LENGTH; i++) {
      var tileIndex = this.vram(i + mapStart);

      if (signedIndex) {
        tileIndex = GameboyJS.Util.getSignedValue(tileIndex) + 128;
      }

      var tileData = this.readTileData(tileIndex, dataStart);
      var x = i % GPU.tilemap.WIDTH;
      var y = (i / GPU.tilemap.WIDTH) | 0;
      this.drawTile(tileData, x * 8, y * 8, buffer, 256);
    }

    var wx = this.deviceram(this.WX) - 7;
    var wy = this.deviceram(this.WY);
    for (var x = Math.max(0, -wx); x < Math.min(Screen.physics.WIDTH, Screen.physics.WIDTH - wx); x++) {
      for (var y = Math.max(0, -wy); y < Math.min(Screen.physics.HEIGHT, Screen.physics.HEIGHT - wy); y++) {
        var color = buffer[(x & 255) + (y & 255) * 256];
        this.drawPixel(x + wx, y + wy, color);
      }
    }
  };

  GPU.prototype.drawPixel = function(x, y, color) {
    this.buffer[y * 160 + x] = color;
  };

  GPU.prototype.getPixel = function(x, y) {
    return this.buffer[y * 160 + x];
  };

// Get the palette mapping from a given palette byte as stored in memory
// A palette will map a tile color to a final palette color index
// used with Screen.colors to get a shade of grey
  GPU.getPalette = function(paletteByte) {
    var palette = [];
    for (var i = 0; i < 8; i += 2) {
      var shade = (paletteByte & (3 << i)) >> i;
      palette.push(shade);
    }
    return palette;
  };

  GameboyJS.GPU = GPU;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
  "use strict";

// Screen device
  var Screen = function(canvas, pixelSize) {
    this.context = canvas.getContext('2d');
    this.canvas = canvas;
    this.pixelSize = pixelSize || 1;
    this.initImageData();
  };

  Screen.colors = [
    0xFF,
    0xAA,
    0x55,
    0x00
  ];
  Screen.physics = {
    WIDTH    : 160,
    HEIGHT   : 144,
    FREQUENCY: 60
  };

  Screen.prototype.setPixelSize = function(pixelSize) {
    this.pixelSize = pixelSize;
    this.initImageData();
  };

  Screen.prototype.initImageData = function() {
    this.canvas.width = Screen.physics.WIDTH * this.pixelSize;
    this.canvas.height = Screen.physics.HEIGHT * this.pixelSize;
    this.imageData = this.context.createImageData(this.canvas.width, this.canvas.height);
  };

  Screen.prototype.clearScreen = function() {
    this.context.fillStyle = '#FFF';
    this.context.fillRect(0, 0, Screen.physics.WIDTH * this.pixelSize, Screen.physics.HEIGHT * this.pixelSize);
  };

  // Drawing vars
  let count = 0;
  const drawQueue = [];
  let executingDraw = false;

  Screen.prototype.fillImageData = function(buffer) {
    count++;
    const gridColors = [];
    for (var y = 0; y < Screen.physics.HEIGHT; y++) {
      for (var py = 0; py < this.pixelSize; py++) {
        var _y = y * this.pixelSize + py;
        let rowColors = [];
        for (var x = 0; x < Screen.physics.WIDTH; x++) {
          for (var px = 0; px < this.pixelSize; px++) {
            var offset = _y * this.canvas.width + (x * this.pixelSize + px);
            var v = Screen.colors[buffer[y * Screen.physics.WIDTH + x]];
            this.imageData.data[offset * 4] = v;
            this.imageData.data[offset * 4 + 1] = v;
            this.imageData.data[offset * 4 + 2] = v;
            this.imageData.data[offset * 4 + 3] = 255;
            rowColors.push(rgb2hex(`rgba(${v}, ${v}, ${v}, 255)`));
          }
        }
        gridColors.push(rowColors);
      }
    }

    drawQueue.push(gridColors);

    if (drawQueue.length > 0) {
      if (!executingDraw) {
        executingDraw = true;
        google.script.run.withFailureHandler(() => {
          console.log("Draw error");
          executingDraw = false;
        }).withSuccessHandler(() => {
          executingDraw = false;
        }).drawGrid(gridColors);
      }
    }
  };

  function rgb2hex(rgb){
    rgb = rgb.match(/^rgba?[\s+]?\([\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?/i);
    return (rgb && rgb.length === 4) ? "#" +
      ("0" + parseInt(rgb[1],10).toString(16)).slice(-2) +
      ("0" + parseInt(rgb[2],10).toString(16)).slice(-2) +
      ("0" + parseInt(rgb[3],10).toString(16)).slice(-2) : '';
  }

  Screen.prototype.render = function(buffer) {
    this.fillImageData(buffer);
    this.context.putImageData(this.imageData, 0, 0);
  };

  GameboyJS.Screen = Screen;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
  "use strict";

// This exception should be thrown whenever a critical feature that
// has not been implemented is requested
  function UnimplementedException(message, fatal) {
    this.message = message;
    this.name = UnimplementedException;
    if (fatal === undefined) {
      fatal = true;
    }
    this.fatal = fatal;
  }
  GameboyJS.UnimplementedException = UnimplementedException;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
  "use strict";

// Object for mapping the cartridge RAM
  var ExtRam = function() {
    this.extRam = null;
    this.ramSize = 0;
    this.ramBank = 0;
  };

  ExtRam.prototype.loadRam = function(game, size) {
    this.gameName = game;

    this.ramSize = size;
    this.ramBanksize = this.ramSize >= 0x2000 ? 8192 : 2048;

    var key = this.getStorageKey();
    var data = localStorage.getItem(key);
    if (data == null) {
      this.extRam = Array.apply(null, new Array(this.ramSize)).map(function(){return 0;});
    } else {
      this.extRam = JSON.parse(data);
      if (this.extRam.length != size) {
        console.error('Found RAM data but not matching expected size.');
      }
    }
  };

  ExtRam.prototype.setRamBank = function(bank) {
    this.ramBank = bank;
  };

  ExtRam.prototype.manageWrite = function(offset, value) {
    this.extRam[this.ramBank * 8192 + offset] = value;
  };

  ExtRam.prototype.manageRead = function(offset) {
    return this.extRam[this.ramBank * 8192 + offset];
  };

  ExtRam.prototype.getStorageKey = function() {
    return this.gameName + '_EXTRAM';;
  };
// Actually save the RAM in the physical storage (localStorage)
  ExtRam.prototype.saveRamData = function() {
    localStorage.setItem(this.getStorageKey(), JSON.stringify(this.extRam));
  };
  GameboyJS.ExtRam = ExtRam;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
  "use strict";

// This is the default buttons mapping for the Gamepad
// It's optimized for the XBOX pad
//
// Any other mapping can be provided as a constructor argument of the Gamepad object
// An alternative mapping should be an object with keys being the indexes
// of the gamepad buttons and values the normalized gameboy button names
  var xboxMapping = {
    0: 'UP',
    1: 'DOWN',
    2: 'LEFT',
    3: 'RIGHT',
    4: 'START',
    5: 'SELECT',
    11: 'A',
    12: 'B'
  };

// Gamepad listener
// Communication layer between the Gamepad API and the Input class
// Any physical controller can be used but the mapping should be provided
// in order to get an optimal layout of the buttons (see above)
  var Gamepad = function(mapping) {
    this.gamepad = null;
    this.state = {A:0,B:0,START:0,SELECT:0,LEFT:0,RIGHT:0,UP:0,DOWN:0};
    this.pullInterval = null;
    this.buttonMapping = mapping || xboxMapping;
  };

// Initialize the keyboard listeners and set up the callbacks
// for button press / release
  Gamepad.prototype.init = function(onPress, onRelease) {
    this.onPress = onPress;
    this.onRelease = onRelease;

    var self = this;
    window.addEventListener('gamepadconnected', function(e) {
      self.gamepad = e.gamepad;
      self.activatePull();
    });
    window.addEventListener('gamepaddisconnected', function(e) {
      self.gamepad = null;
      self.deactivatePull();
    });
  };

  Gamepad.prototype.activatePull = function() {
    this.deactivatePull();
    this.pullInterval = setInterval(this.pullState.bind(this), 100);
  };

  Gamepad.prototype.deactivatePull = function() {
    clearInterval(this.pullInterval);
  };

// Check the state of the current gamepad in order to detect any press/release action
  Gamepad.prototype.pullState = function() {
    for (var index in this.buttonMapping) {
      var button = this.buttonMapping[index];
      var oldState = this.state[button];
      this.state[button] = this.gamepad.buttons[index].pressed;

      if (this.state[button] == 1 && oldState == 0) {
        this.managePress(button);
      } else if (this.state[button] == 0 && oldState == 1) {
        this.manageRelease(button);
      }
    }
  };

  Gamepad.prototype.managePress = function(key) {
    this.onPress(key);
  };

  Gamepad.prototype.manageRelease = function(key) {
    this.onRelease(key);
  };

  GameboyJS.Gamepad = Gamepad;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
  "use strict";

// The Input management system
//
// The pressKey() and releaseKey() functions should be called by a device class
// like GameboyJS.Keyboard after a physical button trigger event
//
// They rely on the name of the original buttons as parameters (see Input.keys)
  var Input = function(cpu, pad) {
    this.cpu = cpu;
    this.memory = cpu.memory;
    this.P1 = 0xFF00;
    this.state = 0;

    pad.init(this.pressKey.bind(this), this.releaseKey.bind(this));
  };

  Input.keys = {
    START:  0x80,
    SELECT: 0x40,
    B:      0x20,
    A:      0x10,
    DOWN:   0x08,
    UP:     0x04,
    LEFT:   0x02,
    RIGHT:  0x01
  };

  Input.prototype.pressKey = function(key) {
    this.state |= Input.keys[key];

    this.cpu.requestInterrupt(GameboyJS.CPU.INTERRUPTS.HILO);
  };

  Input.prototype.releaseKey = function(key) {
    var mask = 0xFF - Input.keys[key];
    this.state &= mask;
  };

  Input.prototype.update = function() {
    var value = this.memory.rb(this.P1);
    value = ((~value) & 0x30); // invert the value so 1 means 'active'
    if (value & 0x10) { // direction keys listened
      value |= (this.state & 0x0F);
    } else if (value & 0x20) { // action keys listened
      value |= ((this.state & 0xF0) >> 4);
    } else if ((value & 0x30) == 0) { // no keys listened
      value &= 0xF0;
    }

    value = ((~value) & 0x3F); // invert back
    this.memory[this.P1] = value;
  };
  GameboyJS.Input = Input;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
  "use strict";

// Keyboard listener
// Does the mapping between the keyboard and the Input class
  var Keyboard = function() {};

// Initialize the keyboard listeners and set up the callbacks
// for button press / release
  Keyboard.prototype.init = function(onPress, onRelease) {
    this.onPress = onPress;
    this.onRelease = onRelease;

    var self = this;
    document.addEventListener('keydown', function(e) {
      self.managePress(e.keyCode);
    });
    document.addEventListener('keyup', function(e) {
      self.manageRelease(e.keyCode);
    });
  }

  Keyboard.prototype.managePress = function(keycode) {
    var key = this.translateKey(keycode);
    if (key) {
      this.onPress(key);
    }
  };

  Keyboard.prototype.manageRelease = function(keycode) {
    var key = this.translateKey(keycode);
    if (key) {
      this.onRelease(key);
    }
  };

// Transform a keyboard keycode into a key of the Input.keys object
  Keyboard.prototype.translateKey = function(keycode) {
    var key = null;
    switch (keycode) {
      case 88: // X
        key = 'A';
        break;
      case 89: // Z
        key = 'B';
        break;
      case 13: // Enter / Return
        key = 'START';
        break;
      case 32: // Space
        key = 'SELECT';
        break;
      case 37: // left
        key = 'LEFT';
        break;
      case 38: // up
        key = 'UP';
        break;
      case 39: // right
        key = 'RIGHT';
        break;
      case 40: // down
        key = 'DOWN';
        break;
    }

    return key;
  };
  GameboyJS.Keyboard = Keyboard;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
  "use strict";

// List of CPU operations
// Most operations have been factorized here to limit code redundancy
//
// How to read operations:
// Uppercase letters qualify the kind of operation (LD = LOAD, INC = INCREMENT, etc.)
// Lowercase letters are used to hint parameters :
// r = register, n = 1 memory byte, sp = sp register,
// a = suffix for memory address, i = bit index
// Example : LDrrar = LOAD operation with two-registers memory address
// as first parameter and one register value as second
//
// Underscore-prefixed functions are here to delegate the logic between similar operations,
// they should not be called from outside
//
// It's up to each operation to update the CPU clock
  var ops = {
    LDrrnn: function(p, r1, r2) {p.wr(r2, p.memory.rb(p.r.pc));p.wr(r1, p.memory.rb(p.r.pc+1)); p.r.pc+=2;p.clock.c += 12;},
    LDrrar: function(p, r1, r2, r3) {ops._LDav(p, GameboyJS.Util.getRegAddr(p, r1, r2), p.r[r3]);p.clock.c += 8;},
    LDrrra: function(p, r1, r2, r3) {p.wr(r1, p.memory.rb(GameboyJS.Util.getRegAddr(p, r2, r3)));p.clock.c += 8;},
    LDrn:   function(p, r1) {p.wr(r1, p.memory.rb(p.r.pc++));p.clock.c += 8;},
    LDrr:   function(p, r1, r2) {p.wr(r1, p.r[r2]);p.clock.c += 4;},
    LDrar:  function(p, r1, r2) {p.memory.wb(p.r[r1]+0xFF00, p.r[r2]);p.clock.c += 8;},
    LDrra:  function(p, r1, r2) {p.wr(r1, p.memory.rb(p.r[r2]+0xFF00));p.clock.c += 8;},
    LDspnn: function(p) {p.wr('sp', (p.memory.rb(p.r.pc + 1) << 8) + p.memory.rb(p.r.pc));p.r.pc+=2;p.clock.c += 12;},
    LDsprr: function(p, r1, r2) {p.wr('sp', GameboyJS.Util.getRegAddr(p, r1, r2));p.clock.c += 8;},
    LDnnar: function(p, r1) {var addr=(p.memory.rb(p.r.pc + 1) << 8) + p.memory.rb(p.r.pc);p.memory.wb(addr,p.r[r1]);p.r.pc+=2; p.clock.c += 16;},
    LDrnna: function(p, r1) {var addr=(p.memory.rb(p.r.pc + 1) << 8) + p.memory.rb(p.r.pc);p.wr(r1, p.memory.rb(addr));p.r.pc+=2; p.clock.c += 16;},
    LDrrspn:function(p, r1, r2) {var rel = p.memory.rb(p.r.pc++);rel=GameboyJS.Util.getSignedValue(rel);var val=p.r.sp + rel;
      var c = (p.r.sp&0xFF) + (rel&0xFF) > 0xFF;var h = (p.r.sp & 0xF) + (rel & 0xF) > 0xF;val &= 0xFFFF;
      var f = 0; if(h)f|=0x20;if(c)f|=0x10;p.wr('F', f);
      p.wr(r1, val >> 8);p.wr(r2, val&0xFF);
      p.clock.c+=12;},
    LDnnsp: function(p) {var addr = p.memory.rb(p.r.pc++) + (p.memory.rb(p.r.pc++)<<8); ops._LDav(p, addr, p.r.sp & 0xFF);ops._LDav(p, addr+1, p.r.sp >> 8);p.clock.c+=20;},
    LDrran: function(p, r1, r2){var addr = GameboyJS.Util.getRegAddr(p, r1, r2);ops._LDav(p, addr, p.memory.rb(p.r.pc++));p.clock.c+=12;},
    _LDav:  function(p, addr, val){p.memory.wb(addr, val);},
    LDHnar: function(p, r1){p.memory.wb(0xFF00 + p.memory.rb(p.r.pc++), p.r[r1]);p.clock.c+=12;},
    LDHrna: function(p, r1){p.wr(r1, p.memory.rb(0xFF00 + p.memory.rb(p.r.pc++)));p.clock.c+=12;},
    INCrr:  function(p, r1, r2) {p.wr(r2, (p.r[r2]+1)&0xFF); if (p.r[r2] == 0) p.wr(r1, (p.r[r1]+1)&0xFF);p.clock.c += 8;},
    INCrra: function(p, r1, r2) {var addr = GameboyJS.Util.getRegAddr(p, r1, r2);var val = (p.memory.rb(addr)+1)&0xFF;var z = val==0;var h=(p.memory.rb(addr)&0xF)+1 > 0xF;
      p.memory.wb(addr, val);
      p.r.F&=0x10;if(h)p.r.F|=0x20;if(z)p.r.F|=0x80;
      p.clock.c+=12;},
    INCsp:  function(p){p.wr('sp', p.r.sp+1); p.r.sp &= 0xFFFF; p.clock.c+=8;},
    INCr:   function(p, r1) {var h = ((p.r[r1]&0xF) + 1)&0x10;p.wr(r1, (p.r[r1] + 1)&0xFF);var z = p.r[r1]==0;
      p.r.F&=0x10;if(h)p.r.F|=0x20;if(z)p.r.F|=0x80;
      p.clock.c += 4;},
    DECrr:  function(p, r1, r2) {p.wr(r2, (p.r[r2] - 1) & 0xFF); if (p.r[r2] == 0xFF) p.wr(r1, (p.r[r1] - 1)&0xFF);p.clock.c += 8;},
    DECsp:  function(p){p.wr('sp', p.r.sp-1); p.r.sp &= 0xFFFF; p.clock.c+=8;},
    DECr:   function(p, r1) {var h = (p.r[r1]&0xF) < 1;p.wr(r1, (p.r[r1] - 1) & 0xFF);var z = p.r[r1]==0;
      p.r.F&=0x10;p.r.F|=0x40;if(h)p.r.F|=0x20;if(z)p.r.F|=0x80;
      p.clock.c += 4;},
    DECrra: function(p, r1, r2){var addr = GameboyJS.Util.getRegAddr(p, r1, r2);var val = (p.memory.rb(addr)-1)&0xFF;var z = val==0;var h=(p.memory.rb(addr)&0xF) < 1;
      p.memory.wb(addr, val);
      p.r.F&=0x10;p.r.F|=0x40;if(h)p.r.F|=0x20;if(z)p.r.F|=0x80;
      p.clock.c+=12;},
    ADDrr:  function(p, r1, r2) {var n = p.r[r2];ops._ADDrn(p, r1, n); p.clock.c += 4;},
    ADDrn:  function(p, r1) {var n = p.memory.rb(p.r.pc++);ops._ADDrn(p, r1, n); p.clock.c+=8;},
    _ADDrn: function(p, r1, n) {var h=((p.r[r1]&0xF)+(n&0xF))&0x10;p.wr(r1, p.r[r1]+n);var c=p.r[r1]&0x100;p.r[r1]&=0xFF;
      var f = 0;if (p.r[r1]==0)f|=0x80;if (h)f|=0x20;if (c)f|=0x10;p.wr('F', f);},
    ADDrrrr:function(p, r1, r2, r3, r4) {ops._ADDrrn(p, r1, r2, (p.r[r3]<<8) + p.r[r4]); p.clock.c+=8;},
    ADDrrsp:function(p, r1, r2) {ops._ADDrrn(p, r1, r2, p.r.sp); p.clock.c += 8;},
    ADDspn: function(p) {var v = p.memory.rb(p.r.pc++);v = GameboyJS.Util.getSignedValue(v);
      var c = ((p.r.sp&0xFF) + (v&0xFF)) > 0xFF; var h = (p.r.sp & 0xF) + (v&0xF) > 0xF;
      var f = 0; if(h)f|=0x20;if(c)f|=0x10;p.wr('F', f);
      p.wr('sp', (p.r.sp + v) & 0xFFFF);
      p.clock.c+=16;},
    _ADDrrn:function(p, r1, r2, n) {var v1 = (p.r[r1]<<8) + p.r[r2];var v2 = n;
      var res = v1 + v2;var c = res&0x10000;var h = ((v1&0xFFF) + (v2&0xFFF))&0x1000;var z = p.r.F&0x80;
      res&=0xFFFF;p.r[r2]=res&0xFF;res=res>>8;p.r[r1]=res&0xFF;
      var f=0;if(z)f|=0x80;if(h)f|=0x20;if(c)f|=0x10;p.r.F=f;},
    ADCrr:  function(p, r1, r2) {var n = p.r[r2]; ops._ADCrn(p, r1, n); p.clock.c += 4;},
    ADCrn:  function(p, r1) {var n = p.memory.rb(p.r.pc++); ops._ADCrn(p, r1, n); p.clock.c += 8;},
    _ADCrn: function(p, r1, n) {
      var c = p.r.F&0x10?1:0;var h=((p.r[r1]&0xF)+(n&0xF)+c)&0x10;
      p.wr(r1, p.r[r1]+n+c);c=p.r[r1]&0x100;p.r[r1]&=0xFF;
      var f = 0;if (p.r[r1]==0)f|=0x80;if (h)f|=0x20;if (c)f|=0x10;p.r.F=f;},
    ADCrrra:function(p, r1, r2, r3) {var n = p.memory.rb(GameboyJS.Util.getRegAddr(p, r2, r3)); ops._ADCrn(p, r1, n); p.clock.c += 8;},
    ADDrrra:function(p, r1, r2, r3) {var v = p.memory.rb(GameboyJS.Util.getRegAddr(p, r2, r3));var h=((p.r[r1]&0xF)+(v&0xF))&0x10;p.wr(r1, p.r[r1]+v);var c=p.r[r1]&0x100;p.r[r1]&=0xFF;
      var f = 0;if (p.r[r1]==0)f|=0x80;if (h)f|=0x20;if (c)f|=0x10;p.wr('F', f);
      p.clock.c += 8;},
    SUBr:   function(p, r1) {var n = p.r[r1];ops._SUBn(p, n);p.clock.c += 4;},
    SUBn:   function(p) {var n = p.memory.rb(p.r.pc++);ops._SUBn(p, n);p.clock.c += 8;},
    SUBrra: function(p, r1, r2) {var n = p.memory.rb(GameboyJS.Util.getRegAddr(p, r1, r2));ops._SUBn(p, n);p.clock.c+=8;},
    _SUBn:  function(p, n) {var c = p.r.A < n;var h = (p.r.A&0xF) < (n&0xF);
      p.wr('A', p.r.A - n);p.r.A&=0xFF; var z = p.r.A==0;
      var f = 0x40;if (z)f|=0x80;if (h)f|=0x20;if (c)f|=0x10;p.wr('F', f);},
    SBCn:   function(p) {var n = p.memory.rb(p.r.pc++); ops._SBCn(p, n); p.clock.c += 8;},
    SBCr:   function(p, r1) {var n = p.r[r1]; ops._SBCn(p, n); p.clock.c += 4;},
    SBCrra: function(p, r1, r2) {var v = p.memory.rb((p.r[r1] << 8) + p.r[r2]); ops._SBCn(p, v); p.clock.c += 8;},
    _SBCn:  function(p, n) {var carry = p.r.F&0x10 ? 1 : 0;
      var c = p.r.A < n + carry;var h = (p.r.A&0xF) < (n&0xF) + carry;
      p.wr('A', p.r.A - n - carry); p.r.A&=0xFF; var z = p.r.A == 0;
      var f = 0x40;if (z)f|=0x80;if (h)f|=0x20;if (c)f|=0x10;p.r.F=f;},
    ORr:    function(p, r1) {p.r.A|=p.r[r1];p.r.F=(p.r.A==0)?0x80:0x00;p.clock.c += 4;},
    ORn:    function(p) {p.r.A|=p.memory.rb(p.r.pc++);p.r.F=(p.r.A==0)?0x80:0x00;p.clock.c += 8;},
    ORrra:  function(p, r1, r2) {p.r.A|=p.memory.rb((p.r[r1] << 8)+ p.r[r2]);p.r.F=(p.r.A==0)?0x80:0x00;p.clock.c += 8;},
    ANDr:   function(p, r1) {p.r.A&=p.r[r1];p.r.F=(p.r.A==0)?0xA0:0x20;p.clock.c += 4;},
    ANDn:   function(p) {p.r.A&=p.memory.rb(p.r.pc++);p.r.F=(p.r.A==0)?0xA0:0x20;p.clock.c += 8;},
    ANDrra: function(p, r1, r2) {p.r.A&=p.memory.rb(GameboyJS.Util.getRegAddr(p, r1, r2));p.r.F=(p.r.A==0)?0xA0:0x20;p.clock.c += 8;},
    XORr:   function(p, r1) {p.r.A^=p.r[r1];p.r.F=(p.r.A==0)?0x80:0x00;p.clock.c += 4;},
    XORn:   function(p) {p.r.A^=p.memory.rb(p.r.pc++);p.r.F=(p.r.A==0)?0x80:0x00;p.clock.c += 8;},
    XORrra: function(p, r1, r2) {p.r.A^=p.memory.rb((p.r[r1] << 8)+ p.r[r2]);p.r.F=(p.r.A==0)?0x80:0x00;p.clock.c += 8;},
    CPr:    function(p, r1) {var n = p.r[r1];ops._CPn(p, n); p.clock.c += 4;},
    CPn:    function(p) {var n =p.memory.rb(p.r.pc++);ops._CPn(p, n);p.clock.c+=8;},
    CPrra:  function(p, r1, r2) {var n = p.memory.rb(GameboyJS.Util.getRegAddr(p, r1, r2));ops._CPn(p, n);p.clock.c+=8;},
    _CPn:   function(p, n) {
      var c = p.r.A < n;var z = p.r.A == n;var h = (p.r.A&0xF) < (n&0xF);
      var f = 0x40;if(z)f+=0x80;if (h)f+=0x20;if (c)f+=0x10;p.r.F=f;},
    RRCr:   function(p, r1) {p.r.F=0;var out=p.r[r1] & 0x01;if(out)p.r.F|=0x10;p.r[r1]=(p.r[r1]>>1)|(out*0x80);if(p.r[r1]==0)p.r.F|=0x80;p.clock.c+=4;},
    RRCrra: function(p, r1, r2) {var addr = GameboyJS.Util.getRegAddr(p, r1, r2);p.r.F=0;var out=p.memory.rb(addr)&0x01;if(out)p.r.F|=0x10;p.memory.wb(addr, (p.memory.rb(addr)>>1)|(out*0x80));if(p.memory.rb(addr)==0)p.r.F|=0x80;p.clock.c+=12;},
    RLCr:   function(p, r1) {p.r.F=0;var out=p.r[r1]&0x80?1:0;if(out)p.r.F|=0x10;p.r[r1]=((p.r[r1]<<1)+out)&0xFF;if(p.r[r1]==0)p.r.F|=0x80;p.clock.c+=4;},
    RLCrra: function(p, r1, r2) {var addr = GameboyJS.Util.getRegAddr(p, r1, r2);p.r.F=0;var out=p.memory.rb(addr)&0x80?1:0;if(out)p.r.F|=0x10;p.memory.wb(addr, ((p.memory.rb(addr)<<1)+out)&0xFF);if(p.memory.rb(addr)==0)p.r.F|=0x80;p.clock.c+=12;},
    RLr:    function(p, r1) {var c=(p.r.F&0x10)?1:0;p.r.F=0;var out=p.r[r1]&0x80;out?p.r.F|=0x10:p.r.F&=0xEF;p.r[r1]=((p.r[r1]<<1)+c)&0xFF;if(p.r[r1]==0)p.r.F|=0x80;p.clock.c+=4;},
    RLrra:  function(p, r1, r2) {var addr = GameboyJS.Util.getRegAddr(p, r1, r2);var c=(p.r.F&0x10)?1:0;p.r.F=0;var out=p.memory.rb(addr)&0x80;out?p.r.F|=0x10:p.r.F&=0xEF;p.memory.wb(addr,((p.memory.rb(addr)<<1)+c)&0xFF);if(p.memory.rb(addr)==0)p.r.F|=0x80;p.clock.c+=12;},
    RRr:    function(p, r1) {var c=(p.r.F&0x10)?1:0;p.r.F=0;var out=p.r[r1]&0x01;out?p.r.F|=0x10:p.r.F&=0xEF;p.r[r1]=(p.r[r1]>>1)|(c*0x80);if(p.r[r1]==0)p.r.F|=0x80;p.clock.c+=4;},
    RRrra:  function(p, r1, r2) {var addr = GameboyJS.Util.getRegAddr(p, r1, r2);var c=(p.r.F&0x10)?1:0;p.r.F=0;var out=p.memory.rb(addr)&0x01;out?p.r.F|=0x10:p.r.F&=0xEF;p.memory.wb(addr,(p.memory.rb(addr)>>1)|(c*0x80));if(p.memory.rb(addr)==0)p.r.F|=0x80;p.clock.c+=12;},
    SRAr:   function(p, r1) {p.r.F = 0;if (p.r[r1]&0x01)p.r.F|=0x10;var msb=p.r[r1]&0x80;p.r[r1]=(p.r[r1]>>1)|msb;if (p.r[r1]==0)p.r.F|=0x80;p.clock.c+=4;},
    SRArra: function(p, r1, r2) {var addr = GameboyJS.Util.getRegAddr(p, r1, r2);p.r.F = 0;if (p.memory.rb(addr)&0x01)p.r.F|=0x10;var msb=p.memory.rb(addr)&0x80;p.memory.wb(addr, (p.memory.rb(addr)>>1)|msb);if (p.memory.rb(addr)==0)p.r.F|=0x80;p.clock.c+=12;},
    SLAr:   function(p, r1) {p.r.F = 0;if (p.r[r1]&0x80)p.r.F|=0x10;p.r[r1]=(p.r[r1]<<1)&0xFF;if (p.r[r1]==0)p.r.F|=0x80;p.clock.c+=4;},
    SLArra: function(p, r1, r2) {var addr = GameboyJS.Util.getRegAddr(p, r1, r2);p.r.F = 0;if (p.memory.rb(addr)&0x80)p.r.F|=0x10;p.memory.wb(addr, (p.memory.rb(addr)<<1)&0xFF);if (p.memory.rb(addr)==0)p.r.F|=0x80;p.clock.c+=12;},
    SRLr:   function(p, r1) {p.r.F = 0;if (p.r[r1]&0x01)p.r.F|=0x10;p.r[r1]=p.r[r1]>>1;if (p.r[r1]==0)p.r.F|=0x80;p.clock.c+=4;},
    SRLrra: function(p, r1, r2) {var addr = GameboyJS.Util.getRegAddr(p, r1, r2);p.r.F = 0;if (p.memory.rb(addr)&0x01)p.r.F|=0x10;p.memory.wb(addr, p.memory.rb(addr)>>1);if (p.memory.rb(addr)==0)p.r.F|=0x80;p.clock.c+=12;},
    BITir:  function(p, i, r1) {var mask=1<<i;var z=(p.r[r1]&mask)?0:1;var f=p.r.F&0x10;f |= 0x20;if(z)f|=0x80;p.r.F=f;p.clock.c+=4;},
    BITirra:function(p, i, r1, r2) {var addr = GameboyJS.Util.getRegAddr(p, r1, r2);var mask=1<<i;var z=(p.memory.rb(addr)&mask)?0:1;var f=p.r.F&0x10;f |= 0x20;if(z)f|=0x80;p.r.F=f;p.clock.c+=8;},
    SETir:  function(p, i, r1) {var mask=1<<i;p.r[r1]|=mask;p.clock.c += 4;},
    SETirra:function(p, i, r1, r2) {var addr = GameboyJS.Util.getRegAddr(p, r1, r2);var mask=1<<i;p.memory.wb(addr, p.memory.rb(addr)|mask);p.clock.c += 12;},
    RESir:  function(p, i, r1) {var mask=0xFF - (1<<i);p.r[r1]&=mask;p.clock.c += 4;},
    RESirra:function(p, i, r1, r2) {var addr = GameboyJS.Util.getRegAddr(p, r1, r2);var mask=0xFF - (1<<i);p.memory.wb(addr, p.memory.rb(addr)&mask);p.clock.c += 12;},
    SWAPr:  function(p, r1) {p.r[r1] = ops._SWAPn(p, p.r[r1]);p.clock.c+=4;},
    SWAPrra:function(p, r1, r2){var addr = (p.r[r1] << 8)+ p.r[r2]; p.memory.wb(addr, ops._SWAPn(p, p.memory.rb(addr))); p.clock.c+=12;},
    _SWAPn: function(p, n){p.r.F = n==0?0x80:0;return ((n&0xF0) >> 4) | ((n&0x0F) << 4);},
    JPnn:   function(p) {p.wr('pc', (p.memory.rb(p.r.pc+1) << 8) + p.memory.rb(p.r.pc));p.clock.c += 16;},
    JRccn:  function(p, cc) {if (GameboyJS.Util.testFlag(p, cc)){var v=p.memory.rb(p.r.pc++);v=GameboyJS.Util.getSignedValue(v);p.r.pc += v;p.clock.c+=4;}else{p.r.pc++;}p.clock.c += 8;},
    JPccnn: function(p, cc) {if (GameboyJS.Util.testFlag(p, cc)){p.wr('pc', (p.memory.rb(p.r.pc+1) << 8) + p.memory.rb(p.r.pc));p.clock.c+=4;}else{p.r.pc+=2;}p.clock.c += 12;},
    JPrr:   function(p, r1, r2) {p.r.pc = (p.r[r1] << 8) + p.r[r2];p.clock.c += 4;},
    JRn:    function(p) {var v=p.memory.rb(p.r.pc++);v=GameboyJS.Util.getSignedValue(v);p.r.pc += v;p.clock.c += 12;},
    PUSHrr: function(p, r1, r2) {p.wr('sp', p.r.sp-1);p.memory.wb(p.r.sp, p.r[r1]);p.wr('sp', p.r.sp-1);p.memory.wb(p.r.sp, p.r[r2]);p.clock.c+=16;},
    POPrr:  function(p, r1, r2) {p.wr(r2, p.memory.rb(p.r.sp));p.wr('sp', p.r.sp+1);p.wr(r1, p.memory.rb(p.r.sp));p.wr('sp', p.r.sp+1);p.clock.c+=12;},
    RSTn:   function(p, n) {p.wr('sp', p.r.sp-1);p.memory.wb(p.r.sp,p.r.pc>>8);p.wr('sp', p.r.sp-1);p.memory.wb(p.r.sp,p.r.pc&0xFF);p.r.pc=n;p.clock.c+=16;},
    RET:    function(p) {p.r.pc = p.memory.rb(p.r.sp);p.wr('sp', p.r.sp+1);p.r.pc+=p.memory.rb(p.r.sp)<<8;p.wr('sp', p.r.sp+1);p.clock.c += 16;},
    RETcc:  function(p, cc) {if (GameboyJS.Util.testFlag(p, cc)){p.r.pc = p.memory.rb(p.r.sp);p.wr('sp', p.r.sp+1);p.r.pc+=p.memory.rb(p.r.sp)<<8;p.wr('sp', p.r.sp+1);p.clock.c+=12;}p.clock.c+=8;},
    CALLnn: function(p) {ops._CALLnn(p); p.clock.c+=24;},
    CALLccnn:function(p, cc) {if (GameboyJS.Util.testFlag(p, cc)){ops._CALLnn(p);p.clock.c+=12;}else{p.r.pc+=2;}p.clock.c+=12; },
    _CALLnn:function(p){p.wr('sp', p.r.sp - 1); p.memory.wb(p.r.sp, ((p.r.pc+2)&0xFF00)>>8);
      p.wr('sp', p.r.sp - 1); p.memory.wb(p.r.sp, (p.r.pc+2)&0x00FF);
      var j=p.memory.rb(p.r.pc)+(p.memory.rb(p.r.pc+1)<<8);p.r.pc=j;},
    CPL:    function(p) {p.wr('A', (~p.r.A)&0xFF);p.r.F|=0x60,p.clock.c += 4;},
    CCF:    function(p) {p.r.F&=0x9F;p.r.F&0x10?p.r.F&=0xE0:p.r.F|=0x10;p.clock.c += 4;},
    SCF:    function(p) {p.r.F&=0x9F;p.r.F|=0x10;p.clock.c+=4;},
    DAA:    function(p) {
      var sub = (p.r.F&0x40) ? 1 : 0; var h = (p.r.F&0x20)?1:0;var c = (p.r.F&0x10)?1:0;
      if (sub) {
        if (h) {
          p.r.A = (p.r.A - 0x6) & 0xFF;
        }
        if (c) {
          p.r.A -= 0x60;
        }
      } else {
        if ((p.r.A&0xF) > 9 || h) {
          p.r.A += 0x6;
        }
        if (p.r.A > 0x9F || c) {
          p.r.A += 0x60;
        }
      }
      if (p.r.A&0x100) c = 1;

      p.r.A &= 0xFF;
      p.r.F &= 0x40;if (p.r.A == 0) p.r.F|=0x80;if (c) p.r.F|=0x10;
      p.clock.c += 4;
    },
    HALT:   function(p) {p.halt(); p.clock.c+=4;},
    DI:     function(p) {p.disableInterrupts();p.clock.c += 4;},
    EI:     function(p) {p.enableInterrupts();p.clock.c += 4;},
    RETI:   function(p) {p.enableInterrupts();ops.RET(p);},
    CB:     function(p) {var opcode = p.memory.rb(p.r.pc++);
      GameboyJS.opcodeCbmap[opcode](p);
      p.clock.c+=4;}
  };
  GameboyJS.cpuOps = ops;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
  "use strict";

  var defaultOptions = {
    pad: {class: GameboyJS.Keyboard, mapping: null},
    zoom: 1,
    romReaders: [],
    statusContainerId: 'status',
    gameNameContainerId: 'game-name',
    errorContainerId: 'error'
  };

// Gameboy class
//
// This object is the entry point of the application
// Will delegate user actions to the emulated devices
// and provide information where needed
  var Gameboy = function(canvas, options) {
    options = options || {};
    this.options = GameboyJS.Util.extend({}, defaultOptions, options);

    var cpu = new GameboyJS.CPU(this);
    var screen = new GameboyJS.Screen(canvas, this.options.zoom);
    var gpu = new GameboyJS.GPU(screen, cpu);
    cpu.gpu = gpu;

    var pad = new this.options.pad.class(this.options.pad.mapping);
    var input = new GameboyJS.Input(cpu, pad);
    cpu.input = input;

    this.cpu = cpu;
    this.screen = screen;
    this.input = input;
    this.pad = pad;

    this.createRom(this.options.romReaders);

    this.statusContainer   = document.getElementById(this.options.statusContainerId) || document.createElement('div');
    this.gameNameContainer = document.getElementById(this.options.gameNameContainerId) || document.createElement('div');
    this.errorContainer    = document.getElementById(this.options.errorContainerId) || document.createElement('div');
  };

// Create the ROM object and bind one or more readers
  Gameboy.prototype.createRom = function (readers) {
    var rom = new GameboyJS.Rom(this);
    if (readers.length == 0) {
      // add the default rom reader
      var romReader = new GameboyJS.RomFileReader();
      rom.addReader(romReader);
    } else {
      for (var i in readers) {
        if (readers.hasOwnProperty(i)) {
          rom.addReader(readers[i]);
        }
      }
    }
  };

  Gameboy.prototype.startRom = function(rom) {
    this.errorContainer.classList.add('hide');
    this.cpu.reset();
    try {
      // TODO CHANGED HERE
      // this.cpu.loadRom(rom.data);
      this.cpu.loadRom(rom.data);
      this.setStatus('Game Running :');
      this.setGameName(this.cpu.getGameName());
      this.cpu.run();
    } catch (e) {
      this.handleException(e);
    }
  };

  Gameboy.prototype.pause = function(value) {
    if (value) {
      this.setStatus('Game Paused :');
      this.cpu.pause();
    } else {
      this.setStatus('Game Running :');
      this.cpu.unpause();
    }
  };

  Gameboy.prototype.error = function(message) {
    this.setStatus('Error during execution');
    this.setError('An error occurred during execution:' + message);
    this.cpu.stop();
  };

  Gameboy.prototype.setStatus = function(status) {
    this.statusContainer.innerHTML = status;
  };
// Display an error message
  Gameboy.prototype.setError = function(message) {
    this.errorContainer.classList.remove('hide');
    this.errorContainer.innerHTML = message;
  };
// Display the name of the game running
  Gameboy.prototype.setGameName = function(name) {
    this.gameNameContainer.innerHTML = name;
  };
  Gameboy.prototype.setSoundEnabled = function(value) {
    if (value) {
      this.cpu.apu.connect();
    } else {
      this.cpu.apu.disconnect();
    }
  };
  Gameboy.prototype.setScreenZoom = function(value) {
    this.screen.setPixelSize(value);
  };
  Gameboy.prototype.handleException = function(e) {
    if (e instanceof GameboyJS.UnimplementedException) {
      if (e.fatal) {
        this.error('This cartridge is not supported ('+ e.message +')');
      } else {
        console.error(e.message);
      }
    } else {
      throw e;
    }
  };
  GameboyJS.Gameboy = Gameboy;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
  "use strict";

// Memory bank controllers

  var MBC = {};

// Create an MBC instance depending on the type specified in the cartridge
  MBC.getMbcInstance = function(memory, type) {
    var instance;
    switch (type) {
      case 0x00:
        instance = new MBC0(memory);
        break;
      case 0x01: case 0x02: case 0x03:
        instance = new MBC1(memory);
        break;
      case 0x0F: case 0x10: case 0x11: case 0x12: case 0x13:
        instance = new MBC3(memory);
        break;
      case 0x19: case 0x1A: case 0x1B: case 0x1C: case 0x1D: case 0x1E:
        instance = new MBC5(memory);
        break;
      default:
        throw new GameboyJS.UnimplementedException('MBC type not supported');
    }

    return instance;
  };

  var MBC1 = function(memory) {
    this.memory = memory;
    this.romBankNumber = 1;
    this.mode = 0; // mode 0 = ROM, mode 1 = RAM
    this.ramEnabled = true;
    this.extRam = new GameboyJS.ExtRam();
  };

  MBC1.prototype.loadRam = function(game, size) {
    this.extRam.loadRam(game, size);
  };

  MBC1.prototype.manageWrite = function(addr, value) {
    switch (addr & 0xF000) {
      case 0x0000: case 0x1000: // enable RAM
        this.ramEnabled = (value & 0x0A) ? true : false;
        if (this.ramEnabled) {
          this.extRam.saveRamData();
        }
        break;
      case 0x2000: case 0x3000: // ROM bank number lower 5 bits
        value &= 0x1F;
        if (value == 0) value = 1;
        var mask = this.mode ? 0 : 0xE0;
        this.romBankNumber = (this.romBankNumber & mask) +value;
        this.memory.loadRomBank(this.romBankNumber);
        break;
      case 0x4000: case 0x5000: // RAM bank or high bits ROM
        value &= 0x03;
        if (this.mode == 0) { // ROM upper bits
          this.romBankNumber = (this.romBankNumber&0x1F) | (value << 5);
          this.memory.loadRomBank(this.romBankNumber);
        } else { // RAM bank
          this.extRam.setRamBank(value);
        }
        break;
      case 0x6000: case 0x7000: // ROM / RAM mode
        this.mode = value & 1;
        break;
      case 0xA000: case 0xB000:
        this.extRam.manageWrite(addr - 0xA000, value);
        break;
    }
  };
  MBC1.prototype.readRam = function(addr) {
    return this.extRam.manageRead(addr - 0xA000);
  };

  var MBC3 = function(memory) {
    this.memory = memory;
    this.romBankNumber = 1;
    this.ramEnabled = true;
    this.extRam = new GameboyJS.ExtRam();
  };

  MBC3.prototype.loadRam = function(game, size) {
    this.extRam.loadRam(game, size);
  };

  MBC3.prototype.manageWrite = function(addr, value) {
    switch (addr & 0xF000) {
      case 0x0000: case 0x1000: // enable RAM
        this.ramEnabled = (value & 0x0A) ? true : false;
        if (this.ramEnabled) {
          this.extRam.saveRamData();
        }
        break;
      case 0x2000: case 0x3000: // ROM bank number
        value &= 0x7F;
        if (value == 0) value = 1;
        this.romBankNumber = value;
        this.memory.loadRomBank(this.romBankNumber);
        break;
      case 0x4000: case 0x5000: // RAM bank
        this.extRam.setRamBank(value);
        break;
      case 0x6000: case 0x7000: // Latch clock data
        throw new GameboyJS.UnimplementedException('cartridge clock not supported', false);
        break;
      case 0xA000: case 0xB000:
        this.extRam.manageWrite(addr - 0xA000, value);
        break;
    }
  };
  MBC3.prototype.readRam = function(addr) {
    return this.extRam.manageRead(addr - 0xA000);
  };

// declare MBC5 for compatibility with most cartriges
// does not support rumble feature
  var MBC5 = MBC3;

// MBC0 exists for consistency and manages the no-MBC cartriges
  var MBC0 = function(memory) {this.memory = memory;};

  MBC0.prototype.manageWrite = function(addr, value) {
    this.memory.loadRomBank(value);
  };
  MBC0.prototype.readRam = function(addr) {return 0;};
  MBC0.prototype.loadRam = function() {};

  GameboyJS.MBC = MBC;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
  "use strict";

// Memory unit
  var Memory = function(cpu) {
    this.MEM_SIZE = 65536; // 64KB

    this.MBCtype = 0;
    this.banksize = 0x4000;
    this.rom = null;
    this.mbc = null;
    this.cpu = cpu;
  };

  Memory.addresses = {
    VRAM_START : 0x8000,
    VRAM_END   : 0x9FFF,

    EXTRAM_START : 0xA000,
    EXTRAM_END   : 0xBFFF,

    OAM_START : 0xFE00,
    OAM_END   : 0xFE9F,

    DEVICE_START: 0xFF00,
    DEVICE_END:   0xFF7F
  };

// Memory can be accessed as an Array
  Memory.prototype = new Array();

  Memory.prototype.reset = function() {
    this.length = this.MEM_SIZE;
    for (var i = Memory.addresses.VRAM_START; i <= Memory.addresses.VRAM_END; i++) {
      this[i] = 0;
    }
    for (var i = Memory.addresses.DEVICE_START; i <= Memory.addresses.DEVICE_END; i++) {
      this[i] = 0;
    }
    this[0xFFFF] = 0;
  };

  Memory.prototype.setRomData = function(data) {
    this.rom = data;
    this.loadRomBank(0);
    this.mbc = GameboyJS.MBC.getMbcInstance(this, this[0x147]);
    this.loadRomBank(1);
    this.mbc.loadRam(this.cpu.getGameName(), this.cpu.getRamSize());
  };

  Memory.prototype.loadRomBank = function(index) {
    var start = index ? 0x4000 : 0x0;
    var romStart = index * 0x4000;
    for (var i = 0; i < this.banksize; i++) {
      this[i + start] = this.rom[romStart + i];
    }
  };

// Video ram accessor
  Memory.prototype.vram = function(address) {
    if (address < Memory.addresses.VRAM_START || address > Memory.addresses.VRAM_END) {
      throw 'VRAM access in out of bounds address ' + address;
    }

    return this[address];
  };

// OAM ram accessor
  Memory.prototype.oamram = function(address) {
    if (address < Memory.addresses.OAM_START || address > Memory.addresses.OAM_END) {
      throw 'OAMRAM access in out of bounds address ' + address;
    }

    return this[address];
  };

// Device ram accessor
  Memory.prototype.deviceram = function(address, value) {
    if (address < Memory.addresses.DEVICERAM_START || address > Memory.addresses.DEVICERAM_END) {
      throw 'Device RAM access in out of bounds address ' + address;
    }
    if (typeof value === "undefined") {
      return this[address];
    } else {
      this[address] = value;
    }

  };

// Memory read proxy function
// Used to centralize memory read access
  Memory.prototype.rb = function (addr) {
    if (addr >= 0xFF10 && addr < 0xFF40) {
      var mask = apuMask[addr - 0xFF10];
      return this[addr] | mask;
    }
    if ((addr >= 0xA000 && addr < 0xC000)) {
      return this.mbc.readRam(addr);
    }
    return this[addr];
  };

// Bitmasks for audio addresses reads
  var apuMask = [
    0x80,0x3F,0x00,0xFF,0xBF, // NR10-NR15
    0xFF,0x3F,0x00,0xFF,0xBF, // NR20-NR25
    0x7F,0xFF,0x9F,0xFF,0xBF, // NR30-NR35
    0xFF,0xFF,0x00,0x00,0xBF, // NR40-NR45
    0x00,0x00,0x70,           // NR50-NR52
    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // Wave RAM
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
  ];

// Memory write proxy function
// Used to centralize memory writes and delegate specific behaviour
// to the correct units
  Memory.prototype.wb = function(addr, value) {
    if (addr < 0x8000 || (addr >= 0xA000 && addr < 0xC000)) { // MBC
      this.mbc.manageWrite(addr, value);
    } else if (addr >= 0xFF10 && addr <= 0xFF3F) { // sound registers
      this.cpu.apu.manageWrite(addr, value);
    } else if (addr == 0xFF00) { // input register
      this[addr] = ((this[addr] & 0x0F) | (value & 0x30));
    } else {
      this[addr] = value;
      if ((addr & 0xFF00) == 0xFF00) {
        if (addr == 0xFF02) {
          if (value & 0x80) {
            this.cpu.enableSerialTransfer();
          }
        }
        if (addr == 0xFF04) {
          this.cpu.resetDivTimer();
        }
        if (addr == 0xFF46) { // OAM DMA transfer
          this.dmaTransfer(value);
        }
      }
    }
  }

// Start a DMA transfer (OAM data from cartrige to RAM)
  Memory.prototype.dmaTransfer = function(startAddressPrefix) {
    var startAddress = (startAddressPrefix << 8);
    for (var i = 0; i < 0xA0; i++) {
      this[Memory.addresses.OAM_START + i] = this[startAddress + i];
    }
  };

  GameboyJS.Memory = Memory;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
  "use strict";

  var ops = GameboyJS.cpuOps;
// Each opcode (0 to 0xFF) is associated to a CPU operation
// CPU operations are implemented separately
// The cbmap object holds operations for CB prefixed opcodes (0xCB00 to 0xCBFF)
// Non existent opcodes are commented out and marked empty
  var map = {
    0x00: function(p){p.clock.c += 4;},
    0x01: function(p){ops.LDrrnn(p, 'B', 'C');},
    0x02: function(p){ops.LDrrar(p, 'B', 'C', 'A');},
    0x03: function(p){ops.INCrr(p, 'B', 'C');},
    0x04: function(p){ops.INCr(p, 'B');},
    0x05: function(p){ops.DECr(p, 'B');},
    0x06: function(p){ops.LDrn(p, 'B');},
    0x07: function(p){var out=p.r.A & 0x80?1:0; out ? p.r.F=0x10:p.r.F=0; p.wr('A', ((p.r.A<<1)+out)&0xFF);p.clock.c+=4;},
    0x08: function(p){ops.LDnnsp(p);},
    0x09: function(p){ops.ADDrrrr(p, 'H', 'L', 'B', 'C');},
    0x0A: function(p){ops.LDrrra(p, 'A', 'B', 'C');},
    0x0B: function(p){ops.DECrr(p, 'B', 'C');},
    0x0C: function(p){ops.INCr(p, 'C');},
    0x0D: function(p){ops.DECr(p, 'C');},
    0x0E: function(p){ops.LDrn(p, 'C');},
    0x0F: function(p){var out=p.r.A & 0x01; out ? p.r.F=0x10:p.r.F=0; p.wr('A', (p.r.A>>1)|(out*0x80));p.clock.c+=4;},

    0x10: function(p){p.r.pc++;p.clock.c+=4;},
    0x11: function(p){ops.LDrrnn(p, 'D', 'E');},
    0x12: function(p){ops.LDrrar(p, 'D', 'E', 'A');},
    0x13: function(p){ops.INCrr(p, 'D', 'E');},
    0x14: function(p){ops.INCr(p, 'D');},
    0x15: function(p){ops.DECr(p, 'D');},
    0x16: function(p){ops.LDrn(p, 'D');},
    0x17: function(p){var c = (p.r.F&0x10)?1:0;var out=p.r.A & 0x80?1:0; out ? p.r.F=0x10:p.r.F=0; p.wr('A',((p.r.A<<1)+c)&0xFF);p.clock.c+=4;},
    0x18: function(p){ops.JRn(p);},
    0x19: function(p){ops.ADDrrrr(p, 'H', 'L', 'D', 'E');},
    0x1A: function(p){ops.LDrrra(p, 'A', 'D', 'E');},
    0x1B: function(p){ops.DECrr(p, 'D', 'E');},
    0x1C: function(p){ops.INCr(p, 'E');},
    0x1D: function(p){ops.DECr(p, 'E');},
    0x1E: function(p){ops.LDrn(p, 'E');},
    0x1F: function(p){var c = (p.r.F&0x10)?1:0;var out=p.r.A & 0x01; out ? p.r.F=0x10:p.r.F=0; p.wr('A', (p.r.A>>1)|(c*0x80));p.clock.c+=4;},

    0x20: function(p){ops.JRccn(p, 'NZ');},
    0x21: function(p){ops.LDrrnn(p, 'H', 'L');},
    0x22: function(p){ops.LDrrar(p, 'H', 'L', 'A');ops.INCrr(p, 'H', 'L');p.clock.c -= 8;},
    0x23: function(p){ops.INCrr(p, 'H', 'L');},
    0x24: function(p){ops.INCr(p, 'H');},
    0x25: function(p){ops.DECr(p, 'H');},
    0x26: function(p){ops.LDrn(p, 'H');},
    0x27: function(p){ops.DAA(p);},
    0x28: function(p){ops.JRccn(p, 'Z');},
    0x29: function(p){ops.ADDrrrr(p, 'H', 'L', 'H', 'L');},
    0x2A: function(p){ops.LDrrra(p, 'A', 'H', 'L');ops.INCrr(p, 'H', 'L');p.clock.c -= 8;},
    0x2B: function(p){ops.DECrr(p, 'H', 'L');},
    0x2C: function(p){ops.INCr(p, 'L');},
    0x2D: function(p){ops.DECr(p, 'L');},
    0x2E: function(p){ops.LDrn(p, 'L');},
    0x2F: function(p){ops.CPL(p);},

    0x30: function(p){ops.JRccn(p, 'NC');},
    0x31: function(p){ops.LDspnn(p);},
    0x32: function(p){ops.LDrrar(p, 'H', 'L', 'A');ops.DECrr(p, 'H', 'L');p.clock.c -= 8;},
    0x33: function(p){ops.INCsp(p);},
    0x34: function(p){ops.INCrra(p, 'H', 'L');},
    0x35: function(p){ops.DECrra(p, 'H', 'L');},
    0x36: function(p){ops.LDrran(p, 'H', 'L');},
    0x37: function(p){ops.SCF(p);},
    0x38: function(p){ops.JRccn(p, 'C');},
    0x39: function(p){ops.ADDrrsp(p, 'H', 'L');},
    0x3A: function(p){ops.LDrrra(p, 'A', 'H', 'L');ops.DECrr(p, 'H', 'L');p.clock.c -= 8;},
    0x3B: function(p){ops.DECsp(p);},
    0x3C: function(p){ops.INCr(p, 'A');},
    0x3D: function(p){ops.DECr(p, 'A');},
    0x3E: function(p){ops.LDrn(p, 'A');},
    0x3F: function(p){ops.CCF(p);},

    0x40: function(p){ops.LDrr(p, 'B', 'B');},
    0x41: function(p){ops.LDrr(p, 'B', 'C');},
    0x42: function(p){ops.LDrr(p, 'B', 'D');},
    0x43: function(p){ops.LDrr(p, 'B', 'E');},
    0x44: function(p){ops.LDrr(p, 'B', 'H');},
    0x45: function(p){ops.LDrr(p, 'B', 'L');},
    0x46: function(p){ops.LDrrra(p, 'B', 'H', 'L');},
    0x47: function(p){ops.LDrr(p, 'B', 'A');},
    0x48: function(p){ops.LDrr(p, 'C', 'B');},
    0x49: function(p){ops.LDrr(p, 'C', 'C');},
    0x4A: function(p){ops.LDrr(p, 'C', 'D');},
    0x4B: function(p){ops.LDrr(p, 'C', 'E');},
    0x4C: function(p){ops.LDrr(p, 'C', 'H');},
    0x4D: function(p){ops.LDrr(p, 'C', 'L');},
    0x4E: function(p){ops.LDrrra(p, 'C', 'H', 'L');},
    0x4F: function(p){ops.LDrr(p, 'C', 'A');},

    0x50: function(p){ops.LDrr(p, 'D', 'B');},
    0x51: function(p){ops.LDrr(p, 'D', 'C');},
    0x52: function(p){ops.LDrr(p, 'D', 'D');},
    0x53: function(p){ops.LDrr(p, 'D', 'E');},
    0x54: function(p){ops.LDrr(p, 'D', 'H');},
    0x55: function(p){ops.LDrr(p, 'D', 'L');},
    0x56: function(p){ops.LDrrra(p, 'D', 'H', 'L');},
    0x57: function(p){ops.LDrr(p, 'D', 'A');},
    0x58: function(p){ops.LDrr(p, 'E', 'B');},
    0x59: function(p){ops.LDrr(p, 'E', 'C');},
    0x5A: function(p){ops.LDrr(p, 'E', 'D');},
    0x5B: function(p){ops.LDrr(p, 'E', 'E');},
    0x5C: function(p){ops.LDrr(p, 'E', 'H');},
    0x5D: function(p){ops.LDrr(p, 'E', 'L');},
    0x5E: function(p){ops.LDrrra(p, 'E', 'H', 'L');},
    0x5F: function(p){ops.LDrr(p, 'E', 'A');},

    0x60: function(p){ops.LDrr(p, 'H', 'B');},
    0x61: function(p){ops.LDrr(p, 'H', 'C');},
    0x62: function(p){ops.LDrr(p, 'H', 'D');},
    0x63: function(p){ops.LDrr(p, 'H', 'E');},
    0x64: function(p){ops.LDrr(p, 'H', 'H');},
    0x65: function(p){ops.LDrr(p, 'H', 'L');},
    0x66: function(p){ops.LDrrra(p, 'H', 'H', 'L');},
    0x67: function(p){ops.LDrr(p, 'H', 'A');},
    0x68: function(p){ops.LDrr(p, 'L', 'B');},
    0x69: function(p){ops.LDrr(p, 'L', 'C');},
    0x6A: function(p){ops.LDrr(p, 'L', 'D');},
    0x6B: function(p){ops.LDrr(p, 'L', 'E');},
    0x6C: function(p){ops.LDrr(p, 'L', 'H');},
    0x6D: function(p){ops.LDrr(p, 'L', 'L');},
    0x6E: function(p){ops.LDrrra(p, 'L', 'H', 'L');},
    0x6F: function(p){ops.LDrr(p, 'L', 'A');},

    0x70: function(p){ops.LDrrar(p, 'H', 'L', 'B');},
    0x71: function(p){ops.LDrrar(p, 'H', 'L', 'C');},
    0x72: function(p){ops.LDrrar(p, 'H', 'L', 'D');},
    0x73: function(p){ops.LDrrar(p, 'H', 'L', 'E');},
    0x74: function(p){ops.LDrrar(p, 'H', 'L', 'H');},
    0x75: function(p){ops.LDrrar(p, 'H', 'L', 'L');},
    0x76: function(p){ops.HALT(p);},
    0x77: function(p){ops.LDrrar(p, 'H', 'L', 'A');},
    0x78: function(p){ops.LDrr(p, 'A', 'B');},
    0x79: function(p){ops.LDrr(p, 'A', 'C');},
    0x7A: function(p){ops.LDrr(p, 'A', 'D');},
    0x7B: function(p){ops.LDrr(p, 'A', 'E');},
    0x7C: function(p){ops.LDrr(p, 'A', 'H');},
    0x7D: function(p){ops.LDrr(p, 'A', 'L');},
    0x7E: function(p){ops.LDrrra(p, 'A', 'H', 'L');},
    0x7F: function(p){ops.LDrr(p, 'A', 'A');},

    0x80: function(p){ops.ADDrr(p, 'A', 'B');},
    0x81: function(p){ops.ADDrr(p, 'A', 'C');},
    0x82: function(p){ops.ADDrr(p, 'A', 'D');},
    0x83: function(p){ops.ADDrr(p, 'A', 'E');},
    0x84: function(p){ops.ADDrr(p, 'A', 'H');},
    0x85: function(p){ops.ADDrr(p, 'A', 'L');},
    0x86: function(p){ops.ADDrrra(p, 'A', 'H', 'L');},
    0x87: function(p){ops.ADDrr(p, 'A', 'A');},
    0x88: function(p){ops.ADCrr(p, 'A', 'B');},
    0x89: function(p){ops.ADCrr(p, 'A', 'C');},
    0x8A: function(p){ops.ADCrr(p, 'A', 'D');},
    0x8B: function(p){ops.ADCrr(p, 'A', 'E');},
    0x8C: function(p){ops.ADCrr(p, 'A', 'H');},
    0x8D: function(p){ops.ADCrr(p, 'A', 'L');},
    0x8E: function(p){ops.ADCrrra(p, 'A', 'H', 'L');},
    0x8F: function(p){ops.ADCrr(p, 'A', 'A');},

    0x90: function(p){ops.SUBr(p, 'B');},
    0x91: function(p){ops.SUBr(p, 'C');},
    0x92: function(p){ops.SUBr(p, 'D');},
    0x93: function(p){ops.SUBr(p, 'E');},
    0x94: function(p){ops.SUBr(p, 'H');},
    0x95: function(p){ops.SUBr(p, 'L');},
    0x96: function(p){ops.SUBrra(p, 'H', 'L');},
    0x97: function(p){ops.SUBr(p, 'A');},
    0x98: function(p){ops.SBCr(p, 'B');},
    0x99: function(p){ops.SBCr(p, 'C');},
    0x9A: function(p){ops.SBCr(p, 'D');},
    0x9B: function(p){ops.SBCr(p, 'E');},
    0x9C: function(p){ops.SBCr(p, 'H');},
    0x9D: function(p){ops.SBCr(p, 'L');},
    0x9E: function(p){ops.SBCrra(p, 'H', 'L');},
    0x9F: function(p){ops.SBCr(p, 'A');},

    0xA0: function(p){ops.ANDr(p, 'B');},
    0xA1: function(p){ops.ANDr(p, 'C');},
    0xA2: function(p){ops.ANDr(p, 'D');},
    0xA3: function(p){ops.ANDr(p, 'E');},
    0xA4: function(p){ops.ANDr(p, 'H');},
    0xA5: function(p){ops.ANDr(p, 'L');},
    0xA6: function(p){ops.ANDrra(p, 'H', 'L');},
    0xA7: function(p){ops.ANDr(p, 'A');},
    0xA8: function(p){ops.XORr(p, 'B');},
    0xA9: function(p){ops.XORr(p, 'C');},
    0xAA: function(p){ops.XORr(p, 'D');},
    0xAB: function(p){ops.XORr(p, 'E');},
    0xAC: function(p){ops.XORr(p, 'H');},
    0xAD: function(p){ops.XORr(p, 'L');},
    0xAE: function(p){ops.XORrra(p, 'H', 'L');},
    0xAF: function(p){ops.XORr(p, 'A');},

    0xB0: function(p){ops.ORr(p, 'B');},
    0xB1: function(p){ops.ORr(p, 'C');},
    0xB2: function(p){ops.ORr(p, 'D');},
    0xB3: function(p){ops.ORr(p, 'E');},
    0xB4: function(p){ops.ORr(p, 'H');},
    0xB5: function(p){ops.ORr(p, 'L');},
    0xB6: function(p){ops.ORrra(p, 'H', 'L');},
    0xB7: function(p){ops.ORr(p, 'A');},
    0xB8: function(p){ops.CPr(p, 'B');},
    0xB9: function(p){ops.CPr(p, 'C');},
    0xBA: function(p){ops.CPr(p, 'D');},
    0xBB: function(p){ops.CPr(p, 'E');},
    0xBC: function(p){ops.CPr(p, 'H');},
    0xBD: function(p){ops.CPr(p, 'L');},
    0xBE: function(p){ops.CPrra(p, 'H', 'L');},
    0xBF: function(p){ops.CPr(p, 'A');},

    0xC0: function(p){ops.RETcc(p, 'NZ');},
    0xC1: function(p){ops.POPrr(p, 'B', 'C');},
    0xC2: function(p){ops.JPccnn(p, 'NZ');},
    0xC3: function(p){ops.JPnn(p);},
    0xC4: function(p){ops.CALLccnn(p, 'NZ');},
    0xC5: function(p){ops.PUSHrr(p, 'B', 'C');},
    0xC6: function(p){ops.ADDrn(p, 'A');},
    0xC7: function(p){ops.RSTn(p, 0x00);},
    0xC8: function(p){ops.RETcc(p, 'Z');},
    0xC9: function(p){ops.RET(p);},
    0xCA: function(p){ops.JPccnn(p, 'Z');},
    0xCB: function(p){ops.CB(p);},
    0xCC: function(p){ops.CALLccnn(p, 'Z');},
    0xCD: function(p){ops.CALLnn(p);},
    0xCE: function(p){ops.ADCrn(p, 'A');},
    0xCF: function(p){ops.RSTn(p, 0x08);},

    0xD0: function(p){ops.RETcc(p, 'NC');},
    0xD1: function(p){ops.POPrr(p, 'D', 'E');},
    0xD2: function(p){ops.JPccnn(p, 'NC');},
    //0xD3 empty
    0xD4: function(p){ops.CALLccnn(p, 'NC');},
    0xD5: function(p){ops.PUSHrr(p, 'D', 'E');},
    0xD6: function(p){ops.SUBn(p);},
    0xD7: function(p){ops.RSTn(p, 0x10);},
    0xD8: function(p){ops.RETcc(p, 'C');},
    0xD9: function(p){ops.RETI(p);},
    0xDA: function(p){ops.JPccnn(p, 'C');},
    //0xDB empty
    0xDC: function(p){ops.CALLccnn(p, 'C');},
    //0xDD empty
    0xDE: function(p){ops.SBCn(p);},
    0xDF: function(p){ops.RSTn(p, 0x18);},

    0xE0: function(p){ops.LDHnar(p, 'A');},
    0xE1: function(p){ops.POPrr(p, 'H', 'L');},
    0xE2: function(p){ops.LDrar(p, 'C', 'A');},
    //0xE3 empty
    //0xE4 empty
    0xE5: function(p){ops.PUSHrr(p, 'H', 'L');},
    0xE6: function(p){ops.ANDn(p);},
    0xE7: function(p){ops.RSTn(p, 0x20);},
    0xE8: function(p){ops.ADDspn(p);},
    0xE9: function(p){ops.JPrr(p, 'H', 'L');},
    0xEA: function(p){ops.LDnnar(p, 'A');},
    //0xEB empty
    //0xEC empty
    //0xED empty
    0xEE: function(p){ops.XORn(p);},
    0xEF: function(p){ops.RSTn(p, 0x28);},

    0xF0: function(p){ops.LDHrna(p, 'A');},
    0xF1: function(p){ops.POPrr(p, 'A', 'F');},
    0xF2: function(p){ops.LDrra(p, 'A', 'C');},
    0xF3: function(p){ops.DI(p);},
    //0xF4 empty
    0xF5: function(p){ops.PUSHrr(p, 'A', 'F');},
    0xF6: function(p){ops.ORn(p);},
    0xF7: function(p){ops.RSTn(p, 0x30);},
    0xF8: function(p){ops.LDrrspn(p, 'H', 'L');},
    0xF9: function(p){ops.LDsprr(p, 'H', 'L');},
    0xFA: function(p){ops.LDrnna(p, 'A');},
    0xFB: function(p){ops.EI(p);},
    //0xFC empty
    //0xFD empty
    0xFE: function(p){ops.CPn(p);},
    0xFF: function(p){ops.RSTn(p, 0x38);}
  };

  var cbmap = {
    0x00: function(p){ops.RLCr(p, 'B');},
    0x01: function(p){ops.RLCr(p, 'C');},
    0x02: function(p){ops.RLCr(p, 'D');},
    0x03: function(p){ops.RLCr(p, 'E');},
    0x04: function(p){ops.RLCr(p, 'H');},
    0x05: function(p){ops.RLCr(p, 'L');},
    0x06: function(p){ops.RLCrra(p, 'H', 'L');},
    0x07: function(p){ops.RLCr(p, 'A');},
    0x08: function(p){ops.RRCr(p, 'B');},
    0x09: function(p){ops.RRCr(p, 'C');},
    0x0A: function(p){ops.RRCr(p, 'D');},
    0x0B: function(p){ops.RRCr(p, 'E');},
    0x0C: function(p){ops.RRCr(p, 'H');},
    0x0D: function(p){ops.RRCr(p, 'L');},
    0x0E: function(p){ops.RRCrra(p, 'H', 'L');},
    0x0F: function(p){ops.RRCr(p, 'A');},

    0x10: function(p){ops.RLr(p, 'B');},
    0x11: function(p){ops.RLr(p, 'C');},
    0x12: function(p){ops.RLr(p, 'D');},
    0x13: function(p){ops.RLr(p, 'E');},
    0x14: function(p){ops.RLr(p, 'H');},
    0x15: function(p){ops.RLr(p, 'L');},
    0x16: function(p){ops.RLrra(p, 'H', 'L');},
    0x17: function(p){ops.RLr(p, 'A');},
    0x18: function(p){ops.RRr(p, 'B');},
    0x19: function(p){ops.RRr(p, 'C');},
    0x1A: function(p){ops.RRr(p, 'D');},
    0x1B: function(p){ops.RRr(p, 'E');},
    0x1C: function(p){ops.RRr(p, 'H');},
    0x1D: function(p){ops.RRr(p, 'L');},
    0x1E: function(p){ops.RRrra(p, 'H', 'L');},
    0x1F: function(p){ops.RRr(p, 'A');},

    0x20: function(p){ops.SLAr(p, 'B');},
    0x21: function(p){ops.SLAr(p, 'C');},
    0x22: function(p){ops.SLAr(p, 'D');},
    0x23: function(p){ops.SLAr(p, 'E');},
    0x24: function(p){ops.SLAr(p, 'H');},
    0x25: function(p){ops.SLAr(p, 'L');},
    0x26: function(p){ops.SLArra(p, 'H', 'L');},
    0x27: function(p){ops.SLAr(p, 'A');},
    0x28: function(p){ops.SRAr(p, 'B');},
    0x29: function(p){ops.SRAr(p, 'C');},
    0x2A: function(p){ops.SRAr(p, 'D');},
    0x2B: function(p){ops.SRAr(p, 'E');},
    0x2C: function(p){ops.SRAr(p, 'H');},
    0x2D: function(p){ops.SRAr(p, 'L');},
    0x2E: function(p){ops.SRArra(p, 'H', 'L');},
    0x2F: function(p){ops.SRAr(p, 'A');},

    0x30: function(p){ops.SWAPr(p, 'B');},
    0x31: function(p){ops.SWAPr(p, 'C');},
    0x32: function(p){ops.SWAPr(p, 'D');},
    0x33: function(p){ops.SWAPr(p, 'E');},
    0x34: function(p){ops.SWAPr(p, 'H');},
    0x35: function(p){ops.SWAPr(p, 'L');},
    0x36: function(p){ops.SWAPrra(p, 'H', 'L');},
    0x37: function(p){ops.SWAPr(p, 'A');},
    0x38: function(p){ops.SRLr(p, 'B');},
    0x39: function(p){ops.SRLr(p, 'C');},
    0x3A: function(p){ops.SRLr(p, 'D');},
    0x3B: function(p){ops.SRLr(p, 'E');},
    0x3C: function(p){ops.SRLr(p, 'H');},
    0x3D: function(p){ops.SRLr(p, 'L');},
    0x3E: function(p){ops.SRLrra(p, 'H', 'L');},
    0x3F: function(p){ops.SRLr(p, 'A');},

    0x40: function(p){ops.BITir(p, 0, 'B');},
    0x41: function(p){ops.BITir(p, 0, 'C');},
    0x42: function(p){ops.BITir(p, 0, 'D');},
    0x43: function(p){ops.BITir(p, 0, 'E');},
    0x44: function(p){ops.BITir(p, 0, 'H');},
    0x45: function(p){ops.BITir(p, 0, 'L');},
    0x46: function(p){ops.BITirra(p, 0, 'H', 'L');},
    0x47: function(p){ops.BITir(p, 0, 'A');},
    0x48: function(p){ops.BITir(p, 1, 'B');},
    0x49: function(p){ops.BITir(p, 1, 'C');},
    0x4A: function(p){ops.BITir(p, 1, 'D');},
    0x4B: function(p){ops.BITir(p, 1, 'E');},
    0x4C: function(p){ops.BITir(p, 1, 'H');},
    0x4D: function(p){ops.BITir(p, 1, 'L');},
    0x4E: function(p){ops.BITirra(p, 1, 'H', 'L');},
    0x4F: function(p){ops.BITir(p, 1, 'A');},

    0x50: function(p){ops.BITir(p, 2, 'B');},
    0x51: function(p){ops.BITir(p, 2, 'C');},
    0x52: function(p){ops.BITir(p, 2, 'D');},
    0x53: function(p){ops.BITir(p, 2, 'E');},
    0x54: function(p){ops.BITir(p, 2, 'H');},
    0x55: function(p){ops.BITir(p, 2, 'L');},
    0x56: function(p){ops.BITirra(p, 2, 'H', 'L');},
    0x57: function(p){ops.BITir(p, 2, 'A');},
    0x58: function(p){ops.BITir(p, 3, 'B');},
    0x59: function(p){ops.BITir(p, 3, 'C');},
    0x5A: function(p){ops.BITir(p, 3, 'D');},
    0x5B: function(p){ops.BITir(p, 3, 'E');},
    0x5C: function(p){ops.BITir(p, 3, 'H');},
    0x5D: function(p){ops.BITir(p, 3, 'L');},
    0x5E: function(p){ops.BITirra(p, 3, 'H', 'L');},
    0x5F: function(p){ops.BITir(p, 3, 'A');},

    0x60: function(p){ops.BITir(p, 4, 'B');},
    0x61: function(p){ops.BITir(p, 4, 'C');},
    0x62: function(p){ops.BITir(p, 4, 'D');},
    0x63: function(p){ops.BITir(p, 4, 'E');},
    0x64: function(p){ops.BITir(p, 4, 'H');},
    0x65: function(p){ops.BITir(p, 4, 'L');},
    0x66: function(p){ops.BITirra(p, 4, 'H', 'L');},
    0x67: function(p){ops.BITir(p, 4, 'A');},
    0x68: function(p){ops.BITir(p, 5, 'B');},
    0x69: function(p){ops.BITir(p, 5, 'C');},
    0x6A: function(p){ops.BITir(p, 5, 'D');},
    0x6B: function(p){ops.BITir(p, 5, 'E');},
    0x6C: function(p){ops.BITir(p, 5, 'H');},
    0x6D: function(p){ops.BITir(p, 5, 'L');},
    0x6E: function(p){ops.BITirra(p, 5, 'H', 'L');},
    0x6F: function(p){ops.BITir(p, 5, 'A');},

    0x70: function(p){ops.BITir(p, 6, 'B');},
    0x71: function(p){ops.BITir(p, 6, 'C');},
    0x72: function(p){ops.BITir(p, 6, 'D');},
    0x73: function(p){ops.BITir(p, 6, 'E');},
    0x74: function(p){ops.BITir(p, 6, 'H');},
    0x75: function(p){ops.BITir(p, 6, 'L');},
    0x76: function(p){ops.BITirra(p, 6, 'H', 'L');},
    0x77: function(p){ops.BITir(p, 6, 'A');},
    0x78: function(p){ops.BITir(p, 7, 'B');},
    0x79: function(p){ops.BITir(p, 7, 'C');},
    0x7A: function(p){ops.BITir(p, 7, 'D');},
    0x7B: function(p){ops.BITir(p, 7, 'E');},
    0x7C: function(p){ops.BITir(p, 7, 'H');},
    0x7D: function(p){ops.BITir(p, 7, 'L');},
    0x7E: function(p){ops.BITirra(p, 7, 'H', 'L');},
    0x7F: function(p){ops.BITir(p, 7, 'A');},

    0x80: function(p){ops.RESir(p, 0, 'B');},
    0x81: function(p){ops.RESir(p, 0, 'C');},
    0x82: function(p){ops.RESir(p, 0, 'D');},
    0x83: function(p){ops.RESir(p, 0, 'E');},
    0x84: function(p){ops.RESir(p, 0, 'H');},
    0x85: function(p){ops.RESir(p, 0, 'L');},
    0x86: function(p){ops.RESirra(p, 0, 'H', 'L');},
    0x87: function(p){ops.RESir(p, 0, 'A');},
    0x88: function(p){ops.RESir(p, 1, 'B');},
    0x89: function(p){ops.RESir(p, 1, 'C');},
    0x8A: function(p){ops.RESir(p, 1, 'D');},
    0x8B: function(p){ops.RESir(p, 1, 'E');},
    0x8C: function(p){ops.RESir(p, 1, 'H');},
    0x8D: function(p){ops.RESir(p, 1, 'L');},
    0x8E: function(p){ops.RESirra(p, 1, 'H', 'L');},
    0x8F: function(p){ops.RESir(p, 1, 'A');},

    0x90: function(p){ops.RESir(p, 2, 'B');},
    0x91: function(p){ops.RESir(p, 2, 'C');},
    0x92: function(p){ops.RESir(p, 2, 'D');},
    0x93: function(p){ops.RESir(p, 2, 'E');},
    0x94: function(p){ops.RESir(p, 2, 'H');},
    0x95: function(p){ops.RESir(p, 2, 'L');},
    0x96: function(p){ops.RESirra(p, 2, 'H', 'L');},
    0x97: function(p){ops.RESir(p, 2, 'A');},
    0x98: function(p){ops.RESir(p, 3, 'B');},
    0x99: function(p){ops.RESir(p, 3, 'C');},
    0x9A: function(p){ops.RESir(p, 3, 'D');},
    0x9B: function(p){ops.RESir(p, 3, 'E');},
    0x9C: function(p){ops.RESir(p, 3, 'H');},
    0x9D: function(p){ops.RESir(p, 3, 'L');},
    0x9E: function(p){ops.RESirra(p, 3, 'H', 'L');},
    0x9F: function(p){ops.RESir(p, 3, 'A');},

    0xA0: function(p){ops.RESir(p, 4, 'B');},
    0xA1: function(p){ops.RESir(p, 4, 'C');},
    0xA2: function(p){ops.RESir(p, 4, 'D');},
    0xA3: function(p){ops.RESir(p, 4, 'E');},
    0xA4: function(p){ops.RESir(p, 4, 'H');},
    0xA5: function(p){ops.RESir(p, 4, 'L');},
    0xA6: function(p){ops.RESirra(p, 4, 'H', 'L');},
    0xA7: function(p){ops.RESir(p, 4, 'A');},
    0xA8: function(p){ops.RESir(p, 5, 'B');},
    0xA9: function(p){ops.RESir(p, 5, 'C');},
    0xAA: function(p){ops.RESir(p, 5, 'D');},
    0xAB: function(p){ops.RESir(p, 5, 'E');},
    0xAC: function(p){ops.RESir(p, 5, 'H');},
    0xAD: function(p){ops.RESir(p, 5, 'L');},
    0xAE: function(p){ops.RESirra(p, 5, 'H', 'L');},
    0xAF: function(p){ops.RESir(p, 5, 'A');},

    0xB0: function(p){ops.RESir(p, 6, 'B');},
    0xB1: function(p){ops.RESir(p, 6, 'C');},
    0xB2: function(p){ops.RESir(p, 6, 'D');},
    0xB3: function(p){ops.RESir(p, 6, 'E');},
    0xB4: function(p){ops.RESir(p, 6, 'H');},
    0xB5: function(p){ops.RESir(p, 6, 'L');},
    0xB6: function(p){ops.RESirra(p, 6, 'H', 'L');},
    0xB7: function(p){ops.RESir(p, 6, 'A');},
    0xB8: function(p){ops.RESir(p, 7, 'B');},
    0xB9: function(p){ops.RESir(p, 7, 'C');},
    0xBA: function(p){ops.RESir(p, 7, 'D');},
    0xBB: function(p){ops.RESir(p, 7, 'E');},
    0xBC: function(p){ops.RESir(p, 7, 'H');},
    0xBD: function(p){ops.RESir(p, 7, 'L');},
    0xBE: function(p){ops.RESirra(p, 7, 'H', 'L');},
    0xBF: function(p){ops.RESir(p, 7, 'A');},

    0xC0: function(p){ops.SETir(p, 0, 'B');},
    0xC1: function(p){ops.SETir(p, 0, 'C');},
    0xC2: function(p){ops.SETir(p, 0, 'D');},
    0xC3: function(p){ops.SETir(p, 0, 'E');},
    0xC4: function(p){ops.SETir(p, 0, 'H');},
    0xC5: function(p){ops.SETir(p, 0, 'L');},
    0xC6: function(p){ops.SETirra(p, 0, 'H', 'L');},
    0xC7: function(p){ops.SETir(p, 0, 'A');},
    0xC8: function(p){ops.SETir(p, 1, 'B');},
    0xC9: function(p){ops.SETir(p, 1, 'C');},
    0xCA: function(p){ops.SETir(p, 1, 'D');},
    0xCB: function(p){ops.SETir(p, 1, 'E');},
    0xCC: function(p){ops.SETir(p, 1, 'H');},
    0xCD: function(p){ops.SETir(p, 1, 'L');},
    0xCE: function(p){ops.SETirra(p, 1, 'H', 'L');},
    0xCF: function(p){ops.SETir(p, 1, 'A');},

    0xD0: function(p){ops.SETir(p, 2, 'B');},
    0xD1: function(p){ops.SETir(p, 2, 'C');},
    0xD2: function(p){ops.SETir(p, 2, 'D');},
    0xD3: function(p){ops.SETir(p, 2, 'E');},
    0xD4: function(p){ops.SETir(p, 2, 'H');},
    0xD5: function(p){ops.SETir(p, 2, 'L');},
    0xD6: function(p){ops.SETirra(p, 2, 'H', 'L');},
    0xD7: function(p){ops.SETir(p, 2, 'A');},
    0xD8: function(p){ops.SETir(p, 3, 'B');},
    0xD9: function(p){ops.SETir(p, 3, 'C');},
    0xDA: function(p){ops.SETir(p, 3, 'D');},
    0xDB: function(p){ops.SETir(p, 3, 'E');},
    0xDC: function(p){ops.SETir(p, 3, 'H');},
    0xDD: function(p){ops.SETir(p, 3, 'L');},
    0xDE: function(p){ops.SETirra(p, 3, 'H', 'L');},
    0xDF: function(p){ops.SETir(p, 3, 'A');},

    0xE0: function(p){ops.SETir(p, 4, 'B');},
    0xE1: function(p){ops.SETir(p, 4, 'C');},
    0xE2: function(p){ops.SETir(p, 4, 'D');},
    0xE3: function(p){ops.SETir(p, 4, 'E');},
    0xE4: function(p){ops.SETir(p, 4, 'H');},
    0xE5: function(p){ops.SETir(p, 4, 'L');},
    0xE6: function(p){ops.SETirra(p, 4, 'H', 'L');},
    0xE7: function(p){ops.SETir(p, 4, 'A');},
    0xE8: function(p){ops.SETir(p, 5, 'B');},
    0xE9: function(p){ops.SETir(p, 5, 'C');},
    0xEA: function(p){ops.SETir(p, 5, 'D');},
    0xEB: function(p){ops.SETir(p, 5, 'E');},
    0xEC: function(p){ops.SETir(p, 5, 'H');},
    0xED: function(p){ops.SETir(p, 5, 'L');},
    0xEE: function(p){ops.SETirra(p, 5, 'H', 'L');},
    0xEF: function(p){ops.SETir(p, 5, 'A');},

    0xF0: function(p){ops.SETir(p, 6, 'B');},
    0xF1: function(p){ops.SETir(p, 6, 'C');},
    0xF2: function(p){ops.SETir(p, 6, 'D');},
    0xF3: function(p){ops.SETir(p, 6, 'E');},
    0xF4: function(p){ops.SETir(p, 6, 'H');},
    0xF5: function(p){ops.SETir(p, 6, 'L');},
    0xF6: function(p){ops.SETirra(p, 6, 'H', 'L');},
    0xF7: function(p){ops.SETir(p, 6, 'A');},
    0xF8: function(p){ops.SETir(p, 7, 'B');},
    0xF9: function(p){ops.SETir(p, 7, 'C');},
    0xFA: function(p){ops.SETir(p, 7, 'D');},
    0xFB: function(p){ops.SETir(p, 7, 'E');},
    0xFC: function(p){ops.SETir(p, 7, 'H');},
    0xFD: function(p){ops.SETir(p, 7, 'L');},
    0xFE: function(p){ops.SETirra(p, 7, 'H', 'L');},
    0xFF: function(p){ops.SETir(p, 7, 'A');}
  };
  GameboyJS.opcodeMap = map;
  GameboyJS.opcodeCbmap = cbmap;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
  "use strict";

// A RomAjaxReader is able to load a file through an AJAX request
  var RomAjaxReader = function() {

  };

// The callback argument will be called when a file is successfully
// read, with the data as argument (Uint8Array)
  RomAjaxReader.prototype.setCallback = function(onLoadCallback) {
    this.callback = onLoadCallback;
  };

// This function should be called by application code
// and will trigger the AJAX call itself and push data to the ROM object
  RomAjaxReader.prototype.loadFromUrl = function(url) {
    if (!url) {
      throw 'No url has been set in order to load a ROM file.';
    }
    var cb = this.callback;

    var xhr = new XMLHttpRequest();
    xhr.open('GET', url, true);
    xhr.responseType = "arraybuffer";
    xhr.onload = function() {
      var rom = new Uint8Array(xhr.response);
      cb && cb(rom);
    };

    xhr.send();
  };

  GameboyJS.RomAjaxReader = RomAjaxReader;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
  "use strict";

// A RomDropFileReader is able to load a drag and dropped file
  var RomDropFileReader = function(el) {
    this.dropElement = el;
    if (!this.dropElement) {
      throw 'The RomDropFileReader needs a drop zone.';
    }

    var self = this;
    this.dropElement.addEventListener('dragenter', function(e) {
      e.preventDefault();
      e.target.classList.add('drag-active');
    });
    this.dropElement.addEventListener('dragleave', function(e) {
      e.preventDefault();
      e.target.classList.remove('drag-active');
    });
    this.dropElement.addEventListener('dragover', function(e) {
      e.preventDefault();
    });
    this.dropElement.addEventListener('drop', function (e) {
      e.target.classList.remove('drag-active');
      if (e.dataTransfer.files.length == 0) {
        return;
      }
      e.preventDefault();
      self.loadFromFile(e.dataTransfer.files[0]);
    });
  };

// The callback argument will be called when a file is successfully
// read, with the data as argument (Uint8Array)
  RomDropFileReader.prototype.setCallback = function(onLoadCallback) {
    this.callback = onLoadCallback;
  };

// The file loading logic is the same as the regular file reader
  RomDropFileReader.prototype.loadFromFile = function(file) {
    if (file === undefined) {
      return;
    }
    var fr = new FileReader();
    var cb = this.callback;

    fr.onload = function() {
      cb && cb(new Uint8Array(fr.result));
    };
    fr.onerror = function(e) {
      console.log('Error reading the file', e.target.error.code)
    };
    fr.readAsArrayBuffer(file);
  };

  GameboyJS.RomDropFileReader = RomDropFileReader;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
  "use strict";

// A RomFileReader is able to load a local file from an input element
//
// Expects to be provided a file input element,
// or will try to find one with the "file" DOM ID
  var RomFileReader = function(el) {
    this.domElement = el || document.getElementById('file');
    // TODO EDITED HERE
    //return;
    if (!this.domElement) {
      throw 'The RomFileReader needs a valid input element.';
    }

    var self = this;
    this.domElement.addEventListener('change', function(e){
      self.loadFromFile(e.target.files[0]);
    });
  };

// The callback argument will be called when a file is successfully
// read, with the data as argument (Uint8Array)
  RomFileReader.prototype.setCallback = function(onLoadCallback) {
    this.callback = onLoadCallback;
  };

// Automatically called when the DOM input is provided with a file
  RomFileReader.prototype.loadFromFile = function(file) {
    if (file === undefined) {
      return;
    }
    var fr = new FileReader();
    var cb = this.callback;

    fr.onload = function() {
      cb && cb(new Uint8Array(fr.result));
    };
    fr.onerror = function(e) {
      console.log('Error reading the file', e.target.error.code)
    };
    fr.readAsArrayBuffer(file);
  };

  GameboyJS.RomFileReader = RomFileReader;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
  "use strict";


  var Rom = function(gameboy, romReader) {
    this.gameboy = gameboy;
    if (romReader) {
      this.addReader(romReader);
    }
  };

  Rom.prototype.addReader = function(romReader) {
    var self = this;
    romReader.setCallback(function(data) {
      if (!validate(data)) {
        self.gameboy.error('The file is not a valid GameBoy ROM.');
        return;
      }
      self.data = data;
      self.gameboy.startRom(self);
    });
  };

// Validate the checksum of the cartridge header
  function validate(data) {
    var hash = 0;
    for (var i = 0x134; i <= 0x14C; i++) {
      hash = hash - data[i] - 1;
    }
    return (hash & 0xFF) == data[0x14D];
  };

  GameboyJS.Rom = Rom;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
  "use strict";

// Handlers for the Serial port of the Gameboy

// The ConsoleSerial is an output-only serial port
// designed for debug purposes as some test roms output data on the serial port
//
// Will regularly output the received byte (converted to string) in the console logs
// This handler always push the value 0xFF as an input
  var ConsoleSerial = {
    current: '',
    timeout: null,
    out: function(data) {
      ConsoleSerial.current += String.fromCharCode(data);
      if (data == 10) {
        ConsoleSerial.print();
      } else {
        clearTimeout(ConsoleSerial.timeout);
        ConsoleSerial.timeout = setTimeout(ConsoleSerial.print, 500);
      }
    },
    in: function() {
      return 0xFF;
    },
    print: function() {
      clearTimeout(ConsoleSerial.timeout);
      console.log('serial: '+ConsoleSerial.current);
      ConsoleSerial.current = '';
    }
  };
  GameboyJS.ConsoleSerial = ConsoleSerial;

// A DummySerial outputs nothing and always inputs 0xFF
  var DummySerial = {
    out: function() {},
    in: function() {
      return 0xFF;
    }
  };
  GameboyJS.DummySerial = DummySerial;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
  "use strict";

// Audio Processing unit
// Listens the write accesses to the audio-reserved memory addresses
// and dispatches the data to the sound channels
  var APU = function(memory) {
    this.memory = memory;
    this.enabled = false;

    AudioContext = window.AudioContext || window.webkitAudioContext;
    var audioContext = new AudioContext();

    this.channel1 = new GameboyJS.Channel1(this, 1, audioContext);
    this.channel2 = new GameboyJS.Channel1(this, 2, audioContext);
    this.channel3 = new GameboyJS.Channel3(this, 3, audioContext);
    this.channel4 = new GameboyJS.Channel4(this, 4, audioContext);

  };
  APU.prototype.connect = function() {
    this.channel1.enable();
    this.channel2.enable();
    this.channel3.enable();
  };
  APU.prototype.disconnect = function() {
    this.channel1.disable();
    this.channel2.disable();
    this.channel3.disable();
  };
// Updates the states of each channel given the elapsed time
// (in instructions) since last update
  APU.prototype.update = function(clockElapsed) {
    if (this.enabled == false) return;

    this.channel1.update(clockElapsed);
    this.channel2.update(clockElapsed);
    this.channel3.update(clockElapsed);
    this.channel4.update(clockElapsed);
  };
  APU.prototype.setSoundFlag = function(channel, value) {
    var mask = 0xFF - (1 << (channel - 1));
    value = value << (channel - 1)
    var byteValue = this.memory.rb(APU.registers.NR52);
    byteValue &= mask;
    byteValue |= value;
    this.memory[APU.registers.NR52] = byteValue;
  };
// Manage writes to audio registers
// Will update the channels depending on the address
  APU.prototype.manageWrite = function(addr, value) {
    if (this.enabled == false && addr < APU.registers.NR52) {
      return;
    }
    this.memory[addr] = value;

    switch (addr) {
      // Channel 1 addresses
      case 0xFF10:
        this.channel1.clockSweep = 0;
        this.channel1.sweepTime = ((value & 0x70) >> 4);
        this.channel1.sweepSign = (value & 0x08) ? -1 : 1;
        this.channel1.sweepShifts = (value & 0x07);
        this.channel1.sweepCount = this.channel1.sweepShifts;
        break;
      case 0xFF11:
        // todo : bits 6-7
        this.channel1.setLength(value & 0x3F);
        break;
      case 0xFF12:
        this.channel1.envelopeSign = (value & 0x08) ? 1 : -1;
        var envelopeVolume = (value & 0xF0) >> 4;
        this.channel1.setEnvelopeVolume(envelopeVolume);
        this.channel1.envelopeStep = (value & 0x07);
        break;
      case 0xFF13:
        var frequency = this.channel1.getFrequency();
        frequency &= 0xF00;
        frequency |= value;
        this.channel1.setFrequency(frequency);
        break;
      case 0xFF14:
        var frequency = this.channel1.getFrequency();
        frequency &= 0xFF;
        frequency |= (value & 7) << 8;
        this.channel1.setFrequency(frequency);
        this.channel1.lengthCheck = (value & 0x40) ? true : false;
        if (value & 0x80) this.channel1.play();
        break;

      // Channel 2 addresses
      case 0xFF16:
        // todo : bits 6-7
        this.channel2.setLength(value & 0x3F);
        break;
      case 0xFF17:
        this.channel2.envelopeSign = (value & 0x08) ? 1 : -1;
        var envelopeVolume = (value & 0xF0) >> 4;
        this.channel2.setEnvelopeVolume(envelopeVolume);
        this.channel2.envelopeStep = (value & 0x07);
        break;
      case 0xFF18:
        var frequency = this.channel2.getFrequency();
        frequency &= 0xF00;
        frequency |= value;
        this.channel2.setFrequency(frequency);
        break;
      case 0xFF19:
        var frequency = this.channel2.getFrequency();
        frequency &= 0xFF;
        frequency |= (value & 7) << 8;
        this.channel2.setFrequency(frequency);
        this.channel2.lengthCheck = (value & 0x40) ? true : false;
        if (value & 0x80) {
          this.channel2.play();
        }
        break;

      // Channel 3 addresses
      case 0xFF1A:
        // todo
        break;
      case 0xFF1B:
        this.channel3.setLength(value);
        break;
      case 0xFF1C:
        // todo
        break;
      case 0xFF1D:
        var frequency = this.channel3.getFrequency();
        frequency &= 0xF00;
        frequency |= value;
        this.channel3.setFrequency(frequency);
        break;
      case 0xFF1E:
        var frequency = this.channel3.getFrequency();
        frequency &= 0xFF;
        frequency |= (value & 7) << 8;
        this.channel3.setFrequency(frequency);
        this.channel3.lengthCheck = (value & 0x40) ? true : false;
        if (value & 0x80) {
          this.channel3.play();
        }
        break;

      // Channel 4 addresses
      case 0xFF20:
        this.channel4.setLength(value & 0x3F);
        break;
      case 0xFF21:
        // todo
        break;
      case 0xFF22:
        // todo
        break;
      case 0xFF23:
        this.channel4.lengthCheck = (value & 0x40) ? true : false;
        if (value & 0x80) {
          this.channel4.play();
        }
        break;

      // channel 3 wave bytes
      case 0xFF30:case 0xFF31:case 0xFF32:case 0xFF33:case 0xFF34:case 0xFF35:case 0xFF36:case 0xFF37:
      case 0xFF38:case 0xFF39:case 0xFF3A:case 0xFF3B:case 0xFF3C:case 0xFF3D:case 0xFF3E:case 0xFF3F:
        var index = addr - 0xFF30;
        this.channel3.setWaveBufferByte(index, value);
        break;

      // general audio switch
      case 0xFF26:
        value &= 0xF0;
        this.memory[addr] = value;
        this.enabled = (value & 0x80) == 0 ? false : true;
        if (!this.enabled) {
          for (var i = 0xFF10; i < 0xFF27; i++)
            this.memory[i] = 0;
          // todo stop sound
        }
        break;
    }
  };

  APU.registers = {
    NR10: 0xFF10,
    NR11: 0xFF11,
    NR12: 0xFF12,
    NR13: 0xFF13,
    NR14: 0xFF14,

    NR21: 0xFF16,
    NR22: 0xFF17,
    NR23: 0xFF18,
    NR24: 0xFF19,

    NR30: 0xFF1A,
    NR31: 0xFF1B,
    NR32: 0xFF1C,
    NR33: 0xFF1D,
    NR34: 0xFF1E,

    NR41: 0xFF20,
    NR42: 0xFF21,
    NR43: 0xFF22,
    NR44: 0xFF23,

    NR50: 0xFF24,
    NR51: 0xFF25,
    NR52: 0xFF26
  };
  GameboyJS.APU = APU;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
  "use strict";
  var Channel1 = function(apu, channelNumber, audioContext) {
    this.apu = apu;
    this.channelNumber = channelNumber;
    this.playing = false;

    this.soundLengthUnit = 0x4000; // 1 / 256 second of instructions
    this.soundLength = 64; // defaults to 64 periods
    this.lengthCheck = false;

    this.sweepTime = 0; // from 0 to 7
    this.sweepStepLength = 0x8000; // 1 / 128 seconds of instructions
    this.sweepCount = 0;
    this.sweepShifts = 0;
    this.sweepSign = 1; // +1 / -1 for increase / decrease freq

    this.frequency = 0;

    this.envelopeStep = 0;
    this.envelopeStepLength = 0x10000;// 1 / 64 seconds of instructions
    this.envelopeCheck = false;
    this.envelopeSign = 1;

    this.clockLength = 0;
    this.clockEnvelop = 0;
    this.clockSweep = 0;

    var gainNode = audioContext.createGain();
    gainNode.gain.value = 0;
    var oscillator = audioContext.createOscillator();
    oscillator.type = 'square';
    oscillator.frequency.value = 1000;
    oscillator.connect(gainNode);
    oscillator.start(0);

    this.audioContext = audioContext;
    this.gainNode = gainNode;
    this.oscillator = oscillator;
  };

  Channel1.prototype.play = function() {
    if (this.playing) return;
    this.playing = true;
    this.apu.setSoundFlag(this.channelNumber, 1);
    this.gainNode.connect(this.audioContext.destination);
    this.clockLength = 0;
    this.clockEnvelop = 0;
    this.clockSweep = 0;
    if (this.sweepShifts > 0) this.checkFreqSweep();
  };
  Channel1.prototype.stop = function() {
    this.playing = false;
    this.apu.setSoundFlag(this.channelNumber, 0);
    this.gainNode.disconnect();
  };
  Channel1.prototype.checkFreqSweep = function() {
    var oldFreq = this.getFrequency();
    var newFreq = oldFreq + this.sweepSign * (oldFreq >> this.sweepShifts);
    if (newFreq > 0x7FF) {
      newFreq = 0;
      this.stop();
    }

    return newFreq;
  };
  Channel1.prototype.update = function(clockElapsed) {
    this.clockEnvelop += clockElapsed;
    this.clockSweep   += clockElapsed;

    if ((this.sweepCount || this.sweepTime) && this.clockSweep > (this.sweepStepLength * this.sweepTime)) {
      this.clockSweep -= (this.sweepStepLength * this.sweepTime);
      this.sweepCount--;

      var newFreq = this.checkFreqSweep(); // process and check new freq

      this.apu.memory[0xFF13] = newFreq & 0xFF;
      this.apu.memory[0xFF14] &= 0xF8;
      this.apu.memory[0xFF14] |= (newFreq & 0x700) >> 8;
      this.setFrequency(newFreq);

      this.checkFreqSweep(); // check again with new value
    }

    if (this.envelopeCheck && this.clockEnvelop > this.envelopeStepLength) {
      this.clockEnvelop -= this.envelopeStepLength;
      this.envelopeStep--;
      this.setEnvelopeVolume(this.envelopeVolume + this.envelopeSign);
      if (this.envelopeStep <= 0) {
        this.envelopeCheck = false;
      }
    }

    if (this.lengthCheck) {
      this.clockLength += clockElapsed;
      if (this.clockLength > this.soundLengthUnit) {
        this.soundLength--;
        this.clockLength -= this.soundLengthUnit;
        if (this.soundLength == 0) {
          this.setLength(0);
          this.stop();
        }
      }
    }
  };
  Channel1.prototype.setFrequency = function(value) {
    this.frequency = value;
    this.oscillator.frequency.value = 131072 / (2048 - this.frequency);
  };
  Channel1.prototype.getFrequency = function() {
    return this.frequency;
  };
  Channel1.prototype.setLength = function(value) {
    this.soundLength = 64 - (value & 0x3F);
  };
  Channel1.prototype.setEnvelopeVolume = function(volume) {
    this.envelopeCheck = volume > 0 && volume < 16 ? true : false;
    this.envelopeVolume = volume;
    this.gainNode.gain.value = this.envelopeVolume * 1/100;
  };
  Channel1.prototype.disable = function() {
    this.oscillator.disconnect();
  };
  Channel1.prototype.enable = function() {
    this.oscillator.connect(this.gainNode);
  };
  GameboyJS.Channel1 = Channel1;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
  "use strict";
  var Channel3 = function(apu, channelNumber, audioContext) {
    this.apu = apu;
    this.channelNumber = channelNumber;
    this.playing = false;

    this.soundLength = 0;
    this.soundLengthUnit = 0x4000; // 1 / 256 second of instructions
    this.lengthCheck = false;

    this.clockLength = 0;

    this.buffer = new Float32Array(32);

    var gainNode = audioContext.createGain();
    gainNode.gain.value = 1;
    this.gainNode = gainNode;

    this.baseSpeed = 65536;
    var waveBuffer = audioContext.createBuffer(1, 32, this.baseSpeed);

    var bufferSource = audioContext.createBufferSource();
    bufferSource.buffer = waveBuffer;
    bufferSource.loop = true;
    bufferSource.connect(gainNode);
    bufferSource.start(0);

    this.audioContext = audioContext;
    this.waveBuffer = waveBuffer;
    this.bufferSource = bufferSource;

  };
  Channel3.prototype.play = function() {
    if (this.playing) return;
    this.playing = true;
    this.apu.setSoundFlag(this.channelNumber, 1);
    this.waveBuffer.copyToChannel(this.buffer, 0, 0);

    this.gainNode.connect(this.audioContext.destination);
    this.clockLength = 0;
  };
  Channel3.prototype.stop = function() {
    this.playing = false;
    this.apu.setSoundFlag(this.channelNumber, 0);
    this.gainNode.disconnect();
  };
  Channel3.prototype.update = function(clockElapsed) {
    if (this.lengthCheck){
      this.clockLength  += clockElapsed;
      if (this.clockLength > this.soundLengthUnit) {
        this.soundLength--;
        this.clockLength -= this.soundLengthUnit;
        if (this.soundLength == 0) {
          this.setLength(0);
          this.stop();
        }
      }
    }
  };
  Channel3.prototype.setFrequency = function(value) {
    value = 65536 / (2048  - value);
    this.bufferSource.playbackRate.value = value / this.baseSpeed;
  };
  Channel3.prototype.getFrequency = function() {
    var freq = 2048 - 65536 / (this.bufferSource.playbackRate.value * this.baseSpeed);
    return freq | 1;
  };
  Channel3.prototype.setLength = function(value) {
    this.soundLength = 256 - value;
  };
  Channel3.prototype.setWaveBufferByte = function(index, value) {
    var bufferIndex = index * 2;

    this.buffer[bufferIndex]   = (value >> 4) / 8 - 1; // value in buffer is in -1 -> 1
    this.buffer[bufferIndex+1] = (value & 0x0F) / 8 - 1;
  };
  Channel3.prototype.disable = function() {
    this.bufferSource.disconnect();
  };
  Channel3.prototype.enable = function() {
    this.bufferSource.connect(this.gainNode);
  };
  GameboyJS.Channel3 = Channel3;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
  "use strict";
  var Channel4 = function(apu, channelNumber, audioContext) {
    this.apu = apu;
    this.channelNumber = channelNumber;
    this.playing = false;

    this.soundLengthUnit = 0x4000; // 1 / 256 second of instructions
    this.soundLength = 64; // defaults to 64 periods
    this.lengthCheck = false;

    this.clockLength = 0;

    this.audioContext = audioContext;
  };

  Channel4.prototype.play = function() {
    if (this.playing) return;
    this.playing = true;
    this.apu.setSoundFlag(this.channelNumber, 1);
    this.clockLength = 0;
  };
  Channel4.prototype.stop = function() {
    this.playing = false;
    this.apu.setSoundFlag(this.channelNumber, 0);
  };
  Channel4.prototype.update = function(clockElapsed) {
    if (this.lengthCheck) {
      this.clockLength  += clockElapsed;
      if (this.clockLength > this.soundLengthUnit) {
        this.soundLength--;
        this.clockLength -= this.soundLengthUnit;
        if (this.soundLength == 0) {
          this.setLength(0);
          this.stop();
        }
      }
    }
  };
  Channel4.prototype.setLength = function(value) {
    this.soundLength = 64 - (value & 0x3F);
  };
  GameboyJS.Channel4 = Channel4;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
  "use strict";

  var Timer = function(cpu, memory) {
    this.cpu    = cpu;
    this.memory = memory;

    this.DIV  = 0xFF04;
    this.TIMA = 0xFF05;
    this.TMA  = 0xFF06;
    this.TAC  = 0xFF07;

    this.mainTime  = 0;
    this.divTime   = 0;
  };

  Timer.prototype.update = function(clockElapsed) {
    this.updateDiv(clockElapsed);
    this.updateTimer(clockElapsed);
  };

  Timer.prototype.updateTimer = function(clockElapsed) {
    if (!(this.memory.rb(this.TAC) & 0x4)) {
      return;
    }
    this.mainTime += clockElapsed;

    var threshold = 64;
    switch (this.memory.rb(this.TAC) & 3) {
      case 0: threshold=64; break; // 4KHz
      case 1: threshold=1;  break; // 256KHz
      case 2: threshold=4;  break; // 64KHz
      case 3: threshold=16; break; // 16KHz
    }
    threshold *= 16;

    while (this.mainTime >= threshold) {
      this.mainTime -= threshold;

      this.memory.wb(this.TIMA, this.memory.rb(this.TIMA) + 1);
      if (this.memory.rb(this.TIMA) > 0xFF) {
        this.memory.wb(this.TIMA, this.memory.rb(this.TMA));
        this.cpu.requestInterrupt(GameboyJS.CPU.INTERRUPTS.TIMER);
      }
    }
  };
// Update the DIV register internal clock
// Increment it if the clock threshold is elapsed and
// reset it if its value overflows
  Timer.prototype.updateDiv = function(clockElapsed) {
    var divThreshold = 256; // DIV is 16KHz
    this.divTime += clockElapsed;
    if (this.divTime > divThreshold) {
      this.divTime -= divThreshold;
      var div = this.memory.rb(this.DIV) + 1;
      this.memory.wb(this.DIV, div&0xFF);
    }
  };

  Timer.prototype.resetDiv = function() {
    this.divTime = 0;
    this.memory[this.DIV] = 0; // direct write to avoid looping
  };
  GameboyJS.Timer = Timer;
}(GameboyJS || (GameboyJS = {})));

var GameboyJS;
(function (GameboyJS) {
  "use strict";

// Utility functions
  var Util = {
    // Add to the first argument the properties of all other arguments
    extend: function(target /*, source1, source2, etc. */) {
      var sources = Array.prototype.slice.call(arguments);
      for (var i in sources) {
        var source = sources[i];
        for (var name in source) {
          target[name] = source[name];
        }
      }

      return target;
    },
    testFlag: function(p, cc) {
      var test=1;
      var mask=0x10;
      if (cc=='NZ'||cc=='NC') test=0;
      if (cc=='NZ'||cc=='Z')  mask=0x80;
      return (test && p.r.F&mask) || (!test && !(p.r.F&mask));
    },
    getRegAddr: function(p, r1, r2) {return Util.makeword(p.r[r1], p.r[r2]);},

    // make a 16 bits word from 2 bytes
    makeword: function(b1, b2) {return (b1 << 8) + b2;},

    // return the integer signed value of a given byte
    getSignedValue: function(v) {return v & 0x80 ? v-256 : v;},

    // extract a bit from a byte
    readBit: function(byte, index) {
      return (byte >> index) & 1;
    }
  };

  GameboyJS.Util = Util;
}(GameboyJS || (GameboyJS = {})));
</script>