dsh-eval-guard 0.2.3 → 0.3.1

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

@@ -0,0 +1,41 @@
+# 夺旗
+
+编写 `submission/bot.cpp`：一个程序统一控制己方 3 个角色，支持 2–15 个阵营同场。完整规则和输入输出格式见 `RULES.md`。
+
+解压时开始计时。你有 60 分钟，只看最终 bot 的强度，提前交卷不加分；可以适当超时，但到 90 分钟会强制交卷。
+
+## 文件
+
+| 文件 | 用途 |
+|---|---|
+| `RULES.md` | 规则与程序接口 |
+| `submission/bot.cpp` | 你的程序。现在是一个模板：已经写好完整的输入解析，角色原地不动 |
+| `baseline.exe` | 中等强度的练习对手，思路常规，没有提供源码，请不要反编译 |
+| `arena.py`、`engine.py`、`core.py` | 本地对战用的裁判，与正式比赛相同 |
+| `viewer.html` | 回放网页模板 |
+| `clock.py` | 查看已用时间 |
+| `run.cmd`、`run.sh` | 找到 Python 并运行上面的脚本 |
+
+## 常用命令
+
+在本目录运行。下面以 PowerShell 和命令提示符为例，写作 `.\run.cmd`；在 bash 里（包括 Windows 上的 Git Bash 和 Linux）把它换成 `sh run.sh`，后面的参数不变。
+
+```text
+.\run.cmd clock.py                                         已用时间
+.\run.cmd arena.py check                                   检查环境
+.\run.cmd arena.py play submission/bot.cpp baseline --seed 7
+.\run.cmd arena.py play submission/bot.cpp baseline baseline baseline baseline --out five
+.\run.cmd arena.py show replays/five.json 120 --around 2    看第 118–122 回合
+.\run.cmd arena.py batch submission/bot.cpp baseline baseline --games 12
+```
+
+- `.cpp` 程序会先自动编译，结果按源码缓存在 `build/`，源码不变就不重复编译。编译出错时会显示编译器的报错。
+- `play` 打一局，打印每个程序的得分、名次、每回合平均和最慢用时，并把回放存成 `replays/名字.json` 和 `replays/名字.html`。网页可以逐回合播放。
+- `show` 在终端里打印棋盘、所有角色的位置、血量和携旗情况、事件，以及各方的指令。
+- `batch` 连续打多局并汇总每个程序的平均得分、平均名次、第一名次数、故障和最慢用时，不保存回放。它和正式比赛一样，每张地图把座位完整轮换一圈（n 方就是 n 局），所以局数最好取人数的整数倍。
+- `--seed` 只决定地图。旗子每次出现在哪个旗点每局都不同，所以同一个种子重打，结果也可能不同。
+- 程序可以重复出场，比如自己和自己对打。
+
+## 提交
+
+最终代码放在 `workspace/submission/bot.cpp`，结束时用几句话说明你的策略。

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

@@ -0,0 +1,119 @@
+# 多阵营夺旗 · 规则 v1.0
+
+2–15 个阵营同场，每个阵营由一个程序控制 3 个角色。把中立旗送回自己的基地，每送回一面得 1 分。400 回合后按得分排名，同分并列。
+
+## 地图
+
+- 正方形格子地图，边长：2 方 23，3–5 方 31，6–10 方 41，11–15 方 49。四周是墙，场内散布单格柱子，也是墙。整张地图公开。
+- **基地**：每个阵营一块 3×3 区域。所有基地排成一圈，到地图中心的距离相同，相邻基地的间距大致相等。任何角色都可以走进任何基地。
+- **旗点**：每个基地前方各一个，再加地图正中心一个，共"阵营数 + 1"个。每个基地到自家旗点、到中心的距离都相同。
+- **旗子**：共 max(2, ⌈阵营数 / 2⌉) 面，没有归属。开局和每次回位时，旗子随机出现在一个没有旗子的旗点上。这个随机与地图生成无关，无法预测。
+
+## 每回合
+
+每个角色选一个**移动**（上、下、左、右、不动）和一个**动作**（攻击、拾旗、丢旗、不做事）。所有程序同时提交，然后按下面的顺序结算：
+
+1. 到时间的旗子回位，到时间的阵亡角色重生
+2. 移动
+3. 攻击，阵亡
+4. 拾旗
+5. 丢旗
+6. 交旗
+
+### 移动
+
+上下左右走一格，或原地不动。走向墙等于不动。结算后任何两个角色都不在同一格：
+
+- 多个角色要进同一格：都不动。
+- 走进别人正在离开的格子：可以；如果对方没走成，你也不动。
+- 两个角色对换位置：同阵营可以；不同阵营都不动。
+- 三个及以上角色绕圈移动：可以。
+
+### 攻击
+
+- 攻击要指定目标（敌方角色的 id），按双方移动后的位置判断能否打到。
+- 射程：横纵距离之和不超过 2。墙的遮挡只有两种情况：隔一格直线攻击（如横向相距 2）时，中间那格不能是墙；斜向攻击（横纵各差 1）时，两个拐角格至少有一个不是墙。紧挨着的攻击不受墙影响。
+- 每次命中造成 34 点伤害。生命值 100，不会自然回复，所以 3 次命中必定阵亡。
+- 所有攻击同时生效，双方可以同回合互相击杀。
+- 携旗的角色不能攻击。刚重生的角色，在重生的那个回合既不能攻击，也不会被攻击。
+
+### 旗子
+
+- 拾旗：和旗子在同一格时拿起。每人最多拿一面；同一格有几面时拿编号最小的。
+- 携旗角色阵亡时，旗子掉在原地，任何阵营都能捡。
+- 丢旗：主动放下旗子。拾旗先于丢旗结算，所以队友最早下一回合才能捡起。
+- 地上的旗子 15 回合无人拾取，会回到一个随机的空旗点。
+- 回合结束时携旗角色站在自己的基地里，即交旗得 1 分。这面旗离场 8 回合后，重新出现在一个随机的空旗点。
+
+### 阵亡与重生
+
+阵亡 10 回合后在自己的基地重生，满血，优先占离地图中心近的空格；基地被站满（包括被敌人站住）时推迟到有空格为止。可以提前给即将重生的角色下指令，它在重生的那个回合就会移动和拾旗。
+
+## 程序接口
+
+- **语言**：C++20，只能用标准库。提交一个文件 `submission/bot.cpp`，用 `g++ -std=c++20 -O2` 编译（Windows 另加 `-static`）。
+- **通信**：每回合从标准输入读一个文本块，向标准输出写一行回复，写完立即刷新（例如用 `endl`）。程序在整局比赛中持续运行，可以在内存里保存状态。调试信息写到标准错误。
+- **时限**：第一回合 2 秒（含程序启动），之后每回合 50 毫秒，从发出输入到收到完整回复计时。超时或回复格式错误时，这一回合按全部原地不动处理，迟到的回复会被丢弃。连续失败 3 次，或者程序退出，本局剩余回合都按原地不动处理。
+- 程序只能通过标准输入输出与裁判通信，不得读写文件、联网或启动其他程序。
+
+`submission/bot.cpp` 模板已经写好了完整的输入解析，可以直接沿用。
+
+### 输入
+
+第一回合先收到一次开局信息，之后每回合收到一个以 `END` 结尾的块。数字之间用空格分隔，每项占一行：
+
+```text
+INIT 阵营数 你的阵营 地图边长 总回合数 生命 伤害 重生回合数 旗子无人拾取回位回合数 交旗后离场回合数
+MAP
+（地图边长行，# 墙，. 空地）
+BASES 阵营数
+x y                    （每行一个阵营的基地中心，基地是以它为中心的 3×3）
+SPOTS 旗点数
+x y                    （每行一个旗点）
+```
+
+```text
+TURN t                 （即将结算的回合，从 1 开始）
+SCORE 各阵营得分
+UNITS 角色数
+U id 阵营 x y 生命 携带的旗 重生回合
+FLAGS 旗子数
+F id 状态 x y 携旗角色 回位回合
+EVENTS 事件数
+E 类型 ...             （上一回合发生的事件，见下表）
+END
+```
+
+- 坐标以左上角为 (0, 0)，x 向右增大，y 向下增大。阵营 k 的角色 id 为 3k、3k+1、3k+2。
+- **角色**：阵亡时 x、y 为 -1；没带旗时"携带的旗"为 -1；活着时"重生回合"为 -1。
+- **旗子**：状态为 `home`（在旗点）、`dropped`（在地上）、`carried`（被携带）、`cooldown`（交旗后离场）。后两种状态下 x、y 为 -1；没有携旗角色、没有回位回合时对应值为 -1。
+- 重生回合或回位回合等于 t 时，重生或回位就发生在本回合开头。
+
+| 事件 | 格式 |
+|---|---|
+| 旗子回位 | `E return 旗` |
+| 重生 | `E respawn 角色 x y` |
+| 命中 | `E attack 攻击者 目标` |
+| 阵亡 | `E death 角色 x y 掉落的旗 击杀者人数 击杀者...`（没掉旗为 -1） |
+| 拾旗 / 丢旗 | `E pickup 角色 旗`、`E drop 角色 旗` |
+| 交旗 | `E capture 角色 阵营 旗` |
+
+### 输出
+
+一行：本回合编号，然后按 id 从小到大给自己的 3 个角色各写一个移动和一个动作：
+
+```text
+t 移动 动作 移动 动作 移动 动作 [# 注释;注释;注释]
+```
+
+- **移动**：`U` 上，`D` 下，`L` 左，`R` 右，`S` 原地不动。
+- **动作**：`-` 什么都不做，`P` 拾旗，`X` 丢旗，一个数字表示攻击这个 id 的角色。
+- **注释**（可选）：`#` 之后用分号分隔，依次对应 3 个角色，每条最多 20 个字，只显示在回放里，例如 `# 抢旗;护送;拦截`。
+- 例：`37 R 4 U P S -` 表示第 37 回合，第一个角色右移并攻击 4 号，第二个角色上移并拾旗，第三个角色不动。
+- 阵亡角色也要写，除非它本回合重生，否则会被忽略。回合编号不对、字段数量不对或出现未定义的字母，都算格式错误。
+
+## 正式比赛
+
+- 参赛的是其他模型写的程序，外加一个中等强度的基准。
+- 覆盖从 2 方到全员的各种人数，每种人数权重相同。地图种子不公开；同一组程序会在同一张地图上轮换全部座位。
+- 每局按得分排名，名次拆成两两胜负，用 Bradley–Terry 模型拟合实力值，基准为 0 分。

package/eval/arena/ctf/workspace/arena.py

@@ -0,0 +1,186 @@
+"""本地对战与复盘。
+
+  arena.py check                                  检查环境
+  arena.py play 程序 程序 ... [--seed N] [--out 名字]
+                                                  对战 2–15 个程序（.cpp 会自动编译），baseline 表示练习基准
+  arena.py batch 程序 程序 ... --games N [--seed N] [--workers W]
+                                                  多局对战并汇总，每张地图轮换全部座位
+  arena.py show 回放.json 回合 [--around K]      打印该回合前后 K 回合的棋盘、角色和指令
+"""
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+import core  # noqa: E402
+from engine import VERSION, Game  # noqa: E402
+
+TEAM_CHARS = "0123456789abcde"
+
+
+BUILD = HERE / "build"
+
+
+def program(spec):
+    """返回运行命令。.cpp 会先编译（结果缓存在 build/，源码不变就不重复编译）。"""
+    if spec == "baseline":   # 开源版：没有编译好的基准时，用 baseline.cpp 源码自动编译
+        path = HERE / ("baseline.exe" if os.name == "nt" else "baseline")
+        if not path.is_file():
+            path = HERE / "baseline.cpp"
+    else:
+        path = Path(spec).resolve()
+    if not path.is_file():
+        raise SystemExit(f"找不到程序：{spec}")
+    try:
+        return core.command_for(path, BUILD)
+    except RuntimeError as exc:
+        raise SystemExit(f"{spec}：{exc}")
+
+
+def names_for(specs):
+    names, seen = [], {}
+    for s in specs:
+        stem = "baseline" if s == "baseline" else Path(s).stem
+        seen[stem] = seen.get(stem, 0) + 1
+        names.append(stem if specs.count(s) == 1 and seen[stem] == 1 else f"{stem}#{seen[stem]}")
+    return names
+
+
+def play(specs, seed, out):
+    if not 2 <= len(specs) <= 15:
+        raise SystemExit("需要 2–15 个程序")
+    programs = [program(s) for s in specs]
+    names = names_for(specs)
+    result, replay = core.run_match(Game, programs, names, seed)
+    path = HERE / "replays" / out
+    core.save_replay(replay, path, HERE / "viewer.html")
+    ranks = [1 + sum(s > x for s in result["score"]) for x in result["score"]]
+    print(f"{VERSION}  {len(specs)} 方  种子 {seed}")
+    for i, (n, b) in enumerate(zip(names, result["bots"])):
+        extra = f"  故障：{b['dead']}" if b["dead"] else f"  失败 {len(b['faults'])} 次" if b["faults"] else ""
+        print(f"  {i}号位 {n:14s} 交旗 {result['score'][i]:3d}  第 {ranks[i]} 名  "
+              f"每回合平均 {b['avg_ms']:.1f}ms、最慢 {b['max_ms']:.1f}ms（首回合 {b['first_ms']:.0f}ms）{extra}")
+        for line in b["stderr_tail"]:
+            print(f"      stderr: {line}")
+    print(f"回放：{path.with_suffix('.html')}（网页）  {path.with_suffix('.json')}（数据）")
+
+
+def _one(job):
+    programs, names, seed = job
+    result, _ = core.run_match(Game, programs, names, seed, record=False)
+    return names, result["score"], result["bots"]
+
+
+def batch(specs, games, seed, workers):
+    """多局对战：每张地图把座位完整轮换一圈（n 方就是 n 局），再换下一张地图。"""
+    import os
+    from concurrent.futures import ProcessPoolExecutor
+    n = len(specs)
+    if not 2 <= n <= 15:
+        raise SystemExit("需要 2–15 个程序")
+    programs, names = [program(s) for s in specs], names_for(specs)
+    jobs = []
+    for k in range(games):
+        r = k % n
+        jobs.append((programs[r:] + programs[:r], names[r:] + names[:r], seed + k // n))
+    workers = workers or max(1, min(8, (os.cpu_count() or 4) // 2 // n))
+    stats = {x: {"games": 0, "score": 0, "rank": 0, "first": 0, "faults": 0, "max_ms": 0.0} for x in names}
+    with ProcessPoolExecutor(workers) as pool:
+        for seats, score, bots in pool.map(_one, jobs):
+            ranks = [1 + sum(s > x for s in score) for x in score]
+            for i, x in enumerate(seats):
+                st = stats[x]
+                st["games"] += 1
+                st["score"] += score[i]
+                st["rank"] += ranks[i]
+                st["first"] += ranks[i] == 1
+                st["faults"] += len(bots[i]["faults"]) + (1 if bots[i]["dead"] else 0)
+                st["max_ms"] = max(st["max_ms"], bots[i]["max_ms"])
+    print(f"{VERSION}  {n} 方  {games} 局（地图种子 {seed}–{seed + (games - 1) // n}，每张图轮换全部座位）  并行 {workers}")
+    for x, st in sorted(stats.items(), key=lambda kv: -kv[1]["score"]):
+        g = st["games"]
+        print(f"  {x:14s} 平均交旗 {st['score'] / g:5.1f}  平均名次 {st['rank'] / g:4.2f}  "
+              f"第一 {st['first']}/{g}  故障 {st['faults']}  最慢 {st['max_ms']:.0f}ms")
+    if games % n:
+        print(f"注意：局数不是 {n} 的整数倍，最后一张地图没有轮换完所有座位。")
+    print(f"并行局数越多，程序的每回合用时越容易被拉长；判断是否接近 {Game.TIME_LIMITS[1] * 1000:g} 毫秒的限时，请以单局 play 的结果为准。")
+
+
+def show(path, turn, around):
+    data = json.loads(Path(path).read_text(encoding="utf-8"))
+    head, frames = data["header"], data["frames"]
+    walls = head["map"]
+    base_of = {tuple(p): t for t, b in enumerate(head["bases"]) for p in b}
+    for f in frames:
+        if abs(f["turn"] - turn) > around:
+            continue
+        grid = [list(row) for row in walls]
+        for (x, y), t in base_of.items():
+            grid[y][x] = "+"
+        for fl in f["flags"]:
+            if fl["pos"]:
+                grid[fl["pos"][1]][fl["pos"][0]] = "*"
+        for u in f["units"]:
+            if u["pos"]:
+                grid[u["pos"][1]][u["pos"][0]] = TEAM_CHARS[u["id"] // 3]
+        print(f"\n===== 第 {f['turn']} 回合结束  得分 {f['score']} =====")
+        print("图例：# 墙  + 基地  * 地上的旗  数字/字母 = 该阵营的角色\n")
+        print("\n".join("".join(r) for r in grid))
+        print("\n角色：" + "  ".join(
+            f"{u['id']}({TEAM_CHARS[u['id'] // 3]})" +
+            (f"@{u['pos'][0]},{u['pos'][1]} {u['hp']}血" + (f" 携旗{u['flag']}" if u["flag"] is not None else "")
+             if u["pos"] else " 阵亡") for u in f["units"]))
+        print("事件：" + ("；".join(json.dumps(e, ensure_ascii=False) for e in f["events"]) or "无"))
+        for t, cmds in sorted(f["orders"].items(), key=lambda kv: int(kv[0])):
+            print(f"指令 {t}：{json.dumps(cmds, ensure_ascii=False)}")
+        for fault in f.get("faults", []):
+            print(f"故障 {fault['team']}：{fault['reason']}")
+
+
+def check():
+    if sys.version_info < (3, 10):
+        raise SystemExit(f"需要 Python 3.10 以上，当前是 {sys.version.split()[0]}")
+    compiler = core.find_compiler()
+    if not compiler:
+        raise SystemExit("没有找到 C++ 编译器（g++ 或 clang++）。请把情况告诉组织方。")
+    result, _ = core.run_match(Game, [program("baseline"), program(str(HERE / "submission" / "bot.cpp"))],
+                               ["baseline", "bot"], 1, record=False)
+    bad = [b for b in result["bots"] if b["faults"] or b["dead"]]
+    if bad:
+        raise SystemExit(f"试跑出错：{bad}")
+    print(f"正常：Python {sys.version.split()[0]}，编译器 {compiler}，模板和基准都能运行。")
+
+
+def main():
+    ap = argparse.ArgumentParser(description="夺旗本地对战与复盘")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+    sub.add_parser("check")
+    p = sub.add_parser("play")
+    p.add_argument("programs", nargs="+")
+    p.add_argument("--seed", type=int, default=1)
+    p.add_argument("--out", default="latest")
+    p = sub.add_parser("batch")
+    p.add_argument("programs", nargs="+")
+    p.add_argument("--games", type=int, required=True)
+    p.add_argument("--seed", type=int, default=1)
+    p.add_argument("--workers", type=int, default=0)
+    p = sub.add_parser("show")
+    p.add_argument("replay")
+    p.add_argument("turn", type=int)
+    p.add_argument("--around", type=int, default=0)
+    a = ap.parse_args()
+    if a.cmd == "check":
+        check()
+    elif a.cmd == "play":
+        play(a.programs, a.seed, a.out)
+    elif a.cmd == "batch":
+        batch(a.programs, a.games, a.seed, a.workers)
+    else:
+        show(a.replay, a.turn, a.around)
+
+
+if __name__ == "__main__":
+    main()

package/eval/arena/ctf/workspace/baseline.cpp

@@ -0,0 +1,257 @@
+// 练习基准（中等）：常规思路，不做对手建模和多步模拟。
+//  - 抢旗：比较我方和敌方谁先到，抢得到的旗才去，拿到就沿最短路回家。
+//  - 截杀：追得上的敌方携旗者就去追，在自家附近的优先。
+//  - 没事做时守在离家最近的空旗点。
+//  - 移动时以少打多就绕开；攻击按射程规则选目标，队友集火同一个。
+#include <bits/stdc++.h>
+using namespace std;
+
+struct Unit { int id, team, x, y, hp, flag, respawn; };
+struct Flag { int id; string status; int x, y, holder, ret; };
+
+int n, me, S, turns, HP, DMG;
+vector<string> grid;
+vector<pair<int, int>> baseCenter, spots;
+vector<vector<int>> homeField;          // 各阵营基地的距离场
+map<int, vector<int>> fieldCache;
+
+inline int idx(int x, int y) { return y * S + x; }
+inline bool wall(int x, int y) { return x < 0 || y < 0 || x >= S || y >= S || grid[y][x] == '#'; }
+inline int manh(int a, int b) { return abs(a % S - b % S) + abs(a / S - b / S); }
+const int DX[5] = {0, 0, -1, 1, 0}, DY[5] = {-1, 1, 0, 0, 0};
+const char* MV[5] = {"U", "D", "L", "R", "S"};
+
+vector<int> bfs(const vector<int>& src) {
+    vector<int> d(S * S, INT_MAX);
+    deque<int> q;
+    for (int c : src) { d[c] = 0; q.push_back(c); }
+    while (!q.empty()) {
+        int c = q.front(); q.pop_front();
+        for (int k = 0; k < 4; k++) {
+            int nx = c % S + DX[k], ny = c / S + DY[k];
+            if (wall(nx, ny)) continue;
+            int nc = idx(nx, ny);
+            if (d[nc] == INT_MAX) { d[nc] = d[c] + 1; q.push_back(nc); }
+        }
+    }
+    return d;
+}
+const vector<int>& field(int c) {
+    auto it = fieldCache.find(c);
+    if (it != fieldCache.end()) return it->second;
+    if (fieldCache.size() > 256) fieldCache.clear();
+    return fieldCache[c] = bfs({c});
+}
+int dist(int a, int b) { return field(b)[a]; }
+
+// 射程 2，墙会挡：直线隔一格要求中间不是墙，斜对角要求两个拐角至少一个不是墙
+bool canHit(int a, int b) {
+    int ax = a % S, ay = a / S, bx = b % S, by = b / S, dx = bx - ax, dy = by - ay;
+    int d = abs(dx) + abs(dy);
+    if (d == 0 || d > 2) return false;
+    if (d == 1) return true;
+    if (dx == 0) return !wall(ax, ay + dy / 2);
+    if (dy == 0) return !wall(ax + dx / 2, ay);
+    return !wall(ax + dx, ay) || !wall(ax, ay + dy);
+}
+
+int main() {
+    ios::sync_with_stdio(false);
+    string w;
+    while (cin >> w) {
+        if (w == "INIT") {
+            int re, fr, fc;
+            cin >> n >> me >> S >> turns >> HP >> DMG >> re >> fr >> fc;
+        } else if (w == "MAP") {
+            grid.assign(S, "");
+            for (auto& r : grid) cin >> r;
+        } else if (w == "BASES") {
+            int k; cin >> k; baseCenter.resize(k);
+            for (auto& b : baseCenter) cin >> b.first >> b.second;
+            homeField.resize(k);
+            for (int t = 0; t < k; t++) {
+                vector<int> cells;
+                for (int dx = -1; dx <= 1; dx++) for (int dy = -1; dy <= 1; dy++)
+                    cells.push_back(idx(baseCenter[t].first + dx, baseCenter[t].second + dy));
+                homeField[t] = bfs(cells);
+            }
+        } else if (w == "SPOTS") {
+            int k; cin >> k; spots.resize(k);
+            for (auto& s : spots) cin >> s.first >> s.second;
+        } else if (w == "TURN") {
+            int t; cin >> t;
+            string key; int k;
+            cin >> key; for (int i = 0, s; i < n; i++) cin >> s;
+            cin >> key >> k; vector<Unit> units(k);
+            for (auto& u : units) { string tag; cin >> tag >> u.id >> u.team >> u.x >> u.y >> u.hp >> u.flag >> u.respawn; }
+            cin >> key >> k; vector<Flag> flags(k);
+            for (auto& f : flags) { string tag; cin >> tag >> f.id >> f.status >> f.x >> f.y >> f.holder >> f.ret; }
+            cin >> key >> k; string rest; getline(cin, rest);
+            for (int i = 0; i < k; i++) getline(cin, rest);
+            cin >> key;   // END
+
+            vector<int> pos(units.size(), -1);
+            for (auto& u : units) if (u.x >= 0) pos[u.id] = idx(u.x, u.y);
+            vector<int> foes, mine;
+            for (auto& u : units) {
+                if (u.x < 0) continue;
+                (u.team == me ? mine : foes).push_back(u.id);
+            }
+            auto enemyETA = [&](int c) {
+                int best = INT_MAX;
+                for (int e : foes) if (units[e].flag < 0) best = min(best, dist(pos[e], c));
+                return best;
+            };
+
+            // ---------- 任务分配（贪心） ----------
+            struct Task { int goal; double value; int cap; };
+            vector<Task> tasks;
+            vector<pair<int, int>> cand;   // (角色, 任务) 由价值排序
+            vector<vector<double>> val;
+            for (auto& f : flags) {
+                if (f.x < 0) continue;
+                tasks.push_back({idx(f.x, f.y), (double)f.ret, 1});   // value 字段暂存回位回合
+            }
+            int nFlagTasks = tasks.size();
+            for (int e : foes) {
+                if (units[e].flag < 0) continue;
+                tasks.push_back({pos[e], (double)e, 2});   // 直接追，value 暂存敌人编号
+            }
+            int nHunt = tasks.size() - nFlagTasks;
+            // 空旗点：离自家基地由近到远
+            vector<char> hasFlag(S * S, 0);
+            for (auto& f : flags) if (f.x >= 0) hasFlag[idx(f.x, f.y)] = 1;
+            for (auto& s : spots) if (!hasFlag[idx(s.first, s.second)]) tasks.push_back({idx(s.first, s.second), 0, 1});
+
+            vector<int> goal(mine.size(), -1);
+            {
+                vector<tuple<double, int, int>> scored;   // (价值, 角色序号, 任务序号)
+                for (int a = 0; a < (int)mine.size(); a++) {
+                    auto& u = units[mine[a]];
+                    if (u.flag >= 0) continue;
+                    int p = pos[u.id];
+                    for (int j = 0; j < (int)tasks.size(); j++) {
+                        auto& tk = tasks[j];
+                        double v = 0;
+                        if (j < nFlagTasks) {
+                            int my = dist(p, tk.goal), en = enemyETA(tk.goal);
+                            int ret = (int)tk.value;
+                            if (ret >= 0 && t + my > ret) continue;               // 赶到前就回位了
+                            int home = homeField[me][tk.goal];
+                            if (t + my + home > turns) continue;                   // 来不及送回
+                            double win = my < en ? 1.0 : my == en ? 0.5 : 0.15;
+                            v = 10.0 * win / (my + home + 2);
+                        } else if (j < nFlagTasks + nHunt) {
+                            int e = (int)tk.value, eh = homeField[units[e].team][pos[e]];
+                            int my = dist(p, pos[e]);
+                            if (my > eh + 3) continue;                              // 追不上
+                            v = 6.0 / (my + 3);
+                            if (homeField[me][pos[e]] < 12) v *= 1.5;               // 在自家附近更值得拦
+                        } else {
+                            int my = dist(p, tk.goal);
+                            v = 1.0 / (my + homeField[me][tk.goal] + 6);
+                        }
+                        scored.push_back({v, a, j});
+                    }
+                }
+                sort(scored.rbegin(), scored.rend());
+                vector<int> used(tasks.size(), 0);
+                for (auto& [v, a, j] : scored) {
+                    if (goal[a] >= 0 || used[j] >= tasks[j].cap) continue;
+                    goal[a] = tasks[j].goal; used[j]++;
+                }
+            }
+
+            // ---------- 移动 ----------
+            // threat[c]：下回合可能打到 c 的敌人数（敌人移动一步后在射程内）
+            vector<int> threat(S * S, 0);
+            for (int e : foes) {
+                if (units[e].flag >= 0) continue;
+                set<int> hit;
+                for (int m = 0; m < 5; m++) {
+                    int ex = pos[e] % S + DX[m], ey = pos[e] / S + DY[m];
+                    if (wall(ex, ey)) continue;
+                    int ec = idx(ex, ey);
+                    for (int dy = -2; dy <= 2; dy++) for (int dx = -2; dx <= 2; dx++) {
+                        int x = ex + dx, y = ey + dy;
+                        if (wall(x, y)) continue;
+                        if (canHit(ec, idx(x, y))) hit.insert(idx(x, y));
+                    }
+                }
+                for (int c : hit) threat[c]++;
+            }
+            vector<int> occupied(S * S, -1);
+            for (auto& u : units) if (u.x >= 0) occupied[pos[u.id]] = u.id;
+            vector<char> claimed(S * S, 0);
+            vector<int> newPos(mine.size());
+            vector<int> order(mine.size());
+            iota(order.begin(), order.end(), 0);
+            stable_sort(order.begin(), order.end(), [&](int a, int b) { return units[mine[a]].flag > units[mine[b]].flag; });
+            for (int a : order) {
+                auto& u = units[mine[a]];
+                int p = pos[u.id];
+                const vector<int>& gf = u.flag >= 0 ? homeField[me] : (goal[a] >= 0 ? field(goal[a]) : homeField[me]);
+                // 附近的敌我人数
+                int allies = 0, enemies = 0;
+                for (int b : mine) if (manh(pos[b], p) <= 3 && units[b].flag < 0) allies++;
+                for (int e : foes) if (manh(pos[e], p) <= 3 && units[e].flag < 0) enemies++;
+                bool outnumbered = enemies > allies;
+                double best = 1e18; int bm = 4;
+                for (int m = 0; m < 5; m++) {
+                    int x = p % S + DX[m], y = p / S + DY[m];
+                    if (wall(x, y)) continue;
+                    int c = idx(x, y);
+                    if (claimed[c]) continue;
+                    if (c != p && occupied[c] >= 0 && units[occupied[c]].team != me) continue;
+                    if (gf[c] == INT_MAX) continue;
+                    double cost = gf[c] * 10.0;
+                    if (u.flag >= 0) cost += threat[c] * 6.0;
+                    else if (outnumbered) cost += threat[c] * 12.0;
+                    else if (u.hp <= DMG) cost += threat[c] * 4.0;
+                    if (c != p && occupied[c] >= 0) cost += 3;   // 队友占着，可能走不动
+                    if (cost < best) { best = cost; bm = m; }
+                }
+                int c = idx(p % S + DX[bm], p / S + DY[bm]);
+                newPos[a] = c; claimed[c] = 1;
+                u.respawn = bm;   // 暂存移动方向
+            }
+
+            // ---------- 动作 ----------
+            vector<int> plan(units.size(), 0);   // 已安排的伤害
+            string out = to_string(t);
+            for (int a = 0; a < (int)mine.size(); a++) {
+                auto& u = units[mine[a]];
+                int c = newPos[a];
+                string act = "-";
+                bool onFlag = false;
+                for (auto& f : flags) if (f.x >= 0 && idx(f.x, f.y) == c) onFlag = true;
+                if (u.flag < 0 && onFlag) act = "P";
+                else if (u.flag < 0) {
+                    int bestE = -1; double bv = -1;
+                    for (int e : foes) {
+                        if (!canHit(c, pos[e])) continue;
+                        if (plan[e] >= units[e].hp) continue;      // 已经够打死了
+                        double v = 1.0 + (units[e].flag >= 0 ? 5.0 : 0) + (units[e].hp - plan[e] <= DMG ? 3.0 : 0) + plan[e] / 50.0;
+                        if (v > bv) { bv = v; bestE = e; }
+                    }
+                    if (bestE >= 0) { act = to_string(bestE); plan[bestE] += DMG; }
+                }
+                out += string(" ") + MV[u.respawn] + " " + act;
+            }
+            // 阵亡的角色原地待命
+            string full = to_string(t);
+            {
+                istringstream in(out); string tok; in >> tok;
+                vector<string> parts;
+                while (in >> tok) parts.push_back(tok);
+                int pi = 0;
+                for (auto& u : units) {
+                    if (u.team != me) continue;
+                    if (u.x < 0) full += " S -";
+                    else { full += " " + parts[pi] + " " + parts[pi + 1]; pi += 2; }
+                }
+            }
+            cout << full << endl;
+        }
+    }
+}

package/eval/arena/ctf/workspace/clock.py

@@ -0,0 +1,15 @@
+"""查看开发用时：从解压出本文件的那一刻算起。只读，不写任何文件。"""
+import time
+from pathlib import Path
+
+TARGET, LIMIT = 60, 90  # 分钟
+
+st = Path(__file__).resolve().stat()
+start = getattr(st, "st_birthtime", None) or st.st_ctime  # Windows 为创建时间；Linux 解压时新建文件的 ctime 即解压时刻
+used = max(0.0, time.time() - start) / 60
+if used < TARGET:
+    print(f"已用 {used:.1f} 分钟，距 {TARGET} 分钟还有 {TARGET - used:.1f} 分钟（{LIMIT} 分钟强制交卷）。")
+elif used < LIMIT:
+    print(f"已用 {used:.1f} 分钟，超过 {TARGET} 分钟。可以继续改进，但 {LIMIT} 分钟会强制交卷，还剩 {LIMIT - used:.1f} 分钟。")
+else:
+    print(f"已用 {used:.1f} 分钟，已到 {LIMIT} 分钟，请立即交卷。")