Skip to main content
Formal Specification

Road and Field Bowling — Formal Specification

Netherlands · dexterity-throw · Confidence: low

← Back to game page

Implementation Suitability

Suitability: adaptation-requiredFidelity: probabilistic-proxyGap-fills: 2
# Klootschieten — AI-optimized specification ## General idea A turn-based team road race where players alternate underarm throws along a winding 1D/2D roadway course. The strategic decision space centers on shot angle, velocity, and roll trajectory management through road curves and cambers to maximize forward progression while minimizing the risk of skidding off-road into friction-heavy ditches. ## Formal model - **Abstraction taken:** The physical terrain (curved road surface, camber, asphalt friction, grass verge) is modeled as a 1D path with lateral width `W` and curvature checkpoints. The physical underarm throw is replaced by a stochastic roll-distance sampler parameterized by aim angle, power, and road surface friction. [gap-fill] - **Player/agent count:** 2 teams of `k` agents (default `k=4`), or reduced to 2 competing agents controlling team throws. - **Turn model:** Dynamic turn order: the team furthest behind in cumulative distance along the course always possesses the next turn. ## Formal rules R1. Setup: A track of length `L` (e.g. 3000 meters) and width `W` (e.g. 4.0 meters) is initialized. Team A and Team B begin at `dist = 0.0, throws = 0`. R2. Active Team Selection: At any state, the active team `T_active` is `argmin(dist(A), dist(B))`. If `dist(A) == dist(B)`, `T_active` alternates. R3. Action Selection: The active thrower from `T_active` selects an action `throw(power, angle_offset)` where `power in [0.0, 1.0]` and `angle_offset in [-15 deg, +15 deg]`. R4. Throw Trajectory Simulation: - Forward distance `d_air = f_air(power, player_strength)`. - Lateral displacement `lat_disp = f_lat(angle_offset, road_camber)`. - Roll distance `d_roll = f_roll(surface_friction, remaining_velocity)`. - If at any point during roll `abs(lat_pos) > W / 2` (ball enters roadside verge/ditch), forward roll halts immediately at the exit coordinate `x_exit`. - Next throw for this team originates from `(x_exit, 0.0)` (realigned perpendicular onto the road center). R5. State Update: `dist(T_active) += total_forward_distance; throws(T_active) += 1; next_player_index(T_active) = (next_player_index + 1) % k`. R6. End Condition: When a team reaches `dist >= L`, that team completes its round. The opposing team continues throwing until `dist >= L`. R7. Win / Loss Resolution: - If `throws(A) < throws(B)`, Team A wins. - If `throws(B) < throws(A)`, Team B wins. - If `throws(A) == throws(B)`, the team with the greater overrun `dist - L` wins. ## Edge cases - Tie at the end condition: Resolved deterministically by R7 via distance overrun past `L`. In the rare case of identical overrun [gap-fill], a single 1-shot sudden-death throw decides the winner. - A player with no legal move: Not applicable; a legal throw action is always available. - Repetition / cycles: Not applicable; forward distance per throw is strictly non-negative `(d >= 0)`, guaranteeing monotonic progress toward `L`. - Simultaneous claims on the same resource or position: Not applicable; turns are strictly sequential per R2. - Player elimination mid-round; turn order repair: If an agent is eliminated or incapacitated, the team cycle skips to the next active player `(index + 1) % remaining_players`. - Resource exhaustion (pieces, tokens, space, time): Bounded; road distance `L` is finite and throw counts increment per turn. - Termination guarantee: Because each throw produces strictly positive forward progress in expectation `E[d] > 0`, the track distance `L` is reached in a finite expected number of steps `N < infty`. ## State representation - Persistent state: - `track_length`: Float `L`. - `team_state`: Map `{Team_A: (dist, throws, current_thrower_idx), Team_B: (dist, throws, current_thrower_idx)}`. - `course_geometry`: List of road curvature segments. - Per-turn ephemeral state: - Active throw parameters: `(power, angle_offset)`. - Roll physics trace: `(d_air, d_roll, off_road_event_bool)`. - Observable information: - Complete information: all positions, throw counts, and track dimensions are fully visible to all agents. ## Action space - `throw(power: float, angle_offset: float)`: - Preconditions: Active team's turn; thrower is valid. - Parameters: `power` in `[0.1, 1.0]`, `angle_offset` in `[-0.3, +0.3]` radians. ## Playability notes - Single-player-vs-AI: Natural; player aims to beat an AI team's throw sequence over the designated course length. - Group games (n>4): The multi-player team structure reduces cleanly to 2 competing agents (each making decisions for their team) without altering gameplay mechanics. - Physical-skill games: Physical arm torque and curve management are abstracted into a 2D trajectory generator with Gaussian noise on aim accuracy. - What is lost: The tactical road reading (anticipating potholes, gravel patches, puddles, and drainage camber) and physical swing exertion. ## Implementation hints Low-to-medium complexity. The primary simulation element is the road physics function determining whether a chosen power/angle combination safely navigates road bends or ends in the grass verge. First milestone: Implement a straight-line track model with basic roll vs. ditch trade-offs, then add curved road profiles and tiebreaker overrun logic.

Download as JSON

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

Download JSON
Cite this page

Road and Field Bowling (Netherlands). (n.d.). Games of Countries. https://gamesofcountries.com/games/nl-netherlands/klootschieten

@misc{gamesofcountries-nl-netherlands-klootschieten,
  title = {Road and Field Bowling (Netherlands)},
  year = {n.d.},
  publisher = {Games of Countries},
  url = {https://gamesofcountries.com/games/nl-netherlands/klootschieten}
}