Formal Specification
Five Stones — Formal Specification
Serbia · dexterity-small · Confidence: low
← Back to game pageImplementation Suitability
Suitability: engine-readyFidelity: probabilistic-proxyGap-fills: 2
# Piljci — AI-optimized specification
## General idea
A sequential dexterity progression game where agents attempt a series of 6 increasingly challenging hand-eye manipulation stages with 5 pebbles. Each attempt is resolved by a skill-based success probability parameterized by stage difficulty and risk choices; a failure halts the active agent's turn until their next rotation, while completing stage 6 wins the match.
## Formal model
- **Abstraction taken:** The physical airborne toss, ground scoop, and catch are modeled as discrete stage-transition checks: `P_success(stage, agent_skill) = f(difficulty(stage), skill_agent, scatter_geometry)`.
- **Player/agent count:** `N` agents (`N in 2..6`, default `N = 2`).
- **Turn model:** Strictly sequential round-robin rotation. On their turn, an agent continues advancing through sub-stages until committing a fault or winning.
## Formal rules
R1. Setup: Agents are indexed `0..N-1`. Each agent has a saved progress level `stage[i] = 1` and `substep[i] = 1`. Total stages `K = 6`.
R2. Stage Definitions:
- Stage 1 (Jednoja): 4 substeps (pick 1, pick 1, pick 1, pick 1). Difficulty per substep.
- Stage 2 (Dvoja): 2 substeps (pick 2, pick 2). Difficulty per substep.
- Stage 3 (Troja): 2 substeps (pick 3, pick 1). Difficulty for pick-3, for pick-1.
- Stage 4 (Četveroja): 1 substep (pick all 4 at once). Difficulty .
- Stage 5 (Kapija): 4 substeps (flick through gate 1, 2, 3, 4). Difficulty per substep.
- Stage 6 (Volujka): 1 substep (back-of-hand flip to palm snatch). Difficulty .
R3. Turn Execution:
- On turn, active agent `i` executes `attempt_substep(stage[i], substep[i])`.
- Success probability: `P_succ = max(0.05, min(0.95, skill[i] - D_{stage, substep}))`.
- If successful:
- Advance `substep[i] += 1`.
- If all substeps of `stage[i]` are complete: advance `stage[i] += 1`, `substep[i] = 1`.
- If `stage[i] == 7`: Agent `i` wins immediately; game terminates.
- If not yet won, agent `i` immediately executes the next substep.
- If failed (fault): Turn ends immediately. Progress `(stage[i], substep[i])` is preserved for agent `i`'s next turn. Turn passes to `(i + 1) % N`.
R4. [gap-fill] Max Round Cap: If no agent completes Stage 6 within `MaxRounds = 50` total rotations, the agent with the highest stage (and highest substep) is declared the winner; if tied, a Stage 6 sudden-death shoot-off is executed.
## Edge cases
- Tie at the end condition: Impossible during standard play because turns are sequential and the first to clear Stage 6 wins instantly. Resolved under R4 cap by sudden-death.
- A player with no legal move: Not applicable; an agent must execute their current substep attempt.
- Repetition / cycles: Bounded by R4's hard round limit and non-decreasing stage progress.
- Simultaneous claims on the same resource or position: Not applicable; turns are strictly sequential.
- Player elimination mid-round / turn order repair: [gap-fill] If an agent disconnects, they are skipped in future turn rotations without affecting other players' stage counters.
- Resource exhaustion: Not applicable; pebbles are invariant non-depleting tokens.
- Termination guarantee: Guaranteed by monotonic stage progress () and R4 round cap.
## State representation
- Persistent state: `progress: list[tuple[stage: int, substep: int]]`, `active_agent: int`, `rotation_count: int`.
- Per-turn ephemeral state: `current_substep_success: bool`.
- Observable information: Fully observable public state.
## Action space
- `execute_substep(risk_profile: enum[cautious, balanced, aggressive])`: Chooses slight risk adjustments modifying speed vs accuracy.
## Playability notes
- Single-player-vs-AI: Natural; can be played as a solitaire time-trial or head-to-head race against AI agents with calibrated skill parameters.
- Group games (n>4): Generalizes seamlessly up to 6 players.
- Physical-skill games: Juggling reflexes, finger flick accuracy, and spatial pickup clusters are mapped directly into substep difficulty parameters .
- What is lost in the adaptation: The tactile sensation of cold river pebbles and the physical risk of stones colliding on ground scatter are abstracted.
## Implementation hints
Very simple deterministic state machine wrapped around a Bernoulli success sampler. First milestone: implement 2-agent turn loop verifying stage transitions from 1 to 6.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Five Stones (Serbia). (n.d.). Games of Countries. https://gamesofcountries.com/games/rs-serbia/piljci
@misc{gamesofcountries-rs-serbia-piljci,
title = {Five Stones (Serbia)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/rs-serbia/piljci}
}