Formal Specification
Bocce (Bay of Kotor Coastal Boules) — Formal Specification
Montenegro · dexterity-throw · Confidence: high
← Back to game pageImplementation Suitability
Suitability: engine-readyFidelity: probabilistic-proxyGap-fills: 2
# Bućanje — AI-optimized specification
## General idea
A traditional coastal lawn bowling game played on an unpaved lane (*zog*). Teams take turns throwing heavy boules to position them closest to a small target ball (*bulin*) or forcefully dislodge opposing balls. Turn order is dynamic: the team currently not holding the closest boule must continue throwing until they regain the lead or exhaust their boules.
## Formal model
- **Abstraction taken:** The continuous 2D court geometry (`24m x 3.5m`) is preserved in a 2D coordinate model `(x, y)`. The physical throw execution (spin, bounce, collision physics) is replaced by a 2D stochastic landing sampler `(x_land, y_land) ~ Gaussian(target_coord, sigma(skill, throw_type))` with elastic collision resolution for displaced balls.
- **Player/agent count:** 2 teams (Team A and Team B), typically 2 agents each controlling 2 boules (total 4 boules per team per round).
- **Turn model:** Sequential, with dynamic turn determination based on ball proximity to the bulin.
## Formal rules
R1. Setup: State tracks `score_A: int = 0`, `score_B: int = 0`. Each round (*ruka*) initializes with `boules_remaining[A] = 4`, `boules_remaining[B] = 4`. Target score is `WIN_SCORE = 13`.
R2. Jack throw: The starting team chooses a target location `(x, y)` to place the bulin; coordinates are sampled within legal boundaries `x in [12.0, 20.0], y in [0.5, 3.0]`.
R3. First throw: The starting team executes `roll_boule(target_coord)` to place their first boule.
R4. Dynamic turn order:
- At any point during the round, determine which team currently holds the boule closest to the bulin.
- The team that does **not** hold the closest boule must take the next turn.
- If the losing team has no remaining boules, the other team throws all its remaining boules consecutively.
R5. Action choices per turn:
- `ROLL(target_x, target_y)`: Precision placement (*valjanje*); lower variance `sigma`, susceptible to terrain drag.
- `STRIKE(target_boule_id)`: High-velocity aerial direct hit (*izbijanje*); higher variance; on hit, transmits momentum to target ball and ejects or displaces it.
R6. Round scoring:
- When all 8 boules have been thrown, identify the winning team (team with the single closest boule to the bulin).
- [gap-fill] Count all boules of the winning team that are strictly closer to the bulin than the nearest boule of the losing team. Award that many points (`1..4`) to the winning team.
- Losing team scores 0 points.
R7. Match end: The first team to reach `WIN_SCORE` points wins the match immediately.
R8. [gap-fill] Equidistant tie: If the closest boules of both teams are measured at exactly equal distance from the bulin, each team throws one additional boule to resolve the tie point.
## Edge cases
- Tie at the end condition: Resolved by R7 (first team to reach target wins; if both cross target in alternative formats, highest score wins).
- A player with no legal move: Not applicable; as long as `boules_remaining > 0`, an agent can always execute `ROLL` or `STRIKE`.
- Repetition / cycles: Each throw strictly decreases `boules_remaining`; each round terminates in exactly 8 throws; scores strictly increase each round, guaranteeing game termination.
- Simultaneous claims on the same resource or position: Overlapping ball positions resolve via 2D elastic sphere displacement; throws are strictly sequential.
- Player elimination mid-round; turn order repair: Team-based game; if an agent disconnects, remaining team agent(s) throw the remaining boules.
- Resource exhaustion: Boule pool is strictly 4 per team per round, refreshed every round.
- Termination guarantee: Each round takes <= 8 throws and awards at least 1 point to one team; maximum possible rounds is `2 * WIN_SCORE - 1`.
## State representation
- Persistent state: `score_A: int`, `score_B: int`, `round_num: int`.
- Per-round state: `bulin_pos: Vector2D`, `boules_on_court: list<{team: TeamID, pos: Vector2D}>`, `boules_remaining: map`.
- Observable information: Fully observable public game state (all positions, remaining boules, and scores are visible to all agents).
## Action space
- `ROLL(target_x: float, target_y: float)`: Precondition: Active turn, `boules_remaining[team] > 0`.
- `STRIKE(target_boule_id: int)`: Precondition: Active turn, `boules_remaining[team] > 0`, target boule exists on court.
## Playability notes
- Single-player-vs-AI: Engine-ready; AI evaluates strategic utility between rolling for placement vs. striking to clear opponent's winning boule.
- Group games (n>4): Generalizes to 4v4 or 3v3 by partitioning team boule budget across players.
- Physical-skill games: Skill modeled by 2D bivariate normal dispersion centered on target coordinates.
- What is lost: Uneven physical bumps of gravel and tavern crowd distractions.
## Implementation hints
Ideal balance of strategic depth and manageable continuous state. 2D Euclidean distance and basic circular collision physics suffice for the resolver. Milestone 1: Implement dynamic turn scheduler and scoring counter. Milestone 2: Implement 2D physics collision and AI heuristic evaluation.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Bocce (Bay of Kotor Coastal Boules) (Montenegro). (n.d.). Games of Countries. https://gamesofcountries.com/games/me-montenegro/bucanje
@misc{gamesofcountries-me-montenegro-bucanje,
title = {Bocce (Bay of Kotor Coastal Boules) (Montenegro)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/me-montenegro/bucanje}
}