Formal Specification
Ekka-dokka (Bengali Traditional Hopscotch / Kutkut) — Formal Specification
Bangladesh · dexterity-small · Confidence: high
← Back to game pageImplementation Suitability
Suitability: engine-readyFidelity: probabilistic-proxyGap-fills: 2
# Ekka-dokka — AI-optimized specification
## General idea
A traditional Bengali hopscotch and precision dexterity game played on a 6-compartment court (*Ekka*, *Dokka*, *Tekka*, *Choukka*, *Pokka*, *Lashti*). Players toss a ceramic/stone marker (*chara*) into sequential boxes and navigate the grid on one foot, using toe-kicks to propel the marker cleanly out of the court. Surviving the kicking and forehead-balance stages allows a player to blindly toss the marker backward to "buy a house" (*ghar kena*), granting exclusive rest privileges and imposing jump barriers on opponents.
## Formal model
- **Abstraction taken:** Physical single-leg balance, shard tosses, and precision foot-flicks are abstracted into stochastic execution checks parameterized by target difficulty and player dexterity attributes. The 6-box court geometry and house ownership map are formalized as a discrete state array.
- **Player/agent count:** 2 to 4 players competing individually.
- **Turn model:** Strictly sequential turns in fixed rotation. A foul immediately ends the active player's turn, and the player resumes from their current stage on their next turn.
## Formal rules
R1. Setup: Court consists of 6 sequential chambers numbered 1 to 6: Box 1 (*Ekka*), Box 2 (*Dokka*), Box 3 (*Tekka*), Box 4 (*Choukka* — natural rest box), Box 5 (*Pokka*), and Box 6 (*Lashti* — semicircle). All chambers start unowned (`house_owner[1..6] = NONE`).
R2. Stage Progression: Each player advances through 3 sequential stages:
- Stage 1: Sequential Toss-and-Kick for Boxes (Box 4 is skipped for tossing as it is a rest zone).
- Stage 2: Forehead Balance Walk (navigate boxes 1 to 6 with shard balanced on forehead).
- Stage 3: House Purchase (*Ghar Kena* — blind backward toss from Box 6 into the grid).
R3. Stage 1 Execution (Toss & Kick):
- Toss: Player declares target box . Toss lands cleanly inside box with probability:
If the toss touches a line or lands outside, a **Foul** occurs (turn ends).
- Hop & Kick: Player hops into box on one foot and kicks the shard out through the baseline:
If kicked onto a line or out through an illegal side boundary, a Foul occurs.
- If both actions succeed, the player advances to target box (or Stage 2 if ).
R4. Stage 2 Execution (Forehead Balance):
- [gap-fill] Player hops through all 6 chambers with shard on forehead:
If the shard drops or player steps on a line, a Foul occurs. If successful, player advances to Stage 3.
R5. Stage 3 Execution (House Purchase / *Ghar Kena*):
- Standing at Box 6 with back turned, player throws shard blindly backward.
- Landing box is sampled uniformly across eligible unclaimed boxes:
- If clean, the player acquires permanent ownership of that box (`house_owner[B_land] = player_id`).
- The player's stage resets to Stage 1 to pursue additional houses.
R6. House Ownership Mechanics:
- The owner of a house may rest on both feet inside their own house.
- Opponents are strictly forbidden from entering an owned house and must leap entirely over it in a single hop.
- Leaping over an owned house adds a difficulty penalty ( to kick/toss success probabilities).
R7. Win Condition: The first player to acquire 2 houses (or highest count when all 6 boxes are claimed) wins the match.
R8. [gap-fill] Tiebreaker: If tied in house count when all eligible chambers are claimed, players participate in a sudden-death forehead-balance hopping race.
## Edge cases
- Tie at the end condition: Resolved by the sudden-death balance hop tiebreaker per R8.
- A player with no legal move: Active player always possesses an action (toss, balance hop, or blind throw).
- Repetition / cycles: Bounded by monotonic stage advancement and the finite pool of 6 purchasable chambers.
- Simultaneous claims on the same resource or position: Turns are strictly sequential; a chamber claimed by one player becomes permanently unavailable to others.
- Player elimination mid-round; turn order repair: Fouls simply yield the turn to the next player in rotation; no player is permanently eliminated before match end.
- Resource exhaustion (pieces, tokens, space, time): When all 6 chambers become owned houses, the match concludes immediately and houses are tallied.
- Termination guarantee: Non-zero success probabilities per attempt guarantee that players inevitably complete stages and purchase houses until the win threshold is reached.
## State representation
- Persistent state:
- `house_owners`: Array of length 6 with values in .
- `player_progress`: Array of structs per player `{current_stage: 1..3, target_box: 1..6, houses_owned: int}`.
- `active_player_idx`: Integer .
- Per-turn ephemeral state:
- `current_attempt_outcome`: Result of stochastic toss, kick, or blind-throw roll.
- Observable information: Fully observable public game state (no hidden information).
## Action space
- `execute_toss_and_kick(target_box)`: Attempt Stage 1 toss and kicking navigation.
- `execute_forehead_balance()`: Attempt Stage 2 balance hop.
- `execute_house_toss()`: Attempt Stage 3 blind backward throw to claim an unclaimed chamber.
## Playability notes
- Single-player-vs-AI: Natural and easy to simulate; AI chooses conservative vs aggressive stage pacing and targets high-value rest boxes (e.g. Box 3/5) to restrict opponent paths.
- Group games (n>4): Plays cleanly for 2 to 4 players by standard round-robin rotation.
- Physical-skill games: Single-leg balance and precision kicking are parameterized through bounded probability curves.
- What is lost in the adaptation: The physical muscular fatigue of prolonged single-leg hopping on hot village dirt.
## Implementation hints
Low complexity. The entire game is a clean finite-state machine over a 6-element array with stage counters per player. Milestone 1: implement stage transitions, foul recovery, and house ownership modifiers; Milestone 2: simulate multi-player games to verify balanced house purchase rates.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Ekka-dokka (Bengali Traditional Hopscotch / Kutkut) (Bangladesh). (n.d.). Games of Countries. https://gamesofcountries.com/games/bd-bangladesh/ekka-dokka
@misc{gamesofcountries-bd-bangladesh-ekka-dokka,
title = {Ekka-dokka (Bengali Traditional Hopscotch / Kutkut) (Bangladesh)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/bd-bangladesh/ekka-dokka}
}