Formal Specification
Long Donkey — Formal Specification
Türkiye · strength-endurance · Confidence: medium
← Back to game pageImplementation Suitability
Suitability: adaptation-requiredFidelity: probabilistic-proxyGap-fills: 2
# Uzun Eşek — AI-optimized specification
## General idea
A physical team contest where jumping agents attempt to load onto a human bridge without collapsing it. The bridge strength and jump landings are modeled stochastically. If the bridge survives the physical loads, the round is resolved via a simultaneous guessing duel between the team leaders.
## Formal model
- **Abstraction taken:** The continuous physical weight load and landing positions are abstracted into discrete slot capacities and cumulative stress thresholds on the bridge. [gap-fill] The physical jump and landing are modeled as a slot-filling probability task.
- **Player/agent count:** 2 teams of equal size `K` (where `K ∈ [4..8]`).
- **Turn model:** Sequential jumping within a round. The jumping team jumps one by one. Once the round ends, teams may swap.
## Formal rules
R1. State representation:
- `lying_team: integer` (0 or 1).
- `scores: Array[2] of integer`.
- `bridge_health: float` (starts at 100.0).
- `bridge_slots: Array[K] of integer` (occupied by jumping agents, indexed 0..K-1 from front/wall to back).
R2. On a round, the jumping team `J` must send their agents `j_1..j_K` to jump in sequence.
R3. Jump action:
- Jumping agent `j` selects a target slot index `S ∈ [0..K-1]`.
- [gap-fill] The success of landing in slot `S` depends on whether it is occupied and how far back it is:
- `P(Land_Success) = skill(j) * (1.0 - S * 0.05)`.
- If slot `S` or any slot before it is already occupied, the agent must land further back.
- If they land successfully:
- `bridge_slots[S] = j`.
- The bridge health decreases: `bridge_health -= weight(j) * slot_multiplier(S)`.
(Front slots place less mechanical stress on the bridge than rear slots).
- If they fail (fall off, touch feet to ground, or overshoot):
- The round terminates immediately. The lying team `L` wins the round. Roles swap: `lying_team = J`.
R4. Collapse check:
- If `bridge_health <= 0.0` at any point during the jumping sequence:
- The bridge collapses. The jumping team `J` wins the round immediately.
- The round terminates. `scores[J] += 1`.
- `bridge_slots` are cleared, `bridge_health` resets, and the same roles are kept for the next round (Jumping team jumps again).
R5. Guessing Phase:
- If all `K` jumping agents successfully occupy the bridge and `bridge_health > 0.0`:
- The jumping leader `j_1` secretly selects `gesture ∈ {1, 2}` (representing odd/even).
- The lying leader `l_1` selects a guess `guess ∈ {1, 2}`.
- If `guess == gesture`:
- Lying team wins the round: `scores[L] += 1`. Roles swap: `lying_team = J`.
- If `guess != gesture`:
- Jumping team wins the round: `scores[J] += 1`. Roles remain unchanged.
R6. End condition:
- The game ends when a team reaches a target score (e.g., 3 points).
R7. Win condition: The team with the highest score wins.
## Edge cases
- **Tie at the end condition:** Not applicable (first to 3 points wins).
- **A player with no legal move:** If all slots on the bridge are occupied, the active jumper cannot jump; this is prevented by design because number of slots equals the number of jumping agents.
- **Repetition / cycles:** Bounded by the monotonic score goal in R6.
- **Simultaneous claims on the same resource:** Not applicable; jumping is strictly sequential.
- **Player elimination mid-round:** Not applicable.
- **Resource exhaustion:** Not applicable.
- **Termination guarantee:** Guaranteed by R3's non-zero fail chance and R4's finite collapse threshold, leading to score updates that hit the limit.
## State representation
- Persistent state:
- `scores: Array[2] of integer`.
- `lying_team: integer`.
- Ephemeral state:
- `bridge_health: float`.
- `bridge_slots: Array[K] of integer`.
- `current_jumper_index: integer`.
- Information set:
- Bridge slots and health are public.
- The jumping leader's gesture in R5 is hidden from the lying team until revealed.
## Action space
- `jump_to_slot(slot_index)`: where `slot_index ∈ [0..K-1]`. Valid only for the active jumper.
- `choose_gesture(gesture)`: where `gesture ∈ {1, 2}`. Valid only for jumping leader in R5.
- `make_guess(guess)`: where `guess ∈ {1, 2}`. Valid only for lying leader in R5.
## Playability notes
- Single-player-vs-AI: Needs adaptation. Can be simulated by treating the physical jumping sequence as a tactical slot-allocation puzzle, where AI agents select target slots based on remaining bridge health.
- Group games: Generalizes to any equal team sizes (n >= 4).
- Physical-skill games: Physical force, balance, and landing are fully abstracted into slots and stress calculations.
- What is lost: The raw physical adrenaline and comedy of leaping onto friends' backs.
## Implementation hints
Medium complexity. Requires implementing a state machine that tracks the sequential jumping phase, handles weight-accumulation logic, checks for collapse, and transitions to the leader's guessing duel. First milestone: implement the sequential jumping loop with deterministic landing success and a simple bridge health reduction formula.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Long Donkey (Türkiye). (n.d.). Games of Countries. https://gamesofcountries.com/games/tr-turkiye/uzun-esek
@misc{gamesofcountries-tr-turkiye-uzun-esek,
title = {Long Donkey (Türkiye)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/tr-turkiye/uzun-esek}
}