Formal Specification
Qatari Wheel Rolling Race — Formal Specification
Qatar · dexterity-small · Confidence: low
← Back to game pageImplementation Suitability
Suitability: adaptation-requiredFidelity: probabilistic-proxyGap-fills: 3
# Al-Dahrooj (الدحروج) — AI-optimized specification
## General idea
A hoop-rolling sprint whose entire strategic content sits in one rule: a hoop that falls
flat is re-erected **at the point of collapse**, not at the start. Distance is therefore
never lost, only time — which turns the race into a continuous speed-versus-stability
wager rather than a test of raw pace. The prohibition on touching the hoop by hand or foot
means the rod is the only control channel available, so recovery is expensive precisely
when the racer was going fastest.
## Formal model
- **Abstraction taken:** Real gyroscopic balance, steering feel, and running speed are
collapsed into a per-tick stochastic stability check whose failure rate rises with
chosen speed. The entry describes the fault qualitatively ("if a hoop falls flat") and
gives no numeric stability model, so a hazard-style check is the minimal faithful
reading. Course length is treated as a bounded parameter L ∈ [30, 50] m (entry §Players
& materials).
- **Player/agent count:** 2-8 racers. Racers do not interact: the entry describes no
blocking, contact, or shared lane, so this is formally a set of parallel time trials
resolved against one clock.
- **Turn model:** Synchronous ticks; every racer acts each tick.
## Formal rules
R1. Setup (entry §1): each racer begins at the start line at position 0 with its hoop
`upright` and engaged in the hook of the guide rod.
R2. Propulsion (entry §2.1): each tick a racer submits `push(intensity)`, advancing its
hoop by a distance increasing in `intensity`.
R3. Stability check (entry §3): each tick a hoop in motion resolves a stochastic
`stability_check` whose failure probability is non-decreasing in `intensity`
[gap-fill: the entry states the fault and its consequence but gives no failure rate;
a speed-monotone hazard is the minimal model that preserves the risk-reward structure
the rule exists to create]. On failure the hoop's status becomes `fallen`.
R4. Contact prohibition (entry §2.2): touching the rolling hoop with hands or feet is not
a member of the legal action set at any time. There is no in-entry penalty for doing
so because the action simply does not exist in the model.
R5. Recovery (entry §3): a racer whose hoop is `fallen` must submit `halt()`, then
`re_erect()` at the exact position where the collapse occurred, then resume R2 from
zero momentum. Position does not decrease during recovery; only ticks are spent
[gap-fill: the entry mandates "a complete stop" but gives no recovery duration; a
fixed non-zero tick cost is assumed, since a zero-cost recovery would make the fault
rule inert].
R6. Victory (entry §4): the first racer whose hoop crosses the finish line at distance L
while simultaneously `upright` **and** under active rod control wins. A hoop that
crosses while `fallen`, or after separating from the rod, does not satisfy the
condition and the racer must re-erect and re-cross.
## Edge cases
- Tie at the end: two hoops satisfying R6 on the same tick is unaddressed by the entry
[gap-fill: resolved as a re-run of the affected racers, the least invasive reading,
since the entry provides no placing mechanism finer than "first across"].
- A player with no legal move: not applicable — a racer with an `upright` hoop always has
`push(intensity)`; a racer with a `fallen` hoop always has the mandated `halt()` /
`re_erect()` sequence available.
- Repetition / cycles: collapse-and-recover cycles (R3, R5) may repeat arbitrarily many
times within one race. This is expected and structural, and does not threaten
termination — see below.
- Simultaneous claims on one position: not applicable — each racer controls its own hoop
on its own line and the entry describes no contact, blocking, or shared target.
- Elimination mid-round and turn-order repair: not applicable — no racer is ever removed;
a fallen racer continues from the point of collapse. There is no turn order to repair,
the model being synchronous.
- Resource exhaustion: not applicable — no consumable resource. Runner stamina is real and
culturally emphasised (entry §Cultural notes) but is not modelled by any rule in the
entry, so it is deliberately absent rather than invented here.
- Termination guarantee: **guaranteed.** R5 fixes recovery at the point of collapse, so
each racer's position is monotonically non-decreasing over the whole race — no rule
anywhere in the entry moves a hoop backwards. Every tick in which a racer is `upright`
carries a fixed positive probability of surviving its `stability_check` at any non-zero
intensity, and recovery from `fallen` costs a finite fixed number of ticks (R5).
Progress toward L is therefore a non-decreasing process with positive expected drift and
bounded stall length, so the finish line at finite distance L is reached with
probability 1.
## State representation
- Persistent (race) state: `position[racer]` (monotone non-decreasing), `finished[racer]`,
course length `L`.
- Per-tick ephemeral state: `hoop_status[racer]` ∈ {upright, fallen}, `momentum[racer]`,
`recovery_ticks_remaining[racer]`.
- Observable information: fully observable. All positions and hoop states are public and
visible down the lane; there is no hidden information anywhere in this game.
## Action space
- `push(intensity)`: any racer; precondition: `hoop_status = upright` and not recovering.
Higher intensity yields more distance and a higher failure rate in R3.
- `steer(angle)`: any racer; precondition: as `push`. Relevant only under the
Dahrooj Al-Awaiq obstacle variant (entry §Variants), inert on a straight lane.
- `halt()`: any racer; precondition: `hoop_status = fallen`. Mandatory, per R5.
- `re_erect()`: any racer; precondition: `halt()` completed at the collapse position.
## Playability notes
- Single-player-vs-AI: natural. Because racers do not interact, a human racer against AI
racers is exactly a shared-clock time trial, and an AI opponent needs no model of its
rivals at all — only its own risk appetite.
- Reducing n > 4 to 2 agents: mechanically lossless. Nothing in the rules depends on field
size; a two-racer contest is the same game with a shorter results list.
- Physical-skill games: real gyroscopic balance, wrist control through the rod hook, and
sustained sprinting are the entire physical contest and are collapsed into a single
stability check (R3). No genuine balance physics is modelled.
- What is lost: the fine motor feedback loop of steering a rim through a hooked rod at
running speed, the sprint stamina the game was valued for developing, and the specific
material culture of the game — a discarded bicycle rim and a bent palm rib repurposed
into a sport.
## Implementation hints
State is very small: a position, a status flag, and a recovery counter per racer, with no
inter-agent coupling at all, so the whole race parallelises trivially across racers.
Branching factor is effectively one continuous parameter (`intensity`), which makes this a
clean testbed for risk-policy search — the optimal policy is a speed schedule, and the
interesting question is whether it is constant or ramps near the line. The one
representational trap is the finish condition (R6): checking only `position ≥ L` silently
discards the "upright and under rod control" requirement and lets a fallen hoop win.
Suggested first milestone: a single racer, flat hazard rate, verifying that expected
finish time is convex in intensity — if it is monotone, the stability model is wrong.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Qatari Wheel Rolling Race (Qatar). (n.d.). Games of Countries. https://gamesofcountries.com/games/qa-qatar/al-dahrooj
@misc{gamesofcountries-qa-qatar-al-dahrooj,
title = {Qatari Wheel Rolling Race (Qatar)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/qa-qatar/al-dahrooj}
}