Skip to main content
Formal Specification

Traditional Raid-and-Tag Sport — Formal Specification

Singapore · chase-tag · Confidence: high

← Back to game page

Implementation Suitability

Suitability: adaptation-requiredFidelity: discretizedGap-fills: 1
# Kabaddi — AI-optimized specification ## General idea Kabaddi is an asymmetric, raid-and-tag team combat game played on a 2D court divided by a midline. Teams alternate sending a single Raider into the opponent's territory under a strict breath timer to tag defenders and cross back across the midline, while the defending squad attempts to corner, tackle, and physically restrain the raider. ## Formal model - **Abstraction taken:** The court is discretized onto a 12×8 grid. A center midline divides the halves at x=6. Time proceeds in discrete raid ticks (up to 30 ticks per raid, representing the 30-second single-breath cant). - **Player/agent count:** 2 teams of 4 agents each (Team 1 vs. Team 2; on each raid, 1 Raider from Team A faces all active Defenders from Team B). - **Turn model:** Alternating raids. Within each raid, the Raider and active Defenders submit simultaneous grid actions per tick. ## Formal rules R1. Setup: 12×8 grid. Midline at x=6. Baulk line at x=8 in defending half. Team A starts with score S1=0; Team B with S2=0. Each team maintains an active roster of 4 agents and an out-queue. R2. Raid Initiation: - The attacking team designates one active agent as `Raider`. The Raider spawns at (6,4) with breath timer Tbreath←30 ticks. - Active defenders spawn distributed across x∈[7,11]. R3. Movement & Actions per Tick: - Raider actions: `move(dx, dy)`, `tag_attempt(target_defender)`. - Defender actions: `move(dx, dy)`, `tackle_attempt()`, `chain_link(teammate_id)`. - Baulk line constraint: The Raider must cross x≥8 before returning, otherwise the raid is scored as empty (0 points). R4. Combat & Grapple Resolution: - If Raider attempts `tag_attempt` on adjacent defender d: - Success check P(tag)=clamp(0.2,0.9,raider_agility−defender_agility). - If successful, defender d is tagged (`tagged_defenders` ←tagged_defenders∪{d}). State transitions to `STRUGGLE_PHASE`. - In `STRUGGLE_PHASE`, defenders can execute `tackle_attempt`: - Combined tackle force Ftackle=∑d∈adjacentstrengthd. - Escape check per tick: P(escape)=clamp(0.1,0.8,raider_strength/Ftackle). R5. Raid Termination & Scoring: - Raider Return: If the Raider reaches x≤5 (across midline) while Tbreath>0: - Attacking team scores K=|tagged_defenders| points. - Tagged defenders are moved to the defending team's out-queue. - Attacking team revives min⁡(K,|out_queueA|) players from their own out-queue back onto court. - Raider Tackled / Cant Expired: If Tbreath==0 or tackle pins the raider: - Defending team scores 1 point. - Raider is moved to the attacking team's out-queue. - Defending team revives 1 player from their out-queue. R6. All-Out (*Lona*): If all defenders on court are eliminated (|active|==0), the attacking team scores 2 bonus points, and all 4 defending players are revived onto court. R7. Match Win: The match consists of 20 total raids (10 per team) [gap-fill]. The team with the higher score wins. ## Edge cases - Tie at the end condition: If tied after 20 raids, a 5-raid tiebreaker shootout is played. - A player with no legal move: Inactive players in out-queue take no actions until revived. - Repetition / cycles: Bounded strictly by the 30-tick raid limit and 20-raid match cap. - Simultaneous claims on the same resource or position: Grid cell occupancy is mutually exclusive; collisions resolve by positional deflection. - Player elimination mid-round: Eliminated agents wait in the FIFO out-queue until revived by team scoring events. - Resource exhaustion: Roster size is conserved (4 agents per team). - Termination guarantee: Guaranteed by the 20-raid limit and 30-tick raid cutoff. ## State representation - Persistent state: - `team_scores`: array of size 2. - `active_rosters`: 2 lists of agent IDs. - `out_queues`: 2 FIFO queues of eliminated agent IDs. - `raid_number`: integer 1..20. - Per-raid state: - `breath_timer`: integer 0..30. - `raider_pos`: 2D coordinate (x,y). - `defender_positions`: map of agent ID to (x,y). - `tagged_defenders`: set of agent IDs. - `baulk_crossed`: boolean. - Observable information: Fully observable to all agents. ## Action space - Raider: `move(direction)`, `tag_attempt(target_id)`. - Defenders: `move(direction)`, `tackle_attempt()`, `chain_link(target_id)`. ## Playability notes - Single-player-vs-AI: 1 human raider/defender coordinating with AI teammates against an AI squad. - Group games (n>4): Standard 4v4 reduced model scales smoothly to 7v7 by expanding grid width. - Physical-skill games: Physical grappling and lunging tags are mapped to multi-agent strength/agility balance checks. - What is lost: Burning respiratory exhaustion of the chanted cant, skin-on-skin friction, and physical bruises. ## Implementation hints Discrete 2D multi-agent grid with state machine for raid phases (`NORMAL`, `STRUGGLE`, `RESOLVED`). Standard MARL benchmark.

Download as JSON

Download the full game corpus entry for this game as structured JSON.

Download JSON
Cite this page

Traditional Raid-and-Tag Sport (Singapore). (n.d.). Games of Countries. https://gamesofcountries.com/games/sg-singapore/kabaddi-singapore

@misc{gamesofcountries-sg-singapore-kabaddi-singapore,
  title = {Traditional Raid-and-Tag Sport (Singapore)},
  year = {n.d.},
  publisher = {Games of Countries},
  url = {https://gamesofcountries.com/games/sg-singapore/kabaddi-singapore}
}