Skip to main content
Formal Specification

Banana Stalk Horse Racing — Formal Specification

Thailand · festival-ritual · Confidence: low

← Back to game page

Implementation Suitability

Suitability: adaptation-requiredFidelity: discretizedGap-fills: 4
# Ma Kaan Kluay — AI-optimized specification ## General idea A traditional sprint race and roleplaying pastime where children straddle self-crafted banana leaf stalk horses (*Ma Kaan Kluay*), gripping reins and galloping along a sprint course while vocalizing horse whinnies. The formal model abstracts the race into a linear track where agents manage acceleration and stamina while avoiding dropping the stalk steed. ## Formal model - **Abstraction taken:** The craft and dramatic roleplay elements of the banana stalk horse are treated as pre-match setup; the racing contest is discretized into a linear track of length `L = 40` units with simultaneous pace selection per tick, stochastic mount-stability checks, and a time-loss penalty for dropping the horse. - **Player/agent count:** 2 to n players (commonly 2 to 6). - **Turn model:** Simultaneous discrete action selection per tick. ## Formal rules R1. Setup: All racers begin behind the start line at position `x = 0` in parallel lanes of length `L = 40`. Each racer begins mounted (`mounted = true`, `stamina = 100`, `penalty_ticks = 0`). R2. Pace Selection: On each tick, every mounted racer with `penalty_ticks == 0` simultaneously chooses a gait: - `Trot`: advance 1 unit, stamina cost 1, mount drop probability `P(drop) = 0.0`. - `Canter`: advance 2 units, stamina cost 3, mount drop probability `P(drop) = 0.05`. - `Gallop_Sprint`: advance 3 units, stamina cost 8, mount drop probability `P(drop) = 0.20`. R3. [gap-fill] Mount Drop and Recovery: If a mount drop occurs, the racer immediately halts (`mounted = false`) and incurs a mandatory recovery penalty of `penalty_ticks = 1` to retrieve and remount the stalk. R4. [gap-fill] Stamina Exhaustion: If an agent's stamina reaches `0`, they are limited strictly to the `Trot` action until stamina is partially restored via a resting tick (+10 stamina, 0 movement). R5. [gap-fill] Lane Integrity: Racers run in independent parallel lanes; physical pushing or lane interference is disallowed and results in immediate disqualification. R6. [gap-fill] Victory Condition: The first racer whose position `x >= L` at the end of a tick wins. In the event of a simultaneous finish, the racer with the greater excess distance `x - L` wins; if equal, the racer with higher remaining stamina is awarded victory. ## Edge cases - Tie at the end condition: Resolved by comparing excess distance past the finish line (`x - L`), followed by highest remaining stamina; if identical, a shared win is recorded. - A player with no legal move: Not applicable; an agent always has access to active gaits or the recovery/rest action. - Repetition / cycles: Not possible; distance along the track is strictly non-decreasing (`delta_x >= 0`). - Simultaneous claims on the same resource or position: Parallel lane assignment prevents spatial contention. - Player elimination mid-round; turn order repair: A disqualified racer is removed from active state; remaining racers continue simultaneously without affecting turn structure. - Resource exhaustion: Track distance `L = 40` is finite; race concludes upon the first crossing. - Termination guarantee: why the game provably ends: Every active tick produces positive forward displacement (or a bounded 1-tick recovery), guaranteeing all racers reach `x >= 40` in finite time. ## State representation - Persistent state: - `track_length`: integer (default 40) - `racer_states[n]`: `{ position: [0, L+5], mounted: boolean, stamina: [0, 100], penalty_ticks: [0, 1], status: active | finished | disqualified }` - `current_tick`: integer - Per-turn ephemeral state: - `chosen_gaits[n]`: gait action chosen by each agent for the tick. - `sampled_drops[n]`: boolean result of mount-stability checks. - Observable information: Fully observable public state (all positions, stamina values, and mount statuses are visible to all racers). ## Action space - `trot()`: Advance 1 unit; 100% mount retention; 1 stamina cost. - `canter()`: Advance 2 units; 95% mount retention; 3 stamina cost. - `gallop_sprint()`: Advance 3 units; 80% mount retention; 8 stamina cost. - `remount()`: Mandatory action when `mounted == false`; restores mounted status. - `rest()`: 0 movement; recovers +10 stamina. ## Playability notes - Single-player-vs-AI: Straightforward racing game; AI evaluates risk-adjusted expected velocity based on distance remaining and current stamina. - Group games (n>4): Easily supports 2 to 20 racers running simultaneously in parallel. - Physical-skill games: The physical balance of running while gripping a banana stalk between one's legs is modeled via the gait speed vs drop probability tradeoff. - What is lost in the adaptation: The tactile experience of harvesting fresh banana leaf stalks, carving horse ears with a bamboo skewer, and the communal joy of vocal whinnying (*Hi-Hi!*). ## Implementation hints - Very low computational complexity. - Suggested first milestone: Implement the deterministic movement and stamina loop, then add stochastic drop events and tie-breaking criteria.

Download as JSON

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

Download JSON
Cite this page

Banana Stalk Horse Racing (Thailand). (n.d.). Games of Countries. https://gamesofcountries.com/games/th-thailand/ma-kaan-kluay

@misc{gamesofcountries-th-thailand-ma-kaan-kluay,
  title = {Banana Stalk Horse Racing (Thailand)},
  year = {n.d.},
  publisher = {Games of Countries},
  url = {https://gamesofcountries.com/games/th-thailand/ma-kaan-kluay}
}