Formal Specification
Seven Stones / Seven Tiles — Formal Specification
Türkiye · ball-team · Confidence: low
← Back to game pageImplementation Suitability
Suitability: adaptation-requiredFidelity: discretizedGap-fills: 2
# Tombik — AI-optimized specification
## General idea
A high-tempo field invasion and elimination game centered on asymmetric objectives: one team (Builders) attempts to knock down and reconstruct a central stone tower, while the opposing team (Fielders) attempts to eliminate all builders with thrown balls. The core tactical tension derives from a strict stationary constraint on the ball carrier, making cooperative ball circulation and passing lanes essential for defensive tagging.
## Formal model
- **Abstraction taken:** The 15x15 meter open field is discretized into a 2D coordinate grid with the stone tower positioned at `(0, 0)`. Continuous running and dodging are mapped to discrete spatial movements per simulation tick. Physical ball throws and stone stacking are parameterized by distance-decayed stochastic success probabilities. A player holding the ball has a movement speed allowance of 0.
- **Player/agent count:** 2 teams of equal size `K` (where `K ∈ [3..8]`). Team 0 = Builders (*Atıcılar*), Team 1 = Fielders (*Ebeler*).
- **Turn model:** Two-phase model. Phase 1 (Opening Throws) is sequential turn-based. Phase 2 (Active Play) is simultaneous real-time ticked.
## Formal rules
R1. Setup and Grid:
- Pitch: 15x15 grid centered at `(0, 0)`.
- Stacking circle: radius 1.0 unit around `(0, 0)`.
- Tower state: integer `stack_height ∈ [0..7]`. Setup starts with `stack_height = 7`.
- Throwing line: marked at coordinate `(0, -5)`.
R2. Opening Throws Phase:
- Builders take turns sequentially executing `throw_at_tower()`. Each builder receives up to 3 attempts.
- Stochastic hit probability: `P(hit) = skill_throw * 0.40`. [gap-fill]
- If a throw hits: `stack_height` becomes 0, the tower collapses, and play transitions immediately to Active Play Phase.
- If all builders exhaust their attempts without hitting the tower: roles invert immediately (Team 0 becomes Fielders, Team 1 becomes Builders) and a new round begins.
R3. Active Play Phase Actions per Tick:
- **Builders (Team 0) actions:**
- `move(dx, dy)`: Move up to `max_step` units (precondition: within grid bounds).
- `stack_stone()`: Valid only if builder is within radius 1.0 of `(0, 0)` and `stack_height < 7`. Increases `stack_height` by 1 upon resolution.
- `hold()`: Remain stationary.
- **Fielders (Team 1) actions:**
- `move(dx, dy)`: Move up to `max_step` units (precondition: agent does NOT possess the ball).
- `pass_ball(target_fielder_id)`: Precondition: agent possesses the ball. Throws the ball to a teammate.
- `tag_builder(target_builder_id)`: Precondition: agent possesses the ball. Throws the ball at an active builder to eliminate them.
- `pickup_ball()`: Precondition: ball is free on the ground and fielder is co-located.
R4. Action Resolution Order:
- Tick resolutions execute in this strict sequence:
1. Fielder ball passes: `P(pass_success) = max(0.1, skill_pass * (1.0 - dist / 15.0))`. If successful, target catches ball. If failed, ball lands at target's cell as a free ground ball.
2. Fielder tag attempts: `P(tag_success) = max(0.05, skill_tag * (1.0 - dist / 10.0))`. If successful, target builder is marked eliminated and removed from play.
3. All agent spatial movements update.
4. Stone stacking: If a builder in the circle executed `stack_stone()` and was not eliminated in step 2, `stack_height += 1`.
R5. Round Win Conditions:
- **Builder Round Win:** If `stack_height == 7`, Team 0 wins the round and receives 1 point.
- **Fielder Round Win:** If all active builders are eliminated before `stack_height == 7`, Team 1 wins the round and receives 1 point.
R6. Match Termination:
- Teams swap roles after each round. Match terminates when a team achieves 3 total points.
## Edge cases
- **Tie at the end condition:** Round outcomes are mutually exclusive (tower reaches 7 or all builders eliminated). Match is played first to 3 points, precluding final ties.
- **A player with no legal move:** A fielder possessing the ball cannot move; their legal action set is strictly constrained to `pass_ball`, `tag_builder`, or `hold`. A trapped builder can always `move` or `hold`.
- **Repetition / cycles:** In each round, the game state advances monotonically towards termination: either builders are progressively eliminated or stones are progressively stacked to 7. A tick counter cap of 500 ticks [gap-fill] breaks any stalling cycle by awarding the round to the fielders.
- **Simultaneous claims on the same resource:** If multiple builders execute `stack_stone()` on the same tick, exactly one stone is added per tick, resolved in ascending order of builder ID.
- **Player elimination mid-round:** Eliminated builders are set to inactive and removed from the active entity list immediately; round cadence continues without interruption.
- **Resource exhaustion:** Stones are finite (7); upon stacking the 7th stone, round termination is triggered immediately.
- **Termination guarantee:** Guaranteed by the monotonic decrease of active builders, monotonic increase of stone stack height, and the tick safety cap.
## State representation
- **Persistent state:**
- `match_scores: Tuple[int, int]` (scores for Team 0 and Team 1).
- `round_number: int`.
- `roles: Tuple[int, int]` (identifying which team is Builder / Fielder).
- **Ephemeral round state:**
- `phase: int` (0: Opening Throws, 1: Active Play).
- `stack_height: int` (0 to 7).
- `agent_positions: Dict[agent_id, Tuple[float, float]]`.
- `agent_active: Dict[agent_id, bool]`.
- `ball_state: Tuple[str, Optional[int], Tuple[float, float]]` (status: `held` or `free`, carrier ID, coordinates).
- `tick_count: int`.
- **Information set:** Fully observable public state.
## Action space
- `throw_at_tower()`: Precondition: Phase 0, active thrower's turn.
- `move(dx: float, dy: float)`: Precondition: Phase 1, within grid bounds, actor is not ball carrier if fielder.
- `stack_stone()`: Precondition: Phase 1, actor is active builder, `dist(pos, (0,0)) <= 1.0`, `stack_height < 7`.
- `pass_ball(target_id: int)`: Precondition: Phase 1, actor is ball carrier, `target_id` is active teammate.
- `tag_builder(target_id: int)`: Precondition: Phase 1, actor is ball carrier, `target_id` is active opponent builder.
- `pickup_ball()`: Precondition: Phase 1, actor is fielder, ball is free, co-located with ball.
- `hold()`: Precondition: Phase 1, always valid.
## Playability notes
- **Single-player-vs-AI:** Highly engaging. A human player controlling a builder agent dodges and coordinates stacking waves while AI fielders run passing trees to establish clean line-of-sight tag angles.
- **Group games (n>4):** Reduces naturally to 3v3 or 4v4 agents without degrading team passing or zone coverage dynamics.
- **Physical-skill model:** Real-world ball accuracy and dodging are parameterized as distance-decay functions weighted by agent skill coefficients.
- **What is lost:** The physical adrenaline of ducking, sliding on concrete, and balancing irregular natural river stones under imminent threat of being hit.
## Implementation hints
Branching factor for builders is small (movement vector or stack action). For fielders, joint action space requires coordinating receiver positioning with ball passing. Implement Phase 1 first as a simple sequential check, then build Phase 2 around a simultaneous tick update loop resolving ball transfers prior to position updates.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Seven Stones / Seven Tiles (Türkiye). (n.d.). Games of Countries. https://gamesofcountries.com/games/tr-turkiye/tombik
@misc{gamesofcountries-tr-turkiye-tombik,
title = {Seven Stones / Seven Tiles (Türkiye)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/tr-turkiye/tombik}
}