Kung-Fu Master

Embedding

Kung-Fu Master is Irem's 1984 arcade machine and the first game on the M62 board: a single Zilog Z80 main CPU at 3.072 MHz (18.432 MHz / 6) that runs the whole game. This build is a from-scratch JavaScript emulation whose board is a port of MAME's irem/m62.cpp and irem/m62_v.cpp. The Z80 core is Molly Howell's MIT Z80.js, reused unchanged. 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 and sprite graphics and the six colour PROMs, resets the Z80 and starts the loop; the board comes up in attract mode:

var m = new KungFuMaster({ canvas, romBase, manifest });
m.boot();                              // fetch ROMs, decode GFX + PROMs, reset the Z80, run
// each animation frame runs one 60Hz field of the 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 64×32-tile background of 8×8 three-bit characters with per-row horizontal scroll (the top six rows stay fixed for the score line), and up to 32 three-bit 16×16 sprites whose height is one, two or four tiles as set by a small height PROM. A two-level priority (from the tile colour code, plus the fixed top rows) lets some background tiles draw in front of the sprites, so Thomas walks behind the temple pillars. Colour is fixed in six 256×4 PROMs -- three for the characters and three for the sprites, one per gun -- decoded through a resistor-network DAC into a 256-entry character palette and a 256-entry sprite palette; because the raw palette is dark, its contrast is amplified once at boot. The renderer draws the 256×256 raster directly (the M62 is a horizontal 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 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, each honouring the one mode-1 vblank interrupt (RST 38h).
• 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 exposes a whole-core getState()/setState(); the vendored copy adds two cheap 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 program ROM, sprite RAM, the tile/colour RAM and work RAM without touching the port-mapped input latches, so inspecting memory never disturbs the machine. 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 M62 board (Irem, 1984) is a single-Z80 design with Irem's tile/sprite hardware, run on a horizontal monitor:

• Main CPU -- Zilog Z80 at 3.072 MHz (18.432 MHz / 6). Program ROM at 0x0000–0x7fff, the background horizontal-scroll latch at 0xa000/0xb000, sprite RAM at 0xc000–0xc0ff, the interleaved tile-code and tile-colour RAM at 0xd000–0xdfff (codes in the low half, colours in the high half), and work RAM at 0xe000–0xefff. This is the CPU the debugger targets.
• Ports -- input and dip switches are Z80 port reads: 0x00 system (coin / start), 0x01 player 1, 0x02 player 2, 0x03/0x04 the two dip banks. Port writes send the sound command (0x00) and the screen-flip / coin-counter latch (0x01).
• Interrupts -- the Z80 runs in interrupt mode 1 and takes a single vblank interrupt each field, vectoring through RST 38h.
• Background -- a 64×32 map of 8×8 three-bit tiles (code extended by two colour bits, 32 palettes, per-tile X-flip). Horizontal scroll is applied per tile row; the top six rows are held fixed for the score line. A per-tile priority category selects whether a tile draws behind or in front of the sprites.
• Sprites -- up to 32 three-bit 16×16 sprites from the 0xc000 list; a 32-entry height PROM gives each sprite a height of one, two or four tiles, and the hardware handles X/Y flip and a 512-wide coordinate space.
• Palette -- there is no palette RAM. Six 256×4 PROMs (three for characters, three for sprites, one per colour gun) are decoded through a resistor-network DAC into a 256-entry character palette and a 256-entry sprite palette.

The Irem M6803 sound board is omitted here -- audio is optional -- and the graphics ROMs are decoded to one-byte-per-pixel tiles once at boot.