Bomberman Gameplay Internals

Mini Arcade now includes a small core toolkit for bomb-and-arena arcade games.

This layer is meant for Bomberman-style prototypes and other games built around:

  • arena tile maps

  • timed bombs

  • directional blast propagation

  • chain reactions

  • destructible blocks

  • short-lived hazard fields

What lives in core

Core built-ins:

  • ArenaTile

  • arena_tile_map_from_strings(...)

  • BombState

  • BombField

  • BombPlacementBinding

  • BombPlacementSystem

  • BombFuseBinding

  • BombFuseSystem

  • ExplosionCellState

  • ExplosionField

  • ExplosionLifetimeBinding

  • ExplosionLifetimeSystem

  • ChainReactionBinding

  • ChainReactionSystem

  • DestructibleTileBinding

  • DestructibleTileSystem

  • HazardCollisionBinding

  • HazardCollisionSystem

  • blast_cells(...)

  • spawn_explosion_from_bomb(...)

Source module:

  • packages/mini-arcade-core/src/mini_arcade_core/scenes/systems/builtins/bomberman.py

Arena tiles

ArenaTile standardizes the common tile categories used by bomb-based grid games:

  • FLOOR

  • SOLID

  • BREAKABLE

  • SPAWN

  • VOID

arena_tile_map_from_strings(...) lets a game define those tiles from ASCII rows instead of building the map cell by cell.

Bomb placement and fuse timing

BombPlacementSystem is the reusable rule for:

  • checking whether placement is requested

  • checking whether the target cell is walkable

  • enforcing one bomb per cell

  • enforcing per-owner active bomb limits

  • inserting the new BombState

BombFuseSystem handles the countdown side:

  • tick fuse timers

  • remove expired bombs from BombField

  • invoke game-specific detonation callbacks

That keeps placement capacity and fuse timing reusable while game code stays in control of scoring, audio, and visuals.

Blast propagation and chain reactions

blast_cells(...) computes directional explosion coverage from one origin.

The propagation rules are reusable and match the common pattern:

  • include the origin cell

  • stop at solid walls

  • include a breakable tile, then stop

  • stop at out-of-bounds or void cells

spawn_explosion_from_bomb(...) is a convenience helper that translates a detonated BombState into live cells in an ExplosionField.

ChainReactionSystem then handles the next rule layer: bombs touched by active explosion cells can be forced to detonate early.

Destruction and hazards

DestructibleTileSystem turns breakable tiles into a replacement tile when active explosion cells overlap them.

HazardCollisionSystem is the generic damage/hit layer for any target type. Games supply:

  • which cells are hazardous

  • which targets to test

  • how to read a target cell

  • what to do on a hit

This keeps player death, enemy damage, item ignition, and similar effects out of the tile/explosion data structures themselves.

Explosion lifetime

ExplosionField stores short-lived active flame cells.

ExplosionLifetimeSystem ticks those cells down and removes them when their TTL expires. This is the reusable cleanup layer for Bomberman-style hazards.

What is intentionally not in core

Core does not include a full Bomberman ruleset.

Still game-specific:

  • player movement rules and collision feel

  • enemy AI and stage progression

  • score and versus mode rules

  • item catalogs and pickup effects

  • bomb kick, throw, or remote-detonation behaviors

  • art, audio, HUD, and exact map content

Those should live in game code on top of the reusable arena/bomb primitives above.