rebuild_data_win_v1_6.py
18185 bytes · Original / download
import importlib.util
import os
import re
import shutil
import subprocess
import sys
from pathlib import Path
# =============================================================================
# DeltaruneVita - Rebuild Data.win
#
# Toda a estrutura e resolvida RELATIVAMENTE a este arquivo:
#
# rebuild_data_win\
# rebuild_data_win.bat
# chapters\
# rebuild\
# source\
# rebuild_data_win.py
# texture_optimizer.py
# UTMT_CLI\
# UndertaleModCli.exe
# =============================================================================
SOURCE_DIR = Path(__file__).resolve().parent
ROOT_DIR = SOURCE_DIR.parent
CHAPTERS_DIR = ROOT_DIR / "chapters"
REBUILD_DIR = ROOT_DIR / "rebuild"
CLI_EXE = SOURCE_DIR / "UTMT_CLI" / "UndertaleModCli.exe"
OPTIMIZER_FILE = SOURCE_DIR / "texture_optimizer_v1_6.py"
GML_OPTIMIZER_SCRIPT = SOURCE_DIR / "apply_vita_gml_optimizations.csx"
WIDTH = 84
APP_VERSION = "1.6.0"
def clear():
os.system("cls" if os.name == "nt" else "clear")
def rel(path):
"""Mostra caminhos relativos a pasta raiz do rebuild_data_win."""
path = Path(path).resolve()
try:
return str(path.relative_to(ROOT_DIR)).replace("/", "\\")
except ValueError:
return path.name
def line(char="="):
print(char * WIDTH)
def page(title, subtitle=None, step=None):
clear()
line("=")
print(f" DELTARUNEVITA - REBUILD DATA.WIN | v{APP_VERSION}")
line("=")
if step:
print(f" {step}")
print()
print(f" {title}")
if subtitle:
print(f" {subtitle}")
print()
line("-")
print()
def footer(message=None):
print()
line("-")
if message:
print(f" {message}")
print()
def fail(title, message):
page(
title,
"O processo foi interrompido com seguranca.",
)
print(message)
footer("Nenhum data.win original foi alterado.")
input("Pressione ENTER para voltar...")
return 1
def load_optimizer():
if not OPTIMIZER_FILE.exists():
raise RuntimeError(
"Arquivo ausente: source\\texture_optimizer_v1_6.py"
)
spec = importlib.util.spec_from_file_location(
"texture_optimizer",
OPTIMIZER_FILE,
)
if spec is None or spec.loader is None:
raise RuntimeError(
"Nao foi possivel carregar texture_optimizer.py."
)
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
return module
def discover_chapters():
CHAPTERS_DIR.mkdir(
parents=True,
exist_ok=True,
)
result = []
for data_win in CHAPTERS_DIR.rglob("data.win"):
if not data_win.is_file():
continue
relative_folder = data_win.parent.relative_to(CHAPTERS_DIR)
name = str(relative_folder).replace("\\", "/")
result.append((name, data_win))
def natural_key(item):
name = item[0]
return [
(0, int(part)) if part.isdigit() else (1, part.lower())
for part in re.split(r"(\d+)", name)
]
return sorted(
result,
key=natural_key,
)
def choose_chapter(chapters):
while True:
page(
"Selecionar arquivo",
"Escolha qual data.win sera analisado.",
"PAGINA 1/5 | SELECAO",
)
print(" Arquivos encontrados em chapters\\:")
print()
longest = max(
[len(name) for name, _ in chapters] + [8]
)
for name, data_win in chapters:
size_mib = (
data_win.stat().st_size
/ (1024 * 1024)
)
print(
f" {name:<{longest}}"
f" {size_mib:>9.2f} MiB"
f" {rel(data_win)}"
)
print()
print(" Digite A para reconstruir todos os arquivos.")
print(" Digite o nome da pasta desejada.")
print(" Exemplo: 2")
print()
print(" Digite Q para sair.")
print()
choice = input(" > ").strip()
if choice.lower() in (
"q",
"quit",
"sair",
):
return None
if choice.lower() in (
"a",
"all",
"todos",
):
return "__ALL__", None
for name, data_win in chapters:
if name == choice:
return name, data_win
print()
print(
f' Pasta "{choice}" nao encontrada ou sem data.win.'
)
input(" Pressione ENTER para tentar novamente...")
def ask_yes_no(message):
while True:
answer = input(
f" {message} [Y/N]: "
).strip().lower()
if answer in (
"y",
"yes",
"s",
"sim",
):
return True
if answer in (
"n",
"no",
"nao",
"não",
):
return False
print(" Resposta invalida. Digite Y ou N.")
def copy_final_win(generated_win, chapter_name):
final_dir = REBUILD_DIR / chapter_name
final_dir.mkdir(
parents=True,
exist_ok=True,
)
final_win = final_dir / "data.win"
previous_win = final_dir / "data.previous.win"
if final_win.exists():
if previous_win.exists():
previous_win.unlink()
final_win.replace(previous_win)
shutil.copy2(
generated_win,
final_win,
)
return final_win
def apply_vita_gml_optimizations(generated_win, work_dir):
"""Apply verified, semantic GML patches after the texture repack."""
if not GML_OPTIMIZER_SCRIPT.exists():
raise RuntimeError(
"Arquivo ausente: source\\apply_vita_gml_optimizations.csx"
)
patched_win = work_dir / "data_vita_gml.win"
report_path = work_dir / "vita_gml_optimizations.txt"
if patched_win.exists():
patched_win.unlink()
env = os.environ.copy()
env["DELTARUNE_VITA_GML_REPORT"] = str(report_path)
command = [
str(CLI_EXE),
"load",
str(generated_win),
"-s",
str(GML_OPTIMIZER_SCRIPT),
"-o",
str(patched_win),
]
result = subprocess.run(
command,
cwd=str(CLI_EXE.parent),
env=env,
check=False,
)
if result.returncode != 0 or not patched_win.exists():
raise RuntimeError(
"Falha ao aplicar as otimizacoes GML do DeltaruneVita."
)
# Reopen and rerun the idempotent checks. A second mutation is forbidden.
verify_report = work_dir / "vita_gml_optimizations_verify.txt"
env["DELTARUNE_VITA_GML_REPORT"] = str(verify_report)
verify = subprocess.run(
[
str(CLI_EXE),
"load",
str(patched_win),
"-s",
str(GML_OPTIMIZER_SCRIPT),
],
cwd=str(CLI_EXE.parent),
env=env,
check=False,
)
if verify.returncode != 0:
raise RuntimeError(
"O data.win falhou ao reabrir apos os patches GML."
)
if verify_report.exists() and "RESULT changed=1" in verify_report.read_text(
encoding="utf-8-sig"
):
raise RuntimeError(
"Patch GML nao idempotente detectado; o arquivo foi rejeitado."
)
return patched_win
def print_analysis_summary(summary_path):
if not summary_path.exists():
print(
" O otimizador concluiu a analise, "
"mas nao gerou summary_unified.txt."
)
return
text = summary_path.read_text(
encoding="utf-8-sig",
).strip()
for current in text.splitlines():
print(" " + current)
def write_batch_report(results):
report_path = REBUILD_DIR / "batch_rebuild_report.txt"
lines = [
"DeltaruneVita DeltaBuilder - batch rebuild report",
f"Pipeline: {APP_VERSION}",
"",
]
for result in results:
lines.append(
f"{result['status']} {result['chapter']} {result['message']}"
)
report_path.write_text("\n".join(lines) + "\n", encoding="utf-8")
return report_path
def run_batch(optimizer, chapters):
page(
"Reconstruir todos os arquivos",
f"{len(chapters)} data.win encontrados em chapters\\.",
"LOTE | CONFIRMACAO",
)
print(" Ordem de processamento:")
print()
for index, (chapter_name, input_win) in enumerate(chapters, start=1):
print(f" {index:>2}. {chapter_name:<24} {rel(input_win)}")
print()
print(" Em caso de erro, o lote sera interrompido imediatamente.")
print(" Os arquivos concluidos antes do erro permanecerao em rebuild\\.")
footer("Uma confirmacao executa o lote inteiro.")
if not ask_yes_no("Analisar e reconstruir todos os arquivos?"):
return 0
results = []
total = len(chapters)
for index, (chapter_name, input_win) in enumerate(chapters, start=1):
chapter_rebuild = REBUILD_DIR / chapter_name
work_dir = chapter_rebuild / "_work"
page(
f"[{index}/{total}] Analisando: {chapter_name}",
rel(input_win),
"LOTE | ANALISE E REBUILD",
)
print(" O original sera apenas lido.")
print(" O resultado anterior sera preservado como data.previous.win.")
print()
try:
analysis = optimizer.analyze_win(
input_win=input_win,
cli=CLI_EXE,
work_root=work_dir,
force_clean=True,
)
print_analysis_summary(Path(analysis["summary_path"]))
print()
print(f" [{index}/{total}] Gerando atlas e data.win...")
generated_win = optimizer.write_optimized_win(analysis)
generated_win = apply_vita_gml_optimizations(
generated_win,
work_dir,
)
final_win = copy_final_win(generated_win, chapter_name)
results.append({
"status": "OK",
"chapter": chapter_name,
"message": rel(final_win),
})
except Exception as exc:
results.append({
"status": "ERROR",
"chapter": chapter_name,
"message": str(exc).replace("\n", " "),
})
report_path = write_batch_report(results)
page(
f"Erro no arquivo: {chapter_name}",
"O lote foi interrompido no arquivo com falha.",
f"LOTE {index}/{total} | ERRO",
)
print(f" Entrada: {rel(input_win)}")
print()
print(f" Erro: {exc}")
print()
print(" Concluidos antes do erro:")
completed = [item for item in results if item["status"] == "OK"]
if completed:
for item in completed:
print(f" OK {item['chapter']}")
else:
print(" Nenhum.")
print()
print(f" Relatorio: {rel(report_path)}")
footer("O arquivo de entrada com erro permaneceu intacto.")
input("Pressione ENTER para encerrar...")
return 1
report_path = write_batch_report(results)
page(
"Processamento em lote concluido",
f"{total} de {total} arquivos reconstruidos e validados.",
"LOTE | CONCLUIDO",
)
for item in results:
print(f" OK {item['chapter']:<24} {item['message']}")
print()
print(f" Relatorio: {rel(report_path)}")
footer("Todos os arquivos originais em chapters\\ permaneceram intactos.")
input("Pressione ENTER para encerrar...")
return 0
def main():
# -------------------------------------------------------------------------
# Bootstrap / environment
# -------------------------------------------------------------------------
page(
"Inicializando",
"Validando a estrutura da ferramenta.",
"INICIALIZACAO",
)
print(f" Versao: {APP_VERSION}")
print()
print(" Estrutura utilizada:")
print(" chapters\\")
print(" rebuild\\")
print(" source\\")
print(" source\\UTMT_CLI\\UndertaleModCli.exe")
print()
if not CLI_EXE.exists():
return fail(
"UndertaleModCli nao encontrado",
(
"O executavel esperado nao existe em:\n\n"
" source\\UTMT_CLI\\UndertaleModCli.exe"
),
)
try:
optimizer = load_optimizer()
except Exception as exc:
return fail(
"Falha ao carregar o otimizador",
str(exc),
)
optimizer_version = getattr(
optimizer,
"PIPELINE_VERSION",
None,
)
if optimizer_version != APP_VERSION:
return fail(
"Versoes incompatíveis",
(
"Os arquivos da ferramenta nao pertencem ao mesmo pacote.\n\n"
f"Controller: {APP_VERSION}\n"
f"Optimizer: {optimizer_version}\n\n"
"Substitua novamente os arquivos dentro de source\\."
),
)
chapters = discover_chapters()
if not chapters:
return fail(
"Nenhum data.win encontrado",
(
"Adicione pelo menos um arquivo seguindo:\n\n"
" chapters\\<nome>\\data.win\n\n"
"Exemplo:\n\n"
" chapters\\2\\data.win"
),
)
# -------------------------------------------------------------------------
# Page 1 - Chapter selection
# -------------------------------------------------------------------------
selected = choose_chapter(chapters)
if selected is None:
clear()
return 0
chapter_name, input_win = selected
if chapter_name == "__ALL__":
return run_batch(optimizer, chapters)
chapter_rebuild = (
REBUILD_DIR
/ chapter_name
)
work_dir = (
chapter_rebuild
/ "_work"
)
# -------------------------------------------------------------------------
# Page 2 - Analyze
# -------------------------------------------------------------------------
page(
f"Analisando: {chapter_name}",
rel(input_win),
"PAGINA 2/5 | ANALISE",
)
print(" O arquivo original sera apenas lido.")
print(" Nenhuma escrita sera realizada nesta etapa.")
print()
print(" Etapas:")
print(" 1. Analise RAW")
print(" 2. Mapeamento Room / recursos")
print(" 3. Packing Hybrid / Density-Aware")
print(" 4. TextureGroup Probe")
print(" 5. Gate de regressao de VRAM")
print()
line("-")
print()
try:
analysis = optimizer.analyze_win(
input_win=input_win,
cli=CLI_EXE,
work_root=work_dir,
force_clean=True,
)
except Exception as exc:
return fail(
"Analise falhou",
str(exc),
)
# -------------------------------------------------------------------------
# Page 3 - Analysis result / confirmation
# -------------------------------------------------------------------------
page(
"Resultado da analise",
f"Arquivo: {rel(input_win)}",
"PAGINA 3/5 | RESULTADO",
)
print_analysis_summary(
Path(analysis["summary_path"])
)
footer(
"O data.win original permanece intacto."
)
if not ask_yes_no(
"Continuar e gerar o data.win otimizado?"
):
page(
"Operacao cancelada",
"A analise foi mantida para consulta.",
"ENCERRADO",
)
print(
" Nenhum arquivo otimizado foi gerado."
)
print()
print(
" Artefatos da analise:"
)
print(
f" {rel(work_dir)}"
)
footer(
"Pressione ENTER para encerrar."
)
input()
return 0
# -------------------------------------------------------------------------
# Page 4 - Write
# -------------------------------------------------------------------------
page(
f"Gerando data.win otimizado",
f"Destino: rebuild\\{chapter_name}\\data.win",
"PAGINA 4/5 | REBUILD",
)
print(" O plano aprovado sera aplicado usando RAW CROP.")
print()
print(" Depois do write o arquivo sera reaberto")
print(" pelo UndertaleModCLI para verificacao estrutural.")
print()
line("-")
print()
try:
generated_win = optimizer.write_optimized_win(
analysis
)
generated_win = apply_vita_gml_optimizations(
generated_win,
work_dir,
)
final_win = copy_final_win(
generated_win,
chapter_name,
)
except Exception as exc:
return fail(
"Geracao falhou",
str(exc),
)
# -------------------------------------------------------------------------
# Page 5 - Finished
# -------------------------------------------------------------------------
page(
"Processo concluido",
"O novo data.win foi gerado e validado.",
"PAGINA 5/5 | CONCLUIDO",
)
print(" Capitulo:")
print(f" {chapter_name}")
print()
print(" Original:")
print(f" {rel(input_win)}")
print()
print(" Otimizado:")
print(f" {rel(final_win)}")
previous = (
final_win.parent
/ "data.previous.win"
)
if previous.exists():
print()
print(" Build anterior:")
print(f" {rel(previous)}")
print()
print(" Proximo passo no Vita:")
print(
" Regenere os caches de textura derivados "
"desse capitulo antes do teste."
)
footer(
"O arquivo em chapters\\ permaneceu intacto."
)
input("Pressione ENTER para encerrar...")
return 0
if __name__ == "__main__":
sys.exit(main())