Formal Specification
Turkish Leapfrog — Formal Specification
Türkiye · strength-endurance · Confidence: low
← Back to game pageImplementation Suitability
Suitability: adaptation-requiredFidelity: abstractedGap-fills: 3
# Birdirbir — AI-optimized specification
## General idea
A sequential athletic game where players leapfrog over a bent-over target agent (*ebe*) while executing specific rhythmic verbal or physical tasks. The physical jump, timing, and coordinate landings are resolved stochastically. Failing a task immediately makes the active agent the new target, resetting game progress.
## Formal model
- **Abstraction taken:** The physical leap, mid-air timing, and landing balance are abstracted into a series of discrete stage tests. [gap-fill] The physical height of the vault and specific physical tasks (like bird-chirping or floor-touching) are modeled as multiplicative modifier checks against the agent's dexterity.
- **Player/agent count:** 3 to n agents, acting in a queue.
- **Turn model:** Sequential jumping. One agent jumps, then the next.
## Formal rules
R1. State representation:
- `active_ebe: integer` (index of the target agent).
- `jump_queue: List of integer` (non-ebe players).
- `current_round: integer` (indexed 1..10, representing the chant-action rounds).
- `player_scores: Array[num_players] of integer` (rounds completed).
R2. On a turn, the active jumper `p` from the queue must execute a jump.
R3. Jump resolution:
- The success probability for agent `p` in round `R` is:
`P(Success) = skill(p) * base_difficulty(R)`
where `base_difficulty` values are defined as:
- `base_difficulty(1) = 0.95` (Standard leap)
- `base_difficulty(2) = 0.95` (Standard leap)
- `base_difficulty(3) = 0.90` (Standard leap)
- `base_difficulty(4) = 0.85` (Chirp action modifier)
- `base_difficulty(5) = 0.85` (Partner shoulder-tap modifier)
- `base_difficulty(6) = 0.75` (Ground-touch action modifier - hardest)
- `base_difficulty(7) = 0.85` (Back-slap action modifier)
- `base_difficulty(8) = 0.90` (Standard leap)
- `base_difficulty(9) = 0.85` (Run-away modifier)
- `base_difficulty(10) = 0.75` (High-vault modifier)
R4. Outcome resolution:
- Case 1: Success.
- Jumper `p` lands safely.
- They are added to the back of the `jump_queue`.
- Turn passes to the next agent in the queue.
- Case 2: Failure.
- Jumper `p` grazes the ebe, loses landing balance, or fails the action rhyme.
- Jumper `p` immediately becomes the new `active_ebe`.
- The previous `active_ebe` joins the back of the `jump_queue`.
- Game progress resets: `current_round = 1`.
- Turn passes to the first player in the queue.
R5. Round progression:
- If all jumpers in the `jump_queue` successfully complete their jumps for the active `current_round`:
- All jumpers receive 1 point: `player_scores[j] += 1`.
- The game advances: `current_round = current_round + 1`.
- If `current_round > 10`:
- `current_round = 1` (loops back).
R6. End condition:
- [gap-fill] The game ends when a player or team completes 3 complete 10-round loops, or after a fixed time limit.
R7. Win condition: The player(s) with the highest score at game end wins.
## Edge cases
- **Tie at the end condition:** Handled by highest score or shared victory.
- **A player with no legal move:** Not applicable.
- **Repetition / cycles:** Progress resets on any failure, but since `P(Success) < 1.0`, failures will eventually occur and the ebe rotates, guaranteeing dynamic state transitions.
- **Simultaneous claims on the same resource:** Not applicable; jumps are strictly sequential.
- **Player elimination mid-round:** Not applicable.
- **Resource exhaustion:** Not applicable.
- **Termination guarantee:** Guaranteed by the fixed time limit or loop cap in R6 [gap-fill].
## State representation
- Persistent state:
- `active_ebe: integer`.
- `jump_queue: List of integer`.
- `player_scores: Array[num_players] of integer`.
- `current_round: integer`.
- Ephemeral state:
- `jump_roll: float`.
- Information set: Public, fully observable.
## Action space
- `leap_vault()`: triggers the probability check for the active round. Only valid for the agent at the front of the queue.
## Playability notes
- Single-player-vs-AI: Suitable. The player attempts to jump, and their success determines if they keep jumping or become the ebe.
- Group games (n>4): Generalizes perfectly.
- Physical-skill games: Fully abstracted via success probability modifiers.
- What is lost: The raw athleticism of running, placing hands on a friend's back, vaulting, and chanting the rhymes.
## Implementation hints
Low complexity. Tracks a queue, an ebe, a round counter, and scores. Implement the queue swap logic (R4, Case 2) and the round advance conditions (R5) first. First milestone: build the round queue loop with static success rates before integrating the different stage difficulties.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Turkish Leapfrog (Türkiye). (n.d.). Games of Countries. https://gamesofcountries.com/games/tr-turkiye/birdirbir
@misc{gamesofcountries-tr-turkiye-birdirbir,
title = {Turkish Leapfrog (Türkiye)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/tr-turkiye/birdirbir}
}