Formal Specification
Limping Chicken (One-Legged Chaser Tag) — Formal Specification
Turkmenistan · chase-tag · Confidence: low
← Back to game pageImplementation 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 () 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 ticks).
- **Player/agent count:** 1 chaser agent ("chicken" / *towuk*), runner agents (, 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 bounded by walls. At tick , 1 agent is assigned role `CHASER` and positioned at ; all other 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: with .
- `CHASER` agents hop on one foot and may move only 1 step per tick: .
- [gap-fill] `CHASER` has a hopping stamina meter (); each hop consumes 1 stamina. If , 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 if the `CHASER` occupies the same grid cell or an adjacent cell () 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 .
- 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 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 wins.
## Edge cases
- Tie at the end condition: If two or more agents have identical survival point totals at , 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 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 ticks elapse.
- Termination guarantee: why the game provably ends: Guaranteed by the finite match duration .
## State representation
- Persistent state: Grid dimensions , match tick counter , 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 .
- 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 ( 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 (), 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 JSONCite 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}
}