Elevator Action

Embedding

Elevator Action is Taito's 1983 arcade machine on the Taito "SJ" board: a Zilog Z80 main CPU at 4 MHz that runs the game, a second Zilog Z80 sound CPU driving four AY-3-8910 PSGs and an R-2R DAC, and a 68705 (M6805) security MCU. This build is a from-scratch JavaScript emulation whose board is a port of MAME's taito/taitosj.cpp and taitosj_v.cpp. The main Z80 core is Molly Howell's MIT Z80.js — the same core reused from the emulators.org 1942 build. 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, wires up the layer-priority PROM, resets the main Z80 and starts the loop; the board comes up in attract mode:

var m = new ElevatorAction({ canvas, romBase, manifest });
m.boot();                              // fetch ROMs, reset the Z80, run the loop
// 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 three independent scrolling 32×32 playfields of 8×8 three-bit characters plus a list of up to 32 four-bit 16×16 sprites. Unusually, the tiles are not in ROM: the program copies graphics from an 8 KB gfx ROM (read one byte at a time through a pointer register) into a 12 KB character RAM, and the tilemaps index that RAM, so the pixel data is decoded live each frame. There is no palette ROM either — 64 colours are held in RAM and turned into RGB by a 3-bit-per-gun resistor DAC. Layer and sprite ordering is chosen every frame from a 256×4 priority PROM. The renderer draws the 256×224 raster upright (ROT0).

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, honouring the one vblank interrupt 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 carries two extra hooks — get_pc() and set_pc() — so the 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 the plug-in binds to. Memory reads use the machine's side-effect-free dbgRead: it returns work RAM, the three playfield RAMs, the sprite RAM, the character (tile-pixel) RAM, the fixed and banked program ROM and the input ports without side effects, and in particular it does not advance the graphics-ROM read pointer the way a real read of 0xd404 would, so inspecting memory never disturbs the game. 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

Elevator Action (Taito, 1983) runs on the Taito "SJ" system, an upright (ROT0) board built from two Z80s and Taito's RAM-based tile/sprite hardware:

• Main CPU — Zilog Z80 at 4 MHz (8 MHz / 2). Fixed program ROM at 0x0000–0x5fff, a banked 8 KB ROM window at 0x6000–0x7fff, work RAM at 0x8000, the 12 KB character (tile-pixel) RAM at 0x9000–0xbfff, three 32×32 playfield RAMs at 0xc400 / 0xc800 / 0xcc00, per-column vertical-scroll RAM at 0xd000, sprite RAM at 0xd100, the 64-colour palette RAM at 0xd200, and the video / scroll / colour-bank / bank-select / gfx-pointer registers and the input ports through the 0xd300–0xd600 pages. This is the CPU the debugger targets.
• Interrupts — the main Z80 takes a single maskable interrupt each field at vblank (mode 1, so RST 38h).
• Playfields — three independent 32×32 tilemaps of 8×8 three-bit characters, each with a horizontal scroll and a per-column vertical scroll, drawn from character RAM the program fills at run time out of the gfx ROM.
• Sprites — up to 32 four-bit 16×16 sprites from a two-page sprite RAM, with per-sprite X/Y flip and a global screen flip, drawn with horizontal wraparound.
• Priority & collision — a 256×4 PROM turns the priority register into a back-to-front order for the three layers and the sprites; dedicated hardware reports sprite/sprite and sprite/layer collisions into four collision registers the game polls.
• Palette — no colour ROM: 64 nine-bit colours live in RAM and are decoded through a 3-bit-per-gun resistor DAC.
• Sound & protection — a second Z80 with four AY-3-8910 PSGs and an R-2R DAC, and on factory boards a 68705 (M6805) security MCU. This build uses the protection-patched bootleg program, so the MCU is stubbed and audio is not synthesised; the main CPU never blocks on either.