259 lines
10 KiB
Python
Executable File
259 lines
10 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""Dump and build Raptor .SWD dialog assets.
|
|
|
|
On-disk format (little-endian), mirrored from src/swdapi.h:
|
|
|
|
SWIN header 120 bytes <8i 16s 16s 14i>
|
|
SFIELD32[] 148 bytes <8i 16s 16s i 16s 15i i> (sptr -> PlaceHolder)
|
|
text blob NUL-padded strings
|
|
|
|
Each TEXT/BUTTON/INPUT/DRAGBAR field stores its text at `txtoff` RELATIVE
|
|
TO ITS OWN RECORD (SWD_ReformatFieldData compensates the 64-bit struct
|
|
growth with `(numflds - i) * 4`, which only closes under that reading).
|
|
Other field types never dereference txtoff.
|
|
|
|
Modes:
|
|
dump <file.swd> pretty-print SWIN, fields, text blob
|
|
build <spec.py> <out.swd> assemble a .swd from a Python spec
|
|
|
|
Spec module contract (see tools/opts_swd_spec.py):
|
|
from swdbuild import BUTTON_TEMPLATE, ... # clone-source records
|
|
SWIN = {...} # all 24 ints + name/item_name strings
|
|
FIELDS = [ {...}, ... ] # {**TEMPLATE, **overrides}; "text_index" links
|
|
# the field to TEXTS[i] and computes txtoff
|
|
TEXTS = ["...", ...] # blob entries, laid out in list order
|
|
"""
|
|
|
|
import argparse
|
|
import importlib.util
|
|
import struct
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
SWIN_STRUCT = struct.Struct("<8i16s16s14i")
|
|
FIELD_STRUCT = struct.Struct("<8i16s16si16s15ii")
|
|
|
|
SWIN_KEYS = [
|
|
"version", "swdsize", "arrowflag", "display", "opt3", "opt4", "id", "type",
|
|
"name", "item_name",
|
|
"item", "picflag", "lock", "fldofs", "txtofs", "firstfld", "opt", "color",
|
|
"numflds", "x", "y", "lx", "ly", "shadow",
|
|
]
|
|
FIELD_KEYS = [
|
|
"opt", "id", "hotkey", "kbflag", "opt3", "opt4", "input_opt", "bstatus",
|
|
"name", "item_name", "item", "font_name",
|
|
"fontid", "fontbasecolor", "maxchars", "picflag", "color", "lite", "mark",
|
|
"saveflag", "shadow", "selectable", "x", "y", "lx", "ly",
|
|
]
|
|
|
|
FLD_TEXT, FLD_BUTTON, FLD_INPUT, FLD_DRAGBAR = 1, 2, 5, 6 # txtoff-carrying
|
|
|
|
|
|
def _s(raw: bytes) -> str:
|
|
return raw.split(b"\0", 1)[0].decode("ascii", "replace")
|
|
|
|
|
|
def _pack_str(text, field):
|
|
raw = text.encode("ascii")
|
|
if len(raw) > 16:
|
|
raise ValueError(f"{field}: string longer than 16 chars: {text!r}")
|
|
return raw.ljust(16, b"\0")
|
|
|
|
|
|
def _check_keys(where, given, required, optional=()):
|
|
missing = [k for k in required if k not in given]
|
|
extra = [k for k in given if k not in required and k not in optional]
|
|
if missing or extra:
|
|
raise ValueError(f"{where}: missing {missing}, unknown {extra}")
|
|
|
|
BUMPIN_TEMPLATE = {
|
|
"opt": 7, "id": 0, "hotkey": 0, "kbflag": 10, "opt3": 0, "opt4": 0,
|
|
"input_opt": 0, "bstatus": 0,
|
|
"name": "", "item_name": "",
|
|
"item": 0, "font_name": "SYSTEM_FNT", "fontid": 5, "fontbasecolor": 0,
|
|
"maxchars": 3, "picflag": 0, "color": 1, "lite": 15, "mark": 0,
|
|
"saveflag": 0, "shadow": 0, "selectable": 0,
|
|
"x": 0, "y": 0, "lx": 127, "ly": 3,
|
|
}
|
|
ICON_TEMPLATE = {
|
|
"opt": 9, "id": 0, "hotkey": 0, "kbflag": 30, "opt3": 0, "opt4": 0,
|
|
"input_opt": 0, "bstatus": 0,
|
|
"name": "PIC1", "item_name": "",
|
|
"item": -1, "font_name": "SYSTEM_FNT", "fontid": 5, "fontbasecolor": 0,
|
|
"maxchars": 1, "picflag": 2, "color": 8, "lite": 15, "mark": 0,
|
|
"saveflag": 0, "shadow": 0, "selectable": 0,
|
|
"x": 11, "y": 35, "lx": 16, "ly": 11,
|
|
}
|
|
BUTTON_TEMPLATE = {
|
|
"opt": 2, "id": 1, "hotkey": 0x20, "kbflag": 80, "opt3": 0, "opt4": 0,
|
|
"input_opt": 0, "bstatus": 0,
|
|
"name": "DETAIL", "item_name": "STEXTURE_PIC",
|
|
"item": 0x10024, "font_name": "FONT2_FNT", "fontid": 0x10004,
|
|
"fontbasecolor": 82, "maxchars": 13, "picflag": 1, "color": 8, "lite": 15,
|
|
"mark": 0, "saveflag": 0, "shadow": 1, "selectable": 0,
|
|
"x": 35, "y": 35, "lx": 118, "ly": 12,
|
|
}
|
|
TEXT_TEMPLATE = {
|
|
"opt": 1, "id": 150, "hotkey": 0, "kbflag": 90, "opt3": 0, "opt4": 0,
|
|
"input_opt": 0, "bstatus": 0,
|
|
"name": "", "item_name": "",
|
|
"item": 0, "font_name": "FONT2_FNT", "fontid": 0x10004, "fontbasecolor": 82,
|
|
"maxchars": 13, "picflag": 0, "color": 8, "lite": 15, "mark": 0,
|
|
"saveflag": 0, "shadow": 0, "selectable": 0,
|
|
"x": 35, "y": 57, "lx": 104, "ly": 8,
|
|
}
|
|
VIEWAREA_TEMPLATE = {
|
|
"opt": 11, "id": 0, "hotkey": 0, "kbflag": 110, "opt3": 0, "opt4": 0,
|
|
"input_opt": 0, "bstatus": 0,
|
|
"name": "VMUSIC", "item_name": "",
|
|
"item": 0, "font_name": "SYSTEM_FNT", "fontid": 5, "fontbasecolor": 0,
|
|
"maxchars": 1, "picflag": 0, "color": 8, "lite": 15, "mark": 0,
|
|
"saveflag": 0, "shadow": 0, "selectable": 0,
|
|
"x": 35, "y": 68, "lx": 127, "ly": 13,
|
|
}
|
|
def parse(path: Path):
|
|
"""Return (swin dict, field dicts, blob bytes) for a .swd file."""
|
|
data = path.read_bytes()
|
|
if len(data) < SWIN_STRUCT.size:
|
|
raise ValueError(f"{path}: {len(data)} bytes, shorter than SWIN header")
|
|
|
|
raw = SWIN_STRUCT.unpack_from(data, 0)
|
|
swin = dict(zip(SWIN_KEYS[:8], raw[:8]))
|
|
swin["name"] = _s(raw[8])
|
|
swin["item_name"] = _s(raw[9])
|
|
swin.update(dict(zip(SWIN_KEYS[10:], raw[10:])))
|
|
|
|
numflds = swin["numflds"]
|
|
fields = []
|
|
for i in range(numflds):
|
|
off = swin["fldofs"] + i * FIELD_STRUCT.size
|
|
if off + FIELD_STRUCT.size > len(data):
|
|
raise ValueError(f"{path}: field {i} at {off} past EOF")
|
|
fr = FIELD_STRUCT.unpack_from(data, off)
|
|
fld = dict(zip(FIELD_KEYS[:8], fr[:8]))
|
|
fld["name"] = _s(fr[8])
|
|
fld["item_name"] = _s(fr[9])
|
|
fld["item"] = fr[10]
|
|
fld["font_name"] = _s(fr[11])
|
|
fld.update(dict(zip(FIELD_KEYS[12:], fr[12:26])))
|
|
fld["txtoff"] = fr[26]
|
|
fld["_offset"] = off
|
|
fields.append(fld)
|
|
|
|
blob_start = swin["fldofs"] + numflds * FIELD_STRUCT.size
|
|
return swin, fields, data[blob_start:]
|
|
|
|
|
|
def dump(path: Path) -> None:
|
|
swin, fields, blob = parse(path)
|
|
print(f"file: {path} ({path.stat().st_size} bytes, blob at "
|
|
f"{SWIN_STRUCT.size + len(fields) * FIELD_STRUCT.size})")
|
|
print("SWIN:")
|
|
for k in SWIN_KEYS:
|
|
print(f" {k:<12} {swin[k]!r}")
|
|
for i, fld in enumerate(fields):
|
|
print(f"field[{i:2d}] at +{fld['_offset']}:")
|
|
for k in FIELD_KEYS:
|
|
print(f" {k:<14} {fld[k]!r}")
|
|
if fld["opt"] in (FLD_TEXT, FLD_BUTTON, FLD_INPUT, FLD_DRAGBAR):
|
|
blob_start = SWIN_STRUCT.size + len(fields) * FIELD_STRUCT.size
|
|
t = blob[fld["_offset"] + fld["txtoff"] - blob_start:]
|
|
text = t.split(b"\0", 1)[0].decode("ascii", "replace")
|
|
print(f" text {text!r}")
|
|
print()
|
|
|
|
|
|
def build(spec_path: Path, out_path: Path) -> None:
|
|
# Import swdbuild itself under its own name so specs can pull templates.
|
|
self_spec = importlib.util.spec_from_file_location(
|
|
"swdbuild", Path(__file__).resolve())
|
|
self_mod = importlib.util.module_from_spec(self_spec)
|
|
sys.modules["swdbuild"] = self_mod
|
|
self_spec.loader.exec_module(self_mod)
|
|
spec = importlib.util.spec_from_file_location("swd_spec", spec_path)
|
|
mod = importlib.util.module_from_spec(spec)
|
|
spec.loader.exec_module(mod)
|
|
|
|
swin_in, fields_in, texts = mod.SWIN, mod.FIELDS, mod.TEXTS
|
|
_check_keys("SWIN", swin_in, SWIN_KEYS)
|
|
if len(fields_in) != swin_in["numflds"]:
|
|
raise ValueError(f"SWIN.numflds={swin_in['numflds']} but "
|
|
f"len(FIELDS)={len(fields_in)}")
|
|
if swin_in["fldofs"] != SWIN_STRUCT.size:
|
|
raise ValueError(f"SWIN.fldofs must be {SWIN_STRUCT.size}")
|
|
|
|
# Lay out the text blob: entry i is padded to the max slot size its
|
|
# referencing fields need (SWD_SetFieldText writes maxchars bytes).
|
|
slot_size = [len(t.encode("ascii")) + 1 for t in texts]
|
|
for i, fld in enumerate(fields_in):
|
|
_check_keys(f"FIELDS[{i}] (after template merge)", fld,
|
|
FIELD_KEYS, optional=("text_index",))
|
|
ti = fld.get("text_index")
|
|
if ti is not None:
|
|
if not 0 <= ti < len(texts):
|
|
raise ValueError(f"FIELDS[{i}]: text_index {ti} out of range")
|
|
slot_size[ti] = max(slot_size[ti], fld["maxchars"])
|
|
|
|
blob = bytearray()
|
|
slot_off = []
|
|
for text, size in zip(texts, slot_size):
|
|
raw = text.encode("ascii")
|
|
if len(raw) >= size:
|
|
raise ValueError(f"TEXTS entry {text!r} does not fit slot {size}")
|
|
slot_off.append(len(blob))
|
|
blob += raw.ljust(size, b"\0")
|
|
blob_start = SWIN_STRUCT.size + len(fields_in) * FIELD_STRUCT.size
|
|
|
|
# Header bookkeeping: total file size and blob offset (the original
|
|
# asset stores exactly these; specs pass 0 and get the real values).
|
|
swin = dict(swin_in)
|
|
swin["swdsize"] = blob_start + len(blob)
|
|
swin["txtofs"] = blob_start
|
|
|
|
out = bytearray()
|
|
swin_vals = [swin[k] for k in SWIN_KEYS[:8]]
|
|
out += SWIN_STRUCT.pack(*swin_vals,
|
|
_pack_str(swin["name"], "SWIN.name"),
|
|
_pack_str(swin["item_name"], "SWIN.item_name"),
|
|
*[swin[k] for k in SWIN_KEYS[10:]])
|
|
|
|
for i, fld in enumerate(fields_in):
|
|
rec_off = SWIN_STRUCT.size + i * FIELD_STRUCT.size
|
|
txtoff = 0
|
|
ti = fld.get("text_index")
|
|
if ti is not None:
|
|
txtoff = blob_start + slot_off[ti] - rec_off
|
|
out += FIELD_STRUCT.pack(
|
|
*[fld[k] for k in FIELD_KEYS[:8]],
|
|
_pack_str(fld["name"], f"FIELDS[{i}].name"),
|
|
_pack_str(fld["item_name"], f"FIELDS[{i}].item_name"),
|
|
fld["item"],
|
|
_pack_str(fld["font_name"], f"FIELDS[{i}].font_name"),
|
|
*[fld[k] for k in FIELD_KEYS[12:]],
|
|
txtoff, 0)
|
|
|
|
assert len(out) == blob_start
|
|
out += blob
|
|
out_path.write_bytes(out)
|
|
print(f"{out_path}: {len(out)} bytes "
|
|
f"({len(fields_in)} fields, {len(texts)} text slots)")
|
|
|
|
|
|
def main() -> None:
|
|
ap = argparse.ArgumentParser(description=__doc__)
|
|
sub = ap.add_subparsers(dest="mode", required=True)
|
|
sub.add_parser("dump").add_argument("swd", type=Path)
|
|
bp = sub.add_parser("build")
|
|
bp.add_argument("spec", type=Path)
|
|
bp.add_argument("out", type=Path)
|
|
args = ap.parse_args()
|
|
|
|
if args.mode == "dump":
|
|
dump(args.swd)
|
|
else:
|
|
build(args.spec, args.out)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|