Bomberman: Simple Rules, Perfect Chaos.
What the Purest Multiplayer Ever Made Teaches Us

Your first Bomberman match ends in three seconds. You place a bomb, fail to move in time, die. Your second match lasts five seconds: you've figured out you need to run, but not where. The third match is when the game clicks. Because the third match is when you start watching the other player instead of your own bomb. At PixelPrompt we rewrite classic arcade games for the browser using AI, and Bomberman is the game that taught us something fundamental: the best rules are the ones players use in ways the designer never predicted.

Hudson Soft released the first Bomberman in 1983. The concept was already complete: a grid-based maze, destructible walls, bombs that explode in a cross pattern after a fixed timer. The player moves in four cardinal directions. No jumping, no direct attack, no inventory. The vocabulary of actions is the most reduced in videogame history: walk and place.

Three Rules, Infinite Complexity

Bomberman works by subtraction. Take everything an action game could have (jumping, attacking, dodging, weapons, abilities) and remove everything except movement and a single verb: place. The result isn't mechanical poverty. It's concentration.

The bomb explodes in four directions after three seconds. This time constraint turns every placement into a prediction: where will my opponent be in three seconds? Where will I be? Which corridors will open? Which will close? You're not playing the present: you're playing three seconds into the future. It's chess compressed into an arcade.

The cross-shaped explosion creates another brilliant constraint: diagonals are safe zones. Two players separated by a destructible wall both know the bomb hits in a straight line. So both plan to flee diagonally. But if both flee in the same direction, they meet face to face. The bomb becomes a positioning tool, not a direct damage one.

«I didn't design the multiplayer strategy. I discovered it watching testers play.»

Shinichi Nakamoto, lead designer of the Bomberman series

The Prisoner's Dilemma at 60 fps

There's a moment in every Bomberman match that is pure game theory. Two players find themselves on opposite sides of a narrow corridor. Each has a bomb available. If one places and the other doesn't, whoever placed controls the exit. If both place, both are trapped. If neither places, the stalemate continues.

It's the Prisoner's Dilemma in real time. Cooperating (not placing) would be the rational choice for both. But the game allows no communication. And the match timer ticks. So time pressure breaks the equilibrium and someone places. Always.

This pattern wasn't designed. It's emergent complexity: sophisticated behaviors arising from simple rules. Chess has the same phenomenon (few rules, enormous combinatorial complexity), but Bomberman compresses it into ninety-second matches played with a single action button.

Fewer Features, More Depth

If I had to bring Bomberman into a product meeting, I'd use it to demonstrate a principle I see violated every week: adding features doesn't add value. It subtracts it.

Bomberman '93 for PC Engine introduced power-ups: more simultaneous bombs, longer explosions, the ability to kick or throw bombs. Each power-up made the game more chaotic but less strategic. The original Bomberman's strength wasn't variety: it was parity. Everyone has the same capabilities, everyone has the same constraints. The difference is your brain, not your loadout.

In product management there's a term for this: feature creep. Every added feature has a hidden cost in cognitive complexity. An app with twenty options where nobody knows what the bottom-right button does is worse than an app with three features everyone masters. Bomberman is the three-feature app: move, place, escape.

The corollary is that constraints breed creativity. Can't jump? Then you learn to use diagonals. Can't attack directly? Then you learn to predict where your opponent will be in three seconds. Limitation forces the player to find solutions the designer never planned. And those solutions are the real game.

Developer Insight: The Timer Is Everything

When I started working on the Bomberman interpretation for PixelPrompt, I thought the hard part would be the destructible grid. In reality the grid is the easy part: a 2D array where each cell is empty, fixed wall, or destructible wall. The placed bomb occupies a cell and after N frames explodes, changing the state of adjacent cells along four directions.

The real problem is the explosion timer and chain propagation. When a bomb explodes and the blast reaches another bomb, that bomb must explode immediately regardless of its remaining timer. This creates the chain reactions that are the heart of advanced Bomberman: you place three bombs in sequence, the first triggers the second, the second triggers the third, and the blast arrives on the other side of the map where your opponent felt safe.

Getting propagation to work without infinite loops was the most persistent bug. If bomb A triggers bomb B and bomb B sits in bomb A's explosion path, you risk a cycle. The solution is a Set of "already processed" bombs in the current frame: each bomb can be triggered only once per propagation cycle. It sounds obvious written like this, but it took three iterations with Claude before converging on this logic. The first version didn't handle the case, the second used a boolean flag on the bomb (which didn't reset correctly between turns), the third used the Set and worked on the first try.

The second technical problem was grid-aligned movement. In the original Bomberman the player doesn't move pixel-by-pixel freely: they're constrained to the grid, but with a "snap" system that aligns them to the nearest cell when changing direction. Without this snap, the player constantly gets stuck on wall corners. With too much snap, movement feels magnetic and artificial. The right value? About 6 pixels of tolerance. Enough to forgive imprecise alignment, little enough to not feel assisted.

«Six pixels of tolerance. The difference between a game that feels fluid and one that feels broken is a margin you can't even see with the naked eye.»

From the PixelPrompt development diary

Perfect Chaos Isn't Designed, It's Discovered

Bomberman's definitive lesson is that the best systems aren't those with the most rules: they're those with the right rules. Three constraints (grid, timer, cross explosion) generate a system that players have explored for forty years without exhausting it. No update, no balance patch, no DLC has ever improved the base formula of four-player Bomberman on a 13×11 grid.

If you work on a product, next time someone proposes adding a feature, ask first: can we achieve the same result with a constraint? Bomberman didn't add an attack button. It put a timer on a bomb and let players invent the rest.

If this piece made you want to take apart more classics, at PixelPrompt we do it every week. We reinterpret retro games for the browser, analyze them piece by piece and share what we've learned. Join the crew: zero spam, just pixels and code.