Skip to main content
Formal Specification

Limping Crane (One-Legged Balance Combat) — Formal Specification

Turkmenistan · wrestling-combat · Confidence: low

← Back to game page

Implementation Suitability

Suitability: adaptation-requiredFidelity: probabilistic-proxyGap-fills: 4
# Agşak durna — AI-optimized specification ## General idea A balance-combat game where agents operate under strict single-leg locomotion constraints (one foot held continuously), colliding and pushing to force opponents off balance or out of bounds. The central mechanic is a balance-stamina threshold where physical collisions degrade stability, causing sudden eliminations when an agent's balance reaches zero or both feet touch the ground. ## Formal model - **Abstraction taken:** Continuous physical body checking while hopping is replaced by a discrete-tick arena model with a directional bumping mechanic; physical stability and leg fatigue are abstracted into a numerical balance attribute resolved via stochastic collision checks. - **Player/agent count:** 2 agents (1v1 duel mode) or 2 teams of n agents (n∈[4,12]). - **Turn model:** Real-time-ticked (e.g., discrete ticks of Δt=0.5 s) with simultaneous action commitment per tick. ## Formal rules R1. **Setup:** Agents initialize on opposite sides of a bounded 2D arena (grid or continuous boundary [−X,X]×[−Y,Y]). Each agent starts in `hopping` state with `balance = 100` and `held_leg = True`. R2. **Tick Actions:** On each tick, every active agent independently and simultaneously commits one action from `{Hop(direction, speed), Bump(target_agent_id), Rest(regain_balance)}`. R3. **Collision & Balance Resolution:** When agent A executes `Bump(B)` within contact range: - [gap-fill] The collision resolver calculates balance degradation: ΔB=f(speedA,massA,skillA)−g(stanceB,skillB). - Agent B suffers balance loss ΔB; agent A suffers recoil balance loss 0.3×ΔB. R4. **Elimination:** An agent is immediately marked `eliminated` and removed from the active arena if: - `balance <= 0` (agent falls or releases the raised ankle), or - The agent's coordinates move outside the arena boundary [−X,X]×[−Y,Y], or - [gap-fill] The agent selects illegal actions (e.g., punching or kicking). R5. **Round End & Scoring:** - A round ends immediately when all agents of one team (or one agent in 1v1) are eliminated. - The team with surviving agent(s) scores 1 point. - [gap-fill] If all remaining agents are eliminated on the exact same tick, the round is scored a tie (0 points to both) and replayed. R6. **Match Victory:** The first player/team to achieve a predetermined threshold of round wins (e.g., 2 out of 3 rounds) wins the match. ## Edge cases - Tie at the end condition: Handled by R5 — simultaneous elimination on the final tick results in a null round; the round is replayed until a decisive winner emerges. - A player with no legal move: Not applicable — at every tick, hopping in a valid direction, resting, or bumping adjacent agents is always available. - Repetition / cycles: [gap-fill] Bounded by an active round timer (e.g., Tmax=120 ticks); if timer expires without total elimination, the team with higher aggregate remaining balance wins the round. - Simultaneous claims on the same resource or position: When two agents move into the same cell/coordinate on the same tick, an elastic collision is resolved simultaneously, applying mutual balance penalties and repelling both agents. - Player elimination mid-round; turn order repair: Since turns are simultaneous tick-based, eliminated agents simply cease emitting actions and their physics colliders are removed; no turn order reconstruction is required. - Resource exhaustion (pieces, tokens, space, time): Spatial bounds are fixed; time exhaustion is resolved via the round timeout balance comparison rule. - Termination guarantee: why the game provably ends: Guaranteed by monotonic balance decay under exertion/contact combined with the finite Tmax round timeout. ## State representation - Persistent state: Match score per team/player, round number, active team rosters. - Per-player state: `position: (x, y)`, `velocity: (vx, vy)`, `balance: float [0, 100]`, `state: {active, eliminated}`, `held_leg: bool`. - Per-turn ephemeral state: Action commitments of all active agents for the current tick, contact graph of collisions. - Observable information: Fully observable — all agent positions, team affiliations, and visible balance bars are common knowledge. ## Action space - `Hop(dx, dy)`: Move in a 2D direction with bounded velocity ≤vmax. Precondition: Agent is active and `balance > 0`. - `Bump(target_id)`: Deliver a body check to an adjacent opponent within distance dcontact. Precondition: Distance ≤dcontact. - `Rest()`: Stationary posture recovering +r balance per tick, but vulnerable to incoming bumps. ## Playability notes - Single-player-vs-AI: Natural — the human controls one hopping combatant against an AI agent in a 1v1 duel ring or leads a team against coordinated bot agents. - Group games (n>4): Cleanly reducible to 1v1 duel format (as attested in the *Ýekebara* variant) without loss of core balance-combat mechanics. - Physical-skill games: Physical balance and agility are modeled via the stochastic collision function parameterized by `balance`, `mass`, and `skill` attributes. - What is lost in the adaptation: The somatic strain of gripping one's own ankle and the micro-proprioception of hopping balance on uneven desert turf are abstracted into a scalar balance meter. ## Implementation hints Low-to-medium complexity. A discrete 2D physics or grid environment with simultaneous tick updates is ideal. Branching factor per tick is small (discrete movement directions + target selection). Suggested first milestone: implement the 1v1 duel ring with simple balance degradation rules and directional bumping before expanding to multi-agent team melee.

Download as JSON

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

Download JSON
Cite this page

Limping Crane (One-Legged Balance Combat) (Turkmenistan). (n.d.). Games of Countries. https://gamesofcountries.com/games/tm-turkmenistan/agsak-durna

@misc{gamesofcountries-tm-turkmenistan-agsak-durna,
  title = {Limping Crane (One-Legged Balance Combat) (Turkmenistan)},
  year = {n.d.},
  publisher = {Games of Countries},
  url = {https://gamesofcountries.com/games/tm-turkmenistan/agsak-durna}
}