titaniumnet-mirror/Holy-Unblocker
1
0
Fork 0
mirror of https://github.com/QuiteAFancyEmerald/Holy-Unblocker.git synced 2025-05-13 03:50:02 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions
Holy-Unblocker/dist/gameboy.js
TheEmeraldStarr 98487c2906 Added Gameboy Emulator
2020-10-07 20:19:42 -07:00

3038 lines
105 KiB
JavaScript
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

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);
};
Screen.prototype.fillImageData = function(buffer) {
for (var y = 0; y < Screen.physics.HEIGHT; y++) {
for (var py = 0; py < this.pixelSize; py++) {
var _y = y * this.pixelSize + py;
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;
}
}
}
}
};
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 71: // G
key = 'A';
break;
case 66: // B
key = 'B';
break;
case 72: // H
key = 'START';
break;
case 78: // N
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 {
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');
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 = {})));
Reference in a new issue View git blame Copy permalink