Skip to main content
Formal Specification

Andorran Six-Pin Skittles — Formal Specification

Andorra · dexterity-throw · Confidence: low

← Back to game page

Implementation Suitability

Suitability: engine-readyFidelity: probabilistic-proxyGap-fills: 3
# Joc de bitlles (Bitlles andorranes) — AI-optimized specification ## General idea A turn-based Pyrenean six-pin bowling game where players throw up to three wooden batons per frame at six standing pins. The central strategic tension is that knocking down all pins yields only 6 points, whereas skillfully knocking down exactly five pins to leave one pin standing upright (*fer bitlla*) awards the maximum score of 10 points. ## Formal model - **Abstraction taken:** The continuous trajectory and physical collisions of the thrown wooden baton (*bitllot*) are abstracted into a parameterized probabilistic sampler that outputs which subset of standing pins fall on each throw. - **Player/agent count:** 2 or more individual agents, or 2 opposing teams of equal size. - **Turn model:** Sequential frame rotation. Each frame consists of up to 3 throw attempts per player. ## Formal rules R1. Setup: 6 pins start in a fixed 2x3 grid state `pins_standing = {1, 2, 3, 4, 5, 6}`. Each player's match score starts at 0. R2. A match consists of a fixed number of rounds `N` (default `N = 4`). Each round consists of one frame per player. R3. Frame execution: R3.1. At the start of a frame, `pins_standing` is reset to all 6 pins. Throw counter `throws_made = 0`. Frame score `frame_score = 0`. R3.2. On each throw, the active agent selects a target zone/aim vector. The stochastic resolver samples a subset of pins from `pins_standing` that fall. R3.3. `pins_standing` is updated by removing fallen pins. `throws_made` increments by 1. R3.4. If `|pins_standing| == 1` (exactly one pin remains standing), `frame_score = 10` (*fer bitlla*), the frame terminates immediately, and no further throws are taken in this frame. R3.5. If `|pins_standing| == 0` (all 6 pins knocked down), `frame_score = 6`, the frame terminates immediately. R3.6. If `throws_made < 3` and `|pins_standing| > 1`, the player proceeds to their next throw at the remaining standing pins. R3.7. If `throws_made == 3` and `frame_score == 0`, `frame_score = 6 - |pins_standing|` (total count of knocked down pins). R4. At frame end, the active player's cumulative match score is updated: `score_total += frame_score`. R5. Turn passes sequentially to the next player. R6. [gap-fill] Tie-break rule: If players are tied for first place after `N` rounds, tied players play one sudden-death frame until a winner emerges. ## Edge cases - Tie at the end condition: Resolved via R6 (single sudden-death frame between tied top scorers). - A player with no legal move: Not applicable — throwing at standing pins is always legal on an active turn. - Repetition / cycles: Not applicable — round count is strictly fixed at `N`, guaranteeing termination. - Simultaneous claims on the same resource or position: Not applicable — turns and throws are strictly sequential. - Player elimination mid-round: [gap-fill] If a player disconnects or forfeits, their remaining frames score 0 and turn order continues with the remaining active players. - Resource exhaustion: Not applicable — pins are reset every frame and throwing batons are reusable. - Termination guarantee: Guaranteed by the fixed finite frame count `N` and sudden-death resolution. ## State representation - Persistent state: `match_round` (integer 1..N), `scores` (map of player_id -> integer), `current_player_idx` (integer). - Per-frame ephemeral state: `pins_standing` (bitmask or set of integers in 1..6), `throws_made` (integer 0..3), `frame_score` (integer 0..10). - Observable information: Fully observable — all pin positions, scores, and throw counts are public. ## Action space - `throw(aim_target)`: Select an aim point among standing pins. Consumed by the physics/probabilistic resolver to determine pin impact and knockdown subset. ## Playability notes - Single-player-vs-AI: Natural — the AI evaluates aim targets to maximize expected value between safe point accumulation vs. aggressive 10-point *bitlla* attempts. - Group games (n>4): Generalizes seamlessly with standard turn rotation. - Physical-skill games: [gap-fill] Throw outcome modeled as `P(pin_i falls | aim_target, skill) = f(distance(pin_i, aim_target), skill_level)`. - What is lost: The exact aerodynamic spin and bounce of the wooden *bitllot* on hard soil is abstracted into probability distributions. ## Implementation hints Extremely simple and deterministic scoring engine once throw outcomes are sampled. The core strategic challenge is deciding whether to go for a 5-pin spread on throw 1 or incrementally pick off pins across 3 throws.

Download as JSON

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

Download JSON
Cite this page

Andorran Six-Pin Skittles (Andorra). (n.d.). Games of Countries. https://gamesofcountries.com/games/ad-andorra/bitlles-andorranes

@misc{gamesofcountries-ad-andorra-bitlles-andorranes,
  title = {Andorran Six-Pin Skittles (Andorra)},
  year = {n.d.},
  publisher = {Games of Countries},
  url = {https://gamesofcountries.com/games/ad-andorra/bitlles-andorranes}
}