Summary of "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.