Skip to main content
Formal Specification

Five Stones (Pesëgurësh) — Formal Specification

Albania · dexterity-small · Confidence: low

← Back to game page

Implementation 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 JSON
Cite 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}
}