Formal Specification
Traditional Dice Race on Cowrie Shell Track — Formal Specification
Bhutan · board-race · Confidence: low
← Back to game pageImplementation Suitability
Suitability: engine-readyFidelity: directGap-fills: 1
# Yam — AI-optimized specification
## General idea
A traditional Himalayan board-race game played on a 64-shell circular track with 2 dice and 9 coin tokens per player. Players manage stacks of tokens, race along the circuit, and capture ("oust") opponent stacks of equal or smaller size, earning bonus rolls while striving to bear all 9 tokens off the board first.
## Formal model
- **Abstraction taken:** None required (direct discrete turn-based board race). The continuous cowrie circle is formalized as a linear 1D track of 64 cells (`0..63`) followed by a terminal bear-off state.
- **Player/agent count:** 2 to 4 players (standard = 3).
- **Turn model:** Sequential clockwise turns; extra turns awarded immediately upon successful stacking or ousting.
## Formal rules
R1. Setup: Board consists of 64 ordered cells (`0` to `63`). Each of the `P` players (indexed `0..P-1`) starts with 9 tokens in their off-board `reserve`. All 64 board cells are initially empty.
R2. On a turn, the active player rolls two standard 6-sided dice (`d1, d2`), yielding a move sum `S = d1 + d2` (range 2 to 12).
R3. Legal Moves: The active player must select one of the following valid actions for the value `S`:
- `Enter`: Move 1 token from `reserve` onto cell `S - 1`. (Legal only if cell `S - 1` is not blocked by a strictly larger opponent stack).
- `Advance`: Move an existing token or an entire assembled stack of `K` tokens currently at cell `c` forward to cell `c + S`.
- `Bear Off`: If an active token/stack at cell `c` has `c + S >= 64`, it is removed from the board and added to the player's `borne_off` total.
R4. Stacking (*para*): If a player's token/stack lands on a cell containing one or more of their own tokens, the incoming and existing tokens merge into a single consolidated stack of size `K_new = K_incoming + K_existing`. Merging awards an immediate bonus dice roll.
R5. Ousting (*tsuk*):
- If a player's stack of size `K_atk` lands on a cell occupied by an opponent's stack of size `K_def`:
- If `K_atk >= K_def`: The attack succeeds. All `K_def` opponent tokens are removed from the board and returned to that opponent's `reserve`. The attacking stack occupies the cell and earns an immediate bonus dice roll.
- If `K_atk < K_def`: The move is illegal and cannot be chosen.
R6. Mandatory Action & Forfeit: If at least one legal move exists for roll `S`, the player must make a move. If no legal move exists, the turn ends with no movement.
R7. Win Condition: The first player whose `borne_off` count reaches 9 wins the game immediately.
R8. [gap-fill] Turn Limit: In the extremely rare event of cyclical ousting exceeding 300 total rounds, the player with the highest sum of `(borne_off * 100 + board_cell_positions)` is declared the winner.
## Edge cases
- Tie at the end condition: Not applicable; turns are strictly sequential, so exactly one player bears off their 9th token first.
- A player with no legal move: Handled via R6 (turn is skipped without movement).
- Repetition / cycles: Bounded by R8 (300-round limit guarantees loop termination).
- Simultaneous claims on the same resource or position: Turns are sequential; cell conflicts resolve unambiguously via R4 and R5.
- Player elimination mid-round: Not applicable; game runs to first winner.
- Resource exhaustion: Exactly 9 tokens per player and 64 fixed board positions.
- Termination guarantee: Stochastic forward progression on high rolls combined with R8 turn-cap guarantees termination.
## State representation
- Persistent state: `track[64]` (each cell stores `(owner_id, stack_size)` or `empty`), `reserve[P]` (integers 0..9), `borne_off[P]` (integers 0..9), `turn_count` (integer).
- Per-turn ephemeral state: `active_player_idx`, `dice_roll` (`d1, d2, S`), `bonus_roll_pending` (boolean).
- Observable information: Fully observable (all token positions, reserve counts, and borne-off counts are open knowledge).
## Action space
- `move_token(source_type, source_idx)`: Where `source_type` in `{"reserve", "track"}` and `source_idx` is the cell index `0..63`.
## Playability notes
- Single-player-vs-AI: Fully engine-ready; classic race-game AI using expectiminimax or Monte Carlo Tree Search (MCTS).
- Group games (n>4): Standard 3-player or 4-player game; naturally scales down to 2 players.
- Physical-skill games: Not applicable (pure discrete board game).
- What is lost: The vocal theatricality, rhythmic poetry, and table-slamming physical drama of traditional play.
## Implementation hints
Extremely high engine suitability. Clean discrete state machine with small branching factor (at most 10 distinct actions per turn). First milestone: implement 2-player board state with single tokens, then add multi-token stacking and bonus roll chaining.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Traditional Dice Race on Cowrie Shell Track (Bhutan). (n.d.). Games of Countries. https://gamesofcountries.com/games/bt-bhutan/yam
@misc{gamesofcountries-bt-bhutan-yam,
title = {Traditional Dice Race on Cowrie Shell Track (Bhutan)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/bt-bhutan/yam}
}