Skip to main content
Formal Specification

Capturing the Tiger (Baghbandi / Bagh-Chhagal) — Formal Specification

Bangladesh · board-abstract · Confidence: high

← Back to game page

Implementation 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 G=(V,E) where |V|=25 grid vertices (5×5 intersection matrix) connected by orthogonal lines and complete diagonals within each 2×2 quadrant, resulting in 56 undirected edges. - **Player/agent count:** 2 agents with asymmetric pieces: Tiger agent (T, 2 pieces) and Goat agent (G, 20 pieces). - **Turn model:** Strictly alternating sequential turns. Goat agent moves first. ## Formal rules R1. Setup: The 25 vertices are indexed (r,c) for r,c∈{0,1,2,3,4}. Tigers start at central vertices VT={(2,1),(2,3)}. [gap-fill] Goats start in stacks of 5 at the four corner vertices {(0,0),(0,4),(4,0),(4,4)}; 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 u may move along an edge (u,v)∈E to an adjacent vertex v if and only if v is empty. Goats cannot jump, cannot occupy an already occupied vertex, and cannot capture Tigers. R4. Tiger standard step: A Tiger at vertex u may move along an edge (u,v)∈E to an adjacent empty vertex v. R5. Tiger jumping capture: A Tiger at vertex u may jump over an adjacent Goat at vertex v to land on an empty vertex w if and only if: - (u,v)∈E and (v,w)∈E, - u,v,w are strictly collinear along a marked grid line, - Vertex w is unoccupied. Upon completion of the jump, the Goat at vertex v 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 =0). R8. Win condition for Tigers (Depletion): The Tiger agent wins immediately if they reduce the number of active Goats to ≤10, 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 ≤10 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 ∈{EMPTY,TIGER,GOAT}. - `corner_stacks`: Array of 4 integers (remaining undeployed goats at the 4 corners, initially [5,5,5,5]). - `goats_alive`: Integer in range [0..20]. - `active_player`: ∈{GOAT,TIGER}. - `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 JSON
Cite 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}
}