Formal Specification
Sammarinese Bowls (Bocce) — Formal Specification
San Marino · dexterity-throw · Confidence: low
← Back to game pageImplementation Suitability
Suitability: engine-readyFidelity: probabilistic-proxyGap-fills: 1
# Bocce sammarinesi — AI-optimized specification
## General idea
A turn-based target-distance boules game where two sides deliver four balls each per frame. The side not currently holding the point must continue throwing until they capture the point or exhaust their balls. At frame end, only the closest side scores, earning points for every ball closer than the opponent's best ball.
## Formal model
- **Abstraction taken:** The 2D continuous court rolling dynamics and 3D collisions are abstracted into a 2D position state vector for the *pallino* `(P_x, P_y)` and 8 played balls `(B_i_x, B_i_y)`.
- **Player/agent count:** 2 sides (Team A and Team B).
- **Turn model:** Dynamic turn switching: the team currently farther from the target must throw next.
## Formal rules
R1. Match setup: Team scores start at `score_A = 0`, `score_B = 0`. Target score is `Win_Score = 12`.
R2. Frame initialization:
R2.1. Active starting team throws the *pallino*, establishing target position `P = (P_x, P_y)` within valid lane bounds `[L_min, L_max] x [-W/2, +W/2]`.
R2.2. Starting team throws their 1st ball `b1_A`.
R2.3. Balls remaining counters are set: `rem_A = 3`, `rem_B = 4`.
R3. Turn decision logic during a frame:
R3.1. Compute minimum distance to pallino for each team: `d_min_A = min_{b in Balls_A} ||b - P||`, `d_min_B = min_{b in Balls_B} ||b - P||` (if a team has thrown 0 balls, its `d_min` is infinity).
R3.2. If `d_min_A < d_min_B` and `rem_B > 0`: Team B throws next ball.
R3.3. If `d_min_B < d_min_A` and `rem_A > 0`: Team A throws next ball.
R3.4. If one team has exhausted its balls (`rem == 0`), the other team throws all its remaining balls sequentially.
R4. Frame scoring:
R4.1. When `rem_A == 0` and `rem_B == 0`, compare `d_min_A` and `d_min_B`.
R4.2. If `d_min_A < d_min_B`: Team A scores `K` points, where `K = |{ b in Balls_A : ||b - P|| < d_min_B }|` (`1 <= K <= 4`).
R4.3. If `d_min_B < d_min_A`: Team B scores `K` points, where `K = |{ b in Balls_B : ||b - P|| < d_min_A }|` (`1 <= K <= 4`).
R4.4. The scoring team begins the next frame.
R5. Win condition: The match ends when `score_A >= 12` or `score_B >= 12`.
R6. [gap-fill] Exact equidistant tie in frame: If `d_min_A == d_min_B` at frame end, the frame is declared void (0 points awarded to both) and replayed.
## Edge cases
- Tie at the end condition: Not applicable — one team reaches 12 first because points are strictly awarded to only one team per frame.
- A player with no legal move: Not applicable — throwing a ball is always legal while `rem > 0`.
- Repetition / cycles: Bounded because each frame consumes exactly 8 balls and scores strictly increase (R4) with positive probability.
- Simultaneous claims on the same resource or position: Ball displacement and displacement collisions are resolved via 2D rigid circle physics.
- Player elimination mid-round: Disconnection awards remaining frame points and match victory to the active opponent.
- Resource exhaustion: Ball count per frame is strictly fixed at 4 per team.
- Termination guarantee: Guaranteed by monotonic point accumulation toward 12.
## State representation
- Persistent state: `score_A` (0..12), `score_B` (0..12), `starting_team` (enum: A/B).
- Per-frame ephemeral state: `pallino_pos` `(x, y)`, `balls_A` (list of `(x, y)`), `balls_B` (list of `(x, y)`), `rem_A` (int 0..4), `rem_B` (int 0..4).
- Observable information: Fully observable by both teams.
## Action space
- `throw_accosto(target_x, target_y)`: Precision roll to rest near coordinates.
- `throw_raffa(target_ball_id)`: High-velocity drive targeting a specific ball or pallino.
## Playability notes
- Single-player-vs-AI: Natural — the AI evaluates positional expected value between defensive blocking vs. aggressive displacement.
- Group games (n>4): Supported via standard doubles/triples team rotation.
- Physical-skill games: Parameterized throw dispersion `P(ball_pos | target, skill)`.
- What is lost: The subtle read of natural grain, micro-slope, and spin on the playing surface.
## Implementation hints
Discrete frame state engine is straightforward. The dynamic turn-switching rule (R3) must be evaluated after every single throw.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Sammarinese Bowls (Bocce) (San Marino). (n.d.). Games of Countries. https://gamesofcountries.com/games/sm-san-marino/bocce-sammarinesi
@misc{gamesofcountries-sm-san-marino-bocce-sammarinesi,
title = {Sammarinese Bowls (Bocce) (San Marino)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/sm-san-marino/bocce-sammarinesi}
}