Formal Specification
The Camel Leapt (Cypriot Team Leapfrog) — Formal Specification
Cyprus · festival-ritual · Confidence: low
← Back to game pageImplementation Suitability
Suitability: adaptation-requiredFidelity: probabilistic-proxyGap-fills: 1
# Αππίσεν ο κάμιλος — AI-optimized specification
## General idea
A physical team vaulting and weight-bearing contest where one team forms a linked, bent structural chain ("the camel") and the opposing team attempts to vault consecutively onto its spine. Jumpers aim to distribute their positions along the chain to maximize stability and prevent falling off, while the camel's structural integrity decays under cumulative compressive load.
## Formal model
- **Abstraction taken:** The physical camel spine is discretized into a 1D positional lattice of `N` segment slots (where `N` is the number of players per team). Jumpers select landing slots; landing accuracy and mounting stability are resolved stochastically. Camel structural stamina degrades as a function of total mounted mass and slot distribution balance.
- **Player/agent count:** 2 teams of `N` agents (3 ≤ N ≤ 8), designated Team C (Camel) and Team J (Jumpers).
- **Turn model:** Round-based. Within a round, Jumpers take turns sequentially `1..N` attempting vaults. If all N jumpers mount successfully, a static hold countdown resolves.
## Formal rules
R1. Setup: Teams of `N` agents initialized. Target match points `WIN_SCORE = 3`. Team C forms the camel spine with initial structural integrity `Integrity_0 = sum(strength_c_i) * 100`.
R2. Jumper Vault Phase:
- Jumpers `j in {1..N}` vault sequentially.
- Active jumper `j` selects a target segment slot `s_target in {1..N}` on the camel's spine (slot 1 is nearest the anchor wall, slot N is the rear tail).
- Landing resolution: Actual landing slot `s_actual = clamp(round(s_target + N(0, 0.5 * (1.0 - agility_j))), 1, N)`.
- Landing stability check: `P(fall) = (occupied_count(s_actual) > 1) ? 0.35 : 0.05`.
- Phrase call check: [gap-fill] Jumper must issue `call_phrase = TRUE`; omission results in automatic jumper fault.
- If jumper falls or faults: Jumper round FAILS immediately. Team C scores 1 point. Round ends.
R3. Camel Integrity Degradation:
- Upon each successful mount, Camel integrity degrades:
`Integrity_{j} = Integrity_{j-1} - (weight_j * 10) * (1.0 + 0.1 * |s_actual - N/2|)`.
- Collapse probability: `P(collapse_j) = max(0.0, (500 - Integrity_j) / 500)^2`.
- If camel collapses: Camel round FAILS immediately. Team J scores 1 point. Round ends.
R4. Hold Phase:
- If all `N` jumpers mount successfully without falling or collapsing the camel, a 10-tick hold phase occurs.
- Camel takes 10 tick degradation steps with `P(collapse_tick) = max(0.0, (400 - Integrity_N) / 400)`.
- If camel survives all 10 ticks: Team J scores 1 point. Round ends.
R5. Role Swap: Teams swap roles (Team J becomes Camel, Team C becomes Jumpers) after each completed round.
R6. Win condition: The first team to reach `WIN_SCORE` points wins the match.
## Edge cases
- Tie at the end condition: Rounds are strictly discrete and yield exactly 1 point to either Camel or Jumpers per round; simultaneous point awards are impossible.
- A player with no legal move: Not applicable; jumpers always have `target_slot` selection actions.
- Repetition / cycles: Impossible; each round has a strict finite sequence of at most `N` jumps plus a 10-tick hold.
- Simultaneous claims on the same resource or position: Handled by `occupied_count(s_actual)` penalty in R2 (stacking on already occupied slots increases fall probability).
- Player elimination mid-round: If an agent disconnects, team strength is scaled proportionally by `(N - 1) / N`.
- Resource exhaustion: Not applicable; team strength and integrity reset at the start of each round.
- Termination guarantee: Each round terminates in at most `N + 10` discrete state transitions; match terminates when one team reaches `WIN_SCORE`.
## State representation
- Persistent state: `team_scores: [int, int]`, `active_camel_team_id: int`, `round_number: int`.
- Per-round ephemeral state: `camel_integrity: float`, `slot_occupancy: list[list[int]]`, `active_jumper_idx: int`, `mounted_jumpers: list[int]`.
- Observable information: Fully observable to all agents (current structural integrity, slot occupancy, and team scores are public).
## Action space
- Jumper Agent: `vault(target_slot: int, call_phrase: bool)` with `target_slot in {1..N}`.
- Camel Agent: `brace_structure(effort: float)` (expends stamina to reduce instantaneous collapse probability).
## Playability notes
- Single-player-vs-AI: Playable as Jumper Commander selecting optimal slot distributions vs. AI camel stability.
- Group games (n>4): Reduces cleanly to 2-agent strategic game where Agent 1 manages jumper landing choices and Agent 2 manages camel bracing tactics.
- Physical-skill games: Physical impact and balance abstracted into slot congestion mechanics and structural integrity degradation.
- What is lost: The physical sensation of carrying human weight and the athletic timing of planting hands on a human back.
## Implementation hints
Medium complexity due to multi-agent queue and structural decay tracking. Implement slot occupancy as an array of length N. First milestone: simulate a single round with deterministic jump placement to verify collapse threshold equations.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
The Camel Leapt (Cypriot Team Leapfrog) (Cyprus). (n.d.). Games of Countries. https://gamesofcountries.com/games/cy-cyprus/appisen-o-kamilos
@misc{gamesofcountries-cy-cyprus-appisen-o-kamilos,
title = {The Camel Leapt (Cypriot Team Leapfrog) (Cyprus)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/cy-cyprus/appisen-o-kamilos}
}