Skip to main content
Formal Specification

Turkish Knucklebones — Formal Specification

Türkiye · dexterity-small · Confidence: low

← Back to game page

Implementation Suitability

Suitability: adaptation-requiredFidelity: probabilistic-proxyGap-fills: 4
# Aşık Oyunu — AI-optimized specification ## General idea A traditional Turkish dexterity game where players attempt to knock knucklebones out of a central circle using a heavy shooter bone (*saka*). Physical throws are modeled stochastically, allowing players to choose their shot targets and balance the risk of long-distance shots against the reward of scoring and earning bonus throws from closer proximity. ## Formal model - **Abstraction taken:** The continuous physical throw of the *saka* at the target bones is replaced by a discrete target selection action, followed by a stochastic resolution based on player skill, distance, and remaining target density. [gap-fill] The exact throwing physics and bone collisions are abstracted into joint probabilities of hitting specific bones. - **Player/agent count:** 2 to 6 agents, acting sequentially. - **Turn model:** Strictly sequential, determined by a randomizer roll representing the pre-game *Saka Atışı* bone-tossing ritual. ## Formal rules R1. Setup: A circle of radius `R` (e.g. 1.0 meter) is centered at coordinate (0,0). `N` target bones are placed in a straight line at `x = 0`, from `y = -0.5` to `y = 0.5`. Each player `p` has their shooter position `pos(p)` initialized to the throwing line at `y = -4.0`. R2. Turn order initialization: Each agent rolls a virtual 4-sided die representing the bone sides (Alçı=4, Tof=3, Çık=2, Ompa=1). Turn order is sorted in descending order of the roll. [gap-fill] In case of a tie, the tied agents roll again until all ranks are unique. R3. On agent `p`'s turn, if they are at the throwing line, they must select a target bone `t` from the remaining set inside the circle. R4. Throw resolution: The outcome is sampled based on the distance `D` from `pos(p)` to `t`. - `P(Success) = skill(p) * (1.0 - D / 10.0) * density_factor`. - If successful, target bone `t` is removed from the board (captured by `p`). - The shooter bone `saka` comes to rest at a new coordinate `pos(p) = (target_x + error_x, target_y + error_y)`. - If unsuccessful, `pos(p)` is reset to the throwing line, no bones are captured, and the turn ends. R5. Bonus Turn rule: If a throw is successful, agent `p` gains an extra throw immediately and must execute their next action from their current resting position `pos(p)` instead of resetting to the throwing line. This can chain until a miss occurs or all bones are captured. R6. [gap-fill] Boundary check: If an agent's `pos(p)` lands inside the circle boundaries (`D < R` from origin), they must immediately reset to the throwing line for their next action to prevent trivial point blank shooting. R7. End condition: The game terminates immediately when all `N` bones are captured. R8. Win condition: The agent with the highest count of captured bones wins. If multiple agents have the highest count, the game ends in a tie. ## Edge cases - **Tie at the end condition:** Handled by R8 — equal highest captures results in a shared tie. - **A player with no legal move:** Not applicable; as long as there is at least one bone remaining inside the circle, a target is available. - **Repetition / cycles:** Bounded, because `P(Success) > 0` is guaranteed, meaning the number of bones strictly decreases over time, preventing infinite loops. - **Simultaneous claims on the same resource:** Not applicable; turns are strictly sequential and individual targets are removed immediately upon capture. - **Player elimination mid-round:** Not applicable; players remain in the game until the end of the round. - **Resource exhaustion:** Total bones is fixed at setup and decrease strictly. - **Termination guarantee:** Since success probability is non-zero, the board will eventually be cleared. An upper bound of 100 turns can be enforced [gap-fill] as a fail-safe draw condition. ## State representation - Persistent state: - `bones: List of Coordinate(x, y)` (positions of remaining target bones). - `scores: Array[num_players] of integer` (captured bone count per player). - `player_positions: Array[num_players] of Coordinate(x, y)` (current position of each player's saka). - `active_player: integer` (index of current player). - `consecutive_strikes: integer` (for extra turn chaining). - Ephemeral state: - `hit_success: boolean` (whether the current shot succeeded). - `new_saka_position: Coordinate(x, y)`. - Information set: Fully public, perfect information. ## Action space - `aim_throw(target_index)`: where `target_index` corresponds to an active bone in `bones`. Only valid on player's turn. ## Playability notes - Single-player-vs-AI: Excellent; can be played against heuristic AIs that target the closest bone or the bone with the highest clearing probability. - Group games (n>4): Reduces cleanly. Turn order scales up to `n` easily; no structural mechanics are altered. - Physical-skill games: Physical accuracy is abstracted via `P(Success)` formula. - What is lost: The exact physical collisions of bones knocking into each other, spinning, and bouncing. ## Implementation hints Low complexity. The 2D coordinates of bones and player shooters are easy to model. Focus on implementing a clean success-probability model and tracking the variable player shooting coordinates. First milestone: build the turn queue (R2) and a basic 2D hit-detector utilizing a simple probability function.

Download as JSON

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

Download JSON
Cite this page

Turkish Knucklebones (Türkiye). (n.d.). Games of Countries. https://gamesofcountries.com/games/tr-turkiye/asik-oyunu

@misc{gamesofcountries-tr-turkiye-asik-oyunu,
  title = {Turkish Knucklebones (Türkiye)},
  year = {n.d.},
  publisher = {Games of Countries},
  url = {https://gamesofcountries.com/games/tr-turkiye/asik-oyunu}
}