Formal Specification
King, Give Us a Soldier! (Láncszakítás) — Formal Specification
Hungary · strength-endurance · Confidence: low
← Back to game pageImplementation Suitability
Suitability: adaptation-requiredFidelity: probabilistic-proxyGap-fills: 2
# Adj, király, katonát! — AI-optimized specification
## General idea
A dynamic roster-transfer team contest where two opposing human chains alternate launching a single sprinting agent to breach a chosen joint in the opposing defensive chain. Breaking the link captures an opponent; failure transfers the runner into the defending chain. Strategic depth centers on identifying structural weakness in the opponent's topology while optimizing one's own defensive chain arrangement.
## Formal model
- **Abstraction taken:** Physical mass, sprint acceleration, and grip tension are discretized into a dynamic force matchup resolver: Runner Impact Momentum `M = mass_runner * velocity_runner` vs. Combined Joint Resistance `R = (strength_L + strength_R) * grip_coeff`. Breach probability `P(break) = sigmoid((M - R) / scale_factor)`.
- **Player/agent count:** 2 teams (Team A, Team B), starting with `N` agents each (standard `N = 6`). Total agent count `2N` is conserved.
- **Turn model:** Strictly sequential alternating attack turns.
## Formal rules
R1. State Setup: Total agents `2N`. Initial rosters `Team_A = [A_1..A_N]`, `Team_B = [B_1..B_N]`. Each agent has static attributes `(mass, speed, grip_strength)`.
R2. Pre-Turn Defense Arrangement: Defending team arranges its current roster into an ordered sequence `[D_1, D_2, ..., D_K]`, defining `K-1` internal links between adjacent agents `(D_i, D_{i+1})`.
R3. Attack Selection: Attacking team selects a runner `A_runner` from its roster and targets a specific defending link index `j in [1..K-1]` between `(D_j, D_{j+1})`.
R4. Impact Resolution:
- Compute `Momentum = A_runner.mass * A_runner.speed`.
- Compute `Resistance = (D_j.grip_strength + D_{j+1}.grip_strength) * 1.5`.
- Sample breach outcome `is_broken ~ Bernoulli(sigmoid(Momentum - Resistance))`.
R5. Transfer Outcomes:
- If `is_broken == true`: Attacking team selects either `D_j` or `D_{j+1}` [gap-fill: or the agent with lower strength]. Selected defending agent is removed from Defending team and appended to Attacking team.
- If `is_broken == false`: Runner `A_runner` is removed from Attacking team and appended to Defending team.
R6. Turn Swap: Attacking and defending roles alternate for the next round.
R7. Win Condition: When one team's roster size reaches `2N - 1` (or opposing team size `<= 1`), the dominant team wins immediately.
R8. [gap-fill] Turn Cap: If game reaches 30 rounds without a team elimination, the team with the larger roster size wins; if equal, match is a draw.
## Edge cases
- Tie at the end condition: Resolved by R8 roster size comparison at turn cap.
- A player with no legal move: Not applicable — attacking team always has at least 2 runners (until final loss condition), defending team always has at least 1 link.
- Repetition / cycles: Bounded by R8 turn cap (max 30 rounds).
- Simultaneous claims on the same resource or position: Actions are strictly alternating; zero concurrent conflict.
- Player elimination mid-round: Dynamic roster transfer changes team sizes after every turn; ordering repair in R2 updates chain indices automatically.
- Resource exhaustion (pieces, tokens, space, time): Total agents strictly conserved (`size(Team_A) + size(Team_B) == 2N`).
- Termination guarantee: Guaranteed by the absorbing states at `size = 2N - 1` and enforced by R8 round limit.
## State representation
- Persistent state: `roster_A (list of agent_ids)`, `roster_B (list of agent_ids)`, `active_attacking_team`, `round_counter`.
- Per-player state: `agent_id`, `mass`, `speed`, `grip_strength`, `current_team`.
- Ephemeral state: `chosen_runner_id`, `target_link_indices (j, j+1)`, `last_breach_success (bool)`.
- Observable information: Fully observable rosters, agent attribute profiles, and defensive line order.
## Action space
- Defending team: `set_chain_order(list_of_agent_ids)`.
- Attacking team: `launch_charge(runner_id, target_link_index)`.
- Capture selection (on breach): `choose_capture(agent_id_left, agent_id_right)`.
## Playability notes
- Single-player-vs-AI: Highly playable as a strategic roster-management and matchup-targeting puzzle.
- Group games (n>4): Perfectly models multi-agent team cooperation and chain configuration optimization.
- Physical-skill games: Direct collision physics abstracted to scalar momentum vs. joint resistance probability distributions.
- What is lost: The physical adrenaline of charging into locked arms and the raw biomechanical pain/strain of holding a line.
## Implementation hints
Low complexity. The state transition is an absorbing Markov chain. Suggested first milestone: implement a 6v6 agent simulation with a greedy AI (attacks the weakest defensive link) and test whether chain sorting heuristics (e.g. alternating strong and weak defenders) increase defensive stability.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
King, Give Us a Soldier! (Láncszakítás) (Hungary). (n.d.). Games of Countries. https://gamesofcountries.com/games/hu-hungary/adj-kiraly-katonat
@misc{gamesofcountries-hu-hungary-adj-kiraly-katonat,
title = {King, Give Us a Soldier! (Láncszakítás) (Hungary)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/hu-hungary/adj-kiraly-katonat}
}