I made a new Amiga Game - Zippy Race!

Project

Arcade-faithful port of the 1983 IRM arcade game Zippy Race to a stock Omega 500 (OCS), targeted to run on Kickstart 1.3 with 512 KB fast memory and minimal chip memory.

• Goal: full playable conversion including multiple difficulty loops, collisions, scoring, fuel, and stage progression.
• Target platform: Omega 500 (7 MHz 68000), Kickstart 1.3, 512 KB fast RAM with limited chip RAM.

Graphics & rendering techniques

• Display mode: 4 bitplanes (16 colors).
• Smooth horizontal scrolling:
  • Implemented by moving bitplane pointers over a large viewport bitmap (the Omega “scroll trick”) and wrapping to a duplicated bitmap.
  • Only one row of tiles is updated per scroll step to reduce work.
  • Viewport uses a 192 × 256 bitmap (stacked copies used for wrap-around).
• HUD and sprites:
  • HUD implemented with hardware sprites (four 16 × 256 sprites); updated only when needed to minimize CPU/GPU cost.
  • Player bike and front-view 3D section use hardware sprites as well—up to four sprites per motorcycle (two 16 × 32 sprites attached in 3D, totaling four hardware sprites per object).
  • Sprite indices: 0–3 for moving objects, 4–7 for HUD.
• Blitting traffic cars (32 × 32, 4 bitplanes) into a scrolling playfield required a robust overlap-handling approach to avoid corruption when objects overlap.

Triple-buffer / pristine buffer approach

• Implemented an Amiga-style triple-buffering: the tile engine maintains three full-screen bitplane buffers.
  • One buffer is kept pristine as a background reference and kept in sync with scrolling.
• Three-pass car rendering:
  1. Restore background from the pristine buffer.
  2. Update object positions.
  3. Draw all blitter objects.
• Benefits: avoids per-object background backups and overlap-restoration problems.
• Drawback: consumes large amounts of chip memory (three full bitplane buffers).

Memory management & compression

• Three large buffers consumed roughly 1/3 of chip RAM (~160 KB), requiring careful overall memory planning to fit the game on the 512 KB fast baseline.
• Memory manager:
  • Stores most assets in the 512 KB fast RAM.
  • Swaps only the stage-relevant tile sheets, maps, music, and assets into chip memory at stage load.
• Compression:
  • Assets are compressed to reduce bytes copied into chip RAM.
  • Decompression on a 68000 takes only a few frames; much faster on accelerators (e.g., O2).
• Result: the whole game fits within constraints, with ~60 KB chip RAM free for extra assets.

Traffic / AI systems

• No binary reverse-engineering of the original arcade code; traffic behavior was implemented from design and reference.
• Steering model:
  • Each car uses a lateral accumulator (drifts between −1 and +1) to produce smooth steering—no instant lane-snapping.
• Road center cache:
  • A 256-entry lookup table mapping each screen Y to road center X is built during the scroll routine.
  • Cars use this for pathfinding and lookahead, steering into curves before they arrive.

Tooling & asset pipeline

• Early tools: Personal Paint (tile art) and Power Crawler (tile maps).
• Custom editor: ZippyEd — a C++ application (ImGui, OpenGL, SDL3) that handles the full asset pipeline for Amiga-style tile maps. Key features:
  • IFFF tile sheet import/export and raw.io tile map format support.
  • Visual collision editor with surface overlays.
  • Duplicate tile detection and consolidation; tile-sheet compaction (remove unused tiles and remap).
  • Multi-tile clipboard paste; insert/delete rows in tile map and tile sheet.
  • Screen boundary overlays (256-pixel boundaries for arcade accuracy).
  • Palette editing, index remapping/swapping, and comparison against a reference palette (important to keep car colors consistent across stages).
• Workflow note: exporting frames from MAME and reusing tiles produced many duplicate tiles—ZippyEd automates consolidation to save memory and storage.

PAL / NTSC & timing

• Supports both 50 Hz PAL (256 scanlines) and 60 Hz NTSC (200 scanlines).
• Vertical layout adjustments made for bike position and other placements between modes.
• Game locks to the native refresh (50 Hz on PAL, 60 Hz on NTSC); timing was verified with the Engine9000 Amiga debugger.

Copper & color tricks

• Hardware sprite color limitations: sprites share color registers in pairs and only a few colors are available, complicating faithful arcade palette reproduction.
• Used the Copper (copperlist) to change color registers at specific scanlines to:
  • Simulate different colored HUD elements.
  • Create the flashing “one-up” text by toggling color registers every ~300 ms.

Performance & constraints

• Minimize per-frame updates: HUD elements are updated only when changed; decompression and heavy data copies are performed between stages.
• Copy/decompress speed is critical on the 7 MHz 68000 Omega; compression reduces copy traffic and improves load times.
• The triple-buffer approach is effective for blitter overlap problems but is memory-expensive (common historical trade-off on Amiga).

Distribution & availability

• The finished game is available free on itch.io.
• Runs on a stock Omega 500 with the specified memory configuration; benefits from accelerators but does not require them.

Practical takeaways / tutorials implied in the video

• How to implement smooth pixel scrolling on OCS Amiga via bitplane pointer movement and bitmap wrap-around.
• Triple-buffer / pristine-buffer workflow to solve blitter overlap problems on scrolling backgrounds.
• Road center cache lookup technique for simple, effective pathfinding and curve anticipation.
• Memory management pattern: staging assets between fast RAM and chip RAM plus compression/decompression for constrained systems.
• Using the Copper to change registers mid-frame for HUD color variation and simple animations.
• Building dedicated tooling (ZippyEd) to optimize tile sheets, reduce duplication, and manage palettes for 16-color OCS targets.

Main speakers & sources

• Video author / developer: first-person narrator and creator of the Amiga port and ZippyEd (primary speaker and source).
• Original arcade: Zippy Race by IRM (IRM M52 hardware, dual Z80s) — referenced as the source game.
• Tools & references used: MAME (frame capture), Engine9000 (Amiga debugger), Personal Paint, Power Crawler, and the custom ZippyEd tool.