1942

Embedding

1942 is Capcom's 1984 arcade machine: a Zilog Z80 main CPU at 3 MHz that runs the game, and a second Zilog Z80 sound CPU at 3 MHz driving two AY-3-8910 PSGs. This build is a from-scratch JavaScript emulation whose board is a port of MAME's capcom/1942.cpp and 1942_v.cpp. Both Z80 cores are Molly Howell's MIT Z80.js. The whole board runs from a host-owned loop, so the debugger can pause and single-step it.

Boot. Constructing the machine fetches the ROMs, decodes the character / tile / sprite graphics and the six colour PROMs, resets the main Z80 and starts the loop; the board comes up in attract mode:

var m = new C1942({ canvas, romBase, manifest });
m.boot();                              // fetch ROMs, decode GFX + PROMs, reset the Z80, run
// each animation frame runs one 60Hz field of the main Z80, then draws the screen

The machine object. Everything the host and debugger need is a field or method on the machine:

Video. The screen is a scrolling 32×16 background of 16×16 three-bit tiles (column-scan, with a scrambled tile-index map and a four-way palette bank), an 8×8 two-bit character foreground for the score and text (transparent pen 0), and up to 32 four-bit 16×16 sprites that can be one, two, four or sixteen tiles tall. Colour is fixed in six PROMs: three 256×4 RGB PROMs give 256 master colours, and a char / tile / sprite lookup PROM maps each layer's pens into them. The renderer draws a 256×224 raster and rotates it (ROT270) to a 224×256 portrait, like the upright cabinet.

Debugger integration

Because the whole board is ordinary JavaScript and the host owns the run loop, the debugger's controls need no changes to the CPU core: the loop can pause, single-step and check breakpoints between any two instructions. window.EMU_BOOT.transport maps the shared debugger onto the main Z80:

• pause / resume / isPaused -- stop or restart the requestAnimationFrame loop.
• stepInsn(n) -- run exactly n Z80 instructions through the core's run_instruction() entry.
• step(n) -- advance n whole 60 Hz fields of the main Z80 (plus the sound Z80), honouring the two mode-0 interrupts a field.
• breakpoints -- a Set of PC values checked before each instruction; a match pauses before the instruction runs.
• watchpoints -- the Z80's memory-write path flags a hit when a watched address is written, and the loop pauses on it.

The stock Z80.js keeps its registers in a closure and only exposes a whole-core getState()/setState(). To make the debugger's live register window cheap, the vendored core is given two extra hooks -- get_pc() and set_pc() -- so the run loop can read PC before every instruction (for breakpoints) without allocating a state object, and the machine wraps getState/setState in focused getReg/setReg/getFlag/setFlag helpers that the plug-in binds to. Memory reads use the machine's side-effect-free dbgRead, which returns work RAM, the video RAMs, the fixed and banked program ROM and the input ports without side effects, so inspecting memory never disturbs the sound latch or the bank register. The Z80 disassembler is the shared decoder at /debugger/src/cpus/z80.js -- reused unchanged, since the Z80 is already a first-class debugger CPU.

Architecture

The 1942 board (Capcom, 1984) is a pre-CPS design built from two Z80s and Capcom's early tile/sprite hardware, run on a rotated (ROT270) monitor:

• Main CPU -- Zilog Z80 at 3 MHz (12 MHz / 4). Fixed program ROM at 0x0000–0x7fff, a 16 KB banked ROM window at 0x8000–0xbfff (four banks selected at 0xc806), the input ports at 0xc000–0xc004, the sound latches / scroll / control / palette-bank registers in the 0xc800 page, sprite RAM at 0xcc00, character RAM at 0xd000, background RAM at 0xd800, and work RAM at 0xe000. This is the CPU the debugger targets.
• Interrupts -- the main Z80 takes two mode-0 interrupts each field: RST 08h near scanline 109 and RST 10h at vblank (scanline 240); the vector is the RST opcode placed on the data bus.
• Sound CPU -- a second Z80 at 3 MHz with 2 KB RAM, fed one-byte commands through two latches the main CPU writes at 0xc800/0xc801, taking a periodic interrupt four times a field. It drives two AY-3-8910 PSGs. (Audio is stubbed here; the Z80 still runs so the latch handshake stays live.)
• Tilemaps -- an 8×8 two-bit character foreground (score / text, transparent pen 0) and a scrolling 16×16 three-bit background. The background is a 32×16 column-scan map whose tile indices are scrambled as (i&0x0f)|((i&0x1f0)<<1), with a four-way palette bank set at 0xc805 and per-tile X/Y flip.
• Sprites -- up to 32 four-bit 16×16 sprites read from 0xcc00–0xcc7f; two attribute bits give a sprite a height of one, two, four or sixteen tiles.
• Palette -- there is no palette RAM. Three 256×4 PROMs (one per gun, decoded through a resistor DAC) give 256 master colours; a char, a tile and a sprite lookup PROM map each layer's pen (offset into the char / tile / sprite palette bank) to one of those colours.

A control register at 0xc804 holds the screen-flip bit, the sound-CPU reset line and the coin counter; the graphics ROMs are decoded to one-byte-per-pixel tiles once at boot.