Skip to main content
Formal Specification

Faratzis (Progressive Easter Leapfrog) — Formal Specification

Cyprus · dexterity-small · Confidence: high

← Back to game page

Implementation Suitability

Suitability: engine-readyFidelity: probabilistic-proxyGap-fills: 2
# Φαρατζής — AI-optimized specification ## General idea A sequential progressive leapfrog and gesture-mimicry game where a designated leader (*Φαρατζής*) executes a jump over a bent "horse" agent while establishing escalating physical difficulty constraints (approach distance, one-handed vault, object balance, posture requirements). Following agents must duplicate the exact constraint parameters without faulting; the first agent to fail assumes the role of the horse. ## Formal model - **Abstraction taken:** The continuous physical gymnastics of progressive leapfrog are discretized into a sequence of difficulty tiers `L in {1..8}`. Each tier dictates a compound constraint vector `(distance_tier, contact_type, gesture_req, object_balance)`. Execution success is resolved via a difficulty-vs-agility probabilistic check. - **Player/agent count:** N agents (3 ≤ N ≤ 15). Roles: 1 Leader (L), 1 Horse (H), N-2 Jumpers (J_1...J_{N-2}). - **Turn model:** Sequential rounds. Round starts with Leader selecting challenge tier; each Jumper executes the leap sequentially. ## Formal rules R1. Setup: Agent 0 is `LEADER`, Agent 1 is `HORSE`, remaining agents are `JUMPERS`. Current tier level `lvl = 1`. Match round `r = 1`. R2. Leader Challenge Phase: - Leader selects difficulty tier `lvl` from `{1..max_unlocked_lvl}` and commits jump action `execute_leap(lvl)`. - Leader execution probability: `P(success_leader) = max(0.1, 1.0 - 0.1 * (lvl - agility_leader))`. - If Leader fails: Leader becomes `HORSE`; previous horse becomes `JUMPER`; `lvl` resets to 1; round ends. - If Leader succeeds: Jumpers must now replicate tier `lvl`. R3. Jumper Execution Phase: - Jumpers execute `replicate_leap(lvl)` in fixed index order. - Success probability for jumper `i`: `P(success_i) = max(0.05, 1.0 - 0.12 * (lvl - agility_i))`. - If jumper `i` fails: Jumper `i` immediately becomes `HORSE`; previous horse becomes `JUMPER`; `lvl` resets to 1; round ends. - If jumper `i` succeeds: Next jumper in order proceeds. R4. Tier Advancement: - If all `N-2` jumpers successfully complete tier `lvl`, the round ends in a `FULL_CLEAR`. - `lvl = min(8, lvl + 1)`. Leader retains leadership and leads next round at elevated tier. R5. Match Scoring / End Condition: - [gap-fill] Match is evaluated after `M = 5 * N` rounds. - Each agent tracks `fault_count` (times forced to become Horse) and `tiers_cleared` as Leader/Jumper. - The agent with the minimum `fault_count` (and highest `tiers_cleared` as tiebreaker) wins the match. ## Edge cases - Tie at the end condition: Resolved by comparing `tiers_cleared` across all rounds. - A player with no legal move: Not applicable; Leader always has valid level selection, and Jumpers always have `replicate_leap()` action. - Repetition / cycles: Resetting `lvl = 1` on a fault creates cyclical transitions, but total match execution is strictly bounded by round counter `M`. - Simultaneous claims on the same resource or position: [gap-fill] Jumpers execute strictly sequentially in ascending agent index order; no concurrent jump attempts are permitted. - Player elimination mid-round: If a jumper faults, the round terminates immediately upon that fault; subsequent jumpers do not jump that round. - Resource exhaustion: Not applicable; no consumable tokens. - Termination guarantee: Monotonic progression of round counter `r` from 1 to `M` guarantees game termination. ## State representation - Persistent state: `match_round: int`, `max_rounds: int`, `current_leader_id: int`, `current_horse_id: int`, `current_level: int`, `fault_counts: dict[agent_id, int]`, `cleared_tiers: dict[agent_id, int]`. - Per-round ephemeral state: `active_jumper_idx: int`, `round_jumpers_queue: list[int]`, `leader_success: bool`. - Observable information: Fully observable to all agents (current tier requirements, live success/fail states, and fault counts are public). ## Action space - Leader: `execute_leap(tier_level: int)`. - Jumper: `replicate_leap(tier_level: int)`. ## Playability notes - Single-player-vs-AI: Natural single-player arcade format (human plays as Jumper progressing through ascending AI-generated Faratzis challenge tiers). - Group games (n>4): N-agent game runs with zero structural friction due to sequential queue architecture. - Physical-skill games: Escalating bodily coordination mapped to discrete difficulty tiers with parametric agility checks. - What is lost: The specific hilarious kinetic antics (landing on one heel while patting one's stomach and shouting dialect rhymes). ## Implementation hints Very straightforward discrete state engine. Tiers 1 through 8 can be mapped to constant difficulty coefficients `0.10, 0.22, 0.35, 0.48, 0.60, 0.72, 0.84, 0.95`. Implement the sequential jumper evaluation loop and verify that round terminates on first failure.

Download as JSON

Download the full game corpus entry for this game as structured JSON.

Download JSON
Cite this page

Faratzis (Progressive Easter Leapfrog) (Cyprus). (n.d.). Games of Countries. https://gamesofcountries.com/games/cy-cyprus/faratzis

@misc{gamesofcountries-cy-cyprus-faratzis,
  title = {Faratzis (Progressive Easter Leapfrog) (Cyprus)},
  year = {n.d.},
  publisher = {Games of Countries},
  url = {https://gamesofcountries.com/games/cy-cyprus/faratzis}
}