Skip to main content
Formal Specification

Hopping Game — Formal Specification

Bulgaria · dexterity-throw · Confidence: medium

← Back to game page

Implementation Suitability

Suitability: engine-readyFidelity: probabilistic-proxyGap-fills: 3
# Kutsanka — AI-optimized specification ## General idea A turn-based sequential progression race across a topological grid graph. On each turn, an agent targets a stone throw into a monotonically increasing compartment index, followed by a deterministic path-traversal routine accompanied by stochastic single-leg balance and line-fault checks. ## Formal model - **Abstraction taken:** The 2D physical grid is modeled as an ordered graph of K=9 compartments with defined stance topologies: Single-leg (S∈{1,2,3,6}), Paired double-leg (P∈{(4,5),(7,8)}), and Rest/Heaven (H=9). Marker tossing and hopping execution are governed by parameterized accuracy and balance functions. - **Player/agent count:** 1 to 8 players, taking sequential turns in fixed rotation. - **Turn model:** Strictly sequential. ## Formal rules R1. Setup: Each player begins at level Li=1 (L∈[1,9]). Turn order is fixed [1..N]. R2. Toss action: - Active player i attempts to throw the marker into target compartment Li. - [gap-fill] Marker landing success is evaluated as Pland(Li)=max⁡(0.3,Acci−0.05⋅Li). - If toss fails (lands out of bounds or on line), turn ends immediately with fault; Li remains unchanged. R3. Course Traversal Phase: - If toss succeeds, player executes sequential hops along nodes 1→9→Exit, skipping target node Li. - For each step s in traversal: - If node s is Single (S): player must execute single-leg landing. - If node s is Paired (P): player must execute simultaneous dual-foot landing. - If node s==9: player enters Rest compartment and rotates 180 degrees. R4. Balance / Fault verification: - [gap-fill] At each traversed node s, balance check evaluates Pfault(s)=(1.0−Balancei)⋅0.08. - If any step incurs a fault (stepping on line or foot drop on single node), traversal aborts immediately; turn ends; Li remains unchanged. R5. Marker Retrieval and Exit: - On return traversal, upon reaching the node adjacent to Li, player executes pick-up action (balance check with 2× base fault rate [gap-fill]), hops over node Li, and exits baseline. - If exit is clean, Li advances: Li←Li+1. Active player retains turn if no faults occurred, or turn passes to next player in sequence per house rules. R6. Victory: The first player to successfully complete level Li=9 and the exit routine wins the game immediately. ## Edge cases - Tie at the end condition: Not applicable — turns are sequential; the first player to complete level 9 wins on detection. - A player with no legal move: Not applicable — throwing action is always available on turn start. - Repetition / cycles: Bounded: The state space for each player is an integer level Li∈[1,9] which strictly advances on successful turns and never decrements. - Simultaneous claims on the same resource or position: Turns are strictly sequential; the grid is completely cleared between turns. - Player elimination mid-round; turn order repair: If a player disconnects, their index is removed from turn rotation array without affecting other players' progress. - Resource exhaustion: Exactly 1 marker per player; grid nodes are static. - Termination guarantee: Because Pland>0 and Psuccess_run>0, the probability of never clearing a level asymptotically approaches 0 as turns increase, guaranteeing eventual termination. ## State representation - Persistent state: Player progress array [L1,…,LN], player skill vectors [(Acci,Balancei)], active player index c∈[1,N]. - Per-turn ephemeral state: Marker landed cell, traversal path trace, fault detected flag. - Observable information: Fully observable — all player levels and turn outcomes are public. ## Action space - `toss_marker(target_level)`: Precondition: Caller is active player, starts turn. - `execute_hop_sequence()`: Automated or stepped traversal execution over graph nodes. - `retrieve_marker()`: Executed at node adjacent to target cell during return leg. ## Playability notes - Single-player-vs-AI: Natural — Solitaire time/turn trial (fewest turns to reach level 9) or turn-based race against AI opponents. - Group games (n>4): Fully scalable; rotation order seamlessly supports any number of agents. - Physical-skill games: Motor balance and throwing precision are abstracted into orthogonal player attributes (Acc,Balance)∈[0.5,1.0]2. - What is lost: The kinetic joy of hopscotch rhythm, shoe friction, and chalk boundary visual feedback is replaced by probabilistic step evaluations. ## Implementation hints Very low complexity. The entire game is a 1D state transition machine with 9 discrete levels per agent. Suggested first milestone: implement a single-agent loop running from level 1 to 9 with stochastic toss/balance checks to verify expected turn-to-completion distributions.

Download as JSON

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

Download JSON
Cite this page

Hopping Game (Bulgaria). (n.d.). Games of Countries. https://gamesofcountries.com/games/bg-bulgaria/kutsanka

@misc{gamesofcountries-bg-bulgaria-kutsanka,
  title = {Hopping Game (Bulgaria)},
  year = {n.d.},
  publisher = {Games of Countries},
  url = {https://gamesofcountries.com/games/bg-bulgaria/kutsanka}
}