#!/usr/bin/env python3 """Build and package Assembler Casino into the modern CASINO-PACK-V2 installer.""" import argparse import hashlib import json import os import re import struct import subprocess import sys import zipfile from pathlib import Path ROOT = Path(__file__).resolve().parents[1] FOOTER_MAGIC = b"CASINO-PACK-V2!\n" STUDIO_MEDIA = ( "assets/animations/intro/eblan-studio-v8.hfm", "assets/animations/intro/eblan-studio-v8.json", "assets/audio/startup/studio-workshop-v8.wav", ) def sha256_stream(file_obj, length=None): h = hashlib.sha256() remaining = length if length is not None else float("inf") while remaining > 0: chunk_size = min(65536, remaining if length is not None else 65536) chunk = file_obj.read(chunk_size) if not chunk: break h.update(chunk) if length is not None: remaining -= len(chunk) return h.hexdigest().lower() def sha256_file(path): with open(path, "rb") as f: return sha256_stream(f) def collect_payload_files(): entries = [] for relative in STUDIO_MEDIA: if not (ROOT / relative).is_file(): raise FileNotFoundError(f"Missing studio intro asset: {relative}") # Executables for src, dst in [ (ROOT / "dist/Assembler Casino.exe", "Assembler Casino.exe"), (ROOT / "dist/Uninstall Assembler Casino.exe", "Uninstall Assembler Casino.exe"), (ROOT / "bin/poker.exe", "bin/poker.exe"), (ROOT / "poker.exe", "poker.exe"), ]: if not src.exists(): raise FileNotFoundError(f"Required binary not found: {src}") entries.append((src, dst)) # Assets (excluding raw sprites used only for asset generation) assets_dir = ROOT / "assets" for r, dirs, files in os.walk(assets_dir): if Path(r) == assets_dir: # Editable Blender/AE projects, scans and source image sequences are # offline authoring material. Ship their compiled media, not the set. dirs[:] = [d for d in dirs if d not in {"cinematics", "sprites"}] if "sprites" in Path(r).parts: continue for f in sorted(files): fp = Path(r) / f rel = fp.relative_to(ROOT).as_posix() if ( rel.startswith(("assets/animations/intro/eblan-studio-v", "assets/audio/startup/studio-workshop-v")) and rel not in STUDIO_MEDIA ): continue entries.append((fp, rel)) # Docs docs_dir = ROOT / "docs" for r, dirs, files in os.walk(docs_dir): for f in sorted(files): if f.endswith((".txt", ".md")): fp = Path(r) / f rel = fp.relative_to(ROOT).as_posix() entries.append((fp, rel)) # Tools tool_files = [ "tools/previews/preview_dbd_hook.bat", "tools/previews/preview_hakari.bat", "tools/previews/preview_intro.bat", "tools/previews/preview_casino3d.bat", "tools/tests/achievement_popup.bat", "tools/tests/release_smoke_check.ps1", ] for rel in tool_files: fp = ROOT / rel if fp.exists(): entries.append((fp, rel)) # Backwards compatibility paths for tests / older scripts if (ROOT / "tools/previews/preview_dbd_hook.bat").exists(): entries.append((ROOT / "tools/previews/preview_dbd_hook.bat", "tools/preview_dbd_hook.bat")) if (ROOT / "tools/tests/release_smoke_check.ps1").exists(): entries.append((ROOT / "tools/tests/release_smoke_check.ps1", "tools/release_smoke_check.ps1")) # AI worker & metadata (without models/ directory) ai_dir = ROOT / "ai" if ai_dir.exists(): for r, dirs, files in os.walk(ai_dir): if "models" in Path(r).parts: continue for f in sorted(files): fp = Path(r) / f rel = fp.relative_to(ROOT).as_posix() entries.append((fp, rel)) # Root documentation & legal for rel in ["AGENTS.md", "README.md", "LICENSE"]: fp = ROOT / rel if fp.exists(): entries.append((fp, rel)) # Clean and deduplicate entries unique_entries = [] seen_dest = set() for src, dst in entries: clean_dst = dst.replace("\\", "/").lstrip("/") if clean_dst not in seen_dest: seen_dest.add(clean_dst) unique_entries.append((src, clean_dst)) return unique_entries def build_payload_zip(zip_path, entries): print(f"Creating game archive: {zip_path} ({len(entries)} files)...") zip_path.parent.mkdir(parents=True, exist_ok=True) uncompressed_bytes = 0 with zipfile.ZipFile(zip_path, "w", compression=zipfile.ZIP_DEFLATED, compresslevel=4) as zf: for src, dst in entries: zf.write(src, dst) uncompressed_bytes += src.stat().st_size size_mb = zip_path.stat().st_size / (1024 * 1024) print(f"Game archive created: {size_mb:.2f} MB (uncompressed: {uncompressed_bytes / (1024*1024):.2f} MB)") return uncompressed_bytes def compile_installer_base(index_sha256): installer_dir = ROOT / "build/installer" stamp_path = installer_dir / "PokerGameSetup/PackageStamp.cs" stamp_content = f"""namespace PokerGameSetup; internal static class PackageStamp {{ \tpublic const string IndexSha256 = "{index_sha256}"; }} """ stamp_path.write_text(stamp_content, encoding="utf-8") print(f"Updated PackageStamp.cs with IndexSha256: {index_sha256}") out_dir = installer_dir / "bin" out_dir.mkdir(parents=True, exist_ok=True) cmd = [ "dotnet", "build", str(installer_dir / "PokerGameSetup.csproj"), "-c", "Release", "-o", str(out_dir), ] print(f"Compiling installer base: {' '.join(cmd)}") res = subprocess.run(cmd, capture_output=True, text=True) if res.returncode != 0: raise RuntimeError(f"dotnet build failed:\n{res.stdout}\n{res.stderr}") base_exe = out_dir / "Setup-base.exe" if not base_exe.exists(): base_exe = out_dir / "PokerGameSetup.exe" if not base_exe.exists(): raise FileNotFoundError(f"Compiled setup base executable not found in {out_dir}") print(f"Compiled base executable: {base_exe} ({base_exe.stat().st_size} bytes)") return base_exe def verify_package(setup_path, expected_index_sha256, has_model, expected_model_sha256=None): print(f"Verifying package {setup_path}...") size = setup_path.stat().st_size if size < 32: raise ValueError("Package too small to contain footer") with open(setup_path, "rb") as f: f.seek(-32, os.SEEK_END) footer = f.read(32) payload_offset, index_len, magic = struct.unpack(" 16777216: raise ValueError(f"Invalid index length: {index_len}") if payload_offset < 0 or payload_offset > size - 32 - index_len: raise ValueError(f"Invalid payload offset: {payload_offset}") index_offset = size - 32 - index_len f.seek(index_offset) index_bytes = f.read(index_len) actual_index_hash = hashlib.sha256(index_bytes).hexdigest().lower() if actual_index_hash != expected_index_sha256.lower(): raise ValueError(f"Index hash mismatch: {actual_index_hash} != {expected_index_sha256}") # Test reading game zip slice f.seek(payload_offset) # Parse XML index import xml.etree.ElementTree as ET root = ET.fromstring(index_bytes.decode("utf-8")) if root.tag != "casino-package": raise ValueError(f"Invalid root tag: {root.tag}") game_elem = root.find("game") if game_elem is None: raise ValueError("Missing element") game_offset = int(game_elem.attrib["offset"]) game_len = int(game_elem.attrib["length"]) game_bytes = int(game_elem.attrib["bytes"]) game_sha256 = game_elem.attrib["sha256"] if game_offset != 0: raise ValueError("Game offset must be 0") f.seek(payload_offset + game_offset) actual_game_hash = sha256_stream(f, game_len) if actual_game_hash != game_sha256.lower(): raise ValueError(f"Game hash mismatch: {actual_game_hash} != {game_sha256}") # Check zip archive validity class SliceIO: def __init__(self, f_obj, start, length): self._f = f_obj self._start = start self._length = length self._pos = 0 def read(self, n=-1): if n < 0 or self._pos + n > self._length: n = self._length - self._pos if n <= 0: return b"" self._f.seek(self._start + self._pos) data = self._f.read(n) self._pos += len(data) return data def seek(self, offset, whence=0): if whence == 0: self._pos = offset elif whence == 1: self._pos += offset elif whence == 2: self._pos = self._length + offset self._pos = max(0, min(self._pos, self._length)) return self._pos def tell(self): return self._pos sio = SliceIO(f, payload_offset + game_offset, game_len) with zipfile.ZipFile(sio, "r") as zf: uncompressed = sum(info.file_size for info in zf.infolist()) if uncompressed != game_bytes: raise ValueError(f"Uncompressed bytes mismatch: {uncompressed} != {game_bytes}") for info in zf.infolist(): if info.filename.endswith("/") or info.is_dir() or not info.filename.split("/")[-1]: raise ValueError(f"Forbidden directory entry in zip: {info.filename}") if "\\" in info.filename: raise ValueError(f"Forbidden backslash in entry: {info.filename}") # Check model if present model_elem = root.find("model") if has_model: if model_elem is None: raise ValueError("Expected element not found in index") model_offset = int(model_elem.attrib["offset"]) model_len = int(model_elem.attrib["length"]) model_bytes = int(model_elem.attrib["bytes"]) model_sha256 = model_elem.attrib["sha256"] if model_offset != game_len: raise ValueError(f"Model offset {model_offset} != game length {game_len}") if model_bytes != model_len: raise ValueError(f"Model bytes {model_bytes} != model length {model_len}") f.seek(payload_offset + model_offset) actual_model_hash = sha256_stream(f, model_len) if actual_model_hash != model_sha256.lower(): raise ValueError(f"Model hash mismatch: {actual_model_hash} != {model_sha256}") if expected_model_sha256 and actual_model_hash != expected_model_sha256.lower(): raise ValueError(f"Model hash mismatch with expected: {actual_model_hash}") else: if model_elem is not None: raise ValueError("Unexpected element found when has_model is False") print("[VERIFIED] Package passed all structural and cryptographic checks!") def main(): parser = argparse.ArgumentParser(description="Build modern Assembler Casino installer.") parser.add_argument("--no-model", action="store_true", help="Build installer without the 2.5 GB offline model") parser.add_argument("--output", type=str, default="", help="Custom output installer filename") args = parser.parse_args() include_model = not args.no_model if args.output: output_name = args.output else: output_name = "PokerGameSetup.exe" if include_model else "PokerGameSetup_NoModel.exe" output_exe = ROOT / output_name print(f"=== Building Assembler Casino Installer: {output_name} ===") print(f"Include offline fortune model: {include_model}") # 1. Model verification (if enabled) model_path = None model_len = 0 model_sha256 = "" model_target_rel = "ai/models/fortune-qwen3-4b-q4_k_m.gguf" if include_model: manifest_path = ROOT / "ai/model.json" if not manifest_path.exists(): raise FileNotFoundError(f"Model manifest not found: {manifest_path}") manifest = json.loads(manifest_path.read_text("utf-8")) model_path = ROOT / "ai" / manifest["file"] if not model_path.exists(): raise FileNotFoundError( f"Offline fortune model not found at {model_path}. " "Run download_fortune_model.bat to download it, or use --no-model." ) model_len = model_path.stat().st_size expected_len = manifest["bytes"] if model_len != expected_len: raise ValueError(f"Model size mismatch: {model_len} != {expected_len}") print(f"Verifying offline model hash ({model_path.name})...") model_sha256 = manifest["sha256"].lower() actual_hash = sha256_file(model_path) if actual_hash != model_sha256: raise ValueError(f"Model SHA-256 mismatch: {actual_hash} != {model_sha256}") print(f"Model verified: {model_len / (1024*1024):.2f} MB, SHA-256: {model_sha256}") # 2. Collect and zip game payload entries = collect_payload_files() payload_zip = ROOT / "build/payload_release_final.zip" uncompressed_bytes = build_payload_zip(payload_zip, entries) game_zip_len = payload_zip.stat().st_size game_zip_sha256 = sha256_file(payload_zip) print(f"Game ZIP SHA-256: {game_zip_sha256}") # 3. Construct XML index if include_model: xml_index = ( f"\n" f'' f'' f'' f"" ) else: xml_index = ( f"\n" f'' f'' f"" ) xml_bytes = xml_index.encode("utf-8") index_sha256 = hashlib.sha256(xml_bytes).hexdigest().lower() print(f"XML Index SHA-256: {index_sha256}") # 4. Compile base setup executable with index SHA-256 stamped base_exe = compile_installer_base(index_sha256) base_len = base_exe.stat().st_size # 5. Assemble final installer executable print(f"Assembling {output_exe}...") with open(output_exe, "wb") as out_f: # Write base executable with open(base_exe, "rb") as in_base: out_f.write(in_base.read()) # Stream game zip print("Writing game archive...") with open(payload_zip, "rb") as in_zip: while chunk := in_zip.read(1048576): out_f.write(chunk) # Stream model (if included) if include_model: print("Writing offline neural model (2.5 GB)...") with open(model_path, "rb") as in_model: while chunk := in_model.read(1048576): out_f.write(chunk) # Write XML index print("Writing XML index and footer...") out_f.write(xml_bytes) # Write 32-byte footer: footer_bytes = struct.pack("