madkit 0.1.0__py3-none-any.whl

madkit/cli/__init__.py

@@ -0,0 +1,3 @@
+from .cli import app, main
+
+__all__ = ["app", "main"]

madkit/cli/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

madkit/cli/cli.py

@@ -0,0 +1,15 @@
+import cyclopts
+
+app = cyclopts.App(name="madkit", version="1.0.0-LittleEndian")
+
+
+def main() -> None:
+    from .commands import unpack  # type: ignore # noqa: F401
+    from .commands import unpack_directory  # type: ignore # noqa: F401
+    from .commands import repack  # type: ignore # noqa: F401
+    #from .commands import txd_unpack  # type: ignore # noqa: F401
+    #from .commands import txd_add_texture  # type: ignore # noqa: F401
+    from .commands import mod  # type: ignore # noqa: F401
+    from .commands import config  # type: ignore # noqa: F401
+
+    app()

madkit/cli/commands/config.py

@@ -0,0 +1,26 @@
+from pathlib import Path
+
+from ..cli import app
+from ..settings import SETTINGS_FILE, load_settings, save_settings
+
+
+@app.command
+def config(game_dir: Path | None = None, levels_dir: Path | None = None):
+    """Create or update settings.toml, then print it.
+
+    Parameters
+    ----------
+    game_dir : Path
+        Game install folder (the one containing Levels/).
+    levels_dir : Path
+        Folder with the stock .stream files that mods are built from.
+    """
+    settings = load_settings()
+    if game_dir is not None:
+        settings.game_dir = game_dir
+    if levels_dir is not None:
+        settings.levels_dir = levels_dir
+
+    save_settings(settings)
+    print(f"{SETTINGS_FILE.resolve()}:\n")
+    print(settings.to_toml())

madkit/cli/commands/mod.py

@@ -0,0 +1,138 @@
+import shutil
+import tomllib
+from pathlib import Path
+
+import cyclopts
+
+from ..cli import app
+from ..settings import load_settings
+from madformats.mod import collect
+from madformats.stream import RW_StreamFile, load_stream
+
+MODS_DIR = Path("mods")
+
+mod_app = cyclopts.App(name="mod", help="Create, build and install mods.")
+app.command(mod_app)
+
+MOD_TOML_TEMPLATE = """\
+name = "{name}"
+description = ""
+"""
+
+BUILD_PY_TEMPLATE = """\
+from pathlib import Path
+
+from madformats.mod import level
+from madformats.stream import RW_StreamFile
+
+ASSETS = Path(__file__).parent / "assets"
+
+
+@level("{level}")
+def edit_{level}({level}: RW_StreamFile) -> None:
+    # =================================
+
+    # YOUR MODDING CODE HERE ;)
+
+    # =================================
+    pass
+"""
+
+
+def _mod_dir(name: str) -> Path:
+    mod_dir = MODS_DIR / name
+    if not (mod_dir / "build.py").is_file():
+        raise SystemExit(f"No mod at {mod_dir} (missing build.py)")
+    return mod_dir
+
+
+@mod_app.command
+def init(name: str, level: str = "kingofny"):
+    """Create a new mod folder from the template.
+
+    Parameters
+    ----------
+    name : str
+        Mod name, becomes the folder mods/NAME.
+    level : str
+        Level the template's first @level function edits.
+    """
+    mod_dir = MODS_DIR / name
+    if mod_dir.exists():
+        raise SystemExit(f"{mod_dir} already exists")
+
+    (mod_dir / "assets").mkdir(parents=True)
+    (mod_dir / "mod.toml").write_text(MOD_TOML_TEMPLATE.format(name=name))
+    (mod_dir / "build.py").write_text(BUILD_PY_TEMPLATE.format(level=level))
+    print(f"Created {mod_dir}")
+
+
+def _build(name: str) -> list[Path]:
+    mod_dir = _mod_dir(name)
+    with open(mod_dir / "mod.toml", "rb") as f:
+        manifest = tomllib.load(f)
+
+    entries = collect(mod_dir / "build.py")
+    if not entries:
+        raise SystemExit(f"{mod_dir / 'build.py'} has no @level functions")
+
+    levels_dir = load_settings().levels_dir
+    levels: dict[str, RW_StreamFile] = {}
+    for names, _ in entries:
+        for level_name in names:
+            if level_name not in levels:
+                levels[level_name] = load_stream(levels_dir / f"{level_name}.stream")
+
+    for names, fn in entries:
+        print(f"{fn.__name__}({', '.join(names)})")
+        fn(*(levels[n] for n in names))
+
+    out_dir = mod_dir / "build"
+    out_dir.mkdir(exist_ok=True)
+    written: list[Path] = []
+    for level_name, strm in levels.items():
+        strm.updatePlacementNew()
+        strm.verify()
+        out_file = out_dir / f"{level_name}.stream"
+        strm.save(out_file)
+        written.append(out_file)
+
+    print(f"Built {manifest.get('name', name)}: {', '.join(str(p) for p in written)}")
+    return written
+
+
+@mod_app.command
+def build(name: str):
+    """Run a mod's @level functions and write the levels to mods/NAME/build/.
+
+    Parameters
+    ----------
+    name : str
+        Mod name (folder in mods/).
+    """
+    _build(name)
+
+
+@mod_app.command
+def install(name: str, game_dir: Path | None = None):
+    """Build a mod and copy its levels into the game's Levels folder.
+
+    Parameters
+    ----------
+    name : str
+        Mod name (folder in mods/).
+    game_dir : Path
+        Game install folder (the one containing Levels/). Defaults to game_dir in settings.toml.
+    """
+    if game_dir is None:
+        game_dir = load_settings().game_dir
+        if game_dir is None:
+            raise SystemExit("Pass --game-dir or run: uv run madkit config --game-dir PATH")
+
+    game_levels = game_dir / "Levels"
+    if not game_levels.is_dir():
+        raise SystemExit(f"{game_levels} does not exist")
+
+    for built in _build(name):
+        shutil.copy2(built, game_levels / built.name)
+        print(f"Installed {game_levels / built.name}")

madkit/cli/commands/repack.py

@@ -0,0 +1,72 @@
+from ..cli import app
+from ..utils import ValidatedDir, ValidatedFile, progress
+from madformats.lib.rwConstants import strfunc_func
+import json
+import io
+from pathlib import Path
+from typing import cast
+from madformats.streamfuncs.stringfuncs.sf_LoadEmbeddedAsset import RW_sf_LoadEmbeddedAsset
+from madformats.stream import RW_StreamFile
+from madformats.streamfuncs import STRFUNC_REGISTRY
+from madformats.lib.rw_basics import RW_StreamFunc_NotImplemented
+
+@app.command
+def repack(
+    input_dir: ValidatedDir, out_stream_file_dir: ValidatedFile, gzipped: bool = False
+):
+    """Repack a stream from a directory (including a manifest).
+
+    Parameters
+    ----------
+    input_dir : str
+        Directory to repack from.
+    out_stream_file_dir : str
+        File to repack into.
+    gzipped : bool
+        Whether the output stream file should be gzipped or not.
+    """
+
+    MANIFEST_FILE = Path(input_dir, "manifest.json")
+
+    with open(MANIFEST_FILE, "r") as f:
+        manifest_contents = json.load(f)
+
+    strm = RW_StreamFile()
+    for sec_dict in progress(manifest_contents, description="Processing..."):
+        streamfunc_name = sec_dict.pop("streamfunc")
+        file_name = sec_dict.pop("file_name", None)
+        streamfunc = strfunc_func[streamfunc_name] if streamfunc_name else None
+
+        assert streamfunc is not None, (
+            f"Streamfunc {streamfunc_name} not found in manifest."
+        )
+
+        streamfunc_class = STRFUNC_REGISTRY.get(
+            streamfunc.value, RW_StreamFunc_NotImplemented
+        )
+
+        streamfunc_inst = streamfunc_class.from_dict(sec_dict)
+
+        if streamfunc == strfunc_func.sf_LoadEmbeddedAsset:
+            sec = cast(RW_sf_LoadEmbeddedAsset, streamfunc_inst)
+            assert file_name is not None, (
+                "Manifest entry is missing 'file_name' for sf_LoadEmbeddedAsset."
+            )
+            with open(Path(input_dir, file_name), "rb") as f:
+                sec.data = f.read()
+        strm.contents.append(streamfunc_inst)
+
+    buf = io.BytesIO()
+    strm.verify()
+    strm.updatePlacementNew()
+    strm.write(buf, 0x1802FFFF)
+
+    if gzipped:
+        import gzip
+
+        with open(out_stream_file_dir, "wb") as f:
+            f.write(gzip.compress(buf.getvalue(), compresslevel=6))
+    else:
+        with open(out_stream_file_dir, "wb") as f:
+            f.write(buf.getvalue())
+

madkit/cli/commands/txd_add_texture.py

@@ -0,0 +1,43 @@
+from madformats.sections.TEXTURENATIVE_0015 import create_texture
+
+from ..cli import app
+from ..utils import (
+    ValidatedExistingFile,
+)
+from madformats.txd import load_txd
+from pathlib import Path
+from PIL import Image
+
+@app.command
+def txd_add_texture(
+    txd_file: ValidatedExistingFile,
+    texture_file: ValidatedExistingFile,
+):
+    """Add a texture to a TXD. THIS ONLY WORKS FOR XBOX TEXTURE DICTIONARYS!
+
+    Parameters
+    ----------
+    txd_file : str
+        File to unpack.
+    texture_file : str
+        BMP file to add
+    """
+
+    texture_name = Path(texture_file).stem
+
+    image = Image.open(texture_file).convert("RGBA")
+
+    pixel_data = image.tobytes()
+
+    txdfile = load_txd(txd_file)
+    txdfile.add_texture(
+        create_texture(
+            name=texture_name,
+            rgba=pixel_data,
+            width=image.size[0],
+            height=image.size[1],
+        )
+    )
+
+    with open(txd_file, "wb") as f:
+        txdfile.write(f, txdfile.header.library_id_stamp)

madkit/cli/commands/txd_unpack.py

@@ -0,0 +1,26 @@
+from ..cli import app
+from ..utils import (
+    ValidatedExistingFile,
+    ValidatedDir,
+)
+from madformats.txd import load_txd
+import os
+
+@app.command
+def txd_unpack(
+    txd_file: ValidatedExistingFile,
+    output_dir: ValidatedDir,
+):
+    """Unpack all textures of a txd into a folder
+
+    Parameters
+    ----------
+    txd_file : str
+        File to unpack.
+    output_dir : str
+        Directory to unpack the stream file into.
+    """
+
+    os.makedirs(output_dir, exist_ok=True)
+    txdfile = load_txd(txd_file)
+    txdfile.export_all(output_dir, raise_on_error=True)

madkit/cli/commands/unpack.py

@@ -0,0 +1,96 @@
+from enum import Enum
+
+from ..cli import app
+from ..utils import (
+    ValidatedExistingFile,
+    ValidatedDir,
+    progress,
+    loadEmbeddedAssets_to_file_name,
+    sanitize_filename,
+)
+from madformats.stream import load_stream
+from madformats.lib.rwConstants import strfunc_func
+import json
+import os
+from pathlib import Path
+from typing import Any, cast
+from madformats.streamfuncs.stringfuncs.sf_LoadEmbeddedAsset import RW_sf_LoadEmbeddedAsset
+
+
+class FileNaming(Enum):
+    GUID = 0
+    SEC_IDX = 1
+
+
+@app.command
+def unpack(
+    stream_file: ValidatedExistingFile,
+    output_dir: ValidatedDir,
+    naming: FileNaming = FileNaming.SEC_IDX,
+    human: bool = True,
+    gzipped: bool = False,
+):
+    """Unpack a stream files assets into a directory (including a manifest).
+
+    Parameters
+    ----------
+    stream_file : str
+        File to unpack.
+    output_dir : str
+        Directory to unpack the stream file into.
+    human : bool
+        Whether to make the manifest more human-readable (pretty-printed).
+    gzipped : bool
+        Whether the stream file is gzipped or not.
+    """
+
+    strm = load_stream(stream_file, gzipped=gzipped)
+
+    os.makedirs(output_dir, exist_ok=True)
+
+    MANIFEST_FILE = Path(output_dir, "manifest.json")
+    MANIFEST_CONTENTS: list[dict[str, Any]] = []
+
+    enumerated_contents = enumerate(strm.contents)
+    for i, sec in progress(
+        enumerate(strm.contents),
+        description=f"Processing {stream_file.name}...",
+        total=len(list(enumerated_contents)),
+    ):
+        extra: dict[str, Any] = {}
+
+        if sec.streamfunc == strfunc_func.sf_LoadEmbeddedAsset:
+            sec = cast(RW_sf_LoadEmbeddedAsset, sec)
+
+            base_file_name = loadEmbeddedAssets_to_file_name(sec)
+
+            stem = Path(base_file_name).stem
+            suffix = Path(base_file_name).suffix
+
+            if naming == FileNaming.GUID:
+                file_name = f"{stem}_{{{sec.guid}}}{suffix}"
+
+            elif naming == FileNaming.SEC_IDX:
+                file_name = f"{i}_{stem}{suffix}"
+
+            file_name = sanitize_filename(file_name)
+
+            with open(Path(output_dir, file_name), "wb") as f:
+                f.write(sec.data)
+
+            extra["file_name"] = file_name
+
+        sec_dict = sec.to_dict()
+        MANIFEST_CONTENTS.append(
+            {
+                "streamfunc": sec.streamfunc.name if sec.streamfunc else None,
+                **sec_dict,
+                **extra,
+            }
+        )
+
+    with open(MANIFEST_FILE, "w") as f:
+        if human:
+            json.dump(MANIFEST_CONTENTS, f, indent=4)
+        else:
+            json.dump(MANIFEST_CONTENTS, f)

madkit/cli/commands/unpack_directory.py

@@ -0,0 +1,31 @@
+from pathlib import Path
+
+from ..cli import app
+from ..utils import (
+    ValidatedExistingDir,
+)
+from .unpack import unpack, FileNaming
+import os
+
+@app.command
+def unpack_directory(
+    stream_folder_dir: ValidatedExistingDir,
+    naming: FileNaming = FileNaming.SEC_IDX,
+    human: bool = True,
+    gzipped: bool = False,
+):
+    """Unpack all stream files in a directory, for more info look at the command "unpack".
+
+    Parameters
+    ----------
+    stream_folder_dir : str
+        Folder with the .stream files in it
+    human : bool
+        Whether to make the manifest more human-readable (pretty-printed).
+    gzipped : bool
+        Whether the stream file is gzipped or not.
+    """
+    for file in Path(stream_folder_dir).glob("*.stream"):
+        output_dir = Path(stream_folder_dir, file.stem)
+        os.makedirs(output_dir, exist_ok=True)
+        unpack(file, output_dir, naming=naming, human=human, gzipped=gzipped)

madkit/cli/settings.py

@@ -0,0 +1,38 @@
+import tomllib
+from dataclasses import dataclass
+from pathlib import Path
+
+SETTINGS_FILE = Path("settings.toml")
+
+
+@dataclass
+class Settings:
+    game_dir: Path | None = None  # game install folder, the one containing Levels/
+    levels_dir: Path = Path("Levels")  # stock .stream files that mods are built from
+
+    def to_toml(self) -> str:
+        game_dir = f"'{self.game_dir.as_posix()}'" if self.game_dir else "''"
+        return (
+            "# Generated by `uv run madkit config`. Machine-specific, not tracked by git.\n\n"
+            "# Game install folder (the one containing Levels/), used by `cli mod install`\n"
+            f"game_dir = {game_dir}\n\n"
+            "# Stock .stream files that mods are built from\n"
+            f"levels_dir = '{self.levels_dir.as_posix()}'\n"
+        )
+
+
+def load_settings() -> Settings:
+    if not SETTINGS_FILE.is_file():
+        return Settings()
+    with open(SETTINGS_FILE, "rb") as f:
+        data = tomllib.load(f)
+    settings = Settings()
+    if data.get("game_dir"):
+        settings.game_dir = Path(data["game_dir"])
+    if data.get("levels_dir"):
+        settings.levels_dir = Path(data["levels_dir"])
+    return settings
+
+
+def save_settings(settings: Settings) -> None:
+    SETTINGS_FILE.write_text(settings.to_toml())

madkit/cli/utils.py

@@ -0,0 +1,89 @@
+from collections.abc import Iterable, Iterator, Sized
+from rich.progress import (
+    Progress,
+    TextColumn,
+    BarColumn,
+    TaskProgressColumn,
+    MofNCompleteColumn,
+    TimeRemainingColumn,
+)
+import re
+from cyclopts import Parameter, validators
+from typing import Annotated
+from pathlib import Path
+
+from madformats.streamfuncs.stringfuncs.sf_LoadEmbeddedAsset import RW_sf_LoadEmbeddedAsset
+
+def progress[T](
+    iterable: Iterable[T],
+    description: str = "Processing...",
+    total: int | None = None,
+) -> Iterator[T]:
+    if total is None and isinstance(iterable, Sized):
+        total = len(iterable)
+
+    with Progress(
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TaskProgressColumn(),
+        MofNCompleteColumn(),
+        TimeRemainingColumn(),
+    ) as p:
+        task = p.add_task(description, total=total)
+
+        for item in iterable:
+            yield item
+            p.advance(task)
+
+def sanitize_filename(file_name: str) -> str:
+    """Make a filename valid on Windows."""
+    return re.sub(r'[<>:"/\\|?*]', "_", file_name)
+
+ValidatedExistingPath = Annotated[
+    Path,
+    Parameter(validator=validators.Path(exists=True)),
+]
+ValidatedExistingFile = Annotated[
+    Path,
+    Parameter(validator=validators.Path(exists=True, file_okay=True, dir_okay=False)),
+]
+ValidatedExistingDir = Annotated[
+    Path,
+    Parameter(validator=validators.Path(exists=True, file_okay=False, dir_okay=True)),
+]
+ValidatedDir = Annotated[
+    Path,
+    Parameter(validator=validators.Path(file_okay=False, dir_okay=True)),
+]
+ValidatedFile = Annotated[
+    Path,
+    Parameter(validator=validators.Path(file_okay=True, dir_okay=False)),
+]
+
+
+def loadEmbeddedAssets_to_file_name(sec: RW_sf_LoadEmbeddedAsset) -> str:
+    file_name = Path(sec.name).stem
+    if sec.type == "rwID_TEXDICTIONARY":  # Texture Dictionary
+        file_name += ".txd"
+    elif sec.type == "rwaID_WAVEDICT":  # Wave Dictionary
+        file_name += ".rws"
+    elif sec.type == "rwID_WORLD":  # World
+        file_name += ".bsp"
+    elif sec.type == "TextStringDict":  # Text String Dict (Localization)
+        file_name += ".txl"
+    elif sec.type == "rwID_CLUMP":  # Clump (Model)
+        file_name += ".dff"
+    elif sec.type == "rwID_HANIMANIMATION":  # Bone Animation
+        file_name += ".anm"
+    elif sec.type == "SCRIPT":  # TFBScript
+        file_name += ".ai"
+    elif sec.type == "rwID_2DFONT":
+        file_name += ".fnt"
+    elif sec.type == "KFset":
+        file_name += ".lpa"
+    elif sec.type == "TEXT":
+        file_name += ".txt" # NOT CONFIRMED EXTENSION
+    else:
+        file_name += Path(sec.name).suffix
+
+    return file_name

madkit/tools/analyze/__init__.py

@@ -0,0 +1,5 @@
+"""Interactive RenderWare file analyzer GUI."""
+
+from .app import run
+
+__all__ = ["run"]

madkit/tools/analyze/__main__.py

@@ -0,0 +1,28 @@
+"""CLI entry point: ``python -m madkit.tools.analyze [FILE]``."""
+
+import argparse
+
+from .app import run
+
+# Previously hardcoded samples, kept for quick reference:
+#   Levels/KingOfNY/170_marty.dff
+#   Levels/KingOfNY-unchanged/92_TreasureDoor.dff
+#   Levels/KingOfNY-unchanged/2_TD_LEVEL FOLDER.txd
+#   Levels/KingOfNY/48_janitor_walk.anm
+DEFAULT_FILE = "Levels/KingOfNY-unchanged/416_marty_jump.anm"
+
+
+def main():
+    ap = argparse.ArgumentParser(prog="analyze", description=__doc__)
+    ap.add_argument(
+        "file",
+        nargs="?",
+        default=DEFAULT_FILE,
+        help=f"RenderWare file to open (default: {DEFAULT_FILE})",
+    )
+    args = ap.parse_args()
+    run(args.file)
+
+
+if __name__ == "__main__":
+    main()