Formal Specification
Traditional Tug of War — Formal Specification
Sri Lanka · strength-endurance · Confidence: low
← Back to game pageImplementation Suitability
Suitability: adaptation-requiredFidelity: abstractedGap-fills: 3
# Kaba Adeema — AI-optimized specification
## General idea
Kaba Adeema is Sri Lanka's traditional team tug-of-war sport. Two teams of eight pullers grasp opposite ends of a 32-meter coir rope and exert combined pulling force to drag a central red marker ribbon across a 2-meter baseline. Teams coordinate synchronized pulling surges (*hōyiyā* calls), manage anaerobic stamina reserves, and brace defensively against opponent momentum across a best-of-three match format.
## Formal model
- **Abstraction taken:** Continuous isometric muscle strain, coir friction, and team rhythm synchronization are abstracted into a 1D rope displacement line `x in [-2.0, +2.0]` meters, where `x = 0` is center. In each discrete tick (e.g. 1 second), both team captains select an exertion stance (Power Surge, Steady Anchor, Defensive Dig/Recover).
- **Player/agent count:** 2 teams (Team A defending negative displacement, Team B defending positive displacement), represented by 2 captain agents managing 8-puller team stamina.
- **Turn model:** Simultaneous synchronized discrete ticks.
## Formal rules
R1. Setup:
- Rope displacement `x = 0.0` meters.
- Ground threshold lines at `x = -2.0` (Team A victory threshold) and `x = +2.0` (Team B victory threshold).
- Both teams start with Team Stamina `S_A = 100`, `S_B = 100`.
- Match structure: Best-of-3 pulls. First team to win 2 pulls wins the match.
R2. In each simultaneous tick `t`:
- Both teams secretly commit to one of three team stances:
- `SURGE`: High force expenditure. Consumes `Delta_S = -12` stamina. Base Force `F = 180 * (S / 100) * Rhythm_Sync`.
- `MAINTAIN`: Steady traction. Consumes `Delta_S = -4` stamina. Base Force `F = 100 * (S / 100)`.
- `ANCHOR_RECOVER`: Defensive brace. Consumes 0 stamina, recovers `Delta_S = +6` stamina (capped at 100). Base Force `F = 60`. Generates `+30%` resistance against opponent surges.
R3. Dynamic Resolution:
- [gap-fill] Net instantaneous pulling force is calculated as:
`F_net = (F_B * Traction_Modifier_B) - (F_A * Traction_Modifier_A)`.
- Displacement updates: `x(t+1) = x(t) + F_net * 0.005`.
- [gap-fill] Traction Slip: If a team executes `SURGE` when stamina is below 20, there is a `P(Slip) = 0.25` chance of a foot slip, causing `Delta_x = 0.3` meters loss toward the opponent.
R4. Pull Resolution & Win Condition:
- If `x(t) <= -2.0`: Team A wins the pull.
- If `x(t) >= +2.0`: Team B wins the pull.
- [gap-fill] Pull Time Limit: If neither threshold is crossed within `T_pull = 90` ticks (seconds), the team with the rope ribbon displaced to their side (`x < 0` for Team A, `x > 0` for Team B) wins the pull.
R5. Match Progression:
- After each pull, teams swap sides (`x = -x`), reset rope to `x = 0.0`, and restore stamina to 80% of original max (reflecting inter-pull fatigue).
## Edge cases
- Tie at the end condition: If `x == 0.00` exactly at the 90-tick expiration, a 30-second sudden-death pull is triggered.
- A player with no legal move: Not applicable — at least one stance (`ANCHOR_RECOVER`) is always available without stamina requirements.
- Repetition / cycles: Bounded strictly by the 90-tick pull timer and best-of-3 match structure.
- Simultaneous claims on the same resource: Not applicable — actions resolve simultaneously into a single 1D displacement scalar.
- Player elimination mid-round: Individual puller cramps/injuries are modeled by lowering overall team maximum stamina capacity.
- Resource exhaustion: When stamina drops to 0, force output collapses to minimum base brace force until recovery stance is taken.
- Termination guarantee: Monotonic clock `t -> 90` per pull guarantees finite pull termination; at most 3 pulls per match guarantees game termination.
## State representation
- Persistent state:
- `match_score` (mapping `{Team_A: int, Team_B: int}`, target 2 wins).
- `pull_number` (integer `1..3`).
- `base_stamina_capacity_a`, `base_stamina_capacity_b` (floats).
- Per-turn ephemeral state:
- `rope_displacement` (float `x in [-2.0, +2.0]`).
- `current_stamina_a`, `current_stamina_b` (floats `0..100`).
- `tick_timer` (integer `0..90`).
- `chosen_stance_a`, `chosen_stance_b`.
- Observable information: Fully observable — rope position, remaining time, match score, and visible opponent exertion states are public.
## Action space
- `select_stance(stance_type)`:
- `stance_type in {"SURGE", "MAINTAIN", "ANCHOR_RECOVER"}`.
## Playability notes
- Single-player-vs-AI: Excellent real-time or turn-based tactical tug game where the player tries to bait the AI into premature surges, anchor defensively to absorb the force, and counter-surge when the AI is depleted.
- Group games (n>4): Reduced to 2 captain agents directing 8-man squads with zero loss of strategic tug-of-war mechanics.
- Physical-skill games: Grip friction and synchronized muscle surges are modeled through stamina economy and stance interactions.
- What is lost in the adaptation: The raw blisters, palm burns from coarse coconut fibers, and the thunderous roar of village cheer squads.
## Implementation hints
Low complexity 1D physics and stamina state machine. Can be easily implemented in under 100 lines of code. Milestone 1: implement simultaneous stance resolution, displacement delta math, 90-tick pull timer, and 3-pull match scoring.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Traditional Tug of War (Sri Lanka). (n.d.). Games of Countries. https://gamesofcountries.com/games/lk-sri-lanka/kaba-adeema
@misc{gamesofcountries-lk-sri-lanka-kaba-adeema,
title = {Traditional Tug of War (Sri Lanka)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/lk-sri-lanka/kaba-adeema}
}