Formal Specification
Relievio / Ring-a-levio — Formal Specification
Ireland · chase-tag · Confidence: low
← Back to game pageImplementation Suitability
Suitability: adaptation-requiredFidelity: discretizedGap-fills: 2
# Cluiche Téite / Relievio — AI-optimized specification
## General idea
A dynamic spatial team pursuit game on a discrete node graph where a Hunting team coordinates search patrols to capture and imprison all Evader agents in a central Jail node, while free Evaders coordinate distraction runs and jailbreak sprints to liberate their captured teammates.
## Formal model
- **Abstraction taken:** The urban street environment is modeled as an undirected connected graph of 16 spatial nodes (representing street corners, alleyways, parks, and courtyards) with a designated node `Node_Jail`. Movement is synchronized in discrete time ticks. Physical holding is modeled as a 1-tick immobilization contest.
- **Player/agent count:** 2 teams of 4 agents each: `Team_Hunt = {H1, H2, H3, H4}` and `Team_Evade = {E1, E2, E3, E4}`.
- **Turn model:** Simultaneous-move discrete time ticks (1 tick = 1 time unit), capped at 120 ticks per half.
## Formal rules
R1. Setup: Board is a 16-node connected graph. `Node_Jail` is at index 1. Team_Hunt starts at `Node_Jail`. Team_Evade begins dispersed across outer nodes `[8..16]`. Global tick `t = 0`.
R2. On each tick, every active agent declares one action: `move_to(neighbor_node)`, `hold_position()`, or `guard_jail()`.
R3. Pursuit & Capture mechanics:
- If a Hunter `H_i` and an uncaptured Evader `E_j` occupy the same node at the end of tick movement:
- Capture contest resolves: `P(capture) = 0.70 + (Hunter_Agility - Evader_Agility) * 0.10`.
- If successful: `E_j` state transitions to `Captured`; `E_j` is moved to `Node_Jail` and cannot declare voluntary movement actions.
- If failed: `E_j` evades capture for that tick.
R4. Jailbreak mechanics (*Relievio!*):
- If an uncaptured Evader `E_k` successfully enters `Node_Jail` on a tick and is not simultaneously captured by a Hunter guarding `Node_Jail`:
- `E_k` triggers a **Jailbreak**.
- All currently `Captured` Evaders in `Node_Jail` immediately transition to `Free` status and are displaced to random adjacent neighbor nodes of `Node_Jail`.
R5. Win condition & scoring:
- **Total Capture:** If all 4 Evaders `{E1, E2, E3, E4}` have status `Captured` simultaneously, `Team_Hunt` wins the round immediately, scoring `(120 - t)` points.
- [gap-fill] Match limit: If tick reaches `t = 120` without total capture, `Team_Evade` wins the half, scoring 50 points + 10 points per uncaptured agent.
R6. Role reversal: Teams swap roles for the second half. The team with the highest aggregate score across both halves wins the match.
## Edge cases
- Tie at the end condition: Sum of round scores breaks the tie. If aggregate scores are identical, resolved as a draw.
- A player with no legal move: Not applicable; nodes have degree ≥ 2, so agents can always move to a neighbor or hold position.
- Repetition / cycles: Governed strictly by the 120-tick global monotonic clock.
- Simultaneous claims on the same resource or position: When a free Evader enters `Node_Jail` simultaneously with a Hunter:
* [gap-fill] Contest check: If Hunter succeeds on tag, the incoming Evader is captured (jailbreak fails). If Hunter fails, the jailbreak successfully triggers before capture.
- Player elimination mid-round: Captured players remain in the game state in `Node_Jail` awaiting potential liberation.
- Resource exhaustion: Node graph and agent rosters are constant.
- Termination guarantee: Monotonic progress of the 120-tick counter guarantees termination.
## State representation
- Persistent state: Graph topology, tick counter `t ∈ [0..120]`, half index (1..2), team scores `score[Team_Hunt]`, `score[Team_Evade]`.
- Per-player state: Node location `node_id`, status (`Free`, `Captured`, `Guarding`), agility rating.
- Per-turn ephemeral state: Declared simultaneous moves, evaluated captures, jailbreak trigger flags.
- Observable information: Full graph visibility of node locations for all agents within 1 hop; agents beyond 1 hop are hidden (fog-of-war) unless reported by line-of-sight.
## Action space
- `move_to(node_id)`: Travel to adjacent graph node.
- `hold_position()`: Remain stationary in current node.
- `guard_jail()`: Special defensive posture with +20% bonus capture probability inside `Node_Jail`.
## Playability notes
- Single-player-vs-AI: Functions as a team coordination puzzle; player commands one team while AI manages decentralized patrol/evasion policies.
- Group games (n>4): Standard 4v4 setup runs seamlessly in discrete multi-agent engines.
- Physical-skill games: Physical running stamina and street pursuit discretized onto graph movement and contest probabilities.
- What is lost: The adrenaline of sprint cornering on cobblestones and diving behind parked cars.
## Implementation hints
Represent the graph with an adjacency list. Implement agent pathfinding via BFS/A* to nearest known quarry or optimal jailbreak route.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Relievio / Ring-a-levio (Ireland). (n.d.). Games of Countries. https://gamesofcountries.com/games/ie-ireland/cluiche-teite
@misc{gamesofcountries-ie-ireland-cluiche-teite,
title = {Relievio / Ring-a-levio (Ireland)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/ie-ireland/cluiche-teite}
}