← All Atari Lynx projectsHard Drivin' LX · Atari Lynx
Fan project · Atari Lynx · LX version · work in progress

Hard Drivin' LX

Hard Drivin' (Lynx, 1993) with almost twice the frames

Same track, same physics, same lap times – and the original is one menu entry away.

The Lynx version of Hard Drivin' draws one picture per game step – three to four per second. LX keeps the original game logic and its pace, but lets the Lynx draw as many pictures as fit between two game steps: with a new 3D renderer, the camera and the cars predicted a step ahead, and distant objects reused within a step.

Work in progress · 1.7 to 1.9 times the frames, no download

Made by a human and an AI

The author

Picked the game after Steel Talons and set the rule: bit-identical logic, original tempo. Asked whether the game was built the wrong way, which led to LX; noticed that the first LX reacted late, which led to the prediction; wanted the original selectable in the game; drove the race in the video himself and decided what to keep.

Claude, the AI

Unpacked the cartridge, traced the main loop, buffers and interrupts, measured where the time goes, wrote the 256 KB layout, the faster logic, the new renderer, the LX scheduler with prediction and the reuse of distant objects in 65C02 assembler, the equivalence and image tests, the recorder for the drive, the video and these texts.

Using AI is no secret here. The AI did the analysis and the code, the human set the course, judged every build and decided what to keep – and the game itself is still Hard Drivin' by Atari Games, brought to the Lynx by John Sanderson for NuFX.

Why the original stutters

One picture per game step

Each step of the race runs the logic once and draws once. The 3D objects cost about 9.5 screen refreshes, the collision check of the logic another 5.4 – 18 to 20 refreshes per step in busy scenes, three to four pictures per second.

Reading through the cartridge

3.3 of those 5.4 refreshes are spent only on skipping through the cartridge to reach the collision data. The Lynx cartridge has no random access; the CPU has to read everything in between.

3D on a 4 MHz 8-bit CPU

A few dozen polygons per picture sounds little, but every corner is rotated and projected with 16-bit numbers, every polygon is cut into stretched sprites for the Suzy chip, and the models are read from the cartridge for every picture.

What LX changes

  • A 256 KB cartridge image: the original blocks sit in the lower half of each page, the LX code in the upper half, with its own boot code and swap areas that are loaded for the race and restored afterwards.
  • Faster logic, identical results: the collision files are opened directly instead of being skipped to, the rotation routines are compacted, the sorting of the visible objects is an insertion sort, the visibility list only looks at candidates near the camera.
  • A new renderer for the picture only: one matrix per object with the hardware multiplier, projection merged in, back-face test in model space, visibility without divisions, an own polygon path with near-plane and screen-edge clipping – about 30 % faster.
  • Pictures no longer tied to the game step: the logic runs at the original pace (a counting model sets every step's duration to the original's), and in between the Lynx draws as many pictures as fit.
  • Camera and cars predicted: every picture shows the camera and the seven traffic cars a step ahead along their last movement, so the picture is as up to date as on the cartridge (on average 267 instead of 270 ms old). LX SMOOTH interpolates instead – no corrections, but about a quarter of a second later.
  • Distant objects reused: the first picture after each game step computes everything; in the following pictures of that step, objects far away keep their finished sprites and are only moved along with their re-projected centre.
  • Your choice in the pause menu: ORIGINAL (one picture per step, like the cartridge), LX (the default) or LX SMOOTH.

Frames per second in the video

Part of the raceOriginalLXGain
Start3.46.51.91×
Drawbridge3.77.01.89×
Loop and jump3.86.71.76×
The whole drive (2:35, four crashes)3.96.71.72×

New pictures per second in emulator real time, the author's own drive replayed with the same inputs in both versions. In a test race with fewer objects LX reaches 12.8 on quiet stretches (original 6.0) and 5.6 in the busiest part (original 2.8).

Checked, not guessed

  • Game state compared with the original after every game step: identical over all test drives (autopilot races, two races in a row, pauses, the 625 steps of the drive in the video), apart from sound and time counters.
  • Pace: the whole drive takes 157.9 s in LX and 154.1 s on the cartridge – within about two percent.
  • Pictures checked: the ORIGINAL mode is pixel-identical to the previous build; reused distant objects were compared frame by frame with fully computed pictures – 72 to 85 % identical, otherwise one-pixel edges.

In the video

Status

  • LX is built and verified: renderer, faster logic, pictures decoupled from the game step with prediction, reuse of distant objects, tempo model, the choice in the pause menu. The race is playable from start to finish.
  • Tested in the trace emulator; real hardware not yet.
  • Close to the limit: what is left is the 3D work itself, and the 64 KB of RAM are full – about 600 bytes remain, in small gaps.
  • No download: work in progress, and like every LX version it is a modified cartridge image. A release would need a tool that patches your own image.

Controls

Pausepause the race, as on the cartridge
Up / Downin the pause: choose ORIGINAL, LX or LX SMOOTH

Everything else is as on the cartridge: steering left and right, A and B for brake and gas, Option 1 and 2 for the gears.

Good to know

The comparison video shows the author's own drive, recorded once and replayed in both versions: the original on the left, LX on the right, the same inputs and an identical game state on every step, in emulator real time with the original sound. Each part starts at the same game step on both sides.