dsh-eval-guard 0.2.2 → 0.3.0

package/eval/arena/tank/bots/half2/qwen-3.8-max.cpp

@@ -0,0 +1,392 @@
+// bot.cpp —— 坦克大战（策略型，不做搜索）
+//
+// 上半场的教训：带 max-min 搜索的版本每回合烧 26 CPU 毫秒却排在基准之下，而成绩表里
+// 第 5 名每回合只用 0.5 毫秒。这个游戏的胜负手是"攻城竞速 + 星星等级差"，是长期规划
+// 问题，2~3 层的战术搜索看不见它，反而让车变得畏缩（任何动作都被假想的全知对手惩罚）。
+// 所以这一版完全不做搜索：分工 + 明确的优先级规则，每回合只用几十微秒。
+//
+// 三条主线：
+//   攻城 —— 一辆车去对方基地的炮位（<=2 格且炮线通 = 每回合稳定 1 点伤害），路上先用炮开砖。
+//   防守 —— 对方有车瞄着我方基地时，派一辆车去挡炮线 / 打那辆车。
+//   争星 —— 场上有星就派一辆确实更近的车去吃；2 级快速型（5 血、不装填、两步）能碾压 1 血车。
+#include "tank.hpp"
+
+#include <algorithm>
+#include <cstring>
+
+using namespace tank;
+
+static const int INF = 9999;
+
+// ---------------------------------------------------------------- 场
+static int g_datt[2][CELLS];          // [seat] 到"能打到对方基地的炮位"的代价（砖算 3 步）
+static int g_dsup[CELLS];             // 到最近补给点的步数
+static int g_dsp[MAX_SUPPLY][CELLS];  // 到第 k 个补给点的步数（分工时按点分配，避免都挤一个点）
+static int g_tgt[6];                  // R_STAR 的车去哪个补给点
+static int g_dhunt[2][CELLS];         // [seat] 到最近敌方坦克的步数
+static int g_ddef[2][CELLS];          // [seat] 到拦截点（挡炮线 / 打攻城车）的步数
+static bool g_need_def[2];
+static int g_attacker_dist[2];        // [seat] 对方攻城车到我方基地的距离（没有则 INF）
+static unsigned char g_threat[CELLS]; // 本回合会有子弹飞到这格
+static unsigned char g_exp[2][CELLS]; // [seat] 这格在对方能开炮的车的炮线上
+static unsigned char g_mine[CELLS];   // 这格有我方车
+static bool g_has_star;
+
+enum Role { R_SIEGE = 0, R_DEF, R_STAR, R_HUNT };
+static int g_role[6];
+
+// ---------------------------------------------------------------- 基础几何
+// 连坦克一起看：从 pos 到 base 的炮线是否通，返回距离。
+static int shot_now(const State& s, int pos, int base) {
+    int best = INF;
+    for (int d = 0; d < 4; ++d) {
+        int c = pos, n = 0;
+        for (;;) {
+            c += DIR_DELTA[d];
+            if (++n > 8) break;
+            if (c == base) { if (n < best) best = n; break; }
+            const uint8_t g = s.grid[c];
+            if (g != EMPTY && g != WATER) break;
+            if (tank_at(s, c) >= 0) break;
+        }
+    }
+    return best;
+}
+
+// 只看地形：从 pos 打到 base 的攻城代价（最多允许一堵砖），打不到返回 INF。
+static int ray_cost(const State& s, int pos, int base) {
+    int best = INF;
+    for (int d = 0; d < 4; ++d) {
+        int c = pos, n = 0, nb = 0;
+        for (;;) {
+            c += DIR_DELTA[d];
+            if (++n > 5) break;
+            if (c == base) {
+                const int cost = 3 * nb + 2 * (n > 2 ? n - 2 : 0);
+                if (cost < best) best = cost;
+                break;
+            }
+            const uint8_t g = s.grid[c];
+            if (g == EMPTY || g == WATER) continue;
+            if (g == BRICK) { if (++nb > 1) break; continue; }
+            break;
+        }
+    }
+    return best;
+}
+
+// ---------------------------------------------------------------- 场计算
+static void bfs_cost(const State& s, const unsigned char* src, int* dist) {
+    static int q[CELLS];
+    for (int c = 0; c < CELLS; ++c) dist[c] = INF;
+    int head = 0, tail = 0;
+    for (int c = 0; c < CELLS; ++c)
+        if (src[c]) { dist[c] = 0; q[tail++] = c; }
+    while (head < tail) {
+        const int c = q[head++];
+        for (int k = 0; k < 4; ++k) {
+            const int nb = c + DIR_DELTA[k];
+            const uint8_t g = s.grid[nb];
+            if (g != EMPTY && g != BRICK) continue;
+            if (dist[nb] > dist[c] + 1) { dist[nb] = dist[c] + 1; q[tail++] = nb; }
+        }
+    }
+}
+
+static void compute_fields(const State& s, int me) {
+    static unsigned char src[CELLS];
+    for (int c = 0; c < CELLS; ++c) {
+        g_threat[c] = 0; g_exp[0][c] = 0; g_exp[1][c] = 0; g_mine[c] = 0; src[c] = 0;
+    }
+    for (int i = 0; i < 6; ++i)
+        if (s.tank[i].alive && seat_of(i) == me) g_mine[s.tank[i].pos] = 1;
+
+    // 已在飞的子弹：本回合两个小步会飞到哪
+    for (int k = 0; k < s.n_bullets; ++k) {
+        const Bullet& b = s.bullet[k];
+        int c = b.pos;
+        for (int st = 0; st < 2; ++st) {
+            c += DIR_DELTA[b.dir];
+            if (c < 0 || c >= CELLS) break;
+            g_threat[c] = 1;
+            const uint8_t g = s.grid[c];
+            if (g != EMPTY && g != WATER) break;
+            if (tank_at(s, c) >= 0) break;
+        }
+    }
+    // 对方能开炮的车，炮线前 5 格是危险格（站上去就是面对面互射，子弹互相抵消、白送节奏）
+    for (int i = 0; i < 6; ++i) {
+        if (!s.tank[i].alive || !can_fire(s, i)) continue;
+        const int victim = 1 - seat_of(i);
+        for (int d = 0; d < 4; ++d) {
+            int c = s.tank[i].pos;
+            for (int n = 0; n < 5; ++n) {
+                c += DIR_DELTA[d];
+                if (c < 0 || c >= CELLS) break;
+                const uint8_t g = s.grid[c];
+                if (g == BRICK || g == STEEL || g == OUTSIDE || g == BASE0 || g == BASE1) break;
+                g_exp[victim][c] = 1;
+                if (tank_at(s, c) >= 0) break;
+            }
+        }
+    }
+
+    // 攻城场：炮位 = 从这格沿某方向最多 5 格、途中最多一堵砖就能打到对方基地
+    for (int seat = 0; seat < 2; ++seat) {
+        const int base = s.base_pos[1 - seat];
+        for (int c = 0; c < CELLS; ++c) src[c] = 0;
+        const int n = s.P.size;
+        for (int y = 0; y < n; ++y)
+            for (int x = 0; x < n; ++x) {
+                const int c = cell_of(x, y);
+                if (s.grid[c] != EMPTY) continue;
+                if (ray_cost(s, c, base) < INF) src[c] = 1;
+            }
+        bfs_cost(s, src, g_datt[seat]);
+    }
+
+    // 补给点场：既算"到最近补给点"，也算"到第 k 个补给点"
+    for (int c = 0; c < CELLS; ++c) src[c] = 0;
+    for (int k = 0; k < s.n_supply; ++k) src[s.supply[k]] = 1;
+    bfs_cost(s, src, g_dsup);
+    for (int k = 0; k < s.n_supply; ++k) {
+        for (int c = 0; c < CELLS; ++c) src[c] = 0;
+        src[s.supply[k]] = 1;
+        bfs_cost(s, src, g_dsp[k]);
+    }
+    g_has_star = s.star_mask != 0;
+
+    // 猎杀场：到最近的敌方坦克
+    for (int seat = 0; seat < 2; ++seat) {
+        for (int c = 0; c < CELLS; ++c) src[c] = 0;
+        for (int i = 0; i < 6; ++i)
+            if (s.tank[i].alive && seat_of(i) != seat) src[s.tank[i].pos] = 1;
+        bfs_cost(s, src, g_dhunt[seat]);
+    }
+
+    // 拦截场：对方有车瞄着 seat 的基地时，把那些车和它们炮线上的格子当目标
+    for (int seat = 0; seat < 2; ++seat) {
+        for (int c = 0; c < CELLS; ++c) src[c] = 0;
+        const int mybase = s.base_pos[seat];
+        int nd = 0, bestd = INF;
+        for (int i = 0; i < 6; ++i) {
+            if (!s.tank[i].alive || seat_of(i) == seat) continue;
+            const int d = shot_now(s, s.tank[i].pos, mybase);
+            if (d > 5) continue;
+            ++nd;
+            if (d < bestd) bestd = d;
+            src[s.tank[i].pos] = 1;
+            for (int k = 0; k < 4; ++k) {   // 炮线上、我和它之间的空格：站上去就挡住这一炮
+                int c = s.tank[i].pos, n = 0;
+                for (;;) {
+                    c += DIR_DELTA[k];
+                    if (++n >= d) break;
+                    if (s.grid[c] != EMPTY) break;
+                    src[c] = 1;
+                }
+            }
+        }
+        g_need_def[seat] = nd > 0;
+        g_attacker_dist[seat] = bestd;
+        if (nd) bfs_cost(s, src, g_ddef[seat]);
+        else for (int c = 0; c < CELLS; ++c) g_ddef[seat][c] = INF;
+    }
+}
+
+// ---------------------------------------------------------------- 打分
+// 这一炮打出去会打到什么。
+static int fire_score(const State& s, int i, int d) {
+    const int me = seat_of(i), foe = 1 - me;
+    int c = s.tank[i].pos;
+    int n = 0, bricks = 0;
+    for (;;) {
+        c += DIR_DELTA[d];
+        if (++n > 16) break;
+        const int v = tank_at(s, c);
+        if (v >= 0) {
+            if (seat_of(v) != me) {
+                int sc = 900 - 40 * n;
+                if (s.tank[v].hp <= 1) sc += 500;          // 一发带走
+                if (s.tank[v].level >= 1) sc += 200;       // 打掉对面的等级更值
+                return sc;
+            }
+            return -4000;                                  // 打队友
+        }
+        if (c == s.base_pos[foe]) return bricks == 0 ? (20000 - 300 * n) : 1200;
+        if (c == s.base_pos[me]) return -20000;            // 打自己基地
+        const uint8_t g = s.grid[c];
+        if (g == BRICK) {
+            if (++bricks > 1) return 40;
+            // 打掉这堵砖之后炮线就通了？继续往前看能不能到对方基地
+            int cc = c, nn = n;
+            for (;;) {
+                cc += DIR_DELTA[d];
+                if (++nn > 6) break;
+                if (cc == s.base_pos[foe]) return 1700 - 120 * nn;
+                if (cc == s.base_pos[me]) return -3000;
+                const uint8_t g2 = s.grid[cc];
+                if (g2 == EMPTY || g2 == WATER) continue;
+                if (tank_at(s, cc) >= 0) break;
+                break;
+            }
+            return 90;
+        }
+        if (g == STEEL) return (s.tank[i].level >= 2) ? 60 : -60;
+        if (g == OUTSIDE) return -30;
+        // 空地 / 水：继续飞
+    }
+    return -20;
+}
+
+static inline int goal_dist(const State& s, int i, int c) {
+    int g;
+    switch (g_role[i]) {
+        case R_DEF:   g = g_ddef[seat_of(i)][c]; break;
+        case R_STAR:  g = (g_tgt[i] < s.n_supply) ? g_dsp[g_tgt[i]][c] : g_dsup[c]; break;
+        case R_HUNT:  g = g_dhunt[seat_of(i)][c]; break;
+        default:      g = g_datt[seat_of(i)][c]; break;
+    }
+    if (g >= INF) g = 120;
+    if (g > 120) g = 120;
+    return g;
+}
+
+static int score_cmd(const State& s, int i, Cmd cmd) {
+    const Tank& t = s.tank[i];
+    const int me = seat_of(i);
+
+    if (is_fire(cmd)) return fire_score(s, i, cmd - 5);
+
+    if (cmd == STAY) {
+        int sc = 0;
+        if (g_threat[t.pos]) sc -= 700;
+        if (g_exp[me][t.pos]) sc -= 90;
+        if (g_has_star && star_at(s, t.pos) && t.level < s.P.max_level) sc += 3000;
+        // 已经占住补给点、就等这批星出在脚下：别动
+        if (g_role[i] == R_STAR && g_tgt[i] < s.n_supply && t.pos == s.supply[g_tgt[i]]) sc += 1500;
+        return sc;
+    }
+
+    const int d1 = is_move(cmd) ? cmd - 1 : (cmd - 9) >> 2;
+    const int p = t.pos;
+    const int p1 = p + DIR_DELTA[d1];
+    int mid = p1, fin = p1;
+    if (s.grid[p1] != EMPTY) { mid = p; fin = p; }        // 第一步走不成
+    if (is_move2(cmd)) {
+        const int d2 = (cmd - 9) & 3;
+        const int p2 = mid + DIR_DELTA[d2];
+        if (s.grid[p2] == EMPTY) fin = p2;
+    }
+
+    int sc = 130 * (goal_dist(s, i, p) - goal_dist(s, i, fin));
+
+    if (g_threat[fin]) sc -= 900;                          // 走进子弹的落点（必中，一定要躲）
+    if (g_threat[mid]) sc -= 500;
+    if (g_threat[p]) sc += 400;                            // 离开子弹的落点
+    // 面对面互射 = 子弹互相抵消、谁也不赚。但这只是"不划算"，不能压过推进：
+    // 上半场就是这一项给得太大，结果三辆车在原地横着挪、永远到不了对方基地。
+    if (g_exp[me][fin]) sc -= 0;
+    if (g_exp[me][p]) sc += 0;
+
+    if (g_mine[fin]) sc -= 200;                            // 和队友抢格（会双双走不成）
+    if (g_has_star && star_at(s, fin) && t.level < s.P.max_level) sc += 2500;
+    if (is_move2(cmd) && fin != mid) sc += 25;             // 快速型一回合两步
+    return sc;
+}
+
+// ---------------------------------------------------------------- 分工
+// 下一批星星还要几个回合末才出（已经出在场上则返回 0）。
+static int star_wait(const State& s) {
+    if (s.star_mask) return 0;
+    const int nt = s.turn + 1;
+    if (nt < s.P.supply_first) return s.P.supply_first - nt;
+    const int k = (nt - s.P.supply_first) % s.P.supply_period;
+    return k == 0 ? 0 : s.P.supply_period - k;
+}
+
+static void assign_roles(const State& s, int me) {
+    for (int k = 0; k < 6; ++k) { g_role[k] = R_HUNT; g_tgt[k] = 0; }
+    int alive[3], na = 0;
+    for (int t = 0; t < 3; ++t) {
+        const int i = tank_id(me, t);
+        if (s.tank[i].alive) alive[na++] = i;
+    }
+    if (na == 0) return;
+
+    auto tt = [&](int i, const int* field) {
+        int d = field[s.tank[i].pos];
+        if (d >= INF) d = 200;
+        return double(d) / s.P.types[type_of(i)].speed;
+    };
+    bool used[6] = {};
+
+    // ---- 1) 攻城永远先留一辆 ----
+    // 基地每回合最多掉 1 血，两边都在攻城就是平局节奏；只有我攻城、对方不攻才是赢。
+    // 所以哪怕基地正挨打，也必须留一辆去啃对方基地，否则会输在基地血量这个第一顺位比较项上。
+    {
+        int best = -1; double bv = 1e18;
+        for (int k = 0; k < na; ++k) { const int i = alive[k]; const double v = tt(i, g_datt[me]); if (v < bv) { bv = v; best = i; } }
+        if (best >= 0) { g_role[best] = R_SIEGE; used[best] = true; }
+    }
+
+    // ---- 2) 防守：对方有车瞄着我方基地 ----
+    if (g_need_def[me]) {
+        int best = -1; double bv = 1e18;
+        for (int k = 0; k < na; ++k) { const int i = alive[k]; if (used[i]) continue; const double v = tt(i, g_ddef[me]); if (v < bv) { bv = v; best = i; } }
+        if (best >= 0) { g_role[best] = R_DEF; used[best] = true; }
+    }
+
+    // ---- 3) 争星：只用剩下的一辆 ----
+    // 这是本局的胜负手（2 级车能碾压 1 血车），而且必须按"点"分配，否则几辆车挤同一个点。
+    // 没出星但一批快到了也要提前占位：出星那回合站在点上，下一回合末就吃到。
+    const int wait = star_wait(s);
+    if (wait <= 12) {
+        int nk = 0, ks[MAX_SUPPLY];
+        for (int k = 0; k < s.n_supply; ++k) {
+            const bool has = (s.star_mask >> k) & 1;
+            if (has || wait <= 12) ks[nk++] = k;
+        }
+        bool taken[MAX_SUPPLY] = {}; int sent = 0;
+        for (int a = 0; a < na; ++a) {
+            const int i = alive[a];
+            if (used[i] || s.tank[i].level >= s.P.max_level) continue;
+            int bk = -1; double bv = 1e18;
+            for (int q = 0; q < nk; ++q) {
+                const int k = ks[q];
+                if (taken[k]) continue;
+                const double v = tt(i, g_dsp[k]);
+                const double adj = ((s.star_mask >> k) & 1) ? v : v + 1.0;   // 已出星的点更急
+                if (adj < bv) { bv = adj; bk = k; }
+            }
+            if (bk < 0) continue;
+            taken[bk] = true;
+            g_role[i] = R_STAR; g_tgt[i] = bk; used[i] = true;
+            if (++sent >= 2) break;
+        }
+    }
+    // 剩下的：也去攻城（打基地才是胜负），别在中路和对面换命
+    for (int k = 0; k < na; ++k) if (!used[alive[k]]) g_role[alive[k]] = R_SIEGE;
+}
+
+// ---------------------------------------------------------------- 对外接口
+void init(const State& s, int me) { (void)s; (void)me; }
+
+Orders decide(const State& s, int me) {
+    Orders orders;
+    compute_fields(s, me);
+    assign_roles(s, me);
+
+    for (int t = 0; t < 3; ++t) {
+        const int i = tank_id(me, t);
+        if (!s.tank[i].alive) { orders.cmd[t] = STAY; continue; }
+        Cmd list[N_CMDS];
+        const int n = legal_commands(s, i, list);
+        int bestk = 0, bestsc = score_cmd(s, i, list[0]);
+        for (int k = 1; k < n; ++k) {
+            const int sc = score_cmd(s, i, list[k]);
+            if (sc > bestsc) { bestsc = sc; bestk = k; }
+        }
+        orders.cmd[t] = list[bestk];
+    }
+    return orders;
+}

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

@@ -0,0 +1,24 @@
+# 复现正式赛
+
+| 文件 | 内容 |
+|---|---|
+| `tournament.py`、`bt.py`、`schedule.py` | 这一集的对战平台：冻结赛程、编译、绑核、逐批测速、可中断续跑、Bradley–Terry 评分。和比赛时逐字节相同。它是为 1 对 1 重写的版本，和仓库根目录 `arena/`（第 3 集起的多人平台）不是同一份 |
+| `halftime.json`、`final.json`、`progress.json` | 中场赛、终场赛、进步赛的配置。程序路径换成了仓库里的相对路径，`seed` 写的是当时抽到的赛程种子，去掉了本机编译器的路径（不写时先看环境变量 `CXX`，再找 `PATH` 里的 g++；只把 w64devkit 放进仓库 `tools/` 的，先设好 `CXX`，见 `../README.md` 的"马上看 / 马上玩"）。名字（`Astra`、`Opus@1` 等）没有改，赛程按名字排序，改了就不是同一份赛程 |
+| `sparring.cpp` | 出题方参照：出题方写的搜索型 bot，成绩表里的 `sparring`。这是比赛时实际编译的文件（源码前面由赛事脚本加了 4 个宏，固定每回合的搜索量，所以它的结果不随机器状态变化）。比赛时不发给选手 |
+
+在本目录运行（终场赛在比赛电脑上约 70 分钟；可以随时中断，再运行同一条命令接着跑）：
+
+```bash
+python tournament.py plan final.json        # 冻结赛程，写到 run-final/赛程.json
+python tournament.py run  run-final         # 开打
+python tournament.py rate run-final         # 出成绩：run-final/成绩.md
+```
+
+中场赛、进步赛把 `final` 换成 `halftime`、`progress`。进步赛的进步幅度要和中场赛合并拟合，比赛时由主办方的赛事脚本完成，算法见 `../results/附表.md` 的说明。
+
+需要注意：
+
+- **选手包目录必须是纯英文路径**：`tournament.py` 会拒绝含中文等非 ASCII 字符的 `kit` 路径（Windows 上的 g++ 在某些区域设置下打不开这种路径）。仓库放在中文路径下时，把整个 `tank/` 复制到纯英文路径再跑。
+- 地图、座位、对阵可以一模一样地重建：开源前用这三份配置重建赛程，`games_sha` 和原赛程完全相同。
+- 逐局结果不一定完全相同。对局本身没有随机，但很多 bot 按 `budget_left()` 决定搜到哪里停，机器状态不同搜得深浅就不同。开源前在比赛电脑上重打终场赛的前 352 局，338 局逐回合相同，347 局胜负相同。总排名应当一致，相邻并列的名次可能互换。
+- 默认只用大核、每局两个 bot 各占一个物理核（`pin: big`），同时打几局由本机的核数决定。`python tournament.py cpus final.json` 可以先看绑核方案。用量的上限是 50 CPU 毫秒，机器太忙会让按时间停的 bot 搜得更浅。

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

@@ -0,0 +1,218 @@
+"""Bradley–Terry 实力值（1 对 1）。
+
+口径：
+- 胜记 1，平记 0.5；
+- 每对交过手的程序加一局虚拟平局（全胜、全负时实力值不会趋于无穷）；
+- 基准 = 0，实力强 10 倍记 +400（和 Elo 同一把尺：差 400 分 ≈ 10:1）；弱于基准是负数；
+- 区间：按地图整块重抽样（同一张图上的所有对局一起抽，一起放回），每次重新拟合，取 2.5% 和 97.5% 分位；
+- 并列：按实力值排好之后，相邻两名“实力值之差”的 95% 区间含 0 就算并列（并列可以连成一串）。
+  差的区间是在每次重抽样里直接算差得到的。不用“两人各自的区间是否重叠”来判：各自的区间里还含着基准自身的噪声，
+  两个人对基准的偏差又是一起动的，用它判并列偏保守（同样的数据，能分开的差距大约要大一倍）。
+
+输入的一局是 {"map": 地图的标识, "a": 名字, "b": 名字, "score": a 的得分（1 / 0.5 / 0）}。
+"map" 可以是任何可哈希的值；几场比赛合在一起拟合时，用 (哪一场, 图号) 这样的元组，重抽样会在每一场内部各抽各的。
+"""
+from __future__ import annotations
+
+import math
+import random
+from collections import defaultdict
+
+SCALE = 400 / math.log(10)
+
+
+def tally(rows):
+    """按地图汇总：{地图: {(a, b): [局数, a 的得分]}}，其中 a < b。"""
+    by_map = defaultdict(lambda: defaultdict(lambda: [0.0, 0.0]))
+    for r in rows:
+        a, b, s = r["a"], r["b"], float(r["score"])
+        if a == b:
+            continue
+        if a > b:
+            a, b, s = b, a, 1.0 - s
+        cell = by_map[r["map"]][a, b]
+        cell[0] += 1.0
+        cell[1] += s
+    return by_map
+
+
+def merge(by_map, maps):
+    """把若干张图（可重复）的汇总加在一起。"""
+    total = defaultdict(lambda: [0.0, 0.0])
+    for m in maps:
+        for pair, (g, w) in by_map[m].items():
+            cell = total[pair]
+            cell[0] += g
+            cell[1] += w
+    return total
+
+
+def fit(pairs, names, anchor, virtual=1.0, start=None, tol=1e-9, max_iter=200000):
+    """pairs：{(a, b): [局数, a 的得分]}。返回 {名字: 实力值}；没有任何对局的名字是 None。
+
+    virtual：每对交过手的程序加几局虚拟平局。start：上一次的解（对数实力），用来热启动。"""
+    games = {}
+    for (a, b), (g, w) in pairs.items():
+        if g > 0:
+            games[a, b] = (g + virtual, w + virtual / 2)
+    active = sorted({n for pair in games for n in pair})
+    if anchor not in active:
+        raise ValueError(f"基准 {anchor} 没有任何对局，定不了零点")
+    _check_connected(games, active)
+    wins = dict.fromkeys(active, 0.0)
+    edges = []
+    for (a, b), (g, w) in games.items():
+        wins[a] += w
+        wins[b] += g - w
+        edges.append((a, b, g))
+    p = {n: math.exp((start or {}).get(n) or 0.0) for n in active}
+    for _ in range(max_iter):
+        denom = dict.fromkeys(active, 0.0)
+        for a, b, g in edges:
+            v = g / (p[a] + p[b])
+            denom[a] += v
+            denom[b] += v
+        new = {n: wins[n] / denom[n] for n in active}
+        center = sum(math.log(v) for v in new.values()) / len(new)
+        scale = math.exp(-center)
+        delta = 0.0
+        for n in active:
+            new[n] *= scale
+            delta = max(delta, abs(math.log(new[n] / p[n])))
+        p = new
+        if delta < tol:
+            break
+    origin = math.log(p[anchor])
+    out = dict.fromkeys(names)
+    for n in active:
+        out[n] = SCALE * (math.log(p[n]) - origin)
+    return out
+
+
+def _check_connected(games, active):
+    """对战关系必须连成一片，否则几块之间的实力值没法比。"""
+    parent = {n: n for n in active}
+
+    def find(x):
+        while parent[x] != x:
+            parent[x] = parent[parent[x]]
+            x = parent[x]
+        return x
+
+    for a, b in games:
+        parent[find(a)] = find(b)
+    roots = {find(n) for n in active}
+    if len(roots) > 1:
+        raise ValueError(f"对战关系分成了 {len(roots)} 块，互相之间没有交手，没法放在一把尺上")
+
+
+def rate(rows, names, anchor, boot=1000, seed=0, virtual=1.0, diffs=None, stats=None):
+    """返回 {名字: {"rating", "low", "high"}}（没有对局的名字三项都是 None），以及实际重抽样的次数。
+
+    区间按地图整块重抽样。地图标识是元组时，按元组的第一项分层（每一层内部各抽各的，层的图数不变）。
+    diffs：[(a, b), ...]。给了它就多返回一项 {(a, b): {"diff", "low", "high"}}，是 a 减 b 的实力值之差和它的区间
+    （在每次重抽样里算差，比两个区间相减准）。
+    stats：{键: 函数}。函数收到一次拟合的结果 {名字: 实力值}，返回一个数（算不了返回 None），比如"几个程序实力值的标准差"。
+    给了它就在最后多返回一项 {键: {"value", "low", "high", "sd", "n"}}：value 是用全部数据算的，low / high 是重抽样的
+    95% 区间，sd 是这个数在重抽样里的标准差（也就是它的抽样误差），n 是算出来的次数。"""
+    by_map = tally(rows)
+    maps = list(by_map)
+    point = fit(merge(by_map, maps), names, anchor, virtual)
+    start = {n: v / SCALE for n, v in point.items() if v is not None}
+    strata = defaultdict(list)
+    for m in maps:
+        strata[m[0] if isinstance(m, tuple) else None].append(m)
+    rng = random.Random(seed)
+    samples = defaultdict(list)
+    done = 0
+    for _ in range(boot if len(maps) >= 2 else 0):
+        pick = []
+        for group in strata.values():
+            pick += rng.choices(group, k=len(group))
+        try:
+            est = fit(merge(by_map, pick), names, anchor, virtual, start=start, tol=1e-7)
+        except ValueError:
+            continue        # 这次抽到的图里基准没有出场或者对战关系断开了（只在图极少时会发生）
+        done += 1
+        for n, v in est.items():
+            if v is not None:
+                samples[n].append(v)
+        for a, b in diffs or ():
+            if est.get(a) is not None and est.get(b) is not None:
+                samples[a, b].append(est[a] - est[b])
+        for key, fn in (stats or {}).items():
+            value = fn(est)
+            if value is not None:
+                samples["stat", key].append(value)
+
+    def interval(key, v):
+        s = sorted(samples[key])
+        if len(s) < 20:
+            return None, None
+        low, high = s[int(0.025 * (len(s) - 1))], s[int(math.ceil(0.975 * (len(s) - 1)))]
+        return min(low, v), max(high, v)
+
+    out = {}
+    for n in names:
+        v = point.get(n)
+        if v is None:
+            out[n] = {"rating": None, "low": None, "high": None}
+            continue
+        low, high = interval(n, v)
+        out[n] = {"rating": v, "low": low, "high": high}
+    stat_out = {}
+    for key, fn in (stats or {}).items():
+        value = fn(point)
+        s = samples["stat", key]
+        low, high = interval(("stat", key), value) if value is not None else (None, None)
+        sd = None
+        if len(s) >= 20:
+            mean = sum(s) / len(s)
+            sd = math.sqrt(sum((x - mean) ** 2 for x in s) / (len(s) - 1))
+        stat_out[key] = {"value": value, "low": low, "high": high, "sd": sd, "n": len(s)}
+    if diffs is None:
+        return (out, done) if stats is None else (out, done, stat_out)
+    diff_out = {}
+    for a, b in diffs:
+        if point.get(a) is None or point.get(b) is None:
+            diff_out[a, b] = {"diff": None, "low": None, "high": None}
+            continue
+        d = point[a] - point[b]
+        low, high = interval((a, b), d)
+        diff_out[a, b] = {"diff": d, "low": low, "high": high}
+    return (out, done, diff_out) if stats is None else (out, done, diff_out, stat_out)
+
+
+def tie_groups_by_diff(order, diffs):
+    """order：按实力值从高到低排好的名字。diffs：rate(..., diffs=相邻的各对) 返回的 {(高的, 低的): {"diff", "low", "high"}}。
+
+    相邻两名之差的 95% 区间含 0（下界 ≤ 0）就并列；并列可以连成一串。差的区间算不出来（图太少）时不并列。
+    返回 [[一组并列的名字], ...]。"""
+    groups = []
+    for n in order:
+        if groups:
+            d = diffs.get((groups[-1][-1], n))
+            if d is not None and d["low"] is not None and d["low"] <= 0.0:
+                groups[-1].append(n)
+                continue
+        groups.append([n])
+    return groups
+
+
+def tie_groups(order, ratings):
+    """旧判法，成绩表已经不用它，留着做对比：相邻两名各自的区间有重叠就并列。返回 [[一组并列的名字], ...]。"""
+    groups = []
+    for n in order:
+        r = ratings[n]
+        if groups:
+            prev = ratings[groups[-1][-1]]
+            if None not in (r["low"], r["high"], prev["low"], prev["high"]) and r["high"] >= prev["low"]:
+                groups[-1].append(n)
+                continue
+        groups.append([n])
+    return groups
+
+
+def expected(ra, rb):
+    """实力值 ra 的程序对 rb 的程序的期望得分率。"""
+    return 1.0 / (1.0 + 10 ** ((rb - ra) / 400.0))