dsh-eval-guard 0.2.3 → 0.3.1

package/eval/arena/land/workspace/engine/referee.py

@@ -0,0 +1,308 @@
+"""圈地对战本地裁判 / Local referee for the territory game.
+
+用法 Usage:
+  python engine/referee.py BOT_A BOT_B [--games N] [--seed S] [--jobs J] [--replay-dir DIR] [--stderr-dir DIR]
+  python engine/referee.py BOT_A BOT_B BOT_C BOT_D [...]      (4 个 bot = 4 人混战 / melee)
+
+bot 可以是 .cpp（按正式参数自动编译）或可执行文件，同一个文件可以重复出现。
+1 对 1：同一地图交换出生位各打一局。混战：同一地图轮换座位打 4 局，每个 bot 每个座位各坐一次。
+Bots are .cpp files (compiled with the official flags) or executables; a file may repeat.
+1v1 games come in pairs on the same map with sides swapped; melee games come in groups of 4
+on the same map with seats rotated.
+"""
+import argparse
+import json
+import os
+import queue
+import subprocess
+import sys
+import threading
+import time
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from game import Game, config_for, make_start  # noqa: E402
+import build  # noqa: E402
+
+MOVE_MS = 50          # per-turn time limit announced to bots
+INIT_MS = 2000        # time limit for turn 0 (includes process start-up)
+GRACE_MS = 15         # tolerance added by the referee, do not rely on it
+MAX_ERRORS = 10       # timeouts + malformed replies allowed per game before forfeiting
+MEM_MB = 512
+
+if sys.platform == 'win32':
+    # Windows 默认计时精度约 15.6 ms，会让响应时间测量失真；调到 1 ms
+    try:
+        import ctypes
+        ctypes.WinDLL('winmm').timeBeginPeriod(1)
+    except Exception:
+        pass
+
+
+def _limit_memory():
+    try:
+        import resource
+        b = MEM_MB * 1024 * 1024
+        resource.setrlimit(resource.RLIMIT_AS, (b, b))
+    except Exception:
+        pass
+
+
+class Bot:
+    def __init__(self, exe, stderr_path=None):
+        self.stderr_file = open(stderr_path, 'wb') if stderr_path else subprocess.DEVNULL
+        kw = {}
+        if sys.platform != 'win32':
+            kw['preexec_fn'] = _limit_memory
+        else:
+            kw['creationflags'] = getattr(subprocess, 'CREATE_NO_WINDOW', 0)
+        self.p = subprocess.Popen([exe], stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+                                  stderr=self.stderr_file, bufsize=0, **kw)
+        self.q = queue.Queue()
+        self.out = queue.Queue()
+        self.crashed = False
+        self.errors = 0
+        self.timeouts = 0
+        self.max_ms = 0.0
+        threading.Thread(target=self._reader, daemon=True).start()
+        threading.Thread(target=self._writer, daemon=True).start()
+
+    def _reader(self):
+        try:
+            for line in self.p.stdout:
+                self.q.put((time.perf_counter(), line))  # 记录到达时刻，超时按到达时刻判定
+        except Exception:
+            pass
+        self.q.put((time.perf_counter(), None))
+
+    def _writer(self):
+        # a separate thread, so a bot that stops reading stdin cannot block the referee
+        while True:
+            data = self.out.get()
+            if data is None:
+                return
+            try:
+                self.p.stdin.write(data)
+                self.p.stdin.flush()
+            except (BrokenPipeError, OSError, ValueError):
+                self.crashed = True
+                return
+
+    def send(self, text):
+        if not self.crashed:
+            self.out.put(text.encode())
+
+    def receive(self, turn, sent_at, limit_ms):
+        """Return a direction, or None on timeout / malformed reply (counted as errors)."""
+        # 两个 bot 按顺序检查，但是否超时只看回复的到达时刻，所以检查顺序不影响结果
+        deadline = sent_at + (limit_ms + GRACE_MS) / 1000.0
+        while not self.crashed:
+            remaining = deadline - time.perf_counter()
+            try:
+                if remaining > 0:
+                    arrived, line = self.q.get(timeout=remaining)
+                else:
+                    arrived, line = self.q.get_nowait()
+            except queue.Empty:
+                if remaining > 0:
+                    continue
+                self.timeouts += 1
+                self.errors += 1
+                return None
+            if line is None:
+                if arrived <= deadline:
+                    self.crashed = True
+                    return None
+                self.q.put((arrived, None))  # 进程在时限后才退出：本回合先按超时处理
+                self.timeouts += 1
+                self.errors += 1
+                return None
+            parts = line.decode(errors='replace').split()
+            if len(parts) == 2 and parts[0].lstrip('-').isdigit() and parts[1] in ('U', 'D', 'L', 'R'):
+                t = int(parts[0])
+                if t < turn:
+                    continue  # 对之前回合的迟到回复，丢弃
+                if t == turn:
+                    if arrived > deadline:
+                        self.timeouts += 1
+                        self.errors += 1
+                        return None
+                    if turn > 0:  # 第 0 回合含进程启动时间，不计入
+                        self.max_ms = max(self.max_ms, (arrived - sent_at) * 1000)
+                    return parts[1]
+            if arrived > deadline:
+                self.timeouts += 1
+            self.errors += 1
+            return None
+        return None
+
+    def close(self):
+        self.out.put(None)
+        try:
+            self.p.kill()
+        except Exception:
+            pass
+        try:
+            self.p.wait(timeout=2)
+        except Exception:
+            pass
+        if self.stderr_file is not subprocess.DEVNULL:
+            self.stderr_file.close()
+
+
+def ranks_of(areas, forfeit):
+    """名次（1 = 最好，并列同名次）。判负者的面积按 -1 计，排在所有人之后。"""
+    eff = [-1 if f else a for a, f in zip(areas, forfeit)]
+    return [1 + sum(e > x for e in eff) for x in eff]
+
+
+def run_match(exes, names, seed, cfg=None, replay_path=None, stderr_paths=None):
+    """Play one game. exes[i] plays as player i (2 bots = 1v1, 4 bots = melee). Returns a result dict."""
+    n = len(exes)
+    cfg = cfg or config_for(n)
+    spawns, dirs = make_start(seed, cfg)
+    game = Game(cfg, spawns, dirs)
+    initial_owner = ''.join('.0123456789'[o + 1] for o in game.owner)
+    bots = [Bot(e, (stderr_paths or [None] * n)[i]) for i, e in enumerate(exes)]
+    frames = []
+    forfeit = [None] * n
+    try:
+        for i, b in enumerate(bots):
+            head = 'INIT\n%d %d %d %d %d %d %d\n' % (
+                cfg['width'], cfg['height'], cfg['max_turns'], game.N, i, MOVE_MS, INIT_MS)
+            head += ''.join('SPAWN %d %d %d\n' % (j, x, y) for j, (x, y) in enumerate(spawns))
+            b.send(head)
+        while not game.over():
+            t = game.turn
+            text = game.state_text(t)
+            limit = INIT_MS if t == 0 else MOVE_MS
+            live = [i for i in range(n) if not forfeit[i]]
+            sent = {}
+            for i in live:
+                bots[i].send(text)
+                sent[i] = time.perf_counter()
+            moves = [None] * n
+            for i in live:
+                moves[i] = bots[i].receive(t, sent[i], limit)
+            newly = []
+            for i in live:
+                if bots[i].crashed:
+                    forfeit[i] = 'crash'
+                elif bots[i].errors >= MAX_ERRORS:
+                    forfeit[i] = 'errors'
+                if forfeit[i]:
+                    newly.append(i)
+            if newly and n == 2:
+                break  # 1v1：有人判负，本局立即结束
+            for i in newly:
+                game.eliminate(i)
+                bots[i].close()
+            if all(forfeit):
+                break
+            frame = game.step(moves)
+            frame['moves'] = [m or '-' for m in moves]
+            for i in newly:
+                frame['events'].insert(0, {'type': 'out', 'player': i, 'reason': forfeit[i]})
+                frame['trail_clear'].append(i)
+            frames.append({k: v for k, v in frame.items() if v})
+    finally:
+        for b in bots:
+            b.close()
+
+    areas = game.areas()
+    ranks = ranks_of(areas, forfeit)
+    best = [i for i in range(n) if ranks[i] == 1]
+    winner = best[0] if len(best) == 1 else -1
+    result = {
+        'mode': 'duel' if n == 2 else 'melee',
+        'seed': seed, 'names': names, 'winner': winner, 'ranks': ranks, 'areas': areas, 'turns': game.turn,
+        'forfeit': forfeit, 'deaths': game.deaths, 'kills': game.kills,
+        'timeouts': [b.timeouts for b in bots], 'errors': [b.errors for b in bots],
+        'max_ms': [round(b.max_ms, 1) for b in bots],
+    }
+    if replay_path:
+        replay = {'version': 2, 'config': cfg, 'names': names, 'seed': seed,
+                  'spawns': spawns, 'init_dirs': dirs, 'initial_owner': initial_owner,
+                  'frames': frames, 'result': result}
+        os.makedirs(os.path.dirname(os.path.abspath(replay_path)), exist_ok=True)
+        with open(replay_path, 'w') as f:
+            json.dump(replay, f, separators=(',', ':'))
+    return result
+
+
+def _play(job):
+    return job[0], run_match(*job[1:])
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument('bots', nargs='+', metavar='BOT', help='2 bots = 1v1; 4 bots = melee (the same file may repeat)')
+    ap.add_argument('--games', type=int, default=0,
+                    help='number of games; rounded up to a multiple of 2 (1v1) or 4 (melee). '
+                         'Default: 2 (1v1) or 4 (melee)')
+    ap.add_argument('--seed', type=int, default=1)
+    ap.add_argument('--jobs', type=int, default=1,
+                    help='games played in parallel (each game runs 2 or 4 bots at once; '
+                         'too many makes bots slow and causes timeouts)')
+    ap.add_argument('--replay-dir', help='save a replay JSON per game (open with viewer/viewer.html)')
+    ap.add_argument('--stderr-dir', help='save bot stderr per game')
+    args = ap.parse_args()
+
+    n = len(args.bots)
+    if n not in (2, 4):
+        ap.error('give 2 bots (1v1) or 4 bots (melee)')
+    exes = [build.resolve(b) for b in args.bots]
+    labels = ['%s:%s' % ('ABCD'[i], os.path.basename(b)) for i, b in enumerate(args.bots)]
+    per_map = n  # 1v1: swap sides; melee: rotate seats so every bot plays every seat
+    games = max(args.games or per_map, 1)
+    games = (games + per_map - 1) // per_map * per_map
+    jobs = []
+    for g in range(games):
+        seed = args.seed + g // per_map
+        rot = g % per_map
+        order = [(i + rot) % n for i in range(n)]  # order[seat] = bot index
+        replay = os.path.join(args.replay_dir, 'game_%d_seed%d_rot%d.json' % (g, seed, rot)) \
+            if args.replay_dir else None
+        errs = None
+        if args.stderr_dir:
+            os.makedirs(args.stderr_dir, exist_ok=True)
+            errs = [os.path.join(args.stderr_dir, 'game_%d_p%d.log' % (g, i)) for i in range(n)]
+        jobs.append((g, order, seed, [exes[o] for o in order], [labels[o] for o in order], seed,
+                     None, replay, errs))
+
+    points = [0.0] * n    # 1v1: win 1 / draw 0.5; melee: sum of ranks
+    area_sum = [0] * n
+
+    def report(g, order, seed, r):
+        for seat, b in enumerate(order):
+            area_sum[b] += r['areas'][seat]
+            if n == 2:
+                points[b] += 1.0 if r['winner'] == seat else 0.5 if r['winner'] == -1 else 0.0
+            else:
+                points[b] += r['ranks'][seat]
+        if n == 2:
+            outcome = 'draw' if r['winner'] == -1 else labels[order[r['winner']]] + ' wins'
+        else:
+            outcome = 'ranks ' + ' '.join('%s=%d' % (labels[o][0], r['ranks'][s]) for s, o in enumerate(order))
+        print('game %d seed %d  %s  areas %s  deaths %s  timeouts %s  max_ms %s  forfeit %s  -> %s' % (
+            g, seed, ' vs '.join(r['names']), r['areas'], r['deaths'], r['timeouts'],
+            r['max_ms'], r['forfeit'], outcome), flush=True)
+
+    if args.jobs <= 1:
+        for j in jobs:
+            report(j[0], j[1], j[2], run_match(*j[3:]))
+    else:
+        from concurrent.futures import ProcessPoolExecutor
+        meta = {j[0]: j[1:3] for j in jobs}
+        with ProcessPoolExecutor(args.jobs) as pool:
+            for g, r in pool.map(_play, [(j[0],) + j[3:] for j in jobs]):
+                report(g, meta[g][0], meta[g][1], r)
+    if n == 2:
+        print('TOTAL  ' + '  :  '.join('%s %.1f' % (labels[i], points[i]) for i in range(n)))
+    else:
+        print('TOTAL average rank (1 = best)  ' + '  '.join(
+            '%s %.2f' % (labels[i], points[i] / games) for i in range(n)))
+    print('average area  ' + '  '.join('%s %.0f' % (labels[i], area_sum[i] / games) for i in range(n)))
+
+
+if __name__ == '__main__':
+    main()

package/eval/arena/land/workspace/starter/bot.cpp

@@ -0,0 +1,82 @@
+// Starter bot: reads the full protocol (any number of players: N = 2 for 1v1, N = 4 for melee)
+// and plays a trivial but legal strategy
+// (keep going straight, turn when the next cell is a wall or its own trail).
+// Copy it to submission/bot.cpp and replace decide() with your own strategy.
+#include <bits/stdc++.h>
+using namespace std;
+
+const int DX[4] = {0, 0, -1, 1};
+const int DY[4] = {-1, 1, 0, 0};
+const char DC[4] = {'U', 'D', 'L', 'R'};
+
+int dirIndex(char c) { return string("UDLR").find(c); }
+
+struct Player {
+    int x, y, dir, trailLen, area, deaths;
+};
+
+struct State {
+    int turn;
+    vector<Player> p;
+    vector<string> owner;  // owner[y][x]: '.' neutral, '0'..'3' territory of that player
+    vector<string> trail;  // trail[y][x]:  '.' none,    '0'..'3' trail of that player
+};
+
+int W, H, MAX_TURNS, N, ME, MOVE_MS, INIT_MS;
+vector<pair<int, int>> spawn;
+
+bool readState(State& s) {
+    string tok;
+    if (!(cin >> tok)) return false;  // "TURN"
+    cin >> s.turn;
+    s.p.assign(N, {});
+    for (int i = 0; i < N; i++) {
+        int id;
+        char d;
+        Player q;
+        cin >> tok >> id >> q.x >> q.y >> d >> q.trailLen >> q.area >> q.deaths;
+        q.dir = dirIndex(d);
+        s.p[id] = q;
+    }
+    cin >> tok;  // OWNER
+    s.owner.assign(H, "");
+    for (auto& row : s.owner) cin >> row;
+    cin >> tok;  // TRAIL
+    s.trail.assign(H, "");
+    for (auto& row : s.trail) cin >> row;
+    cin >> tok;  // END
+    return true;
+}
+
+int decide(const State& s) {
+    const Player& me = s.p[ME];
+    char myTrail = '0' + ME;
+    auto ok = [&](int d) {
+        if (d == (me.dir ^ 1)) return false;  // reversing is not allowed
+        int nx = me.x + DX[d], ny = me.y + DY[d];
+        return nx >= 0 && nx < W && ny >= 0 && ny < H && s.trail[ny][nx] != myTrail;
+    };
+    if (ok(me.dir)) return me.dir;
+    for (int d = 0; d < 4; d++)
+        if (ok(d)) return d;
+    return me.dir;
+}
+
+int main() {
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+    string tok;
+    cin >> tok;  // INIT
+    cin >> W >> H >> MAX_TURNS >> N >> ME >> MOVE_MS >> INIT_MS;
+    spawn.resize(N);
+    for (int i = 0; i < N; i++) {
+        int id, x, y;
+        cin >> tok >> id >> x >> y;
+        spawn[id] = {x, y};
+    }
+    State s;
+    while (readState(s)) {
+        int d = decide(s);
+        cout << s.turn << ' ' << DC[d] << endl;  // endl flushes: required every turn
+    }
+}

package/eval/arena/land/workspace/viewer/viewer.html

@@ -0,0 +1,210 @@
+<!doctype html>
+<html lang="zh-CN">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>圈地回放</title>
+<style>
+:root {
+  --bg: #f6f5f2; --panel: #ffffff; --ink: #1d1d1f; --muted: #6b6b70; --line: #e3e1dc;
+  --cell: #ecebe7; --p0: #2f6fdf; --p0-land: #bcd0f5; --p0-trail: #6f9ae8;
+  --p1: #d9621b; --p1-land: #f5cfb4; --p1-trail: #e8955f; --accent: #1d1d1f;
+  --p2: #2e9a4f; --p2-land: #bfe3c8; --p2-trail: #6cc184;
+  --p3: #8a4fd1; --p3-land: #dccaf3; --p3-trail: #ab84e2;
+}
+@media (prefers-color-scheme: dark) {
+  :root:not([data-theme="light"]) {
+    --bg: #151517; --panel: #1f1f22; --ink: #ececec; --muted: #9a9aa0; --line: #313136;
+    --cell: #26262a; --p0-land: #26406f; --p0-trail: #4b78c9; --p1-land: #6a3a1c; --p1-trail: #c07542;
+    --p2-land: #1f5a33; --p2-trail: #3f9a5c; --p3-land: #4a2f73; --p3-trail: #8663c2;
+    --accent: #ececec;
+  }
+}
+* { box-sizing: border-box; }
+body { margin: 0; background: var(--bg); color: var(--ink);
+  font: 14px/1.5 system-ui, -apple-system, "Segoe UI", "PingFang SC", "Microsoft YaHei", sans-serif; }
+main { max-width: 1100px; margin: 0 auto; padding: 20px 16px 40px; }
+h1 { font-size: 18px; margin: 0 0 4px; }
+.sub { color: var(--muted); margin: 0 0 16px; }
+.layout { display: grid; grid-template-columns: minmax(0, 1fr) 300px; gap: 16px; align-items: start; }
+@media (max-width: 820px) { .layout { grid-template-columns: 1fr; } }
+.card { background: var(--panel); border: 1px solid var(--line); border-radius: 10px; padding: 14px; }
+canvas { width: 100%; height: auto; display: block; border-radius: 6px; image-rendering: pixelated; }
+#drop { border: 1.5px dashed var(--line); border-radius: 10px; padding: 36px 16px; text-align: center; color: var(--muted); }
+#drop.hot { border-color: var(--accent); color: var(--ink); }
+.controls { display: flex; flex-wrap: wrap; gap: 8px; align-items: center; margin-top: 12px; }
+button, select { font: inherit; color: var(--ink); background: var(--bg); border: 1px solid var(--line);
+  border-radius: 6px; padding: 5px 10px; cursor: pointer; }
+button:hover { border-color: var(--muted); }
+input[type=range] { flex: 1; min-width: 160px; accent-color: var(--accent); }
+.turn { font-variant-numeric: tabular-nums; min-width: 88px; }
+.player { display: grid; grid-template-columns: 14px 1fr auto; gap: 4px 8px; align-items: center; margin-bottom: 12px; }
+.sw { width: 14px; height: 14px; border-radius: 3px; }
+.name { font-weight: 600; overflow-wrap: anywhere; }
+.big { font-size: 20px; font-weight: 650; font-variant-numeric: tabular-nums; }
+.kv { grid-column: 2 / 4; color: var(--muted); font-size: 12px; font-variant-numeric: tabular-nums; }
+.bar { height: 8px; border-radius: 4px; overflow: hidden; display: flex; background: var(--cell); margin: 4px 0 14px; }
+#log { max-height: 260px; overflow: auto; font-size: 12px; color: var(--muted); font-variant-numeric: tabular-nums; }
+#log div { padding: 2px 0; border-bottom: 1px solid var(--line); }
+#result { font-weight: 600; margin-bottom: 10px; }
+label.inline { color: var(--muted); display: flex; gap: 6px; align-items: center; }
+</style>
+</head>
+<body>
+<main>
+  <h1>圈地回放</h1>
+  <p class="sub">把 referee.py 或 tournament.py 生成的回放 JSON 拖到下方，或点击选择（可多选）。空格键播放/暂停，← → 逐回合。</p>
+  <div id="drop">拖入回放文件，或 <button id="pick">选择文件</button><input id="file" type="file" accept=".json" multiple hidden></div>
+  <div class="layout" id="ui" hidden>
+    <div class="card">
+      <canvas id="cv"></canvas>
+      <div class="controls">
+        <button id="play">播放</button>
+        <button id="prev">◀</button><button id="next">▶</button>
+        <span class="turn" id="turn"></span>
+        <input type="range" id="scrub" min="0" value="0">
+      </div>
+      <div class="controls">
+        <label class="inline">速度 <select id="speed">
+          <option value="5">5 回合/秒</option><option value="15">15 回合/秒</option>
+          <option value="30" selected>30 回合/秒</option><option value="60">60 回合/秒</option><option value="200">200 回合/秒</option>
+        </select></label>
+        <label class="inline">回放 <select id="which"></select></label>
+      </div>
+    </div>
+    <div class="card">
+      <div id="result"></div>
+      <div id="players"></div>
+      <div class="bar" id="bar"></div>
+      <div style="font-weight:600;margin-bottom:4px">事件</div>
+      <div id="log"></div>
+    </div>
+  </div>
+</main>
+<script>
+const $ = id => document.getElementById(id);
+const css = n => getComputedStyle(document.documentElement).getPropertyValue(n).trim();
+const DEATH = { wall: '撞墙', head: '撞头', self: '撞到自己的轨迹', cut: '轨迹被切断' };
+let replays = [], R = null, states = [], cur = 0, timer = null;
+
+function load(files) {
+  const list = [...files].filter(f => f.name.endsWith('.json'));
+  Promise.all(list.map(f => f.text().then(t => { const j = JSON.parse(t); j._file = f.name; return j; })))
+    .then(rs => {
+      replays = rs.filter(r => r.frames);
+      if (!replays.length) return alert('没有找到回放数据');
+      $('which').innerHTML = replays.map((r, i) => `<option value="${i}">${r._file}</option>`).join('');
+      $('drop').hidden = true; $('ui').hidden = false;
+      open(0);
+    }).catch(e => alert('读取失败：' + e));
+}
+
+// Rebuild every turn's state once; 600 turns x 1600 cells is small.
+function open(i) {
+  stop();
+  R = replays[i];
+  const W = R.config.width, H = R.config.height, n = R.names.length;
+  let owner = Int8Array.from(R.initial_owner, c => c === '.' ? -1 : +c);
+  let trails = Array.from({ length: n }, () => []);
+  let pos = R.spawns.map((s, j) => [s[0], s[1], R.init_dirs[j]]);
+  const snap = (events, t) => ({ owner: owner.slice(), trails: trails.map(t => t.slice()), pos, events, t });
+  states = [snap([], 0)];
+  const deaths = new Array(n).fill(0);
+  R.frames.forEach((f, t) => {
+    for (const j of f.trail_clear || []) trails[j] = [];
+    for (const [j, k] of f.trail_add || []) trails[j].push(k);
+    for (const [k, j] of f.owner || []) owner[k] = j;
+    pos = f.pos;
+    for (const e of f.events || []) if (e.type === 'death') deaths[e.player]++;
+    const s = snap(f.events || [], t + 1); s.deaths = deaths.slice(); states.push(s);
+  });
+  states[0].deaths = new Array(n).fill(0);
+  const cv = $('cv'), cs = Math.max(8, Math.floor(720 / Math.max(W, H)));
+  cv.width = W * cs; cv.height = H * cs; cv.dataset.cs = cs;
+  $('scrub').max = states.length - 1;
+  const res = R.result, names = R.names;
+  if (n > 2) {
+    const order = names.map((nm, j) => j).sort((a, b) => res.ranks[a] - res.ranks[b]);
+    $('result').textContent = '混战名次：' + order.map(j => `${res.ranks[j]}. ${names[j]}${res.forfeit[j] ? '（判负）' : ''}`).join('　') + ` · 种子 ${R.seed}`;
+  } else {
+    $('result').textContent = res.winner === -1 ? `平局 · 种子 ${R.seed}` :
+      `胜者：${names[res.winner]}${res.forfeit.some(Boolean) ? '（对手判负：' + res.forfeit.filter(Boolean).join('/') + '）' : ''} · 种子 ${R.seed}`;
+  }
+  const log = [];
+  states.forEach(s => s.events.forEach(e => {
+    const who = names[e.player];
+    log.push(e.type === 'death'
+      ? `<div>T${s.t - 1} ${who} 阵亡（${DEATH[e.reason]}${e.reason === 'cut' || e.reason === 'head' ? '，' + names[e.by] : ''}）</div>`
+      : e.type === 'out' ? `<div>T${s.t - 1} ${who} 判负出局（${e.reason === 'crash' ? '程序崩溃' : '错误过多'}）</div>`
+      : `<div>T${s.t - 1} ${who} 圈地 +${e.cells}</div>`);
+  }));
+  $('log').innerHTML = log.join('') || '<div>无事件</div>';
+  show(0);
+}
+
+function show(t) {
+  cur = Math.max(0, Math.min(states.length - 1, t));
+  const s = states[cur], W = R.config.width, H = R.config.height;
+  const cv = $('cv'), ctx = cv.getContext('2d'), cs = +cv.dataset.cs;
+  const P = [0, 1, 2, 3], land = P.map(j => css(`--p${j}-land`)), trail = P.map(j => css(`--p${j}-trail`)),
+        head = P.map(j => css(`--p${j}`));
+  ctx.fillStyle = css('--bg'); ctx.fillRect(0, 0, cv.width, cv.height);
+  for (let k = 0; k < W * H; k++) {
+    const o = s.owner[k];
+    ctx.fillStyle = o < 0 ? css('--cell') : land[o];
+    ctx.fillRect((k % W) * cs, Math.floor(k / W) * cs, cs - 1, cs - 1);
+  }
+  const pr = R.config.protect_radius;
+  R.spawns.forEach(([sx, sy], j) => {
+    ctx.strokeStyle = head[j]; ctx.lineWidth = 1.5;
+    ctx.strokeRect((sx - pr) * cs + 1, (sy - pr) * cs + 1, (2 * pr + 1) * cs - 3, (2 * pr + 1) * cs - 3);
+  });
+  s.trails.forEach((tr, j) => {
+    ctx.fillStyle = trail[j];
+    for (const k of tr) ctx.fillRect((k % W) * cs + 1, Math.floor(k / W) * cs + 1, cs - 3, cs - 3);
+  });
+  s.pos.forEach(([x, y], j) => {
+    ctx.fillStyle = head[j];
+    ctx.fillRect(x * cs - 1, y * cs - 1, cs + 1, cs + 1);
+    ctx.strokeStyle = css('--panel'); ctx.lineWidth = 2;
+    ctx.strokeRect(x * cs, y * cs, cs - 1, cs - 1);
+  });
+  const areas = R.names.map((_, j) => s.owner.reduce((a, o) => a + (o === j), 0));
+  $('players').innerHTML = R.names.map((nm, j) => `<div class="player">
+      <span class="sw" style="background:${head[j]}"></span><span class="name">${nm}</span><span class="big">${areas[j]}</span>
+      <span class="kv">轨迹 ${s.trails[j].length} · 阵亡 ${s.deaths[j]} · 占比 ${(100 * areas[j] / (W * H)).toFixed(1)}%</span></div>`).join('');
+  $('bar').innerHTML = areas.map((a, j) => `<span style="width:${100 * a / (W * H)}%;background:${head[j]}"></span>`).join('');
+  $('turn').textContent = `回合 ${cur} / ${states.length - 1}`;
+  $('scrub').value = cur;
+}
+
+function stop() { clearInterval(timer); timer = null; $('play').textContent = '播放'; }
+function toggle() {
+  if (timer) return stop();
+  if (cur >= states.length - 1) show(0);
+  $('play').textContent = '暂停';
+  timer = setInterval(() => { if (cur >= states.length - 1) stop(); else show(cur + 1); }, 1000 / +$('speed').value);
+}
+
+$('pick').onclick = () => $('file').click();
+$('file').onchange = e => load(e.target.files);
+const drop = $('drop');
+['dragenter', 'dragover'].forEach(ev => document.addEventListener(ev, e => { e.preventDefault(); drop.classList.add('hot'); }));
+document.addEventListener('dragleave', () => drop.classList.remove('hot'));
+document.addEventListener('drop', e => { e.preventDefault(); drop.classList.remove('hot'); load(e.dataTransfer.files); });
+$('play').onclick = toggle;
+$('prev').onclick = () => { stop(); show(cur - 1); };
+$('next').onclick = () => { stop(); show(cur + 1); };
+$('scrub').oninput = e => { stop(); show(+e.target.value); };
+$('speed').onchange = () => { if (timer) { stop(); toggle(); } };
+$('which').onchange = e => open(+e.target.value);
+document.addEventListener('keydown', e => {
+  if (!R) return;
+  if (e.key === ' ') { e.preventDefault(); toggle(); }
+  if (e.key === 'ArrowLeft') { stop(); show(cur - 1); }
+  if (e.key === 'ArrowRight') { stop(); show(cur + 1); }
+});
+matchMedia('(prefers-color-scheme: dark)').addEventListener('change', () => R && show(cur));
+</script>
+</body>
+</html>

package/eval/arena/tank/bots/README.md

@@ -0,0 +1,24 @@
+# 各模型的封存代码
+
+都是模型在比赛中写出的原样代码，主办方没有改动。`half1/` 是上半场版本（打中场赛、进步赛里的固定对手池），`half2/` 是下半场版本（打终场赛，决定最终名次）。基准在 `../workspace/baseline.cpp`，出题方参照在 `../tournament/sparring.cpp`。
+
+文件里的 sha256 和 `../results/*/清单.json` 记录的一致。名次和实力值是终场赛的。
+
+| 文件名 | 模型 | 短名 | 终场名次 | 实力值 | 上半场行数 | 下半场行数 | 下半场改了没有 |
+|---|---|---|---:|---:|---:|---:|---|
+| `gpt-6-astra.cpp` | GPT-6 Astra | Astra | 1 | 507 | 233 | 241 | 改了 |
+| `gpt-6.1-sol-ultrafast.cpp` | GPT-6.1 Sol（Ultrafast） | SolUF | 2 | 467 | 350 | 356 | 改了 |
+| `gemini-4-argon.cpp` | Gemini 4 Argon Contributor | Gemini | 3 | 355 | 1132 | 1390 | 改了 |
+| `gpt-6.1-sol.cpp` | GPT-6.1 Sol | Sol | 4 | 319 | 78 | 87 | 改了 |
+| `opus-5.5.cpp` | Claude Opus 5.5 | Opus | 5 | 259 | 435 | 476 | 改了 |
+| `muse-wonder-full.cpp` | Muse Wonder Full | Muse | 6 | 55 | 560 | 560 | 没改（和上半场逐字节相同） |
+| `mimo-v2.6-pro.cpp` | 小米 MiMo V2.6 Pro | MiMo | 7 | 29 | 336 | 336 | 没改（和上半场逐字节相同） |
+| `grok-4.7.cpp` | Grok 4.7 | Grok | 8 | 26 | 1099 | 1205 | 改了 |
+| `deepseek-v4.1-flash.cpp` | DeepSeek V4.1 Flash | DeepSeek | 9 | −6 | 367 | 425 | 改了 |
+| `doubao-seed-evolving.cpp` | Doubao-Seed-Evolving | Doubao | 10 | −31 | 402 | 308 | 改了 |
+| `kimi-k3.cpp` | Kimi K3 | Kimi | 11 | −129 | 353 | 487 | 改了 |
+| `haiku-5.5.cpp` | Claude Haiku 5.5 | Haiku | 12 | −149 | 210 | 210 | 没改（和上半场逐字节相同） |
+| `qwen-3.8-max.cpp` | 通义千问 Qwen 3.8 Max | Qwen | 13 | −205 | 537 | 392 | 改了 |
+| `glm-5.3.cpp` | 智谱 GLM 5.3 | GLM | 14 | −315 | 551 | 651 | 改了 |
+
+短名是成绩表、回放和配置里用的名字。用 `../workspace/arena.py` 可以直接拿它们当对手，例如在 `workspace/` 里运行 `python arena.py batch submission/bot.cpp ../bots/half2/gpt-6-astra.cpp --games 20`。