Formal Specification
Seven stones — Formal Specification
Armenia · ball-team · Confidence: high
← Back to game pageImplementation Suitability
Suitability: adaptation-requiredFidelity: discretizedGap-fills: 2
# Yot kar — AI-optimized specification
## General idea
A two-phase pyramid-knockdown dodgeball game whose distinguishing structural feature is asymmetric role persistence: a Builder-team win keeps the same team building next round, while a Defender-team win forces a role swap — success is rewarded differently depending on which side achieves it. A separate, non-scoring failure branch exists too: if the Builders can't even topple the pyramid in their 3 allotted throws, roles swap immediately with no point awarded to anyone.
## Formal model
- **Abstraction taken:** Real throwing accuracy, stealth approach to the center, ball-passing, and dodge/hit resolution are each abstracted into stochastic per-attempt outcomes, since the entry describes them qualitatively without numeric models.
- **Player/agent count:** 2 teams of 3-7 players (Builders, Defenders).
- **Turn model:** Sequential in the knockdown phase (one throw at a time, team-shared attempt budget); synchronous ticks in the rebuilding/tagging phase (all players act simultaneously).
## Formal rules
R1. Setup: 7 flat stones are stacked in decreasing size at the center; Builders line up at the throwing line 4-6 m away; Defenders position around the pyramid and perimeter (entry §1.1-1.2).
R2. Knockdown phase: Builders collectively get up to 3 `throw_at_pyramid()` attempts total (entry §2.1, "up to 3 total throws" — a shared team budget, not 3 per player), taken by any Builder in turn. Each attempt resolves a stochastic hit/topple check.
R3. Knockdown failure (entry §2.2): if all 3 attempts fail to topple the pyramid, roles swap immediately (Builders become Defenders and vice versa) with no point scored to either team; a new round begins with R1-R2.
R4. Knockdown success (entry §2.3): the instant a throw topples the pyramid, the round becomes ACTIVE — Builders scatter across the field, Defenders rush to retrieve the ball.
R5. Rebuilding (entry §3.1): any Builder near the center may submit `restack_stone()`, adding one stone to the pyramid per successful attempt; stones must be restacked in sequence (one at a time, cumulative).
R6. Ball handling (entry §3.2, §3.4): a Defender holding the ball may submit `pass_ball(teammate_id)` or `throw_at_player(builder_id)` at any time, but may take at most 3 steps of movement while holding the ball before being required to pass or throw. If a Defender attempts to move a 4th step while still holding the ball, the ball is turned over — treated as an automatic loose ball recoverable by either team [gap-fill: the entry states the 3-step cap as a restriction but not its violation consequence; a turnover is the minimal reading, consistent with how comparable step-limit rules function in this game family].
R7. Elimination (entry §3.3): a Builder struck by a thrown ball on the body below the head, before the ball touches the ground, is eliminated ("burned") and leaves the field for the remainder of the round.
R8. Builder win (entry §4.1): if all 7 stones are restacked (R5) while the active builder placing the final stone has not been struck, that builder performs the closing ritual (slap the top stone, palms on ground, "Yot Kar!" — flavor only). Builders score +1 point and retain the Builder role for the next round.
R9. Defender win (entry §4.2): if all Builders are eliminated (R7) before the 7 stones are fully restacked, Defenders score +1 point and roles swap for the next round.
R10. Match end (entry §5): the match ends the instant one team's cumulative score reaches N, an agreed threshold ("typically 5 points" is the entry's example, not a fixed rule) [gap-fill: N is treated as an external session parameter, not an invented fixed number].
## Edge cases
- Tie at the end: not applicable — R8 and R9 are mutually exclusive and jointly exhaustive within a round (either the pyramid completes first or the last Builder is eliminated first); the match itself ends the instant a team strictly reaches N (R10), which cannot produce a simultaneous tie.
- A player with no legal move: not applicable — Builders always have `restack_stone()` (while unstruck and stones remain) or evasive movement available; Defenders always have `pass_ball`/`throw_at_player` (while holding) or repositioning available.
- Repetition / cycles: bounded — R3's failed-knockdown branch has no scoring effect but does not repeat indefinitely without consuming the 3-throw budget each time it recurs; each active round (R4-R9) strictly progresses toward one of exactly two terminal outcomes (7 stones placed or all Builders eliminated), both bounded, finite counts.
- Simultaneous claims on one position: not applicable — `restack_stone()` attempts add to a shared cumulative stone count one at a time; there is no contest over which Builder places a given stone beyond ordinary turn-taking.
- Elimination mid-round and turn-order repair: an eliminated Builder (R7) simply leaves the field for the round; remaining Builders continue `restack_stone()` attempts unaffected, and Defender ball-passing is likewise unaffected by which specific Builders remain.
- Resource exhaustion: the knockdown phase's 3-throw budget (R2) is a hard cap whose exhaustion triggers R3 directly — this is the intended mechanic, not an anomaly.
- Termination guarantee: the knockdown phase is capped at exactly 3 throws before forcing a role swap (R2-R3), so it cannot stall. Each active round is bounded by two monotonically-progressing, finite counters — stones placed (capped at 7, R5/R8) and Builders eliminated (capped at team size, R7/R9) — either of which resolves the round with probability 1 given non-zero per-attempt success probabilities. The match itself is bounded by the finite score threshold N (R10).
## State representation
- Persistent (match) state: `score[team]`, `builder_team`, `defender_team`.
- Per-round state: `throws_used` (0-3, knockdown phase), `pyramid_toppled` (bool), `stones_placed` (0-7, rebuilding phase), `eliminated_builders` (set).
- Per-tick ephemeral state: `ball_holder`, `steps_taken_by_holder` (0-3).
- Observable information: fully observable — all positions, scores, stone counts, and elimination status are public; no hidden information.
## Action space
- `throw_at_pyramid()`: any Builder, knockdown phase; precondition: `throws_used < 3`.
- `restack_stone()`: any un-eliminated Builder, rebuilding phase; precondition: near the center, `stones_placed < 7`.
- `pass_ball(teammate_id)` / `throw_at_player(builder_id)`: the Defender holding the ball; precondition: rebuilding phase ACTIVE.
- `move(direction)`: any player; precondition: if holding the ball, `steps_taken_by_holder < 3` (R6).
## Playability notes
- Single-player-vs-AI: workable as human-Builder-vs-AI-Defenders (dodging and restacking) or human-Defender-vs-AI-Builders (coordinating passes and throws); the shared-budget knockdown phase (R2) gives a natural single-decision opening for either side.
- Reducing team size to 3v3: mechanically consistent — the entry's own range includes 3-per-team as a valid configuration.
- Physical-skill games: real throwing accuracy, stealth approach, and dodge reflexes are the entire game and are collapsed into stochastic checks (R2, R6-R7); no genuine athleticism is modeled.
- What is lost: the real tactical tension of a Builder timing a dash to the center against a Defender's passing lane, the pyramid-toppling crack of a well-thrown ball, and the cultural symbolism of rebuilding under siege.
## Implementation hints
State is modest (a stone counter, elimination set, ball-holder step counter, scores); the real design difficulty is calibrating the topple, restack-approach, and throw-accuracy probabilities, none of which the source quantifies. First milestone: implement one full round (R2-R9) with flat probabilities to verify the asymmetric role-persistence logic (R8 vs R9) and the non-scoring failed-knockdown branch (R3), then wire up the N-point match threshold (R10).
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Seven stones (Armenia). (n.d.). Games of Countries. https://gamesofcountries.com/games/am-armenia/yot-kar
@misc{gamesofcountries-am-armenia-yot-kar,
title = {Seven stones (Armenia)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/am-armenia/yot-kar}
}