---
title: 'Arena Fighter: a fresh context''s plan (2026-10-25)'
summary: 'The answer a fresh Claude context gave to the game brief (topics/saintcon/arena-game-brief) with no tools and no knowledge of our attempts: search-centred (exact engine port, simultaneous-move matrix search at depth 1-2) with learned opponent model + leaf value, a belief tracker for step parity / attack cooldowns / fog, and a league + held-out-clone gauntlet for evaluation.'
updated: '2026-10-25'
canonical: https://unaen.org/llmwiki/topics/saintcon/arena-fresh-take-2026-10-25
markdown: https://unaen.org/llmwiki/topics/saintcon/arena-fresh-take-2026-10-25.md
---

# A fresh context's plan for Arena Fighter

A fresh context wrote this from [arena-game-brief](https://unaen.org/llmwiki/topics/saintcon/arena-game-brief.md) alone. It used no tools and knew nothing about our
bots or attempts. The text is verbatim; my notes on it are at the end.

## Intuitive plan

This is a short-horizon tactical game. Every action resolves instantly, the rules are fully deterministic and integer, and an exact simulator is available. That points to search at the core, with learning used for three things the search can't supply: an opponent model, a leaf evaluation, and a few macro priors. Hand-written rules cover only things the search can't see far enough to find: pad timing, zone positioning and the opening script.

Pure model-free RL is the wrong main bet here. The game's value sits in exact timing windows a tick or two wide, and an exact simulator plus about 300 ms of search finds those reliably. A policy net only approximates them. Pure hand-written rules will tie the crowd of bots sitting within ~100 points of each other, but probably won't beat `house-champion`.

## Which mechanics decide matches

Before designing anything, I'd work out where damage actually comes from. Reading the rules, these mechanics should dominate:

1. **Unavoidable damage windows.** Most damage that can't be dodged comes from four places:
   - **Point-blank ranged.** At distance ≤2 the shot lands the same tick, so it can't be dodged.
   - **Repulsor.** It also lands the same tick, and a wall slam adds 10 damage and a 3-tick stun. The map edge counts as a wall, so slams are easy near edges and around the pillars on columns-21. A stunned target can't dodge a shot from within 6 tiles.
   - **Step parity.** Step cooldown is 2, so a fighter that has just stepped can't step next tick. Movement resolves before projectiles, so the useful window is narrow. At distance 3–4 the shot lands on the second tick, so the target needs a step ready then.
   - **Slow from frostburst.** A step starting inside the area costs 4 ticks instead of 2. After a slowed step, a shot from within about 6 tiles can't be stepped out of. Frostburst plus ranged on a slowed target is the main way to kill at range.
2. **Dash invulnerability against the visible dash cooldown.** Dash is the only answer to all of the above. Both sides can see each other's dash cooldown, so "their dash is down" is a public, exact signal that a combo window is open, lasting up to 12 ticks. Likewise, my dash being down is the signal for me to back off. I'd expect the strongest bots to be built around this.
3. **Hidden cooldowns.** The opponent can't see my ranged, frostburst, repulsor or step timers. Once I've seen them fire, I know the next 6 ticks are safe from their ranged and the next 12 from their repulsor. That lets me close to point-blank exactly when my shot is ready and theirs isn't, then leave. Done consistently, that is an edge in every damage trade.
4. **Pads.**
   - **Power.** Both power pads stock at tick 20 and sit about 7 tiles from each spawn. The ×1.5 buff (18 per shot) for 50 ticks is a large swing early, and 10% of matches end by tick 108.
   - **Health.** +32 HP is roughly 2.7 enemy shots. Tracking the 120-tick respawn and timing pickups for when you're damaged should matter more than most bots treat it.
5. **Zone.** It matters only for the 46% of matches that run past tick 260. It shrinks the board, which turns the game into point-blank and repulsor brawling. Being the one standing at the centre when it closes is worth a lot.

Shouts have no game effect. I'd ignore them, apart from a cheap test of whether any bots react to them.

## Architecture of the live bot

**Engine.** A native port (Rust or C++) of the simulator, verified bit-exact against the reference module and against all ~130k replays: rebuild each fogged observation and compare `danger`, events and positions. It should step at least 1M ticks/s per core with clone and undo. Everything else depends on this being exact.

**Belief tracker.** This is persistent memory, because observations carry no history. It holds:
- **Opponent step parity:** the last tick a position change was seen, and whether a move conflict happened.
- **Opponent attack cooldowns:** a distribution per weapon, counted from the last `attack` event. If I never saw them fire, the prior is learned from replays ("ready" with some probability as time passes).
- **Pad timers:** taken from pickup events, or inferred from a pad that was stocked and is now empty.
- **Opponent position when out of sight:** a particle set of a few hundred. It is moved forward by the opponent model and pruned by negative evidence: tiles I can see and they're not on. With first sight at a median of tick 5, this matters mostly on pillars-21 and columns-21.
- **What the opponent can infer about me:** they see my dash cooldown and nothing else, so I can play to keep my ranged cooldown ambiguous.

**Per-tick decision: a simultaneous-move search.**
- **Candidates.** I generate up to 17 movement options (stay, 8 steps, 8 dashes). For attacks, I take a pruned set:
  - ranged lines aimed at the opponent's reachable tiles at arrival time, chosen by how many likely tiles each line covers, plus a few bounce lines;
  - frostburst centred on their likely tiles or on pads;
  - repulsor when adjacent;
  - no attack.

  That's about 60–150 joint candidates per side. I'd do the same for the opponent and prune dominated pairs.
- **Root.** I fill a payoff matrix of my candidates against theirs at depth 1–2 using the exact engine. Leaves get a value: a learned net, with a hand-written fallback such as HP difference, cooldown advantage, distance to pads and zone. For deeper lines I sample opponent replies from the opponent model (decoupled UCT or a few MCCFR iterations).
- **Choosing the action.** I don't play pure Nash and I don't play pure best response. I maximise expected value against a blend: about 70% the opponent model, 30% their best response to me. Pure maximin makes a bot passive, and passive bots lose knockouts. Pure exploitation gets punished when the model is wrong.
- **Fog.** When the opponent's state is uncertain (position particles, cooldown distribution), I search over 4–16 sampled guesses of the hidden state and average the root values across them.

**Time per tick.** The match budget averages 500 ms/tick, but most matches end by about tick 250, so the real constraint is the 1 s deadline plus network jitter. I'd plan for:
- about 150 ms when the fighters are more than 9 tiles apart or out of sight;
- 300–500 ms within 6 tiles, or when either side's dash is down;
- a hard cap of 700 ms, with an anytime result always ready;
- a budget governor that falls back to cheaper search if total time used gets past 60% before tick 300.

**Macro layer.** Pad and zone goals, plus an opening book, enter the leaf evaluation as shaping terms rather than overriding the search.

## What to learn from data versus self-play

**From the replay archive (full information, ~130k matches):**
- **Opponent model.** A small net (a CNN over 21×21 plus scalars, or a gradient-boosted tree over hand features) that predicts the next turn from the rebuilt fogged observation and recent history. It is conditioned on the opponent's name, with per-name fine-tuning heads for the top 30 or so bots and a generic population model for the rest. The opponent's name arrives in `hello`. Openings measurably don't depend on who they're facing, so per-name opening predictions should be very sharp, and I'd tailor my own opening per opponent.
- **Behaviour-cloned copies of ladder bots** to use as training and evaluation opponents.
- **Cooldown priors** for unseen opponents: how often bots fire the moment their cooldown is up, and how often they hold.
- **Statistics that decide design weights:**
  - the share of damage taken point-blank, from slams, at range, and from frostburst;
  - dodge rate by distance, parity and slow;
  - the win-rate effect of taking the first power pad, adjusted for bot strength.
- **A first value net** predicting the winner from fogged states. It's biased by the skill mix of the ladder, so I'd use it only as a warm start.

**From self-play and league play:**
- **Value net**, refined from matches the search bot plays. This is AlphaZero-style iteration, but the policy is the search itself; I don't train a separate policy head except as a candidate-ordering prior.
- **The opponent pool for training** is a league: our past versions, house bots in-process, behaviour-cloned ladder bots, and dedicated exploiters (RL or search agents trained only to beat the current version). Exploiters are how hidden weaknesses get found before the ladder finds them.

**Compute plan.** Simulation and search run on the 48-thread box. The small 8 GB GPUs train the nets, which are tiny. I'd rent 5090s only for large league rounds once the pipeline is proven.

## Fog and hidden cooldowns, concretely

- **Default assumption:** the opponent's ranged is ready unless I saw it fire within the last 6 ticks. Plan safety against that.
- **Step parity:** the opponent can step only if their last seen move was at least 2 ticks ago. The aiming model gives a target that can't step its full reachable set only when the parity says so. This is where shots get converted into hits.
- **Seen attacks open windows.** When I see a ranged attack, I have 6 ticks to be aggressive. When I see a repulsor, adjacency is safe for 12 ticks.
- **Hiding my own state:** occasionally skip a free shot at long range, so a ready shot doesn't read as a pattern. Concealing my cooldowns is worth a little expected damage.
- **Danger list and projectiles:** use the engine's `danger` list directly, and for my own projectiles in flight, track their paths myself.

## Evaluation and telling real progress from overfitting

- **Offline gauntlet.** Fixed opponents: all house bots, behaviour-cloned copies of the top 20 ladder bots, and our last 5 versions. Every pairing runs on all 3 maps × both spawn assignments with fixed seeds. I promote a version only when a sequential test (SPRT) shows a win-rate gain on the held-out half.
- **Held-out opponents.** Some of the behaviour-cloned bots are never used in training or tuning. If self-play win rate rises while held-out win rate stays flat, that's overfitting.
- **Exploiter test.** Train a fresh exploiter against each candidate version. If it gets above roughly 65%, the version is brittle, whatever its other numbers say.
- **Ladder.** This is the ground truth, but it's noisy and slow, and every new version starts with no pair history. I'd keep a stable champion live, deploy candidates as new versions, and judge them on Bradley–Terry rating after about 300 matches. I'd also check results per opponent against what the gauntlet predicted, and investigate where they diverge.
- **Diagnostics beyond win rate:** damage dealt and taken per window type, the share of combo windows actually converted, and time-budget percentiles.

## Main risks

- **Simulator mismatch.** Some rule details are ambiguous. For example, the tick order says a fighter "standing" on a stocked pad takes it, while the action rules say you must "end" your move on it. That decides whether you can sit on a pad and take it at the tick-20 restock. Every such case must be settled by testing against the reference before any search tuning.
- **Timing failures.** GC pauses, network latency or a slow observation parse can cause idle turns at exactly the wrong moment. I'd use a native core and anytime search, and keep a 300 ms safety margin.
- **Opponent model drift.** Bots change versions often. A confident model of an old version gets punished, which is why the decision blends in best-response robustness and the per-opponent heads get recency weighting.
- **Too passive or too greedy.** Paranoid search leads to kiting stalemates that the zone then punishes. Too much exploitation feeds easy point-blank damage to strong bots.
- **Leaf evaluation bias** from ladder-skill replays, before self-play has fixed it.
- **Protocol limits:** the 4 KB message cap and the rule that more than 5 messages in one tick closes the connection.

## First three experiments

1. **Engine port, replay check and damage census.** Build the native engine and verify it bit-exact on all replays. Then mine the archive for:
   - where damage comes from (point-blank, slam, slowed, ranged at range);
   - dodge rates by distance and parity;
   - first-power-pad and health-timing effects on win rate;
   - how `house-champion` actually wins.

   This sets the weights for everything that follows.
2. **Baseline search bot plus feature ablations.** A depth-1 matrix search with a hand-written evaluation and the full belief tracker, played against house bots across all maps and spawns. Then ablate parity tracking, attack-cooldown counting and dash-window logic one at a time, to measure what each is worth.
3. **Opponent model and opening study.** Train the per-name opponent model and measure its prediction quality, especially for openings. Plug it into the search against a uniform-random model and against pure Nash, and measure the win-rate difference against the behaviour-cloned copies. In parallel, solve the first ~30 ticks of the power-pad race against the top 10 opponents' predicted openings, to build a per-opponent opening book.

## Notes (ai-copec, against what we know; not shown to the fresh context)

- **Pad ruling.** The spec settles the ambiguity it raised. A pad restocks at the end of the tick before its respawn tick, and a fighter already standing on it takes it that tick without moving.
- **Step parity.** It independently put step parity first. That matches the 10-25 timer check on 824 henpecked matches:
  - the live step-cooldown estimate is wrong on 14.4% of visible ticks, almost always "can step" when the opponent can't;
  - point-blank shots hit 92.5% against a step-locked opponent whose dash is down, against 73% when it can step and about 42% when its dash is ready.
- **Copy nets.** It proposes behaviour-cloned ladder bots for the gauntlet. Ours predict moves well (0.71–0.84 nats held-out for 6 of 8) but play weakly: the house-champion copy lost to merge 107. So they're not a valid ladder proxy without search behind them.