Formal Specification
Long Vine (Ukrainian Folk Leapfrog Chain) — Formal Specification
Ukraine · strength-endurance · Confidence: low
← Back to game pageImplementation Suitability
Suitability: adaptation-requiredFidelity: probabilistic-proxyGap-fills: 5
# Dovha loza — AI-optimized specification
## General idea
A non-adversarial, cooperative leapfrog progression game: N agents form a spaced line, all but the rearmost crouched as vaulting "bases." The rearmost agent runs forward vaulting over every base in sequence, then becomes the new lead base, extending the line forward — and, distinctively, the *next* rearmost agent begins their own vaulting run as soon as the current vaulter clears just their first obstacle, producing a cascading wave of overlapping vaulters rather than one-at-a-time turns. There is no adversarial win condition; individual failure produces a penalty (staying a base) rather than elimination.
## Formal model
- **Abstraction taken:** The physical vault (running start, hand-plant, leg-parting jump) is abstracted into a single `vault_attempt` action resolved by a stochastic success check, since the entry frames failure as a probabilistic outcome of skill/balance ("if a jumper knocks over a crouching player or falls") rather than a deterministic rule. The field itself is abstracted to a 1D bounded axis of finite length `field_length` (30-60 m per entry), since forward progress along this bounded axis is what eventually stops the game.
- **Player/agent count:** N agents, 5 <= N <= 20, spaced 2-3 m apart along the axis. No teams — a single shared line ("vine").
- **Turn model:** Ticked, but *not* strictly sequential turn-taking: multiple agents can be actively vaulting concurrently, offset in a cascading wave (see R4). Each tick, every currently-active Vaulter may attempt one action.
## Formal rules
R1. Setup: N agents form an ordered line `queue = [q_1 ... q_N]` along the field axis, q_1 nearest the front (direction of travel), q_N at the rear, spaced 2-3 m apart. All agents except q_N enter state BENT (crouched, hands on knees, chin tucked — entry Rules §2). q_N enters state VAULTING with a target pointer at the nearest BENT agent ahead of it (q_{N-1}).
R2. Legal action for a VAULTING agent: `vault_attempt(target)`, where `target` must be the agent immediately ahead of it in `queue` that is still BENT and has not yet been passed by this agent. Precondition: agent is in state VAULTING and adjacent to `target`.
R3. Resolve `vault_attempt`: succeeds or fails via a stochastic check (entry gives no numeric rate). [gap-fill: success probability is not stated in the entry; a high fixed base success probability with no explicit numeric value is assumed, since the entry frames the game as a normal completable pastime with failure as the atypical case]. On success, the target agent is marked "cleared by this vaulter" and the Vaulter's target pointer advances to the next still-BENT agent ahead (or, if none remain, the Vaulter has reached the front — see R6). On failure, resolve via R7 (penalty).
R4. Cascading activation: the instant a VAULTING agent completes its *first* successful `vault_attempt` since entering the VAULTING state (i.e., clears the first obstacle it encountered), the agent that is now the rearmost still-BENT agent in `queue` transitions from BENT to VAULTING, with its target pointer set to the nearest still-BENT agent ahead of it (entry Rules §6: "As soon as the vaulter clears the first obstacle... the player who is now rearmost begins vaulting"). Multiple agents may therefore be simultaneously VAULTING, each independently advancing its own target pointer.
R5. A BENT agent that has already been cleared by a Vaulter remains BENT and available as a target for any other, later-activated Vaulter behind it, until that BENT agent is itself activated by R4 or R6.
R6. Reaching the front: once a VAULTING agent's target pointer has no remaining still-BENT agent ahead of it (it has cleared every BENT agent originally ahead of it in `queue`), it advances 2-3 paces past the current front of the line, transitions to state BENT, and is prepended to `queue` as the new frontmost agent (entry Rules §5), extending the line's leading edge forward by that pace distance. It is no longer VAULTING.
R7. Penalty on failed vault (entry Rules §7.1): if `vault_attempt` fails (the Vaulter knocks over the target or falls), the failing Vaulter immediately takes over the BENT position of the target agent it failed against — i.e., it becomes BENT in that agent's place in `queue`, and does *not* proceed to the front. [gap-fill: the entry states the failing jumper "must take the position of the fallen player" but does not specify what happens to the originally-BENT target agent it collided with; the target agent is assumed to step out of the immediate sequence and re-enter `queue` as an ordinary BENT agent at the same slot, effectively swapping roles with the failing Vaulter].
R8. Advanced command constraint (entry Rules §7.2, optional ruleset): when active, the current lead Vaulter may issue a constraint command (e.g. "higher backs," "land on one foot," "no hands") that all BENT agents ahead of it must satisfy on the next `vault_attempt` against them. A BENT agent that fails to satisfy the announced constraint is immediately reclassified from ordinary target to a forced-base outcome equivalent to R7 for the Vaulter attempting against it. [gap-fill: the entry does not specify whether the command applies to one target or to all remaining bases for the rest of that Vaulter's run; applying it to all remaining bases for that Vaulter's run is assumed, since the entry frames it as a standing constraint ("Вища лоза!") rather than a one-off].
R9. No adversarial win/loss condition exists. The game is cooperative-endurance: agents accumulate a `penalty_count` (times R7/R8 forced them to remain BENT rather than reach the front) but are never removed from play.
## Edge cases
- Tie at the end: Not applicable — there is no scored win condition (R9); the game is a shared cooperative activity, not a competition with a decidable outcome.
- A player with no legal move: Not applicable — a BENT agent always has an implicit "remain BENT" action and a VAULTING agent always has `vault_attempt` against its current target while any still-BENT agent remains ahead of it.
- Repetition / cycles: Not applicable in the bounded sense — every successful R6 event strictly increases the line's total forward displacement along the finite `field_length` axis (R1), so the configuration cannot repeat indefinitely without the line running out of field.
- Simultaneous claims on one position: Two Vaulters cannot target the same BENT agent at the same moment because each Vaulter's target pointer is always the *nearest* still-BENT agent ahead of it in `queue`, and R4 only activates a new Vaulter once its own nearest target is unambiguous; if a slower Vaulter catches up to a faster one queued at the same target, [gap-fill: the entry does not address a Vaulter overtaking another Vaulter — a Vaulter is assumed to wait one tick rather than attempt a target currently mid-vault by another agent].
- Player elimination mid-round; turn order repair: Not applicable — no agent is ever removed from the line (R9); a failed vault (R7) reassigns the failing agent to a BENT slot rather than eliminating it, and the cascading activation rule (R4) is unaffected by any individual agent's success or failure.
- Resource exhaustion: Not applicable — no consumable resource exists; the only bounded quantity is remaining field length (R1), which is the termination driver, not a resource agents spend.
- Termination guarantee: Every successful R6 event moves the line's leading edge strictly forward by a fixed pace distance along a bounded axis of finite `field_length` (Players & materials: 30-60 m). Since forward progress is monotonic and the axis is bounded, only a finite number of R6 events can occur before the line's front reaches the end of the field. [gap-fill: the entry does not state an explicit rule for what happens when the line reaches the field's end; reaching the end of `field_length` is assumed to be the natural stopping point, since the Overview explicitly frames the game as "continuously advancing... over open ground" of stated finite length]. The game therefore terminates in a bounded number of forward-extension events.
## State representation
- Persistent state: `queue` (ordered list of agent IDs, front to back), `field_position` of the line's leading edge, `penalty_count[agent]` for each agent.
- Per-agent ephemeral state: `role` ∈ {BENT, VAULTING}, and if VAULTING, `target_pointer` (which still-BENT agent ahead it is aiming for) and `has_cleared_first` (bool, drives R4).
- Observable information: Fully observable — all agents' positions and roles are visible to all; there is no hidden information in this game.
## Action space
- `vault_attempt(target)`: attempt to vault the named adjacent still-BENT agent ahead. Precondition: agent is VAULTING and adjacent to `target`.
- `remain_bent()`: implicit no-op for any agent in state BENT; always legal.
- `issue_constraint(command)`: (optional advanced ruleset, R8) issued once by a Vaulter at the start of its run, binding on all remaining BENT targets in that run.
## Playability notes
- Single-player-vs-AI: Unsuitable as a head-to-head contest — there is no opponent role to assign an AI against a human, since the game has no adversarial win condition (R9). It is adaptable as a solitaire endurance/skill challenge (human plays one Vaulter slot, AI fills the rest of the line) but that changes the social nature of the cascading wave.
- Reducing group play (N>4) to 2 agents: Poorly suited — the cascading-wave mechanic (R4) and the forward-creep termination argument both depend on having enough agents to form a meaningful queue; with only 2 agents the "wave" and "line extension" structure collapses to trivial alternating vaulting with no real queue dynamics.
- Physical-skill games: The running vault, hand-plant, and mid-air leg parting are collapsed into a single stochastic `vault_attempt` success check (R3); no biomechanics are modeled.
- What is lost: The rhythmic, overlapping physicality of a real cascading leapfrog wave (multiple runners in motion at once), the social humor of the "фант" forfeit, the escalating-difficulty command variant's live vocal delivery, and the tactile/visual timing judgment of when to launch a vault.
## Implementation hints
State size scales linearly with N (each agent has a small enum role + pointer), and the branching factor per tick is bounded by the number of concurrently VAULTING agents (at most N, typically much smaller). The representational trap is treating this as a normal turn-based game — the defining mechanic is the *concurrent, offset* activation of multiple Vaulters (R4), which a naive single-active-player state machine will not capture. First milestone: implement a single Vaulter completing one full pass to the front (R2, R3, R6) with no cascading, verify line-extension and field-bound termination, then add the R4 cascading-activation trigger.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Long Vine (Ukrainian Folk Leapfrog Chain) (Ukraine). (n.d.). Games of Countries. https://gamesofcountries.com/games/ua-ukraine/dovha-loza
@misc{gamesofcountries-ua-ukraine-dovha-loza,
title = {Long Vine (Ukrainian Folk Leapfrog Chain) (Ukraine)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/ua-ukraine/dovha-loza}
}