Die Schleife brach bislang nach dem ersten mit "career" getaggten Compendium ab, egal ob dort eine Übersetzung gefunden wurde. Da mehrere Zusatzmodule (Up in Arms, Archives, EIS, Empire in Ruins, ...) eigene, career-getaggte Items mitbringen, blieb die Karrieregruppe unübersetzt, sobald ein solches Zusatzpaket vor wfrp4e-core in der Pack-Liste stand und die betreffende Karriere (z.B. "Spy") dort nicht existierte - obwohl wfrp4e-core selbst die korrekte Übersetzung hatte. Jetzt wird erst zurückgegeben, wenn ein Pack tatsächlich eine Übersetzung liefert; sonst wird das nächste Pack geprüft. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
667 lines
30 KiB
JavaScript
667 lines
30 KiB
JavaScript
/************************************************************************************/
|
|
import loadScripts from "./loadScripts.js";
|
|
import statParserFR from "./import-stat-2.js";
|
|
|
|
/************************************************************************************/
|
|
let compmod = "wfrp4e-core";
|
|
const vo_conditions = {
|
|
"ablaze": "Ablaze",
|
|
"bleeding": "Bleeding",
|
|
"blinded": "Blinded",
|
|
"broken": "Broken",
|
|
"deafened": "Deafened",
|
|
"entangled": "Entangled",
|
|
"fatigued": "Fatigued",
|
|
"poisoned": "Poisoned",
|
|
"prone": "Prone",
|
|
"stunned": "Stunned",
|
|
"surprised": "Surprised",
|
|
"unconscious": "Unconscious",
|
|
"grappling": "Grappling",
|
|
"fear": "Fear",
|
|
"defeated": "Defeated"
|
|
}
|
|
|
|
// Map English characteristic names (as they appear in spell formulas) to WFRP4e abbreviations
|
|
const __CHAR_EN_TO_ABBR = {
|
|
"weapon skill": "ws",
|
|
"ballistic skill": "bs",
|
|
"strength": "s",
|
|
"toughness": "t",
|
|
"initiative": "i",
|
|
"agility": "ag",
|
|
"dexterity": "dex",
|
|
"intelligence": "int",
|
|
"willpower": "wp",
|
|
"fellowship": "fel"
|
|
}
|
|
|
|
/************************************************************************************/
|
|
export class WFRP4FrTranslation {
|
|
|
|
static parseSpellContent(spell) {
|
|
if (spell.system.range?.value) {
|
|
spell.system.range.value = this.processSpellContent(spell.system.range.value)
|
|
}
|
|
if (spell.system.damage?.value) {
|
|
spell.system.damage.value = this.processSpellContent(spell.system.damage.value)
|
|
}
|
|
if (spell.system.duration?.value) {
|
|
spell.system.duration.value = this.processSpellContent(spell.system.duration?.value)
|
|
}
|
|
if (spell.system.range?.value) {
|
|
spell.system.range.value = this.processSpellContent(spell.system.range?.value)
|
|
}
|
|
if (spell.system.target?.value) {
|
|
spell.system.target.value = this.processSpellContent(spell.system.target?.value)
|
|
}
|
|
}
|
|
|
|
static processSpellContent(value) {
|
|
if (value == "") return ""; // Hop !
|
|
if (value == "Touch") return "Berührung"; // Hop !
|
|
if (value == "You") return "Du"; // Hop !
|
|
if (value == "Instant") return "Sofort"; // Hop !
|
|
let translw = value;
|
|
let re = /(.*)\s+[Bb]onus\s*(.*)/i; // (.*) at end captures modifiers like "+4"
|
|
let res = re.exec(value);
|
|
let unit = "";
|
|
if (res) { // Test "<charac> Bonus <modifier>" pattern
|
|
if (res[1]) { // We have char name, then convert it
|
|
const charEN = res[1].trim().toLowerCase();
|
|
const abbr = __CHAR_EN_TO_ABBR[charEN];
|
|
if (abbr && game.wfrp4e?.config?.characteristicsBonus?.[abbr]) {
|
|
// Use the localized German bonus name from config (already resolved by localizeConfig at i18nInit)
|
|
translw = game.wfrp4e.config.characteristicsBonus[abbr];
|
|
} else {
|
|
translw = game.i18n.localize(res[1].trim());
|
|
translw = translw + "bonus";
|
|
}
|
|
}
|
|
unit = res[2]; // may be "+4", "-2", "2", "yards", etc.
|
|
} else {
|
|
re = /(\d+) (\w+)/i;
|
|
res = re.exec(value);
|
|
if (res) { // Test : "<number> <unit>" pattern
|
|
translw = res[1];
|
|
unit = res[2];
|
|
} else { // Test
|
|
re = /(\w+) (\w+)/i;
|
|
res = re.exec(value);
|
|
if (res) { // Test : "<charac> <unit>" pattern
|
|
translw = game.i18n.localize(res[1].trim());
|
|
unit = res[2];
|
|
}
|
|
}
|
|
}
|
|
if (unit == "hour") unit = "stunde";
|
|
if (unit == "hours") unit = "stunden";
|
|
if (unit == "days") unit = "tage";
|
|
if (unit == "yard") unit = "meter";
|
|
if (unit == "yards") unit = "meter";
|
|
if (unit == "Bonus") { // Another weird management
|
|
console.log("Translating bonus", unit);
|
|
translw = translw + " Bonus";
|
|
} else if (unit && /^[+\-*\/]/.test(unit)) {
|
|
translw += unit; // No space before operators like "+4"
|
|
} else {
|
|
translw += " " + unit;
|
|
}
|
|
return translw;
|
|
}
|
|
}
|
|
|
|
/************************************************************************************/
|
|
Hooks.once('init', () => {
|
|
|
|
// Check various settings in the installation
|
|
game.modules.forEach((module, id) => {
|
|
if (id == "wfrp4e-core" && module.active) {
|
|
compmod = "wfrp4e-core";
|
|
}
|
|
});
|
|
game.wfrp4efr = {
|
|
compmod: compmod,
|
|
vo_conditions: vo_conditions
|
|
}
|
|
|
|
game.wfrp4e.apps.StatBlockParser.parseStatBlock = async function (statString, type = "npc") {
|
|
return statParserFR(statString, type);
|
|
}
|
|
|
|
console.log("WFRP4E-DE | Modul wird übersetzt ...");
|
|
loadScripts();
|
|
|
|
});
|
|
|
|
/************************************************************************************/
|
|
// Babele registration must happen in Babele's own "babele.init" hook (fires before
|
|
// Babele builds its runtime session/mapping layers). Registering in Foundry's
|
|
// "init" hook is too late for Babele 2.8+: once the runtime session is installed,
|
|
// late register()/registerConverters() calls are silently rejected, leaving the
|
|
// pack "loaded" (JSON parsed) but with no effective mapping applied - which is
|
|
// exactly the "everything stays English except journals" symptom.
|
|
// See: https://gitlab.com/riccisi/foundryvtt-babele/-/raw/master/DEVELOPER_MIGRATION_2_8_0.md
|
|
Hooks.once('babele.init', () => {
|
|
|
|
if (typeof game.babele !== 'undefined') {
|
|
|
|
game.babele.register({
|
|
module: 'wh4-de-translation',
|
|
lang: 'de',
|
|
dir: 'compendium'
|
|
})
|
|
|
|
// Pre-define functions for cross-converter calls (Babele 2.8+ wraps converters
|
|
// as objects, so game.babele.converters.X() no longer works as a plain call)
|
|
const career_skills_fn = (skills_list) => {
|
|
let validCompendiums = game.wfrp4e.tags.getPacksWithTag("skill")
|
|
//DEBUG: console.log( "Thru here ...", compendium, skills_list);
|
|
if (skills_list) {
|
|
let i;
|
|
let len = skills_list.length;
|
|
let re = /(.*)\((.*)\)/i;
|
|
for (i = 0; i < len; i++) {
|
|
skills_list[i] = skills_list[i].trim();
|
|
for (let compData of validCompendiums) {
|
|
let translItem = game.babele.translate(compData.metadata.id, { name: skills_list[i], type: "skill" }, true)
|
|
let transl = translItem?.name || undefined
|
|
if (!transl) transl = skills_list[i]
|
|
if (transl == skills_list[i]) {
|
|
let res = re.exec(skills_list[i]);
|
|
if (res) {
|
|
let subword = game.i18n.localize(res[2].trim());
|
|
let s1 = res[1].trim() + " ()";
|
|
translItem = game.babele.translate(compData.metadata.id, { name: s1, type: "skill" }, true)
|
|
let translw = translItem?.name || undefined
|
|
if (translw && translw != s1) {
|
|
let res2 = re.exec(translw);
|
|
transl = res2[1].trim() + " (" + subword + ")";
|
|
} else {
|
|
s1 = res[1].trim() + " ( )";
|
|
translItem = game.babele.translate(compData.metadata.id, { name: s1, type: "skill" }, true)
|
|
translw = translItem?.name || undefined
|
|
if (translw) {
|
|
let res2 = re.exec(translw);
|
|
transl = res2[1].trim() + " (" + subword + ")";
|
|
} else {
|
|
transl = res[1].trim() + " (" + subword + ")";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
skills_list[i] = transl;
|
|
if (translItem?.system)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return skills_list
|
|
};
|
|
|
|
const career_careergroup_fn = (value) => {
|
|
if (value == 'Slayer') return "Slayer";
|
|
if (value == 'Druidic Priest') return "Druide";
|
|
let validCompendiums = game.wfrp4e.tags.getPacksWithTag("career");
|
|
// Try every career-tagged pack (core + supplements like Up in Arms, Archives, EIS, ...)
|
|
// before giving up - a career group's defining career may only exist in one of them,
|
|
// so returning after the first pack silently left it untranslated whenever that pack
|
|
// happened not to be the one with the match (e.g. "Spy" only exists in wfrp4e-core).
|
|
for (let compData of validCompendiums) {
|
|
let newName = game.babele.translate(compData.metadata.id, { name: value })?.name;
|
|
if (newName) return newName;
|
|
}
|
|
ui.notifications.error("Das Übersetzen der Karriere " + value + " ist nicht möglich. Sie ist wahrscheinlich nicht übersetzt.", { permanent: true });
|
|
return value;
|
|
};
|
|
|
|
game.babele.registerConverters({
|
|
|
|
"career_skills": career_skills_fn,
|
|
"role_skills": (skills) => {
|
|
let skills_list = skills.split(',');
|
|
let skillsFR = career_skills_fn(skills_list);
|
|
return skillsFR.join(', ')
|
|
},
|
|
"process_effects": (effectsData, translations, data, tc, tc_translations) => {
|
|
//console.log("Effects :", effectsData, translations, data, tc, tc_translations)
|
|
for (let e of effectsData) {
|
|
// Foundry v13 requires name; migrate legacy data where only label was stored
|
|
if (e.name == null) e.name = e.label || "";
|
|
let origName = e.name
|
|
// Symptom effects have their own name (Fever, Malaise, etc.) — don't overwrite with the parent item name
|
|
if (e.flags?.wfrp4e?.symptom) {
|
|
let symName = e.name;
|
|
let gravity = "";
|
|
if (symName.includes("(") && symName.includes(")")) {
|
|
let re = /(.*) +\((.*)\)/i;
|
|
let res = re.exec(symName);
|
|
if (res) {
|
|
symName = res[1].trim();
|
|
gravity = " (" + game.i18n.localize(res[2].trim()) + ")";
|
|
}
|
|
}
|
|
e.name = game.i18n.localize(symName) + gravity;
|
|
} else {
|
|
e.name = tc_translations.name || game.i18n.localize(e.name) || e.label || ""
|
|
}
|
|
if (e.flags?.wfrp4e?.scriptData) {
|
|
for (let script of e.flags.wfrp4e.scriptData) {
|
|
if (script?.label) {
|
|
// Quand le label du script est strictement identique au nom de l'item concerné
|
|
if (script.label.toLowerCase() == origName.toLowerCase()) {
|
|
script.label = e.name
|
|
} else if (script.label.toLowerCase().includes("tests to affect")) {
|
|
script.label = script.label.replace("Tests to affect", "Würfe zum Beeinflussen von ")
|
|
} else if (script.label.toLowerCase().includes("using torn muscle")) {
|
|
script.label = script.label.replace("Using Torn Muscle", "Verwende gerissenen Muskel ")
|
|
} else {
|
|
script.label = game.i18n.localize(script.label)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return effectsData
|
|
},
|
|
"resultConverter": (results, translated) => {
|
|
//console.log("STUF PARSING", results, translated)
|
|
if (translated) {
|
|
for (let data of results) {
|
|
if (translated[`${data.range[0]}-${data.range[1]}`]) {
|
|
data.description = translated[`${data.range[0]}-${data.range[1]}`]
|
|
}
|
|
}
|
|
return results
|
|
}
|
|
// Auto patch
|
|
if (results[0].description.includes("wfrp4e-core.career-descriptions")) {
|
|
results[0].description = "wfrp4e-core.journals"
|
|
}
|
|
if (results[0].description.includes("wfrp4e-core.journal")) {
|
|
for (let data of results) {
|
|
let career = data.description.match(/{(.*)}/)
|
|
//console.log(">>>>>", career)
|
|
if (career?.[1]) {
|
|
let careerFR = career_careergroup_fn(career[1])
|
|
data.description = data.description.replace(career[1], careerFR)
|
|
}
|
|
}
|
|
}
|
|
if (results?.[0].documentUuid) {
|
|
// Babele 2.8+ handles documentUuid resolution via its own mapping system
|
|
return results
|
|
}
|
|
return results
|
|
},
|
|
|
|
"npc_details": (details) => {
|
|
//console.log("DETAILS: ", details);
|
|
let newDetails = foundry.utils.duplicate(details);
|
|
if (details.species?.value)
|
|
newDetails.species.value = game.i18n.localize(details.species.value);
|
|
if (details.gender?.value)
|
|
newDetails.gender.value = game.i18n.localize(details.gender.value);
|
|
if (details.class?.value)
|
|
newDetails.class.value = game.i18n.localize(details.class.value);
|
|
return newDetails;
|
|
},
|
|
|
|
"career_talents": (talents_list) => {
|
|
let validCompendiums = game.wfrp4e.tags.getPacksWithTag("talent")
|
|
let i;
|
|
if (talents_list) {
|
|
let len = talents_list.length;
|
|
let re = /(.*)\((.*)\)/i;
|
|
for (i = 0; i < len; i++) {
|
|
for (let compData of validCompendiums) {
|
|
let translItem = game.babele.translate(compData.metadata.id, { name: talents_list[i] }, true);
|
|
// Specific case management
|
|
if (talents_list[i] === "Trapper") {
|
|
translItem = game.babele.translate(compData.metadata.id, { name: "a7v422EZcOUUC20X" }, true);
|
|
}
|
|
if (talents_list[i] === "Inspiring") {
|
|
translItem = game.babele.translate(compData.metadata.id, { name: "WCXnFSV4WOSmzzc4" }, true);
|
|
}
|
|
//console.log("Search talent name:", compData.metadata.id, talents_list[i], translItem);
|
|
let transl = translItem?.name || undefined
|
|
if (!transl) transl = talents_list[i]
|
|
if (transl == talents_list[i]) {
|
|
let res = re.exec(talents_list[i]);
|
|
if (res) {
|
|
let subword = game.i18n.localize(res[2].trim());
|
|
let s1 = res[1].trim(); // No () in talents table
|
|
translItem = game.babele.translate(compData.metadata.id, { name: s1 }, true)
|
|
let translw = translItem?.name || undefined
|
|
//console.log("Search talent name:", compData.metadata.id, s1, translw);
|
|
if (translw && translw != s1) {
|
|
transl = translw.trim() + " (" + subword + ")";
|
|
}
|
|
}
|
|
}
|
|
talents_list[i] = transl;
|
|
if (translItem?.system)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return talents_list;
|
|
},
|
|
"npc_characteristics": (chars) => { // Auto-convert char names in the sheet
|
|
for (let key in chars) {
|
|
let char = chars[key];
|
|
//console.log("Was here !", key, char );
|
|
let abrev = char["abrev"];
|
|
let toTransl = "CHAR." + abrev;
|
|
if (game.i18n.localize(toTransl) != toTransl) { // Manages unknown language
|
|
char["label"] = game.i18n.localize("CHAR." + abrev);
|
|
char["abrev"] = game.i18n.localize("CHARAbbrev." + abrev);
|
|
}
|
|
}
|
|
return chars;
|
|
},
|
|
"bestiary_traits": (beast_traits, translations) => {
|
|
if (!beast_traits) {
|
|
console.log("No beast traits found here ...")
|
|
return beast_traits
|
|
}
|
|
//console.log("TRANS:", beast_traits)
|
|
// Normalize: Foundry v13 requires ActiveEffect.name; migrate legacy v12 data
|
|
for (let trait_en of beast_traits) {
|
|
if (trait_en.effects) {
|
|
for (let eff of trait_en.effects) {
|
|
if (eff.name == null) eff.name = eff.label || "";
|
|
}
|
|
}
|
|
}
|
|
for (let trait_en of beast_traits) {
|
|
let special = "";
|
|
let nbt = "";
|
|
let name_en = trait_en.name.replace(/\r/g, '').trim(); // strip \r (including internal) in some traits name
|
|
if (!trait_en.name || trait_en.name.length == 0) {
|
|
console.log("Wrong item name found!!!!")
|
|
continue
|
|
}
|
|
//console.log(">>>>>>>> Parsing", trait_en.name)
|
|
if (trait_en.type == "trait") {
|
|
//console.log("Trait translation", compmod, trait_en)
|
|
if (name_en.includes("Tentacles")) { // Process specific Tentacles case
|
|
let re = /(.d*)x Tentacles/i;
|
|
let res = re.exec(name_en);
|
|
if (res?.[1])
|
|
nbt = res[1] + "x ";
|
|
name_en = "Tentacles";
|
|
} else if (name_en.includes("(") && name_en.includes(")")) { // Then process specific traits name with (xxxx) inside
|
|
let re = /(.*) \((.*)\)/i;
|
|
let res = re.exec(name_en);
|
|
if (!res) { console.warn("WFRP4E-DE | bestiary_traits: regex failed for trait:", name_en); }
|
|
else {
|
|
name_en = res[1]; // Get the root traits name
|
|
special = " (" + game.i18n.localize(res[2].trim()) + ")"; // And the special keyword
|
|
}
|
|
}
|
|
let validCompendiums = game.wfrp4e.tags.getPacksWithTag("trait")
|
|
for (let compData of validCompendiums) {
|
|
let trait_fr = game.babele.translate(compData.metadata.id, { name: name_en, system: { description: { value: trait_en.system.description.value } } }, true)
|
|
if (trait_fr?.name && trait_fr?.name != name_en) {
|
|
trait_fr.name = trait_fr.name || trait_en.name
|
|
trait_en.name = nbt + trait_fr.name + special;
|
|
if (trait_en.system?.description?.value && trait_fr.system?.description?.value) {
|
|
trait_en.system.description.value = trait_fr.system.description.value;
|
|
}
|
|
if (trait_en?.system?.specification && isNaN(trait_en.system.specification?.value)) { // This is a string, so translate it
|
|
//console.log("Translating : ", trait_en.system.specification.value);
|
|
trait_en.system.specification.value = game.i18n.localize(trait_en.system.specification.value.trim());
|
|
}
|
|
break // Translation has been found, skip other compendiums
|
|
}
|
|
}
|
|
} else if (trait_en.type == "skill") {
|
|
if (name_en.includes("(") && name_en.includes(")")) { // Then process specific skills name with (xxxx) inside
|
|
let re = /(.*) +\((.*)\)/i;
|
|
let res = re.exec(name_en);
|
|
if (!res) { console.warn("WFRP4E-DE | bestiary_traits: regex failed for skill:", name_en); }
|
|
else {
|
|
name_en = res[1].trim(); // Get the root skill name
|
|
special = " (" + game.i18n.localize(res[2].trim()) + ")"; // And the special keyword
|
|
}
|
|
}
|
|
let validCompendiums = game.wfrp4e.tags.getPacksWithTag("skill")
|
|
for (let compData of validCompendiums) {
|
|
let trait_fr = game.babele.translate(compData.metadata.id, { name: name_en, system: { description: { value: trait_en.system.description.value } } }, true)
|
|
//console.log(">>>>> Skill ?", name_en, special, trait_fr.name, trait_fr);
|
|
if (trait_fr?.name && trait_fr?.name != name_en) {
|
|
trait_fr.name = trait_fr.name || name_en
|
|
trait_en.name = trait_fr.name + special;
|
|
trait_en.system.description.value = trait_fr.system.description.value;
|
|
break; // Translation has been found, skip other compendiums
|
|
}
|
|
}
|
|
} else if (trait_en.type == "prayer") {
|
|
let validCompendiums = game.wfrp4e.tags.getPacksWithTag("prayer")
|
|
for (let compData of validCompendiums) {
|
|
let trait_fr = game.babele.translate(compData.metadata.id, { name: name_en, system: { description: { value: trait_en.system.description.value } } }, true)
|
|
if (trait_fr?.name && trait_fr?.name != name_en) {
|
|
//DEBUG : console.log(">>>>> Prayer ?", name_en, special, trait_fr.name );
|
|
WFRP4FrTranslation.parseSpellContent(trait_en)
|
|
trait_fr.name = trait_fr.name || name_en
|
|
trait_en.name = trait_fr.name + special;
|
|
if (trait_fr.system?.description?.value) {
|
|
trait_en.system.description.value = trait_fr.system.description.value;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
} else if (trait_en.type == "spell") {
|
|
let validCompendiums = game.wfrp4e.tags.getPacksWithTag("spell")
|
|
for (let compData of validCompendiums) {
|
|
let trait_fr = game.babele.translate(compData.metadata.id, { name: name_en, system: { description: { value: trait_en.system.description.value } } }, true)
|
|
if (trait_fr?.name && trait_fr?.name != name_en) {
|
|
//DEBUG : console.log(">>>>> Spell ?", name_en, special, trait_fr);
|
|
WFRP4FrTranslation.parseSpellContent(trait_en)
|
|
trait_fr.name = trait_fr.name || name_en
|
|
trait_en.name = trait_fr.name + special;
|
|
if (trait_fr.system?.description?.value) {
|
|
trait_en.system.description.value = trait_fr.system.description.value;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
} else if (trait_en.type == "talent") {
|
|
if (name_en.includes("(") && name_en.includes(")")) { // Then process specific skills name with (xxxx) inside
|
|
let re = /(.*) +\((.*)\)/i;
|
|
let res = re.exec(name_en);
|
|
if (!res) { console.warn("WFRP4E-DE | bestiary_traits: regex failed for talent:", name_en); }
|
|
else {
|
|
name_en = res[1].trim(); // Get the root talent name, no parenthesis this time...
|
|
special = " (" + game.i18n.localize(res[2].trim()) + ")"; // And the special keyword
|
|
}
|
|
}
|
|
let validCompendiums = game.wfrp4e.tags.getPacksWithTag("talent")
|
|
for (let compData of validCompendiums) {
|
|
if (name_en === "Trapper") {
|
|
name_en = "a7v422EZcOUUC20X"
|
|
}
|
|
if (name_en === "Inspiring") {
|
|
name_en = "WCXnFSV4WOSmzzc4"
|
|
}
|
|
trait_en.name = name_en // Reset the name to the original one
|
|
let trait_fr = game.babele.translate(compData.metadata.id, trait_en, true)
|
|
if (trait_fr?.name && trait_fr?.name != name_en) {
|
|
trait_fr.name = trait_fr.name || name_en // Security since babele v10
|
|
//console.log(">>>>> Talent ?", trait_fr, name_en, special, trait_fr.name);
|
|
if (trait_fr.name && (trait_fr.name == "Sprinter" || trait_fr.name != name_en)) { // Talent translated!
|
|
trait_en.name = trait_fr.name.trim() + special
|
|
if (trait_fr.system?.tests?.value) { // Why ???
|
|
trait_en.system.tests.value = trait_fr.system.tests.value;
|
|
}
|
|
if (trait_fr.system?.description?.value) { // Why ???
|
|
trait_en.system.description.value = trait_fr.system.description.value;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
} else if (trait_en.type == "career") {
|
|
let validCompendiums = game.wfrp4e.tags.getPacksWithTag("career")
|
|
for (let compData of validCompendiums) {
|
|
let career_fr = game.babele.translate(compData.metadata.id, trait_en, true);
|
|
if (career_fr?.name && career_fr?.name != name_en) {
|
|
trait_en.name = career_fr.name || trait_en.name
|
|
// DEBG: console.log(">>>>> Career ?", career_fr.name );
|
|
trait_en.system = foundry.utils.duplicate(career_fr.system);
|
|
break;
|
|
}
|
|
}
|
|
} else if (trait_en.type == "vehicleRole") {
|
|
let validCompendiums = game.wfrp4e.tags.getPacksWithTag("vehicleRole")
|
|
for (let compData of validCompendiums) {
|
|
let role_fr = game.babele.translate(compData.metadata.id, trait_en, true);
|
|
if (role_fr?.name && role_fr?.name != name_en) {
|
|
trait_en.name = role_fr.name || trait_en.name
|
|
// DEBG: console.log(">>>>> Role ?", role_fr.name );
|
|
trait_en.system = foundry.utils.duplicate(role_fr.system);
|
|
break;
|
|
}
|
|
}
|
|
} else if (trait_en.type == "trapping" || trait_en.type == "weapon" || trait_en.type == "armour" || trait_en.type == "container" || trait_en.type == "money") {
|
|
let validCompendiums = game.wfrp4e.tags.getPacksWithTag(["trapping"], ["weapon", "armour", "container", "money"])
|
|
for (let compData of validCompendiums) {
|
|
let trapping_fr = game.babele.translate(compData.metadata.id, { name: name_en, system: { description: { value: trait_en.system.description.value } } }, true);
|
|
if (trapping_fr?.name && trapping_fr?.name != name_en) {
|
|
//console.log(">>>>> Trapping ?", name_en, trapping_fr.name);
|
|
trait_en.name = trapping_fr.name || trait_en.name
|
|
if (trapping_fr.system?.description?.value) {
|
|
trait_en.system.description.value = trapping_fr.system.description.value
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//console.log(">>>>>>>><OUTPUT", beast_traits)
|
|
return beast_traits
|
|
},
|
|
// To avoid duplicateing class for all careers
|
|
"generic_localization": (value) => {
|
|
let ret = value
|
|
if (value) {
|
|
ret = game.i18n.localize(value.trim());
|
|
if (!ret) ret = value
|
|
}
|
|
return ret
|
|
},
|
|
"trapping_qualities_flaws": (value) => {
|
|
if (value) {
|
|
let newQF = [];
|
|
//console.log("ATOUTS", value, typeof(value));
|
|
let list = value
|
|
if (typeof (value) == "string") {
|
|
let myList = value.split(",")
|
|
list = []
|
|
for (let l of myList) {
|
|
list.push({ name: l.trim() })
|
|
}
|
|
}
|
|
for (let i = 0; i < list.length; i++) {
|
|
newQF[i] = foundry.utils.duplicate(list[i])
|
|
if (newQF[i].name == "Trap Blade") {
|
|
newQF[i].name = "TrapBlade"; // Auto-patch, without space!
|
|
//console.log("PATCHED", trim);
|
|
}
|
|
let oldName = newQF[i].name
|
|
newQF[i].name = game.i18n.localize(oldName)
|
|
if (!newQF[i].name) newQF[i].name = oldName
|
|
}
|
|
return newQF;
|
|
}
|
|
},
|
|
// Search back in careers the translated name of the groupe (as it is the name of the level career itself)
|
|
"career_careergroup": career_careergroup_fn,
|
|
|
|
"mutations_modifier": (value) => { // This is really UGLYYYY i know, but i started like this and discovered afterward that many strings were not easy to automate... Sorry :)
|
|
//console.log("Parsing mutation :", value);
|
|
if (!value) return;
|
|
value = value.toLowerCase();
|
|
value = value.replace("gain a broken condition if you fail a test derived from ", "Du erhälst einen Demoralisiert-Zustand wenn dir ein Wurf misslingt in ");
|
|
value = value.replace("weapon skill", "Kampfgeschick");
|
|
value = value.replace("ballistic skill", "Ballisitsche Fertigkeit");
|
|
value = value.replace("strength", "Stärke");
|
|
value = value.replace("toughness", "Widerstand");
|
|
value = value.replace("agility", "Gewandheit");
|
|
value = value.replace("dexterity", "Geschicklichkeit");
|
|
value = value.replace("willpower", "Willenskraft");
|
|
value = value.replace("fellowship", "Charisma");
|
|
value = value.replace("initiative", "Initiative");
|
|
value = value.replace("intelligence", "Intelligenz");
|
|
value = value.replace("armor points to the head", "RP am Kopf");
|
|
value = value.replace("subject to frenzy", "unterliegt Raserei");
|
|
value = value.replace("you do not scar", "Du bildest keine Narben");
|
|
value = value.replace("movement", "Bewegung");
|
|
value = value.replace("armor points to all locations", "RP am ganzen Körper");
|
|
value = value.replace("to any test when alone", "auf jeden Wurf, wenn du alleine bsit");
|
|
value = value.replace("track", "Spurenlesen");
|
|
value = value.replace("to any test not hurting another", "auf jeden Wurf, um anderen keine Schmerzen zuzufügen");
|
|
value = value.replace("on tests to hurt", "auf jeden Wurf, um anderen Schmerzen zuzufügen")
|
|
value = value.replace("to all language tests when speaking", "auf alle Sprache-Würfe beim Sprechen");
|
|
value = value.replace("on perception tests involving sight", "auf Wahrnehmungs-Würfe, bei denen es um die Sicht geht");
|
|
value = value.replace("to all Sociabilité tests", "auf alle gesellschaftlichen Würfe");
|
|
return value;
|
|
},
|
|
"talent_name": (name, translation) => {
|
|
console.log("NAME !!!", name, translation)
|
|
},
|
|
"effects": (effects, translations) => {
|
|
if (!effects) return;
|
|
if (!translations) return;
|
|
for (let i = 0; i < effects.length; i++) {
|
|
let effect = effects[i];
|
|
//console.log("EFFECT LABEL1:", effect );
|
|
effect.name = translations['label' + i];
|
|
}
|
|
return effects
|
|
},
|
|
"diseases_effects": (effects, translations) => {
|
|
if (!effects) return;
|
|
for (const element of effects) {
|
|
let effect = element;
|
|
let name = effect.name || effect.label;
|
|
let gravity = "";
|
|
if (name.includes("(") && name.includes(")")) { // Then process specific skills name with (xxxx) inside
|
|
let re = /(.*) +\((.*)\)/i;
|
|
let res = re.exec(name);
|
|
name = res[1].trim(); // Get the gravity
|
|
gravity = " (" + game.i18n.localize(res[2].trim()) + ")"; // And the special keyword
|
|
}
|
|
effect.name = game.i18n.localize(name) + gravity;
|
|
}
|
|
},
|
|
// Auto-translate duration
|
|
"spells_duration_range_target_damage": (value) => {
|
|
return WFRP4FrTranslation.processSpellContent(value);
|
|
},
|
|
// Auto-translate disease duration units
|
|
"disease_duration_unit": (unit) => {
|
|
return game.i18n.localize(unit).capitalize();
|
|
}
|
|
});
|
|
}
|
|
|
|
});
|
|
|
|
|
|
/*---------------------------------------------------------------------*/
|
|
Hooks.once('ready', () => {
|
|
|
|
console.log("WFRP4E-DE | Modul ist übersetzt.");
|
|
ui.notifications.info("WFRP4E-DE: Übersetzung ist fertig geladen.");
|
|
|
|
import("https://www.uberwald.me/fvtt_appcount/count-class-ready.js").then(moduleCounter => {
|
|
console.log("ClassCounter loaded", moduleCounter)
|
|
moduleCounter.ClassCounter.registerUsageCount("wh4-de-translation")
|
|
}).catch(err =>
|
|
console.log("No stats available, giving up.")
|
|
)
|
|
|
|
});
|