Formal Specification
Tin Can Dodgeball — Formal Specification
Singapore · dexterity-throw · Confidence: high
← Back to game pageImplementation Suitability
Suitability: adaptation-requiredFidelity: probabilistic-proxyGap-fills: 3
# Bola Tin — AI-optimized specification
## General idea
Bola Tin is an asymmetric multi-agent team challenge on a 2D discrete grid where a team of Builders attempts to assemble a pyramid of scattered blocks in the center of the field while evading a fielding team that passes a ball and fires targeted projectile attacks to eliminate the builders.
## Formal model
- **Abstraction taken:** Continuous physical movement and projectile physics are discretized onto a grid. The round progresses in discrete time ticks (sub-second steps).
- **Player/agent count:** 2 teams of 3 agents each (Team B: Builders, Team F: Fielders).
- **Turn model:** Simultaneous tick execution: all agents submit a directional movement, can-pickup/stack, or ball-pass/throw action per tick.
## Formal rules
R1. Setup: A grid. The pyramid base is at center . At tick 0, cans are scattered to random adjacent cells. Team B starts near ; Team F starts distributed along edges. Ball starts at .
R2. Simultaneous Movement & Actions per Tick:
- Movement: Each agent can move 1 cell in cardinal directions (or stay).
- Builder actions: `move`, `pickup_can`, `stack_can(at (7,7))`. Stacking requires an agent at carrying a can. A stacked can increments `pyramid_progress` by 1.
- Fielder actions: `move`, `pass_ball(target_teammate)`, `throw_ball(target_cell)`.
R3. Combat / Dodge Resolution:
- When a fielder with the ball executes `throw_ball(target_cell)`:
- Trajectory is traced from fielder to target cell.
- If a builder occupies the target cell (or intersecting path), a dodge check is evaluated: .
- If dodge fails, the builder is eliminated (*mati*) and removed from the grid.
- Ball comes to rest at target cell (or nearest bound).
R4. Ball Possession: A fielder moving into the ball's cell acquires possession. Builders cannot pick up the ball.
R5. Win Conditions per Round:
- Builder Victory: If `pyramid_progress` reaches 6, Team B wins the round immediately (+1 point).
- Fielder Victory: If all 3 Builders are eliminated, Team F wins the round (0 points for B, roles swap).
R6. Match Structure: The match lasts rounds. [gap-fill] A maximum of 100 ticks per round is enforced; if 100 ticks elapse without pyramid completion, Team F is awarded the round win.
## Edge cases
- Tie at the end condition: If both teams have equal points after 6 rounds, a sudden-death speed-build challenge (time to stack 3 cans without defense) decides the tie [gap-fill].
- A player with no legal move: Not applicable; grid movement or wait actions are always available.
- Repetition / cycles: Bounded by the 100-tick round cap [gap-fill].
- Simultaneous claims on the same resource or position:
- If two fielders reach the ball simultaneously, the fielder with the lower agent index acquires it.
- If a builder is stacking at on the exact same tick a ball hits that cell, stacking evaluates first, but if the throw hits, the builder is eliminated after can placement.
- Player elimination mid-round: Eliminated builders are immediately removed; the remaining builders continue play.
- Resource exhaustion: Cans are invariant (6 cans total).
- Termination guarantee: Every round terminates within at most 100 ticks, and the match terminates in 6 rounds.
## State representation
- Persistent state:
- `team_scores`: array of size 2 (integers ).
- `round_number`: integer .
- Per-round state:
- `tick_counter`: integer .
- `pyramid_progress`: integer .
- `builder_positions`: array of 3 coordinates (or null if eliminated).
- `builder_carried_cans`: array of 3 booleans.
- `fielder_positions`: array of 3 coordinates.
- `ball_pos`: 2D coordinate .
- `ball_carrier`: integer (0 = free ball).
- Observable information: Fully observable to all agents.
## Action space
- Builders: `move(direction)`, `pickup_can()`, `stack_can()`.
- Fielders: `move(direction)`, `pass_ball(fielder_id)`, `throw_ball(target_pos)`.
## Playability notes
- Single-player-vs-AI: Can be configured as 1 human builder + 2 AI builders vs. 3 AI fielders.
- Group games (n>4): Naturally reduces to 2v2 or expands to 5v5 by adjusting grid dimensions and can counts.
- Physical-skill games: Throwing accuracy and diving evasions are mapped to discrete stochastic dodge formulas.
- What is lost: Physical pain/sting of being pelted with tennis balls, and vocal shouting coordination across the yard.
## Implementation hints
Discrete grid multi-agent environment with simple line-of-sight raycasts for throws. Easily wrapped in an OpenAI Gym / PettingZoo environment.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Tin Can Dodgeball (Singapore). (n.d.). Games of Countries. https://gamesofcountries.com/games/sg-singapore/bola-tin
@misc{gamesofcountries-sg-singapore-bola-tin,
title = {Tin Can Dodgeball (Singapore)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/sg-singapore/bola-tin}
}