Skip to main content
Formal Specification

Duck on a Rock — Formal Specification

Ireland · dexterity-throw · Confidence: low

← Back to game page

Implementation Suitability

Suitability: adaptation-requiredFidelity: probabilistic-proxyGap-fills: 1
# Lacha ar Chloch — AI-optimized specification ## General idea A dynamic hybrid target-and-tag game where throwers attempt to dislodge a target stone ("duck") from a pedestal rock and recover their thrown stones back behind a safety line before the Guard can tag them. Strategic choices involve calculating sprint timings, opportunistically coordinating group stone-retrieval rushes when the duck is toppled, and managing defensive perimeter coverage as the Guard. ## Formal model - **Abstraction taken:** The physical playing area is discretized into a 1D coordinate axis `x ∈ [0, 10]` where `x = 0` is the Safe Boundary Line, `x = 8` is the Pedestal Rock, and `x ∈ (0, 8)` is the Contested Field. Movement is tick-based with variable agent speeds (`speed_runner = 2.0 units/tick`, `speed_guard = 2.2 units/tick`). Throw accuracy is modeled stochastically against the pedestal coordinate. - **Player/agent count:** 4 agents (`P_1` as initial Guard, `P_2, P_3, P_4` as Throwers). - **Turn model:** Discrete real-time ticks (1 tick = 0.5 seconds), with sequential throwing phases transitioning into simultaneous real-time retrieval scrambles. ## Formal rules R1. Setup: Pedestal is located at `x = 8.0`. Duck state initialized to `On_Rock`. Throwers begin at `x = 0` holding their stones. Guard begins at `x = 7.5`. Game runs for a maximum of 100 ticks. R2. Throw action: - When a thrower at `x = 0` executes `throw_stone(power)`: - Trajectory resolves: landing coordinate `x_land = 6.0 + U(0.0, 3.0)`. - Dislodge probability: `P_hit = 0.40 * accuracy_skill`. - If hit: `duck_state` transitions to `Dislodged` at `x_duck = 8.0 + U(1.0, 3.0)`. - If miss: `duck_state` remains `On_Rock`. Stone remains at `x_land` with state `Lying_Ground`. R3. Movement & state actions on tick: - An agent in the field may execute `move(dx)`, `pin_stone()` (put foot on stone to remain safe), `pick_up_stone()`, or `dash_home()`. - Guard may execute `move(dx)`, `retrieve_duck()`, `replace_duck()`, or `tag(target_agent_id)`. R4. Tagging & safety conditions: - Guard can only successfully tag a thrower if: 1. `duck_state == On_Rock`, AND 2. Thrower is at `x > 0`, AND 3. Thrower's state is `Holding_Stone_In_Field` (not `Safe_Line` and not `Pinning_Stone`), AND 4. Euclidean distance `||pos(Guard) - pos(Thrower)|| ≤ 0.8 units`. - If a valid tag occurs: the tagged thrower immediately becomes the new Guard. The former Guard transitions to a Thrower and teleports/runs safely to `x = 0`. R5. Dislodged scramble state: - While `duck_state == Dislodged`, the Guard cannot tag any agent. Guard must navigate to `x_duck`, execute `retrieve_duck()`, return to `x = 8.0`, and execute `replace_duck()` to reset `duck_state = On_Rock`. - During `Dislodged` status, all throwers holding stones may sprint toward `x = 0` with complete immunity. R6. [gap-fill] Scoring & victory: - Each successful dislodge awards +10 points to the thrower. - Each safe stone recovery awards +5 points. - Each successful tag as Guard awards +10 points. - At tick 100, the agent with the highest aggregate score wins the match. ## Edge cases - Tie at the end condition: Highest score at tick 100 wins; identical scores share victory. - A player with no legal move: Not applicable; agents can always hold position or move within bounds `[0, 10]`. - Repetition / cycles: Governed strictly by the 100-tick monotonic match limit. - Simultaneous claims on the same resource or position: Tag and safe-line crossings evaluated simultaneously; if a runner crosses `x = 0` on the same tick a tag is attempted, crossing safety takes precedence. - Player elimination mid-round: Guard role instantly transfers upon successful tag; player roster is preserved. - Resource exhaustion: Stones are conserved per agent. - Termination guarantee: Monotonic progress of the 100-tick global clock ensures termination. ## State representation - Persistent state: Global tick counter `t ∈ [0..100]`, scoreboard `score[agent_id]`, current Guard ID. - Per-player state: 1D position `x_i`, stone state (`Held_At_Home`, `Lying_Ground(x)`, `Pinned(x)`, `Carried_In_Field`), role (`Thrower`, `Guard`). - Per-turn ephemeral state: `duck_state` (`On_Rock`, `Dislodged(x)`, `Carried_By_Guard`), declared tick actions. - Observable information: Complete 1D positional awareness, duck status, and stone coordinates. ## Action space - `throw_stone(aim_bias)`: Hurling stone from `x = 0`. - `move(target_x)`: Positional displacement capped by maximum tick speed. - `pin_stone()`: Anchor foot to ground stone (grants immunity while stationary). - `pick_up_stone()`: Collect stone from ground, becoming vulnerable to tags. - `retrieve_duck()` / `replace_duck()`: Guard actions to reset the central target. - `tag(target_id)`: Guard offensive capture attempt. ## Playability notes - Single-player-vs-AI: Playable as either a tactical thrower balancing risk/reward rushes, or as Guard orchestrating zone denial. - Group games (n>4): Reduced to 4 agents in benchmark engine. - Physical-skill games: Real-time spatial pursuit and throwing accuracy abstracted via 1D grid intervals and hit probabilities. - What is lost: The physical thrill of sprinting across gravel and ducking under thrown stones. ## Implementation hints Implement as a 1D discrete simulation tick loop. State transitions for the Guard are a simple state machine: `Guard_Post -> Fetch_Duck -> Reset_Duck -> Chase_Mode`.

Download as JSON

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

Download JSON
Cite this page

Duck on a Rock (Ireland). (n.d.). Games of Countries. https://gamesofcountries.com/games/ie-ireland/lacha-ar-chloch

@misc{gamesofcountries-ie-ireland-lacha-ar-chloch,
  title = {Duck on a Rock (Ireland)},
  year = {n.d.},
  publisher = {Games of Countries},
  url = {https://gamesofcountries.com/games/ie-ireland/lacha-ar-chloch}
}