Formal Specification
Tile Tower Ball / Gebokan — Formal Specification
Indonesia · ball-team · Confidence: low
← Back to game pageImplementation Suitability
Suitability: engine-readyFidelity: discretizedGap-fills: 4
# Boy-boyan — AI-optimized specification
## General idea
A multi-agent team game on a 2D discrete grid where an attacking squad attempts to rebuild a fallen multi-tier tile stack at a central node while a defending squad passes a ball and throws it to eliminate attacking agents. The game features emergent cooperative roles: baiting defender fire, ball interception, and sequential tower construction.
## Formal model
- **Abstraction taken:** The continuous field is discretized as a integer grid. Tower is at with height . Ball physics and thrown tag attempts are resolved per tick.
- **Player/agent count:** 2 teams (), each with agents (default 4 per team).
- **Turn model:** Simultaneous tick execution ( tick).
## Formal rules
R1. Initialization:
- Tower node initializes in state `TOPPLED` with `tiles_stacked = 0`, `tiles_remaining = 7`.
- Defending agent possesses the ball at . Attacking agents start at .
R2. Attacking agent actions:
- `move(dx, dy)`: Step up to 1 cell in any direction ().
- `stack_tile()`: Precondition: agent is at and `status == ACTIVE`. Result: `tiles_stacked += 1`.
R3. Defending agent actions:
- `move(dx, dy)`: Step up to 1 cell. If holding the ball, movement is restricted to 0 steps (must pass or throw) [gap-fill].
- `pass_ball(target_defender_id)`: Ball flies to target defender over distance ticks.
- `throw_at_attacker(target_attacker_id)`: Throws ball toward attacker's current coordinates. Hit probability [gap-fill].
R4. Elimination & victory:
- If an attacker is hit by the ball, their status changes to `ELIMINATED` and they are removed from the active grid.
- If `tiles_stacked == 7`, the attacking team immediately scores 1 point; the round ends in Attacker Victory.
- If all attacking agents are `ELIMINATED`, the round ends in Defender Victory (0 points awarded; roles switch) [gap-fill].
R5. Maximum round horizon [gap-fill]: If neither victory condition is achieved by tick , the round terminates and roles switch.
## Edge cases
- Tie at the end condition: If match score is tied after completed alternating rounds, sudden-death round with tiles is played.
- A player with no legal move: (remain stationary) is always legal.
- Repetition / cycles: Bounded by finite tick limit and monotonic tile stacking or attacker eliminations.
- Simultaneous claims on the same resource or position: Multiple agents can occupy the tower cell; if a defender throws at the tower cell, one target attacker is resolved uniformly at random.
- Player elimination mid-round: Eliminated attackers are deactivated; surviving attackers continue the stacking objective.
- Resource exhaustion: Tower has exactly 7 tiles; once stacked, round terminates immediately.
- Termination guarantee: Strict tick bound combined with finite team size guarantees round termination.
## State representation
- Persistent state:
- `attackers`: array of `{id, x, y, status: ACTIVE|ELIMINATED}`.
- `defenders`: array of `{id, x, y, has_ball: bool}`.
- `ball_state`: `{x, y, in_flight: bool, flight_ticks_left: int, target_pos: (x, y)}`.
- `tiles_stacked`: integer .
- `match_score`: `[atk_score, def_score]`.
- `current_tick`: integer .
- Observable information: Fully observable (all positions, ball status, and tile count are public).
## Action space
- Attackers: `move(dx, dy)`, `stack_tile()`.
- Defenders: `move(dx, dy)`, `pass_ball(id)`, `throw_at_attacker(id)`.
## Playability notes
- Single-player-vs-AI: Very engaging as a real-time tactical squad commander or single-agent evasion game.
- Group games (n>4): Reduces naturally to 2v2 (2 attackers vs 2 defenders) with tiles without losing tactical depth.
- Physical-skill games: Physical dodge agility and throwing accuracy are parameterized by distance-based probability curves.
- What is lost in the adaptation: The somatic adrenaline of diving to place the last tile while a rubber ball whizzes past one's ear is abstracted into tick updates.
## Implementation hints
Discrete 2D grid with simple A* pathfinding for bots. First milestone: Implement 2v2 with stationary defenders throwing at moving attackers attempting to increment `tiles_stacked`.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Tile Tower Ball / Gebokan (Indonesia). (n.d.). Games of Countries. https://gamesofcountries.com/games/id-indonesia/boy-boyan
@misc{gamesofcountries-id-indonesia-boy-boyan,
title = {Tile Tower Ball / Gebokan (Indonesia)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/id-indonesia/boy-boyan}
}