Mario Bros.

Embedding

Mario Bros. is Nintendo's 1983 arcade machine: a Zilog Z80 main CPU driving a 256×224 raster, the sequel-of-sorts to Donkey Kong that pairs Mario with his brother Luigi as plumbers stomping pests in the sewers. This build runs the original program ROMs on DrGoldfire/Z80.js (MIT), an instruction-at-a-time Z80 interpreter, wrapped in a hand-written model of the Mario Bros. board (memory map, tile/sprite video, the Z80-DMA sprite copier and the input latches). The graphics-ROM decode, colour-PROM palette, Z80-DMA and renderer are ported from MAME's nintendo/mario.cpp.

Boot. The program ROMs are loaded at 0x0000–0x5FFF and 0xF000–0xFFFF and the Z80 starts at 0x0000, dropping straight into the attract-mode demo:

var m = new Mario();      // decodes gfx ROMs + PROM, wires the Z80 and the Z80-DMA
m.reset();                  // PC = 0x0000 -> attract mode

The machine object. Mario exposes the whole cabinet as ordinary methods, so the host page can render, step and inject input:

Video. Each animation frame the loop runs one field's worth of Z80 cycles, pulses the NMI, then re-renders: the background is a 32×32 tilemap of 8×8 2bpp characters (video RAM at 0x7400) scrolled vertically by the 0x7D00 register, and the sprites are 16×16 3bpp objects read from the list at 0x7000. Colour comes from a single 512×8 palette PROM (the inverted Nintendo half, like Donkey Kong), banked by the 0x7E83 latch; a graphics bank at 0x7E80 selects the character set.

Debugger integration

The debugger drives a host-owned run loop: because the Z80 interpreter runs one instruction at a time in JavaScript, the loop can pause, single-step and check breakpoints between any two instructions — no changes to the CPU core are needed.

window.EMU_BOOT.transport exposes the controls the shared debugger calls:

• pause / resume / isPaused — stop or restart the requestAnimationFrame loop.
• stepInsn(n) — call the core's stepInsn() exactly n times and redraw, so a single step advances the PC by one Z80 instruction.
• step(n) — advance n whole 60 Hz fields (each with its NMI).
• breakpoints — a Set of PC values. When it is non-empty the loop reads the Z80's PC (via getState()) before each instruction and pauses before executing an address in the set; when empty it runs a full field at speed, so an idle debugger costs nothing.
• watchpoints — the machine's RAM-write path (shared by the Z80 and the Z80-DMA copier) is wrapped, so a write to a watched address sets a flag that pauses the loop after that instruction. The watch Set is injected with setWatchSet().

The plug-in (mariobros-debug.js) reads these hooks and calls EmuKit.defineMachine with the full Z80 register file (AF/BC/DE/HL and their bytes, IX/IY, SP, PC, I, R and the S Z H P/V N C flags), each read live from getState() and written back through setState(). It reuses the shared z80 disassembler (/debugger/src/cpus/z80.js) for the hex/disasm views over the 64 KB bus, the 24 KB low program ROM, the video RAM (rendered as tiles) and the object/sprite RAM. Because a watched address must be caught inside the Z80-DMA block copy as well as on plain CPU stores, the watchpoint check lives in the shared wrMem helper the DMA transfer also calls.

Architecture

The Mario Bros. board (Nintendo, 1983) is a single Zilog Z80 main CPU with Nintendo's tile-and-sprite video and a Z80-DMA chip that copies the sprite list, all modelled here as plain JavaScript hanging off Mario:

• CPU — a Z80 interpreter. 0x0000–0x5FFF and 0xF000–0xFFFF are program ROM; 0x6000–0x77FF is RAM, with the sprite/object list at 0x7000 and the video RAM at 0x7400.
• Video — a 32×32 background tilemap of 8×8 2bpp characters, scrolled vertically by 0x7D00, plus 16×16 3bpp sprites with per-object X/Y flip. A single 512×8 colour PROM (the Nintendo inverted half) supplies the 256-colour palette; the 0x7E80 graphics bank and 0x7E83 palette bank latches select the character set and colour table.
• Z80-DMA — a Zilog Z80-DMA chip, programmed through OUT (0),A, block-copies the sprite attributes into the object list each field when the game raises its READY line via the 0x7E85 latch bit. The register-write state machine and the memory-to-memory transfer are modelled after MAME's driver.
• Input — the joystick (left/right), jump and start buttons are read on 0x7C00 (IN0), coin on 0x7C80 (IN1), the DIP switches on 0x7F80.
• Interrupt — a single NMI per field at vertical blank, gated by the 0x7E84 mask latch, is the timing the game depends on.
• Sound — the real cabinet uses an M58715 (i8039) with sample ROMs and a discrete/netlist analogue section; this build has no audio, so the sound-latch writes are ignored.