Possessions des classes

Reviewed-on: #91

babele-register.js

@@ -289,6 +289,7 @@ Hooks.once('init', () => {
           console.log("No beast traits found here ...")
           return beast_traits
         }
+        //console.log("TRANS:", beast_traits)
         for (let trait_en of beast_traits) {
           let special = "";
           let nbt = "";
@@ -403,7 +404,7 @@ Hooks.once('init', () => {
             }
             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) { // Why ???
+              if (trait_fr.system?.description?.value) { // Why ???
                 trait_en.system.description.value = trait_fr.system.description.value;
               }
             }
@@ -412,21 +413,23 @@ Hooks.once('init', () => {
             if (game.system.version.match("7.")) {
               compendiumCareers = 'wfrp4e-core.items'
             }     
-            let career_fr = game.babele.translate(compendiumCareers, trait_en, true);
-            career_fr.name = career_fr.name || trait_en.name
+            let career_fr = game.babele.translate(compendiumCareers, { name: name_en }, true);
+            trait_en.name = career_fr.name || trait_en.name
             //console.log(">>>>> Career ?", career_fr.name );
-            trait_en.system = duplicate(career_fr.system);
+            if ( career_fr?.system) {
+              trait_en.system = duplicate(career_fr.system);
+            }
 
           } else if (trait_en.type == "trapping" || trait_en.type == "weapon" || trait_en.type == "armour" || trait_en.type == "container" || trait_en.type == "money") {
             let compendiumTrappings = 'wfrp4e-core.trappings' // Per default
             if (game.system.version.match("7.")) {
               compendiumTrappings = 'wfrp4e-core.items'
             }     
-            let trapping_fr = game.babele.translate(compendiumTrappings, trait_en, true);
+            let trapping_fr = game.babele.translate(compendiumTrappings,  { name: name_en }, true);
             //console.log(">>>>> Trapping ?", name_en, trapping_fr.name);
-            trapping_fr.name = trapping_fr.name || trait_en.name
-            if (trapping_fr.system) {
-              trait_en.system.description = trapping_fr.system.description;
+            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
             }
           }
         }

fr.json

@@ -1523,14 +1523,19 @@
     
     "Academics": "Lettrés",
     "Academic": "Lettré",
-    "Burgher": "Citadins",
-    "Rogues": "Roublards", 
+    "Burghers": "Citadins",
+    "Burgher": "Citadin",
+    "Rogues": "Roublards",
+    "Rogue": "Roublard",
     "Riverfolk": "Riverains",
     "Peasants": "Ruraux",
-    "Peasant": "Ruraux",
-    "Warrior": "Guerriers",
-    "Ranger": "Itinérants",
-    "Courtier": "Courtisans",
+    "Peasant": "Rural",
+    "Warriors": "Guerriers",
+    "Warrior": "Guerrier",
+    "Rangers": "Itinérants",
+    "Ranger": "Itinérant",
+    "Courtiers": "Courtisans",
+    "Courtier": "Courtisan",
 
     "Calvalry": "Cavalerie",
     "Flail": "Fléau",

module.json

@@ -8,7 +8,7 @@
     }
   ],
   "url": "https://www.uberwald.me/gitea/public/foundryvtt-wh4-lang-fr-fr",
-  "version": "7.0.2",
+  "version": "7.0.5",
   "esmodules": [
     "babele-register.js",
     "addon-register.js",
@@ -127,7 +127,7 @@
     }
   ],
   "manifest": "https://www.uberwald.me/gitea/public/foundryvtt-wh4-lang-fr-fr/raw/v10/module.json",
-  "download": "https://www.uberwald.me/gitea/public/foundryvtt-wh4-lang-fr-fr/archive/foundryvtt-wh4-lang-fr-7.0.2.zip",
+  "download": "https://www.uberwald.me/gitea/public/foundryvtt-wh4-lang-fr-fr/archive/foundryvtt-wh4-lang-fr-7.0.5.zip",
   "id": "wh4-fr-translation",
   "compatibility": {
     "minimum": "10",

modules/config-patch.js

@@ -176,6 +176,12 @@ export class WH4FRPatchConfig {
         game.wfrp4e.config.species["welf"] = "Elfe Sylvain";
       }
 
+      if (game.wfrp4e.config.classTrappings) {
+        for(const c of Object.keys(game.wfrp4e.config.classTrappings)) {
+          game.wfrp4e.config.classTrappings[game.i18n.localize(c)] = game.wfrp4e.config.classTrappings[c];
+        }
+      }
+
       this.patch_species_skills();
       this.patch_species_talents();
       this.patch_subspecies();
@@ -262,7 +268,7 @@ export class WH4FRPatchConfig {
         }
       }*/
 
-      game.wfrp4e.config.statusEffects = [
+      /*game.wfrp4e.config.statusEffects = [
         {
           icon: "systems/wfrp4e/icons/conditions/bleeding.png",
           id: "bleeding",
@@ -474,7 +480,7 @@ export class WH4FRPatchConfig {
           }
 
         }
-      ]
+      ]*/
 
       /*game.wfrp4e.config.systemEffects = {
         "enc1": {

modules/import-stat-2.js

@@ -54,33 +54,53 @@ const fr_carac = 'm\\s+cc\\s+ct\\s+f\\s+e\\s+i\\s+agi?\\s+dex\\s+int\\s+fm\\s+so
 const carac_val = '(?<m>[0-9\\-]+)\\s+(?<ws>[0-9\\-]+)\\s+(?<bs>[0-9\\-]+)\\s+(?<s>[0-9\\-]+)\\s+(?<t>[0-9\\-]+)\\s+(?<i>[0-9\\-]+)\\s+(?<ag>[0-9\\-]+)\\s+(?<dex>[0-9\\-]+)\\s+(?<int>[0-9\\-]+)\\s+(?<wp>[0-9\\-]+)\\s+(?<fel>[0-9\\-]+)\\s+(?<w>[0-9\\-\*]+)';
 const name_val = '(?<name>[a-zA-Z\\s\\-,]*)[\\s\\r\\na-zA-Z]*(?<tiers>.*|[\\(\\)a-z0-9]+)';
 let sectionDataFR = [
-  { name: "trait", toFind: "Traits\\s*:", secondParse: '(?<name>[a-zàéè\\s]*)[\\s\\+]*(?<value>.*|[\\+0-9]+)', index: -1 },
+  { name: "trait", toFind: "Traits\\s*:", secondParse: '(?<name>[a-zöàéè\\s]*)[\\s\\+]*(?<value>.*|[\\+0-9]+)', index: -1 },
   { name: "skill", toFind: "Compétences\\s*:", secondParse: '(?<name>[a-zàéè\\s\\(\\)]*)[\\s\\+]*(?<value>.*|[0-9]+)', index: -1 },
-  { name: "talent", toFind: "Talents\\s*:", secondParse: '(?<name>[a-zàéè\\-\\(\\)\\s\\/]*)[\\s\\+]*(?<value>.*|[0-9]+)', index: -1 },
-  { name: "mutation", toFind: "Mutations\\s*:", secondParse: '(?<name>[a-zàéè\\s]*)[\\s\\+]*(?<value>.*|[0-9]+)', index: -1 },
-  { name: "trapping", toFind: "Equipement\\s*:", secondParse: '(?<name>[a-zàéè\\s]*)[\\s\\+]*(?<value>.*|[0-9]+)', index: -1 },
-  { name: "spell", toFind: "Sorts\\s*\\([a-z\\s]*\\)*:", secondParse: '(?<name>[a-zàéè\\s]*)', index: -1 }
+  { name: "talent", toFind: "Talents\\s*:", secondParse: '(?<name>[a-zöàéè\\-\\(\\)\\s\\/\'’]*)[\\s\\+]*(?<value>.*|[0-9]+)', index: -1 },
+  { name: "mutation", toFind: "Mutations\\s*:", secondParse: '(?<name>[a-zöàéè\\s]*)[\\s\\+]*(?<value>.*|[0-9]+)', index: -1 },
+  { name: "trapping", toFind: "Equipement\\s*:", secondParse: '(?<name>[a-zöàéè0-9\\s]*)[\\s\\+]*(?<value>.*|[0-9]+)', index: -1 },
+  { name: "spell", toFind: "Sorts\\s*\\([a-z\\s]*\\)*:", secondParse: '(?<name>[a-zöàéè\\s]*)', index: -1 },
+  { name: "spellpetty", toFind: "Spells\\s*\\(Magie Mineure\\)*:", secondParse: '(?<name>[a-zö\\-\\s]*)', index: -1 },
+  { name: "spellarcane", toFind: "Spells\\s*\\(Arcane[a-z\\s]*\\)*:", secondParse: '(?<name>[a-zö\\-\\s]*)', index: -1 },
+  { name: "spellarcane", toFind: "Spells\\s*\\(Domaine\\s*(?<lore>[a-z\\s]*)\\)*:", secondParse: '(?<name>[a-zö\\-\\s]*)', index: -1 }
 ];
 let sectionDataUS = [
   { name: "trait", toFind: "Traits\\s*:", secondParse: '(?<name>[a-z\\s]*)[\\s\\+]*(?<value>.*|[\\+0-9]+)', index: -1 },
   { name: "skill", toFind: "Skills\\s*:", secondParse: '(?<name>[a-z\\s\\(\\)]*)[\\s\\+]*(?<value>.*|[0-9]+)', index: -1 },
-  { name: "talent", toFind: "Talents\\s*:", secondParse: '(?<name>[a-z\\-\\s\\(\\)\\/]*)[\\s\\+]*(?<value>.*|[0-9]+)', index: -1 },
-  { name: "mutation", toFind: "Mutations\\s*:", secondParse: '(?<name>[a-z\\s]*)[\\s\\+]*(?<value>.*|[0-9]+)', index: -1 },
-  { name: "trapping", toFind: "Trappings\\s*:", secondParse: '(?<name>[a-z\\s]*)[\\s\\+]*(?<value>.*|[0-9]+)', index: -1 },
-  { name: "spell", toFind: "Spells\\s*\\([a-z\\s]*\\)*:", secondParse: '(?<name>[a-z\\s]*)', index: -1 } 
+  { name: "talent", toFind: "Talents\\s*:", secondParse: '(?<name>[a-z\\-\\s\\(\\)\\/\'’]*)[\\s\\+]*(?<value>.*|[0-9]+)', index: -1 },
+  { name: "mutation", toFind: "Mutations\\s*:", secondParse: '(?<name>[a-zö\\s]*)[\\s\\+]*(?<value>.*|[0-9]+)', index: -1 },
+  { name: "trapping", toFind: "Trappings\\s*:", secondParse: '(?<name>[a-zö0-9\\s]*)[\\s\\+]*(?<value>.*|[0-9]+)', index: -1 },
+  { name: "spellpetty", toFind: "Spells\\s*\\(Petty\\s*[a-z\\s]*\\)*:", secondParse: '(?<name>[a-zö\\-\\s]*)', index: -1 },
+  { name: "spellarcane", toFind: "Spells\\s*\\(Arcane\\s*[a-z\\s]*\\)*:", secondParse: '(?<name>[a-zö\\-\\s]*)', index: -1 },
+  { name: "spelllore", toFind: "Spells\\s*\\(Lore\\s*of\\s*(?<lore>[a-z\\s]*)\\)*:", secondParse: '(?<name>[a-zö\\-\\s]*)', index: -1 }
 ]
 let regSep = XRegExp('\\s*,\\s*', 'gi'); // Term separator, with auto trim
 let regLine1 = XRegExp('[\\r\\n\\.]', 'gi'); // Term separator, with auto trim
 let regName = XRegExp(name_val, 'gi');
 
+// Used to detect/manage the skill groupings in the statblock
+const __SkillGroupsUS = ["Melee", "Lore", "Trade"]
+const __SkillGroupsFR = ["Corps à corps", "Domaine", "Métier"]
+// Used to auto update the system.tests.value field
+const __hasTestValue = {
+  "etiquette": true,
+  "resistance": true,
+  "acute sense": true,
+  "strider": true,
+  "savant": true,
+  "craftsman": true
+}
+
 /************************************************************************************/
 async function __findItem(itemName, itemType, location = null) {
   let toSearch = itemName.toLowerCase().trim();
   let items = game.items.contents.filter(i => i.type == itemType)
 
+  console.log("Searching for", toSearch, itemType)
+
   // Search imported items first
   for (let i of items) {
-    if (i.name.toLowerCase() == itemName.toLowerCase() && i.type == itemType) 
+    if (i.name.toLowerCase() == toSearch.toLowerCase() && i.type == itemType)
       return i.toObject();
   }
   let itemList
@@ -88,12 +108,11 @@ async function __findItem(itemName, itemType, location = null) {
   // find pack -> search pack -> return entity
   if (location) {
     let pack = game.packs.find(p => {
-      location.split(".")[0] == p.metadata.package &&
-        location.split(".")[1] == p.metadata.name
+      location.split(".")[0] == p.metadata.package && location.split(".")[1] == p.metadata.name
     })
     if (pack) {
       await pack.getIndex().then(index => itemList = index);
-      let searchResult = itemList.find(t => (t.translated && t.type == itemType && t.originalName.toLowerCase() == toSearch) || (t.type == itemType && t.name.toLowerCase() == toSearch) );
+      let searchResult = itemList.find(t => (t.translated && t.type == itemType && (t.originalName.toLowerCase() == toSearch || s.originalName.toLowerCase().split("(")[0].trim() == toSearch)) || (t.type == itemType && (t.name.toLowerCase() == toSearch || t.name.toLowerCase().split("(")[0].trim() == toSearch)));
       if (searchResult) {
         let item = await pack.getDocument(searchResult._id)
         return item.toObject()
@@ -104,7 +123,8 @@ async function __findItem(itemName, itemType, location = null) {
   // If all else fails, search each pack
   for (let p of game.wfrp4e.tags.getPacksWithTag(itemType)) {
     await p.getIndex().then(index => itemList = index);
-    let searchResult = itemList.find(t => (t.translated && t.type == itemType && t.originalName.toLowerCase() == toSearch) || (t.type == itemType && t.name.toLowerCase() == toSearch) );
+    console.log("Seatch", itemType, toSearch);
+    let searchResult = itemList.find(t => (t.translated && t.type == itemType && (t.originalName.toLowerCase() == toSearch || s.originalName.toLowerCase().split("(")[0].trim() == toSearch)) || (t.type == itemType && (t.name.toLowerCase() == toSearch || t.name.toLowerCase().split("(")[0].trim() == toSearch)));
     if (searchResult) {
       let item = await p.getDocument(searchResult._id)
       return item.toObject()
@@ -120,80 +140,102 @@ async function __findSkill(skillName, value = undefined) {
   let skillSplit = XRegExp.exec(skillName, XRegExp(parseStr, 'gi'));
 
   // First try world items
+  let item
   let worldItem = game.items.contents.filter(i => i.type == "skill" && i.name.toLowerCase() == toSearch)[0];
-  if (worldItem) return worldItem;
-
-  let packs = game.wfrp4e.tags.getPacksWithTag("skill");
-  for (let pack of packs) {
-    let skillList = await pack.getIndex();
-    // Search for specific skill (won't find unlisted specializations)
-    let searchResult = skillList.find(s => (s.type == "skill" && s.translated && s.originalName.toLowerCase() == toSearch) || (s.type == "skill" && s.name.toLowerCase() == toSearch ) );
-    if (!searchResult) {
-      let toSearchClean = toSearch.split("(")[0].trim();
-      searchResult = skillList.find(s => (s.type == "skill" && s.translated && s.originalName.toLowerCase().split("(")[0].trim() == toSearchClean) || 
-                (s.type == "skill" && s.name.toLowerCase().split("(")[0].trim() == toSearchClean)   );
-    }
-    if (searchResult) {
-      let dbSkill;
-      await pack.getDocument(searchResult._id).then(packSkill => dbSkill = packSkill);
-      let item = dbSkill.toObject();
-      //console.log("Skill name1", skillSplit)
-      if (skillSplit.specialized && ( item.name.includes('()') || item.name.includes('( )' ) ) ) {
-        let spec = XRegExp.replace(skillSplit.specialized, "(", "");
-        spec = XRegExp.replace(spec, ")", "");
-        let skillSplit2 = XRegExp.exec(item.name, XRegExp(parseStr, 'gi'));
-        item.name = skillSplit2.name + '(' + game.i18n.localize( spec.trim() ) + ')' 
-        //dbSkill.update( { name: } );
+  if (worldItem) {
+    item = worldItem.toObject()
+  } else {
+    let packs = game.wfrp4e.tags.getPacksWithTag("skill");
+    for (let pack of packs) {
+      let skillList = await pack.getIndex();
+      // Search for specific skill (won't find unlisted specializations)
+      let searchResult = skillList.find(s => (s.type == "skill" && s.translated && s.originalName.toLowerCase() == toSearch) || (s.type == "skill" && s.name.toLowerCase() == toSearch));
+      if (!searchResult) {
+        let toSearchClean = toSearch.split("(")[0].trim();
+        searchResult = skillList.find(s => (s.type == "skill" && s.translated && s.originalName.toLowerCase().split("(")[0].trim() == toSearchClean) ||
+          (s.type == "skill" && s.name.toLowerCase().split("(")[0].trim() == toSearchClean));
+      }
+      if (searchResult) {
+        let dbSkill;
+        await pack.getDocument(searchResult._id).then(packSkill => dbSkill = packSkill);
+        item = dbSkill.toObject();
       }
-      //game.babele.translate('wfrp4e-core.skills', dbSkill);
-      return item
     }
   }
-  throw "Could not find skill (or specialization of) " + skillName + " in compendum or world"
+  if (item) {
+    //console.log("Skill name1", skillSplit)
+    if (skillSplit.specialized && (item.name.includes('()') || item.name.includes('( )'))) {
+      let spec = XRegExp.replace(skillSplit.specialized, "(", "");
+      spec = XRegExp.replace(spec, ")", "");
+      let skillSplit2 = XRegExp.exec(item.name, XRegExp(parseStr, 'gi'));
+      item.name = skillSplit2.name + '(' + game.i18n.localize(spec.trim()) + ')'
+      //dbSkill.update( { name: } );
+    }
+    //game.babele.translate('wfrp4e-core.skills', dbSkill);
+    return item
+  }
 }
 
 /************************************************************************************/
 async function __findTalent(talentName) {
-  let parseStr = '(?<name>[a-z\\s\\/]*)[\\s\\+]*(?<specialized>[a-z\\s\\(\\)]*)';
+  let parseStr = '(?<name>[a-z\\s\\/\']*)[\\s\\+]*(?<specialized>[a-z\\s\\(\\)\'’]*)';
   let talentSplit = XRegExp.exec(talentName, XRegExp(parseStr, 'gi'));
   let toSearch = talentSplit.name.toLowerCase().trim();
-  
-  //console.log("Talent name", talentName, talentSplit)
+
+  //console.log("Talent name", toSearch, talentName, talentSplit)
 
   // First try world items
+  let item
   let worldItem = game.items.contents.filter(i => i.type == "talent" && i.name.toLowerCase() == toSearch)[0];
-  if (worldItem) return worldItem;
-
-  let packs = game.wfrp4e.tags.getPacksWithTag("talent");
-  for (let pack of packs) {
-    let talentList = await pack.getIndex();
-    // Search for specific skill (won't find unlisted specializations)
-    let searchResult = talentList.find(s => (s.translated && s.originalName.toLowerCase() == toSearch) || (s.name.toLowerCase() == toSearch ) );
-    if (!searchResult) {
-      let toSearchClean = toSearch.split("(")[0].trim();
-      searchResult = talentList.find(s => (s.translated && s.originalName.toLowerCase().split("(")[0].trim() == toSearchClean) || 
-                (s.name.toLowerCase().split("(")[0].trim() == toSearchClean)   );
-    }
-    if (searchResult) {
-      let dbTalent;
-      //console.log("Talent name1", talentSplit)
-      await pack.getDocument(searchResult._id).then(packTalent => dbTalent = packTalent);
-      let item = dbTalent.toObject();
-      if ( talentSplit.specialized  ) {
-        let spec = XRegExp.replace(talentSplit.specialized, "(", "");
-        spec = XRegExp.replace(spec, ")", "");
-        item.name = talentSplit.name + '(' + game.i18n.localize( spec.trim() ) + ')'
-        //console.log("Talent name2", dbTalent.name, spec, game.i18n.localize( spec.trim()) )
+  if (worldItem) {
+    item = worldItem.toObject()
+  } else {
+    let packs = game.wfrp4e.tags.getPacksWithTag("talent");
+    for (let pack of packs) {
+      let talentList = await pack.getIndex();
+      // Search for specific talent (won't find unlisted specializations)
+      let searchResult = talentList.find(s => (s.type == "talent" && s.translated && s.originalName.toLowerCase() == toSearch) || (s.type == "talent" && s.name.toLowerCase() == toSearch));
+      if (!searchResult) {
+        let toSearchClean = toSearch.split("(")[0].trim();
+        searchResult = talentList.find(s => (s.type == "talent" && s.translated && s.originalName.toLowerCase().split("(")[0].trim() == toSearchClean) ||
+          (s.type == "talent" && s.name.toLowerCase().split("(")[0].trim() == toSearchClean));
+      }
+      if (searchResult) {
+        let dbTalent;
+        //console.log("Talent name1", talentSplit)
+        await pack.getDocument(searchResult._id).then(packTalent => dbTalent = packTalent);
+        item = dbTalent.toObject();
       }
-      return item;
     }
   }
-  throw "Could not find talent (or specialization of) " + talentName + " in compendium or world"
+  if (item) {
+    if (talentSplit.specialized) {
+      let spec = XRegExp.replace(talentSplit.specialized, "(", "");
+      spec = XRegExp.replace(spec, ")", "");
+      spec = spec.trim()
+      let addToName = true
+      //console.log("Talent name2", dbTalent.name, spec, game.i18n.localize( spec.trim()) )
+      if (toSearch == 'doomed') {
+        item.system.description.value += `<br><br><em>${spec}</em>`;
+        addToName = false // Very specific case
+      }
+      if (__hasTestValue[toSearch]) {
+        item.system.tests.value = game.i18n.localize(spec);
+      }
+      item.name = talentSplit.name
+      if (addToName) {
+        item.name += '(' + game.i18n.localize(spec) + ')'
+      }
+      item.system.advances.value = 1 // Set 1 advance
+    }
+    // Specific Talent post-processing
+    return item;
+  }
 }
 
 /************************************************************************************/
-function __patchName ( name) {
-  if (name.toLowerCase == 'magic sense') 
+function __patchName(name) {
+  if (name.toLowerCase == 'magic sense')
     name = 'Magical Sense'
   return name
 }
@@ -207,30 +249,35 @@ export default async function statParserFR(statString, type = "npc") {
 
   let statNameReg = us_carac
   let sectionData = sectionDataUS
+  let skillGrouping = __SkillGroupsUS
   // Detect French stat block 
   if (statString.includes('CC') && statString.includes('CT') && statString.includes('FM')) {
     //ui.notifications.warn("Le parsing de stablock en Français n'est pas encore prêt")
     statNameReg = fr_carac
     sectionData = sectionDataFR
+    skillGrouping = __SkillGroupsFR
   }
 
   let reg1 = XRegExp(statNameReg, 'gi')
   let res = reg1.test(statString)
   if (res) { //stat block identified go on
+    let globalItemList = []
+
     // Extract the name
     let res1 = XRegExp.exec(statString, reg1)
     console.log("REG", res1)
     let pnjStr = statString.substring(0, res1.index)
     let nameRes = XRegExp.exec(pnjStr, regName)
-    console.log(nameRes)
+    //console.log(nameRes)
     if (nameRes.tiers && nameRes.tiers.length > 0 && hasProperty(model, "details.status.value")) {
       let regTiers = XRegExp("(?<name>[A-Za-z]*)\\s+(?<level>[0-9]*)");
       let resTiers = XRegExp.exec(nameRes.tiers, regTiers);
       console.log(resTiers);
       model.details.status.value = game.i18n.localize(resTiers.name.trim()) + " " + resTiers.level;
     }
+    let baseName = nameRes.name.split("\n")
     // Compute the PNJ name
-    let pnjName = nameRes.name.split("—")[0].split(" ").filter(f => !!f);
+    let pnjName = baseName[0].split("—")[0].split(" ").filter(f => !!f)
     pnjName = pnjName.map(word => {
       if (word == "VON")
         return word.toLowerCase();
@@ -240,7 +287,14 @@ export default async function statParserFR(statString, type = "npc") {
       return word;
     })
     pnjName = pnjName.join(" ")
-
+    if (baseName[1]) {
+      let careerName = baseName[1].split(",")[0]
+      //console.log("CAREER", careerName)
+      let career = await __findItem(careerName, "career")
+      if (career) {
+        globalItemList.push(career)
+      }
+    }
     // Get the carac values
     let reg2 = XRegExp(carac_val, 'gi')
     let resCarac = XRegExp.exec(statString, reg2) // resr contains all carac found
@@ -259,20 +313,23 @@ export default async function statParserFR(statString, type = "npc") {
     for (let def of sectionData) {
       def.regDef = XRegExp(def.toFind, 'gi');
       let res = XRegExp.exec(statString, def.regDef);
-      if (res) def.index = res.index; // Get the index in the string
+      if (res) {
+        def.index = res.index // Position of the string in the whole statblock
+        def.lore = res.lore // Extraction of the lore, when present
+      } // Get the index in the string
       //console.log("   Parsing", def.name, res);
     }
     // Sort to split position of various substring
     sectionData.sort(function (a, b) { return a.index - b.index; });
 
-    let globalItemList = [];
     // Then loop again and process each item type
     for (let i = 0; i < sectionData.length; i++) {
       let def = sectionData[i];
       if (def.index > -1) {
         let maxIndex = statString.length
-        if (sectionData[i + 1] && sectionData[i + 1].index > -1)
+        if (sectionData[i + 1] && sectionData[i + 1].index > -1) {
           maxIndex = sectionData[i + 1].index
+        }
         def.substring = statString.substring(def.index, maxIndex)
         def.substring = XRegExp.replace(def.substring, def.regDef, "")
         def.substring = XRegExp.replace(def.substring, regLine1, " ")
@@ -280,16 +337,17 @@ export default async function statParserFR(statString, type = "npc") {
 
         // Then create a table of it in termList, with specific sub-parsing rules
         let termList = XRegExp.split(def.substring, regSep);
+        //console.log("Term list identified", termList)
         let lastSkillName
         for (let name of termList) {
           let itemFound, subres, value;
           if (def.secondParse) {
             subres = XRegExp.exec(name, XRegExp(def.secondParse, 'gi'))
             //console.log("Second pars", def, name, subres)
-            name  = subres.name.trim().replace("\n", "").replace("\r", "")
+            name = subres.name.trim().replace("\n", "").replace("\r", "")
             if (subres.value) {
               value = XRegExp.replace(subres.value, "(", "")
-              value = XRegExp.replace(value, ")", "")  
+              value = XRegExp.replace(value, ")", "")
             } else {
               value = 0
             }
@@ -301,38 +359,42 @@ export default async function statParserFR(statString, type = "npc") {
             }
             catch { }
             if (itemFound && value && value.length > 0) {
-              if (name.toLowerCase() == 'weapon' || name.toLowerCase() == "bite" || name.toLowerCase() == "tail" ||
-                  name.toLowerCase() == 'arme' || name.toLowerCase() == "morsure" || name.toLowerCase() == "queue") {
+              let number = value.match(/\d+/g);
+              if (number && (name.toLowerCase() == 'ranged' || name.toLowerCase() == 'weapon' || name.toLowerCase() == "bite" || name.toLowerCase() == "tail" ||
+                name.toLowerCase() == 'arme' || name.toLowerCase() == "morsure" || name.toLowerCase() == "queue")) {
                 //console.log(itemFound)
-                itemFound.system.specification.value = Number(value) - Math.floor( Number(model.characteristics.s.initial) / 10)
+                number = number[0] // Take first number ....
+                itemFound.system.specification.value = Number(number) - ((name.toLowerCase() == 'ranged') ? 0 : Math.floor(Number(model.characteristics.s.initial) / 10))
               } else {
                 itemFound.system.specification.value = game.i18n.localize(value)
               }
+              itemFound.name += "(" + value + ")"
             }
             if (!itemFound)
               ui.notifications.error("Trait non trouvé, à ajouter manuellement : " + name, { permanent: true })
-          
+
           } else if (def.name == 'skill') {
             try {
               itemFound = await __findSkill(name, value);
             }
             catch { }
+            let newName = name
             if (!itemFound && lastSkillName) {
-              name = lastSkillName + " (" + name + ")"
-              itemFound = await __findSkill(name, value);
+              newName = lastSkillName + " (" + name + ")"
+              itemFound = await __findSkill(newName, value)
             }
             if (itemFound && subres && value) {
               itemFound.system.advances.value = Number(value) - Number(model.characteristics[itemFound.system.characteristic.value].initial);
             }
             lastSkillName = undefined
-            if ( itemFound?.name?.includes('Trade')) { // useful to handle skills grouping
-              lastSkillName = "Trade"
-            } 
-            if ( itemFound?.name?.includes('Lore')) {
-              lastSkillName = "Lore"
-            } 
-            if (!itemFound)
+            for (let keySkillGroup of skillGrouping) {
+              if (newName.includes(keySkillGroup)) { // useful to handle skills grouping
+                lastSkillName = keySkillGroup
+              }
+            }
+            if (!itemFound) {
               ui.notifications.error("Compétence non trouvée, à ajouter manuellement : " + name, { permanent: true })
+            }
           } else if (def.name == 'talent') {
             try {
               itemFound = await __findTalent(name);
@@ -340,35 +402,52 @@ export default async function statParserFR(statString, type = "npc") {
             catch { }
             if (itemFound && subres && value)
               itemFound.system.advances.value = Number(value);
-            if (!itemFound)
+            if (!itemFound) {
               ui.notifications.error("Talent non trouvé, à ajouter manuellement : " + name, { permanent: true })
-          } else if (def.name == 'trapping') {
-            try {
-              itemFound = await __findItem(name, "trapping");
             }
-            catch { }
+          } else if (def.name == 'trapping') {
+            itemFound = await __findItem(name, "trapping");
+            if (!itemFound) {
+              itemFound = await __findItem(name, "weapon");
+            }
+            if (!itemFound) {
+              itemFound = await __findItem(name, "armor");
+            }
             if (!itemFound && name) {
-              itemFound = new ItemWfrp4e({ img: "systems/wfrp4e/icons/blank.png", name: name, type: "trapping", system: game.system.model.Item.trapping })
-              itemFound.system.trappingType.value = "misc"
-              itemFound = itemFound.toObject()
-            } 
-          } else if (def.name == 'spell') {
-            console.log("Found spells section!!!!")
-              try {
-                itemFound = await __findItem(name, "spell");
+              if (name.toLowerCase().includes("armor") || name.toLowerCase().includes("armure") || name.toLowerCase().includes("armour")) {
+                itemFound = new ItemWfrp4e({ img: "systems/wfrp4e/icons/blank.png", name: name, type: "armor", system: game.system.model.Item.armor })
+              } else if (name.toLowerCase().includes("weapon") || name.toLowerCase().includes("arme")) {
+                itemFound = new ItemWfrp4e({ img: "systems/wfrp4e/icons/blank.png", name: name, type: "weapon", system: game.system.model.Item.weapon })
+              } else {
+                itemFound = new ItemWfrp4e({ img: "systems/wfrp4e/icons/blank.png", name: name, type: "trapping", system: game.system.model.Item.trapping })
+                itemFound.system.trappingType.value = "misc"
+                if (name.toLowerCase().includes("cloth")) {
+                  itemFound.system.trappingType.value = "clothingAccessories"
+                }
               }
-              catch { }
-              if (!itemFound && name) {
-                itemFound = new ItemWfrp4e({ img: "systems/wfrp4e/icons/blank.png", name: name, type: "spell", system: game.system.model.Item.spell })
-                itemFound = itemFound.toObject();  
-              } 
+              itemFound = itemFound.toObject()
+            }
+          } else if (def.name.includes('spell')) {
+            console.log("Found spells section!!!!", name, def, def.lore || "NO LORE")
+            // Lore management, firs pass
+            if ( def.lore ) {
+              let newName = name + " (" + def.lore + ")"
+              itemFound = await __findItem(newName, "spell");
+              console.log("Trying to find ", newName, itemFound)
+            }
+            if (!itemFound) { // If not found with Lore, try without the lore
+              itemFound = await __findItem(name, "spell");
+            }
+            if (!itemFound && name) { // Auto-create the spell name
+              itemFound = new ItemWfrp4e({ img: "systems/wfrp4e/icons/blank.png", name: name + "(To be checked/completed)", type: "spell", system: game.system.model.Item.spell })
+              itemFound = itemFound.toObject();
+            }
           } else if (def.name == 'mutation') {
             try {
               itemFound = await __findItem(name, "mutation");
             }
             catch { }
           }
-
           if (itemFound)
             globalItemList.push(itemFound);
         }