Skip to main content
Formal Specification

Running the Gap — Formal Specification

Iceland · chase-tag · Confidence: low

← Back to game page

Implementation Suitability

Suitability: engine-readyFidelity: discretizedGap-fills: 5
# Hlaupa í skarðið — AI-optimized specification ## General idea A traditional Icelandic circle-running and sprint-tag game. Players stand in a circular ring; an outside runner taps a stationary player on the back, initiating an instantaneous opposite-direction footrace around the circle perimeter to claim the single vacant opening (*skarðið*). The first runner to occupy the gap becomes permanently safe, while the slower runner becomes the outside chaser for the following round. ## Formal model - **Abstraction taken:** The continuous physical ring and sprint footrace are discretized into a circular graph of N indexed slots {0,1,…,N−1}. Sprint duration around the circumference is resolved via a discrete tick model comparing agent Speed and Reaction attributes against circle perimeter distance. [gap-fill] Ring slot geometry, passing rules, and terminal round caps formalize playground conventions. - **Player/agent count:** N agents (modeled with N=8 in standard configuration: 1 outside Chaser, N−1 Ring players). - **Turn model:** Sequential round structure with simultaneous physical execution during the perimeter sprint. ## Formal rules R1. Setup: A ring of N−1 stationary slots is formed, indexed clockwise 0 to N−2. One agent is designated the Chaser (C), stationed outside the ring. Each stationed ring player begins in state `ACTIVE_INWARD`. R2. Target Selection: The Chaser selects one `ACTIVE_INWARD` ring player at slot k to tag (*klukka*). R3. The Vacant Gap & Race Trigger: - The tagged player (R) steps out of slot k, creating a vacant gap at position k. - Chaser (C) must sprint **clockwise** around the ring toward slot k. - Tagged player (R) must sprint **counter-clockwise** around the ring toward slot k. - Total path distance for both runners is exactly N−1 slot units. R4. Sprint Resolution: - Runner transit time to complete the circuit is calculated as: T=N−1Speed+ReactionDelay+ϵ, where ϵ∼𝒩(0,σ2) is stochastic variation [gap-fill]. - Midpoint passing: When runners cross paths at distance ≈N−12, they pass safely to the right without physical obstruction [gap-fill]. R5. Claiming the Gap: - The runner with the strictly lower arrival time T enters slot k first, claims the gap, and transitions to state `SAFE_OUTWARD` (*stikkfrír*). - The slower runner fails to claim the gap and becomes the Chaser (C) for the next round. R6. Game Termination: [gap-fill] The game concludes when all ring positions have become `SAFE_OUTWARD` (requiring exactly N−1 successful sprint rounds) or when a maximum limit of 2(N−1) rounds is reached. The player who ends as the Chaser is the loser; all safely retired players share victory. ## Edge cases - Tie at the end condition: If |TC−TR|<0.001 ticks, arrival is declared simultaneous; the original Chaser retains role and the tagged player returns to slot k as `ACTIVE_INWARD` [gap-fill]. - A player with no legal move: As long as at least one player remains `ACTIVE_INWARD`, the Chaser has valid targets; when 0 remain, game terminates per R6. - Repetition / cycles: Bounded by the monotonic conversion of ring slots from `ACTIVE_INWARD` to `SAFE_OUTWARD` (each round converts exactly 1 slot unless tied), capped by the 2(N−1) round ceiling in R6. - Simultaneous claims on the same resource or position: Handled via the continuous time comparator TC vs TR in R5 and R6. - Player elimination mid-round; turn order repair: Not applicable — no player is eliminated; roles alternate cleanly between Chaser and Ring. - Resource exhaustion: Ring slots are fixed (N−1); state transitions are strictly finite. - Termination guarantee: Guaranteed by monotonic retirement of ring slots to `SAFE_OUTWARD` state under finite round bound (R6). ## State representation - Persistent state: - `ring_slots`: array of size N−1, each storing `(occupant_id: int, status: {ACTIVE_INWARD, SAFE_OUTWARD})`. - `current_chaser_id`: int. - `round_number`: int. - Per-round ephemeral state: - `tagged_slot`: int `[0..N-2]`. - `tagged_player_id`: int. - `time_chaser`: float. - `time_tagged`: float. - Observable information: - Complete information: all agent positions, slot states, and agent speed attributes are publicly known. ## Action space - Chaser: `tag_player(slot_index)` (Precondition: `ring_slots[slot_index].status == ACTIVE_INWARD`). - Sprinting runners: `sprint(effort_level: [0.0..1.0])`. ## Playability notes - Single-player-vs-AI: Natural — human controls the Chaser/Runner timing acceleration and target selection against AI opponents with variable athletic attributes. - Group games (n>4): Reduces cleanly to 4 players (3 in ring, 1 chaser) while preserving exact opposite-direction sprint mechanics. - Physical-skill games: Real-time sprint burst and directional pivot are abstracted into scalar Speed and Reaction parameters. - What is lost in the adaptation: The physical sensation of running shoulder-to-shoulder past an opponent on a narrow outdoor perimeter is converted into numerical arrival time comparisons. ## Implementation hints - Model the ring as a simple array with circular index wrapping: `(start_pos +/- distance) % (N - 1)`. - Enforce that the Chaser can only select slots whose current status is `ACTIVE_INWARD`. - Suggested first milestone: implement R1–R5 (target selection, opposite-direction sprint timer calculation, slot status update, role swap).

Download as JSON

Download the full game corpus entry for this game as structured JSON.

Download JSON
Cite this page

Running the Gap (Iceland). (n.d.). Games of Countries. https://gamesofcountries.com/games/is-iceland/hlaupa-i-skardid

@misc{gamesofcountries-is-iceland-hlaupa-i-skardid,
  title = {Running the Gap (Iceland)},
  year = {n.d.},
  publisher = {Games of Countries},
  url = {https://gamesofcountries.com/games/is-iceland/hlaupa-i-skardid}
}