Formal Specification
Five Stones (Pesëgurësh) — Formal Specification
Albania · dexterity-small · Confidence: low
← Back to game pageImplementation Suitability
Suitability: engine-readyFidelity: probabilistic-proxyGap-fills: 2
# Loja me pesë gurë — AI-optimized specification
## General idea
A turn-based sequential dexterity game where players race to complete a mandatory progression of 6 discrete catching and scooping stages with five stones. Failure on any attempt ends the active turn, preserving completed stage progress until the next rotation.
## Formal model
- **Abstraction taken:** Physical finger coordination and hand-eye toss-and-catch actions are abstracted into a succession of Bernoulli trial checks with success probability `P(success | stage, skill)`.
- **Player/agent count:** 2 to 4 agents.
- **Turn model:** Sequential turns with stateful stage progression retention.
## Formal rules
R1. Setup: Each agent starts at `stage = 1` and `sub_step = 1`.
R2. The game consists of 6 sequential stages:
- Stage 1: 4 consecutive 1-stone pickups (`sub_step ∈ {1..4}`).
- Stage 2: 2 consecutive 2-stone pickups (`sub_step ∈ {1..2}`).
- Stage 3: 1 3-stone pickup followed by 1 1-stone pickup (`sub_step ∈ {1..2}`).
- Stage 4: 1 4-stone pickup (`sub_step = 1`).
- Stage 5: 4 gate-flicks through finger arch (`sub_step ∈ {1..4}`).
- Stage 6: 1 back-of-hand toss and palm catch (`sub_step = 1`).
R3. On an agent's turn, they attempt the action for their current `(stage, sub_step)`.
R4. Execution success check: Action succeeds with probability `P_stage = max(0.20, 0.90 - 0.10 * stage)` [gap-fill: base probability curve].
- If successful: `sub_step` increments. If all sub-steps for the current stage are completed, `stage` increments and `sub_step` resets to 1. The agent immediately attempts the next step in the same turn.
- If failed: Turn ends immediately. Current `(stage, sub_step)` is saved for the agent's next turn. Turn passes to the next player in rotation.
R5. Win condition: The first agent to complete Stage 6 wins the game immediately.
R6. [gap-fill] Max turns cutoff: If 50 turn rotations elapse without a winner, the agent who achieved the furthest `(stage, sub_step)` progress wins; if tied, a sudden-death Stage 6 attempt is executed.
## Edge cases
- Tie at the end condition: Not applicable; turns are strictly sequential, so the first agent to complete Stage 6 wins immediately.
- A player with no legal move: Not applicable; the current `(stage, sub_step)` action is always executable.
- Repetition / cycles: Bounded because completed stages are permanently retained (monotonic progression) and R6 enforces a 50-turn cap.
- Simultaneous claims on the same resource or position: Not applicable; turns are strictly sequential.
- Player elimination mid-round; turn order repair: If an agent drops out, the turn pointer skips to `(current_player + 1) % remaining_players`.
- Resource exhaustion (pieces, tokens, space, time): Not applicable; stones are reset at the start of each attempt.
- Termination guarantee: why the game provably ends: Guaranteed because `P_stage > 0` for all stages, stage progress is saved, and R6 enforces a hard turn ceiling.
## State representation
- Persistent state: `player_progress: array[N] of {stage: 1..6, sub_step: int}`, `active_player_idx: int`, `turn_count: int`.
- Per-turn ephemeral state: `current_attempt_result: bool`.
- Observable information: Fully observable by all agents.
## Action space
- `attempt_toss_catch()`: Executes the required dexterity check for current `(stage, sub_step)`.
## Playability notes
- Single-player-vs-AI: Natural; can be played as a solo speed challenge (fewest turns to clear Stage 6) or as a 1v1 turn race.
- Group games (n>4): Generalizes cleanly without modification since turns rotate independently.
- Physical-skill games: Abstracted into success probability checks; tactical pacing is retained.
- What is lost in the adaptation: The delicate physical balance of pebbles on the back of the hand, pebble spacing on the ground, and hand speed.
## Implementation hints
Very simple deterministic state machine wrapped around a Bernoulli randomizer. First milestone: Implement single-player stage advancement from Stage 1 through Stage 6 before adding multi-agent turn rotation and tie-breakers.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Five Stones (Pesëgurësh) (Albania). (n.d.). Games of Countries. https://gamesofcountries.com/games/al-albania/loja-me-pese-gure
@misc{gamesofcountries-al-albania-loja-me-pese-gure,
title = {Five Stones (Pesëgurësh) (Albania)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/al-albania/loja-me-pese-gure}
}