Formal Specification
Turkish Knucklebones — Formal Specification
Türkiye · dexterity-small · Confidence: low
← Back to game pageImplementation 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 JSONCite 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}
}