Formal Specification
Congolese Traditional Alertness and Evasion Game — Formal Specification
Dr Congo · chase-tag · Confidence: low
← Back to game pageImplementation Suitability
Suitability: adaptation-requiredFidelity: probabilistic-proxyGap-fills: 4
# Keba! — AI-optimized specification
> **Reconstructed source.** The entry carries a provenance warning: its rules were written from
> general knowledge, not read from the two works it cites. Biebuyck (1987) and Gondola (2002) are
> real books, but the entry does not evidence that either describes this game.
## General idea
A line-defence crossing game of the kabaddi/kho-kho structural family: defenders are **confined to
one-dimensional tracks** while runners move freely in two dimensions. That constraint is the whole
design. A defender cannot pursue — they can only cover their own line and time an outstretched
arm as a runner attempts to cross it — so the game is a sequence of independent one-dimensional
interception problems rather than a chase. The runner's task is to solve four of them in a row,
and then four more on the way back, since a crossing scores nothing until the runner **returns**.
## Formal model
- **Abstraction taken:** Sprinting, feinting, lateral acceleration, and the reach of an
outstretched arm are collapsed into a per-crossing stochastic interception check. The entry
specifies the court geometry exactly (12x6 m, 3 transverse lines, 1 longitudinal line) and gives
no speeds, no reach distance, and no success model.
- **Player/agent count:** 2 teams of 3-6, asymmetric by role — Defenders and Runners.
- **Turn model:** Synchronous ticks; all runners and defenders act simultaneously.
## Formal rules
R1. Court (entry §1): a rectangular court, roughly **12x6 m**, with **3 transverse lines** and
**1 central longitudinal line**, dividing it into **4 zones**.
R2. Defender constraint (entry §2): each defender is assigned to a specific line and **may only
move along that line**. This is a hard constraint on the action space, not a positional
preference, and it is the game's defining rule.
R3. Runner traversal (entry §3): runners enter from the starting baseline and must traverse
**each zone** to reach the far end.
R4. Tag (entry §4): a defender tagging a runner **with an outstretched hand** eliminates that
runner for the round.
R5. Scoring (entry §5): a runner who traverses the court **and returns to the start**, shouting
*"Keba!"*, scores **1 point** for the running team. Note the round trip: reaching the far end
is worth nothing on its own [gap-fill: the entry does not say whether a runner may rest at the
far end, nor whether the return leg faces the same defenders on the same lines].
R6. Role switch (entry §6): teams switch roles when **all runners are tagged**.
R7. Defender assignment: unstated [gap-fill: with 3 transverse lines plus 1 longitudinal line and
3-6 defenders, the mapping of defenders to lines is not given, and whether more than one
defender may share a line is unaddressed].
R8. Match structure: **none.** The entry defines no innings count, no target score, and no win
condition across role switches [gap-fill: which team wins, and after how many switches, is
entirely unstated].
## Edge cases
- Tie at the end: unaddressed, and unaddressable — R8 defines no match end and no comparison of
team scores, so there is nothing that could tie. No tiebreak is invented.
- A player with no legal move: not applicable. A defender always has `slide` along their line or
`reach`; a runner always has `advance`, `retreat`, `hold`, or `dodge`. R2 restricts a defender's
movement to one dimension but never empties it.
- Repetition / cycles: a runner may hover in a zone indefinitely without committing to a crossing,
and role switches (R6) may alternate forever because R8 supplies no stopping condition. The
entry defines no shot clock, no time limit, and no obligation to advance — so stalling is legal
and unpunished, which is the direct cause of the termination failure below.
- Simultaneous claims on one position: two defenders on intersecting lines — the central
longitudinal line crosses all three transverse lines — can occupy an intersection at once, and
two defenders could tag the same runner on the same tick. Since R4's outcome is binary
elimination, concurrent tags are harmless and need no priority rule. The intersections themselves
are the court's most contested points and the entry says nothing about them.
- Elimination mid-round and turn-order repair: central to the game (R4) and permanent within the
round. The model is synchronous, so there is no turn order to repair — an eliminated runner is
removed from the acting set, and the remaining runners face the same defenders with better odds
per runner, which is a real dynamic the entry does not comment on.
- Resource exhaustion: not applicable — nothing is consumed and the court needs no equipment
beyond its markings. The only depleting quantity is the running team's roster of un-tagged
runners, which is exactly what triggers R6.
- Termination guarantee: **not guaranteed.** A single innings terminates with probability 1 *if*
runners attempt crossings: eliminations are monotone (R4), each attempted crossing carries a
fixed positive interception probability, so all runners are eventually tagged. But nothing
compels a runner to attempt anything — R3 states the objective without imposing a clock — so a
team that simply stands on the baseline is never eliminated. And the **match** has no end at all
(R8). Both gaps point the same way, so `termination_guaranteed: false` records the entry's
silence. An implementation must add a shot clock and an innings count, and label both as its own.
## State representation
- Persistent (match) state: `score[team]`, `attacking_team`, `runners_remaining`.
- Per-round state: `runner_status[r]` ∈ {waiting, outbound, at_far_end, inbound, scored, tagged},
`zone[r]` ∈ {1..4}.
- Per-tick ephemeral state: `positions` for all runners (2-D) and defenders (1-D, a scalar offset
along the assigned line), `reach_active[d]`.
- Observable information: fully observable — an open chalk court with every player visible. The
informational content is spatial and anticipatory rather than hidden: a runner is guessing which
way a defender will commit, not what they cannot see.
## Action space
- `slide(offset)`: any defender; **constrained to their assigned line** (R2). One degree of
freedom, which is what makes defending a timing problem rather than a pursuit problem.
- `reach()`: any defender; extends for the tag (R4), presumably at the cost of mobility for the
tick [gap-fill: the entry does not say whether reaching commits a defender or can be aborted].
- `advance(zone)` / `retreat(zone)` / `hold()` / `dodge(direction)`: any active runner; two
degrees of freedom.
- `shout_keba()`: a returning runner at the start line; resolves R5's score.
## Playability notes
- Single-player-vs-AI: good, and better on the runner's side. A human runner timing crossings
against AI defenders is a clean, legible problem, and the defender's one-dimensional constraint
makes AI defenders easy to implement competently. The reverse — a human on one line among
several — is a much thinner experience.
- Reducing n > 4 to 2 agents: survives as one runner against one defender on one line, which
preserves R2 and R4 intact. What is lost is the sequencing that makes R3 a game: four
consecutive interception problems compound risk in a way that a single crossing does not.
- Physical-skill games: sprinting, feinting, and lateral acceleration are the whole contest and
collapse into per-crossing probabilities. Defender reach — the one distance that decides every
tag — is never given in the entry.
- What is lost: the street. The entry places this in Kinshasa's neighbourhood play and along the
Congo River in Équateur, and records that rural courts are marked with cassava stems or palm
fronds rather than chalk — a game whose court is drawn from whatever is at hand, played in the
space between buildings.
## Implementation hints
Model defenders as scalars on a line, not as constrained 2-D agents — R2 is a dimensional
reduction, and representing it as a penalty or a soft constraint invites pathfinding code that
will eventually let a defender leave their line. Make the interception check depend on the
runner's crossing point relative to the defender's position, so that R2's constraint actually
produces the game's characteristic geometry; a flat per-zone tag probability discards the entire
spatial structure and turns four crossings into four coin flips. R5's round trip is the most
commonly mis-implemented rule: award points only on return, or the game becomes twice as generous
and the inbound leg becomes pointless. Both missing bounds — the stalling problem and R8's absent
match structure — need explicit, labelled additions before this is playable. Suggested first
milestone: one zone with one line defender and one runner, with a position-dependent interception
check, then compose four zones and verify that round-trip scoring is rarer than single crossings.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Congolese Traditional Alertness and Evasion Game (Dr Congo). (n.d.). Games of Countries. https://gamesofcountries.com/games/cd-dr-congo/keba-lingala
@misc{gamesofcountries-cd-dr-congo-keba-lingala,
title = {Congolese Traditional Alertness and Evasion Game (Dr Congo)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/cd-dr-congo/keba-lingala}
}