Skip to main content
Formal Specification

Coconut Stilt Walking — Formal Specification

Thailand · dexterity-small · Confidence: low

← Back to game page

Implementation Suitability

Suitability: engine-readyFidelity: probabilistic-proxyGap-fills: 3
# Doen Kala — AI-optimized specification ## General idea A balance and sprinting race where players walk atop inverted coconut shells clamped against the soles of their feet with hand cords. Locomotion requires continuous upward tension and synchronized steps. The formal model discretizes the race course into track units where agents balance pace acceleration against the risk of losing foot contact and incurring reset penalties. ## Formal model - **Abstraction taken:** Continuous physical balance and cord tension are discretized into a linear track of length `L = 30` units. On each tick, agents choose a movement pace; higher paces carry an increasing risk of a foot-slip event modeled by a parameterized stochastic check. - **Player/agent count:** 2 to n players (commonly 2 to 6). - **Turn model:** Simultaneous discrete ticks. ## Formal rules R1. Setup: All agents start at position `x = 0` in parallel lanes of length `L = 30`. Each agent begins in a balanced standing state (`fault = false`, `penalty_ticks = 0`). R2. On each tick, every active agent with `penalty_ticks == 0` simultaneously selects a movement pace: - `Safe_Walk`: advances 1 unit; slip probability `P(slip) = 0.02`. - `Fast_Trot`: advances 2 units; slip probability `P(slip) = 0.15`. - `Sprint`: advances 3 units; slip probability `P(slip) = 0.35`. R3. [gap-fill] Slip and Penalty: If a slip occurs on a step, the agent advances only 1 unit for that tick, enters the fault state (`fault = true`), and incurs a recovery penalty of `penalty_ticks = 1` representing the time needed to reposition feet onto the shells and pull the cords taut. R4. [gap-fill] Recovery: An agent with `penalty_ticks > 0` cannot select a movement pace and must take a mandatory `Recover` action that decrements `penalty_ticks` by 1. R5. Lane Discipline: [gap-fill] Agents operate in isolated parallel tracks; collision between racers is disallowed. R6. Victory Condition: The first agent whose position `x >= L` at the end of a tick wins. If multiple agents cross in the same tick, the agent with the largest `x` (furthest distance past the line) wins; if still equal, the agent who suffered fewer total slip penalties wins. ## Edge cases - Tie at the end condition: If multiple racers reach or exceed `x >= 30` on the same tick, ties are broken by excess distance past the finish line; if equal, the racer with fewer cumulative slip penalties wins; if still tied, a shared victory is awarded. - A player with no legal move: Not applicable; an agent with `penalty_ticks == 0` chooses from the 3 movement paces, and an agent in penalty executes the mandatory `Recover` action. - Repetition / cycles: Not possible; positional progress along the track is strictly non-negative (`delta_x >= 0`), ensuring forward-only advancement. - Simultaneous claims on the same resource or position: Parallel lane assignment prevents positional contention. - Player elimination mid-round; turn order repair: In standard sprint format, no mid-race elimination occurs; in disqualification variants (e.g. lane violation), the disqualified agent's state is set to `eliminated` and remaining racers continue simultaneously without turn order disruption. - Resource exhaustion: Track distance `L = 30` is finite; the race concludes immediately upon the first valid crossing. - Termination guarantee: why the game provably ends: Every active tick yields non-negative movement, and recovery penalties are bounded (`penalty_ticks = 1`), guaranteeing that all agents eventually reach `x >= 30` within a finite number of ticks. ## State representation - Persistent state: - `track_length`: integer (default 30) - `agent_states[n]`: `{ position: [0, L+5], penalty_ticks: [0, 1], slip_count: integer, status: active | finished | disqualified }` - `current_tick`: integer - Per-turn ephemeral state: - `chosen_paces[n]`: pace action selected by each agent for the current tick. - `sampled_slips[n]`: boolean outcome of the stochastic balance check per agent. - Observable information: Fully observable public state (all racer positions, penalty states, and lane assignments are visible to all agents). ## Action space - `safe_walk()`: Advance 1 unit, 2% slip risk. - `fast_trot()`: Advance 2 units, 15% slip risk. - `sprint()`: Advance 3 units, 35% slip risk. - `recover()`: Mandatory action when `penalty_ticks > 0`; resets foot position. ## Playability notes - Single-player-vs-AI: Natural fit; the player races against one or more AI opponents utilizing dynamic programming or Q-learning over risk/reward pace thresholds. - Group games (n>4): Fully scalable to any number of parallel lanes without rule modifications or coalition complications. - Physical-skill games: Plantar foot grip and tactile cord pulling are represented by the risk-calibrated pace selection and slip probability curve. - What is lost in the adaptation: The physical sensation of rough coconut shells under bare feet, rhythmic shell clatter (*gop-gep*), and bodily balancing reflexes. ## Implementation hints - Trivial state representation; ideal for quick simulation benchmarks. - Branching factor is exactly 3 actions per tick per agent. - Suggested first milestone: Implement deterministic track traversal and verify tie-breaking logic, then integrate the stochastic slip model.

Download as JSON

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

Download JSON
Cite this page

Coconut Stilt Walking (Thailand). (n.d.). Games of Countries. https://gamesofcountries.com/games/th-thailand/doen-kala

@misc{gamesofcountries-th-thailand-doen-kala,
  title = {Coconut Stilt Walking (Thailand)},
  year = {n.d.},
  publisher = {Games of Countries},
  url = {https://gamesofcountries.com/games/th-thailand/doen-kala}
}