Formal Specification
Libyan Hoop Rolling Obstacle Race — Formal Specification
Libya · dexterity-throw · Confidence: medium
← Back to game pageImplementation Suitability
Suitability: engine-readyFidelity: probabilistic-proxyGap-fills: 1
# Al-Dahrouja — AI-optimized specification
## General idea
A multi-agent kinetic steering and sprint race over a 100-meter obstacle course. Agents regulate hoop rolling speed against gyroscopic wobble and turning angle limits; pushing too hard increases wobble and causes crashes, requiring prompt recovery.
## Formal model
- **Abstraction taken:** 2D hoop kinematics are discretized into a 20-tick linear race course with 3 slalom waypoint turns.
- **Player/agent count:** `N` agents (default `N = 4`, Agents 0..3).
- **Turn model:** Synchronized simultaneous simulation ticks.
## Formal rules
R1. Setup: Total track length `D = 100.0m`. Slalom checkpoints at `x = 25m, 50m, 75m`. Each agent starts at `x_i = 0`, `v_i = 0`, `Wobble_i = 0.0`.
R2. Action Selection: Each tick, each agent chooses `thrust in [1.0, 5.0]` and `steer_angle in [-30 deg, +30 deg]`.
R3. Physics & Wobble Dynamics:
- Velocity update: `v_i(t+1) = v_i(t) + thrust * 0.8 - friction`.
- Wobble increase: `delta_Wobble = (thrust / 5.0) * 15.0 + abs(steer_angle) * 0.5`.
- Stability correction: Agent balance skill reduces wobble: `Wobble_i = max(0.0, Wobble_i + delta_Wobble - (Skill_i * 0.2))`.
R4. Topple & Penalty:
- If `Wobble_i > 80.0`, hoop topples (`Crash`): agent velocity drops to `v_i = 0`, `Wobble_i = 0`, and agent loses 2 ticks setting up the hoop.
R5. Win Condition: The first agent to cross `x_i >= 100.0m` wins the race.
## Edge cases
- Tie at the end condition: [gap-fill] If multiple agents cross 100m on the same tick, the agent with the highest final `x_i` wins.
- A player with no legal move: Not applicable; thrust and steer parameters are always valid.
- Repetition / cycles: Bounded by positive forward thrust ensuring termination within `<= 30 ticks`.
- Simultaneous claims on the same resource or position: Dedicated parallel racing lanes prevent collisions.
- Player elimination mid-round; turn order repair: Crashed agents recover after penalty ticks.
- Resource exhaustion: Monotonically increasing distance toward 100m.
- Termination guarantee: Enforced by the positive minimum velocity.
## State representation
- Persistent state: `positions: Array[N][float]`, `velocities: Array[N][float]`, `wobbles: Array[N][float]`, `crash_timers: Array[N][int]`.
- Ephemeral state: `active_thrusts: Array[N][float]`.
- Observability: Complete visibility of competitor positions and lane progress.
## Action space
- `control_hoop(thrust, steer_angle)` where `thrust in [1.0, 5.0]`, `steer_angle in [-30.0, 30.0]`.
## Playability notes
- Single-player-vs-AI: Engine-ready arcade steering game balancing speed against topple risks.
- Group games (n>4): Naturally scales to `N` lane competitors.
- Physical-skill games: Gyroscopic stability and wire guide steering cleanly abstracted into wobble equations.
- What is lost: The distinctive metallic hum of a bicycle rim rattling over cracked asphalt.
## Implementation hints
1D/2D integrator state machine. First milestone: implement velocity integration, wobble accumulation/decay curves, and crash penalty triggers.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Libyan Hoop Rolling Obstacle Race (Libya). (n.d.). Games of Countries. https://gamesofcountries.com/games/ly-libya/al-dahrouja
@misc{gamesofcountries-ly-libya-al-dahrouja,
title = {Libyan Hoop Rolling Obstacle Race (Libya)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/ly-libya/al-dahrouja}
}