mini_arcade_core.scenes.systems.builtins.bomberman

Reusable arena bomb/explosion helpers for Bomberman-style games.

Classes

ArenaTile	Common arena tile kinds for bomb-based grid games.
BombState	Mutable bomb metadata stored in a bomb field.
BombField	Dense bomb occupancy keyed by cell.
ExplosionCellState	Mutable active explosion metadata for one cell.
ExplosionField	Dense active explosion occupancy keyed by cell.
BombPlacementBinding	Declarative bomb placement rule.
BombPlacementSystem	Place bombs onto walkable floor cells when rules allow.
BombFuseBinding	Declarative fuse ticking and detonation rule.
BombFuseSystem	Tick bomb fuses and emit detonation callbacks when they expire.
ExplosionLifetimeBinding	Declarative active-explosion lifetime rule.
ExplosionLifetimeSystem	Tick active explosion cells until they expire.
ChainReactionBinding	Declarative bomb chain-reaction rule.
ChainReactionSystem	Trigger bombs early when an active explosion reaches them.
DestructibleTileBinding	Declarative breakable-tile destruction rule.
DestructibleTileSystem	Destroy breakable tiles touched by active explosion cells.
HazardCollisionBinding	Declarative explosion hazard collision rule.
HazardCollisionSystem	Invoke callbacks for targets occupying active hazard cells.

Functions

arena_tile_map_from_strings(...)	Build a common arena tile map from ASCII rows.
is_walkable_arena_tile(→ bool)	Return whether an arena tile can be entered by a player/enemy.
blast_cells(...)	Compute explosion coverage from one bomb origin.
spawn_explosion_from_bomb(...)	Populate explosion cells from one bomb and return covered cells.

Module Contents

class mini_arcade_core.scenes.systems.builtins.bomberman.ArenaTile

Bases: str, enum.Enum

Common arena tile kinds for bomb-based grid games.

FLOOR = 'floor'

SOLID = 'solid'

BREAKABLE = 'breakable'

SPAWN = 'spawn'

VOID = 'void'

mini_arcade_core.scenes.systems.builtins.bomberman.arena_tile_map_from_strings(*rows: str) → mini_arcade_core.scenes.systems.builtins.maze.TileMap[ArenaTile]

Build a common arena tile map from ASCII rows.

mini_arcade_core.scenes.systems.builtins.bomberman.is_walkable_arena_tile(tile: ArenaTile | None) → bool

Return whether an arena tile can be entered by a player/enemy.

class mini_arcade_core.scenes.systems.builtins.bomberman.BombState

Mutable bomb metadata stored in a bomb field.

cell: mini_arcade_core.scenes.systems.builtins.grid.GridCoord

fuse_seconds: float = 2.0

blast_range: int = 2

owner_id: int | None = None

payload: Any = None

class mini_arcade_core.scenes.systems.builtins.bomberman.BombField

Dense bomb occupancy keyed by cell.

bombs: dict[mini_arcade_core.scenes.systems.builtins.grid.GridCoord, BombState]

bomb_at(cell: mini_arcade_core.scenes.systems.builtins.grid.GridCoord) → BombState | None

Return the bomb currently occupying one cell, if any.

active_bombs() → tuple[BombState, Ellipsis]

Return all currently active bombs.

occupied_cells() → tuple[mini_arcade_core.scenes.systems.builtins.grid.GridCoord, Ellipsis]

Return every cell that currently contains a bomb.

add(bomb: BombState) → BombState

Insert or replace a bomb entry and return it.

remove(cell: mini_arcade_core.scenes.systems.builtins.grid.GridCoord) → BombState | None

Remove and return the bomb at one cell, if present.

count_for_owner(owner_id: int | None) → int

Count bombs owned by a specific actor.

class mini_arcade_core.scenes.systems.builtins.bomberman.ExplosionCellState

Mutable active explosion metadata for one cell.

ttl_seconds: float

owner_id: int | None = None

origin: mini_arcade_core.scenes.systems.builtins.grid.GridCoord | None = None

payload: Any = None

class mini_arcade_core.scenes.systems.builtins.bomberman.ExplosionField

Dense active explosion occupancy keyed by cell.

cells: dict[mini_arcade_core.scenes.systems.builtins.grid.GridCoord, ExplosionCellState]

cell_at(cell: mini_arcade_core.scenes.systems.builtins.grid.GridCoord) → ExplosionCellState | None

Return the explosion metadata for one cell, if active.

active_cells() → tuple[mini_arcade_core.scenes.systems.builtins.grid.GridCoord, Ellipsis]

Return the cells currently covered by an active explosion.

set_or_refresh(cell: mini_arcade_core.scenes.systems.builtins.grid.GridCoord, *, ttl_seconds: float, owner_id: int | None = None, origin: mini_arcade_core.scenes.systems.builtins.grid.GridCoord | None = None, payload: Any = None) → ExplosionCellState

Create or refresh the active explosion metadata for one cell.

tick(dt: float) → tuple[mini_arcade_core.scenes.systems.builtins.grid.GridCoord, Ellipsis]

Advance explosion lifetimes and return the cells that expired.

mini_arcade_core.scenes.systems.builtins.bomberman.blast_cells(tile_map: mini_arcade_core.scenes.systems.builtins.maze.TileMap[ArenaTile], origin: mini_arcade_core.scenes.systems.builtins.grid.GridCoord, *, blast_range: int) → tuple[mini_arcade_core.scenes.systems.builtins.grid.GridCoord, Ellipsis]

Compute explosion coverage from one bomb origin.

mini_arcade_core.scenes.systems.builtins.bomberman.spawn_explosion_from_bomb(explosions: ExplosionField, tile_map: mini_arcade_core.scenes.systems.builtins.maze.TileMap[ArenaTile], bomb: BombState, *, ttl_seconds: float) → tuple[mini_arcade_core.scenes.systems.builtins.grid.GridCoord, Ellipsis]

Populate explosion cells from one bomb and return covered cells.

class mini_arcade_core.scenes.systems.builtins.bomberman.BombPlacementBinding

Bases: Generic[TCtx]

Declarative bomb placement rule.

should_place: Callable[[TCtx], bool]

placement_cell_getter: Callable[[TCtx], mini_arcade_core.scenes.systems.builtins.grid.GridCoord]

bombs_getter: Callable[[TCtx], BombField]

tile_map_getter: Callable[[TCtx], mini_arcade_core.scenes.systems.builtins.maze.TileMap[ArenaTile]]

build_bomb: Callable[[TCtx, mini_arcade_core.scenes.systems.builtins.grid.GridCoord], BombState]

owner_id_getter: Callable[[TCtx], int | None]

max_active_getter: Callable[[TCtx], int]

on_placed: Callable[[TCtx, BombState], None] | None = None

class mini_arcade_core.scenes.systems.builtins.bomberman.BombPlacementSystem

Bases: Generic[TCtx]

Place bombs onto walkable floor cells when rules allow.

name: str = 'common_bomb_placement'

phase: int

order: int = 24

enabled_when: Callable[[TCtx], bool]

bindings: tuple[BombPlacementBinding[TCtx], Ellipsis] = ()

step(ctx: TCtx) → None

Place bombs for every binding whose placement rule passes.

class mini_arcade_core.scenes.systems.builtins.bomberman.BombFuseBinding

Bases: Generic[TCtx]

Declarative fuse ticking and detonation rule.

bombs_getter: Callable[[TCtx], BombField]

on_detonated: Callable[[TCtx, BombState], None] | None = None

class mini_arcade_core.scenes.systems.builtins.bomberman.BombFuseSystem

Bases: Generic[TCtx]

Tick bomb fuses and emit detonation callbacks when they expire.

name: str = 'common_bomb_fuse'

phase: int

order: int = 32

enabled_when: Callable[[TCtx], bool]

bindings: tuple[BombFuseBinding[TCtx], Ellipsis] = ()

step(ctx: TCtx) → None

Advance bomb fuses and notify bindings when bombs detonate.

class mini_arcade_core.scenes.systems.builtins.bomberman.ExplosionLifetimeBinding

Bases: Generic[TCtx]

Declarative active-explosion lifetime rule.

explosions_getter: Callable[[TCtx], ExplosionField]

on_expired: Callable[[TCtx, tuple[mini_arcade_core.scenes.systems.builtins.grid.GridCoord, Ellipsis]], None] | None = None

class mini_arcade_core.scenes.systems.builtins.bomberman.ExplosionLifetimeSystem

Bases: Generic[TCtx]

Tick active explosion cells until they expire.

name: str = 'common_explosion_lifetime'

phase: int

order: int = 38

enabled_when: Callable[[TCtx], bool]

bindings: tuple[ExplosionLifetimeBinding[TCtx], Ellipsis] = ()

step(ctx: TCtx) → None

Tick active explosion cells and emit expiration callbacks.

class mini_arcade_core.scenes.systems.builtins.bomberman.ChainReactionBinding

Bases: Generic[TCtx]

Declarative bomb chain-reaction rule.

bombs_getter: Callable[[TCtx], BombField]

explosions_getter: Callable[[TCtx], ExplosionField]

on_triggered: Callable[[TCtx, BombState], None] | None = None

class mini_arcade_core.scenes.systems.builtins.bomberman.ChainReactionSystem

Bases: Generic[TCtx]

Trigger bombs early when an active explosion reaches them.

name: str = 'common_chain_reaction'

phase: int

order: int = 34

enabled_when: Callable[[TCtx], bool]

bindings: tuple[ChainReactionBinding[TCtx], Ellipsis] = ()

step(ctx: TCtx) → None

Detonate bombs early when an active blast reaches them.

class mini_arcade_core.scenes.systems.builtins.bomberman.DestructibleTileBinding

Bases: Generic[TCtx]

Declarative breakable-tile destruction rule.

tile_map_getter: Callable[[TCtx], mini_arcade_core.scenes.systems.builtins.maze.TileMap[ArenaTile]]

explosions_getter: Callable[[TCtx], ExplosionField]

replacement_tile: ArenaTile

on_destroyed: Callable[[TCtx, mini_arcade_core.scenes.systems.builtins.grid.GridCoord], None] | None = None

class mini_arcade_core.scenes.systems.builtins.bomberman.DestructibleTileSystem

Bases: Generic[TCtx]

Destroy breakable tiles touched by active explosion cells.

name: str = 'common_destructible_tiles'

phase: int

order: int = 36

enabled_when: Callable[[TCtx], bool]

bindings: tuple[DestructibleTileBinding[TCtx], Ellipsis] = ()

step(ctx: TCtx) → None

Replace breakable tiles touched by active explosion cells.

class mini_arcade_core.scenes.systems.builtins.bomberman.HazardCollisionBinding

Bases: Generic[TCtx]

Declarative explosion hazard collision rule.

hazard_cells_getter: Callable[[TCtx], Iterable[mini_arcade_core.scenes.systems.builtins.grid.GridCoord]]

targets_getter: Callable[[TCtx], Iterable[object]]

target_cell_getter: Callable[[TCtx, object], mini_arcade_core.scenes.systems.builtins.grid.GridCoord]

on_hit: Callable[[TCtx, object, mini_arcade_core.scenes.systems.builtins.grid.GridCoord], None]

class mini_arcade_core.scenes.systems.builtins.bomberman.HazardCollisionSystem

Bases: Generic[TCtx]

Invoke callbacks for targets occupying active hazard cells.

name: str = 'common_hazard_collision'

phase: int

order: int = 37

enabled_when: Callable[[TCtx], bool]

bindings: tuple[HazardCollisionBinding[TCtx], Ellipsis] = ()

step(ctx: TCtx) → None

Invoke hit callbacks for targets occupying active hazard cells.