Setup auto-publish action

2024-12-03 14:30:18 +01:00 · 2024-12-03 14:15:43 +01:00 · 2024-12-03 14:12:19 +01:00 · 2024-12-03 14:09:32 +01:00 · 2024-12-03 07:31:22 +01:00 · 2024-12-03 00:50:39 +01:00
44 changed files with 1016 additions and 926 deletions
--- a/.gitea/workflows/release.yaml
+++ b/.gitea/workflows/release.yaml
@ -27,7 +27,7 @@ jobs:
      env:
        version: ${{steps.get_version.outputs.version-without-v}}
        url: https://www.uberwald.me/gitea/${{gitea.repository}}
-        manifest: https://www.uberwald.me/gitea/${{gitea.repository}}/releases/download//${{github.event.release.tag_name}}/system.json
+        manifest: https://www.uberwald.me/gitea/${{gitea.repository}}/releases/download/${{github.event.release.tag_name}}/system.json
        download: https://www.uberwald.me/gitea/${{gitea.repository}}/releases/download/${{github.event.release.tag_name}}/rddsystem.zip
    
    - name: Set up Node.js
@ -61,3 +61,14 @@ jobs:
          ./rddsystem.zip  
          system.json
        api_key: '${{secrets.ALLOW_PUSH_RELEASE}}'
+
+    - name: Publish to Foundry server  
+      uses: djlechuck/foundryvtt-publish-package-action@v1
+      with:
+        token: ${{ secrets.FOUNDRYVTT_RELEASE_TOKEN }}
+        id: 'foundryvtt-reve-de-dragon'
+        version: ${{github.event.release.tag_name}}
+        manifest: 'https://www.uberwald.me/gitea/${{gitea.repository}}/releases/download/${{github.event.release.tag_name}}/system.json'
+        notes: 'https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/raw/branch/v11/changelog.md'
+        compatibility-minimum: '12'
+        compatibility-verified: '12'
--- a/changelog.md
+++ b/changelog.md
@ -1,4 +1,13 @@
 # 12.0
+## 12.0.24 - Les ajustements d'Astrobazzarh
+- amélioration
+  - meilleure gestion des noms des voies de draconic
+  - affichage du détail des sorts avec le nom de voie, 'court', la difficulté, le coût
+- corrections
+  - les tas dans les conteneurs peuvent être désempilés sans rendre le conteneur inutilisable
+  - les conteneurs ne peuvent plus être empilés (pour éviter que le contenu de Schroedinger quand on les sépare)
+  - on peut maintenant saisir et supprimer les bonus de cases de manière intuitive
+  
 ## 12.0.23 - La bibliothèque d'Astrobazzarh
 - corrections mineures
  - meilleure gestion de la parade des armes naturelles
--- a/module/actor.js
+++ b/module/actor.js
@ -3017,15 +3017,16 @@ export class RdDActor extends RdDBaseActorSang {
      case 'queue':
      case 'ombre':
      case 'souffle':
-        await this.onDeleteOwnedDraconique(item, options, id);
-        break;
+        await this.onDeleteOwnedDraconique(item, options, id)
+        break
      case 'casetmr':
-        await this.onDeleteOwnedCaseTmr(item, options, id);
-        break;
+        await this.onDeleteOwnedCaseTmr(item, options, id)
+        break
      case 'empoignade':
        await RdDEmpoignade.deleteLinkedEmpoignade(this.id, item)
-        break;
+        break
    }
+    super.onDeleteItem(item, options, id)
  }

  /* -------------------------------------------- */
--- a/module/actor/base-actor.js
+++ b/module/actor/base-actor.js
@ -213,8 +213,20 @@ export class RdDBaseActor extends Actor {
  /* -------------------------------------------- */
  async onPreUpdateItem(item, change, options, id) { }
  async onCreateItem(item, options, id) { }
-  async onDeleteItem(item, options, id) { }
  async onUpdateActor(update, options, actorId) { }
+  async onDeleteItem(item, options, id) {
+    if (item.isInventaire()) {
+      this._removeItemFromConteneur(item)
+    }
+  }
+
+  _removeItemFromConteneur(item) {
+    this.items.filter(it => it.isConteneur() && it.system.contenu.includes(item.id))
+      .forEach(conteneur => {
+        const nouveauContenu = conteneur.system.contenu.filter(id => id != item.id);
+        conteneur.update({ 'system.contenu': nouveauContenu });
+      });
+  }

  async onTimeChanging(oldTimestamp, newTimestamp) {
    this.items.filter(it => it.isFinPeriode(oldTimestamp, newTimestamp))
--- a/module/actor/export-scriptarium/mapping.js
+++ b/module/actor/export-scriptarium/mapping.js
@ -238,7 +238,7 @@ export class Mapping {

  static prepareSorts(actor) {
    const codeVoies = Mapping.getCompetencesCategorie(actor, CATEGORIES_DRACONIC)
-      .map(it => RdDItemSort.getVoieCode(it))
+      .map(it => RdDItemSort.getCodeVoie(it.name))

    return actor.itemTypes[ITEM_TYPES.sort].map(it => Mapping.prepareSort(it, codeVoies))
      .sort(Misc.ascending(it => `${it.voie} : ${it.description}`))
@ -246,7 +246,7 @@ export class Mapping {

  static prepareSort(sort, voies) {
    return {
-      voie: RdDItemSort.getCodeDraconic(sort, voies),
+      voie: RdDItemSort.getCode(sort, voies),
      description: Mapping.descriptionSort(sort),
      bonus: Mapping.bonusCase(sort)
    }
@ -255,21 +255,13 @@ export class Mapping {
  static descriptionSort(sort) {
    const ptSeuil = Array(sort.system.coutseuil).map(it => '*')
    const caseTMR = sort.system.caseTMRspeciale.length > 0 ? Mapping.toVar(sort.system.caseTMRspeciale) : Misc.upperFirst(TMRType[sort.system.caseTMR].name)
-    const ptreve = Mapping.addSpaceToNonNumeric(sort.system.ptreve)
-    const diff = Mapping.addSpaceToNonNumeric(sort.system.difficulte)
-    return `${sort.name}${ptSeuil} (${caseTMR}) R${diff} r${ptreve}`
-  }
-
-  static addSpaceToNonNumeric(value) {
-    return Number.isNumeric(value) || /[-\d].*/.match(String(value)) ? value : ' ' + Mapping.toVar(value)
-  }
-
-  static toVar(value) {
-    return value.replace('variable', 'var')
+    const coutReve = 'r' + RdDItemSort.addSpaceToNonNumeric(sort.system.ptreve)
+    const diff = 'R' + RdDItemSort.addSpaceToNonNumeric(sort.system.difficulte)
+    return `${sort.name}${ptSeuil} (${caseTMR}) ${diff} ${coutReve}`
  }

  static bonusCase(sort) {
-    const list = RdDItemSort.bonuscaseStringToList(sort.system.bonuscase).sort(Misc.descending(it => it.bonus))
+    const list = RdDItemSort.stringToBonuscases(sort.system.bonuscase).sort(Misc.descending(it => it.bonus))
    if (list.length > 0) {
      const bonus = list[0]
      return `+${bonus.bonus}% en ${bonus.case}`
--- a/module/apps/rdd-import-stats.js
+++ b/module/apps/rdd-import-stats.js
@ -2,6 +2,373 @@
 import "./xregexp-all.js";
 import { SystemCompendiums } from "../settings/system-compendiums.js";
 import { RdDBaseActorReve } from "../actor/base-actor-reve.js";
+import { Grammar } from "../grammar.js";
+import { Misc } from "../misc.js";
+import { ENTITE_INCARNE, ENTITE_NONINCARNE } from "../constants.js";
+
+const WHITESPACES = "\\s+"
+const NUMERIC = "[\\+\\-]?\\d+"
+const NUMERIC_VALUE = "(?<value>" + NUMERIC + ")"
+
+const XREGEXP_NAME = "(?<name>[A-Za-zÀ-ÖØ-öø-ÿ\\s\\-]+)"
+const XREGEXP_COMP_CREATURE = WHITESPACES + "(?<carac>\\d+)"
+  + WHITESPACES + NUMERIC_VALUE
+  + "(" + WHITESPACES + "(?<init>\\d+)?\\s+?(?<dommages>[\\+\\-]?\\d+)?" + ")?"
+
+// Skill parser depending on the type of actor
+const compParser = {
+  personnage: "(\\D+)*" + WHITESPACES + NUMERIC_VALUE,
+  creature: XREGEXP_COMP_CREATURE,
+  entite: XREGEXP_COMP_CREATURE
+}
+
+const XREGEXP_SORT_VOIE = "[OHNT\\/]+"
+const XREGEXP_SORT_CASE = "\\((?<case>[A-Za-zÀ-ÖØ-öø-ÿ\\s\\-]+)\\)";
+
+const XREGEXP_SORT = "(" + XREGEXP_SORT_VOIE
+  + WHITESPACES + XREGEXP_NAME
+  + WHITESPACES + XREGEXP_SORT_CASE
+  + WHITESPACES + "R(?<diff>([\\-\\d]+|(\\w|\\s)+))"
+  + WHITESPACES + "r(?<reve>(\\d+(\\+)?|\\s\\w+))"
+  + "(" + WHITESPACES + "\\+(?<bonus>\\d+)\\s?%" + WHITESPACES + "en" + WHITESPACES + "(?<bonuscase>[A-M]\\d{1,2})" + ")?"
+  + ")"
+
+
+// Main class for parsing a stat block
+export class RdDStatBlockParser {
+
+  static openInputDialog() {
+    let dialog = new Dialog({
+      title: "Import de stats de PNJ/Créatures",
+      content: `
+        <div>
+          <p>Coller le texte de la stat ici</p>
+          <textarea id="statBlock" style="width: 100%; height: 200px;"></textarea>
+        </div>
+      `,
+      buttons: {
+        ok: {
+          label: "OK",
+          callback: async (html) => {
+            let statBlock = html.find("#statBlock")[0].value;
+            await RdDStatBlockParser.parseStatBlock(statBlock);
+            dialog.close();
+          }
+        },
+        cancel: {
+          label: "Cancel"
+        }
+      }
+    });
+    dialog.render(true);
+  }
+
+  static fixWeirdPDF(statString) {
+    // Split the statString into lines
+    let lines = statString.split("\n");
+    let newLines = [];
+    let index = 0;
+    let nextType = "string";
+    // Loop through each line
+    for (let i = 0; i < lines.length; i++) {
+      // remove trailing spaces
+      lines[i] = lines[i].trim();
+      // Is it text ?      
+      if (lines[i].match(/^[a-zA-Zéêè\s]+/)) {
+        if (nextType == "string") {
+          newLines[index] = lines[i];
+          nextType = "number";
+        } else {
+          console.log("Wrong sequence string detected...", lines[i], nextType);
+        }
+      }
+      // Is it a number ?
+      if (lines[i].match(/^[\d\s]+/)) {
+        if (nextType == "number") {
+          newLines[index] = newLines[index] + lines[i];
+          nextType = "string";
+          index++;
+        } else {
+          console.log("Wrong sequence number detected...", lines[i], nextType);
+        }
+      }
+    }
+  }
+
+  static getHeureKey(heure) {
+    for (let h of game.system.rdd.config.heuresRdD) {
+      if (h.label.toLowerCase() == heure.toLowerCase()) {
+        return h.value;
+      }
+    }
+    return "vaisseau";
+  }
+
+  static async parseStatBlock(statString, type = "npc") {
+
+    //statString = statBlock03;
+    if (!statString) {
+      return;
+    }
+
+    // Special function to fix strange/weird copy/paste from PDF readers
+    // Unused up to now : this.fixWeirdPDF(statString);
+
+    // Replace all endline by space in the statString
+    statString = statString.replace(/\n/g, " ");
+    // Remove all multiple spaces
+    statString = statString.replace(/\s{2,}/g, " ");
+    // Remove all leading and trailing spaces
+    statString = statString.trim();
+
+    // TODO: check for entite
+    let actorType = RdDStatBlockParser.parseActorType(statString);
+
+    // Now start carac 
+    let actorData = foundry.utils.deepClone(game.model.Actor[actorType]);
+    for (let key in actorData.carac) {
+      let caracDef = actorData.carac[key];
+      // Parse the stat string for each caracteristic
+      let carac = XRegExp.exec(statString, XRegExp(caracDef.label + "\\s+(?<value>\\d+)", 'giu'));
+      if (carac?.value) {
+        actorData.carac[key].value = Number(carac.value);
+      }
+    }
+
+    // If creature we need to setup additionnal fields 
+    switch (actorType) {
+      case "creature":
+        RdDStatBlockParser.parseCreature(statString, actorData)
+        break
+      case "entite":
+        RdDStatBlockParser.parseEntite(statString, actorData)
+        break
+    }
+
+    let items = [];
+    // Get skills from compendium 
+    const competences = await SystemCompendiums.getCompetences(actorType);
+    //console.log("Competences : ", competences);
+    for (let comp of competences) {
+      let compMatch = XRegExp.exec(statString, XRegExp(comp.name + compParser[actorType], 'giu'));
+      if (compMatch) {
+        comp = comp.toObject()
+        comp.system.niveau = Number(compMatch.value);
+        if (actorType == "creature" || actorType == "entite") {
+          comp.system.carac_value = Number(compMatch.carac);
+          if (compMatch.dommages != undefined) {
+            comp.system.dommages = Number(compMatch.dommages);
+            comp.system.iscombat = true;
+          }
+        }
+        items.push(comp)
+      }
+      else if (actorType == "personnage") {
+        comp = comp.toObject()
+        items.push(comp)
+      }
+    }
+
+    // Now process weapons
+    const weapons = await SystemCompendiums.getWorldOrCompendiumItems("arme", "equipement")
+    //console.log("Equipement : ", equipment);
+    // TODO: les noms d'armes peuvent avoir un suffixe (à une main, lancée) qui détermine la compétence correspondante
+    // TODO: une arme peut être spécifique ("fourche"), ajouter une compétence dans ces cas là?
+    for (let weapon of weapons) {
+      let weapMatch = XRegExp.exec(statString, XRegExp(weapon.name + "\\s+(?<value>\\+\\d+)", 'giu'));
+      if (weapMatch) {
+        weapon = weapon.toObject()
+        weapon.system.equipe = 'true'
+        items.push(weapon)
+        // now process the skill
+        if (weapon.system?.competence != "") {
+          let wComp = items.find(i => Grammar.equalsInsensitive(i.name, weapon.system.competence))
+          if (wComp) {
+            wComp.system.niveau = Number(weapMatch.value);
+          }
+        }
+        if (weapon.system?.tir != "") {
+          let wComp = items.find(i => Grammar.equalsInsensitive(i.name, weapon.system.tir))
+          if (wComp) {
+            wComp.system.niveau = Number(weapMatch.value);
+          }
+        }
+        if (weapon.system?.lancer != "") {
+          let wComp = items.find(i => Grammar.equalsInsensitive(i.name, weapon.system.lancer))
+          if (wComp) {
+            wComp.system.niveau = Number(weapMatch.value);
+          }
+        }
+      }
+    }
+
+    // Now process armors
+    const armors = await SystemCompendiums.getWorldOrCompendiumItems("armure", "equipement")
+    for (let armor of armors) {
+      let matchArmor = XRegExp.exec(statString, XRegExp(armor.name, 'giu'));
+      if (matchArmor) {
+        armor = armor.toObject()
+        armor.system.equipe = true
+        items.push(armor);
+      }
+    }
+
+    // Attemp to detect spell
+    let hautRevant = false
+    let sorts = await SystemCompendiums.getWorldOrCompendiumItems("sort", "sorts-oniros")
+    sorts = sorts.concat(await SystemCompendiums.getWorldOrCompendiumItems("sort", "sorts-hypnos"))
+    sorts = sorts.concat(await SystemCompendiums.getWorldOrCompendiumItems("sort", "sorts-narcos"))
+    sorts = sorts.concat(await SystemCompendiums.getWorldOrCompendiumItems("sort", "sorts-thanatos"))
+
+    XRegExp.forEach(statString, XRegExp(XREGEXP_SORT, 'giu'),
+      function (matchSort, i) {
+        let sort = sorts.find(s => Grammar.equalsInsensitive(s.name, matchSort.name))
+        if (sort) {
+          hautRevant = true
+          sort = sort.toObject();
+          if (matchSort.bonus && matchSort.bonuscase) {
+            sort.system.bonuscase = `${matchSort.bonuscase}:${matchSort.bonus}`
+          }
+          items.push(sort);
+        }
+      });
+
+    if (hautRevant) {
+      let tetes = await SystemCompendiums.getWorldOrCompendiumItems("tete", "tetes-de-dragon-pour-tous-personnages")
+      let donHR = tetes.find(t => Grammar.equalsInsensitive(t.name, "Don de Haut-Rêve"))
+      if (donHR) {
+        items.push(donHR.toObject());
+      }
+    }
+    if (actorType == "personnage") {
+
+      let feminin = XRegExp.exec(statString, XRegExp("né(?<value>e?) à", 'giu'));
+      actorData.sexe = (feminin?.value == 'e') ? 'féminin' : 'masculin'
+
+      // Get hour name : heure du XXXXX
+      let heure = XRegExp.exec(statString, XRegExp("heure (du|de la|des|de l\')\\s*(?<value>[A-Za-zÀ-ÖØ-öø-ÿ\\s]+),", 'giu'));
+      actorData.heure = this.getHeureKey(heure?.value || "Vaisseau");
+
+      // Get age
+      let age = XRegExp.exec(statString, XRegExp("(?<value>\\d+) ans", 'giu'));
+      if (age?.value) {
+        actorData.age = Number(age.value);
+      }
+      // Get height
+      let taille = XRegExp.exec(statString, XRegExp("(?<value>\\d+m\\d+)", 'giu'));
+      if (taille?.value) {
+        actorData.taille = taille.value;
+      }
+      // Get weight
+      let poids = XRegExp.exec(statString, XRegExp("(?<value>\\d+) kg", 'giu'));
+      if (poids?.value) {
+        actorData.poids = poids.value;
+      }
+      // Get cheveux
+      let cheveux = XRegExp.exec(statString, XRegExp("kg,\\s+(?<value>[A-Za-zÀ-ÖØ-öø-ÿ\\s\\-]+),\\s+yeux", 'giu'));
+      if (cheveux?.value) {
+        actorData.cheveux = cheveux.value;
+      }
+      // Get yeux
+      let yeux = XRegExp.exec(statString, XRegExp("yeux\\s+(?<value>[A-Za-zÀ-ÖØ-öø-ÿ\\s\\-]+), Beau", 'giu'));
+      if (yeux?.value) {
+        actorData.yeux = yeux.value;
+      }
+
+      // Get beauty
+      let beaute = XRegExp.exec(statString, XRegExp("beauté\\s+(?<value>\\d+)", 'giu'));
+      if (beaute?.value) {
+        actorData.beaute = Number(beaute.value);
+      }
+    }
+
+    // Name is all string before ', né'
+    let name = RdDStatBlockParser.extractName(actorType, statString);
+
+    let newActor = RdDBaseActorReve.create({ name: name || "Importé", type: actorType, system: actorData, items: items });
+
+    // DUmp....
+    console.log(actorData);
+  }
+
+  static parseCreature(statString, actorData) {
+    let plusDom = XRegExp.exec(statString, XRegExp("\\+dom\\s+(?<value>[\\+\\-]?\\d+)", 'giu'));
+    if (plusDom?.values) {
+      actorData.attributs.plusdom.value = Number(plusDom.value);
+    }
+    let protection = XRegExp.exec(statString, XRegExp("protection\\s+(?<value>[\\-]?\\d+)", 'giu'));
+    if (protection?.value) {
+      actorData.attributs.protection.value = Number(protection.value);
+    }
+    let endurance = XRegExp.exec(statString, XRegExp("endurance\\s+(?<value>\\d+)", 'giu'));
+    if (endurance?.value) {
+      actorData.sante.endurance.value = Number(endurance.value);
+      actorData.sante.endurance.max = Number(endurance.value);
+    }
+    let vie = XRegExp.exec(statString, XRegExp("vie\\s+(?<value>\\d+)", 'giu'));
+    if (vie.value) {
+      actorData.sante.vie.value = Number(vie.value);
+      actorData.sante.vie.max = Number(vie.value);
+    }
+    let vitesse = XRegExp.exec(statString, XRegExp("vitesse\\s+(?<value>[\\d\\/]+)", 'giu'));
+    if (vitesse?.value) {
+      actorData.attributs.vitesse.value = vitesse.value;
+    }
+  }
+
+  static parseEntite(statString, actorData) {
+    let plusDom = XRegExp.exec(statString, XRegExp("\\+dom\\s+(?<value>[\\+\\-]?\\d+)", 'giu'));
+    if (plusDom?.values) {
+      actorData.attributs.plusdom.value = Number(plusDom.value);
+    }
+
+    actorData.definition.categorieentite = 'cauchemar'
+    actorData.definition.typeentite = ENTITE_NONINCARNE
+    let endurance = XRegExp.exec(statString, XRegExp("endurance\\s+(?<value>\\d+)", 'giu'));
+    if (endurance?.value) {
+      actorData.sante.endurance.value = Number(endurance.value);
+      actorData.sante.endurance.max = Number(endurance.value);
+      actorData.definition.typeentite = ENTITE_INCARNE
+    }
+    let vitesse = XRegExp.exec(statString, XRegExp("vitesse\\s+(?<value>[\\d\\/]+)", 'giu'));
+    if (vitesse?.value) {
+      actorData.attributs.vitesse.value = vitesse.value;
+    }
+  }
+
+  static parseActorType(statString) {
+    let niveau = XRegExp.exec(statString, XRegExp("Niveau\\s+(?<value>[\\+\\-]?\\d+)", 'giu'))
+    let perception = XRegExp.exec(statString, XRegExp("perception\\s+(?<value>\\d+)", 'giu'))
+    if (perception?.value) {
+      return "creature"
+    }
+    if (niveau?.value) {
+      return "entite"
+    }
+    return "personnage"
+  }
+
+  static extractName(actorType, statString) {
+    switch (actorType) {
+      case "personnage": return RdDStatBlockParser.extractNamePersonnage(statString);
+      case "creature": return RdDStatBlockParser.extractNameCreature(statString);
+    }
+    return RdDStatBlockParser.extractNameCreature(statString);
+  }
+
+  static extractNamePersonnage(statString) {
+    let name = XRegExp.exec(statString, XRegExp("(?<value>[\\p{Letter}\\s\\d]+),", 'giu'));
+    if (!name?.value) {
+      name = XRegExp.exec(statString, XRegExp("(?<value>.+)\\s+taille", 'giu'));
+    }
+    return Misc.upperFirst(name?.value || "Importé");
+  }
+
+  static extractNameCreature(statString) {
+    const name = XRegExp.exec(statString, XRegExp("(?<value>.+)\\s+taille", 'giu'));
+    return Misc.upperFirst(name?.value || "Importé");
+  }
+}

 /************************************************************************************/
 // Some internal test strings
@ -76,7 +443,7 @@ Corps à corps
 (0)
 Esquive
 +8
-Escalade +4 / Saut +5 / Commerce +3 / Équitation
+Escalade, Saut +4 / Commerce +3 / Équitation
 +6 / Chirurgie 0 / Survie en extérieur +4 / Survie fo-
 rêt +6 / Acrobatie -2 / Métallurgie +2 / Natation +3 /
 Légendes -1 / Écriture -4 
@ -194,240 +561,4 @@ Discrétion
 Vigilance
 13
 +3
- `
-// Skill parser depending on the type of actor
-const compParser = { personnage: "\\s+(?<value>[\\+\\-]?\\d+)", creature: "\\s+(?<carac>\\d+)\\s+(?<value>[\\+\\-]?\\d+)\\s?(?<init>\\d+)?\\s+?(?<dommages>\\+\\d+)?" };
-
-// Main class for parsing a stat block
-export class RdDStatBlockParser {
-  
-  static openInputDialog() {
-    let dialog = new Dialog({
-      title: "Import de stats de PNJ/Créatures",
-      content: `
-        <div>
-          <p>Coller le texte de la stat ici</p>
-          <textarea id="statBlock" style="width: 100%; height: 200px;"></textarea>
-        </div>
-      `,
-      buttons: {
-        ok: {
-          label: "OK",
-          callback: async (html) => {
-            let statBlock = html.find("#statBlock")[0].value;
-            await RdDStatBlockParser.parseStatBlock(statBlock);
-            dialog.close();
-          }
-        },
-        cancel: {
-          label: "Cancel"
-        }
-      }
-    });
-    dialog.render(true);
-  }
-  
-  static fixWeirdPDF(statString) {
-    // Split the statString into lines
-    let lines = statString.split("\n");
-    let newLines = [];
-    let index = 0;
-    let nextType = "string";
-    // Loop through each line
-    for (let i = 0; i < lines.length; i++) {
-      // remove trailing spaces
-      lines[i] = lines[i].trim();
-      // Is it text ?      
-      if (lines[i].match(/^[a-zA-Zéêè\s]+/)) {
-        if ( nextType == "string" ) { 
-          newLines[index] = lines[i];
-          nextType = "number";  
-        } else {
-          console.log("Wrong sequence string detected...", lines[i], nextType);
-        }
-      }
-      // Is it a number ?
-      if (lines[i].match(/^[\d\s]+/)) {
-        if ( nextType == "number" ) {
-          newLines[index] = newLines[index] + lines[i];
-          nextType = "string";
-          index++;
-        } else {
-          console.log("Wrong sequence number detected...", lines[i], nextType);
-        }
-      }
-    }
-
-  }  
-  
-  static async parseStatBlock(statString, type = "npc") {
-
-    //statString = statBlock03;
-    if (!statString) {
-      return;
-    }
-
-    // Special function to fix strange/weird copy/paste from PDF readers
-    // Unused up to now : this.fixWeirdPDF(statString);
-
-    // Replace all endline by space in the statString
-    statString = statString.replace(/\n/g, " ");
-    // Remove all multiple spaces
-    statString = statString.replace(/\s{2,}/g, " ");
-    // Remove all leading and trailing spaces
-    statString = statString.trim();
-
-    let actorType = "personnage";
-    let perception = XRegExp.exec(statString.toLowerCase(), XRegExp("perception\\s+(?<value>\\d+)", 'gi'));
-    if (perception?.value ) { 
-      actorType = "creature";
-    }
-
-    // Now start carac 
-    let actorData = foundry.utils.deepClone(game.model.Actor[actorType]); 
-    for (let key in game.model.Actor.personnage.carac) {
-      let caracDef = game.model.Actor.personnage.carac[key];
-      // Parse the stat string for each caracteristic
-      let carac = XRegExp.exec(statString.toLowerCase(), XRegExp(caracDef.label.toLowerCase()+"\\s+(?<value>\\d+)", 'gi'));
-      if (carac?.value) {
-        actorData.carac[key].value = Number(carac.value);
-      }
-    }
-
-    // If creature we need to setup additionnal fields 
-    if (actorType == "creature") {
-      let plusDom  = XRegExp.exec(statString.toLowerCase(), XRegExp("\\+dom\\s+(?<value>\\+\\d+)", 'gi'));
-      if (plusDom?.values) {
-        actorData.attributs.plusdom.value = Number(plusDom.value);
-      }
-      let protection  = XRegExp.exec(statString.toLowerCase(), XRegExp("protection\\s+(?<value>\\d+)", 'gi'));
-      if (protection?.value) {
-        actorData.attributs.protection.value = Number(protection.value);
-      }
-      let endurance = XRegExp.exec(statString.toLowerCase(), XRegExp("endurance\\s+(?<value>\\d+)", 'gi'));
-      if (endurance?.value) {
-        actorData.sante.endurance.value = Number(endurance.value);
-        actorData.sante.endurance.max = Number(endurance.value);
-      }
-      let vie = XRegExp.exec(statString.toLowerCase(), XRegExp("vie\\s+(?<value>\\d+)", 'gi'));
-      if (vie.value) {
-        actorData.sante.vie.value = Number(vie.value);
-        actorData.sante.vie.max = Number(vie.value);
-      }
-      let vitesse = XRegExp.exec(statString.toLowerCase(), XRegExp("vitesse\\s+(?<value>[\\d\\/]+)", 'gi'));
-      if (vitesse?.value) {
-        actorData.attributs.vitesse.value = vitesse.value;
-      }
-    }
-
-    let items = [];
-    // Get skills from compendium 
-    const competences = await SystemCompendiums.getCompetences(actorType);
-    //console.log("Competences : ", competences);
-    let allComp = competences.map(i => i.toObject())
-    for (let comp of allComp) {
-      let skill = XRegExp.exec(statString.toLowerCase(), XRegExp(comp.name.toLowerCase()+compParser[actorType], 'gi'));
-      if (skill) {
-        comp.system.niveau = Number(skill.value);
-        if (actorType == "creature") {
-          comp.system.carac_value = Number(skill.carac);
-          if (skill.init) {
-            comp.system.dommages = Number(skill.dommages);
-            comp.system.iscombat = true;
-          }
-          items.push(comp); // Only selective push
-        }
-      }
-      if (actorType == "personnage") {
-        items.push(comp); // Always push
-      }
-    }
-
-    // Now process weapons
-    const weapons = await SystemCompendiums.getWorldOrCompendiumItems("arme", "equipement")
-    //console.log("Equipement : ", equipment);
-    for (let w of weapons) {
-      
-      let weapon = XRegExp.exec(statString.toLowerCase(), XRegExp(w.name.toLowerCase()+"\\s+(?<value>\\+\\d+)", 'gi'));
-      if (weapon) {
-        w.system.equipe = true
-        items.push(w.toObject());
-        // now process the skill
-        if ( w.system?.competence != "") {
-          let wComp = items.find(i => i.name.toLowerCase() == w.system.competence.toLowerCase());  
-          if (wComp) {
-            wComp.system.niveau = Number(weapon.value);
-          }
-        }
-        if ( w.system?.tir != "") {
-          let wComp = items.find(i => i.name.toLowerCase() == w.system.tir.toLowerCase());  
-          if (wComp) {
-            wComp.system.niveau = Number(weapon.value);
-          }
-        }
-        if ( w.system?.lancer != "") {
-          let wComp = items.find(i => i.name.toLowerCase() == w.system.lancer.toLowerCase());  
-          if (wComp) {
-            wComp.system.niveau = Number(weapon.value);
-          }
-        }
-      }
-    }
-
-    // Now process armors
-    const armors = await SystemCompendiums.getWorldOrCompendiumItems("armure", "equipement")
-    for (let a of armors) {    
-      let armor = XRegExp.exec(statString.toLowerCase(), XRegExp(a.name.toLowerCase(), 'gi'));
-      if (armor) {
-        a.system.equipe = true
-        items.push(a.toObject());
-      }
-    }
-
-    // Get hour name : heure du XXXXX
-    let heure = XRegExp.exec(statString.toLowerCase(), XRegExp("heure du\\s+(?<value>\\w+)", 'gi'));
-    if (heure?.value) {
-      actorData.heure = heure.value;  
-    }
-    // Get age
-    let age = XRegExp.exec(statString.toLowerCase(), XRegExp("(?<value>\\d+) ans", 'gi'));
-    if (age?.value) {
-      actorData.age = Number(age.value);  
-    }
-    // Get height
-    let taille = XRegExp.exec(statString.toLowerCase(), XRegExp("(?<value>\\d+)m\\d+", 'gi'));
-    if (taille?.value) {
-      actorData.taille = taille.value;  
-    }
-    // Get weight
-    let poids = XRegExp.exec(statString.toLowerCase(), XRegExp("(?<value>\\d+) kg", 'gi'));
-    if (poids?.value) {
-      actorData.poids = poids.value;  
-    }
-    // Get beauty
-    let beaute = XRegExp.exec(statString.toLowerCase(), XRegExp("beauté\\s+(?<value>\\d+)", 'gi'));
-    if (beaute?.value) {
-      actorData.beaute = Number(beaute.value);  
-    }
-
-    // Name is all string before ', né'
-    let name
-    if (actorType == "personnage") {
-      name = XRegExp.exec(statString.toLowerCase(), XRegExp("(?<value>[\\w\\s\\d]+),", 'gi'));
-      if (!name?.value) {
-        name = XRegExp.exec(statString.toLowerCase(), XRegExp("(?<value>.+)\\s+taille", 'gi'));
-      }
-      name = name?.value || "Importé";
-    }
-    if (actorType == "creature") {
-      name = XRegExp.exec(statString.toLowerCase(), XRegExp("(?<value>.+)\\s+taille", 'gi'));
-      name = name?.value || "Importé";
-    }
-    
-    let newActor = RdDBaseActorReve.create({name: name || "Importé", type:actorType, system: actorData, items: items});
-
-    // DUmp....
-    console.log(actorData);
-  }
-}
-
+`
--- a/module/item-competencecreature.js
+++ b/module/item-competencecreature.js
@ -81,7 +81,7 @@ export class RdDItemCompetenceCreature extends Item {

  static isParade(item) {
    if (item.type == ITEM_TYPES.competencecreature) {
-      return armeData.system.categorie_parade || armeData.system.isparade
+      return item.system.categorie_parade || item.system.isparade
    }
    return false
  }
--- a/module/item-sheet.js
+++ b/module/item-sheet.js
@ -13,6 +13,7 @@ import { Misc } from "./misc.js";
 import { RdDTimestamp } from "./time/rdd-timestamp.js";
 import { RdDItemCompetenceCreature } from "./item-competencecreature.js";
 import { ITEM_TYPES, RdDItem } from "./item.js";
+import { FLEUVE_COORD, TMRUtility } from "./tmr-utility.js";

 /**
 * Extend the basic ItemSheet for RdD specific items
@ -100,55 +101,59 @@ export class RdDItemSheet extends ItemSheet {
      descriptionmj: await TextEditor.enrichHTML(this.item.system.descriptionmj, { async: true }),
      isComestible: this.item.getUtilisationCuisine(),
      options: RdDSheetUtility.mergeDocumentRights(this.options, this.item, this.isEditable),
+      competences: await SystemCompendiums.getCompetences('personnage'),
+      categories: RdDItem.getCategories(this.item.type),
    }
+
    if (this.item.type == ITEM_TYPES.competencecreature) {
      formData.isparade = RdDItemCompetenceCreature.isParade(this.item)
      formData.isdommages = RdDItemCompetenceCreature.isDommages(this.item)
    }
-
-    const competences = await SystemCompendiums.getCompetences('personnage');
-    formData.categories = RdDItem.getCategories(this.item.type)
-    if (this.item.type == 'tache' || this.item.type == 'livre' || this.item.type == 'meditation' || this.item.type == 'oeuvre') {
+    if (this.item.type == ITEM_TYPES.tache ||
+      this.item.type == ITEM_TYPES.livre ||
+      this.item.type == ITEM_TYPES.meditation ||
+      this.item.type == ITEM_TYPES.oeuvre) {
      formData.caracList = foundry.utils.duplicate(game.model.Actor.personnage.carac)
      formData.caracList["reve-actuel"] = foundry.utils.duplicate(game.model.Actor.personnage.reve.reve)
-      formData.competences = competences;
    }
-    if (this.item.type == 'arme') {
-      formData.competences = competences.filter(it => it.isCompetenceArme())
+    if (this.item.type == ITEM_TYPES.arme) {
+      formData.competences = formData.competences.filter(it => it.isCompetenceArme())
    }
-    if (['sort', 'sortreserve'].includes(this.item.type)) {
-      formData.competences = competences.filter(it => RdDItemCompetence.isDraconic(it));
-    }
-    if (this.item.type == 'recettecuisine') {
+    if (this.item.type == ITEM_TYPES.recettecuisine) {
      formData.ingredients = await TextEditor.enrichHTML(this.object.system.ingredients, { async: true })
    }
-    if (this.item.type == 'extraitpoetique') {
+    if (this.item.type == ITEM_TYPES.extraitpoetique) {
      formData.extrait = await TextEditor.enrichHTML(this.object.system.extrait, { async: true })
      formData.texte = await TextEditor.enrichHTML(this.object.system.texte, { async: true })
    }
-    if (this.item.type == 'recettealchimique') {
-      RdDAlchimie.processManipulation(this.item, this.actor && this.actor.id);
+    if (this.item.type == ITEM_TYPES.recettealchimique) {
+      RdDAlchimie.processManipulation(this.item, this.actor?.id);
      formData.manipulation_update = await TextEditor.enrichHTML(this.object.system.manipulation_update, { async: true })
      formData.utilisation = await TextEditor.enrichHTML(this.object.system.utilisation, { async: true })
      formData.enchantement = await TextEditor.enrichHTML(this.object.system.enchantement, { async: true })
      formData.sureffet = await TextEditor.enrichHTML(this.object.system.sureffet, { async: true })
    }
-    if (this.item.type == 'gemme') {
+    if (this.item.type == ITEM_TYPES.gemme) {
      formData.gemmeTypeList = RdDGemme.getGemmeTypeOptionList();
-      RdDGemme.calculDataDerivees(this.item);
+      RdDGemme.calculDataDerivees(this.item)
    }
-    if (this.item.type == 'potion') {
-      await RdDHerbes.addPotionFormData(formData);
+    if (this.item.type == ITEM_TYPES.potion) {
+      RdDHerbes.calculFormData(formData, this.item)
    }
-    if (formData.options.isOwned && this.item.type == 'herbe' && (formData.system.categorie == 'Soin' || formData.system.categorie == 'Repos')) {
+    if (this.item.type == ITEM_TYPES.herbe) {
+      if (formData.options.isOwned && ['Soin', 'Repos'].includes(formData.system.categorie)) {
        formData.isIngredientPotionBase = true;
      }
-    if (this.item.type == 'sortreserve') {
+    }
+    if (this.item.type == ITEM_TYPES.sortreserve) {
      const sortId = this.item.system.sortid;
+      formData.competences = formData.competences.filter(it => RdDItemCompetence.isDraconic(it));
      formData.sort = formData.options.isOwned ? this.item.actor.items.get(sortId) : game.items.get(sortId);
    }
-    formData.bonusCaseList = RdDItemSort.getBonusCaseList(formData, true);
-
+    if (this.item.type == ITEM_TYPES.sort) {
+      formData.competences = formData.competences.filter(it => RdDItemCompetence.isDraconic(it));
+      formData.bonusCaseList = RdDItemSort.getBonusCaseList(this.item);
+    }
    return formData;
  }

@ -185,6 +190,9 @@ export class RdDItemSheet extends ItemSheet {
        }
      }
    })
+    this.html.find('.delete-bonus-case').click((event) => {
+      this.supprimerBonusCase(event.currentTarget.attributes['data-deleteCoord'].value)
+    })

    this.html.find('.date-enchantement').change((event) => {
      const jour = Number(this.html.find('input.date-enchantement[name="enchantement.jour"]').val());
@ -264,23 +272,66 @@ export class RdDItemSheet extends ItemSheet {
    }
  }

+  async supprimerBonusCase(deleteCoord){
+    if (this.item.type == ITEM_TYPES.sort) {
+      const oldList = RdDItemSort.getBonusCaseList(this.item)
+      const newList = oldList.filter(it => it.case != deleteCoord);
+      if (newList.length != oldList.length) {
+        await this.item.update({
+          'system.bonuscase': RdDItemSort.bonuscasesToString(newList)
+        })
+      }
+    }
+  }
+
  /* -------------------------------------------- */
  /** @override */
  _updateObject(event, formData) {
    switch (this.item.type) {
      case ITEM_TYPES.sort:
-        // Données de bonus de cases ?
-        formData['system.bonuscase'] = RdDItemSort.buildBonuscaseFromArrays(formData.bonusValue, formData.caseValue)
+        formData['system.bonuscase'] = RdDItemSort.bonuscasesToString(RdDItemSheet._listCaseTmr(
+          formData.caseTmrCoord,
+          formData.caseTmrBonus,
+          formData.caseTmrAdd
+        ))
        break
      case ITEM_TYPES.competence:
-        if (formData['system.niveau'] == undefined) {
-          formData['system.niveau'] = formData['system.base']
-        }
+        formData['system.niveau'] = formData['system.niveau'] ?? formData['system.base']
+        break
    }

    return this.item.update(formData);
  }

+  /* -------------------------------------------- */
+  /**
+   * reconstruit les bonus de cases
+   * @param {*} caseTmrCoord tableau des coordonées
+   * @param {*} caseTmrBonus tableau des bonus
+   * @param {*} caseTmrAdd case à ajouter
+   * @returns list d'objets {coord, bonus}
+   */
+  static _listCaseTmr(caseTmrCoord, caseTmrBonus, caseTmrAdd) {
+    const listCaseTmrCoord = caseTmrCoord == undefined ? [] : Array.isArray(caseTmrCoord) ? caseTmrCoord : [caseTmrCoord]
+    const listCaseTmrBonus = caseTmrBonus == undefined ? [] : Array.isArray(caseTmrBonus) ? caseTmrBonus : [caseTmrBonus]
+    if (caseTmrAdd != undefined && caseTmrAdd != '' && TMRUtility.verifyTMRCoord(caseTmrAdd) && !listCaseTmrCoord.includes(caseTmrAdd)) {
+      listCaseTmrCoord.push(TMRUtility.getTMR(caseTmrAdd).coord)
+      listCaseTmrBonus.push(1)
+    }
+
+    const list = [];
+    const caseChecked = {};
+    for (let i = 0; i < listCaseTmrBonus.length && i < listCaseTmrCoord.length; i++) {
+      const coord = listCaseTmrCoord[i] == FLEUVE_COORD ? FLEUVE_COORD : (listCaseTmrCoord[i]?.toUpperCase() ?? 'A1')
+      const bonus = listCaseTmrBonus[i] ?? 0
+      if (TMRUtility.verifyTMRCoord(coord) && bonus >= 0 && !caseChecked[coord]) {
+        caseChecked[coord] = coord
+        list.push({ case: coord, bonus: bonus })
+      }
+    }
+    return list
+  }
+
  /* -------------------------------------------- */
  async _onDragStart(event) {
  }
--- a/module/item-sort.js
+++ b/module/item-sort.js
@ -2,19 +2,32 @@ import { Grammar } from "./grammar.js";
 import { RdDItemCompetence } from "./item-competence.js";
 import { ITEM_TYPES } from "./item.js";
 import { Misc } from "./misc.js";
-import { TMRUtility } from "./tmr-utility.js";
+import { FLEUVE_COORD, TMRUtility } from "./tmr-utility.js";

-const VOIES_DRACONIC = [
+export const VOIES_DRACONIC = [
  { code: 'O', label: "Voie d'Oniros", short: 'Oniros', ordre: 'a' },
  { code: 'H', label: "Voie d'Hypnos", short: 'Hypnos', ordre: 'b' },
  { code: 'N', label: "Voie de Narcos", short: 'Narcos', ordre: 'c' },
  { code: 'T', label: "Voie de Thanatos", short: 'Thanatos', ordre: 'd' },
-  { code: 'O/H/N/T', label: "Oniros/Hypnos/Narcos/Thanatos", short: 'Oniros/Hypnos/Narcos/Thanatos', ordre: 'e' },
-  { code: 'O/H/N', label: "Oniros/Hypnos/Narcos", short: "Oniros/Hypnos/Narcos", ordre: 'f' }
+  { code: 'O/H/N/T', label: "Oniros/Hypnos/Narcos/Thanatos", short: 'O/H/N/T', ordre: 'e' },
+  { code: 'O/H/N', label: "Oniros/Hypnos/Narcos", short: "O/H/N", ordre: 'f' }
 ]

 /* -------------------------------------------- */
 export class RdDItemSort extends Item {
+  static preloadHandlebars() {
+    Handlebars.registerHelper('itemSort-spaceIfText', val => RdDItemSort.addSpaceToNonNumeric(val))
+    Handlebars.registerHelper('itemSort-codeDraconic', voie => RdDItemSort.getCode(voie))
+    Handlebars.registerHelper('itemSort-shortDraconic', voie => RdDItemSort.getShortVoie(voie))
+  }
+
+  static addSpaceToNonNumeric(value) {
+    return Number.isNumeric(value) || ['-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'].includes( String(value).charAt[0]) ? value : ' ' + RdDItemSort.toVar(value)
+  }
+
+  static toVar(value) {
+    return value ? value.replace('variable', 'var') : ''
+  }

  static getDraconicsSort(competencesDraconic, sort) {
    // se baser sur la voie du sort?
@ -33,20 +46,23 @@ export class RdDItemSort extends Item {
    return (VOIES_DRACONIC.find(it => it.code == code)?.ordre ?? '?')
  }

-  static getVoieCode(voie) {
-    return VOIES_DRACONIC.find(it => voie.name.includes(it.short))?.code ?? '?'
+  static getCodeVoie(voie) {
+    return VOIES_DRACONIC.find(it => [it.code, it.short, it.label].includes(voie))?.code ?? '?'
  }

-  static getCodeDraconic(sort, voies = ['O', 'H', 'N', 'T']) {
+  static getShortVoie(voie) {
+    return VOIES_DRACONIC.find(it => [it.code, it.short, it.label].includes(voie))?.short ?? voie
+  }
+
+  static getCode(sort, codeVoies = ['O', 'H', 'N', 'T']) {
    switch (Grammar.toLowerCaseNoAccent(sort.name)) {
      case "lecture d'aura":
      case "detection d'aura":
-        return RdDItemSort.$voiesConnues('O/H/N/T', voies)
+        return RdDItemSort.$voiesConnues('O/H/N/T', codeVoies)
      case "annulation de magie":
-        return RdDItemSort.$voiesConnues('O/H/N', voies)
+        return RdDItemSort.$voiesConnues('O/H/N', codeVoies)
    }
-    const voie = VOIES_DRACONIC.find(it => it.label.includes(sort.system.draconic))
-    return voie?.code ?? sort.system.draconic
+    return RdDItemSort.getCodeVoie(sort.system.draconic)
  }

  static $voiesConnues(voiesSort, voies) {
@ -80,89 +96,60 @@ export class RdDItemSort extends Item {
    return variable;
  }

-  /* -------------------------------------------- */
-  static buildBonusCaseList(bonuscase, newCase) {
-    const list = RdDItemSort.bonuscaseStringToList(bonuscase)
-    if (newCase) {
-      list.push({ case: "Nouvelle", bonus: 0 })
-    }
-    return list;
-  }
-
  /**
   * Retourne une liste de bonus/case pour un item-sheet
  * @param {} item 
  */
-  static getBonusCaseList(item, newCase = false) {
+  static getBonusCaseList(item) {
    // Gestion spéciale case bonus
    if (item.type == ITEM_TYPES.sort) {
-      return RdDItemSort.buildBonusCaseList(item.system.bonuscase, newCase);
+      return RdDItemSort.stringToBonuscases(item.system.bonuscase)
    }
-    return undefined;
-  }
-
-  /* -------------------------------------------- */
-  /** Met à jour les données de formulaire 
-   * si static des bonus de cases sont présents 
-   * */
-  static buildBonuscaseFromArrays(bonuses, coords) {
-    if (bonuses) {
-      const list = [];
-      const caseCheck = {};
-      for (let i = 0; i < bonuses.length && i < coords.length; i++) {
-        const coord = coords[i] == 'Fleuve' ? 'Fleuve' : (coords[i]?.toUpperCase() ?? 'A1');
-        const bonus = bonuses[i] || 0;
-        if (TMRUtility.verifyTMRCoord(coord) && bonus > 0 && caseCheck[coord] == undefined) {
-          caseCheck[coord] = bonus;
-          list.push({ case: coord, bonus: bonus });
-        }
-      }
-      return RdDItemSort._bonuscaseListToString(list);
-    }
-    return undefined;
+    return [];
  }

  /* -------------------------------------------- */
  static incrementBonusCase(actor, sort, coord) {
-    if (TMRUtility.getTMR(coord).type == "fleuve") {
-      coord = 'Fleuve';
+    if (TMRUtility.isFleuve(coord)) {
+      coord = FLEUVE_COORD;
+    }
+    let list = RdDItemSort.stringToBonuscases(sort.system.bonuscase);
+    const existing = list.find(it => it.case == coord)
+    const bonus = Number(existing?.bonus ?? 0) + 1
+    if (existing) {
+      existing.bonus = bonus
+    }
+    else {
+      list.push({ case: coord, bonus: 1 })
    }
-    const list = RdDItemSort.buildBonusCaseList(sort.system.bonuscase, false);
-    const bonus = Number(list.find(it => it.case == coord)?.bonus ?? 0);
-    const modified = { case: coord, bonus: bonus + 1 };

-    const bonuscase = RdDItemSort._bonuscaseListToString(
-      list.filter(it => it.case != coord).concat(modified)
-    );
-
-    // Sauvegarde/update
-    actor.updateEmbeddedDocuments('Item', [{ _id: sort._id, 'system.bonuscase': bonuscase }]);
+    actor.updateEmbeddedDocuments('Item', [{ _id: sort._id, 'system.bonuscase': RdDItemSort.bonuscasesToString(list) }]);
  }


  /* -------------------------------------------- */
  static getCaseBonus(sort, coord) {
-    const isFleuve = TMRUtility.getTMR(coord).type == "fleuve";
-
-    let bc = RdDItemSort.buildBonusCaseList(sort.system.bonuscase, false)
-      .filter(it => it.case == coord || (isFleuve && it.case == 'Fleuve'))
-      .find(it => true)
+    const search = TMRUtility.isFleuve(coord)
+      ? it => it.case == 'Fleuve'
+      : it => it.case == coord;
+    const bc = RdDItemSort.stringToBonuscases(sort.system.bonuscase)
+      .find(search)
    return Number(bc?.bonus ?? 0);
  }

-  static _bonuscaseListToString(list) {
+  static bonuscasesToString(list) {
    return list.map(it => `${it.case}:${it.bonus}`)
      .sort(Misc.ascending())
      .join(',');
  }
-  static bonuscaseStringToList(bonuscase) {
+
+  static stringToBonuscases(bonuscase) {
    if (bonuscase == undefined || bonuscase == '') {
      return []
    }
-    return bonuscase.split(',').map(it => {
-      const b = it.split(':');
-      return { case: b[0], bonus: b[1] };
-    });
+    return bonuscase.split(',')
+      .map(it => it.split(':'))
+      .map(it => { return { case: it[0], bonus: it[1] } });
  }

 }
--- a/module/item.js
+++ b/module/item.js
@ -571,6 +571,7 @@ export class RdDItem extends Item {
    else {
      await this.quantiteIncDec(item.system.quantite);
    }
+    // TODO: suppression dans les conteneurs!
    await item.delete();
  }

@ -601,6 +602,9 @@ export class RdDItem extends Item {
    if (!other || !this.isInventaire()) {
      return [false, undefined];
    }
+    if (this.isConteneur()){
+      return [false, `Impossible de regrouper des conteneurs, ils ne sont pas empilables`];
+    }
    if (this.system.quantite == undefined) {
      return [false, `Impossible de regrouper des ${this.type}, ils ne sont pas empilables`];
    }
--- a/module/migrations.js
+++ b/module/migrations.js
@ -5,7 +5,7 @@ import { Monnaie } from "./item-monnaie.js";
 import { RdDItem, ITEM_TYPES } from "./item.js";
 import { RdDTimestamp } from "./time/rdd-timestamp.js";
 import { RdDRaretes } from "./item/raretes.js";
-import { RdDCalendrier } from "./time/rdd-calendrier.js";
+import { VOIES_DRACONIC } from "./item-sort.js";

 class Migration {
  get code() { return "sample"; }
@ -530,6 +530,32 @@ class _11_2_20_MigrationAstrologie extends Migration {
  }
 }

+class _12_0_24_MigrationVoieSorts extends Migration {
+  get code() { return "migration-voies-sorts" }
+  get version() { return "12.0.24" }
+
+  async migrate() {
+    await this.applyItemsUpdates(items => items
+      .filter(it => ITEM_TYPES.sort == it.type)
+      .map(it => this.migrateSort(it))
+    )
+  }
+  migrateSort(it) {
+    return {
+      _id: it.id,
+      'system.draconic': this.convertDraconic(it.system.draconic),
+    }
+  }
+  convertDraconic(draconic) {
+    for (let v of VOIES_DRACONIC) {
+      if ([v.label, v.short, v.code].includes(draconic)) {
+        return v.short
+      }
+    }
+    return draconic
+  }
+}
+
 export class Migrations {
  static getMigrations() {
    return [
--- a/module/rdd-commands.js
+++ b/module/rdd-commands.js
@ -360,14 +360,15 @@ export class RdDCommands {

  async getTMRAleatoire(msg, params) {
    if (params.length < 2) {
-      let type = params[0];
-      const tmr = await TMRUtility.getTMRAleatoire(type ? (it => it.type == type) : (it => true));
-      return RdDCommands._chatAnswer(msg, `Case aléatoire: ${tmr.coord} - ${tmr.label}`);
+      let type = params[0]
+      const solvedTerrain = TMRUtility.findTMRLike(type)?.type
+      if (solvedTerrain){
+        const tmr = await TMRUtility.getTMRAleatoire(type ? (it => it.type == solvedTerrain) : (it => true))
+        return RdDCommands._chatAnswer(msg, `Case aléatoire: ${tmr.coord} - ${tmr.label}`)
+      }
    }
-    else {
    return false;
  }
-  }

  async findTMR(msg, params) {
    if (params && params.length > 0) {
@ -384,11 +385,11 @@ export class RdDCommands {
  async tableRencontres(msg, params) {
    if (params && params.length > 0) {
      const search = Misc.join(params, ' ');
-      const solvedTerrain = TMRUtility.findTMRLike(search);
+      const solvedTerrain = TMRUtility.findTMRLike(search)
      if (solvedTerrain == undefined) {
        return RdDCommands._chatAnswer(msg, 'Aucune TMR correspondant à ' + search);
      }
-      return await game.system.rdd.rencontresTMR.chatTable(solvedTerrain);
+      return await game.system.rdd.rencontresTMR.chatTable(solvedTMRType.name)
    }
    return false;
  }
--- a/module/rdd-herbes.js
+++ b/module/rdd-herbes.js
@ -28,9 +28,9 @@ export class RdDHerbes extends Item {
  }

  /* -------------------------------------------- */
-  static async addPotionFormData(formData) {
-    formData.isSoins = formData.system.categorie.includes('Soin');
-    formData.isRepos = formData.system.categorie.includes('Repos');
+  static calculFormData(formData, item) {
+    formData.isSoins = item.system.categorie.includes('Soin');
+    formData.isRepos = item.system.categorie.includes('Repos');
    if (formData.isSoins) {
      RdDHerbes.calculBonusHerbe(formData, this.herbesSoins, 12);
    }
@ -40,7 +40,7 @@ export class RdDHerbes extends Item {
    formData.herbesSoins = RdDHerbes.buildHerbesList(this.herbesSoins, 12);
    formData.herbesRepos = RdDHerbes.buildHerbesList(this.herbesRepos, 7);
    formData.dateActuelle = game.system.rdd.calendrier.dateCourante();
-    formData.enchantement = RdDTimestamp.splitIndexDate(formData.system.prdate);
+    formData.enchantement = RdDTimestamp.splitIndexDate(item.system.prdate);
  }

  /* -------------------------------------------- */
--- a/module/rdd-main.js
+++ b/module/rdd-main.js
@ -69,6 +69,7 @@ import { ExportScriptarium } from "./actor/export-scriptarium/export-scriptarium
 import { AppPersonnageAleatoire } from "./actor/random/app-personnage-aleatoire.js"
 import { RdDActorExportSheet } from "./actor/export-scriptarium/actor-encart-sheet.js"
 import { RdDStatBlockParser } from "./apps/rdd-import-stats.js"
+import { RdDItemSort } from "./item-sort.js"

 /**
 * RdD system
@ -122,6 +123,7 @@ export class SystemReveDeDragon {
    // preload handlebars templates
    RdDUtility.preloadHandlebarsTemplates()
    AppPersonnageAleatoire.preloadHandlebars()
+    RdDItemSort.preloadHandlebars()

    /* -------------------------------------------- */
    ReglesOptionnelles.initSettings()
--- a/module/settings/system-compendiums.js
+++ b/module/settings/system-compendiums.js
@ -32,7 +32,7 @@ export class SystemCompendiums extends FormApplication {
        compendium: compendium,
        default: SystemCompendiums._getDefaultCompendium(compendium),
        setting: SystemCompendiums._getSettingCompendium(compendium)
-      });
+      })

      game.settings.register(SYSTEM_RDD, definition.setting, {
        name: definition.label,
@ -40,8 +40,8 @@ export class SystemCompendiums extends FormApplication {
        scope: "world",
        config: false,
        type: String
-      });
-    });
+      })
+    })

    game.settings.registerMenu(SYSTEM_RDD, "compendium-settings", {
      name: "Choisir les compendiums système",
@ -71,16 +71,18 @@ export class SystemCompendiums extends FormApplication {

  static async getCompetences(actorType) {
    switch (actorType ?? 'personnage') {
-      case 'personnage': return await SystemCompendiums.getWorldOrCompendiumItems('competence', 'competences');
-      case 'creature': return await SystemCompendiums.getWorldOrCompendiumItems('competencecreature', 'competences-creatures');
-      case 'entite': return await SystemCompendiums.getWorldOrCompendiumItems('competencecreature', 'competences-entites');
+      case 'personnage':
+        return await SystemCompendiums.getWorldOrCompendiumItems('competence', 'competences')
+      case 'entite':
+      case 'creature':
+        return await SystemCompendiums.getWorldOrCompendiumItems('competencecreature', 'competences-creatures')
      case 'vehicule': return [];
    }
  }

  /* -------------------------------------------- */
  static async getWorldOrCompendiumItems(itemType, compendium) {
-    let items = game.items.filter(it => it.type == itemType);
+    let items = game.items.filter(it => it.type == itemType)
    if (compendium) {
      const ids = items.map(it => it.id);
      const names = items.map(it => it.name.toLowerCase());
@ -284,23 +286,20 @@ export class CompendiumTableHelpers {
  }

  /* -------------------------------------------- */
-  static async tableRowToChatMessage(row, type = 'Item') {
+  static async tableRowToChatMessage(row, type, options = { showSource: true }) {
    if (!row) {
      return;
    }
-    const percentages = (row.total == 100) ? '%' : ''
    const flavorContent = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-compendium-table-roll.hbs', {
      roll: row.roll,
      document: row.document,
-      percentages,
      typeName: Misc.typeName(type, row.document?.type ?? 'objet'),
      isGM: game.user.isGM,
+      options
    });
    const messageData = {
-      // flavor: flavorContent,
      user: game.user.id,
-      type: CONST.CHAT_MESSAGE_TYPES.ROLL,
-      roll: row.roll,
+      rolls: [row.roll],
      sound: CONFIG.sounds.dice,
      content: flavorContent
    };
--- a/module/tmr-rencontres.js
+++ b/module/tmr-rencontres.js
@ -26,22 +26,19 @@ export class TMRRencontres {
   * @param {*} forcedRoll 
   */
  async rollRencontre(terrain, forcedRoll) {
-    terrain = TMRUtility.findTMRLike(terrain);
-    if (terrain == undefined) {
+    const tmrType = TMRUtility.findTMRLike(terrain)?.type
+    if (tmrType == undefined) {
      return undefined;
    }

    if (forcedRoll && (forcedRoll <= 0 || forcedRoll > 100)) {
      forcedRoll = undefined;
    }
-    const codeTerrain = Grammar.toLowerCaseNoAccent(terrain)
-    const filtreMauvaise = codeTerrain == 'mauvaise' ? it => it.system.mauvaiseRencontre : it => !it.system.mauvaiseRencontre;
-    const frequence = it => it.system.frequence[codeTerrain];
+    const filtreMauvaise = tmrType == 'mauvaise' ? it => it.system.mauvaiseRencontre : it => !it.system.mauvaiseRencontre;
+    const frequence = it => it.system.frequence[tmrType];
    const row = await this.table.getRandom(frequence, filtreMauvaise, forcedRoll);
    if (row) {
-      console.log("DORM", row);
-      //row.document.system.computedForce = new Roll(row.document.system.formula).roll({async: false}).total; 
-      await CompendiumTableHelpers.tableRowToChatMessage(row);
+      await CompendiumTableHelpers.tableRowToChatMessage(row, 'Item', {showSource: false});
    }

    return row?.document;
--- a/module/tmr-utility.js
+++ b/module/tmr-utility.js
@ -2,228 +2,216 @@ import { Misc } from "./misc.js";
 import { Grammar } from "./grammar.js";
 import { RdDDice } from "./rdd-dice.js";

-/* -------------------------------------------- */
-const TMRMapping = {
-  A1: { type: "cite", label: "Cité Vide" },
-  B1: { type: "plaines", label: "Plaines d’Assorh" },
-  C1: { type: "necropole", label: "Nécropole de Kroak" },
-  D1: { type: "fleuve", label: "Fleuve de l'Oubli" },
-  E1: { type: "monts", label: "Monts de Kanaï" },
-  F1: { type: "cite", label: "Cité Glauque" },
-  G1: { type: "desolation", label: "Désolation de Jamais" },
-  H1: { type: "lac", label: "Lac d’Anticalme" },
-  I1: { type: "plaines", label: "Plaines Grises" },
-  J1: { type: "monts", label: "Monts Fainéants" },
-  K1: { type: "cite", label: "Cité d’Onkause" },
-  L1: { type: "fleuve", label: "Fleuve de l'Oubli" },
-  M1: { type: "cite", label: "Cité Jalouse" },
-
-  A2: { type: "desert", label: "Désert de Mieux" },
-  B2: { type: "collines", label: "Collines de Dawell" },
-  C2: { type: "marais", label: "Marais Glignants" },
-  D2: { type: "cite", label: "Cité de Frost" },
-  E2: { type: "plaines", label: "Plaines de Fiask" },
-  F2: { type: "lac", label: "Lac de Misère" },
-  G2: { type: "marais", label: "Marais Nuisants" },
-  H2: { type: "collines", label: "Collines de Parta" },
-  I2: { type: "foret", label: "Forêt Fade" },
-  J2: { type: "desert", label: "Désert de Poly" },
-  K2: { type: "foret", label: "Forêt Tamée" },
-  L2: { type: "fleuve", label: "Fleuve de l'Oubli" },
-  M2: { type: "necropole", label: "Nécropole de Logos" },
-
-  A3: { type: "desolation", label: "Désolation de Demain" },
-  B3: { type: "plaines", label: "Plaines de Rubéga" },
-  C3: { type: "fleuve", label: "Fleuve de l'Oubli" },
-  D3: { type: "gouffre", label: "Gouffre d’Oki" },
-  E3: { type: "foret", label: "Forêt d’Estoubh" },
-  F3: { type: "fleuve", label: "Fleuve de l'Oubli" },
-  G3: { type: "gouffre", label: "Gouffre de Sun" },
-  H3: { type: "foret", label: "Forêt de Ganna" },
-  I3: { type: "monts", label: "Monts Grinçants" },
-  J3: { type: "cite", label: "Cité Venin" },
-  K3: { type: "plaines", label: "Plaines de Dois" },
-  L3: { type: "lac", label: "Lac Laineux" },
-  M3: { type: "monts", label: "Monts de Vdah" },
-
-  A4: { type: "foret", label: "Forêt de Falconax" },
-  B4: { type: "monts", label: "Monts Crâneurs" },
-  C4: { type: "pont", label: "Pont de Giolii" },
-  D4: { type: "lac", label: "Lac de Foam" },
-  E4: { type: "plaines", label: "Plaines d’Orti" },
-  F4: { type: "fleuve", label: "Fleuve de l'Oubli" },
-  G4: { type: "sanctuaire", label: "Sanctuaire Blanc" },
-  H4: { type: "plaines", label: "Plaines de Psark" },
-  I4: { type: "plaines", label: "Plaines de Xiax" },
-  J4: { type: "collines", label: "Collines d’Encre" },
-  K4: { type: "pont", label: "Pont de Fah" },
-  L4: { type: "sanctuaire", label: "Sanctuaire Mauve" },
-  M4: { type: "gouffre", label: "Gouffre Grisant" },
-
-  A5: { type: "plaines", label: "Plaines de Trilkh" },
-  B5: { type: "collines", label: "Collines de Tanegy" },
-  C5: { type: "marais", label: "Marais Flouants" },
-  D5: { type: "fleuve", label: "Fleuve de l'Oubli" },
-  E5: { type: "monts", label: "Monts Brûlants" },
-  F5: { type: "cite", label: "Cité de Panople" },
-  G5: { type: "pont", label: "Pont d’Ik" },
-  H5: { type: "desert", label: "Désert de Krane" },
-  I5: { type: "desolation", label: "Désolation de Toujours" },
-  J5: { type: "marais", label: "Marais de Jab" },
-  K5: { type: "fleuve", label: "Fleuve de l'Oubli" },
-  L5: { type: "collines", label: "Collines Suaves" },
-  M5: { type: "cite", label: "Cité Rimarde" },
-
-  A6: { type: "necropole", label: "Nécropole de Zniak" },
-  B6: { type: "foret", label: "Forêt de Bust" },
-  C6: { type: "cite", label: "Cité Pavois" },
-  D6: { type: "fleuve", label: "Fleuve de l'Oubli" },
-  E6: { type: "sanctuaire", label: "Sanctuaire de Plaine" },
-  F6: { type: "fleuve", label: "Fleuve de l'Oubli" },
-  G6: { type: "marais", label: "Marais Glutants" },
-  H6: { type: "monts", label: "Monts Gurdes" },
-  I6: { type: "necropole", label: "Nécropole de Xotar" },
-  J6: { type: "lac", label: "Lac d’Iaupe" },
-  K6: { type: "desolation", label: "Désolation de Poor" },
-  L6: { type: "foret", label: "Forêt Gueuse" },
-  M6: { type: "desolation", label: "Désolation de Presque" },
-
-  A7: { type: "plaines", label: "Plaines de l’Arc" },
-  B7: { type: "marais", label: "Marais Bluants" },
-  C7: { type: "fleuve", label: "Fleuve de l'Oubli" },
-  D7: { type: "plaines", label: "Plaines d’Affa" },
-  E7: { type: "foret", label: "Forêt de Glusks" },
-  F7: { type: "fleuve", label: "Fleuve de l'Oubli" },
-  G7: { type: "cite", label: "Cité de Terwa" },
-  H7: { type: "gouffre", label: "Gouffre de Kapfa" },
-  I7: { type: "plaines", label: "Plaines de Troo" },
-  J7: { type: "fleuve", label: "Fleuve de l'Oubli" },
-  K7: { type: "cite", label: "Cité de Kolix" },
-  L7: { type: "gouffre", label: "Gouffre d’Episophe" },
-  M7: { type: "desert", label: "Désert de Lave" },
-
-  A8: { type: "gouffre", label: "Gouffre de Shok" },
-  B8: { type: "fleuve", label: "Fleuve de l'Oubli" },
-  C8: { type: "foret", label: "Forêt Turmide" },
-  D8: { type: "cite", label: "Cité d’Olak" },
-  E8: { type: "plaines", label: "Plaines d’Iolise" },
-  F8: { type: "lac", label: "Lac des Chats" },
-  G8: { type: "plaines", label: "Plaines Sans Joie" },
-  H8: { type: "foret", label: "Forêt d’Ourf" },
-  I8: { type: "fleuve", label: "Fleuve de l'Oubli" },
-  J8: { type: "monts", label: "Monts Barask" },
-  K8: { type: "desert", label: "Désert de Fumée" },
-  L8: { type: "monts", label: "Monts Tavelés" },
-  M8: { type: "plaines", label: "Plaines Lavées" },
-
-  A9: { type: "collines", label: "Collines de Korrex" },
-  B9: { type: "lac", label: "Lac de Lucre" },
-  C9: { type: "monts", label: "Monts Tuméfiés" },
-  D9: { type: "pont", label: "Pont d’Orx" },
-  E9: { type: "fleuve", label: "Fleuve de l'Oubli" },
-  F9: { type: "plaines", label: "Plaines de Foe" },
-  G9: { type: "desolation", label: "Désolation de Sel" },
-  H9: { type: "collines", label: "Collines de Noirseul" },
-  I9: { type: "fleuve", label: "Fleuve de l'Oubli" },
-  J9: { type: "marais", label: "Marais Gronchants" },
-  K9: { type: "sanctuaire", label: "Sanctuaire Noir" },
-  L9: { type: "collines", label: "Collines Cornues" },
-  M9: { type: "necropole", label: "Nécropole de Zonar" },
-
-  A10: { type: "sanctuaire", label: "Sanctuaire d’Olis" },
-  B10: { type: "monts", label: "Monts Salés" },
-  C10: { type: "marais", label: "Marais de Dom" },
-  D10: { type: "fleuve", label: "Fleuve de l'Oubli" },
-  E10: { type: "gouffre", label: "Gouffre de Junk" },
-  F10: { type: "marais", label: "Marais Zultants" },
-  G10: { type: "cite", label: "Cité de Sergal" },
-  H10: { type: "plaines", label: "Plaines Noires" },
-  I10: { type: "lac", label: "Lac Wanito" },
-  J10: { type: "fleuve", label: "Fleuve de l'Oubli" },
-  K10: { type: "plaines", label: "Plaines Jaunes" },
-  L10: { type: "desert", label: "Désert de Nicrop" },
-  M10: { type: "foret", label: "Forêt de Jajou" },
-
-  A11: { type: "desolation", label: "Désolation d’Hier" },
-  B11: { type: "cite", label: "Cité de Brilz" },
-  C11: { type: "pont", label: "Pont de Roï" },
-  D11: { type: "desolation", label: "Désolation de Partout" },
-  E11: { type: "lac", label: "Lac de Glinster" },
-  F11: { type: "cite", label: "Cité de Noape" },
-  G11: { type: "fleuve", label: "Fleuve de l'Oubli" },
-  H11: { type: "fleuve", label: "Fleuve de l'Oubli" },
-  I11: { type: "pont", label: "Pont de Yalm" },
-  J11: { type: "plaines", label: "Plaines de Miltiar" },
-  K11: { type: "cite", label: "Cité Tonnerre" },
-  L11: { type: "collines", label: "Collines de Kol" },
-  M11: { type: "cite", label: "Cité Crapaud" },
-
-  A12: { type: "plaines", label: "Plaines Sages" },
-  B12: { type: "fleuve", label: "Fleuve de l'Oubli" },
-  C12: { type: "lac", label: "Lac de Fricassa" },
-  D12: { type: "collines", label: "Collines d’Huaï" },
-  E12: { type: "monts", label: "Monts Ajourés" },
-  F12: { type: "necropole", label: "Nécropole de Throat" },
-  G12: { type: "plaines", label: "Plaines de Lufmil" },
-  H12: { type: "collines", label: "Collines de Tooth" },
-  I12: { type: "gouffre", label: "Gouffre Abimeux" },
-  J12: { type: "cite", label: "Cité Folle" },
-  K12: { type: "desolation", label: "Désolation d’Amour" },
-  L12: { type: "plaines", label: "Plaines Venteuses" },
-  M12: { type: "collines", label: "Collines Révulsantes" },
-
-  A13: { type: "fleuve", label: "Fleuve de l'Oubli" },
-  B13: { type: "gouffre", label: "Gouffre des Litiges" },
-  C13: { type: "desert", label: "Désert de Neige" },
-  D13: { type: "cite", label: "Cité Sordide" },
-  E13: { type: "plaines", label: "Plaines de Xnez" },
-  F13: { type: "foret", label: "Forêt des Cris" },
-  G13: { type: "plaines", label: "Plaines Calcaires" },
-  H13: { type: "desolation", label: "Désolation de Rien" },
-  I13: { type: "monts", label: "Monts Bigleux" },
-  J13: { type: "gouffre", label: "Gouffre de Gromph" },
-  K13: { type: "foret", label: "Forêt de Kluth" },
-  L13: { type: "monts", label: "Monts Dormants" },
-  M13: { type: "plaines", label: "Plaines d’Anjou" },
-
-  A14: { type: "collines", label: "Collines de Stolis" },
-  B14: { type: "necropole", label: "Nécropole de Gorlo" },
-  C14: { type: "foret", label: "Forêt de Bissam" },
-  D14: { type: "sanctuaire", label: "Sanctuaire Plat" },
-  E14: { type: "monts", label: "Monts de Quath" },
-  F14: { type: "plaines", label: "Plaines Brisées" },
-  G14: { type: "desert", label: "Désert de Sek" },
-  H14: { type: "plaines", label: "Plaines Blanches" },
-  I14: { type: "cite", label: "Cité Destituée" },
-  J14: { type: "desert", label: "Désert de Sank" },
-  K14: { type: "necropole", label: "Nécropole d’Antinéar" },
-  L14: { type: "plaines", label: "Plaines de Jislith" },
-  M14: { type: "desolation", label: "Désolation d’Après" },
-
-  A15: { type: "cite", label: "Cité de Mielh" },
-  C15: { type: "plaines", label: "Plaines de Toué" },
-  E15: { type: "foret", label: "Forêt des Furies" },
-  G15: { type: "plaines", label: "Plaines des Soupirs" },
-  I15: { type: "monts", label: "Monts des Dragées" },
-  K15: { type: "collines", label: "Collines Pourpres" },
-  M15: { type: "cite", label: "Cité de Klana" }
+export const TMRType = {
+  cite: { type: 'cite', name: "cité", genre: "f" },
+  sanctuaire: { type: 'sanctuaire', name: "sanctuaire", genre: 'm' },
+  plaines: { type: 'plaines', name: "plaines", genre: "fp" },
+  pont: { type: 'pont', name: "pont", genre: "m" },
+  collines: { type: 'collines', name: "collines", genre: "p" },
+  foret: { type: 'foret', name: "forêt", genre: "f" },
+  monts: { type: 'monts', name: "monts", genre: "p" },
+  desert: { type: 'desert', name: "désert", genre: "m" },
+  fleuve: { type: 'fleuve', name: "fleuve", genre: "m" },
+  lac: { type: 'lac', name: "lac", genre: "m" },
+  marais: { type: 'marais', name: "marais", genre: "m" },
+  gouffre: { type: 'gouffre', name: "gouffre", genre: "m" },
+  necropole: { type: 'necropole', name: "nécropole", genre: "f" },
+  desolation: { type: 'desolation', name: "désolation", genre: "f" }
 }

-export const TMRType = {
-  cite: { name: "cité", genre: "f" },
-  sanctuaire: { name: "sanctuaire", genre: 'm' },
-  plaines: { name: "plaines", genre: "fp" },
-  pont: { name: "pont", genre: "m" },
-  collines: { name: "collines", genre: "p" },
-  foret: { name: "forêt", genre: "f" },
-  monts: { name: "monts", genre: "p" },
-  desert: { name: "désert", genre: "m" },
-  fleuve: { name: "fleuve", genre: "m" },
-  lac: { name: "lac", genre: "m" },
-  marais: { name: "marais", genre: "m" },
-  gouffre: { name: "gouffre", genre: "m" },
-  necropole: { name: "nécropole", genre: "f" },
-  desolation: { name: "désolation", genre: "f" }
+export const FLEUVE_COORD = 'Fleuve'
+
+const TMRMapping = {
+  Fleuve: { type: TMRType.fleuve.type, label: "Fleuve de l'Oubli" },
+  A1: { type: TMRType.cite.type, label: "Cité Vide" },
+  B1: { type: TMRType.plaines.type, label: "Plaines d’Assorh" },
+  C1: { type: TMRType.necropole.type, label: "Nécropole de Kroak" },
+  D1: { type: TMRType.fleuve.type, label: "Fleuve de l'Oubli" },
+  E1: { type: TMRType.monts.type, label: "Monts de Kanaï" },
+  F1: { type: TMRType.cite.type, label: "Cité Glauque" },
+  G1: { type: TMRType.desolation.type, label: "Désolation de Jamais" },
+  H1: { type: TMRType.lac.type, label: "Lac d’Anticalme" },
+  I1: { type: TMRType.plaines.type, label: "Plaines Grises" },
+  J1: { type: TMRType.monts.type, label: "Monts Fainéants" },
+  K1: { type: TMRType.cite.type, label: "Cité d’Onkause" },
+  L1: { type: TMRType.fleuve.type, label: "Fleuve de l'Oubli" },
+  M1: { type: TMRType.cite.type, label: "Cité Jalouse" },
+  A2: { type: TMRType.desert.type, label: "Désert de Mieux" },
+  B2: { type: TMRType.collines.type, label: "Collines de Dawell" },
+  C2: { type: TMRType.marais.type, label: "Marais Glignants" },
+  D2: { type: TMRType.cite.type, label: "Cité de Frost" },
+  E2: { type: TMRType.plaines.type, label: "Plaines de Fiask" },
+  F2: { type: TMRType.lac.type, label: "Lac de Misère" },
+  G2: { type: TMRType.marais.type, label: "Marais Nuisants" },
+  H2: { type: TMRType.collines.type, label: "Collines de Parta" },
+  I2: { type: TMRType.foret.type, label: "Forêt Fade" },
+  J2: { type: TMRType.desert.type, label: "Désert de Poly" },
+  K2: { type: TMRType.foret.type, label: "Forêt Tamée" },
+  L2: { type: TMRType.fleuve.type, label: "Fleuve de l'Oubli" },
+  M2: { type: TMRType.necropole.type, label: "Nécropole de Logos" },
+  A3: { type: TMRType.desolation.type, label: "Désolation de Demain" },
+  B3: { type: TMRType.plaines.type, label: "Plaines de Rubéga" },
+  C3: { type: TMRType.fleuve.type, label: "Fleuve de l'Oubli" },
+  D3: { type: TMRType.gouffre.type, label: "Gouffre d’Oki" },
+  E3: { type: TMRType.foret.type, label: "Forêt d’Estoubh" },
+  F3: { type: TMRType.fleuve.type, label: "Fleuve de l'Oubli" },
+  G3: { type: TMRType.gouffre.type, label: "Gouffre de Sun" },
+  H3: { type: TMRType.foret.type, label: "Forêt de Ganna" },
+  I3: { type: TMRType.monts.type, label: "Monts Grinçants" },
+  J3: { type: TMRType.cite.type, label: "Cité Venin" },
+  K3: { type: TMRType.plaines.type, label: "Plaines de Dois" },
+  L3: { type: TMRType.lac.type, label: "Lac Laineux" },
+  M3: { type: TMRType.monts.type, label: "Monts de Vdah" },
+  A4: { type: TMRType.foret.type, label: "Forêt de Falconax" },
+  B4: { type: TMRType.monts.type, label: "Monts Crâneurs" },
+  C4: { type: TMRType.pont.type, label: "Pont de Giolii" },
+  D4: { type: TMRType.lac.type, label: "Lac de Foam" },
+  E4: { type: TMRType.plaines.type, label: "Plaines d’Orti" },
+  F4: { type: TMRType.fleuve.type, label: "Fleuve de l'Oubli" },
+  G4: { type: TMRType.sanctuaire.type, label: "Sanctuaire Blanc" },
+  H4: { type: TMRType.plaines.type, label: "Plaines de Psark" },
+  I4: { type: TMRType.plaines.type, label: "Plaines de Xiax" },
+  J4: { type: TMRType.collines.type, label: "Collines d’Encre" },
+  K4: { type: TMRType.pont.type, label: "Pont de Fah" },
+  L4: { type: TMRType.sanctuaire.type, label: "Sanctuaire Mauve" },
+  M4: { type: TMRType.gouffre.type, label: "Gouffre Grisant" },
+  A5: { type: TMRType.plaines.type, label: "Plaines de Trilkh" },
+  B5: { type: TMRType.collines.type, label: "Collines de Tanegy" },
+  C5: { type: TMRType.marais.type, label: "Marais Flouants" },
+  D5: { type: TMRType.fleuve.type, label: "Fleuve de l'Oubli" },
+  E5: { type: TMRType.monts.type, label: "Monts Brûlants" },
+  F5: { type: TMRType.cite.type, label: "Cité de Panople" },
+  G5: { type: TMRType.pont.type, label: "Pont d’Ik" },
+  H5: { type: TMRType.desert.type, label: "Désert de Krane" },
+  I5: { type: TMRType.desolation.type, label: "Désolation de Toujours" },
+  J5: { type: TMRType.marais.type, label: "Marais de Jab" },
+  K5: { type: TMRType.fleuve.type, label: "Fleuve de l'Oubli" },
+  L5: { type: TMRType.collines.type, label: "Collines Suaves" },
+  M5: { type: TMRType.cite.type, label: "Cité Rimarde" },
+  A6: { type: TMRType.necropole.type, label: "Nécropole de Zniak" },
+  B6: { type: TMRType.foret.type, label: "Forêt de Bust" },
+  C6: { type: TMRType.cite.type, label: "Cité Pavois" },
+  D6: { type: TMRType.fleuve.type, label: "Fleuve de l'Oubli" },
+  E6: { type: TMRType.sanctuaire.type, label: "Sanctuaire de Plaine" },
+  F6: { type: TMRType.fleuve.type, label: "Fleuve de l'Oubli" },
+  G6: { type: TMRType.marais.type, label: "Marais Glutants" },
+  H6: { type: TMRType.monts.type, label: "Monts Gurdes" },
+  I6: { type: TMRType.necropole.type, label: "Nécropole de Xotar" },
+  J6: { type: TMRType.lac.type, label: "Lac d’Iaupe" },
+  K6: { type: TMRType.desolation.type, label: "Désolation de Poor" },
+  L6: { type: TMRType.foret.type, label: "Forêt Gueuse" },
+  M6: { type: TMRType.desolation.type, label: "Désolation de Presque" },
+  A7: { type: TMRType.plaines.type, label: "Plaines de l’Arc" },
+  B7: { type: TMRType.marais.type, label: "Marais Bluants" },
+  C7: { type: TMRType.fleuve.type, label: "Fleuve de l'Oubli" },
+  D7: { type: TMRType.plaines.type, label: "Plaines d’Affa" },
+  E7: { type: TMRType.foret.type, label: "Forêt de Glusks" },
+  F7: { type: TMRType.fleuve.type, label: "Fleuve de l'Oubli" },
+  G7: { type: TMRType.cite.type, label: "Cité de Terwa" },
+  H7: { type: TMRType.gouffre.type, label: "Gouffre de Kapfa" },
+  I7: { type: TMRType.plaines.type, label: "Plaines de Troo" },
+  J7: { type: TMRType.fleuve.type, label: "Fleuve de l'Oubli" },
+  K7: { type: TMRType.cite.type, label: "Cité de Kolix" },
+  L7: { type: TMRType.gouffre.type, label: "Gouffre d’Episophe" },
+  M7: { type: TMRType.desert.type, label: "Désert de Lave" },
+  A8: { type: TMRType.gouffre.type, label: "Gouffre de Shok" },
+  B8: { type: TMRType.fleuve.type, label: "Fleuve de l'Oubli" },
+  C8: { type: TMRType.foret.type, label: "Forêt Turmide" },
+  D8: { type: TMRType.cite.type, label: "Cité d’Olak" },
+  E8: { type: TMRType.plaines.type, label: "Plaines d’Iolise" },
+  F8: { type: TMRType.lac.type, label: "Lac des Chats" },
+  G8: { type: TMRType.plaines.type, label: "Plaines Sans Joie" },
+  H8: { type: TMRType.foret.type, label: "Forêt d’Ourf" },
+  I8: { type: TMRType.fleuve.type, label: "Fleuve de l'Oubli" },
+  J8: { type: TMRType.monts.type, label: "Monts Barask" },
+  K8: { type: TMRType.desert.type, label: "Désert de Fumée" },
+  L8: { type: TMRType.monts.type, label: "Monts Tavelés" },
+  M8: { type: TMRType.plaines.type, label: "Plaines Lavées" },
+  A9: { type: TMRType.collines.type, label: "Collines de Korrex" },
+  B9: { type: TMRType.lac.type, label: "Lac de Lucre" },
+  C9: { type: TMRType.monts.type, label: "Monts Tuméfiés" },
+  D9: { type: TMRType.pont.type, label: "Pont d’Orx" },
+  E9: { type: TMRType.fleuve.type, label: "Fleuve de l'Oubli" },
+  F9: { type: TMRType.plaines.type, label: "Plaines de Foe" },
+  G9: { type: TMRType.desolation.type, label: "Désolation de Sel" },
+  H9: { type: TMRType.collines.type, label: "Collines de Noirseul" },
+  I9: { type: TMRType.fleuve.type, label: "Fleuve de l'Oubli" },
+  J9: { type: TMRType.marais.type, label: "Marais Gronchants" },
+  K9: { type: TMRType.sanctuaire.type, label: "Sanctuaire Noir" },
+  L9: { type: TMRType.collines.type, label: "Collines Cornues" },
+  M9: { type: TMRType.necropole.type, label: "Nécropole de Zonar" },
+  A10: { type: TMRType.sanctuaire.type, label: "Sanctuaire d’Olis" },
+  B10: { type: TMRType.monts.type, label: "Monts Salés" },
+  C10: { type: TMRType.marais.type, label: "Marais de Dom" },
+  D10: { type: TMRType.fleuve.type, label: "Fleuve de l'Oubli" },
+  E10: { type: TMRType.gouffre.type, label: "Gouffre de Junk" },
+  F10: { type: TMRType.marais.type, label: "Marais Zultants" },
+  G10: { type: TMRType.cite.type, label: "Cité de Sergal" },
+  H10: { type: TMRType.plaines.type, label: "Plaines Noires" },
+  I10: { type: TMRType.lac.type, label: "Lac Wanito" },
+  J10: { type: TMRType.fleuve.type, label: "Fleuve de l'Oubli" },
+  K10: { type: TMRType.plaines.type, label: "Plaines Jaunes" },
+  L10: { type: TMRType.desert.type, label: "Désert de Nicrop" },
+  M10: { type: TMRType.foret.type, label: "Forêt de Jajou" },
+  A11: { type: TMRType.desolation.type, label: "Désolation d’Hier" },
+  B11: { type: TMRType.cite.type, label: "Cité de Brilz" },
+  C11: { type: TMRType.pont.type, label: "Pont de Roï" },
+  D11: { type: TMRType.desolation.type, label: "Désolation de Partout" },
+  E11: { type: TMRType.lac.type, label: "Lac de Glinster" },
+  F11: { type: TMRType.cite.type, label: "Cité de Noape" },
+  G11: { type: TMRType.fleuve.type, label: "Fleuve de l'Oubli" },
+  H11: { type: TMRType.fleuve.type, label: "Fleuve de l'Oubli" },
+  I11: { type: TMRType.pont.type, label: "Pont de Yalm" },
+  J11: { type: TMRType.plaines.type, label: "Plaines de Miltiar" },
+  K11: { type: TMRType.cite.type, label: "Cité Tonnerre" },
+  L11: { type: TMRType.collines.type, label: "Collines de Kol" },
+  M11: { type: TMRType.cite.type, label: "Cité Crapaud" },
+  A12: { type: TMRType.plaines.type, label: "Plaines Sages" },
+  B12: { type: TMRType.fleuve.type, label: "Fleuve de l'Oubli" },
+  C12: { type: TMRType.lac.type, label: "Lac de Fricassa" },
+  D12: { type: TMRType.collines.type, label: "Collines d’Huaï" },
+  E12: { type: TMRType.monts.type, label: "Monts Ajourés" },
+  F12: { type: TMRType.necropole.type, label: "Nécropole de Throat" },
+  G12: { type: TMRType.plaines.type, label: "Plaines de Lufmil" },
+  H12: { type: TMRType.collines.type, label: "Collines de Tooth" },
+  I12: { type: TMRType.gouffre.type, label: "Gouffre Abimeux" },
+  J12: { type: TMRType.cite.type, label: "Cité Folle" },
+  K12: { type: TMRType.desolation.type, label: "Désolation d’Amour" },
+  L12: { type: TMRType.plaines.type, label: "Plaines Venteuses" },
+  M12: { type: TMRType.collines.type, label: "Collines Révulsantes" },
+  A13: { type: TMRType.fleuve.type, label: "Fleuve de l'Oubli" },
+  B13: { type: TMRType.gouffre.type, label: "Gouffre des Litiges" },
+  C13: { type: TMRType.desert.type, label: "Désert de Neige" },
+  D13: { type: TMRType.cite.type, label: "Cité Sordide" },
+  E13: { type: TMRType.plaines.type, label: "Plaines de Xnez" },
+  F13: { type: TMRType.foret.type, label: "Forêt des Cris" },
+  G13: { type: TMRType.plaines.type, label: "Plaines Calcaires" },
+  H13: { type: TMRType.desolation.type, label: "Désolation de Rien" },
+  I13: { type: TMRType.monts.type, label: "Monts Bigleux" },
+  J13: { type: TMRType.gouffre.type, label: "Gouffre de Gromph" },
+  K13: { type: TMRType.foret.type, label: "Forêt de Kluth" },
+  L13: { type: TMRType.monts.type, label: "Monts Dormants" },
+  M13: { type: TMRType.plaines.type, label: "Plaines d’Anjou" },
+  A14: { type: TMRType.collines.type, label: "Collines de Stolis" },
+  B14: { type: TMRType.necropole.type, label: "Nécropole de Gorlo" },
+  C14: { type: TMRType.foret.type, label: "Forêt de Bissam" },
+  D14: { type: TMRType.sanctuaire.type, label: "Sanctuaire Plat" },
+  E14: { type: TMRType.monts.type, label: "Monts de Quath" },
+  F14: { type: TMRType.plaines.type, label: "Plaines Brisées" },
+  G14: { type: TMRType.desert.type, label: "Désert de Sek" },
+  H14: { type: TMRType.plaines.type, label: "Plaines Blanches" },
+  I14: { type: TMRType.cite.type, label: "Cité Destituée" },
+  J14: { type: TMRType.desert.type, label: "Désert de Sank" },
+  K14: { type: TMRType.necropole.type, label: "Nécropole d’Antinéar" },
+  L14: { type: TMRType.plaines.type, label: "Plaines de Jislith" },
+  M14: { type: TMRType.desolation.type, label: "Désolation d’Après" },
+  A15: { type: TMRType.cite.type, label: "Cité de Mielh" },
+  C15: { type: TMRType.plaines.type, label: "Plaines de Toué" },
+  E15: { type: TMRType.foret.type, label: "Forêt des Furies" },
+  G15: { type: TMRType.plaines.type, label: "Plaines des Soupirs" },
+  I15: { type: TMRType.monts.type, label: "Monts des Dragées" },
+  K15: { type: TMRType.collines.type, label: "Collines Pourpres" },
+  M15: { type: TMRType.cite.type, label: "Cité de Klana" }
 }

 /* -------------------------------------------- */
@ -251,13 +239,16 @@ const TMR_MOVE = {
 */
 export class TMRUtility {
  static init() {
+
    for (let coord in TMRMapping) {
-      const tmr = TMRMapping[coord];
-      tmr.coord = coord;
-      tmr.oddq = TMRUtility.coordTMRToOddq(coord);
-      tmr.genre = TMRType[tmr.type].genre;
+      const tmr = TMRMapping[coord]
+      tmr.coord = coord
+      tmr.genre = TMRType[tmr.type].genre
+      if (coord != FLEUVE_COORD) {
+        tmr.oddq = TMRUtility.coordTMRToOddq(coord)
      }
-    let tmrByType = Misc.classify(Object.values(TMRMapping));
+    }
+    let tmrByType = Misc.classify(Object.values(TMRMapping).filter(it => it.coord != FLEUVE_COORD))
    for (const [type, list] of Object.entries(tmrByType)) {
      TMRType[type].list = list;
    }
@ -265,14 +256,17 @@ export class TMRUtility {

  /* -------------------------------------------- */
  static verifyTMRCoord(coord) {
-    return Grammar.equalsInsensitive(coord, 'Fleuve') || TMRUtility.getTMR(coord);
+    return Grammar.equalsInsensitive(coord, FLEUVE_COORD) || TMRUtility.getTMR(coord);
  }

  /* -------------------------------------------- */
  static getTMR(coord) {
-    return coord == 'Fleuve' ? TMRMapping['D1'] : TMRMapping[coord];
+    return coord == FLEUVE_COORD ? TMRMapping['D1'] : TMRMapping[coord];
  }

+  static isFleuve(coord) {
+    return TMRMapping[coord]?.type == TMRType.fleuve.type
+  }
  static getTMRLabel(coord) {
    return TMRUtility.getTMR(coord)?.label ?? (coord + ": case inconnue");
  }
@ -290,18 +284,18 @@ export class TMRUtility {
  static findTMRLike(type, options = { inclusMauvaise: true }) {
    const choix = [...Object.values(TMRType)]
    if (options.inclusMauvaise) {
-      choix.push({ name: 'Mauvaise' });
+      choix.push({ name: 'Mauvaise', type: 'mauvaise'});
    }
-    const selection = Misc.findAllLike(type, choix).map(it => it.name);
+    const selection = Misc.findAllLike(type, choix)
    if (selection.length == 0) {
      ui.notifications.warn(`Un type de TMR doit être indiqué, '${type}' n'est pas trouvé dans ${choix}`);
-      return undefined;
+      return undefined
    }
    if (selection.length > 1) {
-      ui.notifications.warn(`Plusieurs types de TMR pourraient correspondre à '${type}': ${selection}`);
+      ui.notifications.warn(`Plusieurs types de TMR pourraient correspondre à '${type}': ${selection.map(it => it.name)}`);
      return undefined;
    }
-    return selection[0];
+    return selection[0]
  }

  static typeTmrName(type) {
@ -326,7 +320,7 @@ export class TMRUtility {
  /* -------------------------------------------- */
  static deplacement(coordOrig, moveName) {
    const tmrMove = TMR_MOVE[moveName];
-    if (! tmrMove) {
+    if (!tmrMove) {
      ui.notifications.error(`Le déplacement dans les TMR '${moveName}' est inconnu`)
      return coordOrig
    }
--- a/packs_src/competences-creatures/competencecreature_Attaque_18wcei5hlEInsBFO.yml
+++ b/packs_src/competences-creatures/competencecreature_Attaque_18wcei5hlEInsBFO.yml
@ -6,17 +6,16 @@ effects: []
 system:
  description: ''
  descriptionmj: ''
-  carac_value: 0
-  niveau: 0
-  default_diffLibre: 0
-  categorie: generale
+  carac_value: 10
+  niveau: 1
+  default_diffLibre: -2
+  categorie: melee
  categorie_parade: ''
  iscombat: true
  isnaturelle: true
  ispossession: false
  dommages: 0
  mortalite: mortel
-  carac-value: null
  isparade: false
 ownership:
  default: 0
--- a/packs_src/competences-creatures/competencecreature_Bouclier_Lourd_QGULMUoC9JXFze0r.yml
+++ b/packs_src/competences-creatures/competencecreature_Bouclier_Lourd_QGULMUoC9JXFze0r.yml
@ -6,17 +6,16 @@ effects: []
 system:
  description: ''
  descriptionmj: ''
-  carac_value: 0
-  niveau: 0
-  default_diffLibre: 0
-  categorie: ''
+  carac_value: 10
+  niveau: 1
+  default_diffLibre: -2
+  categorie: melee
  categorie_parade: boucliers
  iscombat: true
  isnaturelle: true
  ispossession: false
  dommages: 0
  mortalite: mortel
-  carac-value: null
  isparade: true
 ownership:
  default: 0
--- a/packs_src/competences-creatures/competencecreature_Bras_Galet_WsYnwR8GcOxfuCI0.yml
+++ b/packs_src/competences-creatures/competencecreature_Bras_Galet_WsYnwR8GcOxfuCI0.yml
@ -1,22 +1,21 @@
 _id: WsYnwR8GcOxfuCI0
 name: Bras-Galet
 type: competencecreature
-img: systems/foundryvtt-reve-de-dragon/icons/competence_course.webp
+img: systems/foundryvtt-reve-de-dragon/icons/compcreature-pierretenue.webp
 effects: []
 system:
  description: ''
  descriptionmj: ''
-  carac_value: 0
-  niveau: 0
-  default_diffLibre: 0
-  categorie: ''
+  carac_value: 10
+  niveau: 1
+  default_diffLibre: -2
+  categorie: melee
  categorie_parade: ''
  iscombat: true
  isnaturelle: true
  ispossession: false
  dommages: 1
  mortalite: mortel
-  carac-value: null
  isparade: false
 ownership:
  default: 0
--- a/packs_src/competences-creatures/competencecreature_Corps___Corps_c0I93Q53i4ZmxpyT.yml
+++ b/packs_src/competences-creatures/competencecreature_Corps___Corps_c0I93Q53i4ZmxpyT.yml
@ -6,10 +6,10 @@ effects: []
 system:
  description: ''
  descriptionmj: ''
-  carac_value: 0
-  niveau: 0
-  default_diffLibre: 0
-  categorie: ''
+  carac_value: 10
+  niveau: 1
+  default_diffLibre: -2
+  categorie: melee
  categorie_parade: sans-armes
  iscombat: true
  isnaturelle: true
--- a/packs_src/competences-creatures/competencecreature_Crocs_db8E8HwROw1ZcwRR.yml
+++ b/packs_src/competences-creatures/competencecreature_Crocs_db8E8HwROw1ZcwRR.yml
@ -6,17 +6,16 @@ effects: []
 system:
  description: ''
  descriptionmj: ''
-  carac_value: 0
-  niveau: 0
-  default_diffLibre: 0
-  categorie: ''
+  carac_value: 10
+  niveau: 1
+  default_diffLibre: -2
+  categorie: melee
  categorie_parade: ''
  iscombat: true
  isnaturelle: true
  ispossession: false
  dommages: 1
  mortalite: mortel
-  carac-value: null
  isparade: false
 ownership:
  default: 0
--- a/packs_src/competences-creatures/competencecreature_Dague_qilRzXpVaGceNmQp.yml
+++ b/packs_src/competences-creatures/competencecreature_Dague_qilRzXpVaGceNmQp.yml
@ -6,9 +6,9 @@ effects: []
 system:
  description: ''
  descriptionmj: ''
-  carac_value: 0
-  niveau: 0
-  default_diffLibre: 0
+  carac_value: 10
+  niveau: 1
+  default_diffLibre: -2
  categorie: melee
  categorie_parade: dagues
  iscombat: true
--- a/packs_src/competences-creatures/competencecreature_Ep_e_B_tarde_gPOQd9NI7AFH0whX.yml
+++ b/packs_src/competences-creatures/competencecreature_Ep_e_B_tarde_gPOQd9NI7AFH0whX.yml
@ -6,17 +6,16 @@ effects: []
 system:
  description: ''
  descriptionmj: ''
-  carac_value: 0
-  niveau: 0
-  default_diffLibre: 0
-  categorie: ''
+  carac_value: 10
+  niveau: 1
+  default_diffLibre: -2
+  categorie: melee
  categorie_parade: epees-lourdes
  iscombat: true
-  isnaturelle: true
+  isnaturelle: false
  ispossession: false
  dommages: 4
  mortalite: mortel
-  carac-value: null
  isparade: true
 ownership:
  default: 0
--- a/packs_src/competences-creatures/competencecreature_Esquive_CYpxxf1uTa78NWR9.yml
+++ b/packs_src/competences-creatures/competencecreature_Esquive_CYpxxf1uTa78NWR9.yml
@ -6,8 +6,8 @@ effects: []
 system:
  description: ''
  descriptionmj: ''
-  carac_value: 0
-  niveau: 0
+  carac_value: 10
+  niveau: 1
  default_diffLibre: 0
  categorie: generale
  categorie_parade: ''
--- a/packs_src/competences-creatures/competencecreature_Esquive_eau_Qrg3ADB9LOhGthaO.yml
+++ b/packs_src/competences-creatures/competencecreature_Esquive_eau_Qrg3ADB9LOhGthaO.yml
@ -0,0 +1,35 @@
+name: Esquive eau
+type: competencecreature
+img: systems/foundryvtt-reve-de-dragon/icons/competence_esquive.webp
+effects: []
+system:
+  description: ''
+  descriptionmj: ''
+  carac_value: 10
+  niveau: 1
+  default_diffLibre: 0
+  categorie: generale
+  categorie_parade: ''
+  iscombat: false
+  isnaturelle: true
+  ispossession: false
+  dommages: 0
+  mortalite: mortel
+  isparade: false
+ownership:
+  default: 0
+folder: null
+_stats:
+  compendiumSource: null
+  duplicateSource: null
+  coreVersion: '12.331'
+  systemId: foundryvtt-reve-de-dragon
+  systemVersion: 12.0.24
+  createdTime: 1733182927319
+  modifiedTime: 1733182927336
+  lastModifiedBy: Hp9ImM4o9YRTSdfu
+flags: {}
+_id: Qrg3ADB9LOhGthaO
+sort: 1300000
+_key: '!items!Qrg3ADB9LOhGthaO'
+
--- a/packs_src/competences-creatures/competencecreature_Esquive_sol_siPvW3hAMCJbrYvq.yml
+++ b/packs_src/competences-creatures/competencecreature_Esquive_sol_siPvW3hAMCJbrYvq.yml
@ -1,15 +1,14 @@
-_id: 0Ms9iKxqigNNpZEx
-name: Esquive
+name: Esquive sol
 type: competencecreature
 img: systems/foundryvtt-reve-de-dragon/icons/competence_esquive.webp
 effects: []
 system:
  description: ''
  descriptionmj: ''
-  carac_value: 0
-  niveau: 0
+  carac_value: 10
+  niveau: 1
  default_diffLibre: 0
-  categorie: ''
+  categorie: generale
  categorie_parade: ''
  iscombat: false
  isnaturelle: true
@ -20,10 +19,17 @@ system:
 ownership:
  default: 0
 folder: null
-sort: 0
 _stats:
-  systemId: foundryvtt-reve-de-dragon
-  systemVersion: 12.0.22
+  compendiumSource: null
+  duplicateSource: null
  coreVersion: '12.331'
-_key: '!items!0Ms9iKxqigNNpZEx'
+  systemId: foundryvtt-reve-de-dragon
+  systemVersion: 12.0.24
+  createdTime: 1733182930109
+  modifiedTime: 1733182930109
+  lastModifiedBy: Hp9ImM4o9YRTSdfu
+flags: {}
+_id: siPvW3hAMCJbrYvq
+sort: 0
+_key: '!items!siPvW3hAMCJbrYvq'

--- a/packs_src/competences-creatures/competencecreature_Esquive_vol_3ScoGTkQ0VBOpaX6.yml
+++ b/packs_src/competences-creatures/competencecreature_Esquive_vol_3ScoGTkQ0VBOpaX6.yml
@ -0,0 +1,35 @@
+name: Esquive vol
+type: competencecreature
+img: systems/foundryvtt-reve-de-dragon/icons/competence_esquive.webp
+effects: []
+system:
+  description: ''
+  descriptionmj: ''
+  carac_value: 10
+  niveau: 1
+  default_diffLibre: 0
+  categorie: generale
+  categorie_parade: ''
+  iscombat: false
+  isnaturelle: true
+  ispossession: false
+  dommages: 0
+  mortalite: mortel
+  isparade: false
+ownership:
+  default: 0
+folder: null
+_stats:
+  compendiumSource: null
+  duplicateSource: null
+  coreVersion: '12.331'
+  systemId: foundryvtt-reve-de-dragon
+  systemVersion: 12.0.24
+  createdTime: 1733182932133
+  modifiedTime: 1733182932133
+  lastModifiedBy: Hp9ImM4o9YRTSdfu
+flags: {}
+_id: 3ScoGTkQ0VBOpaX6
+sort: 0
+_key: '!items!3ScoGTkQ0VBOpaX6'
+
--- a/packs_src/competences-creatures/competencecreature_Parade_3Crwg8cx2JOb697T.yml
+++ b/packs_src/competences-creatures/competencecreature_Parade_3Crwg8cx2JOb697T.yml
@ -6,17 +6,16 @@ effects: []
 system:
  description: ''
  descriptionmj: ''
-  carac_value: 0
-  niveau: 0
-  default_diffLibre: 0
-  categorie: ''
-  categorie_parade: ''
-  iscombat: false
+  carac_value: 10
+  niveau: 1
+  default_diffLibre: -2
+  categorie: melee
+  categorie_parade: boucliers
+  iscombat: true
  isnaturelle: true
  ispossession: false
  dommages: 0
  mortalite: mortel
-  carac-value: null
  isparade: false
 ownership:
  default: 0
--- a/packs_src/competences-creatures/competencecreature_Possession_9u16zxXRurCtxuOX.yml
+++ b/packs_src/competences-creatures/competencecreature_Possession_9u16zxXRurCtxuOX.yml
@ -7,7 +7,7 @@ system:
  descriptionmj: ''
  carac_value: 14
  niveau: 2
-  default_diffLibre: 0
+  default_diffLibre: -4
  categorie: draconic
  categorie_parade: ''
  iscombat: true
--- a/packs_src/competences-creatures/competencecreature_Possession_duVgxI3Cdko0KzAj.yml
+++ b/packs_src/competences-creatures/competencecreature_Possession_duVgxI3Cdko0KzAj.yml
@ -1,29 +0,0 @@
-name: Possession
-type: competencecreature
-img: systems/foundryvtt-reve-de-dragon/icons/entites/possession.webp
-effects: []
-system:
-  description: <p>L'entit&eacute; tente de prendre possession du corps de sa victime.</p>
-  descriptionmj: ''
-  carac_value: 14
-  niveau: 2
-  default_diffLibre: 0
-  categorie: draconic
-  categorie_parade: ''
-  iscombat: true
-  isnaturelle: true
-  ispossession: true
-  dommages: 0
-  mortalite: mortel
-  isparade: false
-_id: duVgxI3Cdko0KzAj
-folder: null
-sort: 0
-ownership:
-  default: 0
-_stats:
-  systemId: foundryvtt-reve-de-dragon
-  systemVersion: 12.0.22
-  coreVersion: '12.331'
-_key: '!items!duVgxI3Cdko0KzAj'
-
--- a/packs_src/competences-creatures/competencecreature_Tentacules_D9cBJ3EJPYLnABiJ.yml
+++ b/packs_src/competences-creatures/competencecreature_Tentacules_D9cBJ3EJPYLnABiJ.yml
@ -6,10 +6,10 @@ effects: []
 system:
  description: <p>Attaque ou parade avec un tentacule.</p>
  descriptionmj: ''
-  carac_value: 0
-  niveau: 0
-  default_diffLibre: 0
-  categorie: ''
+  carac_value: 10
+  niveau: 1
+  default_diffLibre: -2
+  categorie: melee
  categorie_parade: boucliers
  iscombat: true
  isnaturelle: true
--- a/packs_src/competences-creatures/competencecreature_Tron_onneuse_h9ASt4vrvEgxfj7j.yml
+++ b/packs_src/competences-creatures/competencecreature_Tron_onneuse_h9ASt4vrvEgxfj7j.yml
@ -6,9 +6,9 @@ effects: []
 system:
  description: ''
  descriptionmj: ''
-  carac_value: 0
-  niveau: 0
-  default_diffLibre: 0
+  carac_value: 10
+  niveau: 1
+  default_diffLibre: -2
  categorie: melee
  categorie_parade: ''
  iscombat: true
--- a/packs_src/competences-entites/competencecreature_Bec_d5SZ09sFaG3cL2Rg.yml
+++ b/packs_src/competences-entites/competencecreature_Bec_d5SZ09sFaG3cL2Rg.yml
@ -1,29 +0,0 @@
-_id: d5SZ09sFaG3cL2Rg
-name: Bec
-type: competencecreature
-img: systems/foundryvtt-reve-de-dragon/icons/compcreature-beak.webp
-effects: []
-system:
-  description: ''
-  descriptionmj: ''
-  carac_value: 0
-  niveau: 0
-  default_diffLibre: 0
-  categorie: ''
-  categorie_parade: ''
-  iscombat: true
-  isnaturelle: true
-  ispossession: false
-  dommages: 0
-  mortalite: mortel
-  isparade: false
-ownership:
-  default: 0
-folder: null
-sort: 0
-_stats:
-  systemId: foundryvtt-reve-de-dragon
-  systemVersion: 12.0.22
-  coreVersion: '12.331'
-_key: '!items!d5SZ09sFaG3cL2Rg'
-
--- a/packs_src/competences-entites/competencecreature_Grande_morsure_lDZ3qUPKN35ob5TH.yml
+++ b/packs_src/competences-entites/competencecreature_Grande_morsure_lDZ3qUPKN35ob5TH.yml
@ -1,29 +0,0 @@
-_id: lDZ3qUPKN35ob5TH
-name: Grande morsure
-type: competencecreature
-img: systems/foundryvtt-reve-de-dragon/icons/compcreature-morsure.webp
-effects: []
-system:
-  description: ''
-  descriptionmj: ''
-  carac_value: 0
-  niveau: 0
-  default_diffLibre: 0
-  categorie: ''
-  categorie_parade: ''
-  iscombat: true
-  isnaturelle: true
-  ispossession: false
-  dommages: 2
-  mortalite: mortel
-  isparade: false
-ownership:
-  default: 0
-folder: null
-sort: 0
-_stats:
-  systemId: foundryvtt-reve-de-dragon
-  systemVersion: 12.0.22
-  coreVersion: '12.331'
-_key: '!items!lDZ3qUPKN35ob5TH'
-
--- a/packs_src/competences-entites/competencecreature_Grandes_griffes_6eWCVDYLXXO1Z48D.yml
+++ b/packs_src/competences-entites/competencecreature_Grandes_griffes_6eWCVDYLXXO1Z48D.yml
@ -1,29 +0,0 @@
-_id: 6eWCVDYLXXO1Z48D
-name: Grandes griffes
-type: competencecreature
-img: systems/foundryvtt-reve-de-dragon/icons/compcreature-griffes.webp
-effects: []
-system:
-  description: ''
-  descriptionmj: ''
-  carac_value: 0
-  niveau: 0
-  default_diffLibre: 0
-  categorie: ''
-  categorie_parade: sans-armes
-  iscombat: true
-  isnaturelle: true
-  ispossession: false
-  dommages: 2
-  mortalite: mortel
-  isparade: false
-ownership:
-  default: 0
-folder: null
-sort: 0
-_stats:
-  systemId: foundryvtt-reve-de-dragon
-  systemVersion: 12.0.22
-  coreVersion: '12.331'
-_key: '!items!6eWCVDYLXXO1Z48D'
-
--- a/packs_src/competences-entites/competencecreature_Griffes_9Y83OsQgeyR5oCdH.yml
+++ b/packs_src/competences-entites/competencecreature_Griffes_9Y83OsQgeyR5oCdH.yml
@ -1,30 +0,0 @@
-_id: 9Y83OsQgeyR5oCdH
-name: Griffes
-type: competencecreature
-img: systems/foundryvtt-reve-de-dragon/icons/compcreature-griffes.webp
-effects: []
-system:
-  description: ''
-  descriptionmj: ''
-  carac_value: 0
-  niveau: 0
-  default_diffLibre: 0
-  categorie: ''
-  categorie_parade: sans-armes
-  iscombat: true
-  isnaturelle: true
-  ispossession: false
-  dommages: 1
-  mortalite: mortel
-  carac-value: null
-  isparade: false
-ownership:
-  default: 0
-folder: null
-sort: 0
-_stats:
-  systemId: foundryvtt-reve-de-dragon
-  systemVersion: 12.0.22
-  coreVersion: '12.331'
-_key: '!items!9Y83OsQgeyR5oCdH'
-
--- a/packs_src/competences-entites/competencecreature_Morsure_j1xHCzfIeYKgXxoH.yml
+++ b/packs_src/competences-entites/competencecreature_Morsure_j1xHCzfIeYKgXxoH.yml
@ -1,29 +0,0 @@
-_id: j1xHCzfIeYKgXxoH
-name: Morsure
-type: competencecreature
-img: systems/foundryvtt-reve-de-dragon/icons/compcreature-morsure.webp
-effects: []
-system:
-  description: ''
-  descriptionmj: ''
-  carac_value: 0
-  niveau: 0
-  default_diffLibre: 0
-  categorie: ''
-  categorie_parade: ''
-  iscombat: true
-  isnaturelle: true
-  ispossession: false
-  dommages: 1
-  mortalite: mortel
-  isparade: false
-ownership:
-  default: 0
-folder: null
-sort: 0
-_stats:
-  systemId: foundryvtt-reve-de-dragon
-  systemVersion: 12.0.22
-  coreVersion: '12.331'
-_key: '!items!j1xHCzfIeYKgXxoH'
-
--- a/packs_src/competences-entites/competencecreature_Possession_wDHR5UHWq568lfGa.yml
+++ b/packs_src/competences-entites/competencecreature_Possession_wDHR5UHWq568lfGa.yml
@ -1,29 +0,0 @@
-name: Possession
-type: competencecreature
-img: systems/foundryvtt-reve-de-dragon/icons/entites/possession.webp
-effects: []
-system:
-  description: <p>L'entit&eacute; tente de prendre possession du corps de sa victime.</p>
-  descriptionmj: ''
-  carac_value: 14
-  niveau: 2
-  default_diffLibre: -4
-  categorie: melee
-  categorie_parade: ''
-  iscombat: true
-  isnaturelle: true
-  ispossession: true
-  dommages: 0
-  mortalite: mortel
-  isparade: false
-ownership:
-  default: 0
-folder: null
-sort: 0
-_id: wDHR5UHWq568lfGa
-_stats:
-  systemId: foundryvtt-reve-de-dragon
-  systemVersion: 12.0.22
-  coreVersion: '12.331'
-_key: '!items!wDHR5UHWq568lfGa'
-
--- a/system.json
+++ b/system.json
@ -2,8 +2,8 @@
  "id": "foundryvtt-reve-de-dragon",
  "title": "Rêve de Dragon",
  "version": "12.0.24",
-  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/releases/download/latest/rddsystem.zip",
-  "manifest": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/releases/download/latest/system.json",
+  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/releases/download/12.0.24/rddsystem.zip",
+  "manifest": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/releases/download//12.0.24/system.json",
  "changelog": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/raw/branch/v11/changelog.md",
  "compatibility": {
    "minimum": "11",
@ -53,7 +53,7 @@
      ]
    }
  },
-  "url": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/",
+  "url": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon",
  "license": "LICENSE.txt",
  "esmodules": [
    "module/rdd-main.js"
@ -115,19 +115,6 @@
      },
      "flags": {}
    },
-    {
-      "name": "competences-entites",
-      "label": "Compétences des Entités",
-      "system": "foundryvtt-reve-de-dragon",
-      "path": "packs/competences-entites",
-      "banner": "systems/foundryvtt-reve-de-dragon/styles/img/ui/compendium_banner.webp",
-      "type": "Item",
-      "ownership": {
-        "PLAYER": "NONE",
-        "ASSISTANT": "OWNER"
-      },
-      "flags": {}
-    },
    {
      "name": "sorts-oniros",
      "label": "Sorts d'Oniros",
@ -513,7 +500,9 @@
            "arts-et-divertissements",
            "meditations-et-ecrits",
            "recettes-alchimiques"
-          ]
+          ],
+          "color": null,
+          "folders": []
        },
        {
          "name": "Le Haut-rêve",
@ -530,7 +519,9 @@
            "ombres-de-thanatos",
            "souffles-de-dragon",
            "tetes-de-dragon-pour-haut-revants"
-          ]
+          ],
+          "color": null,
+          "folders": []
        },
        {
          "name": "Découverte du monde",
@ -541,9 +532,10 @@
            "entites",
            "faune-flore-mineraux",
            "competences-creatures",
-            "competences-entites",
            "maladies-et-poisons"
-          ]
+          ],
+          "color": null,
+          "folders": []
        },
        {
          "name": "Outils du Gardien",
@ -554,14 +546,16 @@
            "macros",
            "tarot-draconique",
            "extrait-poetique"
-          ]
+          ],
+          "color": null,
+          "folders": []
        }
-      ]
+      ],
+      "color": null
    }
  ],
  "socket": true,
  "grid": {
-    "distance": 1,
    "units": "m"
  },
  "primaryTokenAttribute": "sante.vie",
--- a/templates/actor/hr-sorts.html
+++ b/templates/actor/hr-sorts.html
@ -4,14 +4,15 @@
  {{#each (trier sorts) as |sort key|}}
  <li class="item list-item flexrow" data-item-id="{{sort._id}}" data-attribute="{{key}}"  data-tooltip="{{#if sort.system.isrituel}}Rituel{{else}}Sort{{/if}}: {{sort.name}}">
    <img class="sheet-competence-img" src="{{sort.img}}"/>
-    <span class="item-edit flex-grow-3">
-      <a data-item-id="{{sort._id}}">{{sort.name}}
-        - {{#if sort.system.caseTMRspeciale}}{{sort.system.caseTMRspeciale}}{{else}}{{upperFirst sort.system.caseTMR}}{{/if}}
-      </a>
+    <span class="flex-shrink">{{itemSort-shortDraconic sort.system.draconic}}</span>
+    <span class="item-edit flex-grow-3">{{sort.name}}{{#if sort.system.isrituel}} 
+      <i class="fa-regular fa-book-sparkles"></i>{{/if}}</span>
+    <span class="flex-grow-2">
+      {{#if sort.system.caseTMRspeciale}}{{sort.system.caseTMRspeciale}}{{else}}{{upperFirst sort.system.caseTMR}}{{/if}}
      </span>
-    <span class="flex-grow-0-5">{{#if sort.system.isrituel}}Rituel{{/if}}</span>
-    <span class="flex-grow-2">{{sort.system.draconic}}/{{sort.system.difficulte}}</span>
+    <span class="flex-grow-1">R{{itemSort-spaceIfText sort.system.difficulte}} r{{itemSort-spaceIfText sort.system.ptreve}}</span>
    <div class="item-controls flex-shrink">
+      <a class="item-edit" data-tooltip="Modifier"><i class="fas fa-edit"></i></a>
      <a class="item-delete" data-tooltip="Supprimer"><i class="fas fa-trash"></i></a>
      <a class="item-montrer" data-tooltip="Montrer"><i class="fas fa-comment"></i></a>
    </div>
--- a/templates/chat-compendium-table-roll.hbs
+++ b/templates/chat-compendium-table-roll.hbs
@ -1,6 +1,9 @@
 <h4>Tirage aléatoire: {{document.name}}</h4>
-<div>Tirage de {{typeName}} aléatoire depuis {{document.pack}}</div>
-<div>Jet {{roll.formula}} : {{roll.total}}{{percentages}}</div>
+<div>
+  Tirage de {{typeName}} aléatoire
+  {{#if options.showSource}} depuis {{document.pack}}{{/if}}
+</div>
+<div>Jet {{roll.formula}} : {{roll.total}}</div>
 <hr>
 <div>
  <img class="chat-icon" src="{{document.img}}" data-tooltip="{{document.name}}" />
--- a/templates/enum-draconic.html
+++ b/templates/enum-draconic.html
@ -1,6 +1,6 @@
 {{#each (trier @root.competences) as |competence key|}}
  {{#if (eq competence.system.categorie 'draconic')}}
-  <option value="{{competence.name}}">{{competence.name}}</option>
+  <option value="{{itemSort-shortDraconic competence.name}}">{{itemSort-shortDraconic competence.name}}</option>
  {{/if}}
 {{/each}}
 <option value="O/H/N/T">Oniros/Hypnos/Narcos/Thanatos</option>
--- a/templates/item-sort-sheet.html
+++ b/templates/item-sort-sheet.html
@ -37,7 +37,7 @@
    </div>
    <div class="form-group">
      <label for="system.isrituel">Rituel</label>
-      <input class="attribute-value" type="checkbox" name="system.isrituel"  {{#if system.isrituel}}checked{{/if}}/>
+      <input class="attribute-value" type="checkbox" name="system.isrituel"  {{#if system.isrituel}}checked{{/if}} />
    </div>
    <div class="form-group">
      <label for="system.duree">Durée</label>
@ -59,14 +59,23 @@
      <label for="system.xp">XP</label>
      <input class="attribute-value" type="text" name="system.xp" value="{{system.xp}}" data-dtype="Number"/>
    </div>
-    {{#each bonusCaseList as |bcData key|}}
+    <hr>
    <div class="form-group">
-      <label for="caseValue">Case/Bonus :</label>
-      <input class="attribute-value" type="text" name="caseValue" value="{{bcData.case}}" data-dtype="String"/>
-      <input class="attribute-value" type="text" name="bonusValue" value="{{bcData.bonus}}" data-dtype="Number"/>
+      <label class="flex-grow-2" for="caseTmrAdd">Nouveau bonus de case en</label>
+      <input class="flex-grow-0-5 attribute-value" type="text" name="caseTmrAdd" value="" maxlength="7" data-dtype="String"/>
+    </div>
+    {{#each bonusCaseList as |caseTmr key|}}
+    <div class="form-group">
+      <label style="flex-grow: 5;">Bonus en {{caseTmr-label caseTmr.case}} ({{caseTmr.case}})</label>
+      <input type="text" name="caseTmrCoord" value="{{caseTmr.case}}" data-dtype="String" hidden/>
+      
+      <input class="flex-grow-0-5 flex-group-right" type="number" name="caseTmrBonus" value="{{caseTmr.bonus}}" data-dtype="Number"/>
+      <a class="flex-shrink delete-bonus-case" 
+        data-deleteCoord="{{caseTmr.case}}"
+        data-tooltip="Supprimer le bonus de case"><i class="fas fa-trash"></i></a>
    </div>
    {{/each}}
-
+    <hr>
    {{>"systems/foundryvtt-reve-de-dragon/templates/partial-item-description.html"}}
  </section>
 </form>
Author	SHA1	Message	Date
LeRatierBretonnien	39ce66a26c	Setup auto-publish action Some checks failed Release Creation / build (release) Failing after 1m18s Details	2024-12-03 14:30:18 +01:00
LeRatierBretonnien	5265c013c1	Setup auto-publish action Some checks failed Release Creation / build (release) Failing after 15s Details	2024-12-03 14:15:43 +01:00
LeRatierBretonnien	a03cee5d60	Setup auto-publish action	2024-12-03 14:12:19 +01:00
LeRatierBretonnien	296c4babbb	Setup auto-publish action Some checks failed Release Creation / build (release) Has been cancelled Details	2024-12-03 14:09:32 +01:00
uberwald	d9c1804a08	Merge pull request 'Imports créatures et entités de cauchemar' (#727 ) from VincentVk/foundryvtt-reve-de-dragon:v11 into v11 Reviewed-on: #727	2024-12-03 07:31:22 +01:00
Vincent Vandemeulebrouck	fa375f8092	Améliorations parser - armure équipée - armes équipées - ajout des bonus de cases - dommages des créatures - ajout des esquives spéciales - fix édition feuilles de compétences créatures - déplacement des valeurs de test en fin de fichier	2024-12-03 00:50:39 +01:00
Vincent Vandemeulebrouck	a27e3894a0	Fix Import entités de cauchemar&créatures - utiliser les carac liées au type d'entités - fix: +dom&protection 0 ou négatifs - fix compétences (qui peuvent ne pas avoir d'init)	2024-12-02 22:21:43 +01:00
Vincent Vandemeulebrouck	ce8616c34e	Merge compétences créatures/entités Les deux compendiums n'avaient pas de raison d'être séparés	2024-12-02 22:21:43 +01:00
LeRatierBretonnien	bbfac286a6	Amelioration parser : heures, cheveux, yeux et sorts	2024-12-01 14:22:40 +01:00
uberwald	c0563efcfa	Merge pull request 'Amélioration du parser' (#725 ) from VincentVk/foundryvtt-reve-de-dragon:v11 into v11 Reviewed-on: #725	2024-12-01 12:38:50 +01:00
Vincent Vandemeulebrouck	c481bad81a	Amélioration du parser: - correction de la taille (ne prennait que avant le 'm' - ajout du sexe masculin/féminin - correction heure de naissance (support heure composée, articles) - support Unicode (nom, HN) - support groupes de compétences (saut, danse +1) - ignorer parenthèses dans ccompétences - armes avec compétences accentuées	2024-11-30 22:32:00 +01:00
uberwald	37c281b300	Merge pull request 'Version 12.0.24' (#724 ) from VincentVk/foundryvtt-reve-de-dragon:v11 into v11 All checks were successful Release Creation / build (release) Successful in 2m6s Details Reviewed-on: #724	2024-11-30 12:48:20 +01:00
Vincent Vandemeulebrouck	9b1a179a71	Corrections voies draconic - Utilisation du nom de voie (Oniros au lieu de Voie d'Oniros) - compatible anciens sorts - migration des objets existants - amélioration de l'affichage de la liste des sorts	2024-11-30 00:08:20 +01:00
Vincent Vandemeulebrouck	8be4c3343f	Fix: les tas de conteneurs	2024-11-30 00:07:52 +01:00
Vincent Vandemeulebrouck	6af5a85dc1	Corrections des tirages tmr/rencontres - on n'affiche plus le compendium d'origine des rencontres dans le tchat - utilisation de ChatMessageData#rolls (compat future v14) - le résultat d'un d100 n'a pas à afficher de signe '%' - utilistaion des types de TMR plutôt que les noms en minuscules	2024-11-30 00:07:52 +01:00
Vincent Vandemeulebrouck	c6d64e09d5	Fix: saisie des bonus de cases	2024-11-30 00:07:48 +01:00