Formal Specification
Hopping Game — Formal Specification
Bulgaria · dexterity-throw · Confidence: medium
← Back to game pageImplementation 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 compartments with defined stance topologies: Single-leg (), Paired double-leg (), and Rest/Heaven (). 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 (). Turn order is fixed .
R2. Toss action:
- Active player attempts to throw the marker into target compartment .
- [gap-fill] Marker landing success is evaluated as .
- If toss fails (lands out of bounds or on line), turn ends immediately with fault; remains unchanged.
R3. Course Traversal Phase:
- If toss succeeds, player executes sequential hops along nodes , skipping target node .
- For each step in traversal:
- If node is Single (): player must execute single-leg landing.
- If node is Paired (): player must execute simultaneous dual-foot landing.
- If node : player enters Rest compartment and rotates 180 degrees.
R4. Balance / Fault verification:
- [gap-fill] At each traversed node , balance check evaluates .
- If any step incurs a fault (stepping on line or foot drop on single node), traversal aborts immediately; turn ends; remains unchanged.
R5. Marker Retrieval and Exit:
- On return traversal, upon reaching the node adjacent to , player executes pick-up action (balance check with base fault rate [gap-fill]), hops over node , and exits baseline.
- If exit is clean, advances: . 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 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 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 and , the probability of never clearing a level asymptotically approaches 0 as turns increase, guaranteeing eventual termination.
## State representation
- Persistent state: Player progress array , player skill vectors , active player index .
- 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 .
- 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 JSONCite 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}
}