Skip to main content
Formal Specification

Turkish Spinning Top (Top Battle) — Formal Specification

Türkiye · top-spinning · Confidence: low

← Back to game page

Implementation Suitability

Suitability: adaptation-requiredFidelity: probabilistic-proxyGap-fills: 3
# Topaç Çevirme — AI-optimized specification ## General idea A multi-player competitive top-spinning game where agents attempt to strike and eject a stationary target top from a central circle using their own thrown tops. The physical throw, spin success, and collision outcomes are modeled stochastically, allowing players to weigh target acquisition against the risk of miss-hits that turn their own tops into targets. ## Formal model - **Abstraction taken:** The continuous physical throw, string release, and rigid-body mechanics of top collisions are abstracted into a target-striking success probability model. [gap-fill] The physical resting locations and spin durations are mapped to discrete states and success parameters. - **Player/agent count:** 2 to 8 agents. - **Turn model:** Sequential strike turns, following an initial simultaneous spin-off that designates the target. ## Formal rules R1. Game state: - `circle_radius: float` (e.g., 0.75 meters). - `target_owner: integer` (index of player whose top is the current target, or -1 if no target). - `target_position: Coordinate(x, y)` (starts at origin (0,0) when active). - `player_scores: Array[num_players] of integer`. R2. Initialization (Ebe Belirleme): - All agents simultaneously execute a spin attempt. - Each agent rolls `spin_duration = skill(p) * random(0.5, 1.5)`. - The agent with the minimum `spin_duration` is designated the target: `target_owner = p`, and their top is placed at coordinate (0,0). All other agents are added to the attacker queue. R3. Attacking phase: - The active attacker `a` from the queue must execute a throw targeting the center (0,0). R4. Throw resolution: - The success of the strike is evaluated stochastically: `P(Strike) = skill(a) * 0.70` `P(Spin_Success) = skill(a) * 0.85` - Case 1: Strike succeeds and Spin succeeds. - The target top is knocked out of the circle: `target_owner = -1`. - Attacker `a` gains 1 point: `player_scores[a] += 1`. - [gap-fill] The next player in the queue whose top stopped spinning first in the initialization phase becomes the new target in the center. - Case 2: Strike succeeds but Spin fails. - The target top is knocked out, but attacker `a`'s top fails to spin. - Attacker `a`'s top is placed at (0,0) as the new target: `target_owner = a`. The previous target is returned to its owner. - Case 3: Strike fails and Spin fails. - Attacker `a`'s top becomes the new target at (0,0): `target_owner = a`. Previous target returned to owner. - Case 4: Strike fails but Spin succeeds. - Attacker `a`'s top spins but does not strike. It lands at some Coordinate `pos` sampled near the circle boundary. - [gap-fill] If `pos` is inside the circle, it is a foul; attacker `a`'s top becomes the new target: `target_owner = a`. Otherwise, no state change occurs, turn passes. R5. Turn rotates to the next attacker in the queue. R6. End condition: - The game ends after a fixed number of rounds (e.g., each player has had 3 attack opportunities). R7. Win condition: The player with the highest score wins. Ties result in a joint win. ## Edge cases - **Tie at the end condition:** Shared victory. - **A player with no legal move:** Not applicable. - **Repetition / cycles:** Bounded by the round limit (R6). - **Simultaneous claims on the same resource:** Not applicable; turns are sequential. - **Player elimination mid-round:** Not applicable. - **Resource exhaustion:** Not applicable. - **Termination guarantee:** Guaranteed by R6's fixed-round limit. ## State representation - Persistent state: - `target_owner: integer`. - `player_scores: Array[num_players] of integer`. - `queue: List of integer` (active attackers). - `round: integer`. - Ephemeral state: - `strike_roll: float`. - `spin_roll: float`. - Information set: Public, fully observable. ## Action space - `strike_target()`: execute the strike throw targeting (0,0). Valid only on player's turn if they are not the target owner. ## Playability notes - Single-player-vs-AI: Suitable. The player faces multiple AI opponents who choose to strike with varying skill levels. - Group games: Generalizes naturally to any number of players. - Physical-skill games: Fully abstracted via success probability formulas. - What is lost: The exact physics of wooden tops spinning, sliding, colliding, and the sound of impact. ## Implementation hints Low-medium complexity. The tricky part is the transition of who is the active target when hits or misses occur. First milestone: write the initialization phase (R2) and the turn queue transition, then implement the four resolution cases of R4.

Download as JSON

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

Download JSON
Cite this page

Turkish Spinning Top (Top Battle) (Türkiye). (n.d.). Games of Countries. https://gamesofcountries.com/games/tr-turkiye/topac-cevirme

@misc{gamesofcountries-tr-turkiye-topac-cevirme,
  title = {Turkish Spinning Top (Top Battle) (Türkiye)},
  year = {n.d.},
  publisher = {Games of Countries},
  url = {https://gamesofcountries.com/games/tr-turkiye/topac-cevirme}
}