Formal Specification
Armenian bat-and-ball field game — Formal Specification
Armenia · ball-team · Confidence: high
← Back to game pageImplementation Suitability
Suitability: adaptation-requiredFidelity: discretizedGap-fills: 2
# Gndaxagh — AI-optimized specification
## General idea
A Lapta/Oina-family bat-and-ball running game whose distinguishing mechanic is the counter-strike: when a fielder "burns" a running batter, the fielding side must immediately drop the ball and flee to safety, and the just-burned batting team gets one retaliatory throw — if it connects, the batting team keeps its turn instead of swapping roles. This nested reversal, not the bat-and-ball mechanic itself, is what makes the game structurally distinct from a plain baseline-running tag game.
## Formal model
- **Abstraction taken:** Continuous striking, sprinting, catching, and throwing are each abstracted into discrete stochastic success checks (legal strike, clean catch, accurate tag-throw, successful counter-throw), since the entry describes them as skill actions without numeric models.
- **Player/agent count:** 2 teams of 4-8 players; one team bats while the other fields, roles determined by R8's swap conditions.
- **Turn model:** Sequential at the batter level (one active batter per at-bat) with simultaneous fielder positioning; base-running and tagging resolve as discrete events between at-bats.
## Formal rules
R1. Setup: the batting team's lineup order is fixed; the fielding team disperses across the field (entry §1.1-1.2).
R2. Batting attempt: the active batter self-tosses and swings, up to 3 `toss_and_strike()` attempts (entry §2.2), each independently resolving a stochastic legal-forward-strike check. A successful attempt ends the toss sequence and the batter becomes a runner (R4). If all 3 attempts fail, the batter is out and `batters_eliminated` increments [gap-fill: the entry caps attempts at 3 but does not state the consequence of exhausting them; a strikeout-style out is the minimal reading, by analogy with the entry's other named out types].
R3. Catch-out (entry §2.3): immediately after a legal strike, resolve a stochastic catch check for the fielder(s) in range. Success: the batter is out on the fly, `batters_eliminated` increments, no run attempt occurs.
R4. Base run (entry §3.1-3.2): on a strike that is not caught, the batter drops the bat and becomes a `runner`, sprinting toward the far safety line (`kone`). A runner who reaches `kone` sets `at_kone = true` and may hold there through subsequent teammates' at-bats rather than immediately returning.
R5. Return run and scoring (entry §3.3): a runner at `kone` may attempt `sprint_home()` at any point after a teammate's subsequent legal strike opens the field; completing the crossing back to Home Base scores +1 run for the batting team and removes that runner from active-runner state (successfully done, not eliminated).
R6. Tagging (entry §4.1-4.2): while any runner is between Home and `kone`, a fielder holding the ball may submit `throw_at_runner(runner_id)`; resolve a stochastic hit check. Success: that runner is "burned."
R7. Counter-strike (entry §4.3): the instant a runner is burned (R6 success), all fielders immediately enter `retreating = true` and must move toward a safety line; simultaneously the batting team retrieves the ball and may submit one `counter_throw(fielder_id)` at a retreating fielder, resolving a stochastic hit check. If the counter-throw hits, the batting team's turn continues uninterrupted (the burned runner is still out, `batters_eliminated` increments, but no role swap occurs). If the counter-throw misses or is not attempted, the burn instead triggers an immediate role swap (R8) — this is the "clean role swap" the entry names in §5.
R8. Turn/inning end (entry §5): the batting team's turn ends, and teams swap roles, the instant either (a) `batters_eliminated` equals the full lineup size (every batter has been put out via R2 or R3, or via an unconverted burn under R7), or (b) an unconverted burn occurs under R7. A converted burn (successful counter-throw) does not end the turn.
R9. Match structure: 4 total innings are played, with the batting/fielding roles alternating so each team bats twice [gap-fill: the entry states "4 innings" and a running-total win condition but does not specify whether this means 4 total turns split 2-2 or 4 turns per team; the 2-2 split is the standard convention in this game family and is the minimal-invention reading]. The team with the higher total runs after all 4 innings wins; the entry gives no tiebreak for equal totals.
## Edge cases
- Tie at the end: not addressed by the entry for equal run totals after 4 innings — a genuine silence, not an oversight.
- A player with no legal move: not applicable — the active batter always has `toss_and_strike()` (while attempts remain) available; runners always have `sprint_home()` (from `kone`) or hold available; fielders always have `throw_at_runner()` when a runner is in range.
- Repetition / cycles: not applicable — `batters_eliminated` is monotonically non-decreasing and bounded by lineup size, so a batting turn cannot recur indefinitely; the counter-strike (R7) always resolves to exactly one of two terminal branches (continue or swap) and cannot itself repeat.
- Simultaneous claims on one position: not applicable — multiple runners may simultaneously hold at `kone` (entry §3.2 explicitly allows this), and there is no exclusive-tile contest elsewhere in the rules.
- Elimination mid-round and turn-order repair: an eliminated batter is simply removed from the current turn's active rotation; the lineup order for the team's *next* turn at bat is unaffected. A burned-and-unconverted runner is likewise removed without disturbing other runners' state.
- Resource exhaustion: not applicable — no consumable resource beyond the bounded 3-attempt toss sequence per batter (R2), which is already covered by the elimination path.
- Termination guarantee: `batters_eliminated` is bounded above by the fixed lineup size and strictly increases on every unconverted out (R2, R3, R7-miss branch), so each batting turn ends in a bounded number of at-bats. The match is a fixed sequence of exactly 4 such turns (R9), so the match terminates.
## State representation
- Persistent (match) state: `score[team]`, `inning_number` (1-4), `batting_team`.
- Per-turn state: `batters_eliminated`, `lineup_position`, `runners`: set of {runner_id, at_kone: bool}.
- Per-at-bat ephemeral state: `toss_attempts_used` (0-3).
- Per-burn ephemeral state: `retreating_fielders`, pending `counter_throw` resolution.
- Observable information: fully observable — all players see all runner positions, scores, and elimination counts; no hidden information.
## Action space
- `toss_and_strike()`: active batter only; precondition: `toss_attempts_used < 3`.
- `sprint_home()`: any runner with `at_kone = true`; precondition: batting turn active.
- `throw_at_runner(runner_id)`: any fielder holding the ball; precondition: `runner_id` is between Home and `kone`.
- `counter_throw(fielder_id)`: the batting team, immediately after a burn; precondition: `fielder_id` is `retreating`; available exactly once per burn event (R7).
## Playability notes
- Single-player-vs-AI: workable as human-batter-vs-AI-fielders, alternating each inning; the counter-strike mechanic (R7) gives a natural single-decision moment for a human to make after being burned.
- Reducing team size to 2 agents per side: mechanically consistent — lineup size just shrinks, all rules apply unchanged.
- Physical-skill games: striking, catching, throwing accuracy, and sprint speed are the entire game and are collapsed into stochastic checks (R2, R3, R6, R7); no genuine athletic skill is modeled.
- What is lost: the real batting timing of a self-tossed strike, genuine sprint racing between bases, the social drama of the counter-strike's sudden role reversal as a live physical scramble, and the pastoral summer-meadow setting.
## Implementation hints
State is modest (lineup position, runner set, elimination counter, per-team score); the design difficulty is calibrating the four stochastic checks (strike, catch, tag-throw, counter-throw), none of which the source quantifies numerically. First milestone: implement one full batting turn (R2-R8) with flat probabilities to verify the elimination-count and counter-strike swap logic, then wire up the fixed 4-inning match structure (R9).
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Armenian bat-and-ball field game (Armenia). (n.d.). Games of Countries. https://gamesofcountries.com/games/am-armenia/gndaxagh
@misc{gamesofcountries-am-armenia-gndaxagh,
title = {Armenian bat-and-ball field game (Armenia)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/am-armenia/gndaxagh}
}