Formal Specification
Single-Leg Hopscotch — Formal Specification
Afghanistan · dexterity-small · Confidence: low
← Back to game pageImplementation 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: , , and , 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 . Squares are single-foot boxes; (*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` and `houses_conquered` . On an agent's turn:
1. **The Toss:** Agent attempts to toss the marker stone into square , where . Success probability . If failed, the turn ends immediately (*sokhtan*).
2. **The Hop Outward:** If toss succeeds, the agent traverses the court hopping from to :
- For every square , if is owned by an opponent (), the agent must jump entirely over . Hop failure check: .
- If any hop fails, the turn ends immediately.
3. **The Turnaround & Kick:** In , the agent turns around. On the return hop, when adjacent to square , the agent executes a single-foot kick to propel the stone across the baseline. Success probability . 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 with equal probability among unowned squares. [gap-fill: uniform random distribution over unowned squares for backward toss].
- If an unowned square 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 ().
- Opponents are strictly forbidden from entering ; they must hop over it, increasing their hop failure probability by .
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 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 ; 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 () 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 JSONCite 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}
}