Skip to main content
Formal Specification

Five Stones (Greek Knucklebones / Jacks) — Formal Specification

Greece · dexterity-small · Confidence: high

← Back to game page

Implementation Suitability

Suitability: engine-readyFidelity: probabilistic-proxyGap-fills: 2
# Pentovola — AI-optimized specification ## General idea A turn-based progressive dexterity challenge where agents advance through an escalating series of stone-snatching and catching stages (1-by-1 up to 4-at-once, arch flicking, and back-of-hand catching). Physical dexterity, hand speed, and spatial proximity are abstracted into a parameterized success probability function per attempt. ## Formal model - **Abstraction taken:** The physical throwing, ground-snatching, and aerial catching motions are modeled as discrete challenge actions with a Bernoulli success probability P(success)=f(stage_difficulty,cluster_dispersion,agent_skill). - **Player/agent count:** 2 to N agents (typically 2). - **Turn model:** Sequential turn rotation. An agent continues attempting stage steps until a fault occurs or the stage sequence completes. ## Formal rules R1. Setup: State tracks for each agent i: `current_stage` ∈{1..6}, `sub_step` ∈{1..4}, and `total_score` ∈ℕ. R2. Stage definitions: - Stage 1 ("Ones"): 4 sub-steps. Each sub-step picks up 1 ground stone while catching the tossed stone. - Stage 2 ("Twos"): 2 sub-steps. Each picks up a pair of stones simultaneously. - Stage 3 ("Threes"): 2 sub-steps. First picks 1 stone; second picks 3 stones simultaneously. - Stage 4 ("Fours"): 1 step. Places 4 stones down, then picks all 4 up in a single sweep. - Stage 5 ("Cave"): 4 sub-steps. Flicks each stone through the hand arch individually without disturbing others. - Stage 6 ("Back-of-Hand Catch"): Samples number of stones caught on back-of-hand k∈{0..5}, awarding 20×k points upon successful flip-catch into palm. R3. Attempt resolution: - Each attempt consumes an action `attempt_step()`. - [gap-fill] Execution success probability is modeled as P(success)=max⁡(0.10,skill−0.08×stage). - If success = True: `sub_step += 1`. If `sub_step > max_sub_steps[stage]`, `stage += 1` and `sub_step = 1`. - If success = False: Agent faults ("καίγεται"); turn ends immediately, preserving `(current_stage, sub_step)` for the next round. R4. Completing Stage 6: - If an agent completes Stage 6, their `total_score` increases by the points earned, and their `current_stage` resets to Stage 1. R5. Win condition: - First agent whose `total_score` reaches or exceeds the target threshold (e.g. 100 points) wins immediately. ## Edge cases - Tie at the end condition: Not applicable — turns are sequential; the first agent to reach target points terminates the game as sole winner. - A player with no legal move: Not applicable — `attempt_step()` is always available on an active turn. - Repetition / cycles: Bounded — non-zero probability of stage progression (P>0) ensures that total points accumulate monotonically toward the threshold almost surely. - Simultaneous claims on the same resource or position: Not applicable — strictly sequential turn execution. - Player elimination mid-round; turn order repair: Not applicable (no mid-game elimination; agents rotate in fixed round-robin order). - Resource exhaustion: Not applicable — stones are permanent state tokens. - Termination guarantee: With P(success)≥0.10, the expected number of turns to complete cycles and reach 100 points is strictly finite. [gap-fill] A hard cap of 50 total game rounds forces a win by highest current score. ## State representation - Persistent state: - `agents`: List of agent states, each containing `[stage, sub_step, score, skill_param]`. - `active_agent`: Integer index. - `target_score`: Integer (default 100). - `round_count`: Integer counter. - Per-turn ephemeral state: - `last_attempt_result`: Boolean success/failure flag. - Observable information: Fully observable. ## Action space - `attempt_step()`: Execute current sub-step attempt for active stage. - `choose_target_subset(stone_indices)`: [Optional strategic layer] Select which specific cluster of stones to sweep up first. ## Playability notes - Single-player-vs-AI: Natural — plays directly as a solo race or against an AI agent with calibrated skill levels. - Group games (n>4): Generalizes seamlessly to N players; each player waits for their turn rotation without inter-agent dependency. - Physical-skill games: Motor dexterity abstracted to Bernoulli trial parameterized by stage difficulty. - What is lost: Tactile pebble feel, finger dexterity, and the visual drama of mid-air stone tracking. ## Implementation hints - Very low computational complexity; state is a compact tuple per agent. - Implement as a simple Markov Decision Process or stochastic turn loop. - First milestone: Implement stages 1 through 6 progression logic with deterministic success to verify stage-transition assertions.

Download as JSON

Download the full game corpus entry for this game as structured JSON.

Download JSON
Cite this page

Five Stones (Greek Knucklebones / Jacks) (Greece). (n.d.). Games of Countries. https://gamesofcountries.com/games/gr-greece/pentovola

@misc{gamesofcountries-gr-greece-pentovola,
  title = {Five Stones (Greek Knucklebones / Jacks) (Greece)},
  year = {n.d.},
  publisher = {Games of Countries},
  url = {https://gamesofcountries.com/games/gr-greece/pentovola}
}