R-Type, the 1987 arcade program, running on Neo Geo hardware — with a two-player co-op mode it never had

1. Translate the program, don't rewrite it

A translator (Python, built on the Capstone disassembler) walks the original's code from its interrupt handler and main loop and emits 68000 assembly for every instruction it reaches: about 21,700 x86 instructions. The x86 flags live in the 68000's condition codes, with a liveness pass that saves and restores them only where a later instruction would need them. Segment registers, far calls, string instructions, BCD arithmetic and the V30's own extra instructions are all covered.

The translated code runs against a byte-exact copy of the original's memory: its program ROM image, 16 KB of work RAM, sprite RAM and palette RAM. Every 16-bit word is stored byte-swapped so that the big-endian 68000 reads the little-endian game's words as single moves.

2. Redraw what the game sends to its video chips

The original writes a 128-entry sprite list, two 64×64 tilemaps and a palette. On the Neo Geo:

• Sprites become hardware sprites, one per 16-pixel column of each entry, placed exactly where the M72 would put them.
• Each tile layer is 32 column sprites of 32 tiles each: the whole 512×512 tilemap sits in hardware, so scrolling only moves the columns. A Neo Geo tile is one 2×2 group of the original's 8×8 tiles, found in a table built from the stage maps and a recording of the original.
• The HUD band (score, beam gauge) goes to the Neo Geo's fix layer.
• Palettes map one to one, with merged palettes generated for tile groups that mix palette slots.

Translated code reports what it wrote, so changed tile groups are queued and redrawn in the next VBlank, and only then.

3. Keep the arcade's frame structure

As on the board, the original's start-up code runs once, its main loop then pops tasks from its own queue forever, and the Neo Geo VBlank interrupt runs the original's interrupt handler wherever the main loop happens to be. Long tasks such as screen fills and map streaming span several frames exactly as they did in the arcade. The game gets every Neo Geo frame (59.19 Hz against the original's 55 Hz), so it plays a little faster but scrolls evenly.

4. Hand-write only the hot spots

Translated code is slower than native code, so the few shared routines every object calls each frame were rewritten in 68000 by hand from a description of what they do: the hit tests (with a broad phase that rejects most candidates before the original's chain of tests), the sprite piece writers, the palette fader, the tilemap clears and the map block streamer. The interrupt handler's object loops are native too, with a per-slot cache of each object's handler address. Everything else is the translation.

What the mode adds

• A 2P start from the title begins a co-op game. Player 2 can also join a running game with a credit.
• A lost ship flies back in where the game is; the game only rewinds to a checkpoint when both players are out.
• Both scores and ship counts on the HUD, player 2's in crimson; a blinking PRESS START while a player is out.
• 1P and 2P tags over the ships at every fly-in, for three seconds.
• Enemies that aim at "the player" are given the nearer ship.

How it stays the original's code

No player logic was rewritten. Each frame the handler runs player 1's code, then the port swaps in player 2's copy of the player objects and runs the same code again. Hooks at a handful of addresses make the original's "the player" mean the right ship: hit tests check both, items go to the one that touched them, and the HUD draws two scores.

Frame-exact comparison against the arcade

A harness records 300 frames of the original in MAME (its memory at one VBlank interrupt, then every port access per frame) and replays them through the translated code on the emulated Neo Geo. Each frame, 16-bit checksums of every 256-byte block of work RAM and both tilemaps are compared with the original's. Result: all 300 frames identical.

Checks on the hand-written routines

Each native routine keeps the original's exact memory, register and flag results, and is tested against its translated counterpart. The hit-test broad phase runs both ways in a check build and counts disagreements: none in 3,900 frames of play. A sprite check rebuilds the Neo Geo's sprite memory from a write tap and compares every object sprite against a model of the sprite list after every frame: 0 mismatches in about 715,000 checks.

Scripted play

Automated runs play attract mode and games in MAME, checking that nothing untranslated ran, that coins and starts worked, that fewer than 10% of frames ran late, and that music and effects played. Every stage was also recorded on its own to check the tile layers against the original's maps.

Real hardware path

The cartridge image runs under MAME's Neo Geo MVS emulation and on a JAMMA cabinet through Recalbox. It uses only documented Neo Geo features; no flash cart or custom hardware is involved.