Skip to main content
Formal Specification

Hopscotch / Paradise Game — Formal Specification

Denmark · dexterity-small · Confidence: high

← Back to game page

Implementation Suitability

Suitability: engine-readyFidelity: probabilistic-proxyGap-fills: 3
# Hinkeleg (Paradisleg) — AI-optimized specification ## General idea A turn-based precision tossing and single-foot hopping game played on a standard 9-compartment chalk grid (Rudeparadis). Players advance through stages 1 to 9 by tossing a stone into the target cell without touching chalk lines, navigating the hop sequence while skipping the stone's compartment, executing split-foot landings on paired squares, retrieving the stone on the return hop, and reaching "Paradise". ## Formal model - **Abstraction taken:** The continuous physical motor coordination of tossing a flat stone (*hinkesten*) and maintaining single-leg balance across chalk lines is abstracted into discrete stochastic checks parameterized by target square distance and player dexterity attributes. The grid topology and sequential stage progression remain fully discrete and deterministic. - **Player/agent count:** 1 to 6 players. - **Turn model:** Strictly sequential turns in fixed cyclic rotation. ## Formal rules R1. **Grid Topology:** The board is an ordered sequence of 9 cells: Single(1), Single(2), Single(3), Paired(4,5), Single(6), Paired(7,8), SemiCircle(9, "Paradis"). Each player tracks a persistent stage counter sp∈{1…9}, initialized to sp=1. R2. **Turn Structure:** On player p's turn, they attempt to complete stage sp. The turn consists of: (1) Toss Phase, (2) Forward Hopping Circuit, (3) Stone Retrieval, and (4) Return Exit. R3. [gap-fill] Toss Resolution:** Player attempts `toss_stone(s_p)`. Success probability is modeled as P(toss_success)=max⁡(0.10,min⁡(0.95,θaim−0.05⋅sp)), where θaim∈[0,1] is the player's aim skill. If the toss fails (lands on a boundary line or incorrect square), the turn ends immediately; sp is unchanged. R4. **Forward Hopping Sequence:** If the toss succeeds, the player traverses the grid from cell 1 to 9, strictly skipping cell sp: - In single cells (c∈{1,2,3,6}), the player must execute a single-foot landing (`hop_single`). - In paired cells (c∈{(4,5),(7,8)}), the player executes a simultaneous two-foot split landing (`hop_split`), landing left foot in cell 2k and right foot in 2k+1. - In cell 9 ("Paradis"), the player lands on two feet and executes a 180∘ pivot (`hop_pivot`). R5. **Return Hopping and Retrieval:** The player traverses the grid in reverse (9→1). When landing in the cell immediately preceding sp, the player executes `retrieve_stone(s_p)`. R6. [gap-fill] Balance Failure Check:** Each hopping step and retrieval action incurs a balance fault probability P(fault)=0.03⋅(1−θbal), where θbal∈[0,1] is the player's balance skill. If any fault occurs, the turn ends immediately; sp is unchanged. R7. [gap-fill] Turn Continuation & Progression:** If both the toss and the complete hopping/retrieval circuit succeed without fault, stage counter increments (sp←sp+1). The player retains the turn and immediately attempts stage sp+1 (traditional continuous turn until first fault). R8. **Win Condition:** The first player to successfully complete stage 9 ("Paradis") wins the match immediately. R9. **Turn Turnover:** When a player faults on either toss or hop, the turn passes to (p+1)(modN). ## Edge cases - Tie at the end condition: Not applicable; turns are strictly sequential, so exactly one player completes stage 9 first and triggers the immediate win condition. - A player with no legal move: Not applicable; `toss_stone(s_p)` is always legally available at turn start. - Repetition / cycles: Bounded by non-decreasing stage counters sp (which never decrement) and positive success probabilities, guaranteeing almost-sure termination. - Simultaneous claims on the same resource or position: Not applicable; only one player occupies the course at any given time. - Player elimination mid-round; turn order repair: If an agent disconnects, they are removed from the rotation array; turn pointer advances to the next remaining index. - Resource exhaustion (pieces, tokens, space, time): Not applicable; each player uses a single reusable stone token. - Termination guarantee: why the game provably ends: Absorbing Markov chain where state vector s→=(s1,…,sN) has strictly non-negative transitions and an absorbing goal state si=9 reachable with positive probability on every turn. ## State representation - **Persistent state:** Number of players N, active player index p, per-player stage counters {si}i=1N, skill parameters {(θaim,i,θbal,i)}i=1N. - **Per-turn ephemeral state:** Stone position on grid, current player cell coordinate, step index in hopping circuit. - **Observable information:** Fully observable; all players observe the public grid state, stone landing location, and current stage of all competitors. ## Action space - `toss_stone(target_cell)`: Attempt to land stone in target square sp. Precondition: turn start. - `hop_single(cell_id)`: Hop on single leg into single square. Precondition: cell is valid next step in circuit and cell_id≠sp. - `hop_split(left_cell, right_cell)`: Land both feet in paired squares. Precondition: valid paired step. - `retrieve_stone(cell_id)`: Pick up stone from adjacent compartment while balancing. Precondition: current cell adjacent to sp. ## Playability notes - Single-player-vs-AI: Natural; works seamlessly as a solo time/turn trial (fewest turns to reach Paradise) or 1v1 turn race against an AI with parameterized skills. - Group games (n>4): Generalizes cleanly; turn-order rotation natively supports any N≥1 without structural alterations. - Physical-skill games: Tossing accuracy and dynamic hopping balance are modeled via logistic/clamped scalar skill probabilities. - What is lost in the adaptation: The somatic strain of hopping on one foot, physical chalk friction, and real-time fine motor stone calibration. ## Implementation hints Extremely low complexity. Can be implemented as a simple state machine with an array of cell types and a sequential stage counter. First milestone: implement single-agent 9-stage progression loop with deterministic toss/hop success before introducing stochastic noise parameters.

Download as JSON

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

Download JSON
Cite this page

Hopscotch / Paradise Game (Denmark). (n.d.). Games of Countries. https://gamesofcountries.com/games/dk-denmark/hinkeleg

@misc{gamesofcountries-dk-denmark-hinkeleg,
  title = {Hopscotch / Paradise Game (Denmark)},
  year = {n.d.},
  publisher = {Games of Countries},
  url = {https://gamesofcountries.com/games/dk-denmark/hinkeleg}
}