The Game That Couldn't Be Won

After Flock shipped — the Amiga sheep game from the last two posts — I did something that felt responsible at the time: I held the other three platforms’ first games up against it. Gloaming on the Spectrum, Starfield on the C64, Dash on the NES. All three finished months ago, all three verified, all three live.

The audit came back with the same list for each: silent title screen, no win fanfare, no lose sting — and on two of the three, nothing to win. Starfield’s waves repeat forever at the same speed. Dash’s coins, it turned out, counted for nothing at all. You could collect all three and the game would shrug and keep scrolling its one obstacle at you until you died.

Fine. Fixable. A “last yard” unit for each game: a win condition, a difficulty curve, a tune, two stings. The kind of work Flock had just taught me to see. I budgeted an afternoon per platform.

Dash took the afternoon, and then it took another one, because Dash could not be won. Not “had no win condition” — I was adding one of those. Could not be traversed.

One pixel

Dash is a tiny platformer: a runner, a platform, a wall, three coins, a spike pit. The new win condition was honest and small — collect all three coins, the level turns over, everything gets faster. To capture it for the unit’s screenshots, I scripted a perfect run: frame-counted joystick inputs driving the real game, the way I’d captured everything in Flock.

The script walked right, jumped the spike pit, and died. Adjusted the timing. Died. Measured the actual jump arc frame by frame instead of trusting my mental model of the physics: the jump carries the runner fifteen pixels. The spike pit is sixteen pixels wide.

Sixteen units of curriculum. Every unit’s code assembled cleanly, ran correctly, was screenshotted and verified. And the right half of the level — the platform coin, the ground coin, the wall — had never been visited by anyone, because it could not be reached. Every screenshot in sixteen published units was taken on the left half of the level. The game’s evidence was curated by the same defect it was hiding.

Nobody lied. Each unit verified exactly what it claimed: this sprite moves, this tile collides, this sound plays. All true. The game just didn’t add up to a game, and no amount of unit-scale verification would ever have noticed, because verification only answers the questions you ask, and we had never asked the game for anything. We’d inspected it. We’d never wanted something from it.

Three lives in three frames

Wanting things finds bugs the way inspection can’t, and it wasn’t done with me. With the spike narrowed to one tile and the route finally walkable, the script died again — strangely. One moment three lives, the next moment a game over, with no visible disaster in between.

Frame-by-frame: the runner died beside the obstacle, respawned at the start point, and the obstacle — still sliding through the respawn point — killed it again on the next frame. And the next. Three lives in three frames. Any human player who died in the wrong spot would have watched their whole game evaporate in a twentieth of a second, and I doubt they’d have been able to say what happened.

The fix is as old as arcades: a grace window, a second of invulnerability after every respawn, with the runner blinking so the player can see the rule protecting them. The interesting part isn’t the fix. It’s that this bug had also been sitting there through sixteen verified units, waiting for someone to want something — in this case, to want to survive.

The silent band

One more, because it’s the punchline’s punchline. The new title tune — a tiny sequencer playing Camptown Races on the NES’s pulse channel, because what else would a game called Dash play — produced silence. The code was right. I checked it the way you check code you wrote twenty minutes ago and then the way you check code you suspect of betrayal, and it was right both times.

The culprit was one register write: $08 to the sweep unit, the canonical “sweep off” idiom that half the NES software ever written uses. My emulator’s sweep unit computes the disabled sweep’s target period a little too literally, decides the result is out of range, and mutes the channel. A bug — filed, and worked around with an equally correct $00. But note what found it: not the emulator’s test suite, not the curriculum’s verification checklist. A game that wanted to sing.

The gate

So there’s a new rule in the project now, written into the definition of done where it can’t be unseen: before any game is called complete, a scripted run has to drive it — real inputs, real game logic — all the way to the win. The script gets checked in next to the game, so the claim is repeatable by anyone, forever. And the loss path gets driven too, because both endings deserve to be seen and heard, not just the happy one.

The modern-software people in the audience recognised this three paragraphs in: unit tests versus acceptance tests, the oldest distinction in the book. Verified parts, unverified whole. I knew that distinction professionally for years and still shipped a platformer with an unjumpable pit, because knowing a lesson and being unable to avoid it are different things — the second one only comes from meeting it. The 198x machines keep doing this to me: taking something I’d have nodded along to in a conference talk and making it sixteen pixels wide, four months old, and mine.

Last time I said a machine simple enough to see all the way down still has floorboards that move. This time the floorboards were fine. I’d just never walked on them.

---

Dash is the NES track’s first game; the unit that makes it winnable — and confesses everything above — is unit 17, “The Last Yard.” The win-by-script rule is now part of the project’s shipping bar, where it sits with a drift warning attached: if the win run is too hard to choreograph, that’s information about the game, not the gate.