Formal Specification
Georgian hopscotch — Formal Specification
Georgia · dexterity-throw · Confidence: medium
← Back to game pageImplementation Suitability
Suitability: adaptation-requiredFidelity: discretizedGap-fills: 2
# Klasobana (კლასობანა) — AI-optimized specification
## General idea
A traditional Georgian hopscotch game played on a 10-cell chalked court ending in a semicircular "Heaven" (*tsa*). Players take sequential turns tossing a flat stone (*sala*) into ascending classes (1 through 10), completing single- and double-foot hopping circuits to retrieve the marker, and culminating in a blind toss to claim restricted "House" (*sakhli*) squares.
## Formal model
- **Abstraction taken:** Discrete topological grid navigation game over a graph of 10 cells plus Heaven (). Throw precision and hopping balance stability are modeled via parameterized stochastic checks. Successfully claiming houses adds traversability constraints for opponents.
- **Player/agent count:** players (, with ).
- **Turn model:** Strict sequential turn order ().
## Formal rules
R1. Court Topology & Cell Types:
- Court consists of ordered cells and Rest Semicircle ("Heaven"):
- Single cells: (require single-foot landing).
- Paired cells: and (require simultaneous dual-foot landing).
- `house_owner[C_j] = null` for all .
- Each player initializes `current_class = 1`, `houses_owned = 0`, `completed_circuit = false`.
R2. Active Turn — Phase 1: Stone Toss:
- Active player executes `toss_stone(target_class)` where .
- Evaluate throw outcome:
- **In-Bounds:** Stone lands cleanly in . Proceed to Hopping Phase (R3).
- **Line Foul / Miss:** Stone touches border or wrong square. Turn ends immediately (`fault = true`); resume at same class on next turn.
R3. Active Turn — Phase 2: Hopping Circuit:
- Player hops forward through cells , turns around, and hops back :
- Must skip the cell containing the stone ().
- Must skip any cell owned as a House by an opponent (`house_owner[C] != null and house_owner[C] != P_i`).
- May rest on both feet in owned House cells or .
- While adjacent to on return journey, player executes `retrieve_stone_on_one_foot()`.
- Each hop transition evaluates balance check .
- If any balance check fails, line is stepped on, or prohibited house is entered: Turn ends immediately in fault.
- If circuit completes without fault: .
R4. Phase 3 — Buying a House (*Sakhli*):
- When a player completes class 10 ():
- Player executes blind reverse toss `blind_house_toss()`.
- If stone lands in an unowned square , that square is assigned: `house_owner[C_k] = P_i`.
- Player increments `houses_owned` by 1.
R5. Victory Condition:
- The first player to complete all 10 classes and successfully claim a designated threshold of houses (default: 1 house) wins the game [gap-fill: standard 1-house completion win].
## Edge cases
- Tie at the end condition: Not applicable; first player to complete the master circuit and secure house ownership claims immediate victory.
- A player with no legal move: If all possible path cells are blocked by opponent houses making a jump topologically impossible, the trapped player may step through an opponent house at the cost of yielding 1 bonus point/turn pass to the owner [gap-fill: standard impassable court resolution].
- Repetition / cycles: Player progress monotonically ascends from 1 to 10; failed turns pass cleanly to the next player.
- Simultaneous claims on the same position: Strictly sequential turns; houses are permanently registered to a single owner.
- Elimination mid-round and turn-order repair: Players are not eliminated; turn rotates sequentially.
- Resource exhaustion: Exactly 10 numbered squares on the court.
- Termination guarantee: Each turn has a non-zero probability of successfully completing a class (), ensuring almost-sure termination in finite turns.
## State representation
- Persistent state:
- `player_progress`: Map of Player ID integer class .
- `house_ownership`: Map of cell index Player ID or null.
- `turn_order`: List of Player IDs.
- Ephemeral state:
- `active_player_idx`: Integer index in turn order.
- `stone_location`: Cell index or null.
- `current_hop_cell`: Integer position on grid.
- Observable information: Fully observable court markings, stone positions, and ownership statuses.
## Action space
- `toss_stone(target_class)`: Precision throw into target numbered square.
- `hop_step(destination_cell)`: Single- or double-foot movement along court graph.
- `retrieve_stone_on_one_foot()`: Bending retrieval check.
- `blind_house_toss()`: Post-completion blind throw over shoulder.
## Playability notes
- Single-player-vs-AI: Highly engaging path-planning and risk-management game where players balance throw accuracy against emerging spatial house obstacles created by AI rivals.
- Group reduction: Naturally playable from 2 to 6 players.
- Physical-skill games: Single-leg isometric balance, vestibular stability while bending over, and chalked line accuracy are modeled via agility and throw dispersion parameters.
- What is lost: The chalk dust on fingertips, the scrape of slate against asphalt, and the satisfaction of drawing a roof over your new "House".
## Implementation hints
Graph traversal model with dynamic edge traversability costs based on house ownership. First milestone: implement single player class 1..10 progression with throw and hop validation before adding multiplayer house claim obstacles.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Georgian hopscotch (Georgia). (n.d.). Games of Countries. https://gamesofcountries.com/games/ge-georgia/klasobana
@misc{gamesofcountries-ge-georgia-klasobana,
title = {Georgian hopscotch (Georgia)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/ge-georgia/klasobana}
}