Formal Specification
Duck on a Rock — Formal Specification
Ireland · dexterity-throw · Confidence: low
← Back to game pageImplementation 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 JSONCite 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}
}