Formal Specification
Libyan Knucklebones Game — Formal Specification
Libya · dexterity-small · Confidence: medium
← Back to game pageImplementation Suitability
Suitability: engine-readyFidelity: probabilistic-proxyGap-fills: 1
# Laabat al-Adhem — AI-optimized specification
## General idea
A sequential dexterity game where players advance through 5 escalating stages of tossing an airborne bone/pebble, scooping ground counters, and catching the airborne piece before it strikes the ground. Completing all 5 stages scores points, while any drop or touch fault ends the active turn.
## Formal model
- **Abstraction taken:** Hand dexterity and reaction time are modeled via stage-specific success probabilities parameterized by agent dexterity attribute `Dexterity in [0, 100]`.
- **Player/agent count:** `N` agents (default `N = 2`, Player 0 and Player 1).
- **Turn model:** Sequential turn rotation. A player continues attempting stages within their turn until a fault occurs or the 5-stage cycle finishes.
## Formal rules
R1. Setup: Stage tracker `Stage: Array[N] in [1..5]` initialized to `1`. Score tracker `Score: Array[N] in int` initialized to `0`.
R2. Stage Definitions & Base Success Rates:
- Stage 1 (Ones): 4 single pickups. `P_step = (Dexterity / 100) * 0.95`.
- Stage 2 (Twos): 2 pair pickups. `P_step = (Dexterity / 100) * 0.88`.
- Stage 3 (Threes): 1 triplet + 1 single pickup. `P_step = (Dexterity / 100) * 0.80`.
- Stage 4 (Fours): 1 four-bone sweep. `P_step = (Dexterity / 100) * 0.70`.
- Stage 5 (The Trench): 4 tunnel flicks + catches. `P_step = (Dexterity / 100) * 0.60`.
R3. Execution on Turn:
- The active agent attempts `execute_stage(Stage[i])`.
- If successful, `Stage[i]` increments by 1.
- If `Stage[i] > 5`, `Score[i] += 1`, `Stage[i] = 1`, and the agent may attempt Stage 1 again.
- If the stage attempt fails, a `Fault` occurs; turn ends and passes to the next agent.
R4. Win Condition: The first agent to accumulate `TargetScore = 3` points wins the match.
## Edge cases
- Tie at the end condition: Not applicable; turns are strictly sequential and the first agent to reach 3 points wins immediately.
- A player with no legal move: Not applicable; stage execution is always valid.
- Repetition / cycles: [gap-fill] If 40 consecutive agent turns occur without any increase in `Score`, the agent with the highest `Stage` progression wins.
- Simultaneous claims on the same resource or position: Not applicable; sequential turns.
- Player elimination mid-round; turn order repair: Not applicable; no elimination.
- Resource exhaustion: Non-depleting physical tokens.
- Termination guarantee: Enforced by the 40-turn cycle breaker and the monotonic score threshold.
## State representation
- Persistent state: `scores: Array[N][int]`, `current_stages: Array[N][int]`, `active_player: int in [0..N-1]`, `stagnation_turns: int`.
- Ephemeral state: `active_toss_result: bool`.
- Observability: Complete, perfect public information.
## Action space
- `attempt_stage(stage_id)`: Execute dexterity resolution for the current stage.
## Playability notes
- Single-player-vs-AI: Functions cleanly as a solo skill-challenge simulator or a turn-based race against an AI opponent.
- Group games (n>4): Extends naturally to `N` players in rotation.
- Physical-skill games: Parameterized via stage difficulty coefficients and agent dexterity scalars.
- What is lost: The tactile weight of polished sheep astragalus bones in hand.
## Implementation hints
Finite state machine with 5 discrete stages. First milestone: implement sequential stage progression loop and turn switching upon simulated failure.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Libyan Knucklebones Game (Libya). (n.d.). Games of Countries. https://gamesofcountries.com/games/ly-libya/laabat-al-adhem-libya
@misc{gamesofcountries-ly-libya-laabat-al-adhem-libya,
title = {Libyan Knucklebones Game (Libya)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/ly-libya/laabat-al-adhem-libya}
}