Formal Specification
Traditional Raid-and-Tag Sport — Formal Specification
Singapore · chase-tag · Confidence: high
← Back to game pageImplementation 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 grid. A center midline divides the halves at . 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: grid. Midline at . Baulk line at in defending half. Team A starts with score ; Team B with . 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 with breath timer ticks.
- Active defenders spawn distributed across .
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 before returning, otherwise the raid is scored as empty (0 points).
R4. Combat & Grapple Resolution:
- If Raider attempts `tag_attempt` on adjacent defender :
- Success check .
- If successful, defender is tagged (`tagged_defenders` ). State transitions to `STRUGGLE_PHASE`.
- In `STRUGGLE_PHASE`, defenders can execute `tackle_attempt`:
- Combined tackle force .
- Escape check per tick: .
R5. Raid Termination & Scoring:
- Raider Return: If the Raider reaches (across midline) while :
- Attacking team scores points.
- Tagged defenders are moved to the defending team's out-queue.
- Attacking team revives players from their own out-queue back onto court.
- Raider Tackled / Cant Expired: If 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 (), 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 .
- Per-raid state:
- `breath_timer`: integer .
- `raider_pos`: 2D coordinate .
- `defender_positions`: map of agent ID to .
- `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 JSONCite 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}
}