Formal Specification
Gollachhut (Circle Sprint) — Formal Specification
Bangladesh · chase-tag · Confidence: high
← Back to game pageImplementation Suitability
Suitability: engine-readyFidelity: discretizedGap-fills: 3
# Gollachhut — AI-optimized specification
## General idea
A discretized team running and tagging game centered around a base peg (*golla*). The attacking squad links hands to form a pivoting centrifugal chain around their captain (*Goda*), releasing runners who sprint across an open 2D grid to reach a distant target marker without being intercepted by defenders. Successful runs award consecutive standing broad-jumps chained from the central base toward the target to achieve set victory (*pati*).
## Formal model
- **Abstraction taken:** Centrifugal spinning momentum is modeled as a speed bonus vector upon chain release. The open field is discretized into a cell grid with the base peg at and the boundary target post at .
- **Player/agent count:** 2 teams of 6 agents: Attacking team () and Defending team ().
- **Turn model:** Real-time ticked / simultaneous movement per tick. Each attacking inning concludes when all runners and the Goda finish or are tagged. 4 full innings per match.
## Formal rules
R1. Setup:
- Field is a coordinate grid.
- Base Peg (*Golla*) located at .
- Boundary Target (*Tree / Post*) located at .
- Defending Sentries start distributed across .
- Goda anchors at ; remaining attacking runners start linked in a chain.
R2. Spinning Chain & Breakout:
- While linked, the chain rotates around at angular velocity .
- [gap-fill] When a runner unlinks from the chain, they gain an initial sprint speed boost ( for the first 3 ticks, then ) in their release direction.
- Once unlinked, a runner cannot rejoin the chain and must move toward the target at .
R3. Runner Tagging & Safety:
- A runner reaching without being tagged becomes **Safe** (*পাকা*).
- If an active defender occupies the same cell or is orthogonally adjacent to an active runner in the field, that runner is **Tagged & Eliminated** (*মারা যাওয়া*).
R4. Captain (*Goda*) Sprint:
- After all 5 regular runners have unlinked, must release from the peg and sprint to .
- If is tagged before reaching the target, the attacking inning terminates immediately with 0 jump rewards.
R5. Chained Jump Calculation & Set Victory (*পাটি*):
- [gap-fill] If reaches safety, each Safe runner contributes a chained jump distance of .
- Total Jump Progress = .
- If (reaching the target distance from base), the attacking team scores 1 *pati* (set point).
- If , progress is recorded for potential cumulative carry-over.
R6. Role Inversion: Teams swap attacking and defending roles after each half-inning.
R7. Win Condition: The team with the most *pati* after 4 complete innings wins the match.
R8. [gap-fill] Tiebreaker: If tied after 4 innings, each team executes a single-runner breakout sprint; the team whose runner reaches the target in fewer ticks wins.
## Edge cases
- Tie at the end condition: Resolved via single-runner speed sprint tiebreaker per R8.
- A player with no legal move: All active players submit cardinal movement vectors .
- Repetition / cycles: Bounded strictly by a 100-tick per-inning limit; runners not reaching by tick 100 are automatically ruled eliminated.
- Simultaneous claims on the same resource or position: Defender tag check executes before runner safe-target registration.
- Player elimination mid-round; turn order repair: Eliminated runners are removed from the grid for that inning; team roster resets for the next half-inning.
- Resource exhaustion (pieces, tokens, space, time): All runners reaching safe target or being eliminated closes the half-inning (R4, R5).
- Termination guarantee: The 100-tick inning ceiling and 4-inning match limit guarantee finite match completion.
## State representation
- Persistent state:
- `set_scores`: Array of 2 integers (pati counts for Team 1 and Team 2).
- `current_inning`: Integer .
- `active_attacking_team`: .
- Per-turn ephemeral state:
- `tick_counter`: Integer .
- `chain_status`: Array of bools (linked/unlinked for each runner).
- `agent_positions`: Map of agent IDs to coordinates.
- `safe_runners_count`: Integer .
- `goda_status`: .
- Observable information: Fully observable 2D field grid, agent coordinates, chain links, and tick timer.
## Action space
- `rotate_chain(angular_step)`: Goda rotates the chain to adjust breakout launch angles.
- `release_runner(runner_id)`: Unlink runner from chain to trigger sprint burst.
- `move_runner(runner_id, dx, dy)`: Move sprinting runner across grid cells.
- `patrol_defender(defender_id, dx, dy)`: Move defending sentry to intercept runners.
## Playability notes
- Single-player-vs-AI: Highly dynamic multi-agent chase simulation; player orchestrates timed multi-angle breakouts while AI optimizes defensive intercept lines.
- Group games (n>4): Reduced to 2 agents (Attacking Team Captain vs Defending Defensive Coordinator).
- Physical-skill games: Centrifugal rotation and raw sprint velocity are mapped to discrete speed boosts and pathfinding ticks.
- What is lost in the adaptation: The dizzying physical sensation of the spinning human chain and the high-speed diving lunges at the base peg.
## Implementation hints
Moderate complexity. The grid allows fast pathfinding. Milestone 1: implement chain rotation trigonometry, release velocity vector, and tag collision detection; Milestone 2: construct multi-runner diversion strategies where sacrificial runners draw defenders away from the Goda's path.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Gollachhut (Circle Sprint) (Bangladesh). (n.d.). Games of Countries. https://gamesofcountries.com/games/bd-bangladesh/gollachhut
@misc{gamesofcountries-bd-bangladesh-gollachhut,
title = {Gollachhut (Circle Sprint) (Bangladesh)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/bd-bangladesh/gollachhut}
}