dsh-eval-guard 0.2.3 → 0.3.1

package/eval/arena/bomberman/tournament/README.md

@@ -0,0 +1,11 @@
+# 复现正式赛
+
+`evaluate.py`、`bt.py` 是正式赛用的评测和评分脚本，原样保留。`run.py` 是开源版加的小工具：先用正式赛的编译参数把 C++ 选手编译好，再调用 `evaluate.py`。
+
+```bash
+python tournament/run.py --formal --output rerun/对战      # 冻结赛程，8930 局；4 并发约需数小时，可用 --workers 调整
+```
+
+`schedule-2to10.json.gz` 是正式赛的冻结赛程（地图种子、座位顺序），`--formal` 会自动解压使用。`evaluate.py` 会先核对选手包文件的哈希（`workspace/MANIFEST.json`），选手包里的文件被改动时会拒绝运行。
+
+部分 bot 按时间控制搜索深度，所以逐局结果不保证与 `results/games.json.gz` 完全一致，但总排名应当一致。

package/eval/arena/bomberman/tournament/bt.py

@@ -0,0 +1,56 @@
+"""Bradley–Terry, equal total weight per match size, explicit baseline anchor."""
+import math
+from collections import Counter,defaultdict
+
+
+def comparisons(rows,names,sizes):
+    valid=[row for row in rows if row['size'] in sizes and row['result']['valid_for_scoring']]
+    counts=Counter(row['size'] for row in valid)
+    if any(not counts[size] for size in sizes):raise ValueError('部分人数尚无有效对局')
+    pairs=defaultdict(lambda:[0.0,0.0])
+    total=len(valid)
+    for row in valid:
+        r=row['result'];n=row['size'];weight=total/(len(sizes)*counts[n]*(n*(n-1)/2))
+        for i in range(n):
+            for j in range(i+1,n):
+                a,b=r['names'][i],r['names'][j]
+                win=1.0 if r['ranks'][i]<r['ranks'][j] else 0.5 if r['ranks'][i]==r['ranks'][j] else 0.0
+                if a>b:a,b,win=b,a,1-win
+                pairs[a,b][0]+=weight;pairs[a,b][1]+=weight*win
+    if any(a not in names or b not in names for a,b in pairs):raise ValueError('未知选手')
+    return pairs,dict(counts)
+
+
+def fit(rows,names,sizes,anchor):
+    if anchor not in names:raise ValueError('基准必须作为真实参赛者包含在名单中')
+    pairs,counts=comparisons(rows,names,sizes)
+    reached={anchor}
+    while True:
+        new=reached|{b for a,b in pairs if a in reached}|{a for a,b in pairs if b in reached}
+        if new==reached:break
+        reached=new
+    if reached!=set(names):raise ValueError('尚有选手未通过交手关系连接到基准')
+    # Same finite-estimate convention as the earlier territory contest:
+    # one virtual draw per observed pair, after size weighting.
+    games={pair:(g+1,w+.5) for pair,(g,w) in pairs.items()}
+    wins={name:0.0 for name in names}
+    for (a,b),(g,w) in games.items():wins[a]+=w;wins[b]+=g-w
+    strength={name:1.0 for name in names}
+    for iteration in range(20000):
+        denom={name:0.0 for name in names}
+        for (a,b),(g,w) in games.items():
+            v=g/(strength[a]+strength[b]);denom[a]+=v;denom[b]+=v
+        updated={name:wins[name]/denom[name] for name in names}
+        center=sum(math.log(v) for v in updated.values())/len(names)
+        updated={name:math.exp(math.log(v)-center) for name,v in updated.items()}
+        delta=max(abs(math.log(updated[n]/strength[n])) for n in names)
+        strength=updated
+        if delta<1e-11:break
+    else:raise ValueError('BT 未收敛，暂不输出实力值')
+    origin=math.log(strength[anchor])
+    rating={n:400/math.log(10)*(math.log(strength[n])-origin) for n in names}
+    rating={n:0.0 if abs(v)<1e-10 else v for n,v in rating.items()}
+    rating[anchor]=0.0
+    return dict(anchor=anchor,ratings=rating,valid_games_by_size=counts,iterations=iteration+1,
+                size_weight='equal_total',scale='400 * log10(strength / baseline_strength)',
+                smoothing='one virtual draw per observed pair after weighting')

package/eval/arena/bomberman/tournament/evaluate.py

@@ -0,0 +1,199 @@
+"""Evaluate a roster with explicit 2–10-player matches, no filler bots."""
+import argparse
+import hashlib
+import itertools
+import json
+import random
+import secrets
+import sys
+import time
+from concurrent.futures import ProcessPoolExecutor
+from collections import deque
+from pathlib import Path
+from bt import fit
+
+
+def run_match(job):
+    """One isolated match; preserve the frozen referee and its time limits."""
+    number,game,workspace,output,resume,bot_hashes=job
+    sys.path.insert(0,str(Path(workspace)/'engine'))
+    from arena import play
+    from verify_replay import verify
+    stem=Path(output)/'replays'/f'{number:05d}'
+    start=time.perf_counter()
+    if resume and stem.with_suffix('.json').exists():
+        verify(stem.with_suffix('.json'))
+        result=json.loads(stem.with_suffix('.json').read_text(encoding='utf-8'))['result']
+        if result['seed']!=game['seed'] or result['names']!=[n for n,_ in game['roster']]:
+            raise ValueError('Recovered match differs')
+        if any(result['hashes'].get(f'bot_{i}')!=bot_hashes[name] for i,(name,_) in enumerate(game['roster'])):
+            raise ValueError('Recovered bot hashes differ')
+    else:
+        result=play([n+'='+p for n,p in game['roster']],game['seed'],str(stem))
+        verify(stem.with_suffix('.json'))
+    return dict(match=number,size=game['size'],result=result),time.perf_counter()-start
+
+
+def match_results(jobs,workers):
+    if workers==1:
+        for job in jobs:yield run_match(job)
+        return
+    # Keep only a small bounded queue; checkpoint in original schedule order.
+    with ProcessPoolExecutor(max_workers=workers) as pool:
+        jobs=iter(jobs);pending=deque()
+        for _ in range(workers*2):
+            job=next(jobs,None)
+            if job is None:break
+            pending.append(pool.submit(run_match,job))
+        while pending:
+            yield pending.popleft().result()
+            job=next(jobs,None)
+            if job is not None:pending.append(pool.submit(run_match,job))
+
+
+def make_schedule(entrants, sizes, seed_count, seed):
+    count=len(entrants)
+    if count<2: raise ValueError('at least two entrants required')
+    if seed_count<1: raise ValueError('seed count must be positive')
+    if not sizes or len(set(sizes))!=len(sizes) or any(n<2 or n>min(10,count) for n in sizes):
+        raise ValueError('each match size must be unique and between 2 and min(10, entrant count)')
+    rng=random.Random(seed)
+    result=[]
+    for size in sizes:
+        seeds=rng.sample(range(1,2**31),seed_count)
+        for group in itertools.combinations(entrants,size):
+            for game_seed in seeds:
+                # The same roster orders and maps apply to each entrant group.
+                forward=list(group)
+                orders=[forward] if size<=2 else [forward,list(reversed(forward))]
+                for order in orders:
+                    for shift in range(size):
+                        result.append(dict(size=size,seed=game_seed,roster=order[shift:]+order[:shift]))
+    return result
+
+
+def report(rows, entrants, sizes, anchor=None):
+    lines=['# 对战统计','','单局分＝生存分＋0.5×击杀份额；第一率按单局合计分排名。',
+           '', '|人数|选手|有效局|场均生存分|场均击杀分|场均合计分|独占第一率|含并列第一率|故障局|',
+           '|---:|---|---:|---:|---:|---:|---:|---:|---:|']
+    for size in sizes:
+        for name,_ in entrants:
+            values=[]
+            for row in rows:
+                r=row['result']
+                if row['size']!=size or not r['valid_for_scoring'] or name not in r['names']:continue
+                i=r['names'].index(name);rank=r['ranks'][i];ties=r['ranks'].count(rank)
+                values.append((r['survival_points'][i],r['kill_points'][i],r['points'][i],
+                               rank==1 and ties==1,rank==1,r['errors'][i]>0))
+            if not values:continue
+            av=[sum(v[k] for v in values)/len(values) for k in range(5)]
+            lines.append(f'|{size}|{name}|{len(values)}|{av[0]:.3f}|{av[1]:.3f}|{av[2]:.3f}|{av[3]:.1%}|{av[4]:.1%}|{sum(v[5] for v in values)}|')
+    if anchor:
+        lines+=['','## BT 实力值','','各人数总权重相等；基准为 0，固定尺度，不按最高分重缩放。','']
+        try:
+            result=fit(rows,[n for n,_ in entrants],sizes,anchor)
+            lines+=['|选手|BT 实力值|','|---|---:|']
+            for name,value in sorted(result['ratings'].items(),key=lambda x:-x[1]):
+                lines.append(f'|{name}|{value:.2f}|')
+        except ValueError as e:lines.append('暂不可汇总：'+str(e))
+    invalid=sum(not r['result']['valid_for_scoring'] for r in rows)
+    lines+=['',f'完成 {len(rows)} 局，启动失败不计分 {invalid} 局。',
+            '名次不能单独证明没有作弊；故障详情、源代码及运行记录需保留。']
+    return '\n'.join(lines)+'\n'
+
+
+def main():
+    ap=argparse.ArgumentParser()
+    ap.add_argument('--workspace',type=Path,required=True,help='clean referee workspace')
+    ap.add_argument('--bots',nargs='+',required=True,help='unique Name=program entries; order is frozen slot order')
+    ap.add_argument('--sizes',type=int,nargs='+',required=True,help='explicit match sizes, no fillers')
+    ap.add_argument('--anchor',required=True,help='name of the public baseline included in --bots')
+    ap.add_argument('--seeds',type=int,default=5,help='number of maps per size')
+    ap.add_argument('--seed',type=int,help='schedule seed; otherwise generated and recorded')
+    ap.add_argument('--output',type=Path,required=True)
+    ap.add_argument('--plan-only',action='store_true',help='save schedule without running bots')
+    ap.add_argument('--schedule',type=Path,help='frozen slot schedule; bot order defines slot IDs')
+    ap.add_argument('--resume',action='store_true',help='resume completed matches only after hash checks')
+    ap.add_argument('--workers',type=int,default=1,help='concurrent matches; calibrate on the host before increasing')
+    ap.add_argument('--report-every',type=int,default=25,help='refresh aggregate report every N games; results checkpoint every game')
+    args=ap.parse_args()
+    if args.workers<1 or args.report_every<1:ap.error('workers and report-every must be positive')
+    entrants=[]
+    for entry in args.bots:
+        name,sep,path=entry.partition('=')
+        if not sep or not name.strip() or not Path(path).is_file():ap.error('Use Name=existing-program entries')
+        if any(c in name for c in '|\n\r'):ap.error('Names cannot contain pipes or line breaks')
+        entrants.append((name,str(Path(path).resolve())))
+    if len({name for name,_ in entrants})!=len(entrants):ap.error('Names must be unique')
+    if args.anchor not in {name for name,_ in entrants}:ap.error('--anchor must name a bot included in --bots')
+    seed=args.seed if args.seed is not None else secrets.randbits(63)
+    if not args.schedule:
+        try:schedule=make_schedule(entrants,args.sizes,args.seeds,seed)
+        except ValueError as e:ap.error(str(e))
+    if args.schedule:
+        frozen=json.loads(args.schedule.read_text(encoding='utf-8'))
+        if frozen['sizes']!=args.sizes:ap.error('Frozen schedule sizes differ')
+        slot_ids={slot for g in frozen['entries'] for slot in g['slots']}
+        if slot_ids!=set(range(len(entrants))):ap.error('Frozen roster size differs')
+        if entrants[frozen['baseline_slot']][0]!=args.anchor:ap.error('Baseline must occupy its frozen slot')
+        schedule=[]
+        for g in frozen['entries']:
+            if not 2<=g['size']<=10 or len(g['slots'])!=g['size'] or len(set(g['slots']))!=g['size']:ap.error('Invalid frozen match')
+            schedule.append(dict(size=g['size'],seed=g['seed'],roster=[entrants[i] for i in g['slots']]))
+        seed=frozen['schedule_seed']
+    if args.output.exists() and not args.resume:ap.error('Output exists; use --resume or a new directory')
+    if args.resume and not args.output.exists():ap.error('Nothing to resume')
+    workspace=args.workspace.resolve()
+    manifest=json.loads((workspace/'MANIFEST.json').read_text(encoding='utf-8'))
+    for name,digest in manifest.items():
+        file=(workspace/name).resolve()
+        if not file.is_relative_to(workspace):ap.error('Invalid manifest path')
+        if hashlib.sha256(file.read_bytes()).hexdigest()!=digest:ap.error('Referee package modified: '+name)
+    sys.path.insert(0,str(workspace/'engine'))
+    from arena import play
+    from engine import VERSION
+    from verify_replay import verify
+    if args.schedule and frozen['version']!=VERSION:ap.error('Frozen schedule engine version differs')
+    identity=dict(version=VERSION,anchor=args.anchor,sizes=args.sizes,execution=dict(workers=args.workers),
+                  scoring_code={p.name:hashlib.sha256(p.read_bytes()).hexdigest() for p in (Path(__file__),Path(__file__).with_name('bt.py'))},
+                  engine_manifest=manifest,bot_hashes={name:hashlib.sha256(Path(path).read_bytes()).hexdigest() for name,path in entrants},
+                  schedule=dict(schedule_seed=seed,entries=schedule))
+    identity=json.loads(json.dumps(identity))
+    rows=[]
+    if args.resume:
+        if json.loads((args.output/'identity.json').read_text(encoding='utf-8'))!=identity:ap.error('Referee, bots or schedule changed; resume rejected')
+        saved=args.output/'results.json'
+        if saved.exists():rows=json.loads(saved.read_text(encoding='utf-8'))
+        if len(rows)>len(schedule):ap.error('Too many saved results')
+        for number,row in enumerate(rows,1):
+            g=schedule[number-1];r=row['result']
+            if row['match']!=number or row['size']!=g['size'] or r['seed']!=g['seed'] or r['names']!=[n for n,_ in g['roster']]:ap.error('Saved match differs')
+            path=args.output/'replays'/f'{number:05d}.json';verify(path)
+            if json.loads(path.read_text(encoding='utf-8'))['result']!=r:ap.error('Saved result/replay mismatch')
+    else:
+        args.output.mkdir(parents=True)
+        (args.output/'identity.json').write_text(json.dumps(identity,ensure_ascii=False,indent=2),encoding='utf-8')
+        (args.output/'schedule.json').write_text(json.dumps(identity['schedule'],ensure_ascii=False,indent=2),encoding='utf-8')
+    print(f'{len(entrants)} entrants; sizes={args.sizes}; {len(schedule)} games; no fillers.',flush=True)
+    if args.plan_only:return
+    started=time.perf_counter();report_seconds=0;checkpoint_seconds=0;match_seconds=0
+    jobs=[(i,g,str(workspace),str(args.output),args.resume,identity['bot_hashes']) for i,g in enumerate(schedule,1) if i>len(rows)]
+    for row,duration in match_results(jobs,args.workers):
+        number=row['match'];result=row['result'];rows.append(row);match_seconds+=duration
+        tick=time.perf_counter()
+        temp=args.output/'results.tmp'
+        temp.write_text(json.dumps(rows,ensure_ascii=False,indent=2),encoding='utf-8');temp.replace(args.output/'results.json')
+        checkpoint_seconds+=time.perf_counter()-tick
+        if number%args.report_every==0 or number==len(schedule):
+            tick=time.perf_counter()
+            (args.output/'汇总.md').write_text(report(rows,entrants,args.sizes,args.anchor),encoding='utf-8')
+            report_seconds+=time.perf_counter()-tick
+        print(f'{number}/{len(schedule)} ranks={result["ranks"]} errors={result["errors"]}',flush=True)
+    try:rating=fit(rows,[n for n,_ in entrants],args.sizes,args.anchor)
+    except ValueError as e:rating={'unavailable':str(e)}
+    (args.output/'bt.json').write_text(json.dumps(rating,ensure_ascii=False,indent=2),encoding='utf-8')
+    (args.output/'performance.json').write_text(json.dumps(dict(workers=args.workers,wall_seconds=time.perf_counter()-started,
+        match_worker_seconds=match_seconds,checkpoint_seconds=checkpoint_seconds,report_seconds=report_seconds),indent=2),encoding='utf-8')
+
+
+if __name__=='__main__':main()

package/eval/arena/bomberman/tournament/run.py

@@ -0,0 +1,79 @@
+"""先把 C++ 选手编译好，再调用正式赛用的 evaluate.py。挑战脚本和复现正式赛都走这里。
+
+  python tournament/run.py --output 输出目录 --sizes 2 5 10 --seeds 3 --bots 名字=程序.cpp ...
+  python tournament/run.py --formal --output 输出目录        复现正式赛（8930 局，冻结赛程）
+"""
+import argparse
+import hashlib
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+sys.stdout.reconfigure(encoding="utf-8")
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parent
+FORMAL = ["GPT-6 Astra=bots/gpt-6-astra.cpp", "GPT-6 Sol=bots/gpt-6-sol.cpp", "Opus 5.5=bots/opus-5.5.cpp", "Kimi K3=bots/kimi-k3.cpp",
+          "GLM 5.3=bots/glm-5.3.cpp", "DeepSeek V4.1 Flash=bots/deepseek-v4.1-flash.cpp", "豆包 Seed 2.1=bots/doubao-seed-2.1.cpp",
+          "Qwen 3.8 Max=bots/qwen-3.8-max.cpp", "MiMo V2.6 Pro=bots/mimo-v2.6-pro.cpp", "Base=workspace/baseline.cpp"]
+
+
+def find_compiler():
+    cxx = os.environ.get("CXX") or shutil.which("g++") or shutil.which("clang++")
+    if not cxx and os.name == "nt":  # 没加进 PATH 的 w64devkit：仓库根目录下的 tools/，或 C 盘根目录
+        for root in [*(a / "tools" for a in HERE.parents), Path("C:/")]:
+            if (root / "w64devkit/bin/g++.exe").is_file():
+                return str(root / "w64devkit/bin/g++.exe")
+    return cxx
+
+
+def compile_all(entries, build):
+    build.mkdir(parents=True, exist_ok=True)
+    out = []
+    for e in entries:
+        name, src = e.split("=", 1)
+        src = (ROOT / src).resolve() if not Path(src).is_absolute() else Path(src)
+        if src.suffix.lower() != ".cpp":
+            out.append(f"{name}={src}"); continue
+        digest = hashlib.sha256(src.read_bytes()).hexdigest()[:12]
+        exe = build / f"{src.stem}-{digest}{'.exe' if os.name == 'nt' else ''}"
+        if not exe.is_file():
+            print(f"编译 {name}：{src.name}", flush=True)
+            cxx = find_compiler()
+            if not cxx:
+                raise SystemExit("没有找到 C++ 编译器（g++ 或 clang++），安装方法见仓库根目录 README。")
+            # 与正式赛相同的编译参数（见 workspace/engine/build.py）
+            r = subprocess.run([cxx, *(["-static"] if os.name == "nt" else []), "-std=c++20", "-O2", str(src), "-o", str(exe)],
+                               capture_output=True, text=True, encoding="utf-8", errors="replace")
+            if r.returncode or not exe.is_file():
+                raise SystemExit(f"{name} 编译失败：\n{r.stdout}\n{r.stderr}")
+        out.append(f"{name}={exe}")
+    return out
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--output", type=Path, required=True)
+    ap.add_argument("--bots", nargs="+")
+    ap.add_argument("--sizes", type=int, nargs="+")
+    ap.add_argument("--seeds", type=int, default=3)
+    ap.add_argument("--formal", action="store_true", help="用冻结的正式赛赛程（2–10 人，8930 局）")
+    ap.add_argument("--workers", type=int, default=max(1, min(8, (os.cpu_count() or 2) // 2)))
+    a = ap.parse_args()
+    bots = compile_all(FORMAL if a.formal else a.bots, ROOT / "workspace" / "build")
+    args = [sys.executable, "-X", "utf8", "-u", str(HERE / "evaluate.py"), "--workspace", str(ROOT / "workspace"), "--bots", *bots,
+            "--anchor", "Base", "--output", str(a.output), "--workers", str(a.workers), "--report-every", "100"]
+    if a.formal:
+        import gzip
+        sched = a.output.parent / "schedule-2to10.json"
+        sched.parent.mkdir(parents=True, exist_ok=True)
+        sched.write_bytes(gzip.decompress((HERE / "schedule-2to10.json.gz").read_bytes()))
+        args += ["--sizes", *map(str, range(2, 11)), "--schedule", str(sched)]
+    else:
+        args += ["--sizes", *map(str, a.sizes), "--seeds", str(a.seeds)]
+    raise SystemExit(subprocess.call(args))
+
+
+if __name__ == "__main__":
+    main()

package/eval/arena/bomberman/workspace/MANIFEST.json

@@ -0,0 +1,13 @@
+{
+  "baseline.cpp": "a4ca3e21d2f8a75ca9a0c52fbec8d46442ba62031f0f666a825f76edbc573097",
+  "clock.py": "9841b6a5485507b8cb40a6391e9d984b4a1c7d275f4644df344aa206f0077742",
+  "engine/arena.py": "293b5f7f63cc93b39fe2a480ed7a07053d00e5d64f1c81299628368ad44668ff",
+  "engine/build.py": "d430ff44d877a6f8d1e71d1084e00f8b80abab0535e2b914fdf26deec0bd10ab",
+  "engine/engine.py": "e543412fce0c918825b741ec53f751a94daedcb288905ae261f9a3140bf57396",
+  "engine/verify_replay.py": "5d54e98fe4385a4cf31a5c08cde9363d8128e2a6252fa5b65873fe3583ae0164",
+  "README.md": "6880de795f428f1ba2dd74074f04207b14cb02fac7b3c7da5c2b33c3e33bf5f3",
+  "RULES.md": "374f9a615babde524517fa690e94fec7ccbb357782cd3fe2c002c0e297573c6b",
+  "run.cmd": "b526ba862199ae83f0c97f5a8cfa103d8e3881d24994ab49d2daa16c336a658a",
+  "run.sh": "2e41d6f16386eb3ccc069e3d911a89cc4aac67ef61bce28e38e9204c780b8c4b",
+  "viewer/index.html": "d3e14ae5c5c4d67b7d676965d2eb0ea76cd8660d488679d20044121d63a4493c"
+}

package/eval/arena/bomberman/workspace/README.md

@@ -0,0 +1,29 @@
+# 炸弹人对抗
+
+编写尽可能强的 bot，同一程序须支持2–10人。游戏规则和通信协议见 RULES.md；baseline.cpp 是可修改的公开练习对手。各场人数由实际参赛配置决定。正式赛多轮对战，使用 Bradley–Terry 模型拟合实力值，公开基准为0分线。单局分为生存分＋0.5×击杀份额，按合计分排名，同分并列。
+
+解压起计时，争取60分钟内完成开发与测试，90分钟必须停止修改并交卷，无需启动计时器。允许本地工具、编译、模拟与复盘；禁止联网、调用其他AI、读取其他选手资料、修改裁判或计时器、干扰对手。比赛中的 bot 按标准输入输出协议独立决策，不访问文件或网络。
+
+提交 `submission/bot.cpp`（C++20），简述策略。
+
+## 本地使用
+
+以下在 workspace 目录运行。Windows 使用 `run.cmd`；Linux 替换为 `sh run.sh`，并去掉可执行文件名的 `.exe`。只需要现有 Python；C++程序还需要现有编译器，无第三方Python依赖。
+
+- 剩余时间：`run.cmd clock.py`
+- 编译基准：`run.cmd engine/build.py --compile --output baseline.exe`
+- 编译C++提交：`run.cmd engine/build.py --compile --source submission/bot.cpp --output bot.exe`
+- 对战：`run.cmd engine/arena.py --bots Mine=bot.exe Base=baseline.exe --seed 1 --replay replays/duel.html`
+- 文本复盘：`run.cmd engine/arena.py --inspect replays/duel.json --turn 20 --context 2`
+
+多人对战增加 `Name=程序路径`，每个名字唯一，总计2–10个；可加入重复基准实例练习，但正式赛程不默认补位。带空格的路径需将整个 `Name=路径` 参数加引号。
+
+每局自动保存 JSON 和 HTML。HTML可逐帧查看该步动作、实际落点、事件、最终得分和名次；文本复盘还展示完整棋盘与故障详情。结合具体回合改进，不必提交测试报告。
+
+## 时间与环境
+
+开发90分钟与回合预算不同：bot首回合2000ms，之后50ms。回合限时包含通信与系统调度。
+
+用 `clock.py` 查看剩余时间，无需初始化。不要覆盖解压、修改计时器或调整系统时间；到时自行停止修改并交卷。
+
+环境故障请报告组织方，不修改系统权限、防护或安装软件。编译命令只编译，不会额外启动你的程序；运行能力通过对战验证。

package/eval/arena/bomberman/workspace/RULES.md

@@ -0,0 +1,100 @@
+# 炸弹人规则 v0.5-public-state（公开）
+
+## 目标与行动
+
+每人控制一个角色，争取最高的生存与击杀合计分。每回合所有存活玩家看到相同的完整公开状态，独立选择 U/D/L/R/S（上下左右/等待）与放弹位 0/1。没有攻击按钮、装备、道具、生命值或复活。角色被爆炸、残留火焰、缩圈击中即淘汰。
+
+坐标从 0 开始，左上角 (0,0)，x 向右，y 向下。`#` 永久墙，`+` 可破坏箱子，`.` 空地。玩家不能重叠；允许相邻两人同时交换位置，也允许多人形成移动环。不因碰撞死亡。非法地形移动原地停留，方向可以直接反向。
+
+所有人数：炸弹容量 2，爆炸射程 3 格（不含中心），引信 4 回合，火焰覆盖爆炸回合及下一回合。绝对行动回合 t 从 0 开始；t 放的炸弹在 t+4 的爆炸阶段引爆。放弹在原位置，随后移动；放弹和移动可以同回合执行。
+
+## 各人数参数
+
+| 人数 | 棋盘 | 回合上限 | 首次缩圈的行动回合 | 每隔几回合再缩一层 |
+|---:|---:|---:|---:|---:|
+|2|13×13|300|150|20|
+|3|15×15|340|175|20|
+|4|17×17|450|250|25|
+|5|19×19|475|225|25|
+|6|21×21|525|250|25|
+|7|21×21|550|275|25|
+|8|23×23|600|300|25|
+|9|25×25|650|325|25|
+|10|25×25|675|350|25|
+
+2、4人使用表中固定参数；其余人数参数公式：边长 `2*ceil(sqrt(14*p))+1`，首缩 `150+25*(p-2)`，上限 `首缩+间隔*(边长//2)+25`。3 人间隔20，其余25。后期会自然缩至无可生存格，所以正常游戏通常早于上限结束。
+
+## 地图
+
+外圈为永久墙；内部 x、y 同为偶数的格子也是永久墙。其余格子按生成器以 0.42 概率放箱子；出生点曼哈顿距离2内不放箱子。出生位置至少两条初始可走出口，清除箱子后的道路连通。箱子分布开局公开，对局过程无随机数。
+
+2 人出生在对角，地图180°对称；4人在四角，地图90°对称。其他人数在内侧边界的奇坐标位置环上等距取点（整数取整），种子决定起点，箱子独立生成。这些人数不保证单局出生点完全等价。地图生成代码见 `make_map()`。
+
+## 一回合的精确阶段
+
+输入是本回合开始、尚未执行以下阶段的状态。按顺序处理：
+
+1. **清理和缩圈**：删除已过期火焰；所有协议错误/超时玩家同回合淘汰；到缩圈回合时，将距外边界不大于新层数的格子变成永久墙。首缩是层1（原外墙层0）。新墙上的玩家立即死亡，不能在该回合移动逃出。新墙上的炸弹直接移除，不爆炸；箱子和火焰也移除。
+2. **放弹**：在玩家移动前的位置尝试放置。存活、当前位置无炸弹、自己的在场炸弹少于2，才有资格。多个有资格玩家在同格同时请求放弹时，所有请求失败，避免按 ID 偏袒。没资格的请求不参与冲突。放弹失败不影响移动，也不算协议错误。本回合即将爆炸的旧炸弹仍占用容量。
+3. **移动**：上下左右移动一格或等待，所有玩家同时处理。墙、箱子、炸弹阻挡进入；被阻挡则原地停留。玩家可站在脚下原有/刚放的炸弹上等待，也可以离开；离开后不可走回仍有炸弹的格子。地形判定后，若多个玩家的目标相同（包括等待者的当前位置），这些玩家全部停留。随后若某人的目标被已停留者占用，他也停留，反复传播直至稳定。其余移动同时成功，包括两人交换、多人成环、跟随离开的玩家。没有按 ID 抢占的优先级。
+4. **爆炸**：计时到期或处于旧火焰上的炸弹引爆，向四方向延伸最多3格。永久墙阻断且不着火；箱子格着火、箱子被毁，但阻断继续传播；炸弹格着火、立即连锁引爆，同时阻断这一条射线。所有爆炸统一使用本阶段开始时的箱子/炸弹分布：先炸掉箱子不让本回合另一股火焰穿过去，先爆炸的炸弹仍是这个阶段其他射线的阻挡物。
+5. **火焰与淘汰**：删除引爆炸弹，移除被炸箱子，火焰在爆炸回合 t 和 t+1 有效。移动结束后处于旧/新火焰的玩家同时淘汰。死者已放的炸弹保留、继续计时，除非后来被缩圈删除。然后回合数加1。
+
+所有阶段执行完整后才判断结束。即使缩圈后只剩一人，他仍需经受本回合爆炸；可以最终无人存活。同回合不同阶段死亡者仍并列。
+
+## 结束与排名
+
+存活人数≤1，或达到回合上限，结束。单局分 = 生存分 + 0.5 × 击杀份额。
+
+- 生存分：每多活过一名对手得 1 分；与一名对手同回合淘汰或同为终局幸存者，彼此各得 0.5 分。终局幸存者比所有死者晚淘汰。设人数为 n、生存名次为 r、该名次人数为 t，则生存分为 `n-r-(t-1)/2`。
+- 击杀份额：死者所在格的有效火焰按炸弹原主人归属，排除死者本人，不同主人均分一个击杀。同一主人多股火焰只算一次；连锁爆炸不转移下游炸弹归属；旧火焰保留来源；已死亡的主人仍可获份额。缩圈、协议错误、仅自身火焰造成的死亡没有击杀份额。
+- 按单局分从高到低排名，同分并列，不另设破平条件。名次为 `1 + 分数严格高于自己的玩家数`。裁判使用精确分数比较；最后幸存者不保证单局第一。
+
+例如五人局：第二名生存分 3，独占三个击杀得 1.5，合计 4.5；零击杀的最后幸存者得 4 分。
+
+放弹数、破箱数仅展示，不计分。一个箱子同回合被多个玩家炸到时，每个命中的玩家都记一次破箱。
+
+正式赛按单局排名转换为两两胜负，平局计半胜，用 Bradley–Terry 模型拟合实力。不同参赛人数的比赛总权重相等，公开基准锚定 0；不按当期最高分重新缩放。
+
+本届九位选手及一个公开基准参加2、5、10人三档比赛，各档总权重为1/3，每档20张地图。双人全配对并交换座位；五人平衡分组并正反轮换座位；十人全员正反轮换座位。合计2600局，各选手960局。五人赛每对选手交手80、90或100局，各选手总出场及各座位次数相同。
+
+BT 显示值为 `400×log10(选手实力/基准实力)`，弱于基准显示负值。每对已交手选手在加权统计后加入一次虚拟平局，使全胜或全负也得到有限估计。
+
+## 文本协议
+
+进程启动后仅一次：
+
+```text
+INIT 边长 玩家数 自己ID 回合上限 引信 射程 容量 火焰回合数 首缩回合 缩圈间隔
+```
+
+每回合：
+
+```text
+TURN t
+BOARD
+...（边长行，字符 # + .）
+P id x y alive
+...（玩家数行，alive为0/1，ID从0起）
+BOMBS k
+B owner x y explode_at
+...（k行，explode_at为绝对行动回合）
+FLAMES f
+F x y last_lethal_turn
+...（f行，最后致命回合含端点）
+STATUS 玩家数
+S id death_turn kill_numerator kill_denominator
+...（玩家数行；存活者death_turn为-1，击杀份额为精确分数）
+SOURCES s
+O x y owner last_lethal_turn
+...（s行；当前仍有效的每格火焰来源，每位主人一行）
+END
+```
+
+STATUS 是截至本次输入的累计击杀份额与淘汰回合；SOURCES 保留各主人各自的火焰到期时间。所有选手接收相同公开状态，自身ID由INIT指定。必须读取至END后再回答。
+
+回答恰一行，单空格分隔：`t U 0`。大写 U/D/L/R/S；0/1；行尾换行并 flush。支持 LF/CRLF，每行最多256字节。禁止提前输出未来回合，禁止 stdout 调试内容，非法输出或超时立即淘汰。
+
+首回合2000ms，之后每回合50ms。从开始发送输入到完整回答行抵达计时，包含输入输出和系统调度；进程创建时间不计入首回合预算。
+
+程序超时、退出或违反输出协议时淘汰。