沙威玛传奇游戏引擎解包

pip install pillow

from __future__ import annotations

import bz2
import shutil
import struct
from pathlib import Path

from PIL import Image


ROOT = Path(__file__).resolve().parent
OUT = ROOT / "unpacked"


def u32(value: int) -> int:
    return value & 0xFFFFFFFF


def sar32(value: int, shift: int) -> int:
    value &= 0xFFFFFFFF
    if value & 0x80000000:
        value -= 0x100000000
    return value >> shift


def fioq_hash(px: int) -> int:
    return (px ^ (px >> 8) ^ (px >> 16) ^ (px >> 24)) & 0x3F


def patch_lane(px: int, value: int, mask: int) -> int:
    return px ^ (((px + value) ^ px) & mask)


def decode_fioq(payload: bytes) -> Image.Image:
    if payload[:4] != b"fioq":
        raise ValueError(f"not a fioq payload: {payload[:4]!r}")

    width, height = struct.unpack_from("<HH", payload, 4)
    data = memoryview(payload)[12:]
    pixels = bytearray(width * height * 4)
    index = [0] * 64
    px = 0xFF000000
    in_pos = 0
    out_pos = 0
    run = 0

    while out_pos < len(pixels):
        if run:
            run -= 1
        else:
            b1 = data[in_pos]
            in_pos += 1

            if b1 < 0x80:
                if b1 < 0x40:
                    px = index[b1]
                else:
                    run = b1 & 0x1F
                    if b1 & 0x20:
                        run = (run << 8) | data[in_pos]
                        in_pos += 1
                        run += 0x20
            else:
                if not (b1 & 0x40):
                    px = patch_lane(px, sar32((b1 & 0x30) << 26, 30), 0x000000FF)
                    px = patch_lane(px, sar32((b1 & 0x0C) << 28, 22) & 0xFFFFFF00, 0x0000FF00)
                    px = patch_lane(px, sar32((b1 & 0x03) << 30, 14), 0x00FF0000)
                elif not (b1 & 0x20):
                    b2 = data[in_pos]
                    in_pos += 1
                    value = (b1 << 8) | b2
                    px = patch_lane(px, sar32((value & 0x1F00) << 19, 27), 0x000000FF)
                    px = patch_lane(px, sar32((value & 0x00F0) << 24, 20) & 0xFFFFFF00, 0x0000FF00)
                    px = patch_lane(px, sar32((value & 0x000F) << 28, 12), 0x00FF0000)
                elif not (b1 & 0x10):
                    b2 = data[in_pos]
                    b3 = data[in_pos + 1]
                    in_pos += 2
                    value = (b1 << 16) | (b2 << 8) | b3
                    px = patch_lane(px, sar32((value & 0x0F8000) << 12, 27), 0x000000FF)
                    px = patch_lane(px, sar32((value & 0x007C00) << 17, 19) & 0xFFFFFF00, 0x0000FF00)
                    px = patch_lane(px, sar32((value & 0x0003E0) << 22, 11), 0x00FF0000)
                    px = u32(px + (sar32((value & 0x00001F) << 27, 3) & 0xFF000000))
                else:
                    if b1 & 0x08:
                        px = (px & 0xFFFFFF00) | data[in_pos]
                        in_pos += 1
                    if b1 & 0x04:
                        px = (px & 0xFFFF00FF) | (data[in_pos] << 8)
                        in_pos += 1
                    if b1 & 0x02:
                        px = (px & 0xFF00FFFF) | (data[in_pos] << 16)
                        in_pos += 1
                    if b1 & 0x01:
                        px = (px & 0x00FFFFFF) | (data[in_pos] << 24)
                        in_pos += 1

                index[fioq_hash(px)] = px

        pixels[out_pos : out_pos + 4] = px.to_bytes(4, "little")
        out_pos += 4

    return Image.frombytes("RGBA", (width, height), bytes(pixels))


def unpack_yytex(path: Path, out_dir: Path) -> None:
    raw = path.read_bytes()
    if raw[:4] != b"2zoq" or raw[12:15] != b"BZh":
        raise ValueError(f"unknown yytex header in {path.name}")
    image = decode_fioq(bz2.decompress(raw[12:]))
    image.save(out_dir / f"{path.stem}.png")


def unpack_audiogroup(path: Path, out_dir: Path) -> int:
    raw = path.read_bytes()
    if raw[:4] != b"FORM" or raw[8:12] != b"AUDO":
        raise ValueError(f"unknown audiogroup header in {path.name}")

    count = struct.unpack_from("<I", raw, 16)[0]
    offsets = [struct.unpack_from("<I", raw, 20 + i * 4)[0] for i in range(count)]
    written = 0

    for i, off in enumerate(offsets):
        if off + 4 > len(raw):
            continue
        size = struct.unpack_from("<I", raw, off)[0]
        start = off + 4
        end = start + size
        chunk = raw[start:end]
        if chunk[:4] != b"OggS":
            continue
        (out_dir / f"{path.stem}_{i:03}.ogg").write_bytes(chunk)
        written += 1

    return written


def main() -> None:
    OUT.mkdir(parents=True, exist_ok=True)

    tex_count = 0
    for path in sorted(ROOT.glob("*.yytex")):
        tex_out = OUT / path.stem
        tex_out.mkdir(parents=True, exist_ok=True)
        unpack_yytex(path, tex_out)
        tex_count += 1

    audio_count = 0
    for path in sorted(ROOT.glob("audiogroup*.dat")):
        audio_out = OUT / path.stem
        audio_out.mkdir(parents=True, exist_ok=True)
        audio_count += unpack_audiogroup(path, audio_out)

    copied_ogg = 0
    for path in sorted(ROOT.glob("*.ogg")):
        audio_out = OUT / path.stem
        audio_out.mkdir(parents=True, exist_ok=True)
        shutil.copy2(path, audio_out / path.name)
        copied_ogg += 1

    print(f"textures: {tex_count} PNG files -> {OUT}\\<yytex name>\\")
    print(f"audiogroup sounds: {audio_count} OGG files -> {OUT}\\<audiogroup name>\\")
    print(f"loose ogg copied: {copied_ogg} files -> {OUT}\\<ogg name>\\")


if __name__ == "__main__":
    main()