Skip to main content
Formal Specification

Rotten Mares (Leapfrog Buck-Buck) — Formal Specification

Montenegro · strength-endurance · Confidence: high

← Back to game page

Implementation Suitability

Suitability: adaptation-requiredFidelity: abstractedGap-fills: 3
# Trule kobile — AI-optimized specification ## General idea A traditional team leapfrog and weight-bearing contest where one team forms a bent-over human chain ("the mare"), and the opposing team runs and vaults onto their backs. Jumpers attempt to mount all riders while distributing weight along the chain, while the base team attempts to bear the cumulative structural load until the riders fault or a countdown concludes. ## Formal model - **Abstraction taken:** The physical chain of crouching backs is modeled as a 1D grid of `M` slots (`0..M-1`), where each slot has a load capacity and current weight. Jumpers choose approach speed and target slot depth, resolving into landing accuracy and structural stability checks. - **Player/agent count:** 2 teams of `K = 5` agents each. - **Turn model:** Phased team turns: Jump Phase (sequential vaults by jumping team), followed by Endurance Phase (weight-bearing hold). ## Formal rules R1. Setup: State tracks `score_A = 0`, `score_B = 0`. Roles initialize: Team A is `JUMPERS`, Team B is `MARE`. Target score is `WIN_SCORE = 5`. R2. Formation: Mare team occupies `K` adjacent slots `[0..K-1]`. Each slot `i` has structural base strength `capacity[i] = base_strength[agent_i]`. R3. Jump Phase: - Jumpers vault in fixed order `1..K`. - Active jumper chooses target slot `target_slot in [0..K-1]` and `vault_force in [0.5..1.0]`. - Landing resolution: - [gap-fill] Landing slot sampled: `actual_slot = clamp(round(Normal(target_slot, 0.5 * (1.0 - vault_force))), 0, K-1)`. - [gap-fill] Slip/fall check: With probability `P(slip) = 0.05 + 0.10 * count_jumpers_in_slot(actual_slot)`, jumper falls off; turn ends immediately in a **Jumper Fault** (roles swap; 0 points scored). - Load update: `current_load[actual_slot] += weight[jumper]`. - [gap-fill] Collapse check: If `current_load[slot] > capacity[slot] * 1.5`, the mare buckles at slot `slot`; turn ends immediately in a **Mare Collapse** (Jumping team scores 1 point and retains jumping role). R4. Endurance Phase: - If all `K` jumpers successfully mount without slip or collapse, a holding check is evaluated for `T = 10` countdown ticks. - On each tick `t`, cumulative fatigue increases mare failure probability: `P(collapse_t) = sum(current_load) * 0.002 * t`. - If mare collapses during countdown: Jumping team scores 1 point and jumps again. - If mare holds through tick 10: Roles swap cleanly (0 points scored). R5. Match victory: The first team to accumulate `WIN_SCORE = 5` points wins the match. ## Edge cases - Tie at the end condition: Points are awarded sequentially; first team to reach `WIN_SCORE` wins immediately. - A player with no legal move: Not applicable; target slots and vault parameters are always available. - Repetition / cycles: Role swaps occur on jumper faults and successful holds; cumulative scoring ensures monotonic progression toward `WIN_SCORE`. - Simultaneous claims on the same resource or position: Handled via multiple occupancy stacking in R3 with increased slip risk. - Player elimination mid-round; turn order repair: Team-based game; forfeiting team concedes match. - Resource exhaustion: Structural capacity and slots reset fully at the start of each new turn. - Termination guarantee: Each turn has non-zero probability of collapse (`P > 0`), generating points; finite rounds guarantee termination. ## State representation - Persistent state: `scores: map`, `role_jumpers: TeamID`, `role_mare: TeamID`. - Per-turn state: `slot_occupancy: map>`, `slot_loads: array[K] of float`, `jumpers_mounted: int (0..K)`, `countdown_tick: int (0..10)`. - Observable information: Fully observable public game state. ## Action space - `vault(target_slot: int, vault_force: float)`: Precondition: Jump phase active, `0 <= target_slot < K`, `0.5 <= vault_force <= 1.0`. ## Playability notes - Single-player-vs-AI: Fun tactical team-management game (slot assignment vs. vault targeting). - Group games (n>4): Reduces naturally to 2 competing squads. - Physical-skill games: Physical impact and human structural stability modeled via discrete slot loading. - What is lost: Bruises, breath knocked out of lungs, and boisterous schoolyard shouting. ## Implementation hints Discrete slot array model with probability resolvers. Milestone 1: Implement the sequential vaulting loop and slot load accumulation. Milestone 2: Tune collapse and slip probability curves to match historical 50/50 balance between jumpers and mare.

Download as JSON

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

Download JSON
Cite this page

Rotten Mares (Leapfrog Buck-Buck) (Montenegro). (n.d.). Games of Countries. https://gamesofcountries.com/games/me-montenegro/trule-kobile

@misc{gamesofcountries-me-montenegro-trule-kobile,
  title = {Rotten Mares (Leapfrog Buck-Buck) (Montenegro)},
  year = {n.d.},
  publisher = {Games of Countries},
  url = {https://gamesofcountries.com/games/me-montenegro/trule-kobile}
}