Formal Specification
One-legged hopping tag — Formal Specification
Georgia · chase-tag · Confidence: medium
← Back to game pageImplementation Suitability
Suitability: adaptation-requiredFidelity: probabilistic-proxyGap-fills: 2
# Askinkila — AI-optimized specification
## General idea
A one-legged balance-and-elimination game played in two structurally different modes on the same core constraint (continuous single-foot hopping inside a boundary): a free-for-all Chaser mode where one hopping player eliminates others by tag, and a contact Duel mode where paired or team hoppers use shoulder nudges to force each other into a fault. What is structurally distinct is that "losing" is not scored by an opponent's action alone but is self-triggered the instant a player's own balance fails (second foot, knee, or hand touches ground, or the boundary is crossed) — the physical constraint itself is the primary elimination mechanism, with tag/nudge only precipitating it.
## Formal model
- **Abstraction taken:** Real balance and fatigue cannot be modeled deterministically, so the physical act of maintaining a one-legged hop is abstracted as a per-tick fault probability rather than a hard-coded skill value. Ground contact, boundary contact, and tag/nudge outcomes remain deterministic checks; only the underlying "does this player's balance hold this tick" question is proxied stochastically.
- **Player/agent count:** 4-12 agents. In Chaser mode, 1 designated Chaser vs. N-1 Hoppers. In Duel mode, agents are paired 1v1 or grouped into two teams (team-duel variant, entry §4.2).
- **Turn model:** Continuous/simultaneous ticked model — all active agents act (move/tag/nudge/hold) every tick; there is no sequential turn order, matching the entry's description of live continuous hopping.
## Formal rules
R1. Setup: every active player lifts one foot off the ground (either foot, player's choice) and enters Hopping state on the supporting foot only, within the marked boundary.
R2. Fault check (all modes): each tick, an active player in Hopping state resolves a balance check; if it fails, or if the player's raised foot, knee, or hand touches the ground, the player transitions to Eliminated for the remainder of the round (entry's "datsva"/burning fault).
R3. Boundary check (all modes): a player whose position touches or crosses the outer arena boundary transitions to Eliminated for the remainder of the round, regardless of R2.
R4. Illegal-contact check (all modes): `tag`/`nudge` actions that involve open-hand pushing, tripping, or grabbing clothing are illegal. [gap-fill: the entry prohibits this contact but does not state a penalty; the fouling player is treated as immediately Eliminated, the same consequence as R2/R3, since no lesser penalty is described.]
R5. Chaser-mode action: the designated Chaser may execute `tag(target)` against any Hopping, non-Chaser player within reach; on success, target transitions to Eliminated for the remainder of the round.
R6. Duel-mode action: a Hopping player may execute `nudge(target)` (shoulder-to-shoulder contact only) against an opposing Hopping player; a successful nudge increases the target's fault probability for R2 on the following tick rather than eliminating directly, modeling the real mechanic of pushing an opponent off balance.
R7. Team-duel structure: teams are two disjoint sets of players; a team is Eliminated once every one of its members has individually transitioned to Eliminated (R2, R3, or R4).
R8. Win condition, Chaser mode: the round ends when exactly one non-Chaser Hopper remains active; that player wins and becomes the Chaser for the next round.
R9. Win condition, Duel mode (individual pair): the round ends when one of the two paired players is Eliminated; the other wins.
R10. Win condition, Team duel: the round ends when one team is fully Eliminated (R7); the surviving team wins.
R11. Win conditions R8-R10 are mode-specific and mutually exclusive within a given round (a round is played in exactly one mode), and each is individually exhaustive for its mode — no other terminal state exists in the source rules.
## Edge cases
- **Tie at end:** Not addressed by the entry for the case where the last two active players fault on the same tick. [gap-fill: declare a shared/joint victory for that round.]
- **Player with no legal move:** Never occurs while Hopping — `hop_move`, and mode-appropriate `tag`/`nudge`, are always available; Eliminated players simply have no actions for the rest of the round.
- **Repetition/cycles:** Not possible in the strict sense — elimination is monotonic and irreversible within a round (R2-R4), so the count of active players strictly decreases or stays constant each tick; there is no path back to a prior state.
- **Simultaneous claims on one position:** Not applicable — hopping players occupy distinct positions and the only "claims" are tag/nudge actions against a target, which resolve independently per target with no shared-resource contention.
- **Elimination mid-round and turn-order repair:** Not applicable — there is no turn order (play is continuous/simultaneous); an Eliminated player is simply excluded from all future action resolution for the remainder of that round, and the next round restarts fresh per R1.
- **Resource exhaustion:** Not applicable — no consumable resource exists in the rules beyond the players' own standing balance.
- **Termination guarantee:** `termination_guaranteed: true`. Under the stochastic-proxy model (R2), every active player faces a non-zero per-tick fault probability, and elimination is irreversible (see Repetition/cycles). Active-player count is therefore a non-increasing process that, given unbounded ticks and non-zero per-tick fault probability for each remaining player, reaches its terminal value (1 survivor in Chaser mode, 0 members of one side in Duel/team-duel mode) with probability 1. A purely deterministic model with zero fault probability would not terminate — the stochastic-proxy framing is required for this guarantee, which is why `determinism: stochastic-proxy` is declared above rather than plain `deterministic`.
## State representation
- Persistent state: selected mode (Chaser | Duel-individual | Duel-team); Chaser identity (Chaser mode only); team assignments (team-duel only); boundary geometry.
- Per-tick ephemeral state: each player's status (`Hopping` | `Eliminated`); fault-probability modifier per player (elevated for one tick after being the target of a successful `nudge`, R6).
- Observable information: fully observable. This is a pure physical dexterity/tag game with no hidden information — every player's stance and position is visible to all others at all times.
## Action space
- `hop_move(dx, dy)`: reposition within the boundary while remaining in Hopping state; always legal for active players.
- `tag(target_id)`: Chaser mode only; precondition per R5.
- `nudge(target_id)`: Duel mode only; precondition per R6 (shoulder contact only, per R4).
- `hold()`: remain in place while hopping; always legal.
## Playability notes
- Single-player-vs-AI: Natural for Chaser mode — a human can play Hopper against an AI Chaser, or vice versa, with the fault-probability model standing in for balance. Duel mode is playable 1v1 against a single AI opponent without modification.
- Reducing n>4 to 2 agents: Chaser mode degenerates to a plain tag-or-fault duel once only 2 players remain, which is a legitimate (if less rich) endgame the real game already produces naturally at round's end. Team-duel mode loses its multi-body arena chaos and decoy dynamics when reduced to 1v1, but the mechanic itself (R2-R4, R6) survives intact.
- Physical-skill modeling: the entry's balance, leg strength, and fatigue are not decomposed into separate stats — they are folded into a single per-tick fault probability (R2) that can optionally be made to rise over time to model fatigue. Nudge success (R6) is modeled as a probability modifier rather than a discrete contest, since the entry gives no scoring or strength-comparison rule for nudges.
- What is lost: the real-time balance skill itself, the escalating physical comedy of players teetering, and the "askinkila run" social forfeit custom described in the entry's Cultural notes, which has no formal-rule analogue.
## Implementation hints
Represent each active player with a single `fault_probability` scalar (baseline constant, temporarily boosted by an incoming `nudge`) rather than physics simulation. Branching factor per tick is small: one `hop_move` plus at most one `tag`/`nudge` per active player. Representational trap: do not model elimination as removal from a turn queue (there is none) — model it as a per-player status flag checked every tick, since Chaser mode and Duel mode differ only in which actions are available, not in the underlying elimination loop. First milestone: implement Chaser mode with a fixed constant fault probability and no nudge mechanic, to validate the elimination-to-single-survivor loop (R2, R5, R8) before adding Duel-mode nudging (R6).
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
One-legged hopping tag (Georgia). (n.d.). Games of Countries. https://gamesofcountries.com/games/ge-georgia/askinkila
@misc{gamesofcountries-ge-georgia-askinkila,
title = {One-legged hopping tag (Georgia)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/ge-georgia/askinkila}
}