We shipped a win condition that was geometrically impossible

Jellygon drops soft polygon pieces into a cup. Matching shapes fuse, each tier adds a side, and two tier-7 decagons create the final hendecagon burst. We had tuned the sizes, run stability soaks, and built the celebration. Then someone asked a less glamorous question: was there enough room in the cup to make the final shape?

There was not. The ending was not merely difficult. With the original piece growth, the required late-game inventory could not pack into the available space. No careful player was going to discover that for us.

The area calculation was right and the conclusion was wrong

Piece size follows scale = 0.62 · g^tier. The original growth factor was g = 1.26. Measuring the spawned polygons rather than estimating from their bounding circles gave us this late-game inventory:

The cup is 8.4 units wide with 9.8 units of usable height, or 82.3 units of area. One piece from every tier from 0 through 7—the worst inventory held while building upward—occupies 71.6, about 87 percent of the cup. Tight, but not obviously impossible. Soft pieces pack better than rigid ones, and a merge removes part of the pair's combined area.

The missing detail was the shape of the bottleneck. To build the second tier-7 piece, the board must hold the first tier 7, with area 28.6, plus two tier-6 pieces at 17.7 each. That is 64 of 82.3 units in three large, rounded polygons before counting the smaller working pieces required to build them. Total area was not the binding constraint. Three awkward pieces in one narrow cup were.

Twelve games found the wall immediately

Paper geometry could identify the suspicious step, but it could not settle a soft-body packing problem. We wrote a simple automated player that used the same game rules and physics as a normal run. It aimed for the highest matching piece and otherwise parked shapes in size-based slots. One game took about two seconds.

The first experiment was only 12 games across three variants. Every run reached tier 7 in roughly 45 drops. Every run then lasted another 10–20 drops and died while trying to build the second tier 7. Zero reached the final shape.

That was exactly the geometric bottleneck, now appearing in play.

We widened the test to 11 strategies across 100 fixed sequences each. The strategies ranged from orderly match targeting to noisy aim, wall stacking, center stacking, random placement, and deliberately abusive timing. Checks ran throughout each game for unstable velocities, invalid positions, pieces leaving the cup, and rejected merge storms.

At the original growth factor, the result was unanimous: zero wins and a tier distribution piled against tier 7. The celebration existed. The game could not reach it.

The first smaller setting was still impossible

The honest fix was the growth ratio. Reducing it makes later tiers smaller relative to the cup without changing the rules or granting a special-case win.

We moved from 1.26 to 1.24 and expected that to be enough. It was not: zero wins in 200 games. The same simplified geometry that had missed the original problem also overestimated the first fix.

At 1.22, the first wins appeared. The first strategy through was the noisy one, which adds aim error. The deterministic players kept arranging themselves into similar blocked boards; small placement variations explored layouts they did not.

One success only proved the door was open. It did not say how wide.

Seven settings turned difficulty into a curve

We exposed the growth factor to native test builds and swept seven values. Four strategies played 50 fixed sequences at each value: 1,400 games in about 30 minutes on a laptop, split across seven jobs.

The curve is monotonic but not linear. Around the shipped value, a change of 0.01 moved the automated win rate from 4 to 8 percent, and the next step reached 21 percent. A casual change of 0.05 would not be a touch of polish. It would produce a different game.

This does not turn the bot rate into a human difficulty target. The automated players do not plan several pieces ahead, remember earlier drops, or use every player action. Human play data still has to decide whether the shipped setting is too hard. The sweep tells us what one adjustment is likely to do after that data arrives.

The same method found a bug in a different game

We ported the full-game testing approach to Jelly48, our soft-body version of 2048, using swipe policies instead of drop positions. Across 350 games, the checks found velocity spikes between 47 and 96 units per second. The pieces visibly snapped when a packed board pinched them under brisk input. Steady play stayed below roughly 34.

The existing regression test lasted 25 seconds. The first spikes appeared around the fourth simulated minute, so the short test never entered the state that caused them.

Two details made the finding useful instead of merely alarming:

1. Jelly48 uses a fixed spawn sequence. Replaying the same inputs on the last deployed engine and the current version produced identical output, showing that the spike was already present rather than introduced by recent work.
2. Jellygon already used a velocity cap for pile ejections. Setting Jelly48's cap to 40—above the normal ceiling and below the observed failures—cleared the five worst sequences. A 60-game confirmation sweep produced no flags.

The important test was not a tiny reproduction constructed after the bug was known. It was a complete game allowed to become old, crowded, and rude.

What we kept from the experiment

A win condition is a testable claim. If a game has a hardest achievement, an automated player does not need to be brilliant to reveal that the geometry never permits it.

Measure a curve rather than defending one constant. The 1.22 result matters because the neighboring values show how sensitive it is. A single win rate without that context would invite another guess.

Different bad players find different good bugs. Noisy aim reached a valid board before the tidier strategies. Aggressive input found the Jelly48 spike. Strategy diversity mattered more than making every automated player look clever.

Long games cover states short tests miss. A 25-second check and a four-minute failure are tests of different systems, even when they start from the same board.

Determinism turns suspicion into a replay. Fixed sequences let us compare versions, preserve failures, and rerun the exact bad game after a fix.

The original question was whether two large pieces could meet inside a cup. It left us with something more useful than a yes: a measured way to change the answer without guessing.