Formal Specification
Andorran Six-Pin Skittles — Formal Specification
Andorra · dexterity-throw · Confidence: low
← Back to game pageImplementation 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 JSONCite 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}
}