Files
NX2navi/launcher/build.py
chrg6 18a86dd652 Show what the check of the game files found.
The check printed its counts into the build's lines only, so a player
whose build ended with "4 damaged, 3 given a stand-in, 1 left as they
are" saw nothing of it. A job now reads romfs-check.json after the build:
the count goes into the step's row, and when the check ran in that job, a
sentence goes onto the home screen and into launcher.log.

The same four files are flagged on every copy of the game, and three of
them get a stand-in. For those the sentence says so and that nothing
needs doing; other files are counted and romfs-check.json is named.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-10 15:27:55 -05:00

186 lines
7.4 KiB
Python

"""Running tools/make_game.py for the launcher: the command line, its "@@" progress lines (make_game.py --events)
and cancelling it with every compiler it started."""
import json
import os
import signal
import stat
import subprocess
import threading
# Runs make_game.py with pydeps/ (zbic) and the script's folder first on sys.path; the embeddable Python's ._pth
# file leaves both off.
RUN = ('import os, runpy, sys; p = sys.argv[1]; s = sys.argv[2]; sys.argv = sys.argv[2:]; '
'sys.path[:0] = [x for x in p.split(os.pathsep) if x] + [os.path.dirname(os.path.abspath(s))]; '
'runpy.run_path(s, run_name="__main__")')
CREATE_NO_WINDOW = 0x08000000
CREATE_NEW_PROCESS_GROUP = 0x00000200
def command(layout, args):
return [layout.python_for_builds(), '-I', '-c', RUN, str(layout.pydeps), str(layout.make_game), *map(str, args),
'--events']
def has_prompt_art(layout):
"""True when this version holds button art (app/<version>/prompt-art, tools/prompt_art.py FOLDER): make_game.py
then draws the button prompts in a step of its own, and the jobs show a row for it."""
return (layout.app / 'prompt-art').is_dir()
def install_args(layout, dump, game_dir):
dump = str(dump)
if os.path.isdir(dump):
src = ['--exefs', os.path.join(dump, 'exefs'), '--romfs', os.path.join(dump, 'romfs')]
else:
src = ['--nup', dump]
return [*src, '--out', str(game_dir), '--msys', str(layout.msys)]
def rebuild_args(layout, game_dir, retune=False):
"""retune: Rebuild the Game, which compiles the game's code for this processor's level; an update keeps the level
its objects were compiled for, so that it compiles only what changed (tools/make_game.py lifted_level)."""
return ['--rebuild', *(['--retune'] if retune else []), '--out', str(game_dir), '--msys', str(layout.msys)]
def check_args(dump):
dump = str(dump)
if os.path.isdir(dump):
return ['--exefs', os.path.join(dump, 'exefs'), '--romfs', os.path.join(dump, 'romfs'), '--check']
return ['--nup', dump, '--check']
class BuildError(Exception):
pass
class Run:
"""One make_game.py process. on_event(dict) for each "@@" line, on_line(str) for every other line; wait()
returns the exit code. cancel() ends the process and its children."""
def __init__(self, cmd, on_event, on_line, cwd=None):
self.error = None
kw = {}
if os.name == 'nt':
kw['creationflags'] = CREATE_NO_WINDOW | CREATE_NEW_PROCESS_GROUP
else:
kw['start_new_session'] = True
env = dict(os.environ, PYTHONUNBUFFERED='1', PYTHONIOENCODING='utf-8')
self.proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, stdin=subprocess.DEVNULL,
cwd=cwd, env=env, text=True, encoding='utf-8', errors='replace', bufsize=1, **kw)
self.cancelled = False
self._reader = threading.Thread(target=self._read, args=(on_event, on_line), daemon=True)
self._reader.start()
def _read(self, on_event, on_line):
for line in self.proc.stdout:
line = line.rstrip('\r\n')
if line.startswith('@@'):
try:
ev = json.loads(line[2:])
except ValueError:
on_line(line)
continue
if ev.get('ev') == 'error':
self.error = ev.get('message')
on_event(ev)
elif line.startswith('error: ') and not self.error:
self.error = line[7:]
on_line(line)
else:
on_line(line)
def wait(self):
code = self.proc.wait()
self._reader.join(5)
return code
def cancel(self):
self.cancelled = True
if self.proc.poll() is not None:
return
if os.name == 'nt':
subprocess.run(['taskkill', '/T', '/F', '/PID', str(self.proc.pid)], capture_output=True,
creationflags=CREATE_NO_WINDOW)
else:
try:
os.killpg(self.proc.pid, signal.SIGTERM)
except (ProcessLookupError, PermissionError):
pass
def game_running(game_dir, exe='ocarina.exe'):
"""True when the built game runs from game_dir: Windows refuses to open a running exe for writing. A read-only
exe (a copy restored from a backup or read-only media) is refused too, though nothing runs it: its read-only
attribute is cleared and the open tried again, as the next build replaces the file anyway."""
path = os.path.join(str(game_dir), exe)
if os.name != 'nt' or not os.path.isfile(path):
return False
for attempt in range(2):
try:
with open(path, 'r+b'):
return False
except PermissionError:
if attempt or not os.stat(path).st_file_attributes & stat.FILE_ATTRIBUTE_READONLY:
return True
try:
os.chmod(path, stat.S_IREAD | stat.S_IWRITE)
except OSError:
return True
except OSError:
return False
return True
def build_state(game_dir):
"""The game folder's build-cache/state.json (make_game.py), or {}."""
try:
with open(os.path.join(str(game_dir), 'build-cache', 'state.json'), encoding='utf-8') as f:
return json.load(f)
except (OSError, ValueError):
return {}
def built_version(game_dir):
"""The kit version that last built the game folder ('' when none finished)."""
st = build_state(game_dir)
if 'compile' in st.get('steps', {}) and os.path.isfile(os.path.join(str(game_dir), 'ocarina.exe')):
return st.get('kit', '')
return ''
def scan_report(game_dir):
"""What the check of the game files found (tools/romfs_check.py writes <game>/romfs-check.json): (the paths of
the damaged files, how many of them got a stand-in), or None when the folder has no readable report."""
try:
with open(os.path.join(str(game_dir), 'romfs-check.json'), encoding='utf-8') as f:
report = json.load(f)
return sorted(report['damaged']), len(report.get('repaired') or ())
except (OSError, ValueError, KeyError, TypeError):
return None
def can_rebuild(game_dir):
st = build_state(game_dir)
return st.get('version') == 2 and all(s in st.get('steps', {}) for s in ('exefs', 'romfs'))
def unpacked(game_dir):
"""True when the game files a rebuild reads are in the game folder (make_game.py BuiltSource names the same
ones): the unpacked ExeFS, the RomFS image and its index."""
gd = str(game_dir)
return all(os.path.isfile(os.path.join(gd, *parts)) for parts in
(('exefs', 'main'), ('romfs', 'romfs.bin'), ('romfs', 'index.json')))
def installed(game_dir):
"""True when the game folder holds a game the player can start: a finished build, or the exe of the last
finished build beside a build that stopped later. make_game.py drops a step's record when a step before it
runs again, so an update that lifted again and then stopped in the compile (an error, Cancel, a power cut)
leaves state.json without `compile` and built_version says '': the old exe is still there and playable, and
a rebuild continues from the unpacked game files without the dump (can_rebuild)."""
if not game_dir:
return False
if built_version(game_dir):
return True
return os.path.isfile(os.path.join(str(game_dir), 'ocarina.exe')) and can_rebuild(game_dir)