Skip to main content
Formal Specification

Traditional leapfrog jumping game — Formal Specification

Azerbaijan · chase-tag · Confidence: medium

← Back to game page

Implementation Suitability

Suitability: adaptation-requiredFidelity: probabilistic-proxyGap-fills: 5
# Ənzəli — AI-optimized specification ## General idea A single-croucher leapfrog game combining a fixed 7-stage trick curriculum (each stage adding a specific rhyme-synchronized flourish — an elbow tap, a heel click, a 3-second freeze) with a single shared Croucher role that rotates to whichever Vaulter faults next. Unlike a checkpoint-reset penalty, faulting here changes *who crouches*, not how far back a Vaulter's own progress falls — their personal stage progress is preserved across turns spent crouching. ## Formal model - **Abstraction taken:** Each stage's specific acrobatic flourish (elbow tap, heel click, freeze, broad leaps) is collapsed into a single stochastic success check per attempt, since the entry names these actions without a numeric accuracy model. Global posture-height escalation (entry §3.1) modifies the check's difficulty rather than being separately simulated. - **Player/agent count:** 6-15 agents; exactly one holds the Croucher role at any time, the rest are active Vaulters, each with an independent persistent `checkpoint` (0-7). - **Turn model:** Sequential; Vaulters take turns attempting the next stage in their own personal sequence against the single current Croucher. ## Formal rules R1. Setup: one agent is chosen Croucher by counting rhyme (uniform random selection, entry §1.1), assuming the bent-forward "cushion" posture (entry §1.2). All agents' persistent `checkpoint` starts at 0. Global `tier = 1` (low knee-bend, entry §3.1). R2. Turn: the active Vaulter (cycling through all non-Croucher agents in a fixed rotation) submits `vault_attempt()` for the stage immediately following their own `checkpoint`, performing that stage's specific required action: Stage 1 (plant hands, shout "Bir — Ənzəli!"), Stage 2 (clear cleanly, shout "İki — Təkəli!"), Stage 3 (elbow-tap the Croucher's back while clearing), Stage 4 (click heels mid-air), Stage 5 (slap the Croucher's back with one hand while clearing), Stage 6 (land adjacent and freeze motionless 3 seconds), Stage 7 (land and take three broad leaps without stopping) — entry §2. R3. Resolution: each `vault_attempt()` resolves a stochastic success check whose probability decreases with `tier` and with the targeted stage's inherent complexity [gap-fill: the entry gives no numeric success-rate curve, so a monotonically decreasing function of both tier and stage number is the minimal faithful reading, matching how comparable progressive-stage games in this batch are formalized]. R4. Success: the Vaulter's `checkpoint` advances by 1. A Vaulter whose `checkpoint` reaches 7 is recognized as a Master Jumper (`Cəld atlananlar`, entry §5) — an honorific, not a removal from play; they continue taking turns [gap-fill: the entry does not state what a Vaulter does after completing Stage 7; continuing to participate is assumed, consistent with the entry's "continuous rounds" framing]. R5. Fault (entry §4.1): a `vault_attempt()` that fails to clear, touches the Croucher with legs/feet, stumbles on landing, or omits the stage's required rhyme/trick action is a fault (`yandı`). R6. Role reversal (entry §4.2): the faulted Vaulter immediately becomes the new Croucher; the previous Croucher rejoins the Vaulter rotation. The previous Croucher's `checkpoint` is unaffected by having crouched — they resume vaulting from wherever their own progress last stood [gap-fill: the entry states only that the faulted player "replaces" the Croucher, with no mention of any progress reset for either the newly-crouching player or the returning one; preserving both agents' `checkpoint` values is the minimal reading, in contrast to this batch's `hing-qar` entry, where an explicit stage-reset-on-fault rule *is* stated — the two games are read differently here because their source texts differ]. R7. Tier escalation (entry §3.1): `tier` advances from 1 to 2 to 3 across "progressive rounds" [gap-fill: the entry does not state the exact trigger; advancing tier once every Vaulter in the current rotation has completed at least one attempt is the minimal reading consistent with "progressive rounds," matching the analogous gap-fill used for this batch's `plenji` entry]. R8. Match end: the entry specifies no competitive win condition, only continuous play with Master Jumper recognition (R4) as an individual honorific (entry §5) [gap-fill: treated honestly — there is no formal terminal state, matching the entry's own framing]. ## Edge cases - Tie at the end: not applicable — there is no competitive win condition; multiple Vaulters can independently achieve Master Jumper status without affecting each other. - A player with no legal move: not applicable — the active Vaulter always has `vault_attempt()` available for their next stage; the Croucher's only "action" is holding posture, which requires no decision. - Repetition / cycles: expected and structural — the Croucher role can rotate repeatedly among the same players via consecutive faults, and this is not a bug; each individual Vaulter's `checkpoint` is nonetheless monotonically non-decreasing over time (R4, R6), so total progress across the group never regresses even though role-holding cycles freely. - Simultaneous claims on one position: not applicable — exactly one Croucher exists at a time (R1, R6), and turns are strictly sequential. - Elimination mid-round and turn-order repair: not applicable — no agent is ever removed from play; a fault (R5-R6) reassigns the Croucher role rather than eliminating anyone. - Resource exhaustion: not applicable — no consumable resource; the vaulting curriculum and Croucher role are reused indefinitely. - Termination guarantee: **not guaranteed.** The entry gives this game no competitive win condition, only continuous play with an individual honorific for reaching Stage 7 (R4, R8) — matching the pattern of other "no formal endpoint" games in this batch. `termination_guaranteed: false` reflects this honestly. ## State representation - Persistent (session) state: `croucher_id`, `tier` (1-3), `checkpoint[player]` for every agent (including the current Croucher, whose value is simply not advancing while they crouch). - Per-turn ephemeral state: `active_vaulter`, the stage currently being attempted. - Observable information: fully observable — all checkpoints, the current Croucher, and the current tier are public; no hidden information. ## Action space - `vault_attempt()`: the active Vaulter only; precondition: it is their turn, `checkpoint < 7`. - (implicit `hold_posture`): the current Croucher; no decision required. ## Playability notes - Single-player-vs-AI: workable as a human Vaulter racing an AI Vaulter's checkpoint progress, both sharing an AI- or rule-driven Croucher rotation; less natural as a literal solo activity since the Croucher role inherently requires a second participant. - Reducing 6-15 players to 2: degenerate but functional — with only 2 agents, the Croucher role simply alternates between them on every fault, since there is no third Vaulter to absorb the rotation. - Physical-skill games: real vaulting height, landing control, and the specific acrobatic flourish per stage (elbow tap, heel click, freeze) are the entire game and are collapsed into the tier/stage-scaled stochastic success check (R3); no genuine gymnastic skill is modeled. - What is lost: the actual escalating rhyme chant that names each stage, the physical comedy of the freeze-in-place Stage 6, the chain and hat-balancing variants, and the social camaraderie of watching peers attempt harder tiers. ## Implementation hints State is modest (a checkpoint per player, a tier, a Croucher pointer); the real design difficulty is calibrating the tier/stage-to-success-probability curve, which the source gives no numbers for. First milestone: implement the checkpoint/fault/role-reversal loop (R2-R6) with a flat success probability at `tier = 1` to validate the Croucher-rotation mechanic and the persistent (non-reset) checkpoint behavior, then add tier escalation and stage-specific difficulty scaling.

Download as JSON

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

Download JSON
Cite this page

Traditional leapfrog jumping game (Azerbaijan). (n.d.). Games of Countries. https://gamesofcountries.com/games/az-azerbaijan/enzeli

@misc{gamesofcountries-az-azerbaijan-enzeli,
  title = {Traditional leapfrog jumping game (Azerbaijan)},
  year = {n.d.},
  publisher = {Games of Countries},
  url = {https://gamesofcountries.com/games/az-azerbaijan/enzeli}
}