Skip to main content
Formal Specification

The Log (Balka / Klyok Target Throwing) — Formal Specification

Belarus · dexterity-throw · Confidence: medium

← Back to game page

Implementation Suitability

Suitability: adaptation-requiredFidelity: discretizedGap-fills: 2
# Балка — AI-optimized specification ## General idea A target-toppling retrieval game whose distinguishing mechanic is an explicit invulnerability window: the Guard has categorically no power to tag anyone while the block lies toppled, and only regains tagging power the instant they re-erect it and announce "Стаіць!" — turning the retrieval sprint into a race against a clearly-telegraphed, binary state change rather than a continuously-live threat. ## Formal model - **Abstraction taken:** Real throwing accuracy, sprint speed, and tag contact are abstracted into stochastic per-attempt checks, since the entry describes them qualitatively without numeric models. The single-baton-per-player constraint (each Thrower has exactly one baton, entry Players & materials) is treated as a hard resource limit rather than an infinite-attempts mechanic. - **Player/agent count:** 1 Guard, K Throwers, K in [2, 9]. - **Turn model:** Sequential during the throwing phase (one Thrower at a time); synchronous ticks during the retrieval/re-erection race. ## Formal rules R1. Setup: the block stands upright in its 1 m circle; the Guard stands beside it holding their own stick; all Throwers stand behind the baseline (10-15 m away) each holding their single baton (entry §1). R2. Throwing phase (entry §2.1-2.2): Throwers take turns submitting `throw_baton()` underhand at the block from behind the baseline. A miss leaves the thrown baton on the ground where it landed; that Thrower now holds no baton and must wait behind the baseline [gap-fill: since each player has exactly one baton and the entry gives no rule for retrieving it before a topple, a Thrower without a baton cannot throw again until a topple event (R3) opens the retrieval window]. R3. Topple (entry §3.1, first-numbered "3"): a throw that strikes the block down sets `block_standing = false`, and "Балка збіта!" is called. R4. Retrieval and re-erection race (entry §3.2-3.3): the instant `block_standing = false`, every Thrower with a baton in the field may submit `sprint_and_retrieve()`, moving to recover their own baton; simultaneously the Guard submits `re_erect_block()`, racing to stand the block back up. Both proceed as simultaneous per-tick actions. R5. Invulnerability window (entry second §3.2, renumbered here as the safe-window rule): while `block_standing = false`, the Guard has no tagging power whatsoever — `tag()` is not a legal action for the Guard during this window, regardless of any Thrower's position. R6. Re-erection trigger (entry second §3.3-3.4): the instant the Guard's `re_erect_block()` completes, `block_standing` becomes `true` and the Guard calls "Стаіць!". From this moment, the Guard may submit `tag(thrower_id)` against any Thrower who is in the field and currently holding (has already picked up) their own baton [gap-fill: the entry's phrase "touching their baton" is read as requiring the Thrower to have already retrieved their baton to be a valid tag target — a Thrower still empty-handed and searching is not yet taggable, since the rule's evident purpose is to punish a successful-but-slow retrieval, not mere presence in the field]. R7. Safe return: a Thrower who crosses back behind the baseline while still holding their baton is safe for the remainder of the round (entry's Objective section: "sprint back... before being tagged"). R8. Tag and role transition (entry §5.1-5.2): if the Guard's `tag()` succeeds against a baton-holding Thrower in the field, that Thrower becomes the new Guard for the next round; the former Guard picks up their own stick and joins the Throwers behind the baseline. R9. Guard retention (entry §5.3): if every Thrower safely retrieves their baton and crosses behind the baseline without being tagged, the same Guard remains Guard for another round, and a new round begins at R1 with the block reset and all Throwers' batons back in hand. ## Edge cases - Tie at the end: not applicable — there is no scoring system or match-level terminal state; each round resolves cleanly to either R8 (role change) or R9 (Guard retained). - A player with no legal move: not applicable — a Thrower with a baton always has `throw_baton()` (throwing phase) or `sprint_and_retrieve()` (retrieval phase) available; a baton-less Thrower waits legally until the retrieval window opens (R2). - Repetition / cycles: the throwing phase (R2) could in principle continue for a while as multiple Throwers each take their single throw, but this is bounded — each Thrower has exactly one baton and one throw before the topple/retrieval cycle must occur, so the phase cannot recur indefinitely without either a topple (R3) or all Throwers exhausting their single attempt. - Simultaneous claims on one position: not applicable — each Thrower retrieves only their own baton (R4); there is no contest over a shared object. - Elimination mid-round and turn-order repair: not applicable — no player is ever removed from the game; a tag (R8) relabels the Guard without eliminating anyone. - Resource exhaustion: each Thrower's single baton is the round's core constraint — once thrown, they cannot throw again until it is retrieved (R2); this is the intended mechanic, not an anomaly. - Termination guarantee: **not guaranteed at the match/session level.** The entry describes a repeating throw/topple/retrieve/tag cycle (R1-R9) with no score threshold or session-ending condition, matching the pattern of other continuous-play games in this batch. Each individual *round*, however, is bounded: the throwing phase is capped at K single-attempt throws, and the retrieval race (R4-R6) resolves with probability 1 given non-zero per-tick success probabilities for both retrieval and tagging (the standard hazard-style argument used elsewhere in this batch) — so `termination_guaranteed: false` reflects the absence of a formal match ending, not any doubt about individual rounds concluding. ## State representation - Persistent (session) state: `guard_id`, `round_number`. - Per-round state: `block_standing` (bool), `thrower_baton_status[player]` ∈ {held, in_field, retrieved, safe}. - Per-tick ephemeral state: positions of all Throwers and the Guard during the retrieval race. - Observable information: fully observable — all positions, block state, and baton status are public; no hidden information. ## Action space - `throw_baton()`: any Thrower with a baton in hand, throwing phase; precondition: `block_standing = true`, thrower has not yet thrown this round. - `sprint_and_retrieve()`: any Thrower whose baton is `in_field`; precondition: `block_standing = false` or `true` (retrieval can continue after re-erection, just now at risk of tag). - `re_erect_block()`: the Guard only; precondition: `block_standing = false`. - `tag(thrower_id)`: the Guard only; precondition: `block_standing = true`, `thrower_id` is in the field and holding their baton (R6) — not a legal action at all while `block_standing = false` (R5). ## Playability notes - Single-player-vs-AI: natural on either side — human Thrower timing a retrieval sprint against an AI Guard's re-erection speed, or human Guard racing to re-erect and then chase down AI Throwers. - Reducing K > 4 to 2 agents: mechanically trivial (fewer Throwers), though it reduces the crowded-retrieval chaos that gives the game its social texture. - Physical-skill games: real throwing accuracy, sprint speed, and tag contact are the entire game and are collapsed into stochastic checks (R2-R3, R6); no genuine athleticism is modeled. - What is lost: the actual physical drama of the toppled-block safe window, the shouted call-and-response ("Балка збіта!"/"Стаіць!") that marks the state transition, and the pastoral shepherd-pasture setting that gave the game its name and origin. ## Implementation hints State is modest (a block-standing flag, per-Thrower baton status, positions); the real design difficulty is calibrating throw-accuracy, retrieval-speed, and tag-success probabilities, none of which the source quantifies. First milestone: implement the throw/topple/retrieve/re-erect/tag loop (R2-R8) with flat probabilities to validate the invulnerability window (R5) and the Guard-retention condition (R9), then add the ranked-throwing-distance variant if desired.

Download as JSON

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

Download JSON
Cite this page

The Log (Balka / Klyok Target Throwing) (Belarus). (n.d.). Games of Countries. https://gamesofcountries.com/games/by-belarus/balka

@misc{gamesofcountries-by-belarus-balka,
  title = {The Log (Balka / Klyok Target Throwing) (Belarus)},
  year = {n.d.},
  publisher = {Games of Countries},
  url = {https://gamesofcountries.com/games/by-belarus/balka}
}