Formal Specification
Qatari Circular Base Ball Tag — Formal Specification
Qatar · ball-team · Confidence: low
← Back to game pageImplementation Suitability
Suitability: adaptation-requiredFidelity: probabilistic-proxyGap-fills: 2
# Al-Rin (الرن) — AI-optimized specification
## General idea
A base-and-dodgeball hybrid whose distinctive feature is that **safety is a place, not a
state, and it is voluntary**. The central circle confers total immunity with no time limit,
so every elimination in the game is the consequence of a risk the runner chose to take.
The fielders' constraint mirrors it exactly: a fielder holding the ball may not move, so
the field team cannot chase — it can only pass the ball into a better throwing position
while the runner is exposed.
## Formal model
- **Abstraction taken:** Real sprint speed, throwing accuracy, and evasive dodging are
collapsed into two stochastic checks — a hit probability for a throw at a running target,
and a pass-completion probability between fielders — since the entry describes both
qualitatively with no numeric model. The 20 × 20 m arena, 3 m safety circle, and 15 m
stone distance are taken as stated (entry §Players & materials, §2.1).
- **Player/agent count:** 2 teams of 3-7. Exactly one team is the Base Team at any time.
- **Turn model:** Synchronous ticks. Runners and fielders act simultaneously; the
stationary-thrower rule (R5) is a per-tick constraint, not a turn structure.
## Formal rules
R1. Setup (entry §1): the Base Team begins inside the central circle *Al-Rin*; the Field
Team distributes around the perimeter, one fielder holding the ball.
R2. Sanctuary (entry §2.2): a runner inside the circle cannot be tagged. Immunity is
absolute and has no duration limit anywhere in the entry.
R3. Dash (entry §2.1): a runner may submit `dash_out()` at any tick, leaving the circle to
run at a target stone 15 m away, becoming taggable for the entire excursion.
R4. Scoring run (entry §4.1): a runner who reaches a target stone with `touch_stone()` and
returns to the circle with `return_to_base()` without being struck scores **1 point**
for the Base Team.
R5. Fielder constraint (entry §3.1-3.2): a fielder holding the ball must be stationary
before throwing. Legal fielder actions are therefore `pass_ball(teammate)` and
`throw_at(runner)`; a fielder in possession may not also move on the same tick. Both
resolve stochastic checks.
R6. Elimination (entry §3.3): a runner struck by the ball while outside the circle is
eliminated for the remainder of the inning. Elimination is permanent within the inning
and no rule in the entry restores an eliminated runner.
R7. Inning end and role swap (entry §4.2): when every runner on the Base Team is
eliminated, the inning ends and the teams exchange roles.
R8. Match victory (entry §4.2): after exactly **2 innings**, the team with more accumulated
points wins.
## Edge cases
- Tie at the end: equal points after 2 innings is unaddressed by the entry [gap-fill: a
third inning under the same rules is assumed as a decider, being the only resolution
consistent with the game's own structure; the entry supplies no tiebreak of any kind].
- A player with no legal move: not applicable — a runner in the circle may always `hold()`
or `dash_out()`; a runner outside may always continue toward the stone or the circle; a
fielder may always `pass_ball` or `throw_at`, and fielders without the ball may move.
- Repetition / cycles: runners may make arbitrarily many successful round trips (R4), and
fielders may pass indefinitely without throwing (R5). Both are expected; see the
termination note below for the one case where this matters.
- Simultaneous claims on one position: not applicable to the circle, which admits any
number of runners simultaneously (R2 sets no capacity). Ball possession is exclusive by
construction — exactly one fielder holds it, and `pass_ball` transfers it atomically.
- Elimination mid-round and turn-order repair: elimination is frequent and permanent within
an inning (R6), and it shrinks the Base Team only. No turn order needs repairing, the
model being synchronous; the eliminated runner is simply removed from the acting set and
restored at the next role swap (R7).
- Resource exhaustion: not applicable — the single ball is never consumed and returns to
play after every throw. Points accumulate and are never spent.
- Termination guarantee: **guaranteed, but resting on a marked assumption.** Within an
inning, the runner pool is finite and strictly non-increasing (R6), and every dash
carries a fixed positive probability of being struck, so once runners dash the pool
reaches zero with probability 1, ending the inning (R7); the match is then hard-bounded
at 2 innings (R8). The gap is that **nothing in the entry compels a runner to dash** —
R2's immunity is unlimited, so a base team that never leaves the circle stalls the inning
forever [gap-fill: a dash obligation is assumed — each runner must eventually attempt a
run — since the entry treats dashing as the point of the game rather than an option to
decline. Without this assumption the game does not terminate under adversarial play, and
the assumption, not the source, is what carries the guarantee].
## State representation
- Persistent (match) state: `inning` ∈ {1, 2}, `points[team]`, `base_team` (which side is
currently running).
- Per-inning state: `runner_status[r]` ∈ {in_circle, running_out, returning, eliminated},
`stone_touched[r]` (bool, gates whether a return scores under R4).
- Per-tick ephemeral state: `positions` (all agents), `ball_holder`, `ball_in_flight`.
- Observable information: fully observable. Positions, ball possession, and who has touched
a stone are all public in an open sand arena; the entry describes no concealment.
## Action space
- `hold()`: a runner inside the circle; always legal.
- `dash_out()`: a runner inside the circle; precondition: `runner_status = in_circle`.
- `touch_stone()`: a runner adjacent to a target stone; sets `stone_touched = true`.
- `return_to_base()`: a runner outside the circle; scores under R4 only if
`stone_touched = true`.
- `pass_ball(teammate)`: the fielder holding the ball; precondition: stationary this tick.
- `throw_at(runner)`: the fielder holding the ball; precondition: stationary this tick and
the target runner is outside the circle.
- `move(direction)`: any fielder **not** holding the ball (R5).
## Playability notes
- Single-player-vs-AI: natural on the runner side — one human runner choosing dash timing
against an AI field team's passing and throwing is the game's core decision in miniature.
The field side is less natural solo, since its play is inherently cooperative passing.
- Reducing n > 4 to 2 agents: degrades badly. With one runner and one fielder, R5's
stationary-thrower rule loses all meaning — passing exists precisely to reposition the
ball around a spread perimeter, and a lone fielder cannot pass at all.
- Physical-skill games: sprint speed, throwing accuracy at a moving target, and evasive
dodging are the entire physical contest and are collapsed into two probability checks
(R5). No genuine kinematics or ballistics are modelled.
- What is lost: the read-and-react timing of choosing the moment to break from the circle,
the cooperative field chatter that sets up a throw, and the specific tension of a runner
stranded at the far stone watching the ball being passed toward them.
## Implementation hints
State is modest — a status enum per runner, positions, and one possession pointer — but
the decision structure is genuinely interesting on both sides: the runner side is an
optimal-stopping problem (when is the ball far enough to break?), and the field side is a
positioning problem constrained by R5's no-move-while-holding rule. Branching factor is
small per agent but the joint action space grows with team size. The representational trap
is R4: scoring on any return to the circle rather than gating on `stone_touched` lets a
runner farm points by dashing one step out and back. Suggested first milestone: one inning,
flat hit and pass probabilities, verifying that the inning reliably terminates once the
dash obligation is enforced — and observing that it does not when it is removed.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Qatari Circular Base Ball Tag (Qatar). (n.d.). Games of Countries. https://gamesofcountries.com/games/qa-qatar/al-rin
@misc{gamesofcountries-qa-qatar-al-rin,
title = {Qatari Circular Base Ball Tag (Qatar)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/qa-qatar/al-rin}
}