#!/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()