Formal Specification
Five Stones — Formal Specification
Türkiye · dexterity-small · Confidence: low
← Back to game pageImplementation Suitability
Suitability: adaptation-requiredFidelity: probabilistic-proxyGap-fills: 3
# Beştaş — AI-optimized specification
## General idea
A sequential multi-stage dexterity game where players toss a stone in the air and attempt to pick up or slide the remaining stones on the ground. Physical execution is modeled as a success probability that depends on player skill and stage difficulty, allowing players to build up points and manage the risk of losing their turn.
## Formal model
- **Abstraction taken:** The high-speed continuous hand-eye coordination of throwing and catching stones is abstracted into a series of discrete stage transition tests. [gap-fill] Each stage is represented as a single probability roll, parameterized by a base difficulty scalar.
- **Player/agent count:** 2 to n players, acting sequentially.
- **Turn model:** Sequential turns. A player continues executing stages until they fail, which passes the turn to the next player.
## Formal rules
R1. Game progression: The game consists of 6 discrete levels indexed 0..5 (0: Birler, 1: İkiler, 2: Üçler, 3: Dörtler, 4: Köprü, 5: Karar).
R2. Player state: Each player `p` maintains a persistent state:
- `current_level(p): integer` (initialized to 0).
- `score(p): integer` (initialized to 0).
R3. On player `p`'s turn, they start at `current_level(p)` and must attempt that level's action.
R4. Level resolution:
- The probability of successfully completing level `L` is:
`P(Success) = skill(p) * base_difficulty(L)`
where `base_difficulty` is defined as:
- `base_difficulty(0) = 0.90` (Birler - easiest)
- `base_difficulty(1) = 0.80` (İkiler)
- `base_difficulty(2) = 0.70` (Üçler)
- `base_difficulty(3) = 0.60` (Dörtler)
- `base_difficulty(4) = 0.50` (Köprü - hardest)
- `base_difficulty(5) = 1.00` (Karar - scoring is handled differently).
R5. Level outcome:
- If successful for `L ∈ [0..4]`:
- Player `p` immediately advances: `current_level(p) = L + 1`.
- Since they succeeded, they *must* immediately attempt the next level `L + 1` in the same turn.
- If successful for `L == 5` (Karar):
- [gap-fill] The number of stones caught `C` is sampled from a binomial distribution `Binomial(n=5, p=skill(p)*0.6)`.
- Player `p` receives `C * 10` points: `score(p) += C * 10`.
- Level resets: `current_level(p) = 0`.
- Turn ends and passes to the next player in the rotation.
- If failure:
- Player `p` does not advance: `current_level(p)` remains unchanged.
- Turn ends and passes to the next player in the rotation.
R6. End condition:
- [gap-fill] The game ends immediately when any player `p` reaches or exceeds 100 points, or after a fixed number of rounds (e.g. 5 rounds).
R7. Win condition: The player with the highest `score` at game end wins. If scores are equal, the game is a tie.
## Edge cases
- **Tie at the end condition:** Handled by R7 — equal high scores result in a tie.
- **A player with no legal move:** Not applicable; players can always attempt their current level on their turn.
- **Repetition / cycles:** The scoring threshold or fixed-round limit (R6) prevents infinite loops.
- **Simultaneous claims on the same resource:** Not applicable; turns are strictly sequential.
- **Player elimination mid-round:** Not applicable.
- **Resource exhaustion:** Not applicable; stones are never removed from the game.
- **Termination guarantee:** Guaranteed by the round limit or score limit in R6.
## State representation
- Persistent state:
- `player_scores: Array[num_players] of integer`.
- `player_levels: Array[num_players] of integer`.
- `active_player: integer`.
- `round_count: integer`.
- Ephemeral state:
- `stage_roll: float` (sampled random value 0.0..1.0).
- `stones_caught_karar: integer`.
- Information set: Fully observable, no hidden information.
## Action space
- `attempt_level()`: triggers the probability check for the active player's current level. No parameters.
## Playability notes
- Single-player-vs-AI: Natural. Can be played as a solitaire challenge (reach 100 points in minimum turns) or against basic AI agents that model the same probability equations.
- Group games (n>4): Generalizes perfectly.
- Physical-skill games: Physical dexterity is fully abstracted into the success probability equation.
- What is lost: The tactile satisfaction of tossing, catching, and sorting smooth stones on a hard floor.
## Implementation hints
Very low complexity. State requires only two integers per player (score and level). First milestone: implement the state progression and turn-passing logic (R3-R5) using deterministic success flags, then introduce the stochastic probability resolver.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Five Stones (Türkiye). (n.d.). Games of Countries. https://gamesofcountries.com/games/tr-turkiye/bestas
@misc{gamesofcountries-tr-turkiye-bestas,
title = {Five Stones (Türkiye)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/tr-turkiye/bestas}
}