yotisstudios/RaifuWars-Warrior-SFT-v2

Raifu Wars — Warrior SFT v2 (built-in AI, seven maps, free-for-all)

Supervised fine-tuning data for an LLM that plays a seat in Raifu Wars, a turn-based strategy game, through the Warrior protocol. Every row is one decision by the game's built-in "classic" AI, paired with the exact board state and legal action list a human would have been shown, and targets a take_action tool call.

Supersedes RaifuWars-Warrior-Experimental-SFT, which was one map, 9,894 rows, and carried every defect listed below.

What changed since the experimental release

	experimental	v2
maps	1 (Arboretum)	7
board sizes	21×22	17×21 → 27×27
roster sizes	4 only	2 and 4
rows	9,894	77,915
matches	40	280
tier up examples	11	3,069
points marked as bases	0	all of them
team matches	—	none, by construction

Seven defects were found and fixed by collecting at scale and then checking the corpus against itself. Five of them corrupted data rather than merely the harness:

• No payload had ever identified a base. is_base was written as variable_instance_exists(pt, "isBase") ? pt.isBase : false, and the field on a point is startPoint — so the guard always failed and every point in every payload the protocol has ever sent was marked "not a base". A base is the only place tiering is possible and tiering is the only way to win, so agents were reading a board with the winning tile unmarked.

• The tier-up that ends the match was usually invisible. A raifu that moves onto its base tiers on arrival, on a code path that carried no trace call. Two other tier sites were instrumented; this was the one the code reaches most. Before the fix the winning tier-up was absent from 236 of 360 matches.

• The built-in AI could hang a match forever. A failed Sandbags placement refunds both the stars and the card, restoring the exact board that produced the decision — so the AI chose it again, indefinitely. One turn produced 10,787 decisions, 10,781 of them the same card.

• RW_MAP never worked — a shell prefix bash did not treat as an assignment, carrying a variable the game does not read. Every run silently played the default map while reporting the one it had been asked for, which is how the experimental corpus came to be 100% one board.

• match_id repeated. Every map replayed the same seed sequence, so 360 matches produced 80 distinct ids and 40 of those spanned four boards.

• The AI trial only ran on 4-player maps, so every 2- and 6-seat map aborted after one decision.

• Every six-player match was silently a 3v3. loadBasesFromMapJSON assigned the roster size without re-establishing free-for-all — which is a relationship (numTeams == numPlayers), not a number — so the team count stayed at its default of 4 whatever the map seated. The roster is then split with (i + 1) % (numPlayers / numTeams), and once those two disagree that modulus is a fraction: 6/4 = 1.5 yields teams 1,1,1,2,2,2. Four-player free-for-all worked only because the default happened to be 4.

  It matters because tier and stars are shared within a team. A seat on a 3v3 reads its team-mates' progress as its own, so its objective advances on turns it never took: 435 of 1520 seats in the unfiltered corpus finished above the last tier they personally observed. That is a state-to-action mapping whose state is partly somebody else's.

  Fixed in the game. This release drops the affected matches rather than re-collecting them, which is why it is seven maps and not nine — the two six-seat boards, Colosseum and Firing Line, were the only team matches and are gone entirely. Every remaining match is a true free-for-all.

Action distribution

target	share	rows
move	37.4%	29,136
end turn	20.9%	16,251
rush	13.0%	10,136
attack	8.6%	6,680
discard	4.9%	3,829
play card	4.5%	3,478
tier up	3.9%	3,069
tier choice (stars)	3.4%	2,645
reload / fortify	2.9%	2,258
select tile	0.3%	262
tier choice (KOs)	0.2%	171

tier up is worth its own note. Reaching tier 4 is the only win condition, and a model trained on the experimental corpus — which held eleven examples — matched the teacher's rates on rush (27.4% vs 26.9%), reload, attack and cards, then declined tier-up 137 times out of 145 offered. It played a recognisable game and would not climb the ladder that ends it. This release has 3,069, and every one of 280 matches contains its decisive tier-up.

Format

OpenAI chat format, one JSON object per line: a system turn, a user turn holding the rendered board and legal actions, and an assistant turn that is a take_action tool call.

{
  "messages": [
    {"role": "system",    "content": "<Warrior protocol system prompt>"},
    {"role": "user",      "content": "<briefing + board + legal actions + 'Take one action now.'>"},
    {"role": "assistant", "content": null,
     "tool_calls": [{"type": "function",
                     "function": {"name": "take_action",
                                  "arguments": "{\"action_id\": \"move_9_3\"}"}}]}
  ],
  "tools": [ { "type": "function", "function": { "name": "take_action", "...": "..." } } ]
}

tools carries the per-row schema, whose action_id enum is exactly the legal set for that board, so the model trains under the constraint it is served under. Some trainers expect content: "" rather than content: null on a tool-calling assistant turn.

Contents

77,915 rows — 69,678 train / 8,237 validation — from 280 matches. Split by match, never by row: decisions inside one match share a board, roster and map, so a random row split puts near-identical positions on both sides and reports memorisation as validation.

map	rows	share	seats
Cornfield	12,942	16.6%	4
Crossroads	12,633	16.2%	4
Dustbowl	12,409	15.9%	4
Arboretum	11,058	14.2%	4
Glacier	11,038	14.2%	4
Trench Warfare	10,333	13.3%	4
Twin Rivers	7,524	9.7%	2

How it was built

Traces come from the game itself (RW_WARRIOR_TRACE=1), recorded at the moment of choice, before the action is applied, so the state describes the board the decision was made on rather than the one it produced. Conversion is tools/make_dataset.py in the Warrior repo.

• The prompt is rendered by the sidecar itself — the converter imports the live policy and calls the same functions the serving path calls. A reimplementation would drift silently: train on one distribution, serve another, nothing reports it.
• Hints are stripped. Some source runs showed the model the built-in AI's intended phase. Training on that teaches reliance on a field absent at inference.
• Deduplicated by content (prompt and action).

Checks this release passes

• Every action the built-in AI took was in the legal set it was offered — 100% across the corpus, so the enumerator is complete with respect to a real policy.
• Every payload field varies. A field that is always false looks identical to a correct one; is_base hid there for the entire life of the protocol. your_notes is the sole constant, and legitimately so — the built-in AI writes no notes.
• Every match has exactly one winner, and every winner is at tier 4 (280/280). Before the tier fix this read 124/360, which is what exposed the missing trace site.
• Every match is a free-for-all — one seat per team, checked per match. Team matches share tier and stars, so a single team game puts a shared objective into per-seat data with nothing in the payload admitting it.
• The payload agrees with itself. The ascii board and the structured fields are two independent renderings of one board, and the acting seat appears both as state.self and as the is_self entry of players[]. Checked on every row: the @ is where the struct says it is, every living raifu and every point is drawn, and the two copies of self agree.
• The offers are legal and the actions did what they said — a referee re-derives the rules from the payloads and checks every offer against the state it was made in, every applied action against the state it produced, and that every turn produced a decision.

Limitations

The teacher is good, not optimal. The built-in AI beats a random-legal control 83–17 and every LLM policy measured against it, but wins only ~32% of its own seats in a four-way match. This is imitation of a decent heuristic, and top-1 agreement with it is capped accordingly.

last_action is omitted. At inference the sidecar appends a line describing how the previous action resolved, mid-turn; traces do not record it. A known train/serve mismatch, left explicit rather than filled with invented context.

Rare classes are rare. tier_kills 171 rows, select tile 284.

No rationale supervision. The schema supports a why field; the built-in AI produces none.

Reference results (4B, trained on the experimental corpus)

metric	base	fine-tuned
held-out agreement, trained map	22.8%	86.0%
held-out agreement, unseen maps	—	74.4%
illegal actions	0%	0%
avg stars (classic AI: 1683)	367–416	838
rush rate (classic AI: 26.9%)	0 / 1258	27.4%
match wins	0 / 40	2 / 40

Cross-map generalisation degraded only on the two spatial families — move 78.4%→58.3% and rush 50%→24.2% — while end turn, attack, discard, tier choice and reload all held at 100%. Categorical judgement transferred from a single map; spatial judgement did not. That, plus the base and tier defects above, is the argument for this release.

Ten base models were also screened through the same protocol (gemini-2.5-flash-lite, deepseek-v4-flash, qwen3-235b and others). None beat its own always-move baseline, and three could not reliably emit a tool call at all. A 4B fine-tuned on ~10k rows of this teacher outscored a 235B base model.

Reproducibility

The collection is seeded and deterministic, and this release demonstrated it twice. Re-running all 360 matches after adding a trace site reproduced every other action count exactly — move 32,309, end turn 16,994, rush 11,243 — and added only the previously invisible decisions.

Licence

GPL-3.0. This licenses the dataset as released by Yotis Studios. It is not a grant over Raifu Wars itself; rules prose reproduced inside these prompts is present because a training row cannot be reconstructed without it.