Formal Specification
Knuckle-Peg Toppling (Csülközés) — Formal Specification
Hungary · dexterity-throw · Confidence: high
← Back to game pageImplementation Suitability
Suitability: adaptation-requiredFidelity: probabilistic-proxyGap-fills: 2
# Csülközés — AI-optimized specification
## General idea
An asymmetric target-and-retrieval contest where multiple throwers launch projectile sticks at a central standing block, then must sprint to retrieve their landed equipment during the brief window when the block is down before the guard re-erects it and tags them. The strategic core is deciding whether to make an aggressive retrieval dash or hold back while others create a distraction.
## Formal model
- **Abstraction taken:** Physical throwing accuracy is discretized into hit probabilities `P(hit)` based on agent throw skill and target distance. Sprinting and tagging are modeled on a 1D distance continuum between Baseline (0m) and Target Circle (10m).
- **Player/agent count:** N agents (1 Guard `G`, N-1 Throwers `T_1..T_{N-1}`).
- **Turn model:** Two-phase structure: Sequential Throwing Phase → Simultaneous Real-Time Ticked Retrieval Phase (tick = 0.2s).
## Formal rules
R1. Setup: Guard `G` positioned at Target (`d = 10m`). Target state `is_standing = true`. Throwers `T_i` positioned at Baseline (`d = 0m`) with 1 stick each.
R2. Throwing Phase: Throwers in sequential order choose `throw(angle, power)`. Hit probability `P(knockdown) = skill_i * baseline_acc`.
R3. If a throw misses, the stick lands at distance `d_stick_i in [8m..12m]` and remains unretrieved. `T_i` remains at Baseline.
R4. If a throw hits: Target state becomes `is_standing = false`. The Retrieval Phase activates immediately.
R5. Retrieval Phase Actions (Simultaneous ticks):
- Throwers with unretrieved sticks choose `sprint_to_stick()`, `pick_up_stick()`, `sprint_to_base()`, or `stay_at_base()`.
- Guard `G` must execute `re-erect_target()` (requires `K` consecutive ticks, e.g., 5 ticks, at `d = 10m`).
R6. Once `is_standing = true` again, Guard `G` can execute `chase_and_tag(target_T)`.
R7. Tag Resolution: If Guard `G` reaches distance of `T_j` while `T_j` is at `d > 0m` and not in base, `T_j` is tagged.
R8. Role Reversal: Tagged thrower `T_j` becomes the new Guard `G` for the next round.
R9. [gap-fill] If all throwers complete their retrieval and return to `d = 0m` safely, round concludes and current Guard `G` incurs 1 penalty point; game ends after fixed rounds or penalty threshold.
R10. [gap-fill] Deadlock Resolution: If all throwers miss and all sticks lie in the field, each thrower must attempt a retrieval run in order of landed stick distance; if nobody moves within 30 ticks, the thrower whose stick is furthest from base is designated the new guard.
## Edge cases
- Tie at the end condition: Guard with fewest penalty points after `M` rounds wins.
- A player with no legal move: Not applicable — throwers can always choose movement actions or wait at base.
- Repetition / cycles: Bounded by R10 deadlock timer and fixed round counts.
- Simultaneous claims on the same resource or position: Multiple throwers can pick up distinct sticks simultaneously without conflict; Guard can only tag 1 agent per tick.
- Player elimination mid-round: When a thrower is tagged, the round terminates immediately per R8; roles reset for round N+1.
- Resource exhaustion (pieces, tokens, space, time): Each player has exactly 1 stick; target block has binary state (up/down).
- Termination guarantee: Enforced by finite round count `M` and bounded tick loops during retrieval.
## State representation
- Persistent state: `guard_id`, `penalty_points[agent_id]`, `round_number`.
- Per-player state: `distance_from_base`, `has_stick_in_hand`, `stick_pos_on_field`, `speed_stat`, `throw_acc_stat`.
- Per-turn ephemeral state: `target_is_standing`, `re-erect_progress_ticks`, `active_retrieval_ticks`.
- Observable information: Fully observable distances and equipment positions.
## Action space
- Throwing phase: `throw_stick(power, angle)`.
- Retrieval phase (Throwers): `sprint_forward(speed)`, `retrieve_stick()`, `sprint_backward(speed)`, `idle_at_base()`.
- Retrieval phase (Guard): `erect_target()`, `pursue_agent(agent_id)`, `tag(agent_id)`.
## Playability notes
- Single-player-vs-AI: Highly playable as human thrower or human guard against AI crowd.
- Group games (n>4): Naturally scales to 1v5 or 1v8 asymmetric multi-agent simulations.
- Physical-skill games: Physical stick flight and sprint acceleration abstracted into discrete probabilistic checks.
- What is lost: The visceral thrill of diving for a wooden stick while a shepherd lunges with a staff.
## Implementation hints
Low-to-medium complexity. Implement the state machine with explicit `THROWING` and `RETRIEVAL` modes. First milestone: build a 1 Guard vs. 3 Throwers simulation with deterministic tick-based movement speeds to tune the guard re-erect duration against thrower sprint times.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Knuckle-Peg Toppling (Csülközés) (Hungary). (n.d.). Games of Countries. https://gamesofcountries.com/games/hu-hungary/csulkozes
@misc{gamesofcountries-hu-hungary-csulkozes,
title = {Knuckle-Peg Toppling (Csülközés) (Hungary)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/hu-hungary/csulkozes}
}