Files
airdef/tools/raid_bench.py
T
chexit c08b737296
build / mod (push) Failing after 32s
Reproducible raid/replay render bench and #147 instancing measurements
tools/raid_bench.py (+ tests): the #147 step-0 driver replaces the #126
scratch script. One battle at fixed ticks (waves inside resident terrain —
far waves stall at the unknown-chunk edge and no fight happens), fingerprint
chat lines at control ticks, then the raid's own recording replayed. Both
render paths are benched on the SAME recording in ONE process via the
engine's diagnostic `model-instancing off|on` toggle (cross-process battles
diverge in event timing: 16 vs 32 kills at one control tick), pairs in
alternating order; idle cold/warm, mid-battle window, reload (F3+T), replay
seek, away-camera checks, and static off/on stills for pixel parity
(hd_bench motion-mask methodology). report.json carries gitlinks, device,
mod_models counters, CPU/GPU p50/p95/p99/max, raw frame times, >25/33 ms
frame counts, guest fuel and streaming queues.

Engine gitlink: one mass mod-model group GPU-instanced (retained mesh per
pack generation, current/previous pose/id/light instance stream shared by
main, motion and shadow passes, per-vertex fallback to parity, runtime
diagnostic toggle, stats raw + guest fuel reporting).

Measurements: docs/measurements/issue-147-instancing/ (M5/Metal, 2560x1440;
RTX 3060 pending). docs/REPO-MAP.md and docs/ENGINE.md pin updated.

Co-Authored-By: Kimi Code <noreply@moonshot.ai>
2026-11-21 11:39:43 +03:00

603 lines
29 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#!/usr/bin/env python3
"""Воспроизводимый драйвер замера рендера AirDef (#147, шаг 0): один бой по
фиксированным тикам и прогон той же записи (replay) для изоляции рендера, плюс idle.
python3 tools/raid_bench.py --label m5 --out run-home-bench/out/147-m5
python3 tools/raid_bench.py --compare run-home-bench/out/147-m5/report.json
python3 tools/raid_bench.py --stills run-home-bench/out/147-m5
Каждый прогон: свежий HORIZON_HOME в папке вывода, копия мира Polygon из run-home/saves,
собранный airdef.hmod, игра офскрин на своём сокете (чужой игре run-home/ctl.sock не
мешаем). Сцена фиксирована: tp, полдень, время и погода заморожены, HD, HUD скрыт.
Бой выдаётся по тикам (не по стене): батареи, затем волны на указанных тиках;
отпечаток боя — строки `airdef stats` на контрольных тиках.
После боя играется его собственная запись (`airdef replay full`): призраки летят по
записанным трекам. Оба пути рендера замеряются на ОДНОЙ записи в ОДНОМ процессе:
драйвер переключает `model-instancing off|on` (диагностический toggle движка) и
проигрывает запись заново каждым путём; пары чередуются по порядку (проверка
прогрева). Межпроцессные бои расходятся по таймингу событий (стриминг/акустика),
поэтому сравнение разных записей не было бы сравнением рендера — первый вариант
драйвера это показал (16 против 32 сбитых на одном контрольном тике).
Окна: idle cold (сразу после загрузки), idle warm (после сходимости LOD), бой,
replay_before/replay_after (+ вторая пара). Проверки: reload (F3+T), seek (стрелки
в replay), камера в сторону от моделей (тени и чужая камера обязаны их рисовать),
статичные кадры off/on для пиксельного паритета (--stills, методика hd_bench).
Отчёт: report.json с gitlink'ами, устройством, счётчиками mod_models, CPU/GPU
p50/p95/p99/max и сырыми frame time, плюс скриншоты.
Только стандартная библиотека. Коды выхода: 0 — прогон снят; 2 — ошибка запуска/аргументов.
"""
import argparse
import datetime
import json
import math
import os
import platform
import re
import shutil
import subprocess
import sys
import threading
import time
from pathlib import Path
ROOT = Path(__file__).resolve().parent.parent
SAVES = ROOT / "run-home" / "saves"
CTL = ROOT / "horizon" / "target" / "fast" / "horizon-ctl"
HMOD_CANDIDATES = (
ROOT / "airdef-mod" / "target" / "horizon-mod" / "airdef.hmod",
ROOT / "airdef.hmod",
)
# Поза и свет как в замере #126 (docs/measurements/issue-126-first-stage/README.md).
POSE = (40, 76, 40, 135, 25)
DAY_TIME = 6000
# Расписание боя: (тик от T0, команда). T0 — тик начала боя после прогрева сцены.
# Дальности волн — в пределах резидентного террейна (render distance 12 = 192 блока):
# дальше дроны ждут ответа земли на краю неизвестных чанков и бой не состоится
# (sim/terrain.rs, #61); в пределах — бой детерминирован по тикам.
BATTLE_SCHEDULE = (
(20, "airdef deploy s400"), (20, "airdef deploy s400"),
(22, "airdef deploy patriot"), (22, "airdef deploy patriot"),
(24, "airdef deploy pantsir"), (24, "airdef deploy pantsir"),
(26, "airdef deploy gepard"), (26, "airdef deploy gepard"),
(28, "airdef deploy nasams"), (28, "airdef deploy nasams"),
(30, "airdef deploy irist"), (30, "airdef deploy irist"),
(32, "airdef deploy tor"), (32, "airdef deploy tor"),
(60, "airdef wave shahed 40 160"),
(140, "airdef wave kh101 16 180"),
(220, "airdef wave mix 24 140"),
)
# Контрольные тики отпечатка боя (от T0) и конец боя.
FINGERPRINT_TICKS = (400, 800, 1200)
BATTLE_END = 1400
# Окна замера, секунд (bench N): idle cold/warm, бой, replay.
BENCH_SECONDS = {"idle_cold": 4, "idle_warm": 6, "battle": 10, "replay": 12}
SETTLE_TICKS = 500 # 25 с: LOD сходится, как в методике #126
REPLAY_WARM_TICKS = 100 # 5 с записи до окна замера
STATS_RE = re.compile(r"В воздухе: (\d+), ракет: (\d+), ПВО: (\d+), сбито: (\d+), поражений: (\d+)")
class BenchError(RuntimeError):
pass
def die(msg):
raise BenchError(msg)
def percentile(values, p):
"""Перцентиль как в FrameStats::summary (ceil-индекс, 1-based)."""
if not values:
return None
s = sorted(values)
i = max(1, min(len(s), math.ceil(len(s) * p)))
return s[i - 1]
def frame_summary(raw):
"""p50/p95/p99/max и счётчики худших кадров по сырым временам, мс."""
out = {}
for key in ("frame_ms", "cpu_ms", "gpu_ms"):
v = raw.get(key) or []
out[key] = {
"n": len(v),
"avg_ms": sum(v) / len(v) if v else None,
"p50_ms": percentile(v, 0.5),
"p95_ms": percentile(v, 0.95),
"p99_ms": percentile(v, 0.99),
"max_ms": max(v) if v else None,
}
frames = raw.get("frame_ms") or []
out["frames_over_25ms"] = sum(1 for f in frames if f > 25.0)
out["frames_over_33ms"] = sum(1 for f in frames if f > 33.0)
return out
def git_sha(cwd):
r = subprocess.run(["git", "rev-parse", "HEAD"], cwd=cwd, capture_output=True, text=True)
return r.stdout.strip() if r.returncode == 0 else None
def git_branch(cwd):
r = subprocess.run(["git", "branch", "--show-current"], cwd=cwd, capture_output=True, text=True)
return r.stdout.strip() or None
class Driver:
"""Одна игра на своём сокете; команды horizon-ctl и ожидание по тикам."""
def __init__(self, out, game, resources, mod, extra_env, width, height):
self.out = Path(out).resolve()
self.home = self.out / "home"
self.sock = self.out / "c.sock"
self.log = self.out / "c.log"
self.game = Path(game).resolve()
self.resources = Path(resources).resolve()
self.mod = Path(mod).resolve()
self.extra_env = dict(extra_env)
self.width, self.height = width, height
self.t0 = None
# --- запуск ---
def prepare(self):
if self.home.exists():
shutil.rmtree(self.home)
(self.home / "saves").mkdir(parents=True)
src = SAVES / "Polygon"
if not src.is_dir():
die(f"нет мира {src}")
shutil.copytree(src, self.home / "saves" / "Polygon",
ignore=shutil.ignore_patterns("session.lock", "*.lock"))
mods = self.home / "horizon-mods"
mods.mkdir(parents=True, exist_ok=True)
shutil.copyfile(self.mod, mods / "airdef.hmod")
(self.home / "horizon-mods.txt").write_text("mod.airdef:true\n")
# Фоновая потеря фокуса не должна ставить игру на паузу посреди замера.
(self.home / "options.txt").write_text("pauseOnLostFocus:false\n")
def env(self):
env = dict(os.environ)
env.update({
"HORIZON_HOME": str(self.home),
"HORIZON_NO_AUDIO": "1",
"HORIZON_LAUNCHER_NO_SELF_UPDATE": "1",
"HORIZON_MOD_FUEL_PROFILE": "1",
"HORIZON_HD_SCALE": "1",
"HORIZON_SPIKES": "0",
})
env.update(self.extra_env)
return env
def launch(self):
if self.sock.exists():
self.sock.unlink()
cmd = [str(CTL), "--socket", str(self.sock), "launch",
"--world", "Polygon", "--creative", "--offscreen", "--wait",
"--in-frame", "--width", str(self.width), "--height", str(self.height),
"--game", str(self.game), "--resources", str(self.resources)]
with open(self.log, "w") as log:
r = subprocess.run(cmd, text=True, env=self.env(),
cwd=self.home, timeout=600, stdout=log, stderr=subprocess.STDOUT)
if r.returncode != 0:
die(f"launch: {self.log.read_text()[-400:]}")
def ctl(self, *args, timeout=60.0):
cmd = [str(CTL), "--socket", str(self.sock), "--timeout", f"{timeout:g}", *map(str, args)]
try:
r = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout + 60)
except subprocess.TimeoutExpired as e:
die(f"horizon-ctl {' '.join(map(str, args))}: таймаут")
if r.returncode != 0:
die(f"horizon-ctl {' '.join(map(str, args))}: {(r.stdout or r.stderr).strip()[:300]}")
return r.stdout.strip()
def ctl_json(self, *args, timeout=60.0):
text = self.ctl(*args, timeout=timeout)
try:
return json.loads(text)
except json.JSONDecodeError:
return {"_raw": text}
def status(self):
return self.ctl_json("status")
def ticks(self):
return int(self.status()["ticks"])
def wait_ticks(self, n, timeout=240.0):
"""Ждать n тиков игры (20 Гц), не стены."""
start = self.ticks()
deadline = time.monotonic() + timeout
while self.ticks() < start + n:
if time.monotonic() > deadline:
die(f"тики не идут: {start} -> {self.ticks()} за {timeout:g} с")
time.sleep(0.1)
def at_tick(self, target, *args):
deadline = time.monotonic() + 240.0
while self.ticks() < target:
if time.monotonic() > deadline:
die(f"тик {target} не достигнут")
time.sleep(0.05)
return self.ctl(*args)
def chat(self, line):
return self.ctl_json("chat", line)
def chat_log(self, n=12):
return self.ctl_json("chat-log", str(n)).get("chat", [])
def stats(self, raw=True):
return self.ctl_json("stats", "raw" if raw else "", timeout=120.0)
def bench(self, seconds):
"""bench N: сброс счётчиков, окно N секунд, summary + сырые времена."""
self.ctl("bench", str(seconds), timeout=seconds + 120.0)
return self.stats(raw=True)
def screenshot(self, name):
path = self.out / f"{name}.png"
self.ctl("screenshot", str(path), timeout=120.0)
return path.name
def stop(self):
try:
self.ctl("quit", timeout=30.0)
except BenchError:
pass
# --- сцена и бой ---
def scene(self):
self.ctl("command", "gamemode creative")
self.chat("/airdef shader hd")
self.ctl("key", "f1", "tap") # HUD скрыт
self.ctl("command", f"tp @s {' '.join(map(str, POSE))}")
self.ctl("command", f"time set {DAY_TIME}")
self.ctl("command", "gamerule advance_time false")
self.ctl("command", "gamerule advance_weather false")
self.ctl("command", "weather clear")
def battle(self, report):
self.t0 = self.ticks() + 40
fingerprints = {}
for tick, cmd in BATTLE_SCHEDULE:
self.at_tick(self.t0 + tick, "chat", f"/{cmd}")
# Окно замера в середине боя — отдельным потоком, чтобы расписание
# контрольных тиков не плыло за блокирующим bench.
battle_window = {}
def mid_battle():
self.at_tick(self.t0 + 500, "bench", str(BENCH_SECONDS["battle"]))
battle_window.update(self.stats(raw=True))
thread = threading.Thread(target=mid_battle)
thread.start()
self.at_tick(self.t0 + 550, "screenshot", str(self.out / "battle.png"))
for tick in FINGERPRINT_TICKS:
self.at_tick(self.t0 + tick, "chat", "/airdef stats")
time.sleep(0.3)
line = next((l for l in reversed(self.chat_log(20)) if "В воздухе:" in l), None)
fingerprints[str(tick)] = line
self.at_tick(self.t0 + BATTLE_END, "chat", "/airdef stats")
time.sleep(0.3)
fingerprints[str(BATTLE_END)] = next(
(l for l in reversed(self.chat_log(20)) if "В воздухе:" in l), None)
thread.join()
report["windows"]["battle"] = battle_window
report["screenshots"].append("battle.png")
# Запись завершается, когда небо чисто 5 с (sim/record.rs): ждём конца
# боя по тикам, не по стене, затем паузу на финализацию записи.
end_deadline = self.t0 + BATTLE_END + 800
while self.ticks() < end_deadline:
self.ctl("chat", "/airdef stats")
time.sleep(0.3)
line = next((l for l in reversed(self.chat_log(20)) if "В воздухе:" in l), "")
m = STATS_RE.search(line)
if m and m.group(1) == "0" and m.group(2) == "0":
break
self.wait_ticks(20)
report["raid_end_tick"] = self.ticks() - self.t0
self.wait_ticks(120)
return fingerprints
def replay_seek(self, steps):
"""Seek записи: стрелка влево/вправо = ±5 с (replay::control)."""
key = "left" if steps < 0 else "right"
for _ in range(abs(steps)):
self.ctl("key", key, "tap")
time.sleep(0.15)
def static_parity(args):
"""Чистый пиксельный паритет off/on: статичная сцена (батареи), без боя,
TAA/ветер/облака/туман выключены (методика #126), долгий settle."""
env = dict(kv.split("=", 1) for kv in args.env)
env.update({"HORIZON_HD_TAA": "0", "HORIZON_HD_WIND": "0",
"HORIZON_HD_CLOUDS": "0", "HORIZON_HD_VOLFOG": "0"})
d = Driver(args.out, args.game, args.resources, args.mod, env, args.width, args.height)
d.prepare()
d.launch()
out = Path(args.out).resolve()
try:
d.scene()
for kind in ("s400", "patriot", "pantsir", "gepard", "nasams", "irist", "tor"):
d.chat(f"/airdef deploy {kind}")
d.chat(f"/airdef deploy {kind}")
d.wait_ticks(SETTLE_TICKS)
d.bench(4) # прогрев счётчиков/кэшей
d.wait_ticks(SETTLE_TICKS)
for mode in ("off", "on"):
d.ctl("model-instancing", mode)
d.wait_ticks(100)
for i in range(3):
d.screenshot(f"stills_{mode}_{i}")
d.wait_ticks(10)
m = d.stats(raw=False).get("mod_models") or {}
print(f"модели: {m.get('models')} за {m.get('frames')} кадров, "
f"instanced={m.get('instanced_models')}, gpu_mesh_builds={m.get('gpu_mesh_builds')}")
finally:
d.stop()
res = stills_compare(out)
(out / "static_parity.json").write_text(json.dumps(res, indent=1))
return res
def run(args):
d = Driver(args.out, args.game, args.resources, args.mod,
dict(kv.split("=", 1) for kv in args.env), args.width, args.height)
d.prepare()
d.launch()
report = {
"issue": 147,
"label": args.label,
"timestamp": datetime.datetime.now().isoformat(timespec="seconds"),
"git": {
"airdef": git_sha(ROOT),
"airdef_branch": git_branch(ROOT),
"horizon": git_sha(ROOT / "horizon"),
},
"platform": {"system": platform.system(), "machine": platform.machine(),
"mac_ver": platform.mac_ver()[0]},
"env": d.env(),
"battle_schedule": [[t, c] for t, c in BATTLE_SCHEDULE],
"windows": {},
"checks": {},
"screenshots": [],
}
try:
d.scene()
status = d.status()
report["device"] = status.get("renderer")
report["display"] = status.get("display")
size = (status.get("renderer") or {}).get("size")
print(f"устройство: {report['device']}, кадр {size}")
# Idle cold: первые кадры после загрузки мира (холодные меши/атлас).
report["windows"]["idle_cold"] = d.bench(BENCH_SECONDS["idle_cold"])
# Прогрев: LOD и стриминг сходятся по тикам, не по стене.
d.wait_ticks(SETTLE_TICKS)
report["windows"]["idle_warm"] = d.bench(BENCH_SECONDS["idle_warm"])
report["checks"]["settle"] = {
"pending_chunks": d.status().get("pending_chunks"),
"lod": d.status().get("lod"),
}
# Бой по фиксированным тикам; окно замера в середине боя (в потоке).
fingerprints = d.battle(report)
report["battle_fingerprints"] = fingerprints
# Та же запись в обоих путях, один процесс: бой записан один раз, replay
# проигрывает его идентично в каждом окне. Межпроцессные бои расходятся
# по таймингу событий (стриминг/акустика), поэтому A/B на разных записях
# не был бы сравнением рендера. Порядок пар чередуется (проверка прогрева).
def replay_window(tag):
d.chat("/airdef replay full")
d.wait_ticks(REPLAY_WARM_TICKS)
w = d.bench(BENCH_SECONDS["replay"])
report["screenshots"].append(d.screenshot(tag))
d.chat("/airdef replay stop")
d.wait_ticks(20)
return w
d.ctl("model-instancing", "off")
report["windows"]["replay_before"] = replay_window("replay_before")
d.ctl("model-instancing", "on")
report["windows"]["replay_after"] = replay_window("replay_after")
report["windows"]["replay_after2"] = replay_window("replay_after2")
d.ctl("model-instancing", "off")
report["windows"]["replay_before2"] = replay_window("replay_before2")
d.ctl("model-instancing", "on")
# Seek и камера в сторону — на той же записи, instancing включён.
d.chat("/airdef replay full")
d.wait_ticks(REPLAY_WARM_TICKS)
# Seek: перемотка на ±5 с, кадр после seek (движение не должно размазать модели).
before = d.stats(raw=False).get("mod_models")
d.replay_seek(-4)
d.wait_ticks(10)
report["screenshots"].append(d.screenshot("replay_seek"))
report["checks"]["seek"] = {"before": before,
"after": d.stats(raw=False).get("mod_models")}
d.replay_seek(4)
# Камера в сторону от боя: модели за main camera обязаны рисовать тени и чужую камеру.
d.ctl("look", str(POSE[3] + 180.0), str(POSE[4]))
d.wait_ticks(10)
away = d.stats(raw=False).get("mod_models")
report["screenshots"].append(d.screenshot("replay_away"))
report["checks"]["away_camera"] = away
d.ctl("look", str(POSE[3]), str(POSE[4]))
# Reload (F3+T): атлас и меши перестраиваются, модели рисуются снова.
d.chat("/airdef replay stop")
d.wait_ticks(20)
pre = d.stats(raw=False).get("mod_models")
report["screenshots"].append(d.screenshot("pre_reload"))
d.ctl("key", "f3", "down")
d.ctl("key", "t", "tap")
d.ctl("key", "f3", "up")
d.wait_ticks(SETTLE_TICKS)
post = d.stats(raw=False).get("mod_models")
report["screenshots"].append(d.screenshot("post_reload"))
report["checks"]["reload"] = {"before": pre, "after": post}
report["windows"]["reload_warm"] = d.bench(BENCH_SECONDS["idle_warm"])
# Статичные кадры для пиксельного паритета обоих путей (методика hd_bench:
# движущиеся пиксели маскируются по размаху между кадрами одного прогона).
for mode in ("off", "on"):
d.ctl("model-instancing", mode)
d.wait_ticks(40) # TAA сходится на статичной сцене
for i in range(3):
report["screenshots"].append(d.screenshot(f"stills_{mode}_{i}"))
d.wait_ticks(5)
finally:
d.stop()
# Сырые времена и счётчики худших кадров по каждому окну.
for name, window in report["windows"].items():
raw = {k: window.get(k) for k in ("frame_ms", "cpu_ms", "gpu_ms")}
window["derived"] = frame_summary(raw)
print(f"{name}: frames={window.get('frames')} "
f"cpu p95={window['derived']['cpu_ms']['p95_ms']} "
f"p99={window['derived']['cpu_ms']['p99_ms']}")
out = Path(args.out).resolve()
(out / "report.json").write_text(json.dumps(report, ensure_ascii=False, indent=1))
print(f"отчёт: {out / 'report.json'}")
return report
def pair_rows(wa, wb):
fa_, fb_ = wa.get("frames") or 1, wb.get("frames") or 1
ma, mb = wa.get("mod_models") or {}, wb.get("mod_models") or {}
rows = [
("models/кадр", ma.get("models", 0) / fa_, mb.get("models", 0) / fb_),
("instanced/кадр", ma.get("instanced_models", 0) / fa_, mb.get("instanced_models", 0) / fb_),
("vertex_bytes/кадр", ma.get("vertex_bytes", 0) / fa_, mb.get("vertex_bytes", 0) / fb_),
("motion_bytes/кадр", ma.get("motion_bytes", 0) / fa_, mb.get("motion_bytes", 0) / fb_),
("instance_bytes/кадр", ma.get("instance_bytes", 0) / fa_, mb.get("instance_bytes", 0) / fb_),
]
for key in ("cpu_ms", "frame_ms", "gpu_ms"):
for p in ("avg_ms", "p50_ms", "p95_ms", "p99_ms", "max_ms"):
va = (wa.get("derived") or {}).get(key, {}).get(p)
vb = (wb.get("derived") or {}).get(key, {}).get(p)
if va is not None and vb is not None:
rows.append((f"{key} {p}", va, vb))
da, db = wa.get("derived") or {}, wb.get("derived") or {}
rows.append(("кадров >25мс", da.get("frames_over_25ms", 0), db.get("frames_over_25ms", 0)))
rows.append(("кадров >33мс", da.get("frames_over_33ms", 0), db.get("frames_over_33ms", 0)))
return rows
def print_pair(title, wa, wb):
print(f"\n{title}")
print(f"{'метрика':<26}{'A':>14}{'B':>14}{'B/A':>9}")
for label, va, vb in pair_rows(wa, wb):
ratio = f"{vb / va:.3f}" if va else "—"
print(f"{label:<26}{va:>14.1f}{vb:>14.1f}{ratio:>9}")
def compare(paths):
reports = [json.loads(Path(p).read_text()) for p in paths]
if len(reports) == 1:
# Один прогон: fallback и instancing на одной и той же записи.
r = reports[0]
print(f"прогон {r['label']} (engine {r['git']['horizon'][:9]}): "
f"пары окон на одной записи, один процесс")
for before, after in (("replay_before", "replay_after"),
("replay_before2", "replay_after2")):
wa, wb = r["windows"].get(before), r["windows"].get(after)
if wa and wb:
print_pair(f"{before} (off) -> {after} (on)", wa, wb)
return 0
a, b = reports
print(f"A: {a['label']} ({a['git']['horizon'][:9]}) B: {b['label']} ({b['git']['horizon'][:9]})")
fa, fb = a.get("battle_fingerprints", {}), b.get("battle_fingerprints", {})
match = fa == fb
print(f"отпечаток боя: {'совпал' if match else 'НЕ совпал (фазы боя разные, как в #126)'}")
for tick in sorted(set(fa) | set(fb), key=int):
if fa.get(tick) != fb.get(tick):
print(f" тик {tick}:\n A: {fa.get(tick)}\n B: {fb.get(tick)}")
for name in a["windows"]:
if name in b["windows"]:
print_pair(name, a["windows"][name], b["windows"][name])
return 0 if match else 1
def stills_compare(folder):
"""Пиксельный паритет fallback (off) и instancing (on) на статичной сцене
одного прогона (после reload): маскировка движения по размаху кадров
одного пути, методика tools/hd_bench.py."""
import hd_bench as hb
folder = Path(folder)
a = [hb.read_png_rgb(folder / f"stills_off_{i}.png") for i in range(3)]
b = [hb.read_png_rgb(folder / f"stills_on_{i}.png") for i in range(3)]
w, h, _ = a[0]
if any(x[:2] != (w, h) for x in a + b):
die("stills: размеры кадров не совпадают")
fa, fb = [x[2] for x in a], [x[2] for x in b]
ra, rb = hb.motion_range(fa), hb.motion_range(fb)
res = hb.compare_runs(fb, rb, fa, ra, w, h, hb.MOTION_LEVEL,
diff_out=str(folder / "stills_diff.png"),
motion_out=str(folder / "stills_motion.png"))
print(f"статичный паритет off/on: {json.dumps(res)}")
print(f"порог: статичных пикселей с разницей >{hb.DIFF_LEVEL}/255 — {res['pct']:.4f}% "
f"(проверено {res['static_pct']:.1f}% кадра), mean abs diff {res['mean']:.3f}")
return res
def main():
p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
p.add_argument("--out", help="папка прогона (home, лог, скриншоты, report.json)")
p.add_argument("--label", default="run", help="метка прогона в отчёте (before/after)")
p.add_argument("--game", default=str(ROOT / "horizon" / "target" / "fast" / "horizon-client"),
help="бинарник игры")
p.add_argument("--resources", default=os.environ.get("HORIZON_RESOURCES"),
help="подготовленные ресурсы 26.3 (или HORIZON_RESOURCES)")
p.add_argument("--mod", help="собранный airdef.hmod (один и тот же в A/B)")
p.add_argument("--env", action="append", default=[], metavar="КЛЮЧ=ЗНАЧЕНИЕ")
p.add_argument("--width", type=int, default=1280)
p.add_argument("--height", type=int, default=720)
p.add_argument("--compare", nargs="+", metavar="REPORT",
help="один report.json: пары off/on на одной записи; два: кросс-прогон")
p.add_argument("--stills", metavar="DIR", help="пиксельный паритет off/on stills прогона")
p.add_argument("--static-parity", action="store_true",
help="чистый паритет: батареи, без боя, TAA/ветер/облака выключены")
args = p.parse_args()
if args.stills:
stills_compare(args.stills)
sys.exit(0)
if args.compare:
sys.exit(compare(args.compare))
if not args.out:
p.error("--out обязателен (или --compare)")
if not args.resources:
# Лаунчер готовит ресурсы сюда (macOS и Linux).
data = (Path.home() / "Library" / "Application Support" if platform.system() == "Darwin"
else Path(os.environ.get("XDG_DATA_HOME", Path.home() / ".local" / "share")))
found = sorted(data.glob("horizon-launcher/versions/*/.local/horizon-client/26.3"))
local = ROOT / "horizon" / ".local" / "horizon-client" / "26.3"
if local.exists():
found.append(local)
if not found:
die("нет ресурсов 26.3: установи Horizon лаунчером или задай --resources")
args.resources = str(found[-1])
if not args.mod:
args.mod = next((str(c) for c in HMOD_CANDIDATES if c.exists()), None)
if not args.mod:
die("нет собранного airdef.hmod: python3 tools/airdef.py build-mod")
if not Path(args.game).exists():
die(f"нет бинарника {args.game}: cargo build --profile fast -p horizon-client --features mods")
if not CTL.exists():
die(f"нет {CTL}: cargo build --profile fast -p horizon-client --features mods")
try:
if args.static_parity:
static_parity(args)
else:
run(args)
except BenchError as e:
print(f"ошибка: {e}", file=sys.stderr)
sys.exit(2)
if __name__ == "__main__":
main()