Skip to main content
Formal Specification

Limping Chicken (One-Legged Chaser Tag) — Formal Specification

Turkmenistan · chase-tag · Confidence: low

← Back to game page

Implementation Suitability

Suitability: engine-readyFidelity: discretizedGap-fills: 4
# Agşak towuk — AI-optimized specification ## General idea An asymmetric pursuit-evasion tag game where the chaser is subject to severe kinematic handicaps (single-leg hopping, lower top speed or movement frequency) while pursuing unhindered two-legged runners within a bounded grid. The strategic core lies in cornering, boundary exploitation, and stamina/rest management where the chaser must balance burst hopping against rest phases. ## Formal model - **Abstraction taken:** Continuous physical running and hopping across open terrain are mapped to a discrete 2D grid (N×M) with discrete time ticks. Single-leg hopping is formalized as a movement point handicap (e.g., runners move 2 cells per tick, chaser moves 1 cell per tick, or chaser must rest every k ticks). - **Player/agent count:** 1 chaser agent ("chicken" / *towuk*), n runner agents (n≥1, typically 4–19). - **Turn model:** Real-time-ticked with simultaneous action commitment per tick. ## Formal rules R1. **Grid Setup:** The playing field is a discrete 2D grid of size W×H bounded by walls. At tick t=0, 1 agent is assigned role `CHASER` and positioned at (xcenter,ycenter); all other n agents are assigned role `RUNNER` and placed at randomized initial vacant coordinates. R2. **Movement Constraints:** - `RUNNER` agents may move up to 2 orthogonal/diagonal steps per tick: (dx,dy)∈{−2,−1,0,1,2}2 with ‖(dx,dy)‖∞≤2. - `CHASER` agents hop on one foot and may move only 1 step per tick: (dx,dy)∈{−1,0,1}2. - [gap-fill] `CHASER` has a hopping stamina meter (S∈[0,Smax]); each hop consumes 1 stamina. If S=0, the chaser enters a 2-tick `Resting` state where both feet touch the ground and tagging is disabled. R3. **Tagging / Capture:** - A tag occurs on tick t if the `CHASER` occupies the same grid cell or an adjacent cell (‖pchaser−prunner‖∞≤1) with an active runner while in `Hopping` state. - [gap-fill] If a `RUNNER` moves onto or beyond the boundary of the grid, that runner is automatically counted as tagged (out-of-bounds penalty). R4. **Role Transfer & Continuation:** - The tagged runner immediately converts to the new `CHASER` at the start of tick t+1. - The former chaser converts to a `RUNNER` and is granted a [gap-fill] 3-tick immunity period during which they cannot be re-tagged by the new chaser. R5. **Scoring & End Condition:** - [gap-fill] The game is played across a fixed duration of Tmax ticks (e.g., 300 ticks). - Each agent accumulates survival points: +1 point per tick spent as a `RUNNER`. - The agent with the highest cumulative survival score at Tmax wins. ## Edge cases - Tie at the end condition: If two or more agents have identical survival point totals at Tmax, the tie is broken by the fewest number of times tagged; if still equal, the match is declared a draw. - A player with no legal move: Not applicable — remaining stationary `(0, 0)` is always a legal action. - Repetition / cycles: The bounded game horizon Tmax guarantees that movement cycles or evasive loops cannot continue indefinitely. - Simultaneous claims on the same resource or position: Runners can occupy the same cell without collision. If the chaser enters a cell containing multiple runners, the runner with the lowest total survival score is tagged first. - Player elimination mid-round; turn order repair: Not applicable in standard role-transfer tag; if an agent disconnects, they are removed and role transfer falls back to the nearest active runner if the chaser disconnected. - Resource exhaustion (pieces, tokens, space, time): Bounded grid limits space; match terminates strictly when Tmax ticks elapse. - Termination guarantee: why the game provably ends: Guaranteed by the finite match duration Tmax. ## State representation - Persistent state: Grid dimensions (W,H), match tick counter t∈[0,Tmax], leaderboard score table `Dict[AgentID, int]`. - Per-player state: `position: (x, y)`, `role: {CHASER, RUNNER}`, `stamina: int`, `immunity_timer: int`, `hopping_state: {Hopping, Resting}`. - Per-turn ephemeral state: Simultaneous movement intent vector for all agents a→t. - Observable information: Fully observable — all agent coordinates, roles, and stamina states are public knowledge. ## Action space - `Move(dx, dy)`: Move to target relative offset. Precondition: Destination must be within role speed limits and within grid boundaries. - `Rest()`: Voluntarily pause movement to regenerate stamina (+2 per tick). Precondition: Agent is `CHASER`. ## Playability notes - Single-player-vs-AI: Natural — 1 human player as `CHASER` cornering AI `RUNNER` bots, or 1 human `RUNNER` evading an AI `CHASER`. - Group games (n>4): Reduces cleanly to a 2-agent duel (1 Chaser vs 1 Runner) with a smaller grid (10×10), retaining the core geometry of cornering without losing the evasive dynamic. - Physical-skill games: Physical hopping fatigue and balance are abstracted into the discrete speed differential and stamina/resting mechanic. - What is lost in the adaptation: The somatic awkwardness and humorous physical stumbling of hopping on one foot are replaced by pure grid pathfinding and evasion math. ## Implementation hints Low complexity. Standard discrete 2D grid world. Branching factor is 9 for chaser, 25 for runners. Suggested first milestone: implement a 1v1 grid environment with speed differential and role transfer, then add multi-agent support and stamina limits.

Download as JSON

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

Download JSON
Cite this page

Limping Chicken (One-Legged Chaser Tag) (Turkmenistan). (n.d.). Games of Countries. https://gamesofcountries.com/games/tm-turkmenistan/agsak-towuk

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