Formal Specification
Walnut Target Game (Arrash) — Formal Specification
Albania · dexterity-small · Confidence: low
← Back to game pageImplementation Suitability
Suitability: engine-readyFidelity: probabilistic-proxyGap-fills: 3
# Loja me arra — AI-optimized specification
## General idea
A turn-based target-shooting and stake-collection game. A discrete line of target walnut tokens sits on a 1D/2D baseline. Agents sequentially throw a designated shooter token to dislodge walnuts beyond a boundary threshold. Struck walnuts are removed to the thrower's bank, and chain throws are granted on successful hits.
## Formal model
- **Abstraction taken:** Physical walnut rolling and collision mechanics are discretized into a 1D target array of `W` walnuts and a stochastic hit resolver parameterized by aim choice and distance.
- **Player/agent count:** `N` agents (`N = 2..6`, default `N = 3`).
- **Turn model:** Sequential turns with consecutive-throw chain bonuses upon successful strikes.
## Formal rules
R1. Setup: Each agent contributes 2 walnuts. Total target walnuts `W_total = 2 * N`, positioned at discrete slots `x ∈ {1..W_total}` along target line `y = 0`. All agents have `bank[i] = 0`.
R2. Active agent stands at baseline `y = -10` and selects a target walnut index `t ∈ {1..W_total}` currently present on the line, or an opponent shooter coordinate.
R3. Throw Resolution:
- Hit probability on target `t`: `P_hit = 0.50` [gap-fill: base shooting skill].
- If hit: Target walnut `t` is knocked out of the line and added to thrower's bank (`bank[active_agent] += 1`). Walnut `t` is removed from play.
- Chain bonus: Thrower immediately takes another throw in the same turn from the landing spot.
- If miss: Shooter walnut comes to rest at coordinate `(x_land, y_land) ~ (aim_x + Uniform(-1, 1), Uniform(-2, 2))`. Turn ends immediately; turn passes to `(active_agent + 1) % N`.
R4. Opponent Shooter Target:
- If an agent chooses to shoot at an opponent's resting shooter and hits (`P_hit_shooter = 0.35` [gap-fill]): Target opponent transfers 1 walnut from their bank to the shooter agent.
R5. Win condition: When all walnuts on the central target line are cleared (`remaining_walnuts == 0`), the game terminates. The agent with the maximum walnuts in `bank` wins the game.
R6. [gap-fill] Tie-breaking: If multiple agents have equal winning counts, a sudden-death single throw against a lone walnut decides the winner.
## Edge cases
- Tie at the end condition: Resolved by R6 sudden-death shoot-off.
- A player with no legal move: If the target line is empty, the game has already terminated under R5.
- Repetition / cycles: Bounded because the count of available target walnuts strictly decreases by 1 on every hit, guaranteeing termination in at most `W_total` successful hits.
- Simultaneous claims on the same resource or position: Turns are strictly sequential; removed walnuts are instantly unavailable to subsequent throwers.
- Player elimination mid-round; turn order repair: If an agent runs out of walnuts, they still participate until the central line is cleared.
- Resource exhaustion (pieces, tokens, space, time): The central line has a strictly finite pool of walnuts (`2 * N`).
- Termination guarantee: why the game provably ends: Guaranteed because `P_hit > 0` on every attempt, and each hit permanently consumes one target walnut until the finite pool of `2 * N` walnuts is exhausted.
## State representation
- Persistent state: `bank: array[N] of int`, `walnuts_on_line: set of int (subset of {1..W_total})`, `shooter_positions: array[N] of (float, float)`, `active_player_idx: int`.
- Per-turn ephemeral state: `hit_success: bool`, `chain_count: int`.
- Observable information: Fully observable by all agents.
## Action space
- `shoot_target_walnut(index: int)`: Aim at a specific remaining walnut on the target line.
- `shoot_opponent_shooter(target_agent_id: int)`: Aim at an opponent's shooter resting on the board.
## Playability notes
- Single-player-vs-AI: Natural; player competes against AI bots in individual free-for-all stake accumulation.
- Group games (n>4): Natively supported up to 6 players.
- Physical-skill games: Physical spin, roll velocity, and ground bump deflections are abstracted into hit probability curves.
- What is lost in the adaptation: The tactile inspection and weighting of irregular wild walnut shells.
## Implementation hints
Discrete target array with simple stochastic resolver. Branching factor is `|walnuts_on_line| + N - 1`. First milestone: Implement target line hit resolution and chain bonus loop for 2 agents.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Walnut Target Game (Arrash) (Albania). (n.d.). Games of Countries. https://gamesofcountries.com/games/al-albania/loja-me-arra
@misc{gamesofcountries-al-albania-loja-me-arra,
title = {Walnut Target Game (Arrash) (Albania)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/al-albania/loja-me-arra}
}