Skip to main content
Formal Specification

Single-Leg Hopscotch — Formal Specification

Afghanistan · dexterity-small · Confidence: low

← Back to game page

Implementation Suitability

Suitability: engine-readyFidelity: probabilistic-proxyGap-fills: 4
# Chīndrō — AI-optimized specification ## General idea A turn-based hopscotch and territorial conquest game. Agents sequentially toss a flat marker stone through a 5-box linear course, hop on one leg through the grid while avoiding lines and opponent-owned "houses", kick the marker cleanly out across the baseline, and upon completing the course, attempt a backward blind toss to conquer private sanctuary squares. ## Formal model - **Abstraction taken:** Continuous physical single-leg balance, floor friction, and foot-kicking dexterity are abstracted into a discrete stage-progression state machine with stochastic success checks: P(toss success), P(hop success), and P(kick success), parameterized by agent dexterity. - **Player/agent count:** 1 to 6 individual agents. - **Turn model:** Strictly sequential, cyclic turn rotation. ## Formal rules R1. **Court Setup:** The court consists of 5 sequential numbered squares S1,S2,S3,S4,S5. Squares S1,S2,S3,S4 are single-foot boxes; S5 (*Samander*) is a rest sanctuary permitting a two-footed 180° turn. Each square has an `owner` attribute initialized to `None`. R2. **Turn Sequence & Stages:** Each agent maintains a progress counter `target_stage` ∈[1,5] and `houses_conquered` ⊆{1..5}. On an agent's turn: 1. **The Toss:** Agent attempts to toss the marker stone into square Sk, where k=target_stage. Success probability P(toss)=0.90−0.05×k. If failed, the turn ends immediately (*sokhtan*). 2. **The Hop Outward:** If toss succeeds, the agent traverses the court hopping from S1 to S5: - For every square j, if j is owned by an opponent (j∈housesopponent), the agent must jump entirely over j. Hop failure check: P(step on line)=0.05+0.08×is_jumped. - If any hop fails, the turn ends immediately. 3. **The Turnaround & Kick:** In S5, the agent turns around. On the return hop, when adjacent to square Sk, the agent executes a single-foot kick to propel the stone across the baseline. Success probability P(kick)=0.85. If failed, turn ends. 4. **Stage Advancement:** If all three steps succeed, `target_stage` increments by 1. R3. **House Conquest (*Khāna*):** When an agent successfully completes stage 5 (`target_stage > 5`): - The agent performs a backward blind toss to conquer a house. The engine samples a target square j∈{1..5} with equal probability among unowned squares. [gap-fill: uniform random distribution over unowned squares for backward toss]. - If an unowned square j is struck, `owner[j] = current_agent`. The agent's `target_stage` resets to 1 to begin a new conquest cycle. - If all squares are already owned, no house is awarded. R4. **Ownership Immunity & Blocking:** - An agent may rest on both feet inside any square they own (j∈housesself). - Opponents are strictly forbidden from entering j; they must hop over it, increasing their hop failure probability by +0.08. R5. **Foul & Turn Transition:** Any failure in toss, hop, or kick forfeits the remaining turn; state progress `target_stage` is preserved for the agent's next turn. R6. **Victory Condition:** The game terminates immediately when all 5 squares are owned by agents, or after a fixed maximum of M=20 rotation cycles. The agent with the most conquered houses wins. [gap-fill: 20-cycle safety timeout]. ## Edge cases - Tie at the end condition: If two agents have conquered an equal number of houses when the grid is filled or time expires, the tied agents perform a sudden-death single toss into S1; highest accuracy roll wins. [gap-fill: sudden-death toss for ties]. - A player with no legal move: Not applicable; an active agent always attempts their current stage progression. - Repetition / cycles: Bounded because house conquests are monotonic (squares once owned cannot be lost) and the global cycle cap (M=20) forces termination. - Simultaneous claims on the same resource or position: Not applicable; turns are strictly sequential. A conquered square is permanently locked to its first owner. - Player elimination mid-round; turn order repair: If an agent withdraws, their owned houses remain blocked or revert to neutral [gap-fill: houses revert to neutral `None` if an agent leaves], and turn order skips that agent. - Resource exhaustion (pieces, tokens, space, time): The 5 grid squares represent a finite exhaustible resource. Once all 5 squares are owned, R6 triggers immediate game end. - Termination guarantee: Provably terminates because the number of unowned squares is non-increasing and the simulation cycle counter strictly caps execution at 20 rounds. ## State representation - **Persistent state:** - `court_squares`: array of 5 elements, each `owner: agent_id | None` - `agent_states`: map of `agent_id -> {target_stage: 1..5, houses_owned: list[int]}` - `active_turn_index`: integer (0..N-1) - `cycle_count`: integer (1..20) - **Per-turn ephemeral state:** - `toss_result`: boolean - `hop_trace`: list of booleans (per-square hop checks) - `kick_result`: boolean - `house_awarded`: integer | None - **Observable information:** Fully observable. Court ownership status, agent stages, and turn sequence are completely public. ## Action space - `execute_stage_attempt()`: Attempt current stage (triggers stochastic sequential checks for toss, hopping sequence, and kick). - `execute_backward_toss()`: Available only when completing stage 5 (triggers house allocation roll). ## Playability notes - Single-player-vs-AI: Fully engine-ready and natural as a solitaire score-attack (conquer all 5 houses in fewest turns) or head-to-head match against an AI agent. - Group games (n>4): Plays smoothly with 2 to 6 agents; increasing player count increases competition for the 5 finite houses, creating high blocking incentives. - Physical-skill games: Physical balance and motor precision are parameterized as skill coefficients modifying base failure probabilities. - What is lost in the adaptation: The tactile chalk-line boundary judgment, physical leg fatigue, and vocal playground banter during backward tosses. ## Implementation hints Low complexity. Simple state machine with integer indices and a few probability checks. Suggested first milestone: implement single-agent 5-stage traversal and house conquest loop, then add multi-agent turn cycling and house blocking mechanics.

Download as JSON

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

Download JSON
Cite this page

Single-Leg Hopscotch (Afghanistan). (n.d.). Games of Countries. https://gamesofcountries.com/games/af-afghanistan/chendro

@misc{gamesofcountries-af-afghanistan-chendro,
  title = {Single-Leg Hopscotch (Afghanistan)},
  year = {n.d.},
  publisher = {Games of Countries},
  url = {https://gamesofcountries.com/games/af-afghanistan/chendro}
}