Formal Specification
Five Stones — Formal Specification
Singapore · dexterity-small · Confidence: high
← Back to game pageImplementation Suitability
Suitability: engine-readyFidelity: probabilistic-proxyGap-fills: 3
# Five Stones — AI-optimized specification
## General idea
Five Stones is a sequential dexterity-stage game where players progress through 8 increasingly challenging mechanical routines of throwing, scooping, and catching small weighted bags. Tactical decision-making centers on risk management during scatter throws, target cluster selection, and deciding point thresholds in the scoring stage.
## Formal model
- **Abstraction taken:** The physical throwing and manual dexterity required to catch airborne stones while scooping ground stones is abstracted into a success probability function: .
- **Player/agent count:** 2 to 6 agents taking turns sequentially.
- **Turn model:** Sequential turns. An active agent continues performing routine steps until a fault occurs or the 8-stage sequence is completed.
## Formal rules
R1. State Initialization: Each agent has a progress tracker `stage` initialized to 1, and an accumulated `score` initialized to 0. Target score limit is set to (default: 50 points) [gap-fill].
R2. Turn Structure: On agent 's turn, the agent executes the sub-actions for their current `stage`.
R3. Stage 1 to 7 Execution:
- The agent executes a scatter drop generating 2D coordinates for the 5 stones.
- The agent selects a "mother stone" and sequentially declares target pickup subsets matching the stage requirement ( for Stage 1, for Stage 2, for Stage 3, for Stage 4, exchange sequence for Stage 5, bridge shots for Stage 6, claw scoops for Stage 7).
- For each pickup attempt, a stochastic test determines success. If successful, stones are scooped and mother stone caught. If all pickups in the stage succeed, `stage` increments by 1.
R4. Fault Condition: If any pickup attempt fails (dropped stone or collision with non-target stone), the turn ends immediately (*mati*). The agent retains their current `stage` and the turn passes to agent .
R5. Stage 8 (Timbang / Scoring):
- The agent performs the balance throw. Number of caught stones is sampled based on agent skill.
- If , the agent adds points to their total score.
- Upon completing Stage 8, `stage` resets to 1, allowing the agent to cycle through stages again for additional points.
R6. Win Condition: The first agent to reach or exceed the target score at the conclusion of a turn wins immediately. [gap-fill] If a turn limit rounds is reached without any player reaching , the player with the highest score wins.
## Edge cases
- Tie at the end condition: If multiple players reach target score in the same round, the player with the highest total score wins; if exactly tied, a single tiebreaker Timbang throw determines the winner.
- A player with no legal move: Not applicable; an active player always has an executable stage routine.
- Repetition / cycles: The cycle from Stage 1 through 8 is bounded by the monotonic accumulation of points toward , backed by round limit [gap-fill].
- Simultaneous claims on the same resource or position: Not applicable; turns are strictly sequential with a single set of 5 stones.
- Player elimination mid-round: Not applicable; no elimination occurs in standard play (all players remain active).
- Resource exhaustion: The 5 stones are permanent and never consumed or permanently removed.
- Termination guarantee: Guaranteed because each successful Stage 8 adds positive points toward finite target , bounded by finite maximum rounds .
## State representation
- Persistent state:
- `scores`: array of size (integers ).
- `stages`: array of size (integers ).
- `active_player`: integer .
- `round_count`: integer.
- Per-turn ephemeral state:
- `stone_positions`: 5 2D coordinate pairs .
- `held_stones`: set of stone indices in hand.
- `mother_stone`: index of airborne stone.
- Observable information: Fully observable to all agents.
## Action space
- `scatter_throw()`: Generates stone positions.
- `select_mother_stone(stone_id)`: Selects which stone to toss.
- `attempt_pickup(target_subset)`: Initiates scoop attempt for designated stones.
- `execute_timbang()`: Triggers scoring balance attempt in Stage 8.
## Playability notes
- Single-player-vs-AI: Fully natural; the player competes against an AI agent following identical probability distributions.
- Group games (n>4): Generalizes seamlessly with standard turn rotation.
- Physical-skill games: Motor dexterity is modeled via parametrized success curve: .
- What is lost: Physical tactile sensation of bean-bag grip, subtle finger-arch geometry, and manual flick micro-adjustments.
## Implementation hints
Low state complexity. Implement deterministic state machine for stages 1–8 first with uniform random sampling, then integrate proximity-based scatter physics and skill factors.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Five Stones (Singapore). (n.d.). Games of Countries. https://gamesofcountries.com/games/sg-singapore/five-stones
@misc{gamesofcountries-sg-singapore-five-stones,
title = {Five Stones (Singapore)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/sg-singapore/five-stones}
}