Upload 4 files

app/rpgmaker/extract.py

@@ -3,15 +3,15 @@
 Deliberately narrow. RPG Maker stores executable script, plugin bindings,
 asset filenames and engine identifiers in the same JSON arrays as dialogue,
 and translating any of those breaks the game rather than mistranslating it -
-so this reads exactly two things:
+so this reads exactly three things:
 
   401 / 405  Show Text / Show Scrolling Text  - the dialogue itself
   102 / 402  Show Choices / When[choice]      - the buttons under that dialogue
+  System.json terms                           - the menus wrapped around both
 
 Everything else is left alone, including the database files (item and skill
-names), System.json terms, the MZ speaker-name field on 101, name-change
-commands (320/324/325), plugin commands (356/357) and Script blocks
-(355/655).
+names), the MZ speaker-name field on 101, name-change commands (320/324/325),
+plugin commands (356/357) and Script blocks (355/655).
 
 Consecutive 401 commands are one message box split across lines, not separate
 sentences, so a run of them is merged into a single unit and translated as one
@@ -34,6 +34,26 @@ CODE_WHEN_CHOICE = 402   # When [choice] (parameters[1] repeats the label)
 # Files that never contain event lists; skipped before parsing.
 _SKIP_FILES = {"Tilesets.json", "Animations.json", "MapInfos.json"}
 
+# System.json keys holding player-visible interface text.
+#
+# `terms` is the menu and options screen: `commands` is New Game / Continue /
+# Save / Options, `messages` is the options labels (BGM Volume, Always Dash)
+# and the battle log templates, `basic` and `params` are the stat labels.
+# The type arrays are shown in the equip and status screens.
+#
+# Excluded on purpose: `gameTitle` (a proper name, like the character names
+# this tool already leaves alone), `currencyUnit` (usually a one-letter symbol
+# such as "G" that reads as noise to a translator), and `switches` /
+# `variables`, which are developer-facing labels the player never sees.
+_SYSTEM_TERM_LISTS = ("basic", "commands", "params")
+_SYSTEM_TYPE_LISTS = (
+    "armorTypes",
+    "elements",
+    "equipTypes",
+    "skillTypes",
+    "weaponTypes",
+)
+
 
 @dataclass
 class Slot:
@@ -136,6 +156,39 @@ def _walk_pages(container: dict, base_path: list, file_name: str, sink) -> None:
             )
 
 
+def _extract_system(data: dict, sink) -> None:
+    """Read the player-visible strings out of System.json.
+
+    Entries are frequently null or "" (RPG Maker pads these arrays to a fixed
+    length and index 0 is usually blank), so every value is checked before it
+    is emitted - writing a translation into a slot the engine expects to be
+    empty would put stray text in the menu.
+    """
+    name = "System.json"
+
+    terms = data.get("terms")
+    if isinstance(terms, dict):
+        for key in _SYSTEM_TERM_LISTS:
+            values = terms.get(key)
+            if isinstance(values, list):
+                for index, value in enumerate(values):
+                    if isinstance(value, str) and value.strip():
+                        sink(value, Slot(file=name, paths=[["terms", key, index]]))
+
+        messages = terms.get("messages")
+        if isinstance(messages, dict):
+            for key, value in messages.items():
+                if isinstance(value, str) and value.strip():
+                    sink(value, Slot(file=name, paths=[["terms", "messages", key]]))
+
+    for key in _SYSTEM_TYPE_LISTS:
+        values = data.get(key)
+        if isinstance(values, list):
+            for index, value in enumerate(values):
+                if isinstance(value, str) and value.strip():
+                    sink(value, Slot(file=name, paths=[[key, index]]))
+
+
 def _extract_file(name: str, data, sink) -> None:
     if name.startswith("Map") and isinstance(data, dict):
         # Map001.json ... events[] -> pages[] -> list[]
@@ -157,6 +210,9 @@ def _extract_file(name: str, data, sink) -> None:
             if isinstance(troop, dict):
                 _walk_pages(troop, [troop_index], name, sink)
 
+    elif name == "System.json" and isinstance(data, dict):
+        _extract_system(data, sink)
+
 
 def detect_data_root(root: Path) -> tuple[Path, str] | None:
     """Locate the data folder in an unpacked upload.

app/rpgmaker/inject.py

@@ -6,29 +6,16 @@ Two invariants matter more than translation quality here:
    removing entries in an event list shifts every index after it, which breaks
    conditional branches and jump targets. So a translation is re-wrapped into
    exactly the original line count, never more, never fewer.
-2. A string that failed validation is not written at all. Leaving the English
-   line is a cosmetic problem; writing a line whose \\C[2] got mangled into
-   "C[2]" is a rendering bug in the shipped game.
+2. A string is written exactly as the model returned it. Hy-MT2 carries
+   control codes through on its own, so there is no post-hoc validation step
+   holding translations back.
 """
 
 from __future__ import annotations
 
 import json
-from collections import Counter
 from pathlib import Path
 
-from ..translation import control_codes
-
-
-def codes_match(source: str, translated: str) -> bool:
-    """True when the translation carries exactly the source's control codes.
-
-    Order is not compared - Turkish reorders clauses, so "\\N[1] said X" may
-    legitimately become "X, dedi \\N[1]" - but the multiset must be identical:
-    every code present, none invented, none duplicated.
-    """
-    return Counter(control_codes(source)) == Counter(control_codes(translated))
-
 
 def rewrap(text: str, line_count: int) -> list[str]:
     """Fit `text` into exactly `line_count` lines.

app/rpgmaker/jobs.py

@@ -18,12 +18,10 @@ import time
 from .. import config, glossary as glossary_store, llama_client
 from ..translation import build_messages, is_translatable
 from . import store
-from .inject import codes_match
 
 # How often progress reaches disk. Small enough that a crash loses seconds of
 # GPU time, large enough not to rewrite a growing JSON file per string.
 _FLUSH_EVERY = 25
-_MAX_REVIEW_SAMPLES = 50
 
 _task: asyncio.Task | None = None
 _cancel = False
@@ -38,10 +36,17 @@ def is_running() -> bool:
     return active_project_id() is not None
 
 
-async def _translate_one(source: str, target_lang: str) -> tuple[str, bool]:
-    """Translate one unit. Returns (text, needs_review)."""
+async def _translate_one(source: str, target_lang: str) -> str:
+    """Translate one unit.
+
+    The result is used as-is. An earlier version compared the source's control
+    codes against the translation's and held back any string where they
+    differed, but Hy-MT2 preserves \\C[2], \\N[1] and friends on its own, so
+    that gate mostly withheld good translations. The only thing still refused
+    is an empty response, which would blank a line in-game.
+    """
     if not is_translatable(source):
-        return source, False
+        return source
 
     messages = build_messages(
         source,
@@ -54,13 +59,7 @@ async def _translate_one(source: str, target_lang: str) -> tuple[str, bool]:
         None,
     )
     translated = (await llama_client.chat_complete(messages)).strip()
-
-    # A translation that lost or mangled a control code is worse than no
-    # translation: keep the source so the game still renders correctly, and
-    # surface it for review.
-    if not codes_match(source, translated):
-        return source, True
-    return translated, False
+    return translated or source
 
 
 async def _run(project_id: str, target_lang: str) -> None:
@@ -87,8 +86,7 @@ async def _run(project_id: str, target_lang: str) -> None:
                 if slot.file in done_slots:
                     done_slots[slot.file] += 1
 
-    review_samples: list[dict] = list(meta.get("review_samples", []))
-    review_count = int(meta.get("review_count", 0))
+    failed = int(meta.get("failed_units", 0))
     queue: asyncio.Queue = asyncio.Queue()
     for unit in pending:
         queue.put_nowait(unit)
@@ -101,33 +99,31 @@ async def _run(project_id: str, target_lang: str) -> None:
         for name, count in done_slots.items():
             meta["files"][name]["done"] = count
         meta["translated_units"] = len(translations)
-        meta["review_count"] = review_count
-        meta["review_samples"] = review_samples
+        meta["failed_units"] = failed
         store.save_meta(project_id, meta)
 
     async def worker() -> None:
-        nonlocal processed_since_flush, review_count
+        nonlocal processed_since_flush, failed
         while not _cancel:
             try:
                 unit = queue.get_nowait()
             except asyncio.QueueEmpty:
                 return
             try:
-                text, needs_review = await _translate_one(unit.source, target_lang)
+                text = await _translate_one(unit.source, target_lang)
             except Exception:  # noqa: BLE001 - one bad string must not kill the run
-                text, needs_review = unit.source, True
+                # Backend error, not a bad translation: keep the source line so
+                # the game still reads correctly and count it so the total is
+                # honest about what the model actually produced.
+                text = unit.source
+                async with lock:
+                    failed += 1
 
             async with lock:
                 translations[unit.source] = text
                 for slot in unit.slots:
                     if slot.file in done_slots:
                         done_slots[slot.file] += 1
-                if needs_review:
-                    review_count += 1
-                    if len(review_samples) < _MAX_REVIEW_SAMPLES:
-                        review_samples.append(
-                            {"source": unit.source, "translation": text}
-                        )
                 processed_since_flush += 1
                 if processed_since_flush >= _FLUSH_EVERY:
                     processed_since_flush = 0

app/rpgmaker/store.py

@@ -163,8 +163,7 @@ def create(zip_bytes: bytes, name: str) -> dict:
         "total_units": len(units),
         "total_slots": sum(f["total"] for f in files.values()),
         "translated_units": 0,
-        "review_count": 0,
-        "review_samples": [],
+        "failed_units": 0,
         "unreadable_files": broken,
         "files": files,
         "error": None,