Formal Specification
Capturing the Tiger (Baghbandi / Bagh-Chhagal) — Formal Specification
Bangladesh · board-abstract · Confidence: high
← Back to game pageImplementation Suitability
Suitability: engine-readyFidelity: directGap-fills: 3
# Baghbandi — AI-optimized specification
## General idea
An asymmetric two-player abstract strategy board game played on a 25-intersection grid (a 4×4 subdivided square with orthogonal and diagonal connections). One agent controls 2 Tigers seeking to decimate a herd of 20 Goats via orthogonal/diagonal leaping captures, while the opposing agent controls the Goats, moving them to construct an airtight perimeter that blocks all legal moves for both Tigers simultaneously.
## Formal model
- **Abstraction taken:** Direct graph formalization. The board is represented as an undirected graph where grid vertices ( intersection matrix) connected by orthogonal lines and complete diagonals within each quadrant, resulting in 56 undirected edges.
- **Player/agent count:** 2 agents with asymmetric pieces: Tiger agent (, 2 pieces) and Goat agent (, 20 pieces).
- **Turn model:** Strictly alternating sequential turns. Goat agent moves first.
## Formal rules
R1. Setup: The 25 vertices are indexed for . Tigers start at central vertices . [gap-fill] Goats start in stacks of 5 at the four corner vertices ; on a Goat turn, the player may either move an already active single goat to an adjacent empty vertex, or deploy one goat from a corner stack to an adjacent empty vertex along an edge.
R2. On their turn, an agent must make exactly one legal move. Passing is illegal.
R3. Goat movement: A Goat piece at vertex may move along an edge to an adjacent vertex if and only if is empty. Goats cannot jump, cannot occupy an already occupied vertex, and cannot capture Tigers.
R4. Tiger standard step: A Tiger at vertex may move along an edge to an adjacent empty vertex .
R5. Tiger jumping capture: A Tiger at vertex may jump over an adjacent Goat at vertex to land on an empty vertex if and only if:
- and ,
- are strictly collinear along a marked grid line,
- Vertex is unoccupied.
Upon completion of the jump, the Goat at vertex is permanently eliminated from the game board.
R6. [gap-fill] Single capture restriction: Tigers may perform only a single jump per turn; multi-jump chains are prohibited in standard play.
R7. Win condition for Goats (Immobilization): The Goat agent wins immediately if at the start of the Tiger agent's turn, neither Tiger has any legal regular steps or jumping captures (total mobility of Tigers ).
R8. Win condition for Tigers (Depletion): The Tiger agent wins immediately if they reduce the number of active Goats to , rendering an encirclement trap mathematically impossible.
R9. [gap-fill] Repetition draw: If the exact same global board configuration (positions and stack counts of all pieces and the active player) occurs three times, the game terminates immediately in a draw.
## Edge cases
- Tie at the end condition: Only reachable via the R9 threefold repetition draw rule; mutual win states are impossible due to disjoint win conditions.
- A player with no legal move: If Tiger has no legal move on their turn, Goat wins immediately (R7). If Goat has no legal move (extremely rare before 10 captures), Tiger wins.
- Repetition / cycles: Bounded by R9 threefold repetition rule and monotonic capture reductions in goat counts.
- Simultaneous claims on the same resource or position: Not applicable; vertices accept exactly one piece (except initial corner deploy stacks), and turns are strictly sequential.
- Player elimination mid-round; turn order repair: Not applicable; exactly two players in alternating sequence.
- Resource exhaustion (pieces, tokens, space, time): Tracked explicitly by active Goat piece count; dropping to triggers Tiger victory (R8).
- Termination guarantee: Every capture strictly reduces the number of goats. In non-capture sequences, the finite state space combined with the R9 threefold repetition rule provably guarantees termination.
## State representation
- Persistent state:
- `board`: Array of length 25 where each cell .
- `corner_stacks`: Array of 4 integers (remaining undeployed goats at the 4 corners, initially ).
- `goats_alive`: Integer in range .
- `active_player`: .
- `history_hashes`: Set of board position hashes for threefold repetition detection.
- Per-turn ephemeral state: Active piece selected, destination vertex, captured goat vertex (if jump).
- Observable information: Fully observable by both agents with complete information.
## Action space
- `deploy_goat(corner_idx, to_v)`: Deploy a goat from corner stack `corner_idx` into adjacent empty vertex `to_v`. Precondition: `corner_stacks[corner_idx] > 0`, `(corner_v, to_v) in E`, `board[to_v] == EMPTY`.
- `move_goat(from_v, to_v)`: Move a deployed goat from vertex `from_v` to adjacent empty vertex `to_v`. Precondition: `board[from_v] == GOAT`, `(from_v, to_v) in E`, `board[to_v] == EMPTY`.
- `step_tiger(from_v, to_v)`: Move a tiger to an adjacent empty vertex. Precondition: `board[from_v] == TIGER`, `(from_v, to_v) in E`, `board[to_v] == EMPTY`.
- `jump_tiger(from_v, over_v, to_v)`: Execute a leaping capture over an enemy goat. Precondition: `board[from_v] == TIGER`, `board[over_v] == GOAT`, `board[to_v] == EMPTY`, `collinear(from_v, over_v, to_v)`.
## Playability notes
- Single-player-vs-AI: Natural and direct. Alpha-beta minimax with transposition tables or Monte Carlo Tree Search (MCTS) operates directly on the graph state.
- Group games (n>4): Not applicable; strictly a 2-agent asymmetric adversarial zero-sum duel.
- Physical-skill games: Fully deterministic combinatorial strategy game; no physical skill component.
- What is lost in the adaptation: None; the graph formalization captures the exact traditional board topology and folk rules.
## Implementation hints
Low complexity. The 25-vertex graph can be represented with 64-bit integer bitboards (Tiger bitboard, Goat bitboard, Stack counts). Branching factor: 2–10 moves for Tigers, 10–30 moves for Goats. First milestone: implement graph connectivity matrix and move generator, verify legal jump detection, and build a random-play rollout simulator.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Capturing the Tiger (Baghbandi / Bagh-Chhagal) (Bangladesh). (n.d.). Games of Countries. https://gamesofcountries.com/games/bd-bangladesh/baghbandi
@misc{gamesofcountries-bd-bangladesh-baghbandi,
title = {Capturing the Tiger (Baghbandi / Bagh-Chhagal) (Bangladesh)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/bd-bangladesh/baghbandi}
}