Formal Specification
Deer game (Stag hunt) — Formal Specification
Mongolia · board-abstract · Confidence: low
← Back to game pageImplementation Suitability
Suitability: engine-readyFidelity: directGap-fills: 2
# Buga naadakh — AI-optimized specification
## General idea
A deterministic asymmetric abstract strategy board game played on a graph of 33 intersections representing a central pasture flanked by two mountain pens. One agent commands 2 Deer (*Buga*) who move and leap to capture dogs, while the other agent commands 24 Dogs (*Khüü*) who move one step along lines to surround and immobilize the deer without capturing.
## Formal model
- **Abstraction taken:** Direct graph formalization. The board is represented as an undirected graph `G = (V, E)` with `|V| = 33` vertices (25 in a 5×5 central grid + 8 in two 4-vertex triangular mountain appendages) and corresponding adjacency edges.
- **Player/agent count:** 2 agents: Player 1 (Deer, 2 pieces) and Player 2 (Dogs, 24 pieces).
- **Turn model:** Strictly alternating sequential turns; Deer agent moves first.
## Formal rules
R1. Setup: The 2 Deer pieces occupy designated central mountain vertices `V_deer_start = {v_16, v_17}`. The 24 Dog pieces occupy the remaining peripheral vertices.
R2. On a turn, an agent must make exactly one legal move with one of their pieces.
R3. Dog movement: A Dog piece at vertex `u` may move along an edge `(u, v) in E` to an adjacent vertex `v` if and only if `v` is empty. Dogs cannot jump and cannot capture.
R4. Deer movement (regular step): A Deer piece at vertex `u` may move along an edge `(u, v) in E` to an adjacent empty vertex `v`.
R5. Deer jump capture: A Deer at vertex `u` may jump over an adjacent Dog at vertex `v` to land on vertex `w` if:
- `(u, v) in E` and `(v, w) in E`,
- `u, v, w` form a collinear straight line along the grid,
- Vertex `w` is empty,
- The jumped Dog at `v` is permanently removed from the game.
R6. [gap-fill] Multiple captures: A Deer that executes a jump capture may optionally continue making additional immediate jump captures from its landing position in the same turn if valid jumping lines exist.
R7. Win condition for Dogs: The Dog player wins if at the start of any Deer turn, all Deer pieces on the board have 0 legal moves (no empty adjacent vertices and no legal jump captures).
R8. Win condition for Deer: The Deer player wins if they reduce the total count of active Dog pieces on the board to `<= 10`, making trapping mathematically impossible.
R9. [gap-fill] Repetition draw: If the exact same global board state (piece positions and active player) repeats 3 times, the game is declared a draw.
## Edge cases
- Tie at the end condition: Only possible via R9 threefold repetition draw rule.
- A player with no legal move: If Deer has no legal move, Dogs win immediately under R7. If Dogs have no legal move (extremely rare), Deer win.
- Repetition / cycles: Bounded by R9 threefold repetition rule and R8 piece depletion.
- Simultaneous claims on the same resource: Not applicable — turns are strictly sequential.
- Player elimination mid-round: Not applicable — exactly 2 players.
- Resource exhaustion: Dog piece elimination triggers R8 victory for Deer.
- Termination guarantee: Provably terminates via monotonic reduction in dog pieces or the finite-state threefold repetition loop breaker.
## State representation
- Persistent state: `board_state` (map of vertex_id `0..32` -> `{EMPTY, DEER, DOG}`), `dogs_remaining` (integer, 10..24), `active_player` (`DEER` | `DOG`), `history_hashes` (set of state hashes for repetition detection).
- Per-turn ephemeral state: Selected moving piece vertex, destination vertex, captured dog vertex list.
- Observable information: Fully observable — no hidden state, zero stochasticity.
## Action space
- `move_dog(from_v, to_v)`: Move a dog to an adjacent empty vertex.
- `step_deer(from_v, to_v)`: Move a deer to an adjacent empty vertex.
- `jump_deer(path=[v_start, v_mid, v_end, ...])`: Execute one or more consecutive jump captures.
## Playability notes
- Single-player-vs-AI: Natural — direct minimax / MCTS search with asymmetric evaluation functions (Dogs evaluate encirclement and mobility restriction; Deer evaluate capture counts and escape routes).
- Group games (n>4): Strictly a 2-player duel.
- Physical-skill games: Deterministic strategy game.
- What is lost in the adaptation: None — formalizes the exact traditional board topology and movement rules.
## Implementation hints
Graph-based state representation with bitboards or integer arrays. Branching factor is small: ~2–8 moves for Deer, ~10–25 moves for Dogs. Milestone 1: implement graph topology and move validator; Milestone 2: implement alpha-beta minimax agent with mobility heuristic.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Buga naadakh (Mongolia). (n.d.). Games of Countries. https://gamesofcountries.com/games/mn-mongolia/buga-naadakh
@misc{gamesofcountries-mn-mongolia-buga-naadakh,
title = {Buga naadakh (Mongolia)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/mn-mongolia/buga-naadakh}
}