| import os |
| import zipfile |
| import tempfile |
| import json |
| import re |
| import subprocess |
| import UnityPy |
| from fastapi import FastAPI, UploadFile, File |
| from fastapi.responses import FileResponse |
| from fastapi.middleware.cors import CORSMiddleware |
| from typing import Optional |
|
|
| app = FastAPI() |
|
|
| app.add_middleware( |
| CORSMiddleware, |
| allow_origins=["*"], |
| allow_credentials=True, |
| allow_methods=["*"], |
| allow_headers=["*"], |
| ) |
|
|
| @app.post("/generate_dll") |
| async def generate_dll(binary_file: UploadFile = File(...), metadata_file: UploadFile = File(...)): |
| temp_dir = tempfile.mkdtemp() |
| binary_path = os.path.join(temp_dir, binary_file.filename) |
| metadata_path = os.path.join(temp_dir, metadata_file.filename) |
| with open(binary_path, "wb") as f: f.write(await binary_file.read()) |
| with open(metadata_path, "wb") as f: f.write(await metadata_file.read()) |
| output_dir = os.path.join(temp_dir, "output") |
| os.makedirs(output_dir, exist_ok=True) |
| subprocess.run(["/app/dumper/Il2CppDumper", binary_path, metadata_path, output_dir], capture_output=True) |
| zip_path = os.path.join(temp_dir, "DummyDlls.zip") |
| with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf: |
| for root, _, files in os.walk(output_dir): |
| for file in files: |
| if file.endswith(".dll"): zipf.write(os.path.join(root, file), arcname=file) |
| return FileResponse(zip_path, media_type="application/zip", filename="DummyDlls.zip") |
|
|
| @app.post("/extract") |
| async def extract_dialogues(file: UploadFile = File(...), assembly_file: Optional[UploadFile] = File(None)): |
| temp_dir = tempfile.mkdtemp() |
| asset_path = os.path.join(temp_dir, file.filename) |
| with open(asset_path, "wb") as f: f.write(await file.read()) |
| |
| env = UnityPy.load(asset_path) |
| zip_filename = os.path.join(temp_dir, f"{file.filename}_dialogues.zip") |
| extracted_count = 0 |
| |
| with zipfile.ZipFile(zip_filename, 'w', zipfile.ZIP_DEFLATED) as zipf: |
| for obj in env.objects: |
| if obj.type.name in ["TextAsset", "MonoBehaviour"]: |
| |
| obj_name = f"{obj.type.name}_{obj.path_id}" |
| |
| if obj.type.name == "MonoBehaviour": |
| raw_data = obj.get_raw_data() |
| found_strings = {} |
| i = 28 |
| |
| while i <= len(raw_data) - 4: |
| length = int.from_bytes(raw_data[i:i+4], 'little') |
| if 2 <= length <= 5000 and (i + 4 + length) <= len(raw_data): |
| str_bytes = raw_data[i+4 : i+4+length] |
| pad_len = (4 - (length % 4)) % 4 |
| |
| if (i + 4 + length + pad_len) <= len(raw_data): |
| padding = raw_data[i+4+length : i+4+length+pad_len] |
| if all(b == 0 for b in padding): |
| try: |
| text = str_bytes.decode('utf-8') |
| if len(text.strip()) > 1 and any(c.isalpha() for c in text): |
| found_strings[text] = text |
| i += 4 + length + pad_len |
| continue |
| except UnicodeDecodeError: |
| pass |
| i += 4 |
| |
| if found_strings: |
| zipf.writestr(f"{obj_name}_raw.json", json.dumps(found_strings, indent=4, ensure_ascii=False).encode('utf-8')) |
| extracted_count += 1 |
| |
| elif obj.type.name == "TextAsset": |
| try: |
| content = obj.read().text.encode('utf-8') |
| zipf.writestr(f"{obj_name}.txt", content) |
| extracted_count += 1 |
| except: pass |
|
|
| return FileResponse(zip_filename, media_type="application/zip", filename=f"{file.filename}_dialogues.zip") |
|
|
| @app.post("/repack") |
| async def repack_dialogues(asset_file: UploadFile = File(...), mod_zip: UploadFile = File(...)): |
| temp_dir = tempfile.mkdtemp() |
| asset_path = os.path.join(temp_dir, asset_file.filename) |
| zip_path = os.path.join(temp_dir, mod_zip.filename) |
| with open(asset_path, "wb") as f: f.write(await asset_file.read()) |
| with open(zip_path, "wb") as f: f.write(await mod_zip.read()) |
|
|
| |
| env = UnityPy.load(asset_path) |
| |
| |
| path_id_to_translations = {} |
| with zipfile.ZipFile(zip_path, 'r') as zipf: |
| for file_info in zipf.infolist(): |
| filename = file_info.filename |
| if filename.endswith(".json"): |
| |
| match = re.search(r'_(\d+)(_raw)?\.json$', filename) |
| if match: |
| path_id = int(match.group(1)) |
| content = zipf.read(filename) |
| path_id_to_translations[path_id] = json.loads(content.decode('utf-8')) |
|
|
| |
| for obj in env.objects: |
| if obj.path_id in path_id_to_translations: |
| translations = path_id_to_translations[obj.path_id] |
| |
| if obj.type.name == "MonoBehaviour": |
| raw_data = obj.get_raw_data() |
| patched_data = bytearray(raw_data) |
| |
| for orig_str, trans_str in translations.items(): |
| if orig_str == trans_str: continue |
| |
| |
| orig_bytes = orig_str.encode('utf-8') |
| orig_pad = (4 - (len(orig_bytes) % 4)) % 4 |
| orig_block = len(orig_bytes).to_bytes(4, 'little') + orig_bytes + (b'\x00' * orig_pad) |
| |
| |
| trans_bytes = trans_str.encode('utf-8') |
| trans_pad = (4 - (len(trans_bytes) % 4)) % 4 |
| trans_block = len(trans_bytes).to_bytes(4, 'little') + trans_bytes + (b'\x00' * trans_pad) |
| |
| |
| patched_data = patched_data.replace(orig_block, trans_block) |
| |
| |
| obj.set_raw_data(bytes(patched_data)) |
|
|
| |
| output_path = os.path.join(temp_dir, f"repacked_{asset_file.filename}") |
| with open(output_path, "wb") as f: f.write(env.file.save()) |
| |
| return FileResponse(output_path, media_type="application/octet-stream", filename=asset_file.filename) |
|
|
