foundryvtt-wh4-lang-fr-fr/babele-register.js

556 lines
26 KiB
JavaScript
Raw Permalink Normal View History

2020-11-08 00:22:04 +01:00
/************************************************************************************/
2020-11-08 23:12:52 +01:00
import statParserFR from "./modules/import-stat-2.js";
2020-11-08 00:22:04 +01:00
2020-06-29 08:12:31 +02:00
/************************************************************************************/
var compmod = "wfrp4e";
2020-11-13 14:52:23 +01:00
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"
}
/************************************************************************************/
2020-03-25 20:37:09 +01:00
Hooks.once('init', () => {
2020-07-03 11:38:38 +02:00
// Check various settings in the installation
2020-06-29 07:44:16 +02:00
game.modules.forEach((module, name) => {
2020-11-05 21:53:12 +01:00
if ( name == "wfrp4e-core" && module.active) {
compmod = "wfrp4e-core";
}
2020-06-29 07:47:22 +02:00
} );
2020-11-13 14:52:23 +01:00
game.wfrp4efr = { compmod: compmod,
vo_conditions: vo_conditions }
2020-11-08 00:22:04 +01:00
2020-11-08 23:12:52 +01:00
game.wfrp4e.apps.StatBlockParser.parseStatBlock = async function( statString, type = "npc") {
return statParserFR( statString, type);
}
2020-11-13 14:52:23 +01:00
/*---------------------------------------------------------------------*/
game.wfrp4e.utility.handleConditionClick = function(event) {
let cond = $(event.currentTarget).attr("data-cond")
if (!cond)
cond = event.target.text;
cond = cond.trim();
let condkey
// En vo, les noms d'états sont égaux aux clés en minuscules
if ( game.wfrp4e.config.conditions[cond.toLowerCase()] ) {
condkey = cond.toLowerCase();
} else {
try {
condkey = game.wfrp4e.utility.findKey(cond.toLowerCase(), game.wfrp4e.config.conditions, {caseInsensitive: true});
}
catch {
2021-04-21 11:25:14 +02:00
ui.notifications.error("L'état est inconnu : " + cond);
2020-11-13 14:52:23 +01:00
}
}
let condName = game.wfrp4e.config.conditions[condkey];
let condDescr = game.wfrp4e.config.conditionDescriptions[condkey];
let messageContent = `<b>${condName}</b><br>${condDescr}`
let chatData = game.wfrp4e.utility.chatDataSetup(messageContent)
ChatMessage.create(chatData);
}
/*---------------------------------------------------------------------*/
2020-11-07 13:46:15 +01:00
game.wfrp4e.entities.ActorWfrp4e.prototype.calculateRangeOrDamage = function(formula)
{
//console.log("FR function calculateRangeOrDamage !", formula);
let actorData = this.data
try
{
formula = formula.toLowerCase();
// Iterate through characteristics
for(let ch in actorData.data.characteristics)
{
// Determine if the formula includes the characteristic's abbreviation + B (SB, WPB, etc.)
if (formula.includes(ch.concat('b')))
{
// Replace that abbreviation with the Bonus value
formula = formula.replace(ch.concat('b'), actorData.data.characteristics[ch].bonus.toString());
}
}
if (formula.includes("yard") )
formula = formula.replace('yard', "mètre" );
if (formula.includes("yds") )
formula = formula.replace('yds', "m." );
// To evaluate multiplication, replace x with *
formula = formula.replace('x', '*');
2020-12-12 10:07:24 +01:00
//console.log("FOEM", formula);
2020-11-07 13:46:15 +01:00
return eval(formula);
}
catch
{
2020-12-12 10:07:24 +01:00
//console.log("FOEM2", formula);
2020-12-02 22:15:26 +01:00
return formula;
2020-11-07 13:46:15 +01:00
}
}
2020-11-13 14:52:23 +01:00
/*---------------------------------------------------------------------*/
2020-11-07 13:46:15 +01:00
game.wfrp4e.entities.ActorWfrp4e.prototype.calculateSpellDamage = function(formula, isMagicMissile) {
//console.log("Compute FR")
let actorData = this.data
formula = formula.toLowerCase();
if (isMagicMissile) // If it's a magic missile, damage includes willpower bonus
{
formula += "+ " + actorData.data.characteristics["wp"].bonus
}
2020-06-29 07:44:16 +02:00
2021-02-06 21:50:08 +01:00
// Specific case, to avoid wrong matching with "Force"
if (formula.includes("toughness bonus")) {
formula = formula.replace( "toughness bonus", actorData.data.characteristics["t"].bonus);
}
2020-11-07 13:46:15 +01:00
// Specific case, to avoid wrong matching with "Force"
if (formula.includes("force mentale"))
{
// Determine if it's looking for the bonus or the value
if (formula.includes('bonus')) {
formula = formula.replace( "bonus de force mentale", actorData.data.characteristics["wp"].bonus);
formula = formula.replace( "force mentale bonus", actorData.data.characteristics["wp"].bonus);
} else
formula = formula.replace("force mentale", actorData.data.characteristics["wp"].value);
}
// Iterate through characteristics
for(let ch in actorData.data.characteristics)
{
// If formula includes characteristic name
while (formula.includes(actorData.data.characteristics[ch].label.toLowerCase()))
{
// Determine if it's looking for the bonus or the value
if (formula.includes('bonus')) {
formula = formula.replace("bonus de " + game.wfrp4e.config.characteristics[ch].toLowerCase(), actorData.data.characteristics[ch].bonus);
formula = formula.replace(game.wfrp4e.config.characteristics[ch].toLowerCase() + " bonus", actorData.data.characteristics[ch].bonus);
}
else
formula = formula.replace(game.wfrp4e.config.characteristics[ch].toLowerCase(), actorData.data.characteristics[ch].value);
}
}
2021-02-06 21:50:08 +01:00
//console.log("calculateSpellDamage -> " + formula );
2020-11-07 13:46:15 +01:00
return eval(formula);
}
2020-11-13 14:52:23 +01:00
/*---------------------------------------------------------------------*/
2020-11-07 13:46:15 +01:00
game.wfrp4e.entities.ActorWfrp4e.prototype.calculateSpellAttributes = function(formula, aoe=false) {
//console.log("Compute FR")
let actorData = this.data
formula = formula.toLowerCase();
// Do not process these special values
if (formula != game.i18n.localize("You").toLowerCase() && formula != game.i18n.localize("Special").toLowerCase() && formula != game.i18n.localize("Instant").toLowerCase())
{
// Specific case, to avoid wrong matching with "Force"
if (formula.includes("force mentale"))
{
// Determine if it's looking for the bonus or the value
if (formula.includes('bonus')) {
formula = formula.replace( "bonus de force mentale", actorData.data.characteristics["wp"].bonus);
formula = formula.replace( "force mentale bonus", actorData.data.characteristics["wp"].bonus);
}
else
formula = formula.replace("force mentale", actorData.data.characteristics["wp"].value);
}
if (formula.includes("yard") )
formula = formula.replace('yard', "mètre" );
if (formula.includes("yds") )
formula = formula.replace('yds', "m." );
// Iterate through remaining characteristics
for(let ch in actorData.data.characteristics)
{
// If formula includes characteristic name
//console.log("Testing :", ch, WFRP4E.characteristics[ch].toLowerCase());
if (formula.includes(game.wfrp4e.config.characteristics[ch].toLowerCase()))
{
// Determine if it's looking for the bonus or the value
if (formula.includes('bonus')) {
formula = formula.replace("bonus de " + game.wfrp4e.config.characteristics[ch].toLowerCase(), actorData.data.characteristics[ch].bonus);
formula = formula.replace(game.wfrp4e.config.characteristics[ch].toLowerCase() + " bonus", actorData.data.characteristics[ch].bonus);
}
else
formula = formula.replace(game.wfrp4e.config.characteristics[ch].toLowerCase(), actorData.data.characteristics[ch].value);
}
}
}
// If AoE - wrap with AoE ( )
if (aoe)
formula = "AoE (" + formula.capitalize() + ")";
2021-02-06 21:50:08 +01:00
//console.log("calculateSpellAttributes -> " + formula );
2020-11-07 13:46:15 +01:00
return formula.capitalize();
}
2020-11-13 14:52:23 +01:00
/*---------------------------------------------------------------------*/
// Converters area
2020-03-25 20:37:09 +01:00
if(typeof Babele !== 'undefined') {
Babele.get().register({
module: 'WH4-fr-translation',
lang: 'fr',
dir: 'compendium'
});
2020-07-04 21:48:40 +02:00
Babele.get().registerConverters({
2020-03-31 09:03:19 +02:00
"career_skills": (skills_list) => {
2020-06-29 07:44:16 +02:00
var compendium = game.packs.find(p => p.collection === compmod+'.skills');
2020-11-10 15:01:06 +01:00
//console.log( "Thru here ...", compendium, skills_list);
2020-05-05 09:21:03 +02:00
if ( skills_list ) {
var i;
var len = skills_list.length;
var re = /(.*)\((.*)\)/i;
for (i = 0; i < len; i++) {
2021-04-29 09:01:22 +02:00
skills_list[i] = skills_list[i].trim();
2021-05-02 14:05:39 +02:00
var transl = compendium.translate( { name: skills_list[i] } ).name;
2020-05-05 09:21:03 +02:00
//console.log("List ...", skills_list[i]);
if ( transl == skills_list[i] ) {
2021-04-29 09:01:22 +02:00
var res = re.exec( skills_list[i] );
2020-05-05 09:21:03 +02:00
if (res) {
//console.log("Matched/split:", res[1], res[2]);
var subword = game.i18n.localize(res[2].trim() );
var s1 = res[1].trim() + " ()";
2021-05-02 14:05:39 +02:00
var translw = compendium.translate( { name: s1} ).name;
2020-05-05 09:21:03 +02:00
if (translw != s1) {
var res2 = re.exec(translw);
transl = res2[1] + "(" + subword + ")";
} else {
s1 = res[1].trim() + " ( )";
2021-05-02 14:05:39 +02:00
translw = compendium.translate( { name: s1} ).name;
2020-05-05 09:21:03 +02:00
var res2 = re.exec(translw);
transl = res2[1] + "(" + subword + ")";
}
}
}
2020-05-05 09:21:03 +02:00
skills_list[i] = transl;
}
}
return skills_list;
},
2020-11-10 15:01:06 +01:00
"npc_details": (details) => {
//console.log("DETAILS: ", details);
let newDetails = duplicate(details);
2020-11-12 16:35:30 +01:00
if (details.species && details.species.value )
2020-11-11 19:08:20 +01:00
newDetails.species.value = game.i18n.localize(details.species.value);
2020-11-12 16:35:30 +01:00
if (details.gender && details.gender.value )
2020-11-11 19:08:20 +01:00
newDetails.gender.value = game.i18n.localize(details.gender.value);
if (details.class && details.class.value )
newDetails.class.value = game.i18n.localize(details.class.value);
2020-11-10 15:01:06 +01:00
return newDetails;
},
"career_talents": (talents_list) => {
2020-06-30 18:37:02 +02:00
var compendium = game.packs.find(p => p.collection === compmod+'.talents');
var i;
2020-05-05 09:21:03 +02:00
if ( talents_list ) {
var len = talents_list.length;
var re = /(.*)\((.*)\)/i;
for (i = 0; i < len; i++) {
2021-05-02 14:05:39 +02:00
var transl = compendium.translate( { name: talents_list[i]} ).name;
2020-05-05 09:21:03 +02:00
if ( transl == talents_list[i] ) {
var res = re.exec( talents_list[i]);
if (res) {
//console.log("Matched/split:", res[1], res[2]);
var subword = game.i18n.localize(res[2].trim() );
var s1 = res[1].trim(); // No () in talents table
2021-05-02 14:05:39 +02:00
var translw = compendium.translate( { name: s1 } ).name;
2020-05-05 09:21:03 +02:00
if (translw != s1) {
transl = translw + "(" + subword + ")";
} else {
s1 = res[1].trim() + " ( )";
2021-05-02 14:05:39 +02:00
translw = compendium.translate( { name: s1 } ).name;
2020-05-05 09:21:03 +02:00
var res2 = re.exec(translw);
transl = res2[1] + "(" + subword + ")";
}
}
}
2020-05-05 09:21:03 +02:00
talents_list[i] = transl;
}
}
return talents_list;
2020-03-31 09:27:04 +02:00
},
"npc_characteristics": (chars) => { // Auto-convert char names in the sheet
for (var key in chars) {
var char = chars[key];
//console.log("Was here !", key, char );
var abrev = char["abrev"];
2020-06-06 13:27:59 +02:00
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;
},
2020-11-08 23:12:52 +01:00
"bestiary_traits": (beast_traits, translations) => {
var fulltraits = game.packs.get(compmod+'.traits');
var fullskills = game.packs.get(compmod+'.skills');
var fulltalents = game.packs.get(compmod+'.talents');
var fullcareers = game.packs.get(compmod+'.careers');
var fulltrappings = game.packs.get(compmod+'.trappings');
var fullspells = game.packs.get(compmod+'.spells');
var fullprayers = game.packs.get(compmod+'.prayers');
var eisitems = game.packs.get('eis.eisitems');
var eisspells = game.packs.get('eis.eisspells');
var ugtalents = game.packs.get('wfrp4e-unofficial-grimoire.ug-careerstalentstraits');
var ugspells = game.packs.get('wfrp4e-unofficial-grimoire.ug-spells');
//console.log("Comp :", compmod, fulltraits);
for (let trait_en of beast_traits)
{
var special = "";
var nbt = "";
var name_en = trait_en.name.trim(); // strip \r in some traits name
if ( trait_en.type == "trait") {
if ( name_en.includes("Tentacles") ) { // Process specific Tentacles case
var re = /(.d*)x Tentacles/i;
var res = re.exec( name_en );
if ( res && 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
var re = /(.*) \((.*)\)/i;
var res = re.exec( name_en );
name_en = res[1]; // Get the root traits name
special = " (" + game.i18n.localize( res[2].trim() ) + ")"; // And the special keyword
}
var trait_fr = fulltraits.translate( { name: name_en } );
//console.log(">>>>> Trait ?", name_en, nbt, trait_fr.name, special);
trait_en.name = nbt + trait_fr.name + special;
if ( trait_fr.data && trait_fr.data.description && trait_fr.data.description.value ) {
trait_en.data.description.value = trait_fr.data.description.value;
} else if ( eisitems ) { // No description in the FR compendium -> test other compendium if presenr
2020-12-02 22:15:26 +01:00
trait_fr = eisitems.translate( { name: name_en } );
trait_en.name = nbt + trait_fr.name + special;
if ( trait_fr.data && trait_fr.data.description && trait_fr.data.description.value )
trait_en.data.description.value = trait_fr.data.description.value;
2020-11-08 23:12:52 +01:00
}
if ( trait_en.data && trait_en.data.specification && isNaN(trait_en.data.specification.value) ) { // This is a string, so translate it
//console.log("Translating : ", trait_en.data.specification.value);
trait_en.data.specification.value = game.i18n.localize( trait_en.data.specification.value.trim() );
}
} else if ( trait_en.type == "skill") {
if ( name_en.includes("(") && name_en.includes(")") ) { // Then process specific skills name with (xxxx) inside
var re = /(.*) +\((.*)\)/i;
var res = re.exec( name_en );
name_en = res[1].trim(); // Get the root skill name
special = " (" + game.i18n.localize( res[2].trim() ) + ")"; // And the special keyword
}
var trait_fr = fullskills.translate( { name: name_en } );
//console.log(">>>>> Skill ?", name_en, special, trait_fr.name, trait_fr);
if (trait_fr.translated) {
trait_en.name = trait_fr.name + special;
if ( trait_fr.data ) {
trait_en.data.description.value = trait_fr.data.description.value;
}
}
} else if ( trait_en.type == "prayer") {
var trait_fr = fullprayers.translate( { name: name_en } );
//console.log(">>>>> Prayer ?", name_en, special, trait_fr.name );
trait_en.name = trait_fr.name + special;
if ( trait_fr.data && trait_fr.data.description && trait_fr.data.description.value )
trait_en.data.description.value = trait_fr.data.description.value;
} else if ( trait_en.type == "spell") {
var trait_fr = fullspells.translate( { name: name_en } );
if ( (!trait_fr.data || !trait_fr.data.description || !trait_fr.data.description.value) && eisspells) { // If no translation, test eisspells
trait_fr = eisspells.translate( { name: name_en } );
}
if ( (!trait_fr.data || !trait_fr.data.description || !trait_fr.data.description.value) && ugspells) { // If no translation, test eisspells
trait_fr = ugspells.translate( { name: name_en } );
}
//console.log(">>>>> Spell ?", name_en, special, trait_fr.name );
trait_en.name = trait_fr.name + special;
if ( trait_fr.data && trait_fr.data.description && trait_fr.data.description.value )
trait_en.data.description.value = trait_fr.data.description.value;
} else if ( trait_en.type == "talent") {
if ( name_en.includes("(") && name_en.includes(")") ) { // Then process specific skills name with (xxxx) inside
var re = /(.*) +\((.*)\)/i;
var res = re.exec( name_en );
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
}
var trait_fr = fulltalents.translate( { name: name_en } );
//console.log(">>>>> Talent ?", name_en, special, trait_fr.name);
if ( (!trait_fr.data || !trait_fr.data.description || !trait_fr.data.description.value) && ugtalents) { // If no translation, test ugtalents
trait_fr = ugtalents.translate( { name: name_en } );
}
if ( trait_fr.translated) {
trait_en.name = trait_fr.name + special;
if ( trait_fr.data ) { // Why ???
trait_en.data.description.value = trait_fr.data.description.value;
}
}
} else if ( trait_en.type == "career") {
var career_fr = fullcareers.translate( trait_en );
2020-11-10 15:01:06 +01:00
console.log(">>>>> Career ?", name_en, career_fr.name );
trait_en.name = career_fr.name;
trait_en.data = duplicate(career_fr.data);
2020-11-08 23:12:52 +01:00
} else if ( trait_en.type == "trapping" || trait_en.type == "weapon" || trait_en.type == "armour" || trait_en.type == "container" || trait_en.type == "money") {
var trapping_fr = fulltrappings.translate( trait_en );
//console.log(">>>>> Trapping ?", name_en, trapping_fr.name);
trait_en.name = trapping_fr.name;
if ( trapping_fr.data) {
trait_en.data.description = trapping_fr.data.description;
}
}
}
return beast_traits;
},
2020-03-31 09:27:04 +02:00
// To avoid duplicateing class for all careers
2020-03-31 17:44:46 +02:00
"generic_localization": (value) => {
2020-04-01 00:41:20 +02:00
if ( value )
return game.i18n.localize( value.trim() );
2020-04-10 15:11:26 +02:00
},
2020-04-01 00:41:20 +02:00
"trapping_qualities_flaws": (value) => {
if ( value ) {
2020-06-22 09:10:40 +02:00
//console.log("ATOUTS", value);
2020-04-01 00:41:20 +02:00
var list = value.split( "," );
var i=0;
var re = /(.*) (\d+)/i;
for (i=0; i<list.length; i++) {
2020-06-19 00:26:15 +02:00
let trim = list[i].trim();
if ( trim == "Trap Blade") {
trim = "TrapBlade"; // Auto-patch, without space!
//console.log("PATCHED", trim);
}
var splitted = re.exec( trim );
2020-06-22 09:10:40 +02:00
//console.log("Current quality", splitted, trim );
2020-04-01 00:41:20 +02:00
if ( splitted ) {
//console.log("FOund:", splitted[0], splitted[1], splitted[2] );
list[i] = game.i18n.localize( splitted[1] ) + " " + splitted[2];
} else {
2020-06-19 00:26:15 +02:00
list[i] = game.i18n.localize( trim ) ;
2020-04-01 00:41:20 +02:00
}
2020-03-31 17:44:46 +02:00
}
2020-04-01 00:41:20 +02:00
return list.toString();
2020-03-31 17:44:46 +02:00
}
},
2020-03-31 09:27:04 +02:00
// Search back in careers the translated name of the groupe (as it is the name of the level career itself)
"career_careergroup": (value) => {
2020-10-06 08:25:51 +02:00
// Manage exception - Dirty hack
2020-07-03 11:38:38 +02:00
if ( value == 'Slayer' ) {
return "Tueur Nains";
2020-07-03 11:38:38 +02:00
}
2020-10-06 08:25:51 +02:00
if ( value == 'Druidic Priest' ) {
return "Druide";
}
2020-07-03 11:38:38 +02:00
// Per default
2020-06-29 07:44:16 +02:00
var compendium = game.packs.find(p => p.collection === compmod+'.careers');
2020-11-08 23:12:52 +01:00
if ( compendium )
2021-05-02 14:05:39 +02:00
return compendium.translate( { name: value } ).name;
2020-11-08 23:12:52 +01:00
else
ui.notifications.error("Impossible de trouver la carrière " + value + ". Elle n'est probablement pas traduite.", { permanent: true })
2020-04-10 15:11:26 +02:00
},
2020-06-21 22:28:51 +02:00
"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 :)
2020-06-14 21:22:07 +02:00
//console.log("Parsing mutation :", value);
value = value.toLowerCase();
2020-06-21 22:28:51 +02:00
value = value.replace("gain a broken condition if you fail a test derived from ", "Gagnez un état Brisé si vous échouez à un test dérivé de ");
value = value.replace("weapon skill" ,"Capacité de Combat");
value = value.replace("ballistic skill", "Capacité de Tir");
value = value.replace("strength", "Force");
value = value.replace("toughness", "Endurance");
value = value.replace("agility", "Agilité");
value = value.replace("dexterity", "Dextérité");
value = value.replace("willpower", "Force Mentale");
value = value.replace("fellowship", "Sociabilité");
value = value.replace("initiative", "Initiative");
value = value.replace("intelligence", "Intelligence");
2020-06-21 22:28:51 +02:00
value = value.replace("armor points to the head", "PA à la Tête");
value = value.replace("subject to frenzy", "Sujet à la Frénésie");
value = value.replace("you do not scar", "Aucune cicatrice");
value = value.replace("movement", "Mouvement");
value = value.replace("armor points to all locations", "PA sur tout le corps");
value = value.replace("to any test when alone", "à tout les tests lorsque seul");
value = value.replace("track", "Pistage");
value = value.replace("to any test not hurting another", "à tout les Tests n'aggressant pas autrui");
value = value.replace("on tests to hurt", "pour les tests impliquant une agression")
value = value.replace("to all language tests when speaking", "à tout les Tests de Langue lorsque vous parlez");
value = value.replace("on perception tests involving sight", "aux Tests de Perception impliquant la Vue");
value = value.replace("to all Sociabilité tests", "à tout les Tests de Sociabilité");
return value;
},
2021-02-06 21:50:08 +01:00
"talent_name": (name, translation) => {
console.log("NAME !!!", name, translation);
},
"effects": (effects, translations) => {
2021-02-08 22:03:29 +01:00
if ( !effects) return;
2021-05-06 21:51:06 +02:00
if ( !translations) return;
2021-02-06 21:50:08 +01:00
for (let i=0; i<effects.length; i++) {
let effect = effects[i];
2021-05-06 21:51:06 +02:00
//console.log("EFFECT LABEL1:", effect );
2021-02-06 21:50:08 +01:00
effect.label = translations['label'+i];
}
return effects
},
"diseases_effects": (effects, translations) => {
2021-02-08 22:03:29 +01:00
if ( !effects) return;
2021-02-06 21:50:08 +01:00
for (let i=0; i<effects.length; i++) {
let effect = effects[i];
let label = effect.label;
let gravity = "";
if ( label.includes("(") && label.includes(")") ) { // Then process specific skills name with (xxxx) inside
var re = /(.*) +\((.*)\)/i;
var res = re.exec( label );
label = res[1].trim(); // Get the gravity
gravity = " (" + game.i18n.localize( res[2].trim() ) + ")"; // And the special keyword
}
effect.label = game.i18n.localize( label ) + gravity;
}
},
2020-04-10 15:11:26 +02:00
// Auto-translate duration
"spells_duration_range_target_damage": (value) => {
2020-04-10 17:36:32 +02:00
//console.log("Spell duration/range/damage/target :", value);
2020-04-10 15:11:26 +02:00
if ( value == "" ) return ""; // Hop !
if ( value == "Touch" ) return "Contact"; // Hop !
if ( value == "You" ) return "Vous"; // Hop !
if ( value == "Instant" ) return "Instantané"; // Hop !
var translw = value;
var re = /(.*) Bonus (\w*)/i;
var res = re.exec( value );
var unit = "";
if ( res ) { // Test "<charac> Bonus <unit>" pattern
if ( res[1] ) { // We have char name, then convert it
translw = "Bonus de " + game.i18n.localize( res[1].trim() );
}
unit = res[2];
} 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 = "heure";
if ( unit == "hours") unit = "heures";
if ( unit == "days") unit = "jours";
if ( unit == "yard") unit = "mètre";
if ( unit == "yards") unit = "mètres";
translw += " " + unit;
return translw;
2020-03-31 17:44:46 +02:00
}
});
2020-03-27 23:12:43 +01:00
}
2020-03-25 21:03:36 +01:00
} );
2020-04-12 08:59:47 +02:00