Formal Specification
Eating the Goats (Goat and Leopard) — Formal Specification
Sri Lanka · chase-tag · Confidence: high
← Back to game pageImplementation Suitability
Suitability: adaptation-requiredFidelity: discretizedGap-fills: 3
# Eluvan Kema — AI-optimized specification
## General idea
Eluvan Kema (Eating the Goats) is a dramatic Sri Lankan asymmetric chase-and-tag game. A circular defensive pen (*Elu-gala*) formed by linked defenders encloses a Goat (*Eluva*), while an outside Leopard (*Diviya*) attempts to breach the perimeter. When the Leopard forces entry into the pen, the defenders open the opposite side to let the Goat escape into the outer field while trapping the Leopard inside, creating a dynamic multi-phase zoning and containment puzzle.
## Formal model
- **Abstraction taken:** The physical circle of linked children and grassy pursuit arena is discretized into a 2D concentric graph: an Inner Pen (node `IN`), a Circular Ring Barrier with `k = 8` perimeter gate sectors `G_0..G_7`, and an Outer Field (node `OUT`). The Leopard attempts barrier breach actions at specific gates; the Circle Controller adjusts gate barrier strengths and opens/closes gate valves to manipulate agent flow.
- **Player/agent count:** 2 macro-agents: Agent 1 (Leopard / Predator) and Agent 2 (Herd Controller managing both Goat movement and Circle Defender gate linkages).
- **Turn model:** Synchronous discrete ticks (up to `T_max = 60` ticks per round).
## Formal rules
R1. Setup:
- Arena consists of node `IN`, ring sectors `G_0..G_7`, and node `OUT`.
- Initial positions: `Goat_loc = IN`, `Leopard_loc = OUT`.
- Gate status: Each gate `G_i` has barrier status `CLOSED` with link strength `S_i = 100`.
- Round timer `T = 60` ticks. Score = 0.
R2. In each tick `t`, both agents submit simultaneous actions:
- *Leopard Actions:*
- `Stalk(gate_i)`: Move to perimeter gate `i`.
- `Breach(gate_i)`: Attempt to force through gate `i` (from `OUT -> IN` or `IN -> OUT`).
- `Pursue()`: Sprint toward the Goat if both occupy the same spatial region (`IN` or `OUT`).
- *Herd Controller Actions:*
- `Reinforce(gate_i, gate_j)`: Bolster barrier strength of two target gates (`+30` strength).
- `Open_Gate(gate_i)`: Temporarily open a gate (`CLOSED -> OPEN`) to allow the Goat through.
- `Move_Goat(target_region)`: Move the Goat between `IN` and `OUT` through any `OPEN` gate.
R3. Breach Resolution:
- If Leopard executes `Breach(gate_i)` on a `CLOSED` gate:
- [gap-fill] Breach success probability is `P(Breach) = max(0.10, 1.0 - (S_i / 150))`.
- If breach succeeds, Leopard transitions across the gate (`OUT -> IN` or `IN -> OUT`), and `S_i` degrades by 40.
- If breach fails, Leopard remains in current region and loses 1 tick in recovery.
- If gate is `OPEN`, Leopard passes through automatically without resistance.
R4. Catch & Tag Resolution:
- When Leopard and Goat occupy the same zone (`IN` or `OUT`):
- [gap-fill] In each co-occupied tick, Leopard catch probability is `P(Tag) = 0.40 * (1.0 - Goat_Evasion_Modifier)`.
- If tag succeeds, the Goat is caught. Leopard wins the round (`Result = PREDATOR_WIN`).
R5. Containment & Escape Dynamics:
- If Leopard enters `IN`, Herd Controller may execute `Open_Gate(gate_opposite)` to evacuate Goat to `OUT`, then close the gate to trap Leopard in `IN`.
- While trapped in `IN`, Leopard must breach outward to re-enter `OUT`.
R6. Round Termination & Victory:
- If Leopard tags Goat within `T_max = 60` ticks: Leopard scores 1 point.
- If round timer reaches `T = 0` without a tag: Herd Controller scores 1 point.
- [gap-fill] Match consists of 4 rounds with alternating Predator/Herd roles. Highest score wins.
## Edge cases
- Tie at the end condition: Equal points across 4 rounds result in a declared draw or a sudden-death speed round.
- A player with no legal move: Not applicable — Stalk, Reinforce, and Move actions are always legal.
- Repetition / cycles: Bounded strictly by the 60-tick countdown timer per round.
- Simultaneous claims on the same resource: If Leopard attempts to breach a gate in the exact tick Herd Controller opens it, the gate is OPEN and Leopard passes through freely.
- Player elimination mid-round: Individual defenders do not get eliminated; their collective grip strength degrades upon heavy breaches.
- Resource exhaustion: If a gate's strength `S_i` drops to 0, it remains permanently damaged/open until reinforced.
- Termination guarantee: Clock strictly decrements `T = T - 1` every tick, guaranteeing round termination in at most 60 ticks.
## State representation
- Persistent state:
- `round_number` (integer `1..4`), `scores` (mapping `{Predator: int, Herd: int}`).
- Per-turn ephemeral state:
- `time_remaining` (integer `0..60`).
- `goat_location` (`"IN"` or `"OUT"`), `leopard_location` (`"IN"` or `"OUT"`).
- `gate_strengths` (array of 8 integers `S_0..S_7`).
- `gate_open_states` (array of 8 booleans: `true` if open, `false` if closed).
- Observable information: Fully observable — all agent positions, gate strengths, open/closed valves, and remaining time are public.
## Action space
- `leopard_action(type, gate_index)`:
- `type in {"STALK", "BREACH", "PURSUE"}`; `gate_index in {0..7}`.
- `herd_action(reinforce_gate_1, reinforce_gate_2, open_gate, move_goat_target)`:
- Macro-command controlling gate reinforcement, gate opening, and goat pathing.
## Playability notes
- Single-player-vs-AI: Excellent tactical asymmetric strategy game (playing either as the cunning predator seeking weak gates or as the defensive ring coordinator).
- Group games (n>4): Reduced to 2 macro-agents (Predator vs. Circle Commander) without losing the spatial containment and gate-opening dynamics.
- Physical-skill games: Physical grip wrestling is abstracted to barrier strength numbers and breach success sampling.
- What is lost in the adaptation: The charming musical chants (*Eluvan Kavi*) and the joyful vocal banter between children.
## Implementation hints
Low-to-medium complexity state machine. Can be cleanly represented as an 8-node circular graph with an inner hub and outer boundary. Milestone 1: implement gate status array, breach probability checks, and 60-tick timer loop in under 120 lines.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Eating the Goats (Goat and Leopard) (Sri Lanka). (n.d.). Games of Countries. https://gamesofcountries.com/games/lk-sri-lanka/eluvan-kema
@misc{gamesofcountries-lk-sri-lanka-eluvan-kema,
title = {Eating the Goats (Goat and Leopard) (Sri Lanka)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/lk-sri-lanka/eluvan-kema}
}