From 5a534c97114242403145037780350f8cec72c61c Mon Sep 17 00:00:00 2001 From: Cristian Date: Sun, 15 Nov 2026 21:48:38 -0500 Subject: [PATCH 1/3] =?UTF-8?q?fix(glosario):=20sin=20may=C3=BAscula=20par?= =?UTF-8?q?a=20palabras=20comunes=20de=20un=20mod?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Una palabra suelta de un mod que el español del juego o de los mods escribe en minúscula («Engranaje») ya no recibe mayúscula a mitad de frase; los nombres propios y el glosario del usuario conservan las suyas. Con las respuestas grabadas, de 22 textos que cambiaron, 20 se acercaron a la traducción humana. --- CHANGELOG.md | 1 + src/traductor_es/nucleo/glosario.py | 7 +++++ src/traductor_es/nucleo/traductor.py | 10 +++++-- tests/test_mayusculas_comunes.py | 42 ++++++++++++++++++++++++++++ 4 files changed, 58 insertions(+), 2 deletions(-) create mode 100644 tests/test_mayusculas_comunes.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 7f75f5f..62a39e4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -103,6 +103,7 @@ Todos los cambios importantes de ModpackES quedan en este archivo. El formato si ### Corregido - **La máscara tapaba texto que no era código:** en «R&D», «Q&A» o «B&B», el «&D», «&A» o «&B» se tomaba por un código de color y el modelo no veía la palabra. Una frase entre llaves («{the quick brown fox}») también se tapaba entera. Ahora solo se protegen los códigos: «&6Wrench&r», «&c&l», `{image:…}`, `{@pagebreak}`, `{0}`, `{clave}`. Con las respuestas grabadas, ningún pedido de los tres bancos cambió. +- **Mayúsculas de más en palabras comunes de un mod:** si un mod traducía «Gear» como «Engranaje», una misión que decía «the Gear» terminaba en «el Engranaje», aunque el español del juego escribe los objetos en minúscula a mitad de frase. Ahora, una palabra suelta que el español del juego o de los mods escribe en minúscula no recibe mayúscula («el marco de máquina», «cultivo de nivel 6»). Los nombres propios de una palabra («Arcanita», «Fluix») y tu glosario conservan las suyas. Con las respuestas grabadas, de 22 textos que cambiaron, 20 se acercaron más a la traducción humana. - **Los libros guía que viven en los archivos de idioma se traducían como interfaz.** Desde Patchouli 1.20 casi todos los libros usan claves de idioma (`"i18n": true`), igual que Modonomicon, y la app los mandaba al motor como textos de menú, sueltos. Ahora sus claves («occultism.book.entries…», «…guide.entry…») se traducen como libro, con el título de la entrada y el texto anterior como contexto, y entran en la revisión de misiones y libros. Los nombres de objetos y los textos de menús o tooltips siguen como interfaz. Lo ya traducido de esas claves se vuelve a pedir una vez, con el tono de libro. - **El glosario exigía términos donde la palabra tenía otro sentido:** «lead the way» pedía «Correa», «the power signal» pedía «Poder» y «the target» pedía «Diana». Ahora la app mira en el inglés y el español del juego y de los mods cómo se traduce cada palabra cuando va en minúscula. Si casi nunca sale con el término del glosario, ese término solo se manda y se exige cuando el texto lo usa como nombre: es todo el texto, va con mayúscula a mitad de frase o el texto es un nombre en estilo título. Las palabras que sí se traducen igual («fire» → «fuego») se siguen exigiendo, y los términos del usuario siempre. - **Términos de un mod a medio traducir** («Almacen Portable de Energía», «slot de los Muslos») ya no entran en el glosario: se descarta el término que deja en español una palabra inglesa que no sale en ningún texto en español del juego ni de los mods. Los nombres de los mods de la instancia («estilo Create») no cuentan. diff --git a/src/traductor_es/nucleo/glosario.py b/src/traductor_es/nucleo/glosario.py index 5a436c4..3e7a15d 100644 --- a/src/traductor_es/nucleo/glosario.py +++ b/src/traductor_es/nucleo/glosario.py @@ -40,6 +40,7 @@ def __init__(self) -> None: #: Palabra inglesa en minúscula → textos en español donde sale (del juego y los mods ya traducidos) self._usos: dict[str, list[str]] = {} self._palabras_es: set[str] = set() #: palabras del español de esos textos (sin mayúsculas) + self._minusculas_es: set[str] = set() #: las que esos textos escriben en minúscula («engranaje») self._ambiguos: dict[tuple[str, str], bool] = {} self._marcas: set[str] = set() #: nombres de mods («create»): no son inglés a medio traducir self._por_palabra: dict[str, list[tuple[str, str, re.Pattern[str]]]] | None = None @@ -90,6 +91,7 @@ def aprender_usos(self, ingles: Mapping[str, object], traducido: Mapping[str, ob continue limpio = sin_formato(valor_es) self._palabras_es.update(p.casefold() for p in PALABRA.findall(limpio)) + self._minusculas_es.update(p for p in PALABRA.findall(limpio) if p.islower()) for palabra in {p for p in PALABRA.findall(sin_formato(valor_en)) if p.islower() and len(p) >= 3}: usos = self._usos.setdefault(palabra, []) if len(usos) < _MAX_USOS: @@ -116,6 +118,11 @@ def ambiguo(self, termino: str) -> bool: self._ambiguos[clave] = aciertos < len(usos) / 2 return self._ambiguos[clave] + def comun_en_espanol(self, palabra: str) -> bool: + """¿El español del juego o de los mods escribe esta palabra en minúscula («engranaje», «martillo»)? Entonces + es un sustantivo común, no un nombre propio, aunque un mod la ponga con mayúscula en su nombre.""" + return palabra.casefold() in self._minusculas_es + def ambiguos(self, terminos: Iterable[str]) -> frozenset[str]: """Los términos de una palabra que en minúscula tienen otro sentido (ver `ambiguo`).""" return frozenset(t for t in terminos if self.ambiguo(t)) diff --git a/src/traductor_es/nucleo/traductor.py b/src/traductor_es/nucleo/traductor.py index 2760e5e..c96d87f 100644 --- a/src/traductor_es/nucleo/traductor.py +++ b/src/traductor_es/nucleo/traductor.py @@ -586,8 +586,14 @@ def _motivo_de_forma(self, original: str, final: str, glosario: Mapping[str, str def _con_mayusculas(self, glosario: Mapping[str, str]) -> dict[str, str]: """Términos cuyas mayúsculas se respetan: los del pack y del usuario. Los del juego («Cofre») no: en medio - de una frase en español los objetos del juego van en minúscula.""" - return {en: es for en, es in glosario.items() if not self.glosario.del_juego(en)} + de una frase en español los objetos del juego van en minúscula. Tampoco una palabra suelta de un mod que el + español escribe en minúscula («Engranaje»): es un sustantivo común. «Fluix» o «Arachnarch» sí la conservan.""" + return { + en: es + for en, es in glosario.items() + if not self.glosario.del_juego(en) + and (self.glosario.fijo(en) is not None or " " in es.strip() or not self.glosario.comun_en_espanol(es)) + } def _reparar( self, original: str, final: str, glosario: Mapping[str, str] | None, motivo: str diff --git a/tests/test_mayusculas_comunes.py b/tests/test_mayusculas_comunes.py new file mode 100644 index 0000000..5cc519e --- /dev/null +++ b/tests/test_mayusculas_comunes.py @@ -0,0 +1,42 @@ +"""Una palabra suelta de un mod que el español escribe en minúscula no recibe mayúscula a mitad de frase.""" + +from __future__ import annotations + +from traductor_es.motores.base import Lote +from traductor_es.nucleo.glosario import Glosario +from traductor_es.nucleo.memoria import Memoria +from traductor_es.nucleo.traductor import Traductor + + +class _Fijo: + nombre = "fijo" + + def __init__(self, salida: dict[str, str]) -> None: + self.salida = salida + + def traducir_lote(self, lote: Lote) -> dict[str, str]: + return {e.id: self.salida[e.texto] for e in lote.entradas} + + +def _glosario() -> Glosario: + g = Glosario() + g.agregar_pares({"a": "Gear", "b": "Arcanite"}, {"a": "Engranaje", "b": "Arcanita"}, fuente="mod") + g.aprender_usos({"z": "Craft a gear"}, {"z": "Fabrica un engranaje"}) # el español lo escribe en minúscula + return g + + +def test_un_sustantivo_comun_no_recibe_mayuscula() -> None: + texto = "Put the Gear and the Arcanite in the machine" + motor = _Fijo({texto: "Pon el engranaje y la arcanita en la máquina"}) + with Memoria(":memory:") as m: + r = Traductor(motor, m, _glosario()).traducir([texto], "mision") + assert r.traducciones[texto] == "Pon el engranaje y la Arcanita en la máquina" # nombre propio del mod + + +def test_el_glosario_del_usuario_conserva_sus_mayusculas() -> None: + g = _glosario() + g.fijar({"Gear": "Engranaje"}) + texto = "Put the Gear in the machine" + with Memoria(":memory:") as m: + r = Traductor(_Fijo({texto: "Pon el engranaje en la máquina"}), m, g).traducir([texto], "mision") + assert r.traducciones[texto] == "Pon el Engranaje en la máquina" From eb46467c539ae2d6d09914b0dcc2c7e8e14ea017 Mon Sep 17 00:00:00 2001 From: Cristian Date: Sun, 15 Nov 2026 22:11:08 -0500 Subject: [PATCH 2/3] feat(contexto): vecindad en las misiones de BetterQuesting, HQM y Heracles MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sus textos van con el título de la misión y el texto anterior, como los de FTB Quests. --- CHANGELOG.md | 1 + src/traductor_es/modulos/misiones.py | 11 ++++++++++- tests/test_misiones.py | 14 ++++++++++++++ 3 files changed, 25 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 62a39e4..562e9d0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -64,6 +64,7 @@ Todos los cambios importantes de ModpackES quedan en este archivo. El formato si - **Frases partidas con su contexto:** - Un texto con estilos mezclados («Use the » + «Wrench» en dorado + « to rotate») se sigue traduciendo por trozos, para no perder los estilos, pero cada trozo va con la frase entera, para que encaje en ella. Vale para las misiones (FTB Quests, Heracles) y los libros. - Una línea de una misión o de un libro que no cierra su frase («Right-click the block with») va con el comienzo de la siguiente, además de la anterior y el título que ya llevaba. + - Las misiones de BetterQuesting, Hardcore Questing Mode y Heracles van con el título de la misión y el texto anterior, como ya iban las de FTB Quests. - **Libros más fieles al original:** el pedido de libros ya no dice «Escribe de forma clara y natural». Esa frase empujaba al modelo a reescribir en vez de traducir: sin ella, el chrF del banco de libros subió 1,45 (IC 0,80 a 2,12). Vale para todos los libros guía, en JSON o en archivos de idioma. - **La memoria distingue cada modpack y recuerda lo dudoso:** - Cada traducción se guarda con su modpack y con su calidad: «ok», o el motivo por el que se aceptó con dudas. diff --git a/src/traductor_es/modulos/misiones.py b/src/traductor_es/modulos/misiones.py index 0f22c31..4876c47 100644 --- a/src/traductor_es/modulos/misiones.py +++ b/src/traductor_es/modulos/misiones.py @@ -20,6 +20,12 @@ def _es_titulo(pieza: Pieza) -> bool: return pieza.pista.endswith("title") +def _es_titulo_json(pieza: Pieza) -> bool: + """El nombre de una misión en BetterQuesting («name:8»), HQM («name») o Heracles («title»).""" + campo = pieza.pista.split(" · ", 1)[0] + return campo.endswith(("title", "name:8", ": name")) + + def _relativa(ctx: Contexto, ruta: Path) -> str: return ruta.relative_to(ctx.instancia.juego).as_posix() @@ -309,7 +315,10 @@ def _preparar(self) -> Iterator[_Trabajo]: elegidas = [(c, lit) for c in cadenas for ok, lit in [self._es_texto(c)] if ok] if not elegidas: continue - piezas = [p for c, lit in elegidas for p in piezas_de(c.texto, f"misión: {c.campo}", lit)] + # Con el título de la misión y el texto anterior, como en FTB Quests + piezas = con_vecindad( + [p for c, lit in elegidas for p in piezas_de(c.texto, f"misión: {c.campo}", lit)], _es_titulo_json + ) bom = original.startswith(b"\xef\xbb\xbf") def generar( diff --git a/tests/test_misiones.py b/tests/test_misiones.py index 7b6c7a7..e133f86 100644 --- a/tests/test_misiones.py +++ b/tests/test_misiones.py @@ -268,3 +268,17 @@ def test_ftbquests_lang_ignora_lo_que_quests_lang_splitter_ya_fusiono(tmp_path: assert not (lang / "es_mx" / "chapters").exists() # el «.snbt_merged» no genera traducción aparte assert "«ES» Find Iron" in (lang / "es_mx.snbt").read_text(encoding="utf-8") assert fusionado.read_text(encoding="utf-8") == '{ quest.A.title: "Find Iron" }' + + +def test_las_misiones_json_llevan_su_titulo_y_el_texto_anterior(tmp_path: Path) -> None: + juego = fabrica.prism(tmp_path, "1.20.1", "fabric") + sets = juego / "config" / "hqm" / "sets" + sets.mkdir(parents=True) + (juego / "config" / "hqm" / "sets.json").write_text('{"sets": ["Basics"]}', encoding="utf-8") + quest = {"quests": [{"name": "Wood", "description": "Get some wood"}]} + (sets / "Basics.json").write_text(json.dumps(quest), encoding="utf-8") + inst, ctx = contexto(juego) + with inst: + piezas = {p.texto: p.pista for p in HQM(ctx).recolectar()} + assert "dentro de «Wood»" in piezas["Get some wood"] + assert "dentro de" not in piezas["Wood"] From c8f5d7cc931302c6eab4dc18ddce5bb79222e3bb Mon Sep 17 00:00:00 2001 From: Cristian Date: Sun, 15 Nov 2026 22:16:34 -0500 Subject: [PATCH 3/3] =?UTF-8?q?fix(calidad):=20la=20hoja=20de=20revisi?= =?UTF-8?q?=C3=B3n=20distingue=20los=20libros=20gu=C3=ADa?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- scripts/hoja_revision.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/scripts/hoja_revision.py b/scripts/hoja_revision.py index 4ff688a..d5d1c1c 100644 --- a/scripts/hoja_revision.py +++ b/scripts/hoja_revision.py @@ -159,7 +159,7 @@ def _html(args: argparse.Namespace) -> int: datos: list[dict[str, Any]] = json.loads(args.entrada.read_text(encoding="utf-8")) filas = [] for t in datos[-1]["traducciones"]: - tipo = "Misión" if t["ambito"] == "mision" else "Interfaz de un mod" + tipo = {"mision": "Misión", "libro": "Libro guía"}.get(t["ambito"], "Interfaz de un mod") filas.append( { "tipo": tipo, @@ -260,7 +260,7 @@ def _ab(args: argparse.Namespace) -> int: continue ahora_es_a = azar.random() < 0.5 # a ciegas: no se sabe cuál es la nueva a, b = (otra, t["traduccion"]) if ahora_es_a else (t["traduccion"], otra) - tipo = "Misión" if t["ambito"] == "mision" else "Interfaz de un mod" + tipo = {"mision": "Misión", "libro": "Libro guía"}.get(t["ambito"], "Interfaz de un mod") filas.append( { "tipo": tipo,