Formal Specification
Dutch Shuffleboard — Formal Specification
Netherlands · dexterity-throw · Confidence: low
← Back to game pageImplementation Suitability
Suitability: engine-readyFidelity: probabilistic-proxyGap-fills: 2
# Sjoelen — AI-optimized specification
## General idea
A turn-based precision disc-sliding game where an agent allocates 30 wooden discs across 3 sub-turns into 4 numbered goal arches (values 2, 3, 4, 1). The strategic objective is balancing disc distribution to complete quadruplets (one in each arch), which triggers a double-value set bonus (20 points vs. 10 points face value).
## Formal model
- **Abstraction taken:** The 2.0 m x 0.41 m board is modeled as a 2D friction lane with 4 target aperture intervals at `x = 2.0`: `Arch_2` in `[0.02, 0.10]`, `Arch_3` in `[0.12, 0.20]`, `Arch_4` in `[0.22, 0.30]`, `Arch_1` in `[0.32, 0.40]`. Each slide action is modeled as an aim angle and speed vector with simulated disc-disc deflection and arch-edge collision.
- **Player/agent count:** 1 to n agents taking sequential turns of 3 sub-turns each.
- **Turn model:** 3 sequential sub-turns (`Beurt 1`, `Beurt 2`, `Beurt 3`) per agent.
## Formal rules
R1. Setup: State initializes with `potted = {Arch_1: 0, Arch_2: 0, Arch_3: 0, Arch_4: 0}` and `unpotted_discs = 30`.
R2. Sub-turn Execution (for `sub_turn in [1, 2, 3]`):
- While `unpotted_discs > 0`:
- Active agent submits `slide_disc(target_arch, release_velocity, lateral_offset)`.
- Simulated trajectory calculates whether the disc enters one of the 4 arches cleanly or deflects.
- If disc fully crosses arch `k in {1, 2, 3, 4}`: `potted[Arch_k] += 1`.
- `unpotted_discs -= 1`.
- At end of `sub_turn`:
- If `sub_turn < 3`: `unpotted_discs` is set to `30 - sum(potted.values())`.
- If all 30 discs are potted and `sub_turn == 1`, award 1 bonus disc (ANS tournament rule [gap-fill]).
R3. Scoring Evaluation:
- `full_sets = min(potted[Arch_1], potted[Arch_2], potted[Arch_3], potted[Arch_4])`.
- `rem_1 = potted[Arch_1] - full_sets`.
- `rem_2 = potted[Arch_2] - full_sets`.
- `rem_3 = potted[Arch_3] - full_sets`.
- `rem_4 = potted[Arch_4] - full_sets`.
- `final_score = (full_sets * 20) + (rem_1 * 1) + (rem_2 * 2) + (rem_3 * 3) + (rem_4 * 4)`.
R4. Game / Match Winner: The agent with the highest `final_score` after all agents complete their 3 sub-turns wins the game.
## Edge cases
- Tie at the end condition: If two agents have equal final scores, each plays a single tiebreaker turn of 3 sub-turns. [gap-fill] If still tied, the agent with the highest number of discs in Arch 4 wins.
- A player with no legal move: Not applicable; sliding action is always available while discs remain.
- Repetition / cycles: Not applicable; exactly 30 discs are processed across strictly bounded 3 sub-turns.
- Simultaneous claims on the same resource or position: Not applicable; turns are strictly sequential.
- Player elimination mid-round; turn order repair: If an agent withdraws, their score is locked at their last completed sub-turn evaluation.
- Resource exhaustion: Exactly 30 discs per game; all unpotted discs are cleared at the end of Beurt 3.
- Termination guarantee: State transitions decrement remaining discs monotonically per slide, guaranteeing termination after at most `3 * 30 = 90` slide simulations per agent.
## State representation
- Persistent state:
- `potted_counts`: Map `{Arch_1: int, Arch_2: int, Arch_3: int, Arch_4: int}`.
- `current_sub_turn`: Integer in `{1, 2, 3}`.
- `remaining_discs_in_hand`: Integer in `[0..30]`.
- Per-turn ephemeral state:
- `discs_on_board`: List of 2D positions of stationary discs currently on the open track.
- Active trajectory vector: `(angle, speed, offset)`.
- Observable information:
- Full observability: all disc counts, arch distributions, and opponent scores are publicly visible.
## Action space
- `slide_disc(target_arch: int, release_velocity: float, lateral_offset: float)`:
- Preconditions: `remaining_discs_in_hand > 0`.
- Parameters: `target_arch in {1, 2, 3, 4}`, `release_velocity in [0.5, 4.0] m/s`, `lateral_offset in [-0.15, +0.15] m`.
## Playability notes
- Single-player-vs-AI: Natural; player competes against target score thresholds (e.g. 140+ for master level) or AI opponents.
- Group games (n>4): Fully scalable; tournament bracket/leaderboard handles arbitrary numbers of players without rule adjustments.
- Physical-skill games: Disc sliding modeled with directional precision: `entry_probability = f(angle_error, speed_window, disc_crowding_penalty)`.
- What is lost: The auditory click of beechwood discs colliding and the subtle tactile friction variations across waxed wood surfaces.
## Implementation hints
Low complexity. The deterministic scoring algorithm (R3) can be written in 10 lines of code. The trajectory simulator can be abstracted to a discrete success-check model per arch or implemented with simple 2D circle-wall physics. First milestone: Implement the exact mathematical set-bonus scorer, then attach the multi-turn sliding simulator.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Dutch Shuffleboard (Netherlands). (n.d.). Games of Countries. https://gamesofcountries.com/games/nl-netherlands/sjoelen
@misc{gamesofcountries-nl-netherlands-sjoelen,
title = {Dutch Shuffleboard (Netherlands)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/nl-netherlands/sjoelen}
}