Formal Specification
Five stones — Formal Specification
Armenia · dexterity-small · Confidence: high
← Back to game pageImplementation Suitability
Suitability: adaptation-requiredFidelity: probabilistic-proxyGap-fills: 3
# Hing qar — AI-optimized specification
## General idea
A jacks-family dexterity game whose defining structural feature is per-player *checkpointed progress* through a fixed 6-stage curriculum (5 hand-figure stages plus a master finale): a fault ends the turn immediately but does not erase progress within the completed portion of the curriculum — the player resumes at their saved checkpoint on their next turn. The race is therefore not about beating an opponent directly but about who exhausts the fixed, ordered skill sequence first.
## Formal model
- **Abstraction taken:** Each fine-motor sub-action (tossing, scooping a specific quantity without disturbing neighbors, catching the falling stone) is collapsed into a single stochastic success check per attempt, since the entry describes these as skill actions with no numeric accuracy model.
- **Player/agent count:** 2-6 agents, playing individual sequential turns in a fixed rotation.
- **Turn model:** Sequential; on each turn the active player attempts consecutive sub-steps of the curriculum starting from their saved checkpoint, continuing until either a fault ends the turn or (on a single very lucky turn) they complete the whole curriculum.
## Formal rules
R1. Setup: turn order is determined by a `catch_toss()` contest — all players simultaneously toss and catch the 5 stones on the back of the hand; the player catching the most goes first (entry §1.2) [gap-fill: the entry does not state a tiebreak for an equal catch count; resolved by a repeat `catch_toss()` among tied players, the same mechanism used to establish order in the first place].
R2. The curriculum is a fixed ordered sequence of sub-steps: Stage 1 (4 individual pickups), Stage 2 (2 paired pickups: 2+2), Stage 3 (2 sweeps: 3+1), Stage 4 (2 motions: place-all-4-flat, then sweep-all-4), Stage 5 (4 sequential gate-flicks), Finale (2 sub-steps: back-hand catch of all 5, then re-toss caught cleanly palm-down). Each agent has a persistent `checkpoint` (stage, sub-step index) initialized to (Stage 1, 0).
R3. On a turn, the active player repeatedly submits `attempt_substep()` for the sub-step immediately following their `checkpoint`. Each attempt independently resolves a stochastic success check [gap-fill: the entry gives no numeric success probability, and does not state whether later stages are harder than earlier ones, though their described complexity strongly suggests it; a per-stage success probability that is non-increasing with stage number is assumed as the minimal faithful reading].
R4. Success: the sub-step is marked complete, `checkpoint` advances to the next sub-step (or next stage, if the completed sub-step was the last in its stage), and the same turn continues with another `attempt_substep()` for the new current sub-step.
R5. Fault (entry §4.1-4.3: dropped air-stone, touched an adjacent stone, or wrong quantity collected): the turn ends immediately. `checkpoint` is reset to the start of the *stage* that was in progress when the fault occurred (entry §4.4: "resume from the exact stage where they faulted") [gap-fill: the entry says "stage," not "sub-step," so partial progress within the faulted stage is lost, while any earlier fully-completed stages remain banked].
R6. Turn rotation: after a fault (R5) or, in the rare case, after completing the full curriculum in one turn, control passes to the next player in the fixed rotation (R1) who has not yet completed the curriculum.
R7. Win condition (entry §5): the moment any player's `checkpoint` reaches "Finale complete," that player wins the game immediately, regardless of how many turns it took them to get there.
R8. Scoring (entry §3.3): independently of R7, each stone caught during the Finale's second sub-step optionally awards +10 points to a running score; this is a secondary tally the entry itself notes as parenthetical to full completion ("or 1 full completed game") and does not gate the win condition.
## Edge cases
- Tie at the end: not applicable — R7 triggers the instant one player's checkpoint reaches completion; no other player can reach completion on the exact same discrete event, since turns are strictly sequential.
- A player with no legal move: not applicable — the active player always has `attempt_substep()` available for their current checkpoint.
- Repetition / cycles: possible in the sense that a player can fault at the same stage repeatedly across many turns, but this is not a state cycle — `checkpoint` never regresses below the start of the currently-attempted stage, and every earlier stage, once completed, is permanently banked (R5), so total progress across the game is monotonically non-decreasing.
- Simultaneous claims on one position: not applicable — turns are strictly sequential with one active player at a time; there is no shared contested resource.
- Elimination mid-round and turn-order repair: not applicable — no player is ever removed from the rotation; a fault only ends the current turn (R5), and rotation simply continues to the next player (R6).
- Resource exhaustion: not applicable — the 5 stones are reused every turn; no consumable resource depletes.
- Termination guarantee: each `attempt_substep()` carries a fixed positive success probability (R3), and the curriculum has a finite, fixed number of sub-steps (17 total: 4+2+2+2+4+2+... i.e., a small fixed count). Since progress is monotonically non-decreasing and each remaining sub-step is retried on every subsequent turn a player reaches it, the probability that a given player has *not* completed the curriculum after t turns tends to 0 as t → ∞ (each of finitely many sub-steps is eventually cleared almost surely). With multiple players making independent progress in rotation, the game terminates with probability 1.
## State representation
- Persistent (game) state: `checkpoint[player]` (stage, sub-step), `score[player]` (optional, R8), `turn_order`, `active_player_index`.
- Per-turn ephemeral state: none beyond the active player's ongoing sequence of `attempt_substep()` calls until a fault or the curriculum completes.
- Observable information: fully observable — all players see every other player's checkpoint and score; no hidden information.
## Action space
- `catch_toss()`: any player, setup only (R1).
- `attempt_substep()`: the active player only; precondition: it is their turn; resolves against the sub-step immediately following their current `checkpoint`.
## Playability notes
- Single-player-vs-AI: natural — a human and an AI opponent each accumulate checkpoint progress in alternating turns, racing to complete the curriculum first; this maps cleanly to a turn-based digital adaptation.
- Reducing 6 players to 2: trivial — the rotation and checkpoint mechanic are already fully player-independent; more players only means more turns pass between a given player's attempts.
- Physical-skill games: the entire fine-motor skill (tossing, scooping precise quantities, avoiding disturbing neighboring stones) is collapsed into the single stochastic success check per sub-step (R3); no genuine dexterity is modeled.
- What is lost: the actual hand-eye coordination and tactile precision of each named figure (the Gate, the paired scoops, the back-hand catch), the traditional counting rhymes and chants that accompanied play, and the physical object-handling texture of real stones or knucklebones.
## Implementation hints
State per player is tiny (a (stage, sub-step) pair and a score), and the total curriculum is a short fixed list, so this is computationally trivial. The actual design difficulty is choosing per-stage success probabilities that make later, more complex stages meaningfully harder without the game stalling; the source gives no numbers, so probabilities should be tuned empirically. First milestone: implement the checkpoint/fault/resume loop (R3-R6) with a flat success probability across all stages to validate turn rotation and the win trigger (R7), then differentiate stage difficulty.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Five stones (Armenia). (n.d.). Games of Countries. https://gamesofcountries.com/games/am-armenia/hing-qar
@misc{gamesofcountries-am-armenia-hing-qar,
title = {Five stones (Armenia)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/am-armenia/hing-qar}
}