unirebuild 0.0.1__tar.gz

unirebuild-0.0.1/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.3
+Name: unirebuild
+Version: 0.0.1
+Summary: A modular framework for patching Unity games.
+Author: Nuutti
+Author-email: Nuutti <snuutti@protonmail.com>
+Requires-Dist: colorlog>=6.10.1
+Requires-Dist: pyyaml>=6.0.3
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+# UniRebuild

unirebuild-0.0.1/README.md

@@ -0,0 +1 @@
+# UniRebuild

unirebuild-0.0.1/pyproject.toml

@@ -0,0 +1,25 @@
+[project]
+name = "unirebuild"
+version = "0.0.1"
+description = "A modular framework for patching Unity games."
+readme = "README.md"
+authors = [
+    { name = "Nuutti", email = "snuutti@protonmail.com" }
+]
+requires-python = ">=3.14"
+dependencies = [
+    "colorlog>=6.10.1",
+    "pyyaml>=6.0.3",
+]
+
+[build-system]
+requires = ["uv_build>=0.11.15,<0.12.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "ruff>=0.15.16",
+]
+
+[tool.ruff.lint.per-file-ignores]
+"__init__.py" = ["F401"]

unirebuild-0.0.1/src/unirebuild/__init__.py

@@ -0,0 +1 @@
+from .core import UniRebuild

unirebuild-0.0.1/src/unirebuild/constants.py

@@ -0,0 +1,10 @@
+GUID_REFERENCE_EXTENSIONS = {
+    ".anim",
+    ".meta",
+    ".controller",
+    ".asset",
+    ".mat",
+    ".mixer",
+    ".prefab",
+    ".unity",
+}

unirebuild-0.0.1/src/unirebuild/context.py

@@ -0,0 +1,97 @@
+import logging
+import os
+import shutil
+import subprocess
+import sys
+
+
+class PatcherContext:
+    def __init__(self, game_name: str, workspace_dir: str, temp_dir: str):
+        self.game_name = game_name
+        self.workspace_dir = os.path.abspath(workspace_dir)
+        self.temp_dir = os.path.abspath(temp_dir)
+        self.platform = sys.platform
+        self.is_ci = "CI" in os.environ
+        self.args = None
+        self.setup_steps = []
+        self.rebuild_steps = []
+        self.__executable_cache = {}
+
+    def get_temp_path(self, *paths: str) -> str:
+        """Resolves a path within the temporary directory."""
+        return os.path.join(self.temp_dir, *paths)
+
+    def get_extracted_path(self) -> str:
+        """Returns the path where the app was extracted."""
+        return self.get_temp_path("extracted_app")
+
+    def find_executable(self, name: str) -> str | None:
+        """Finds the path of an executable on the system path or in the current directory."""
+        if name in self.__executable_cache:
+            return self.__executable_cache[name]
+
+        search_name = name
+        if self.platform == "win32":
+            search_name += ".exe"
+
+        local_path = os.path.abspath(os.path.join(os.getcwd(), search_name))
+        if os.path.isfile(local_path) and os.access(local_path, os.X_OK):
+            self.__executable_cache[name] = local_path
+            return local_path
+
+        system_path = shutil.which(search_name)
+        if system_path:
+            abs_system_path = os.path.abspath(system_path)
+            self.__executable_cache[name] = abs_system_path
+            return abs_system_path
+
+        return None
+
+    def find_unity(self, version: str) -> list[str] | None:
+        """Finds the Unity executable for a given version."""
+        cache_key = f"unity_{version}"
+        if cache_key in self.__executable_cache:
+            return self.__executable_cache[cache_key]
+
+        if self.is_ci:
+            docker_cmd = [
+                "docker",
+                "run",
+                "--rm",
+                "-v",
+                f"{os.getcwd()}:{os.getcwd()}",
+                "-w",
+                os.getcwd(),
+                f"unityci/editor:ubuntu-{version}-linux-il2cpp-3",
+                "unity-editor",
+            ]
+            self.__executable_cache[cache_key] = docker_cmd
+            return docker_cmd
+
+        unity_path = ""
+        if self.platform == "linux":
+            unity_path = os.path.expanduser(
+                f"~/Unity/Hub/Editor/{version}/Editor/Unity"
+            )
+        elif self.platform == "darwin":
+            unity_path = f"/Applications/Unity/Hub/Editor/{version}/Unity.app/Contents/MacOS/Unity"
+        elif self.platform == "win32":
+            unity_path = f"C:/Program Files/Unity/Hub/Editor/{version}/Editor/Unity.exe"
+
+        if unity_path and os.path.isfile(unity_path):
+            cmd = [unity_path]
+            self.__executable_cache[cache_key] = cmd
+            return cmd
+
+        return None
+
+    def run_cmd(
+        self, cmd: list[str], cwd: str | None = None, ignore_errors: bool = False
+    ) -> int:
+        """Runs a command and returns the exit code."""
+        logging.info("Running command: %s", " ".join(cmd))
+        result = subprocess.run(cmd, cwd=cwd)
+        if result.returncode != 0 and not ignore_errors:
+            raise RuntimeError(f"Command failed with exit code {result.returncode}")
+
+        return result.returncode

unirebuild-0.0.1/src/unirebuild/core.py

@@ -0,0 +1,123 @@
+import argparse
+import logging
+import os
+import shutil
+import sys
+
+import colorlog
+
+from . import steps
+from .steps import PatcherStep
+from .context import PatcherContext
+
+
+class UniRebuild:
+    def __init__(self, game_name: str, workspace_dir: str, temp_dir: str = "Temp"):
+        self.context = PatcherContext(game_name, workspace_dir, temp_dir)
+        self.setup_steps = []
+        self.rebuild_steps = []
+
+    def add_setup_steps(self, steps: list):
+        self.setup_steps.extend(steps)
+
+    def add_rebuild_steps(self, steps: list):
+        self.rebuild_steps.extend(steps)
+
+    def execute(self):
+        colorlog.basicConfig(
+            level=logging.INFO, format="%(log_color)s%(levelname)s: %(message)s"
+        )
+
+        sys.stdout.reconfigure(line_buffering=True)
+
+        if not self.rebuild_steps:
+            self.rebuild_steps.append(steps.RebuildPatches())
+
+        parser = argparse.ArgumentParser(
+            description=f"UniRebuild - {self.context.game_name} Patcher"
+        )
+        subparsers = parser.add_subparsers(dest="command", required=True)
+
+        parser_setup = subparsers.add_parser("setup", help="Set up the workspace")
+        parser_rebuild = subparsers.add_parser("rebuild", help="Rebuild all patches")
+
+        for step in self.setup_steps:
+            step.register_arguments(parser_setup)
+
+        for step in self.rebuild_steps:
+            step.register_arguments(parser_rebuild)
+
+        args = parser.parse_args()
+        self.context.args = args
+
+        self.context.setup_steps = self.setup_steps
+        self.context.rebuild_steps = self.rebuild_steps
+
+        if args.command == "setup":
+            if os.path.exists(self.context.workspace_dir):
+                logging.error(
+                    "Workspace directory '%s' already exists. Please remove it before running setup.",
+                    self.context.workspace_dir,
+                )
+                sys.exit(1)
+
+            if os.path.exists(self.context.temp_dir):
+                shutil.rmtree(self.context.temp_dir)
+
+            self.run_pipeline(self.setup_steps, True)
+
+            logging.info(
+                "Setup completed successfully! You can now open '%s' in Unity.",
+                self.context.workspace_dir,
+            )
+        elif args.command == "rebuild":
+            if not os.path.exists(self.context.workspace_dir):
+                logging.error(
+                    "Workspace directory '%s' does not exist. Please run 'setup' first.",
+                    self.context.workspace_dir,
+                )
+                sys.exit(1)
+
+            self.run_pipeline(self.rebuild_steps, False)
+
+    def run_pipeline(self, steps: list[PatcherStep], cleanup_temp: bool):
+        dependencies = set()
+        for step in steps:
+            for dependency in step.get_dependencies():
+                dependencies.add(dependency)
+
+        missing_tools = []
+        for dependency in dependencies:
+            if dependency.startswith("unity:"):
+                version = dependency.split(":")[1]
+                if not self.context.find_unity(version):
+                    missing_tools.append(f"Unity {version}")
+            else:
+                if not self.context.find_executable(dependency):
+                    missing_tools.append(dependency)
+
+        if missing_tools:
+            logging.error("The following required tools were not found:")
+            for tool in missing_tools:
+                logging.error(" - %s", tool)
+
+            sys.exit(1)
+
+        if cleanup_temp:
+            shutil.rmtree(self.context.temp_dir, ignore_errors=True)
+            os.makedirs(self.context.temp_dir, exist_ok=True)
+
+        try:
+            for step in steps:
+                step.execute(self.context)
+        except Exception as e:
+            logging.error("Patching failed!")
+            logging.exception(e)
+            sys.exit(1)
+        finally:
+            if cleanup_temp:
+                logging.info("Cleaning up temporary files...")
+                shutil.rmtree(self.context.temp_dir, ignore_errors=True)
+                # TODO: move this somewhere else
+                # AssetRipper
+                shutil.rmtree("temp", ignore_errors=True)

unirebuild-0.0.1/src/unirebuild/ios/cgbi.py

@@ -0,0 +1,99 @@
+from struct import unpack, pack
+from zlib import decompress, compress, crc32
+
+
+# Copied from https://gist.github.com/urielka/3609051
+def cgbi_to_png(cgbi_path: str) -> bytes | None:
+    png_header = b"\x89PNG\r\n\x1a\n"
+
+    with open(cgbi_path, "rb") as file:
+        cgbi_file = file.read()
+
+    if cgbi_file[:8] != png_header:
+        return None
+
+    png_file = cgbi_file[:8]
+    chunk_pos = len(png_file)
+    idat_acc = b""
+    break_loop = False
+
+    # For each chunk in the PNG file
+    while chunk_pos < len(cgbi_file):
+        skip = False
+
+        # Reading chunk
+        chunk_length = cgbi_file[chunk_pos : chunk_pos + 4]
+        chunk_length = unpack(">L", chunk_length)[0]
+        chunk_type = cgbi_file[chunk_pos + 4 : chunk_pos + 8]
+        chunk_data = cgbi_file[chunk_pos + 8 : chunk_pos + 8 + chunk_length]
+        chunk_crc = cgbi_file[
+            chunk_pos + chunk_length + 8 : chunk_pos + chunk_length + 12
+        ]
+        chunk_crc = unpack(">L", chunk_crc)[0]
+        chunk_pos += chunk_length + 12
+
+        # Parsing the header chunk
+        if chunk_type == b"IHDR":
+            width = unpack(">L", chunk_data[0:4])[0]
+            height = unpack(">L", chunk_data[4:8])[0]
+
+        # Parsing the image chunk
+        if chunk_type == b"IDAT":
+            idat_acc += chunk_data
+            skip = True
+
+        # Remove CgBI chunk
+        if chunk_type == b"CgBI":
+            skip = True
+
+        # When reaching the end chunk, process the accumulated IDAT data
+        if chunk_type == b"IEND":
+            try:
+                buf_size = width * height * 4 + height
+                chunk_data = decompress(idat_acc, -15, buf_size)
+            except Exception as e:
+                # The PNG image is already normalized
+                print(e)
+                return None
+
+            # Prepare new IDAT chunk
+            chunk_type = b"IDAT"
+
+            # Swap red & blue for each pixel
+            new_data = bytearray()
+            pos = 0
+            for y in range(height):
+                # Copy the filter byte for the scanline
+                new_data.append(chunk_data[pos])
+                pos += 1
+                for x in range(width):
+                    # Original order: R, G, B, A
+                    r = chunk_data[pos]
+                    g = chunk_data[pos + 1]
+                    b = chunk_data[pos + 2]
+                    a = chunk_data[pos + 3]
+                    # New order: B, G, R, A
+                    new_data.append(b)
+                    new_data.append(g)
+                    new_data.append(r)
+                    new_data.append(a)
+                    pos += 4
+
+            # Compress the modified image data
+            chunk_data = compress(bytes(new_data))
+            chunk_length = len(chunk_data)
+            chunk_crc = crc32(chunk_type)
+            chunk_crc = crc32(chunk_data, chunk_crc)
+            chunk_crc = (chunk_crc + 0x100000000) % 0x100000000
+            break_loop = True
+
+        if not skip:
+            png_file += pack(">L", chunk_length)
+            png_file += chunk_type
+            if chunk_length > 0:
+                png_file += chunk_data
+            png_file += pack(">L", chunk_crc)
+        if break_loop:
+            break
+
+    return png_file

unirebuild-0.0.1/src/unirebuild/ios/plist.py

@@ -0,0 +1,48 @@
+import os
+import plistlib
+from typing import Any
+
+
+def extract_plist_icon_filenames(plist_path: str) -> list[str]:
+    if not os.path.exists(plist_path):
+        raise FileNotFoundError(f"The .plist file '{plist_path}' does not exist.")
+
+    with open(plist_path, "rb") as fp:
+        try:
+            plist_data = plistlib.load(fp)
+        except Exception as e:
+            raise ValueError(f"Failed to parse .plist file: {e}")
+
+    found_icons = []
+
+    def walk_plist(obj: Any, key: str | None = None):
+        if isinstance(obj, dict):
+            for k, v in obj.items():
+                walk_plist(v, k)
+        elif isinstance(obj, list):
+            if key and "CFBundleIconFiles" in key:
+                for item in obj:
+                    if isinstance(item, str):
+                        found_icons.append(item)
+            else:
+                for item in obj:
+                    walk_plist(item, key)
+        elif isinstance(obj, str):
+            if key and ("CFBundleIconFile" in key or "CFBundleIconName" in key):
+                found_icons.append(obj)
+
+    walk_plist(plist_data)
+
+    valid_icons = []
+    for icon in found_icons:
+        icon_cleaned = icon.strip()
+        if not icon_cleaned:
+            continue
+
+        if not icon_cleaned.lower().endswith(".png"):
+            icon_cleaned += ".png"
+
+        if icon_cleaned not in valid_icons:
+            valid_icons.append(icon_cleaned)
+
+    return valid_icons

unirebuild-0.0.1/src/unirebuild/steps/__init__.py

@@ -0,0 +1,20 @@
+from .base import PatcherStep
+from .apply_patches import ApplyPatches
+from .copy_bundles import CopyBundles
+from .copy_gitignore import CopyGitignore
+from .copy_overrides import CopyOverrides
+from .custom_action import CustomAction
+from .decode_fsb_audio import DecodeFsbAudio
+from .deduplicate_assets import DeduplicateAssets
+from .delete_assets import DeleteAssets
+from .extract_app import ExtractApp
+from .extract_app_icon import ExtractAppIcon
+from .generate_deterministic_guids import GenerateDeterministicGuids
+from .git_commit import GitCommit
+from .git_init import GitInit
+from .populate_texture_settings import PopulateTextureSettings
+from .rebuild_patches import RebuildPatches
+from .reencode_wavs import ReencodeWavs
+from .run_assetripper import RunAssetRipper
+from .swap_files import SwapFiles
+from .unity_upgrade import UnityUpgrade

unirebuild-0.0.1/src/unirebuild/steps/apply_patches.py

@@ -0,0 +1,28 @@
+import glob
+import logging
+import os.path
+
+from unirebuild.context import PatcherContext
+from unirebuild.steps import PatcherStep
+
+
+class ApplyPatches(PatcherStep):
+    def __init__(self, patches_dir: str):
+        self.patches_dir = patches_dir
+
+    def get_dependencies(self) -> list[str]:
+        return ["git"]
+
+    def execute(self, context: PatcherContext):
+        git_path = context.find_executable("git")
+        patches = sorted(
+            glob.glob(os.path.abspath(os.path.join(self.patches_dir, "*.patch")))
+        )
+        if patches:
+            logging.info("Applying %d patches...", len(patches))
+            context.run_cmd(
+                [git_path, "am", "--3way", "--ignore-whitespace"] + patches,
+                cwd=context.workspace_dir,
+            )
+        else:
+            logging.info("No patches found to apply.")

unirebuild-0.0.1/src/unirebuild/steps/base.py

@@ -0,0 +1,19 @@
+from argparse import ArgumentParser
+
+from unirebuild.context import PatcherContext
+
+
+class PatcherStep:
+    """Base class for all patcher steps."""
+
+    def register_arguments(self, parser: ArgumentParser):
+        """Registers command-line arguments for this step."""
+        pass
+
+    def get_dependencies(self) -> list[str]:
+        """Returns a list of tool dependencies required by this step."""
+        return []
+
+    def execute(self, context: PatcherContext):
+        """Executes the step using the provided context."""
+        raise NotImplementedError()

unirebuild-0.0.1/src/unirebuild/steps/copy_bundles.py

@@ -0,0 +1,49 @@
+import logging
+import os.path
+import shutil
+from argparse import ArgumentParser
+
+from unirebuild.context import PatcherContext
+from unirebuild.steps import PatcherStep
+
+
+class CopyBundles(PatcherStep):
+    def __init__(
+        self, bundles_path_arg: str = "bundles", delete_existing: bool = False
+    ):
+        self.bundles_path_arg = bundles_path_arg
+        self.delete_existing = delete_existing
+
+    def register_arguments(self, parser: ArgumentParser):
+        parser.add_argument(
+            self.bundles_path_arg,
+            help="Path to a folder containing the game asset bundles",
+        )
+
+    def execute(self, context: PatcherContext):
+        bundles_src = getattr(context.args, self.bundles_path_arg)
+        bundles_dst = os.path.join(context.get_extracted_path(), "bundles")
+
+        if not os.path.exists(bundles_src):
+            raise FileNotFoundError(
+                f"Bundles directory '{bundles_src}' does not exist."
+            )
+
+        logging.info("Copying bundles from '%s' to '%s'...", bundles_src, bundles_dst)
+        shutil.copytree(bundles_src, bundles_dst)
+
+        if not self.delete_existing:
+            return
+
+        bundles = set()
+        for root, dirs, files in os.walk(bundles_dst):
+            for file in files:
+                bundles.add(file)
+
+        app_path = os.path.join(context.get_extracted_path(), "app")
+        for root, dirs, files in os.walk(app_path):
+            for file in files:
+                if file in bundles:
+                    file_path = os.path.join(root, file)
+                    logging.info("Deleting existing bundle '%s'...", file_path)
+                    os.remove(file_path)

unirebuild-0.0.1/src/unirebuild/steps/copy_gitignore.py

@@ -0,0 +1,17 @@
+import logging
+import os
+import shutil
+
+from unirebuild.context import PatcherContext
+from unirebuild.steps import PatcherStep
+
+
+class CopyGitignore(PatcherStep):
+    def __init__(self, source: str):
+        self.source = source
+
+    def execute(self, context: PatcherContext):
+        logging.info("Copy .gitignore...")
+        gitignore_src = os.path.abspath(self.source)
+        gitignore_dst = os.path.join(context.workspace_dir, ".gitignore")
+        shutil.copyfile(gitignore_src, gitignore_dst)

unirebuild-0.0.1/src/unirebuild/steps/copy_overrides.py

@@ -0,0 +1,20 @@
+import logging
+import os.path
+import shutil
+
+from unirebuild.context import PatcherContext
+from unirebuild.steps import PatcherStep
+
+
+class CopyOverrides(PatcherStep):
+    def __init__(self, overrides_dir: str):
+        self.overrides_dir = overrides_dir
+
+    def execute(self, context: PatcherContext):
+        if not os.path.exists(self.overrides_dir):
+            raise FileNotFoundError(
+                f"Overrides directory '{self.overrides_dir}' does not exist."
+            )
+
+        logging.info(f"Copying overrides from '{self.overrides_dir}'...")
+        shutil.copytree(self.overrides_dir, context.workspace_dir, dirs_exist_ok=True)

unirebuild-0.0.1/src/unirebuild/steps/custom_action.py

@@ -0,0 +1,16 @@
+import logging
+from typing import Callable
+
+from unirebuild.context import PatcherContext
+from unirebuild.steps import PatcherStep
+
+
+class CustomAction(PatcherStep):
+    """A patcher step for executing a custom user-defined action."""
+
+    def __init__(self, action_func: Callable[[PatcherContext], None]):
+        self.action_func = action_func
+
+    def execute(self, context: PatcherContext):
+        logging.info("Running custom action '%s'...", self.action_func.__name__)
+        self.action_func(context)