Formal Specification
Backgammon (Romanian Traditional Table) — Formal Specification
Romania · board-race · Confidence: low
← Back to game pageImplementation Suitability
Suitability: engine-readyFidelity: directGap-fills: 2
# Table — AI-optimized specification
## General idea
A discrete, two-player race and capture board game played on a 24-point linear graph with counter-flowing paths. Players advance 15 checkers according to dice rolls, hit exposed opposing checkers to the bar, construct blockading two-checker points ("case"), and bear off all pieces once gathered in their home quadrant. Identical to traditional Mediterranean backgammon without a doubling cube.
## Formal model
- **Abstraction taken:** None required (`fidelity_class: direct`). The board is modeled as a 24-node line graph with player-specific directional indices 1..24, a bar state, and an off-board terminal state.
- **Player/agent count:** Exactly 2 agents (Player 0 and Player 1).
- **Turn model:** Sequential alternating turns with 2d6 roll (4 moves on doubles).
## Formal rules
R1. State space: Board consists of 24 points indexed 1..24. Checkers of Player 0 move from 24 down to 1 (home table: 1..6); Checkers of Player 1 move from 1 up to 24 (home table: 19..24).
R2. Starting setup:
- Player 0: 2 on pt 24, 5 on pt 13, 3 on pt 8, 5 on pt 6. Bar = 0, Off = 0.
- Player 1: 2 on pt 1, 5 on pt 12, 3 on pt 17, 5 on pt 19. Bar = 0, Off = 0.
R3. On a turn, roll uniformly from . If , available move list is , else .
R4. Legal move rules:
- If `bar[active] > 0`: Active agent must re-enter a checker from the bar onto target point `25 - die` (for P0) or `die` (for P1). If target point contains opposing checkers, entry on that die is illegal.
- If `bar[active] == 0`: A checker on point moves to provided target point contains opponent checkers.
- Hitting: If target point contains exactly 1 opponent checker, the opponent checker is moved to `bar[opponent] += 1` and the active checker occupies the point.
- Point creation: If target point contains friendly checkers, it forms a closed "casă" blocking opponent landing.
R5. Bearing off:
- Precondition: All 15 friendly checkers are within the home board or already borne off (`off[active]`).
- An exact roll bears off a checker from point `die` (from home boundary).
- If no checker exists on the exact die point, but higher points within the home table are also empty, a checker from the highest occupied point may be borne off.
R6. [gap-fill] Mandatory move consumption: A player must use as many rolled dice as legally possible, prioritizing the higher die value if only one can be played.
R7. Win condition:
- The first agent to reach `off[active] == 15` wins immediately.
- If `off[opponent] > 0`, score is 1 point (Linie simplă).
- If `off[opponent] == 0`, score is 2 points (Marț).
## Edge cases
- Tie at the end condition: Not applicable — sequential turns ensure a single winner bears off the 15th checker first.
- A player with no legal move: If no legal moves can be made with remaining dice, all unused dice are forfeited and turn passes immediately.
- Repetition / cycles: Bounded — checkers advance monotonically toward home quadrants; only hits reset pieces to the bar. [gap-fill] Hard 400-ply timeout adjudicates a draw if reached.
- Simultaneous claims on the same resource or position: Not applicable — sequential turns.
- Player elimination mid-round; turn order repair: Not applicable (strictly 2 agents).
- Resource exhaustion: Conserved checker count () and 24 points.
- Termination guarantee: Monotonic progress during bearing-off ensures eventual termination almost surely.
## State representation
- Persistent state:
- `board`: Array of 24 integers (positive for P0 checkers, negative for P1 checkers, 0 for empty).
- `bar`: Array of 2 integers `[p0_bar, p1_bar]`.
- `off`: Array of 2 integers `[p0_off, p1_off]`.
- `turn`: Active player index (0 or 1).
- `match_score`: Array of 2 integers `[p0_score, p1_score]`.
- `ply_count`: Integer tracking elapsed plies.
- Per-turn ephemeral state:
- `dice_remaining`: List of available die values.
- Observable information: Fully observable.
## Action space
- `move(from_point, die_value)`:
- `from_point`: `0..24` (`0` represents the bar).
- `die_value`: An element of `dice_remaining`.
- `pass()`: Auto-triggered if and only if no legal move exists.
## Playability notes
- Single-player-vs-AI: Engine-ready. Directly implementable with expectiminimax, MCTS, or reinforcement learning policies.
- Group games (n>4): Not applicable (strictly 2-player).
- Physical-skill games: Not applicable (discrete board game).
- What is lost: Sensory clatter of heavy wooden pieces, coffeehouse smoke, and bystander (*chibiț*) kibitzing.
## Implementation hints
- Re-use standard backgammon move-generator structures without doubling cubes.
- Branching factor: Typically 10–25 legal actions per roll.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Backgammon (Romanian Traditional Table) (Romania). (n.d.). Games of Countries. https://gamesofcountries.com/games/ro-romania/table-romanesc
@misc{gamesofcountries-ro-romania-table-romanesc,
title = {Backgammon (Romanian Traditional Table) (Romania)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/ro-romania/table-romanesc}
}