Formal Specification
Seven Stones / Seven Tiles — Formal Specification
Pakistan · ball-team · Confidence: low
← Back to game pageImplementation Suitability
Suitability: engine-readyFidelity: discretizedGap-fills: 2
# Pitho Garam — AI-optimized specification
## General idea
A turn-based team dodgeball-and-construction game played on a 2D coordinate grid with a central objective structure. The attacking team first topples a stack of 7 stone pieces with a thrown ball, then attempts to reconstruct the stack piece-by-piece while navigating spatial evasion, while the defending team passes the ball and throws at attacking agents to eliminate them.
## Formal model
- **Abstraction taken:** The playing area is a 2D grid `[-15, 15] x [-15, 15]`. The stone stack is located at `(0, 0)`. The game transitions through two discrete phases: Phase 1 (Throwing/Knockdown) and Phase 2 (Real-time Ticked Scatter & Rebuild).
- **Player/agent count:** 2 teams (Attacking Team A, Defending Team B) of `K` agents each (standard `K = 4`).
- **Turn model:** Phase 1 is sequential per-thrower; Phase 2 executes in simultaneous discrete state ticks `Delta_t = 0.5` seconds.
## Formal rules
R1. Setup: Stack state `stack_height = 7` at `(0, 0)`. Attacking agents are stationed at throwing crease `(0, -6)`. Defending agents are positioned in `y > 0`.
R2. Phase 1 (Knockdown): Attacking throwers sequentially execute `throw_at_stack(power, angle)`.
- If throw impacts within radius `0.3` of `(0, 0)`: Stack is toppled. `stack_height` is reduced to a sampled value `h_topple in {0..2}`. Phase 2 begins immediately.
- If all `K` attackers miss: Innings ends with 0 points; roles swap.
R3. Phase 2 (Scatter & Rebuild):
- On each tick, all active agents submit movement vectors `(dx, dy)` with max speed `2.0` units/tick (unarmed) or `1.0` units/tick (ball carrier).
- Ball carrier action set: `{pass(target_agent_id), throw_tag(target_agent_id)}`.
R4. Tag resolution: If ball is thrown at an attacker `A_i` and lands within tag radius without being blocked, `A_i` is eliminated (`eliminated_status[A_i] = True`).
R5. Rebuilding action: If an active attacker `A_i` is within `dist(A_i, (0, 0)) <= 1.0` and executes `rebuild_stack()`, `stack_height` increments by 1 per uninterrupted tick.
R6. Win conditions of round:
- If `stack_height == 7`: Attacking team successfully triggers `pitho_garam_cry()` -> Team A scores 1 point.
- If all `K` attackers are eliminated before `stack_height == 7`: Team A scores 0 points, and round terminates.
R7. Innings swap: After round resolution, roles swap (Team B attacks, Team A defends).
R8. [gap-fill] Match end: Total of 4 rounds (2 attack rounds per team). Team with higher point total wins.
R9. [gap-fill] Tie-break: In case of a draw, a sudden-death single-player knockdown accuracy challenge is played.
## Edge cases
- **Tie at the end condition:** Handled by R9 sudden-death target throw.
- **A player with no legal move:** Movement vectors always permit `(0, 0)` (holding ground).
- **Repetition / cycles:** Bounded because in Phase 2, either `stack_height` strictly increases to 7 or the number of active attackers strictly decrements to 0.
- **Simultaneous claims on the same resource or position:** If two attackers reach the stack simultaneously, both can contribute parallel rebuild ticks (`+2` height per tick).
- **Player elimination mid-round:** Eliminated agents are removed from active grid simulation; turn/tick updates continue over surviving agents.
- **Resource exhaustion:** Active attackers decrement monotonically to zero if not completing the stack.
- **Termination guarantee:** Guaranteed by monotonic progress toward either `stack_height == 7` or `active_attackers == 0`.
## State representation
- **Persistent state:** `scores[A, B]`, `current_round in {1..4}`, `attacking_team in {A, B}`.
- **Per-tick ephemeral state:** `phase in {Phase_1, Phase_2}`, `stack_height in {0..7}`, positions `(x, y)` for all `2K` agents, `ball_carrier_id`, `ball_position`, `eliminated_flags[1..K]`.
- **Observable information:** Fully observable 2D state for all agents.
## Action space
- `move(dx, dy)`: Displacement vector within velocity limits.
- `throw_at_stack(power, angle)`: Phase 1 action.
- `pass(defender_id)`: Pass ball to teammate.
- `throw_tag(attacker_id)`: Attempt elimination throw at target attacker.
- `rebuild_stack()`: Increment stack height when adjacent to `(0, 0)`.
## Playability notes
- **Single-player-vs-AI:** Natural; human player can control the primary stack builder while coordinating AI teammate decoy runs.
- **Group games (n>4):** Reduces cleanly via multi-agent team control (4v4).
- **Physical-skill games:** Dodge evasion and throwing accuracy are parameterized by distance-decay probability functions.
- **What is lost:** The sudden panic of scrambling for scattered rocks while watching the ball fly overhead in real life.
## Implementation hints
Low-to-medium complexity. The two-phase finite state machine is crisp and modular. Build Phase 2 grid movement and ball tag logic first with a dummy initial topple state before connecting Phase 1 throwing ballistics.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Seven Stones / Seven Tiles (Pakistan). (n.d.). Games of Countries. https://gamesofcountries.com/games/pk-pakistan/pitho-garam
@misc{gamesofcountries-pk-pakistan-pitho-garam,
title = {Seven Stones / Seven Tiles (Pakistan)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/pk-pakistan/pitho-garam}
}