firestorm/MW4COMPARE/tools/decompile/armature_parts.py

#!/usr/bin/env python3
"""
armature_parts.py - generate a mech's `armaturedata/` and `armaturevideo/` files.

Every joint in a mech's `.contents` points at `armaturedata\\<part>.data`, which
in turn points at `armaturevideo\\<part>.video`, which names the geometry. Both
are packed as compiled records -- the `.data` becomes a 12-byte stub and the
`.video` becomes a binary renderer graph -- so neither survives extraction as
text and both have to be regenerated.

They are formulaic. Measured over the 89 shipped mechs:

  * `armaturedata/<part>.data` -- **one single shape** across all 1336 files,
    parameterised only by the part name.
  * `armaturevideo/<part>.video` -- three shapes cover 91% of 1354 files:
    with a damaged LOD, without one, and with a running-lights block.

Rules, and their measured accuracy:

  * A `DAMLOD` block iff `<part>_dam.erf` exists next to the mech. This holds for
    1327 of 1354 shipped files. **All 27 exceptions run the same way**: the
    `_dam.erf` exists but the author's `.video` ignores it. No shipped `.video`
    ever references a `_dam.erf` that is absent, so generating by this rule is
    safe by construction -- it can never produce a dangling reference, only
    occasionally more damage-state switching than the original author chose.
    The exceptions are mostly `_gun` and `_toe` parts and follow no clean rule.
  * A running-lights block iff the part is the torso and a running-lights `.erf`
    is present. 68 of the 71 torsos carry it; almost nothing else does.

    python3 armature_parts.py <mech-source-dir>
    python3 armature_parts.py --verify
"""
import argparse, os, re, sys, collections

DATA_TEMPLATE = """[gamedata]
Class=MechWarrior4::MWMover

[renderers]
VideoRenderer=armaturevideo\\{part}.video
"""

LIGHT_BLOCK = """[lightlod]
Type=ShapeComponent
Geometry={lights}
Unique=true

[lightwatcher]
Type=AttributeWatcherOfInt
Attribute=IsDark
SimulationShouldExecute=1

[lightswitch]
Type=SwitchComponent
Input=LightWatcher
Child=LightLOD

"""

LOD_BLOCK = """[lod]
Type=ShapeComponent
Geometry={part}.erf
Unique=true

"""

DAM_BLOCK = """[damlod]
Type=ShapeComponent
Geometry={part}_DAM.erf
Unique=true

"""

# joint_cage has its own shape: two empty group components, then the cage
# geometry twice (intact and destroyed), shadow-disabled.
CAGE_TEMPLATE = """[fake1]
Type=GroupComponent

[fake2]
Type=GroupComponent

[cage]
Type=ShapeComponent
Geometry={cage}
Unique=true
DisableShadow=true

[destroyedcage]
Type=ShapeComponent
Geometry={cage}
Unique=true
DisableShadow=true

[watcher]
Type=AttributeWatcherOfInt
Attribute=VisualRepresentation
SimulationShouldExecute=1

[damageappearance]
Type=SwitchComponent
Input=Watcher
Child=Fake1
Child=Fake2
Child=Cage
Child=DestroyedCage

[locator]
Child=DamageAppearance
"""


def parts_of(mech_dir):
    """Part names referenced as armaturedata\\<part>.data by the .contents."""
    out = []
    for fn in os.listdir(mech_dir):
        if not fn.lower().endswith(".contents"):
            continue
        t = open(os.path.join(mech_dir, fn), "rb").read().decode("latin-1")
        for m in re.finditer(r'armaturedata[\\/]([A-Za-z0-9_\-]+)\.data', t, re.I):
            if m.group(1) not in out:
                out.append(m.group(1))
    return out


def video_text(mech_dir, part):
    files = {f.lower(): f for f in os.listdir(mech_dir)}
    cage = next((files[f] for f in files if f.endswith("_cage.erf")), None)
    if part.lower() == "joint_cage" and cage:
        return CAGE_TEMPLATE.format(cage=cage)

    has_dam = f"{part.lower()}_dam.erf" in files
    lights = next((files[f] for f in files
                   if f.startswith("runninglights") and f.endswith(".erf")), None)
    is_torso = part.lower().endswith("torso")

    text = ""
    if lights and is_torso:
        text += LIGHT_BLOCK.format(lights=lights)
    text += LOD_BLOCK.format(part=part)
    if has_dam:
        text += DAM_BLOCK.format(part=part)
    text += """[watcher]
Type=AttributeWatcherOfInt
Attribute=VisualRepresentation
SimulationShouldExecute=1

[damageappearance]
Type=SwitchComponent
Input=Watcher
Child=LOD
"""
    if has_dam:
        text += "Child=DAMLOD\n"
    text += "\n[locator]\n"
    if lights and is_torso:
        text += "Child=LightSwitch\n"
    text += "Child=DamageAppearance\n"
    return text


def generate(mech_dir, write=True):
    """-> {relativePath: text} for every part."""
    out = {}
    for part in parts_of(mech_dir):
        out[f"armaturedata/{part}.data"] = DATA_TEMPLATE.format(part=part)
        out[f"armaturevideo/{part}.video"] = video_text(mech_dir, part)
    if write:
        for rel, text in out.items():
            p = os.path.join(mech_dir, rel)
            os.makedirs(os.path.dirname(p), exist_ok=True)
            with open(p, "wb") as fh:
                fh.write(text.replace("\n", "\r\n").encode("latin-1"))
    return out


def norm(text, part):
    t = re.sub(r'//[^\n]*', '', text).replace("\r", "")
    t = re.sub(re.escape(part), "PART", t, flags=re.I)
    return re.sub(r'\n+', "\n", t).strip().lower()


def verify():
    import glob
    MECHS = "/home/rich/Repositories/firestorm/Gameleap/mw4/Content/Mechs"
    t = collections.Counter()
    diffs = collections.Counter()
    for d in sorted(glob.glob(MECHS + "/*")):
        if not os.path.isdir(d) or not glob.glob(d + "/armaturedata/*.data"):
            continue
        gen = generate(d, write=False)
        for rel, text in gen.items():
            p = os.path.join(d, rel)
            part = os.path.basename(rel).rsplit(".", 1)[0]
            kind = rel.split("/")[0]
            if not os.path.exists(p):
                t[kind + " absent"] += 1
                continue
            t[kind] += 1
            want = open(p, "rb").read().decode("latin-1")
            if norm(want, part) == norm(text, part):
                t[kind + " ok"] += 1
            else:
                diffs[kind] += 1
    print(f"armaturedata : {t['armaturedata ok']}/{t['armaturedata']} reproduced")
    print(f"armaturevideo: {t['armaturevideo ok']}/{t['armaturevideo']} reproduced")
    if t["armaturedata absent"] or t["armaturevideo absent"]:
        print(f"  referenced but absent on disk: "
              f"{t['armaturedata absent']} data, {t['armaturevideo absent']} video")


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("mech_dir", nargs="?")
    ap.add_argument("--verify", action="store_true")
    args = ap.parse_args()
    if args.verify:
        verify()
        return
    if not args.mech_dir:
        ap.error("mech_dir required")
    out = generate(args.mech_dir)
    print(f"wrote {len(out)} files into {args.mech_dir}")


if __name__ == "__main__":
    main()