Formal Specification
Leapfrog hopping game — Formal Specification
Armenia · chase-tag · Confidence: high
← Back to game pageImplementation Suitability
Suitability: adaptation-requiredFidelity: discretizedGap-fills: 4
# Plenji — AI-optimized specification
## General idea
A cooperative (not adversarial) chain-advancing game: players continuously cycle between vaulting over a line of crouchers and becoming crouchers themselves at the head of the line, with multiple runners active in the chain simultaneously (a new runner launches as soon as the previous one clears the first back). Its distinguishing feature versus simple leapfrog is the escalating difficulty tiers applied globally to the whole line, and a fault penalty that reintegrates a failed vaulter into the chain rather than removing them from play.
## Formal model
- **Abstraction taken:** Real vaulting technique and landing control are abstracted into a stochastic per-vault success check whose probability decreases with the line's current global difficulty tier, since the entry names three escalating tiers without numeric success rates.
- **Player/agent count:** 6-15 agents, all part of one shared chain; roles (Runner, Croucher) rotate continuously and every agent participates in both.
- **Turn model:** Overlapping/asynchronous — multiple Runners can be mid-chain simultaneously, since a new Runner launches as soon as the prior one clears the line's first Croucher (entry §2.5), not after the prior Runner finishes entirely.
## Formal rules
R1. Setup: N agents (6 ≤ N ≤ 15) form a line spaced 2-3 m apart, all in Croucher posture ("blek," entry §1.2) at global `tier = 1`.
R2. Launch: the rearmost agent in the line submits `sprint_and_vault()`, beginning a sequential run of `vault_attempt()` sub-actions against each Croucher ahead of them in line order (entry §2.1-2.3).
R3. Vault resolution: each `vault_attempt()` against a given Croucher resolves a stochastic success check whose success probability decreases with `tier` [gap-fill: the entry names three tiers of increasing height (§3.1) but gives no numeric success-rate curve, so a monotonically decreasing function of tier is the minimal faithful reading].
R4. Chain continuation trigger (entry §2.5): the instant a Runner clears the *first* Croucher in the line (not the whole line), the next rearmost agent may launch its own `sprint_and_vault()` (R2), so multiple Runners can be simultaneously mid-chain at different positions.
R5. Successful full clear (entry §2.4): a Runner who clears every Croucher in the line takes 3 strides forward and immediately assumes Croucher posture at the new head of the line, at the line's current global `tier`.
R6. Tier escalation: `tier` advances from 1 to 2 to 3 across "progressive rounds" (entry §3) as a global, line-wide parameter — not a per-individual choice [gap-fill: the entry does not state the exact trigger for advancing tiers (a fixed number of full clears, elapsed time, or group agreement); advancing tier once per full round of the whole line successfully cycling is the minimal reading consistent with "progressive rounds"].
R7. Fault (entry §4.1): a `vault_attempt()` that fails, knocks over the target Croucher, or lands with knee/hand ground contact is a fault ("burned") for the attempting Runner; their `sprint_and_vault()` sequence ends immediately at that point.
R8. Fault penalty (entry §4.2): the faulted agent must either (a) immediately become a stationary Croucher at `tier = 1` (rejoining the chain at the point of the fault, resetting their local difficulty), or (b) carry the vaulter who most recently cleared them on their back for a measured penalty walk [gap-fill: the entry presents these as alternatives ("or") without specifying which applies in a given fault; treated as a consensus group choice made at the moment of the fault, not a fixed rule].
R9. Course completion (entry §5): the activity continues "until an agreed course distance is traversed" [gap-fill: treated honestly as an external session parameter, since the entry gives no fixed distance]. Any agent who completes the agreed course without ever faulting (R7) is recognized as a Master Jumper — an honorific, not a win condition that ends play for others.
## Edge cases
- Tie at the end: not applicable — there is no competitive win condition, only an individual zero-fault recognition (R9) that multiple agents can independently achieve.
- A player with no legal move: not applicable — a Croucher always has `sprint_and_vault()` available once they become rearmost; a mid-chain Runner always has the next `vault_attempt()` available.
- Repetition / cycles: expected and structural, not a bug — the entire game is a continuous role-cycling loop (Croucher → Runner → Croucher) by design; this is bounded in extent only by the external course-distance parameter (R9), not by the per-cycle mechanics themselves.
- Simultaneous claims on one position: not applicable to vaulting itself (each Croucher is vaulted by one Runner at a time in sequence, R2), though R4 allows multiple Runners to be concurrently active at different points along the line — this is by design, not a conflict.
- Elimination mid-round and turn-order repair: not applicable — no agent is ever removed from play; a fault (R7-R8) reassigns the faulted agent to Croucher rather than eliminating them.
- Resource exhaustion: not applicable — no consumable resource; the chain and course are continuously reused.
- Termination guarantee: given the external course-distance parameter (R9) is finite, and the chain's net forward progress is driven by successful full clears (R5, each advancing the line's position by 3 strides) which occur with non-zero probability each attempt (R3), the course distance is covered in bounded expected time — the same non-decreasing-progress argument used elsewhere in this batch. Absent an agreed distance, the entry gives the activity no formal terminal state, which is stated honestly here rather than inventing one.
## State representation
- Persistent (session) state: `tier` (global, 1-3), `line_position` (cumulative forward distance covered), `fault_count[agent]`.
- Per-agent state: `role` ∈ {Croucher, Runner}, `line_index` (Croucher only), `vault_progress` (Runner only, how many Crouchers cleared this run).
- Observable information: fully observable — all agents see the full line, everyone's role, and the current tier; no hidden information.
## Action space
- `sprint_and_vault()`: any agent currently rearmost in the Croucher line; precondition: the immediately-preceding Runner has cleared at least the first Croucher (R4).
- `vault_attempt()`: the active Runner, against the next Croucher in their sequence; precondition: mid-run, not yet faulted this run.
## Playability notes
- Single-player-vs-AI: unnatural as a competitive contest since the game has no adversarial win condition; better suited to a human joining an AI-simulated chain to test their own fault rate against the tier-escalation curve.
- Reducing N > 4 to 2 agents: mechanically degenerate — with only 2 agents the "chain" collapses to a simple alternating leapfrog with no overlapping-runner dynamic (R4), which is the game's distinguishing structural feature.
- Physical-skill games: real vaulting height, landing control, and sprint timing are the entire game and are collapsed into the tier-scaled stochastic success check (R3); no genuine gymnastic skill is modeled.
- What is lost: the actual physical thrill of a spread-eagled vault over a moving line of peers, the comic taunting of the `Esh-blek` variant, and the shepherds' extended cross-pasture races that gave the game its pastoral character.
## Implementation hints
State is modest (a role/position per agent, a global tier, a fault counter); the real design difficulty is calibrating the tier-to-success-probability curve and deciding the tier-escalation trigger, neither of which the source quantifies. First milestone: implement the overlapping-runner chain loop (R2-R5) with a flat success probability at `tier = 1` to validate the concurrent-runner mechanic (R4) and fault-reintegration (R8), then add tier escalation.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Leapfrog hopping game (Armenia). (n.d.). Games of Countries. https://gamesofcountries.com/games/am-armenia/plenji
@misc{gamesofcountries-am-armenia-plenji,
title = {Leapfrog hopping game (Armenia)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/am-armenia/plenji}
}