TypeScript GameBoy Emulator is a GameBoy emulator written from scratch in TypeScript with zero dependencies.
My implementation of a UI with this package can be seen here: https://roblouie.com/gameboy/
The source code for this UI is also in the ui/
folder in the package github repo.
The simple example shown below has been implemented in a folder in the github repo named simple-example.
Install the package:
npm install gameboy-emulator
First you need to create an instance of the GameBoy:
import { Gameboy } from "gameboy-emulator";
const gameboy = new Gameboy();
After installing the package there are a couple of things you need to do to actually play games. Primarily load a rom, enable audio, and have a canvas to render to.
There are additional steps you may want to take, for instance configuring controls, changing colors, storing game save data, etc. Those additional features are explained in the API section.
The emulator expects the rom in ArrayBuffer form. The simplest example to implement this is to add a file input to your html and add an event handler to convert the file to ArrayBuffer.
<input type="file" class="file-input"/>
const fileInput = document.querySelector('.file-input');
fileInput.addEventListener('change', onFileChange);
async function onFileChange(event) {
if (fileInput.files && fileInput.files[0]) {
// Convert the selected file into an array buffer
const rom = await fileToArrayBuffer(fileInput.files[0]);
// load game
gameboy.loadGame(rom);
}
}
function fileToArrayBuffer(file) {
const fileReader = new FileReader();
return new Promise((resolve, reject) => {
fileReader.onload = () => resolve(fileReader.result);
fileReader.onerror = () => {
fileReader.abort();
reject(new Error('Error parsing file'))
}
fileReader.readAsArrayBuffer(file);
});
}
The web does not allow auto-playing of audio, so you must enable audio support when the user presses a button. You can add a mute button, or simply enable audio inside the event handler for file selection. For simplicity, we will add that to our event handler from above.
// enable audio
gameboy.apu.enableSound();
In order to provide near real-time buffered audio, this emulator uses a shared array buffer to write to an audio player on another thread. Since this allows direct memory access, certain security features are required. First, you must use https. In addition, you must have the following headers set on your server:
'Cross-Origin-Opener-Policy': 'same-origin'
'Cross-Origin-Embedder-Policy': 'require-corp'
You can see these being set in the webpack dev server in the simple example projects. You can still use the emulator without this, but audio will not work.
Finally you need to actually render the graphics somewhere. For flexibility the emulator just draws
the graphics to an ImageData with the native GameBoy resolution of 160x144. The emulator provides a
callback named onFrameFinished
that will pass you the ImageData for rendering. If you want your
canvas to be larger than 160x144 (and you probably do), the simplest way is to increase the size
with css, making sure to set image-rendering: pixelated;
to stop the browser from blurring the image.
This can be set up at any time, but for convenience we will set this callback in the same event handler:
<canvas width="160" height="144"></canvas>
canvas {
width: 100%;
image-rendering: pixelated;
}
const context = document.querySelector('canvas').getContext('2d');
// draw the image data to canvas when a frame is drawn
gameboy.onFrameFinished(imageData => {
context.putImageData(imageData, 0, 0);
});
Finally, with the rom loaded and the frame callback set, run the game with gameboy.run()
Our full JavaScript that does everything we need looks like this:
import { Gameboy } from "gameboy-emulator";
const gameboy = new Gameboy();
const fileInput = document.querySelector('.file-input');
fileInput.addEventListener('change', onFileChange);
async function onFileChange(event) {
if (fileInput.files && fileInput.files[0]) {
const rom = await fileToArrayBuffer(fileInput.files[0]);
gameboy.loadGame(rom);
gameboy.apu.enableSound();
const context = document.querySelector('canvas').getContext('2d');
gameboy.onFrameFinished(imageData => {
context.putImageData(imageData, 0, 0);
});
gameboy.run(); // Run the game
}
}
function fileToArrayBuffer(file) {
const fileReader = new FileReader();
return new Promise((resolve, reject) => {
fileReader.onload = () => resolve(fileReader.result);
fileReader.onerror = () => {
fileReader.abort();
reject(new Error('Error parsing file'))
}
fileReader.readAsArrayBuffer(file);
});
}
The emulator comes with built-in controller and keyboard support. It defaults to the first active controller found. Default key bindings are:
- Left: Dpad left and first analog stick left
- Right: Dpad right and first analog stick right
- Up: Dpad up and first analog stick up
- Down: Dpad down and first analog stick down
- A: Button 2, which is the X button on an XBox controller
- B: Button 0, which is the A button on an XBox controller
- Select: Button 8, which is the select button on an Xbox controller
- Start: Button 9, which is the start button on an Xbox controller
- Left: Left Arrow
- Right: Right Arrow
- Up: Up Arrow
- Down: Down Arrow
- A: A key
- B: B key
- Select: Right Control
- Start: Enter
- Gameboy
- cpu: CPU
- gpu
- apu
- cartridge
- title
- typeName
- romSize
- ramSize
- versionNumber
- memory
- input
- isPressingUp: boolean
- isPressingDown: boolean
- isPressingLeft: boolean
- isPressingRight: boolean
- isPressingSelect: boolean
- isPressingStart: boolean
- isPressingA: boolean
- isPressingB: boolean
- controllerManager
- controller: number
- left: number
- right: number
- up: number
- down: number
- select: number
- start: number
- b: number
- a: number
- keyboardManager
- left: string
- right: string
- up: string
- down: string
- select: string
- start: string
- b: string
- a: string
- loadGame(romData: ArrayBuffer)
- run()
- onFrameFinished(callback: Function)
- setOnWriteToCartridgeRam(onSramWrite: Function)
- getCartridgeSaveRam(): ArrayBuffer
- setCartridgeSaveRam(sramArrayBuffer: ArrayBuffer)
Constructor to create a new Gameboy instance:
const gameboy = new Gameboy()
Contains registers and operations, executes instructions
Contains all the CPU registers. All registers can be seen here:
// Getting the value of every register
gameboy.cpu.registers.A.value;
gameboy.cpu.registers.B.value;
gameboy.cpu.registers.C.value;
gameboy.cpu.registers.D.value;
gameboy.cpu.registers.E.value;
gameboy.cpu.registers.F.value;
gameboy.cpu.registers.AF.value;
gameboy.cpu.registers.BC.value;
gameboy.cpu.registers.DE.value;
gameboy.cpu.registers.HL.value;
gameboy.cpu.registers.stackPointer.value;
gameboy.cpu.registers.programCounter.value;
Collection of all base level operations (excludes cb operations, which are stored separately).
The operation type is defined as:
interface Operation {
instruction: string;
byteDefinition: number;
cycleTime: number;
byteLength: number;
execute: Function;
}
So if you'd like to see the assembly for all base instructions you could do:
for (const operation of gameboy.cpu.operationMap.values()) {
console.log(operation.instruction);
}
The instruction at position 0xcb
uses the next byte to define a subset of operations.
These operations are stored here, and are the same format as operations as described above.
Graphics processor. Handles all drawing. Exposes screen pixel data and color palette.
Defines the 4 color palette used to draw graphics:
colors = [
{ red: 255, green: 255, blue: 255 },
{ red: 192, green: 192, blue: 192 },
{ red: 96, green: 96, blue: 96 },
{ red: 0, green: 0, blue: 0 },
]
You can change these colors to change the colors used to draw graphics. The default is gray scale as seen above.
// Use blue for color 0 instead of white
gameboy.gpu.colors[0] = { red: 0, green: 0, blue: 255 };
ImageData object containing the pixel data for the screen. This is also passed in
the onFrameFinished
callback.
Audio Processor. Handles playing audio, allows audio to be enabled and disabled.
Enables audio
Disables audio
The inserted cartridge. Information about the cartridge can be queried
- title
- typeName
- romSize
- ramSize
- versionNumber
// For Link's Adventure:
console.log(gameboy.cartridge.title) // prints ZELDA
console.log(gameboy.cartridge.version) // prints 0
console.log(gameboy.cartridge.typeName) // prints MBC1_RAM_BATTERY
console.log(gameboy.cartridge.romSize) // prints 524288
console.log(gameboy.cartridge.ramSize) // prints 32768
System memory, including attached items like the cartridge
Uint8Array
containing all of the systems memory
Read the byte at a given address
Read a word at the given address
Writes a byte value to the address specified
Writes a word value to the address specified
Resets all memory back to default value
This is the internal input state used by the GameBoy itself. The controller and keyboard in turn set these booleans to true or false.
These can be used to programmatically set the input state. Useful for creating touch controls or any sort of programmatic input.
- isPressingUp: boolean
- isPressingDown: boolean
- isPressingLeft: boolean
- isPressingRight: boolean
- isPressingSelect: boolean
- isPressingStart: boolean
- isPressingA: boolean
- isPressingB: boolean
Used for managing controller input. Stores a number for the index of the controller to use, and then stores numbers representing the number of each button on the controller.
You can change these values to change which controller to use (if multiple are active) and what buttons to use.
- controller: number
- left: number
- right: number
- up: number
- down: number
- select: number
- start: number
- b: number
- a: number
Used for managing keyboard input. Stores the key code for the key to use.
So for instance the default value for left is 'ArrowLeft'
console.log(gameboy.keyboardManager.left) // Prints ArrowLeft
- left: string
- right: string
- up: string
- down: string
- select: string
- start: string
- b: string
- a: string
Loads a game cartridge into memory. Similar to inserting a cartridge into a GameBoy
Starts emulation. Similar to turning on the power switch of the GameBoy.
Set a callback that runs every time a frame is drawn. Passes an ImageData
object to the callback
that contains the current frame.
Set a callback that runs every time a cartridge's SRAM is written to.
NOTE! This is not passed any argument. You must retrieve the actual sram data by calling
getCartridgeSaveRam()
Returns an ArrayBuffer
with the contents of the cartridge's SRAM.
Combining this with setOnWriteToCartridgeRam
will allow you to persist save data when
a player saves. Here's an example using localforage:
// Will save a games save data with the key of it's title
gameboy.setOnWriteToCartridgeRam(() => {
localforage.setItem(gameboy.cartridge.title, gameboy.getCartridgeSaveRam())
})
Set the sram in a cartridge. This will let you load saved data. Here's an example with localforage that should be called after the rom data is loaded
gameboy.loadGame(rom);
const sram = await localforage.getItem(gameboy.cartridge.title);
gameboy.setCartridgeSaveRam(sram);
gameboy.run();