Skip to main content
Formal Specification

Belt-circle defense game — Formal Specification

Azerbaijan · wrestling-combat · Confidence: low

← Back to game page

Implementation Suitability

Suitability: adaptation-requiredFidelity: probabilistic-proxyGap-fills: 2
# Dirədöymə — AI-optimized specification ## General idea A two-phase circle defense game: attackers first try to snatch belts out from under defenders' anchored feet while risking a below-the-knee kick, and once every belt is captured, the game flips into a second phase where the former defenders must dodge belt-whips and land a single counter-kick to trigger a complete role reversal. The belt count is a hard, monotonically-shrinking resource that gates the phase transition. ## Formal model - **Abstraction taken:** Real snatching dexterity, kick accuracy, and dodge reflexes are abstracted into stochastic per-attempt success checks, since the entry describes them qualitatively without numeric models. - **Player/agent count:** 2 teams of 3-6 (equal size); `belt_count = defender_team_size` at round start. - **Turn model:** Synchronous ticks within each phase; all players act simultaneously each tick, resolved at tick end. ## Formal rules R1. Setup (entry §1): a circle 5 m in diameter is drawn; each defender anchors one foot on a folded belt (`dirə`); attackers surround the outside of the circle. `belts_captured = 0`. R2. Session mode: exactly one of `elimination_mode` or `instant_swap_mode` is fixed for the whole session [gap-fill: entry §3.1 states a successful Phase 1 kick causes "elimination, or an immediate role swap," presenting these as alternatives without specifying which applies when; treated as a session-fixed ruleset choice, consistent with how other dual-outcome entries in this batch are resolved]. R3. Phase 1 actions (entry §2.1-2.3): each tick, any attacker may submit `snatch_attempt(defender_id)`; any defender may submit `kick(attacker_id)`, legal only while that defender maintains at least one foot on or inside the circle boundary. R4. Phase 1 kick resolution: `kick()` resolves a stochastic success check. On success, either that attacker is eliminated from Phase 1 (`elimination_mode`) or a full role reversal triggers immediately, identical in effect to R8 (`instant_swap_mode`), per the R2 session choice. R5. Phase 1 snatch resolution: `snatch_attempt()` resolves a stochastic success check; success removes that belt from the defender's foot and pulls it outside the circle without the attacker being kicked in the process (entry §3.2), incrementing `belts_captured` and permanently transferring that belt to the attacking team. R6. Phase transition: the instant `belts_captured = belt_count` (all belts taken), Phase 1 ends and Phase 2 begins (entry §4.1). R7. Phase 2 actions (entry §4.1-4.2): each tick, any attacker (now belt-holder) may submit `whip(defender_id)` from outside the boundary; each defender may submit `dodge()` or `counter_kick(attacker_id)`. `whip()` and `counter_kick()` each resolve independent stochastic success checks. R8. Phase 2 role reversal (entry §4.3): the instant any `counter_kick()` succeeds, a full role reversal triggers: all attackers immediately drop their belts and flee into the circle (becoming the new defenders), and the former defenders snatch the dropped belts and pursue, whipping the retreating former attackers (becoming the new attackers). This ends the round; a new round begins at R1 with roles swapped and belts reset under the new defenders' feet. R9. Match end: the entry specifies no score threshold, only "played in rounds until an agreed score or festive conclusion is reached" (entry §5) [gap-fill: treated honestly as an external session parameter, since the source gives no fixed number]. ## Edge cases - Tie at the end: not applicable — there is no formal terminal state without an externally-agreed score (R9). - A player with no legal move: not applicable — attackers always have `snatch_attempt`/`whip` available (phase-dependent); defenders always have `kick`/`dodge`/`counter_kick` available (phase-dependent). - Repetition / cycles: not structurally prevented across rounds — successive role reversals (R8) can in principle continue indefinitely without any externally-agreed stopping point, consistent with the entry's own "until an agreed score or festive conclusion" framing (R9). - Simultaneous claims on one position: not applicable — each belt is snatched or defended independently (R5); there is no shared contested slot. - Elimination mid-round and turn-order repair: in `elimination_mode`, an eliminated attacker (R4) is simply removed from Phase 1 activity for the remainder of that phase; all other players' state is unaffected. - Resource exhaustion: `belt_count` is the phase-gating resource and is designed to reach zero (R6); this is the intended mechanic, not an anomaly. - Termination guarantee: **not guaranteed at the match level.** Within a single round, Phase 1 is bounded — `belts_captured` is monotonically non-decreasing and capped at `belt_count`, and each `snatch_attempt()` carries non-zero success probability, so Phase 1 completes with probability 1 (the same hazard-style argument used elsewhere in this batch); Phase 2 is similarly bounded, since each `counter_kick()` carries non-zero success probability and R8 triggers on the first success. So each *round* terminates with probability 1. But the *match* — the sequence of rounds — has no formal stopping rule in the source (R9), so `termination_guaranteed: false` reflects the match level honestly, matching the entry's own open-ended framing. ## State representation - Persistent (match) state: `round_number`, `defender_team`, `attacker_team`. - Per-round state: `phase` (1 or 2), `belts_captured` (0 to `belt_count`), `mode` (fixed, R2). - Per-tick ephemeral state: `eliminated_attackers` (elimination_mode only), positions. - Observable information: fully observable — all positions, belt status, and phase are public; no hidden information. ## Action space - `snatch_attempt(defender_id)`: any attacker, Phase 1; precondition: `phase = 1`. - `kick(attacker_id)`: any defender, Phase 1; precondition: `phase = 1`, kicking defender has a foot on/inside the boundary. - `whip(defender_id)`: any attacker, Phase 2; precondition: `phase = 2`. - `dodge()` / `counter_kick(attacker_id)`: any defender, Phase 2; precondition: `phase = 2`. ## Playability notes - Single-player-vs-AI: workable as human-plays-one-role vs AI opponents in either phase; the phase-2 dodge/counter-kick decision gives a natural single-moment tactical choice for a human defender. - Reducing team size to 3v3: mechanically consistent — `belt_count` simply scales down. - Physical-skill games: real snatching dexterity, kick accuracy, and dodge reflexes are the entire game and are collapsed into stochastic checks (R4-R5, R7); no genuine martial reflexes are modeled. - What is lost: the actual balance and pain tolerance required to anchor a foot on a belt while kicking, the sting of a real belt whip, and the festival framing (Novruz) that gave the game its seasonal significance. ## Implementation hints State is modest (a belt counter, phase flag, mode setting); the real design difficulty is calibrating the snatch, kick, whip, and counter-kick success probabilities, none of which the source quantifies. First milestone: implement Phase 1 with flat probabilities to verify the belt-exhaustion phase transition (R6), then add Phase 2 and the counter-kick-triggered role reversal (R8).

Download as JSON

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

Download JSON
Cite this page

Belt-circle defense game (Azerbaijan). (n.d.). Games of Countries. https://gamesofcountries.com/games/az-azerbaijan/diredoyme

@misc{gamesofcountries-az-azerbaijan-diredoyme,
  title = {Belt-circle defense game (Azerbaijan)},
  year = {n.d.},
  publisher = {Games of Countries},
  url = {https://gamesofcountries.com/games/az-azerbaijan/diredoyme}
}