Tempest

Embedding

Tempest is a MOS 6502 at 1.512 MHz driving the Atari Analog Vector Generator (AVG) -- the colour cousin of the Asteroids DVG. There is no framebuffer: the AVG reads a display list of lines from the memory it shares with the CPU and steers a colour beam to draw the tube. A bit-slice math box co-processor does the tube's projection maths. This build vendors a self-hosted machine (no CDN): a JavaScript port of Mike Chambers' public-domain Fake6502 core, our AVG + math box + POKEY-pot model, and the original Atari ROMs, driven from a host-owned loop so the debugger can control it.

Boot. The five 4 KB program ROMs load at $9000–$DFFF (the top part mirrored to $F000 so the reset/IRQ vectors resolve) and the 4 KB vector ROM at $3000; the 6502 starts from $FFFC ($D93F) and drops straight into attract mode:

var m = new TempestMachine();   // loads ROMs, builds 6502 + AVG + math box
m.reset();                        // pulls the reset vector at $FFFC
// one field: 4 IRQs across ~25200 cycles, then draw the AVG list
for (var s = 0; s < 4; s++) { irqLine = true; runCycles(6300); }
m.renderTo(ctx, W, H);

The machine is plain objects. Everything the host and debugger need is a field or method on the machine or its CPU:

Video. Each field the loop runs one display's worth of 6502 (four IRQ slices), then walks the AVG display list the game left in vector RAM and strokes the colour lines to the canvas, one colour per STAT instruction through the 16-entry colour RAM at $0800.

Debugger integration

The debugger drives a host-owned run loop: because the 6502 interpreter runs one instruction at a time, 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 cpu.step() exactly n times and redraw, so a single step advances the PC by one instruction.
• step(n) -- advance n whole display fields (each with its four IRQs).
• breakpoints -- a Set of PC values. When non-empty the loop runs instruction-by-instruction and pauses before executing a watched address; when empty it runs a field at speed, so an idle debugger costs nothing.
• watchpoints -- the machine's memWrite is the single write path; it flags a hit when a watched address is written and the loop pauses on it. Because the 6502's registers and the whole 64 KB map are ordinary JavaScript, registers are read and written directly and memory is exposed side-effect-free.

The plug-in (tempest-debug.js) reads these hooks and calls EmuKit.defineMachine with the 6502 register set bound to the shared mos6502 disassembler, four memory chips (the 64 KB bus, the program ROM, the AVG vector RAM display list and the vector ROM shape library), and the on-screen control panel. A neat trick for a vector machine: point the Vector RAM hex window at $2000 and single-step -- you can watch the game build the frame's line list word by word before it strobes $4800.

Architecture

Tempest has no video RAM in the usual sense. A single MOS 6502 builds a list of vectors in the 4 KB it shares with the AVG, then strobes it; the AVG is a stack machine that reads that list and draws colour lines on an X-Y monitor. Modelled here as plain JavaScript objects:

• CPU -- a port of Fake6502 (NMOS 6502), reaching memory only through the machine's memRead/memWrite, so the bus and I/O live in one place.
• AVG -- the Analog Vector Generator: it walks the display list as opcodes -- VCTR long vector, SVEC short vector, STAT colour + brightness (with Tempest's sparkle bit), SCAL scale, CNTR recentre, JSRL/RTSL call/return, JMPL, HALT -- accumulating colour line segments. Colours come through the 16-entry colour RAM at $0800; Tempest swaps X and Y (the monitor is rotated).
• Math box -- a bit-slice (AM2901) co-processor with 16 signed-16-bit registers doing the tube's multiply / project / divide / distance / window maths, poked at $6080-$609F and read back at $6060/$6070. Ported here as direct arithmetic (Eric Smith's high-level model).
• I/O -- IN0 (coins, tilt, VG-halt, 3 kHz clock), two DIP banks, and the two POKEYs whose analog "pot" lines carry the spinner (4-bit encoder on POKEY 1) and the fire / superzapper / start buttons (POKEY 2); sound is stubbed. An EAROM latch stands in for the high-score store.
• ROMs -- 20 KB of 6502 program (five mask ROMs) and 4 KB of vector ROM holding the tube, letters, digits and shapes the display list calls into.

The timing the game truly needs is its four-per-frame IRQ; the host loop reproduces exactly that, four IRQ slices per ~60 Hz field, and renders the AVG list at the end of each field.