88757d05f8
`airdef.py game` no longer needs manual SDK setup. On Windows with an RTX adapter, when neither DLSS_SDK nor VULKAN_SDK is set, it downloads only the files dlss_wgpu reads: - NVIDIA/DLSS at the newest stable v310.9.x tag (GitHub API; pinned v310.9.1 when the API fails): include/*.h, both x64 static libs and the runtime rel/nvngx_dlss.dll (~67 MB once), laid out under .horizon-cache/dlss-sdk/<tag>/ exactly as valid_dlss_sdk expects. - KhronosGroup/Vulkan-Headers include/ under .horizon-cache/vulkan-headers/<tag>/Include/, since build.rs uses headers only and links no Vulkan library. The resolved roots are passed to cargo as DLSS_SDK/VULKAN_SDK, and after a successful dlss build the fresh nvngx_dlss.dll is copied beside the built horizon-client.exe. Explicit DLSS_SDK/VULKAN_SDK (and the sdk argument) keep priority and disable auto-download for that component. Any network or layout failure warns and falls back to --features mods/native TAAU instead of failing the build; non-Windows and non-RTX take the old mods path with no network access. valid_dlss_sdk now looks for the real nvsdk_ngx*.h names instead of the nonexistent nvngx*.h glob, so a genuine SDK (and the downloaded cache) is recognised at all. Tests cover tag selection and fallback, selective layout + marker cache hit, damaged/partial caches, streamed download and truncation, Vulkan Include layout, plan env wiring, explicit-env precedence, failure to mods, and DLL placement beside the client. Co-Authored-By: Kimi Code <noreply@moonshot.ai>
850 lines
42 KiB
Python
850 lines
42 KiB
Python
#!/usr/bin/env python3
|
||
"""AirDef: сборка, установка и запуск на Windows, macOS и Linux. Только стандартная библиотека Python.
|
||
|
||
python3 tools/airdef.py fork # инициализировать закреплённый сабмодуль Horizon (horizon/)
|
||
python3 tools/airdef.py game # собрать игру (форк) — нужен Rust; на Windows + NVIDIA RTX сам скачивает DLSS SDK
|
||
python3 tools/airdef.py mod # собрать мод airdef.hmod — нужен Rust с wasm32
|
||
python3 tools/airdef.py install # положить мод в папку игры и включить
|
||
python3 tools/airdef.py play [аргументы игры] # запустить форк на папке игры
|
||
python3 tools/airdef.py all # всё по порядку: fork, game, mod, install
|
||
python3 tools/airdef.py check # совпадают ли форк, упаковщик, уровень API мода и ресурсы
|
||
python3 tools/airdef.py test-wasm # собрать и прогнать настоящий .hmod в песочнице без GPU
|
||
python3 tools/airdef.py test-budgets # тяжёлый WASM budget сценарий + JSON provenance
|
||
|
||
Переменные окружения: HORIZON_HOME (папка игры), HORIZON_RESOURCES (подготовленные ресурсы
|
||
Minecraft 26.3), AIRDEF_GAME (готовый horizon-client вместо собранного).
|
||
На Windows + NVIDIA RTX сборка с DLSS (feature dlss) сама скачивает DLSS SDK и заголовки Vulkan
|
||
в .horizon-cache/ и кладёт nvngx_dlss.dll рядом с horizon-client.exe. Явные DLSS_SDK и VULKAN_SDK
|
||
по-прежнему имеют приоритет над автоскачиванием; при сбое сети собирается обычный mods/TAAU.
|
||
"""
|
||
import glob
|
||
import hashlib
|
||
import json
|
||
import os
|
||
import platform
|
||
import re
|
||
import shutil
|
||
import subprocess
|
||
import sys
|
||
import tempfile
|
||
import urllib.request
|
||
import zipfile
|
||
from pathlib import Path
|
||
|
||
ROOT = Path(__file__).resolve().parent.parent
|
||
FORK = ROOT / "horizon"
|
||
EXE = ".exe" if os.name == "nt" else ""
|
||
|
||
|
||
def data_dir() -> Path:
|
||
"""Как `dirs::data_dir()` в Horizon."""
|
||
system = platform.system()
|
||
if system == "Windows":
|
||
return Path(os.environ["APPDATA"])
|
||
if system == "Darwin":
|
||
return Path.home() / "Library" / "Application Support"
|
||
return Path(os.environ.get("XDG_DATA_HOME", Path.home() / ".local" / "share"))
|
||
|
||
|
||
def game_home() -> Path:
|
||
return Path(os.environ.get("HORIZON_HOME") or data_dir() / "horizon")
|
||
|
||
|
||
def run(cmd, cwd=None, env=None):
|
||
print("+", " ".join(str(c) for c in cmd), flush=True)
|
||
subprocess.run([str(c) for c in cmd], cwd=cwd, env=env, check=True)
|
||
|
||
|
||
def cargo() -> str:
|
||
found = shutil.which("cargo") or str(Path.home() / ".cargo" / "bin" / ("cargo" + EXE))
|
||
if not Path(found).exists() and not shutil.which("cargo"):
|
||
sys.exit("Нужен Rust: https://rustup.rs (затем: rustup target add wasm32-unknown-unknown)")
|
||
return found
|
||
|
||
|
||
def engine_commit() -> str:
|
||
"""The index pins the engine, including a deliberate not-yet-committed gitlink update."""
|
||
row = subprocess.check_output(["git", "ls-files", "--stage", "--", "horizon"], cwd=ROOT, text=True).strip().split()
|
||
if len(row) < 2 or row[0] != "160000":
|
||
sys.exit("Нет закреплённого сабмодуля horizon/: проверьте checkout AirDef")
|
||
return row[1]
|
||
|
||
|
||
def engine_identity() -> str:
|
||
commit = subprocess.check_output(["git", "rev-parse", "HEAD"], cwd=FORK, text=True).strip()
|
||
diff = subprocess.check_output(["git", "diff", "--binary", "HEAD"], cwd=FORK)
|
||
return commit + ("-" + hashlib.sha256(diff).hexdigest()[:16] if diff else "")
|
||
|
||
|
||
def fork():
|
||
"""Initialize the exact gitlink; never replace a modified developer checkout."""
|
||
expected = engine_commit()
|
||
matched = False
|
||
if (FORK / ".git").exists():
|
||
current = subprocess.check_output(["git", "rev-parse", "HEAD"], cwd=FORK, text=True).strip()
|
||
matched = current == expected
|
||
dirty = subprocess.check_output(["git", "status", "--porcelain"], cwd=FORK, text=True).strip()
|
||
if not matched and dirty:
|
||
sys.exit("horizon/: есть изменения при другом закреплённом SHA; сохраните их перед обновлением сабмодуля")
|
||
if (FORK / ".git").is_dir():
|
||
# Migrate the old standalone clone without deleting it or any local branches.
|
||
run(["git", "submodule", "absorbgitdirs", "--", "horizon"], cwd=ROOT)
|
||
url = subprocess.check_output(["git", "config", "-f", ".gitmodules", "--get", "submodule.horizon.url"], cwd=ROOT, text=True).strip()
|
||
run(["git", "remote", "set-url", "origin", url], cwd=FORK)
|
||
elif FORK.exists() and any(FORK.iterdir()):
|
||
sys.exit("horizon/: непустой каталог без Git; сохраните его перед инициализацией сабмодуля")
|
||
# Existing clones cache the previous upstream URL in local Git configuration.
|
||
# Synchronize even when HEAD already matches: the next pin may exist only in our fork.
|
||
run(["git", "submodule", "sync", "--recursive", "--", "horizon"], cwd=ROOT)
|
||
if matched:
|
||
print(f"horizon/: закреплённый коммит {expected}")
|
||
return
|
||
run(["git", "submodule", "update", "--init", "--recursive", "--", "horizon"], cwd=ROOT)
|
||
current = subprocess.check_output(["git", "rev-parse", "HEAD"], cwd=FORK, text=True).strip()
|
||
if current != expected:
|
||
sys.exit(f"horizon/: ожидался {expected}, получен {current}")
|
||
|
||
|
||
DLSS_SDK_URL = "https://github.com/NVIDIA/DLSS"
|
||
DLSS_TAGS_API = "https://api.github.com/repos/NVIDIA/DLSS/tags?per_page=30"
|
||
DLSS_RAW = "https://raw.githubusercontent.com/NVIDIA/DLSS/{tag}/{path}"
|
||
DLSS_TAG_PINNED = "v310.9.1"
|
||
# Автоскачивание берёт только стабильные v310.9.x; закреплённая версия — резерв при сбое API.
|
||
DLSS_TAG = re.compile(r"^v310\.9\.(\d+)$")
|
||
DLSS_INCLUDE_FALLBACK = (
|
||
"nvsdk_ngx.h", "nvsdk_ngx_defs.h", "nvsdk_ngx_defs_dlssd.h", "nvsdk_ngx_defs_dlssg.h",
|
||
"nvsdk_ngx_defs_vk.h", "nvsdk_ngx_helpers.h", "nvsdk_ngx_helpers_cuda.h",
|
||
"nvsdk_ngx_helpers_d3d.h", "nvsdk_ngx_helpers_dlssd.h", "nvsdk_ngx_helpers_dlssd_cuda.h",
|
||
"nvsdk_ngx_helpers_dlssd_d3d.h", "nvsdk_ngx_helpers_dlssd_vk.h", "nvsdk_ngx_helpers_dlssg.h",
|
||
"nvsdk_ngx_helpers_dlssg_d3d.h", "nvsdk_ngx_helpers_dlssg_vk.h", "nvsdk_ngx_helpers_vk.h",
|
||
"nvsdk_ngx_loader.h", "nvsdk_ngx_params.h", "nvsdk_ngx_params_dlssd.h",
|
||
"nvsdk_ngx_params_dlssg.h", "nvsdk_ngx_standalone_common.h", "nvsdk_ngx_standalone_cuda.h",
|
||
"nvsdk_ngx_vk.h",
|
||
)
|
||
# dlss_wgpu линкует static-библиотеку (nvsdk_ngx_d, либо nvsdk_ngx_s при crt-static).
|
||
DLSS_LIBS = ("lib/Windows_x86_64/x64/nvsdk_ngx_d.lib", "lib/Windows_x86_64/x64/nvsdk_ngx_s.lib")
|
||
DLSS_RUNTIME = "lib/Windows_x86_64/rel/nvngx_dlss.dll"
|
||
|
||
VULKAN_SDK_URL = "https://vulkan.lunarg.com/sdk/home"
|
||
VULKAN_TAG_PINNED = "vulkan-sdk-1.4.363.0"
|
||
VULKAN_RAW = "https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/{tag}/include/{path}"
|
||
# build.rs использует только заголовки ({VULKAN_SDK}/Include), полный LunarG SDK не нужен.
|
||
VULKAN_HEADERS = (
|
||
"vulkan/vulkan.h", "vulkan/vulkan_core.h", "vulkan/vk_platform.h",
|
||
"vk_video/vulkan_video_codec_av1std.h", "vk_video/vulkan_video_codec_av1std_decode.h",
|
||
"vk_video/vulkan_video_codec_av1std_encode.h", "vk_video/vulkan_video_codec_h264std.h",
|
||
"vk_video/vulkan_video_codec_h264std_decode.h", "vk_video/vulkan_video_codec_h264std_encode.h",
|
||
"vk_video/vulkan_video_codec_h265std.h", "vk_video/vulkan_video_codec_h265std_decode.h",
|
||
"vk_video/vulkan_video_codec_h265std_encode.h", "vk_video/vulkan_video_codec_vp9std.h",
|
||
"vk_video/vulkan_video_codec_vp9std_decode.h", "vk_video/vulkan_video_codecs_common.h",
|
||
)
|
||
|
||
CACHE = ROOT / ".horizon-cache"
|
||
DLSS_CACHE = CACHE / "dlss-sdk"
|
||
VULKAN_CACHE = CACHE / "vulkan-headers"
|
||
INSTALL_MARKER = "airdef-install.json"
|
||
|
||
|
||
class DownloadError(RuntimeError):
|
||
"""Сеть или неполный файл при автоскачивании; вызывающий код откатывается на mods."""
|
||
|
||
|
||
def open_url(url):
|
||
request = urllib.request.Request(url, headers={"User-Agent": "airdef-dlss-autoinstall"})
|
||
return urllib.request.urlopen(request, timeout=120)
|
||
|
||
|
||
def github_json(url):
|
||
with open_url(url) as response:
|
||
return json.load(response)
|
||
|
||
|
||
def download(url, dest):
|
||
"""Один файл потоком во временный .part и атомарная замена; прогресс для больших файлов."""
|
||
dest = Path(dest)
|
||
dest.parent.mkdir(parents=True, exist_ok=True)
|
||
part = dest.with_name(dest.name + ".part")
|
||
try:
|
||
try:
|
||
response = open_url(url)
|
||
except Exception as exc:
|
||
raise DownloadError(f"{url}: {exc}") from exc
|
||
with response, open(part, "wb") as out:
|
||
total = int(response.headers.get("Content-Length") or 0)
|
||
big = total >= 8_000_000
|
||
if big:
|
||
print(f" {dest.name}: {total / 1e6:.1f} МБ", flush=True)
|
||
done, step = 0, 0
|
||
while True:
|
||
chunk = response.read(1 << 20)
|
||
if not chunk:
|
||
break
|
||
out.write(chunk)
|
||
done += len(chunk)
|
||
if big and done * 10 // total > step:
|
||
step = done * 10 // total
|
||
print(f" {dest.name}: {min(step * 10, 100)}%", flush=True)
|
||
if total and done < total:
|
||
raise DownloadError(f"{url}: получено {done} из {total} байт")
|
||
os.replace(part, dest)
|
||
finally:
|
||
if part.exists():
|
||
part.unlink()
|
||
|
||
|
||
def dlss_latest_tag():
|
||
"""Новейший стабильный тег v310.9.x с GitHub; при сбое API — закреплённый v310.9.1."""
|
||
try:
|
||
tags = github_json(DLSS_TAGS_API)
|
||
except Exception as exc:
|
||
print(f"Внимание: не удалось получить теги DLSS ({exc}); беру {DLSS_TAG_PINNED}.", flush=True)
|
||
return DLSS_TAG_PINNED
|
||
versions = []
|
||
for entry in tags if isinstance(tags, list) else []:
|
||
name = entry.get("name", "") if isinstance(entry, dict) else ""
|
||
match = DLSS_TAG.match(name)
|
||
if match:
|
||
versions.append((int(match.group(1)), name))
|
||
if not versions:
|
||
print(f"Внимание: среди тегов DLSS нет v310.9.x; беру {DLSS_TAG_PINNED}.", flush=True)
|
||
return DLSS_TAG_PINNED
|
||
return max(versions)[1]
|
||
|
||
|
||
def dlss_include_files(tag):
|
||
"""Список include/*.h тега из API; при сбое — закреплённый набор v310.9.x."""
|
||
try:
|
||
entries = github_json(f"https://api.github.com/repos/NVIDIA/DLSS/contents/include?ref={tag}")
|
||
names = [entry["name"] for entry in entries if isinstance(entry, dict)
|
||
and str(entry.get("name", "")).endswith(".h")]
|
||
if names:
|
||
return names
|
||
except Exception:
|
||
pass
|
||
return list(DLSS_INCLUDE_FALLBACK)
|
||
|
||
|
||
def read_marker(path):
|
||
"""Манифест установки в кэше (версия, размер DLL); None, если его нет или он битый."""
|
||
try:
|
||
return json.loads((Path(path) / INSTALL_MARKER).read_text(encoding="utf-8"))
|
||
except (OSError, ValueError):
|
||
return None
|
||
|
||
|
||
def dlss_sdk_complete(path) -> bool:
|
||
"""Полный набор для сборки: include, обе static .lib и runtime DLL."""
|
||
path = Path(path)
|
||
return valid_dlss_sdk(path) and all((path / rel).is_file() for rel in DLSS_LIBS + (DLSS_RUNTIME,))
|
||
|
||
|
||
def dlss_tag_key(name):
|
||
match = DLSS_TAG.match(name)
|
||
return int(match.group(1)) if match else -1
|
||
|
||
|
||
def cached_dlss_sdk():
|
||
"""Самый новый полностью скачанный SDK в кэше или None."""
|
||
if not DLSS_CACHE.is_dir():
|
||
return None
|
||
for path in sorted(DLSS_CACHE.iterdir(), key=lambda p: dlss_tag_key(p.name), reverse=True):
|
||
state = read_marker(path)
|
||
if state and state.get("tag") == path.name and dlss_sdk_complete(path):
|
||
return path
|
||
return None
|
||
|
||
|
||
def install_dlss_sdk(tag=None):
|
||
"""Скачивает только нужные файлы NVIDIA/DLSS в .horizon-cache/dlss-sdk/<tag>.
|
||
|
||
Раскладка ровно та, которую ожидает dlss_wgpu: include/nvsdk_ngx*.h и lib/Windows_x86_64/{x64,rel}.
|
||
"""
|
||
tag = tag or dlss_latest_tag()
|
||
dest = DLSS_CACHE / tag
|
||
state = read_marker(dest)
|
||
if state and state.get("tag") == tag and dlss_sdk_complete(dest):
|
||
print(f"DLSS SDK {tag}: уже в кэше {dest}", flush=True)
|
||
return dest
|
||
print(f"DLSS SDK {tag}: скачиваю заголовки, .lib и nvngx_dlss.dll (~67 МБ) с {DLSS_SDK_URL}", flush=True)
|
||
staging = DLSS_CACHE / f".{tag}.part"
|
||
shutil.rmtree(staging, ignore_errors=True)
|
||
try:
|
||
for name in dlss_include_files(tag):
|
||
download(DLSS_RAW.format(tag=tag, path=f"include/{name}"), staging / "include" / name)
|
||
for rel in DLSS_LIBS + (DLSS_RUNTIME,):
|
||
download(DLSS_RAW.format(tag=tag, path=rel), staging / rel)
|
||
if not dlss_sdk_complete(staging):
|
||
raise DownloadError(f"DLSS SDK {tag}: после скачивания нет полного набора include/ и lib/Windows_x86_64")
|
||
(staging / INSTALL_MARKER).write_text(json.dumps({
|
||
"tag": tag, "source": DLSS_SDK_URL,
|
||
"dll_bytes": (staging / DLSS_RUNTIME).stat().st_size}, indent=2) + "\n", encoding="utf-8")
|
||
shutil.rmtree(dest, ignore_errors=True)
|
||
staging.rename(dest)
|
||
except Exception:
|
||
shutil.rmtree(staging, ignore_errors=True)
|
||
raise
|
||
print(f"DLSS SDK {tag}: готов, {dest}", flush=True)
|
||
return dest
|
||
|
||
|
||
def vulkan_headers_ok(path) -> bool:
|
||
"""dlss_wgpu ищет Include/vulkan/vulkan.h (Windows) или include/vulkan/vulkan.h."""
|
||
if not path:
|
||
return False
|
||
path = Path(path)
|
||
return any((path / part).is_file() for part in
|
||
("Include/vulkan/vulkan.h", "include/vulkan/vulkan.h"))
|
||
|
||
|
||
def vulkan_cache_ok(path, tag) -> bool:
|
||
state = read_marker(path)
|
||
return bool(state) and state.get("tag") == tag and vulkan_headers_ok(path) \
|
||
and (Path(path) / "Include" / "vk_video" / "vulkan_video_codecs_common.h").is_file()
|
||
|
||
|
||
def cached_vulkan_headers():
|
||
path = VULKAN_CACHE / VULKAN_TAG_PINNED
|
||
return path if vulkan_cache_ok(path, VULKAN_TAG_PINNED) else None
|
||
|
||
|
||
def install_vulkan_headers(tag=VULKAN_TAG_PINNED):
|
||
"""Только заголовки Khronos в <cache>/Include: build.rs линкует Vulkan-библиотеку сам."""
|
||
dest = VULKAN_CACHE / tag
|
||
if vulkan_cache_ok(dest, tag):
|
||
print(f"Vulkan-заголовки {tag}: уже в кэше {dest}", flush=True)
|
||
return dest
|
||
print(f"Vulkan-заголовки {tag}: скачиваю include/ (полный LunarG SDK не нужен)", flush=True)
|
||
staging = VULKAN_CACHE / f".{tag}.part"
|
||
shutil.rmtree(staging, ignore_errors=True)
|
||
try:
|
||
for rel in VULKAN_HEADERS:
|
||
download(VULKAN_RAW.format(tag=tag, path=rel), staging / "Include" / rel)
|
||
if not vulkan_headers_ok(staging):
|
||
raise DownloadError(f"Vulkan-заголовки {tag}: после скачивания нет Include/vulkan/vulkan.h")
|
||
(staging / INSTALL_MARKER).write_text(json.dumps({"tag": tag, "source": VULKAN_SDK_URL},
|
||
indent=2) + "\n", encoding="utf-8")
|
||
shutil.rmtree(dest, ignore_errors=True)
|
||
staging.rename(dest)
|
||
except Exception:
|
||
shutil.rmtree(staging, ignore_errors=True)
|
||
raise
|
||
print(f"Vulkan-заголовки {tag}: готовы, {dest}", flush=True)
|
||
return dest
|
||
|
||
|
||
def gpu_names():
|
||
"""Имена видеоадаптеров Windows. Сбой опроса — пустой список (это «нет DLSS», а не ошибка сборки)."""
|
||
if platform.system() != "Windows":
|
||
return []
|
||
flags = getattr(subprocess, "CREATE_NO_WINDOW", 0)
|
||
for cmd in (["powershell", "-NoProfile", "-Command", "(Get-CimInstance Win32_VideoController).Name"],
|
||
["wmic", "path", "win32_VideoController", "get", "name"]):
|
||
try:
|
||
out = subprocess.run(cmd, capture_output=True, text=True, timeout=30,
|
||
creationflags=flags, errors="replace")
|
||
except (OSError, ValueError, subprocess.SubprocessError):
|
||
continue
|
||
if out.returncode != 0:
|
||
continue
|
||
# У wmic первая строка — заголовок Name.
|
||
names = [line.strip() for line in out.stdout.splitlines()
|
||
if line.strip() and line.strip().lower() != "name"]
|
||
if names:
|
||
return names
|
||
return []
|
||
|
||
|
||
def rtx_gpu(names) -> bool:
|
||
"""NVIDIA RTX среди адаптеров: в имени есть и NVIDIA, и RTX."""
|
||
return any("nvidia" in name.lower() and "rtx" in name.lower() for name in names)
|
||
|
||
|
||
def valid_dlss_sdk(path) -> bool:
|
||
"""Каталоги, без которых dlss_wgpu не соберётся: include/nvsdk_ngx*.h и lib/Windows_x86_64/x64."""
|
||
return bool(path) and (path / "include").is_dir() and list((path / "include").glob("nvsdk_ngx*.h")) \
|
||
and (path / "lib" / "Windows_x86_64" / "x64").is_dir()
|
||
|
||
|
||
def dlss_sdk_path():
|
||
"""Корень уже установленного NVIDIA DLSS SDK (DLSS_SDK, ROOT/DLSS, Program Files) или None."""
|
||
candidates = []
|
||
if os.environ.get("DLSS_SDK"):
|
||
candidates.append(Path(os.environ["DLSS_SDK"]))
|
||
candidates += [ROOT / "DLSS", ROOT / "dlss-sdk"]
|
||
for env in ("ProgramFiles", "ProgramFiles(x86)"):
|
||
if os.environ.get(env):
|
||
candidates += sorted((Path(os.environ[env]) / "NVIDIA" / "DLSS").glob("*"), reverse=True)
|
||
for path in candidates:
|
||
if valid_dlss_sdk(path):
|
||
return path
|
||
return None
|
||
|
||
|
||
def _auto_install(install, label):
|
||
"""Автоскачивание не должно ломать сборку: любая ошибка — предупреждение и mods/TAAU."""
|
||
try:
|
||
return install()
|
||
except Exception as exc:
|
||
print(f"Внимание: {label} не скачался: {exc}", flush=True)
|
||
return None
|
||
|
||
|
||
def dlss_build_plan(system=None, gpus=None, sdk=None) -> dict:
|
||
"""Features сборки и окружение DLSS_SDK/VULKAN_SDK для Windows + NVIDIA RTX.
|
||
|
||
Возвращает {"features", "env", "sdk", "dll"}. Без явного SDK на Windows + RTX сам скачивает
|
||
DLSS SDK и заголовки Vulkan в .horizon-cache. Явные DLSS_SDK/VULKAN_SDK (или аргумент sdk)
|
||
имеют приоритет и отключают автоскачивание; неполный явный путь — предупреждение и mods.
|
||
"""
|
||
plan = {"features": "mods", "env": {}, "sdk": None, "dll": None}
|
||
system = platform.system() if system is None else system
|
||
if system != "Windows":
|
||
return plan
|
||
names = gpu_names() if gpus is None else gpus
|
||
if not rtx_gpu(names):
|
||
return plan
|
||
|
||
env_sdk = os.environ.get("DLSS_SDK")
|
||
explicit_sdk = sdk is not None or bool(env_sdk)
|
||
if sdk is not None:
|
||
candidate = Path(sdk)
|
||
sdk_root = candidate if valid_dlss_sdk(candidate) else None
|
||
elif env_sdk:
|
||
candidate = Path(env_sdk)
|
||
sdk_root = candidate if valid_dlss_sdk(candidate) else None
|
||
else:
|
||
sdk_root = dlss_sdk_path() or cached_dlss_sdk()
|
||
if sdk_root is None:
|
||
sdk_root = _auto_install(install_dlss_sdk, "NVIDIA DLSS SDK")
|
||
|
||
env_vulkan = os.environ.get("VULKAN_SDK")
|
||
explicit_vulkan = bool(env_vulkan)
|
||
if env_vulkan:
|
||
vulkan_root = Path(env_vulkan) if vulkan_headers_ok(env_vulkan) else None
|
||
else:
|
||
vulkan_root = cached_vulkan_headers()
|
||
if vulkan_root is None:
|
||
vulkan_root = _auto_install(install_vulkan_headers, "Vulkan-заголовки")
|
||
|
||
missing = []
|
||
if sdk_root is None:
|
||
missing.append("NVIDIA DLSS SDK")
|
||
if vulkan_root is None:
|
||
missing.append("заголовки Vulkan")
|
||
if missing:
|
||
print("Внимание: NVIDIA RTX найден, но DLSS-сборка пропущена — нет " + " и ".join(missing) + ".",
|
||
flush=True)
|
||
if explicit_sdk or explicit_vulkan:
|
||
print(" DLSS_SDK/VULKAN_SDK заданы, но путь неполный. Убери их, и airdef.py скачает SDK сам.",
|
||
flush=True)
|
||
else:
|
||
print(" Автоскачивание не удалось: проверь сеть/прокси и повтори сборку.", flush=True)
|
||
print(f" Вручную: DLSS SDK {DLSS_SDK_URL} (переменная DLSS_SDK), Vulkan SDK или только "
|
||
f"заголовки (VULKAN_SDK, {VULKAN_SDK_URL}).", flush=True)
|
||
print(" Собираю --features mods: DLSS выключен, native TAAU остаётся.", flush=True)
|
||
return plan
|
||
|
||
plan.update(features="mods,dlss", sdk=sdk_root, dll=Path(sdk_root) / DLSS_RUNTIME,
|
||
env={"DLSS_SDK": str(sdk_root), "VULKAN_SDK": str(vulkan_root)})
|
||
print(f"DLSS: NVIDIA RTX, SDK {sdk_root}; собираю --features mods,dlss", flush=True)
|
||
print(" nvngx_dlss.dll из SDK кладу рядом с horizon-client.exe после сборки; DLSS включён по умолчанию — переключатель в настройках мода (N → DLSS), HORIZON_DLSS=1|0 переопределяет.", flush=True)
|
||
return plan
|
||
|
||
|
||
def dlss_build_features(system=None, gpus=None, sdk=None) -> str:
|
||
"""Строка features для cargo build: 'mods,dlss' только на Windows + RTX с полным SDK."""
|
||
return dlss_build_plan(system=system, gpus=gpus, sdk=sdk)["features"]
|
||
|
||
|
||
def built_client_candidates():
|
||
paths = []
|
||
if os.environ.get("AIRDEF_GAME"):
|
||
paths.append(Path(os.environ["AIRDEF_GAME"]))
|
||
paths += [FORK / "target" / "fast" / ("horizon-client" + EXE), ROOT / ("horizon-client" + EXE)]
|
||
return paths
|
||
|
||
|
||
def place_dlss_runtime(sdk_root):
|
||
"""Копирует свежий nvngx_dlss.dll из SDK рядом с собранным horizon-client.exe."""
|
||
dll = Path(sdk_root) / DLSS_RUNTIME
|
||
if not dll.is_file():
|
||
print(f"Внимание: в SDK {sdk_root} нет {DLSS_RUNTIME}; положи nvngx_dlss.dll рядом с клиентом вручную.",
|
||
flush=True)
|
||
return None
|
||
for exe in built_client_candidates():
|
||
if not exe.is_file():
|
||
continue
|
||
target = exe.with_name(dll.name)
|
||
try:
|
||
# Всегда свежая DLL: старый nvngx_dlss.dll рядом с клиентом не должен пережить пересборку.
|
||
shutil.copy2(dll, target)
|
||
print(f" nvngx_dlss.dll ({dll.stat().st_size / 1e6:.1f} МБ) рядом с {exe}", flush=True)
|
||
return target
|
||
except OSError as exc:
|
||
print(f"Внимание: не удалось положить {dll.name} рядом с {exe}: {exc}", flush=True)
|
||
print("Внимание: собранный horizon-client.exe не найден; nvngx_dlss.dll нужно положить рядом с ним вручную.",
|
||
flush=True)
|
||
return None
|
||
|
||
|
||
def game():
|
||
fork()
|
||
plan = dlss_build_plan()
|
||
env = dict(os.environ)
|
||
env.update(plan["env"])
|
||
run([cargo(), "build", "--profile", "fast", "-p", "horizon-client", "--features", plan["features"]],
|
||
cwd=FORK, env=env)
|
||
if plan["sdk"] is not None:
|
||
place_dlss_runtime(plan["sdk"])
|
||
|
||
|
||
def built_game() -> Path:
|
||
if os.environ.get("AIRDEF_GAME"):
|
||
return Path(os.environ["AIRDEF_GAME"])
|
||
for name in (FORK / "target" / "fast" / ("horizon-client" + EXE), ROOT / ("horizon-client" + EXE)):
|
||
if name.exists():
|
||
return name
|
||
sys.exit("Нет собранной игры: python3 tools/airdef.py game (или AIRDEF_GAME=путь к horizon-client)")
|
||
|
||
|
||
def packer_path() -> Path:
|
||
return ROOT / ".horizon-cache" / "packer" / engine_identity() / "bin" / ("cargo-horizon-mod" + EXE)
|
||
|
||
|
||
def mod():
|
||
fork()
|
||
tool = packer_path()
|
||
if not tool.exists():
|
||
run([cargo(), "install", "--locked", "--no-default-features", "--target-dir", FORK / "target", "--root", tool.parent.parent,
|
||
"--path", FORK / "crates" / "cargo-horizon-mod"])
|
||
# Invoke the pinned executable directly; PATH may contain an unrelated old packer.
|
||
build_env = dict(os.environ)
|
||
build_env["PATH"] = str(Path(cargo()).parent) + os.pathsep + build_env.get("PATH", "")
|
||
run([tool, "horizon-mod", "build"], cwd=ROOT / "airdef-mod", env=build_env)
|
||
artifact = hmod()
|
||
identity = {"airdef": subprocess.check_output(["git", "rev-parse", "HEAD"], cwd=ROOT, text=True).strip(),
|
||
"engine": engine_identity(), "engine_pin": engine_commit(),
|
||
"wit_sha256": hashlib.sha256((FORK / "crates/horizon-mod-sdk/wit/horizon.wit").read_bytes()).hexdigest(),
|
||
"artifact_sha256": hashlib.sha256(artifact.read_bytes()).hexdigest(),
|
||
"airdef_dirty": bool(subprocess.check_output(["git", "status", "--porcelain", "--untracked-files=no"], cwd=ROOT)),
|
||
"airdef_diff_sha256": hashlib.sha256(subprocess.check_output(["git", "diff", "--binary", "HEAD"], cwd=ROOT)).hexdigest()}
|
||
artifact.with_name("build-identity.json").write_text(json.dumps(identity, indent=2) + "\n")
|
||
|
||
|
||
def hmod() -> Path:
|
||
for p in (ROOT / "airdef-mod" / "target" / "horizon-mod" / "airdef.hmod", ROOT / "airdef.hmod"):
|
||
if p.exists():
|
||
return p
|
||
sys.exit("Нет airdef.hmod: python3 tools/airdef.py mod")
|
||
|
||
|
||
def test_wasm():
|
||
"""The real component and host ABI, with the engine's normal fuel/memory limits."""
|
||
mod()
|
||
build_env = dict(os.environ)
|
||
build_env["PATH"] = str(Path(cargo()).parent) + os.pathsep + build_env.get("PATH", "")
|
||
# `full` is the packer's default feature; the lightweight release packer has no runtime.
|
||
run([cargo(), "run", "--locked", "--manifest-path", FORK / "Cargo.toml",
|
||
"-p", "cargo-horizon-mod", "--", "horizon-mod", "test", "--hmod", hmod()],
|
||
cwd=ROOT / "airdef-mod", env=build_env)
|
||
|
||
|
||
BUDGET_SCENARIO = "tests/budgets/wasm_flat_budget.toml"
|
||
BUDGET_ASSERTED_SHA256 = "eaee000d05aa1da232db5dfb225fa067e29bb554edcb0a90ddf1aad18a8aae29"
|
||
|
||
|
||
def fuel_measurements(output):
|
||
"""Read the pinned host's callback counters; never infer them from source caps."""
|
||
samples = []
|
||
for mod_id, callback, calls, maximum, budget, failures in re.findall(
|
||
r"(?m)^fuel (\S+) (\S+): calls=(\d+) max=(\d+) budget=(\d+) failures=(\d+)\s*$", output):
|
||
samples.append({"mod": mod_id, "callback": callback, "calls": int(calls),
|
||
"max_used": int(maximum), "budget": int(budget), "failures": int(failures)})
|
||
return samples
|
||
|
||
|
||
def test_budgets():
|
||
"""Run the opt-in heavy scenario and always write a machine-readable report."""
|
||
report_path = Path(os.environ.get("AIRDEF_BUDGET_REPORT") or
|
||
ROOT / ".horizon-cache" / "wasm-budget-report.json")
|
||
report = {
|
||
"schema": 1,
|
||
"command": "test-budgets",
|
||
"scenario": BUDGET_SCENARIO,
|
||
"scenario_render_world": None,
|
||
"status": "failed",
|
||
"exit_code": None,
|
||
"scenario_counts": {"scripts": 1, "steps": None, "raid_requests": None,
|
||
"raid_units_requested": None, "air_defense_units": None,
|
||
"layout_unit_limit": None, "frames": None, "ticks": None,
|
||
"accepted_raids_asserted": None, "snapshot_airborne_asserted": None,
|
||
"snapshot_tick": None, "peak_airborne_observed": None},
|
||
"runtime_limits": {"source": "horizon/crates/horizon-mods/src/runtime.rs",
|
||
"metering": "source_configured"},
|
||
"measured_fuel": {"available": False, "callbacks": [],
|
||
"scope": "guest callback fuel; excludes host CPU, memory and GPU time"},
|
||
}
|
||
|
||
def git(*args, text=True):
|
||
return subprocess.check_output(["git", *args], cwd=ROOT,
|
||
text=text, stderr=subprocess.DEVNULL)
|
||
|
||
try:
|
||
report["airdef"] = {
|
||
"sha": git("rev-parse", "HEAD").strip(),
|
||
"dirty": bool(git("status", "--porcelain", "--untracked-files=no").strip()),
|
||
"diff_sha256": hashlib.sha256(git("diff", "--binary", "HEAD", text=False)).hexdigest(),
|
||
}
|
||
report["engine"] = {"pin": engine_commit(), "identity": engine_identity()}
|
||
wit = FORK / "crates" / "horizon-mod-sdk" / "wit" / "horizon.wit"
|
||
report["api_level"] = fork_api()[0] if fork_api() else None
|
||
report["wit_sha256"] = hashlib.sha256(wit.read_bytes()).hexdigest() if wit.is_file() else None
|
||
runtime = (FORK / "crates" / "horizon-mods" / "src" / "runtime.rs").read_text()
|
||
layout = (ROOT / "airdef-mod" / "src" / "layout.rs").read_text()
|
||
limit = re.search(r"pub const MAX_UNITS: usize = (\d+);", layout)
|
||
report["scenario_counts"]["layout_unit_limit"] = int(limit.group(1)) if limit else None
|
||
memory = re.search(r"const MEMORY: usize = (\d+) << (\d+);", runtime)
|
||
report["runtime_limits"].update({
|
||
"memory_bytes": int(memory.group(1)) << int(memory.group(2)) if memory else None,
|
||
"fuel_per_call": {name.lower(): int(value) for name, value in
|
||
re.findall(r"const FUEL_(INIT|TICK|FRAME|EVENT): u64 = ([\d_]+);", runtime)
|
||
for value in [value.replace("_", "")]},
|
||
"wasmtime_component_model": bool(re.search(r"wasm_component_model\(true\)", runtime)),
|
||
"wasmtime_fuel_metering": bool(re.search(r"consume_fuel\(true\)", runtime)),
|
||
})
|
||
lock_text = (ROOT / "horizon" / "Cargo.lock").read_text()
|
||
wasmtime = re.search(r'\[\[package\]\]\s*name = "wasmtime"\s*version = "([^"]+)"', lock_text)
|
||
report["wasmtime_version"] = wasmtime.group(1) if wasmtime else None
|
||
fixture = ROOT / "airdef-mod" / BUDGET_SCENARIO
|
||
fixture_bytes = fixture.read_bytes()
|
||
fixture_text = fixture_bytes.decode("utf-8")
|
||
flat_heights = list(dict.fromkeys(re.findall(r"(?m)^render-ground-y\s*=\s*(-?\d+)\s*$", fixture_text)))
|
||
if flat_heights:
|
||
report["scenario_render_world"] = "flat at y=" + ",".join(flat_heights)
|
||
counts = report["scenario_counts"]
|
||
counts["steps"] = len(re.findall(r"(?m)^\[\[step\]\]$", fixture_text))
|
||
counts["air_defense_units"] = len(re.findall(r'(?m)^command = "airdef deploy [^"]+"', fixture_text))
|
||
requests = re.findall(r'(?m)^command = "airdef wave \S+ (\d+)(?: [^"]*)?"', fixture_text)
|
||
counts["raid_requests"] = len(requests)
|
||
counts["raid_units_requested"] = sum(map(int, requests))
|
||
for field in ("ticks", "frames"):
|
||
counts[field] = sum(map(int, re.findall(rf"(?m)^{field}\s*=\s*(\d+)\s*$", fixture_text)))
|
||
report["scenario_sha256"] = hashlib.sha256(fixture_bytes).hexdigest()
|
||
|
||
mod()
|
||
artifact = hmod()
|
||
report["artifact_sha256"] = hashlib.sha256(artifact.read_bytes()).hexdigest()
|
||
identity_path = artifact.with_name("build-identity.json")
|
||
identity = json.loads(identity_path.read_text())
|
||
identity_checks = {
|
||
"engine_pin": identity.get("engine_pin") == report["engine"]["pin"],
|
||
"engine_identity": identity.get("engine") == report["engine"]["identity"],
|
||
"airdef_sha": identity.get("airdef") == report["airdef"]["sha"],
|
||
"airdef_dirty": identity.get("airdef_dirty") == report["airdef"]["dirty"],
|
||
"airdef_diff_sha256": identity.get("airdef_diff_sha256") == report["airdef"]["diff_sha256"],
|
||
"artifact_sha256": identity.get("artifact_sha256") == report["artifact_sha256"],
|
||
"wit_sha256": identity.get("wit_sha256") == report["wit_sha256"],
|
||
}
|
||
report["build_identity"] = {"path": str(identity_path), "checks": identity_checks,
|
||
"matches": all(identity_checks.values())}
|
||
if not report["build_identity"]["matches"]:
|
||
raise RuntimeError("build identity is stale or does not match the tested artifact: " +
|
||
", ".join(k for k, ok in identity_checks.items() if not ok))
|
||
build_env = dict(os.environ)
|
||
build_env["PATH"] = str(Path(cargo()).parent) + os.pathsep + build_env.get("PATH", "")
|
||
with tempfile.TemporaryDirectory(prefix="airdef-wasm-budget-") as temp:
|
||
isolated = Path(temp)
|
||
(isolated / "tests").mkdir()
|
||
(isolated / "tests" / "wasm_budget.toml").write_bytes(fixture_bytes)
|
||
command = [cargo(), "run", "--locked", "--manifest-path", FORK / "Cargo.toml",
|
||
"-p", "cargo-horizon-mod", "--", "horizon-mod", "test", "--hmod", artifact,
|
||
"--fuel-profile", "budget"]
|
||
print("+", " ".join(str(c) for c in command), flush=True)
|
||
result = subprocess.run([str(c) for c in command], cwd=isolated, env=build_env,
|
||
text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
|
||
print(result.stdout, end="", flush=True)
|
||
report["exit_code"] = result.returncode
|
||
report["status"] = "passed" if result.returncode == 0 else "failed"
|
||
report["output"] = result.stdout[-12000:]
|
||
samples = fuel_measurements(result.stdout)
|
||
report["measured_fuel"].update({"available": bool(samples), "callbacks": samples})
|
||
if result.returncode == 0 and not samples:
|
||
report["status"] = "failed"
|
||
raise RuntimeError("pinned runtime did not return requested callback fuel counters")
|
||
# These assertions belong to this exact fixture, not to arbitrary edited scripts.
|
||
# Two `airdef wave oreshnik` orders plus two Smart orders through the UI launch
|
||
# path (`airdef preset` + `airdef raid`, the wave screen's ПУСК handler, #122).
|
||
if result.returncode == 0 and report["scenario_sha256"] == BUDGET_ASSERTED_SHA256:
|
||
counts["accepted_raids_asserted"] = 4
|
||
counts["snapshot_airborne_asserted"] = 184
|
||
counts["snapshot_tick"] = 2102
|
||
except Exception as exc:
|
||
report["error"] = f"{type(exc).__name__}: {exc}"
|
||
except SystemExit as exc:
|
||
report["error"] = f"SystemExit: {exc.code}"
|
||
finally:
|
||
report_path.parent.mkdir(parents=True, exist_ok=True)
|
||
report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + "\n")
|
||
print(f"Budget report: {report_path}", flush=True)
|
||
if report["status"] != "passed":
|
||
sys.exit(f"WASM budget scenario failed; see {report_path}")
|
||
|
||
|
||
def install():
|
||
home = game_home()
|
||
mods = home / "horizon-mods"
|
||
mods.mkdir(parents=True, exist_ok=True)
|
||
shutil.rmtree(mods / "airdef", ignore_errors=True) # первая версия мода была папкой
|
||
shutil.copy2(hmod(), mods / "airdef.hmod")
|
||
listing = home / "horizon-mods.txt"
|
||
lines = listing.read_text().splitlines() if listing.exists() else []
|
||
lines = [l for l in lines if not l.startswith("mod.airdef:")] + ["mod.airdef:true"]
|
||
listing.write_text("\n".join(lines) + "\n")
|
||
print(f"Мод установлен в {mods} и включён")
|
||
|
||
|
||
def resources() -> Path:
|
||
if os.environ.get("HORIZON_RESOURCES"):
|
||
return Path(os.environ["HORIZON_RESOURCES"])
|
||
found = sorted(glob.glob(str(data_dir() / "horizon-launcher" / "versions" / "*" / ".local" / "horizon-client" / "26.3")))
|
||
local = FORK / ".local" / "horizon-client" / "26.3"
|
||
if local.exists():
|
||
found.append(str(local))
|
||
if not found:
|
||
sys.exit("Не найдены ресурсы игры. Установи Horizon через лаунчер и запусти его один раз "
|
||
"(он подготовит ресурсы из твоего Minecraft 26.3), либо задай HORIZON_RESOURCES.")
|
||
return Path(found[-1])
|
||
|
||
|
||
def play(args):
|
||
exe = built_game().resolve()
|
||
home = game_home()
|
||
home.mkdir(parents=True, exist_ok=True)
|
||
# Игра хранит настройки, моды и миры в текущей папке.
|
||
run([exe, "--resources", resources(), *args], cwd=home)
|
||
|
||
|
||
def fork_api():
|
||
"""Новейший уровень API форка и его таблица функций (horizon-mods/src/api_level.rs); None без форка."""
|
||
try:
|
||
text = (FORK / "crates" / "horizon-mods" / "src" / "api_level.rs").read_text(encoding="utf-8")
|
||
except OSError:
|
||
return None
|
||
try:
|
||
level = int(re.search(r"pub const LEVEL: u32 = (\d+);", text).group(1))
|
||
table = text[text.index("pub const FUNCTIONS"):]
|
||
table = table[:table.index("];")]
|
||
except (AttributeError, ValueError):
|
||
return None
|
||
return level, [(name, int(lvl)) for name, lvl in re.findall(r'\("([a-z.\-]+)", (\d+)\)', table)]
|
||
|
||
|
||
def needed_level(wasm: bytes, table) -> tuple:
|
||
"""Уровень, который нужен модулю: самая новая функция, которую он импортирует (как api_level::needed).
|
||
|
||
В компоненте имя функции записано как 0x00, длина, UTF-8 имя; по этим байтам и ищем."""
|
||
need = (0, None)
|
||
for name, level in table:
|
||
part = name.split(".", 1)[1].encode()
|
||
if level > need[0] and b"\x00" + bytes([len(part)]) + part in wasm:
|
||
need = (level, name)
|
||
return need
|
||
|
||
|
||
def game_level():
|
||
"""Уровень, который игра записала в себя (метка horizon-mod-api-level:NNNN;); None, если игры нет.
|
||
Игра без метки считается уровня 0, как в api_level::read_mark."""
|
||
try:
|
||
exe = built_game()
|
||
except SystemExit:
|
||
return None
|
||
if not exe.exists():
|
||
return None
|
||
found = re.search(rb"horizon-mod-api-level:(\d{4});", exe.read_bytes())
|
||
return int(found.group(1)) if found else 0
|
||
|
||
|
||
def check():
|
||
"""Говорит прямо, совпадают ли форк, упаковщик, уровень API мода с игрой и ресурсы. Код 0 — да, 1 — нет."""
|
||
commit = engine_commit()
|
||
problems = []
|
||
|
||
def line(name, ok, text):
|
||
print(f"[{'ok' if ok else 'нет'}] {name}: {text}")
|
||
if not ok:
|
||
problems.append(name)
|
||
|
||
current = subprocess.run(["git", "rev-parse", "HEAD"], cwd=FORK, capture_output=True, text=True).stdout.strip() if (FORK / ".git").exists() else ""
|
||
fork_ok = current == commit
|
||
line("форк", fork_ok, f"gitlink {commit}, checkout {current or 'не инициализирован'}")
|
||
packer_ok = fork_ok and packer_path().exists()
|
||
line("упаковщик", packer_ok, "repo-local, соответствует engine identity" if packer_ok else
|
||
"нет упаковщика этого форка: python3 tools/airdef.py mod")
|
||
|
||
api = fork_api()
|
||
try:
|
||
mod_file = hmod()
|
||
except SystemExit:
|
||
mod_file = None
|
||
if api is None:
|
||
line("уровень API", False, "нет или не читается horizon/crates/horizon-mods/src/api_level.rs: python3 tools/airdef.py fork")
|
||
elif mod_file is None:
|
||
line("уровень API", False, "нет airdef.hmod: python3 tools/airdef.py mod")
|
||
else:
|
||
level, table = api
|
||
with zipfile.ZipFile(mod_file) as z:
|
||
wasm = z.read("mod.wasm") if "mod.wasm" in z.namelist() else b""
|
||
need, function = needed_level(wasm, table)
|
||
game = game_level()
|
||
text = f"мод нужен {need} ({function}), форк {level}, игра " + ("не собрана" if game is None else str(game))
|
||
if game is None:
|
||
line("уровень API", False, text + ": python3 tools/airdef.py game")
|
||
else:
|
||
# Сравнивается уровень, не код: одинаковый уровень не доказывает одинаковые патчи.
|
||
supported = need <= game and game == level
|
||
line("уровень API", supported, text if supported else
|
||
text + ": игра не поддерживает мод или собрана из другого форка")
|
||
|
||
try:
|
||
res = resources()
|
||
except SystemExit as e:
|
||
res = None
|
||
line("ресурсы", False, str(e.code))
|
||
if res is not None:
|
||
try:
|
||
preparer = (FORK / "crates" / "horizon-prepare" / "src" / "lib.rs").read_text(encoding="utf-8")
|
||
schema = int(re.search(r"pub const SCHEMA: i64 = (\d+);", preparer).group(1))
|
||
except (OSError, AttributeError):
|
||
schema = None
|
||
try:
|
||
manifest = json.loads((res / "horizon-resources.json").read_text(encoding="utf-8"))
|
||
except (OSError, ValueError):
|
||
manifest = {}
|
||
ok = schema is not None and manifest.get("schema") == schema and manifest.get("minecraft") == "26.3"
|
||
line("ресурсы", ok, f"{res}, схема {schema}, Minecraft 26.3" if ok else
|
||
f"{res}: схема {manifest.get('schema')}, Minecraft {manifest.get('minecraft')}; нужны схема {schema} и Minecraft 26.3")
|
||
|
||
if problems:
|
||
sys.exit("Не совпадает: " + ", ".join(problems) + ".")
|
||
print("Всё совпадает: форк, упаковщик, уровень API мода и ресурсы.")
|
||
|
||
|
||
def main():
|
||
if len(sys.argv) < 2:
|
||
sys.exit(__doc__)
|
||
cmd, rest = sys.argv[1], sys.argv[2:]
|
||
steps = {"fork": fork, "game": game, "mod": mod, "install": install, "check": check, "test-wasm": test_wasm, "test-budgets": test_budgets}
|
||
if cmd == "play":
|
||
play(rest)
|
||
elif cmd == "all":
|
||
for step in ("fork", "game", "mod", "install"):
|
||
steps[step]()
|
||
elif cmd in steps:
|
||
steps[cmd]()
|
||
else:
|
||
sys.exit(__doc__)
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main()
|