Utilisation du nom du Nom du token

suite (pour les encaissements)

.gitea/workflows/release.yaml

@@ -1,74 +0,0 @@
-name: Release Creation
-
-on: 
-  release:
-    types: [published]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-    - run: echo "💡 The ${{ gitea.repository }} repository will cloned to the runner."
-    
-    #- uses: actions/checkout@v3
-    - uses: RouxAntoine/checkout@v3.5.4
-
-    # get part of the tag after the `v`
-    - name: Extract tag version number
-      id: get_version
-      uses: battila7/get-version-action@v2
-
-    # Substitute the Manifest and Download URLs in the module.json
-    - name: Substitute Manifest and Download Links For Versioned Ones
-      id: sub_manifest_link_version
-      uses: microsoft/variable-substitution@v1
-      with:
-        files: 'system.json'
-      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
-        download: https://www.uberwald.me/gitea/${{gitea.repository}}/releases/download/${{github.event.release.tag_name}}/rddsystem.zip
-    
-    - name: Set up Node.js
-      uses: actions/setup-node@v2
-      with:
-        node-version: '18'  # Use the node version your project requires
-
-    - name: Install dependencies
-      run: npm install
-      
-    - name: Build the compendiums
-      run: node ./tools/packCompendiumsToDist.mjs
-
-    # Create a zip file with all files required by the module to add to the release
-    - run: |
-         apt update -y
-         apt install -y zip
-
-    - run: zip -r ./rddsystem.zip system.json template.json README.md LICENSE.txt assets/ fonts/ icons lang/ module/ packs/ pic/ sounds/ styles/ templates/ 
-    
-    - name: setup go
-      uses: actions/setup-go@v3
-      with:
-        go-version: '>=1.20.1'
-    
-    - name: Use Go Action  
-      id: use-go-action
-      uses: https://gitea.com/actions/release-action@main
-      with:
-        files: |-
-          ./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'

changelog.md

@@ -1,57 +1,4 @@
 # 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
-  - cas de "User lacks permission to update" pour les blessures et les StatusEffects
-  - risque de message d'encaissement non affiché
-  - support de sorts à voies multiples
-- correction de compendiums
-  - résistance des armes mise à jour
-  - voies multiples pour las sorts de Lecture d'aura, Détection d'aura et Annulation de magie
-- améliorations "Scriptarium"
-  - recherche des compétences sans accents pour permettre les noms accentués (standard Scriptarium)
-  - affichage r1+ des sorts à coût variable dans la feuille simplifiée
-  - affichage de Corps à corps pour le combat à mains nues dans la feuille simplifiée
-  - dans les compendiums, les compétences Écriture et Épée ont une majuscule accentuée. Les Épée dans le compendium d'équipements référence le nom de compétence accentué.
-
-## 12.0.21 - La nomination d'Astrobazzarh
-- Les noms pour les messages dans le tchat sont maintenant ceux des tokens plutôt que ceux des acteurs
-- Fix: le choix des effets dans les options s'affiche correctement
-
-## 12.0.20 - Le tableau d'Astrobazzarh
-- Ecran d'accueil officiel Scriptarium
-
-## 12.0.19 - La témérité d'Astrobazzarh
-- Fix
-  - les défenses des créatures sont correctement filtrées
-  - le lancer d'initiative pour tous les personnages/PNJs fonctionne correctement
-  - les lieux et commerces n'ont pas d'initiative
-
-## 12.0.18 - A la barbe d'Astrobazzarh
-- Améliorations sur la feuille de PNJ simplifiée
-  - Ajout du portrait
-  - Ajout du corps à corps
-  - Affichage du niveau d'esquive
-  - Un clic sur l'initiative permet de lancer l'initiative
-  - les boutons +/- pour la vie, l'endurance et la fatigue changent si on est à la valeur normale
-  - un clic sur l'endurance effectue un jet d'endurance
-- Fix
-  - les achats des commerces sont de nouveau possibles
-  - la commande /astro fonctionne de nouveau
-  - le nombre d'utilisations d'items est réinitialisé à chaque round et fin de combat
-  - la difficulté de parade pour les armes à distances n'est plus indiquée
-  - les propositions d'armes de parade sont corrigées
-- Ajout d'un indicateur pour les armes de parade nécessitant une significative
-
 ## 12.0.16 - Le secret d'Astrobazzarh
 - Fix: les jets envoyés messages uniquement au MJ ne sont plus envoyés à tous les autres joueurs (et dupliqués)
 - Les noms affichés dans les automatisations de combat sont maintenant ceux des tokens plutôt que ceux des acteurs

dev-notes.md

@@ -0,0 +1,61 @@
+# Actor notes
+
+> The Actor#getData default implementation gives you the following for use in sheet rendering:
+
+```
+  actor -> the Actor instance
+  data -> a cloned copy of Actor#data
+  items -> a cloned copy of Actor#data#items
+  effects -> a cloned copy of Actor#data#effects
+```
+
+> if all you need is a safe copy of `Actor#data`, you'll be much better off by simply defining your own function and avoiding all the wasted work that the parent class does which will slow down your sheet
+```js
+getData(options) {
+  return {
+    data: foundry.utils.deepClone(this.object.data)
+  }
+}
+```
+
+who knows, maybe you don't even need to copy your actor data, skip the copy and it's even faster:
+```js
+getData(options) {
+  return {
+    data: this.object.data
+  }
+}
+```
+
+
+Atropos19/02/2021
+There are two recommended ways to create owned items in 0.8.0:
+```js
+await Item.create(itemData, {parent: actor});
+await actor.createEmbeddedDocuments("Item", itemDataArray);
+```
+
+
+You can update an embedded item in one of two ways:
+```js
+//Method 1:
+
+const item = actor.items.get(itemId);
+item.update(data);
+
+//Method 2:
+actor.updateEmbeddedDocuments("Item", [{_id: itemId, ...}]);
+```
+
+
+I noticed adding an ActiveEffect to an actor in code using
+
+```js
+this.createEmbeddedDocuments('ActiveEffect', [effet], options);
+this.applyActiveEffects();
+```
+
+Atropos — Aujourd’hui à 14:42
+Two notes on this:
+1. You don't actually need to call this.applyActiveEffects() because this will happen automatically whenever an effect is created/updated/deleted
+2. If you want to suppress the automatic display of the sheet for the newly created document, you can pass options.renderSheet = false as part of your options object

module/actor-sheet.js

@@ -80,7 +80,7 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
       const actor = this.actor;
       formData.combat = foundry.utils.duplicate(formData.armes);
       RdDItemArme.computeNiveauArmes(formData.combat, formData.competences);
-      formData.combat.push(RdDItemArme.corpsACorps(actor));
+      formData.combat.push(RdDItemArme.mainsNues(actor));
       formData.combat.push(RdDItemArme.empoignade(actor));
 
       formData.esquives = this.actor.getCompetences("Esquive");
@@ -224,7 +224,7 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
     this.html.find('.roll-arme').click(async event => this.actor.rollArme(foundry.utils.duplicate(this._getEventArmeCombat(event)), 'competence'))
 
     // Initiative pour l'arme
-    this.html.find('.roll-init-arme').click(async event => {
+    this.html.find('.arme-initiative a').click(async event => {
       let combatant = game.combat.combatants.find(c => c.actor.id == this.actor.id)
       if (combatant) {
         RdDCombatManager.rollInitiativeAction(combatant._id, this._getEventArmeCombat(event));

module/actor.js

@@ -36,8 +36,6 @@ import { ITEM_TYPES } from "./item.js";
 import { RdDBaseActorSang } from "./actor/base-actor-sang.js";
 import { RdDCoeur } from "./coeur/rdd-coeur.js";
 import { DialogChoixXpCarac } from "./dialog-choix-xp-carac.js";
-import { RdDItemArme } from "./item-arme.js";
-import { RdDCombatManager } from "./rdd-combat.js";
 
 export const MAINS_DIRECTRICES = ['Droitier', 'Gaucher', 'Ambidextre']
 
@@ -132,23 +130,6 @@ export class RdDActor extends RdDBaseActorSang {
       .reduce(Misc.sum(), 0);
   }
 
-  listActionsCombat() {
-    // Recupération des armes
-    const actions = RdDCombatManager.listActionsArmes(
-      this.itemTypes[ITEM_TYPES.arme]
-        .filter(it => RdDItemArme.isAttaque(it))
-        .concat(RdDItemArme.corpsACorps(this))
-        .concat(RdDItemArme.empoignade(this))
-      ,
-      this.itemTypes[ITEM_TYPES.competence],
-      this.system.carac)
-
-    if (this.system.attributs.hautrevant.value) {
-      actions.push({ name: "Draconic", action: 'haut-reve', system: { initOnly: true, competence: "Draconic" } });
-    }
-    return actions
-  }
-
   /* -------------------------------------------- */
   getTache(id) { return this.findItemLike(id, 'tache') }
   getMeditation(id) { return this.findItemLike(id, 'meditation') }
@@ -181,7 +162,7 @@ export class RdDActor extends RdDBaseActorSang {
         whisper: ChatUtility.getOwners(this),
         content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-potionenchantee-chateaudormant.html`, {
           pr: nouveauReve,
-          alias: this.getAlias(),
+          alias: this.name,
           potionName: it.name,
           potionImg: it.img
         })
@@ -1341,7 +1322,7 @@ export class RdDActor extends RdDBaseActorSang {
     const etat = this.getEtatGeneral({ ethylisme: true });
     const nbDoses = Number(this.system.compteurs.ethylisme.nb_doses || 0);
     const ethylismeData = {
-      alias: this.getAlias(),
+      alias: this.name,
       actor: this,
       vie: this.system.sante.vie.max,
       alcool: alcool,
@@ -1426,7 +1407,7 @@ export class RdDActor extends RdDBaseActorSang {
     const perteDissolution = Math.max(0, Math.min(dissolution, conversion));
 
     let stressRollData = {
-      alias: this.getAlias(),
+      alias: this.name,
       selectedCarac: this.system.carac.reve,
       rolled: stressRoll,
       stress: fromStress,
@@ -1517,7 +1498,7 @@ export class RdDActor extends RdDBaseActorSang {
         carac.value = niveauSuivant;
 
         let checkXp = {
-          alias: this.getAlias(),
+          alias: this.name,
           carac: caracName,
           value: niveauSuivant,
           xp: carac.xp
@@ -1547,7 +1528,7 @@ export class RdDActor extends RdDBaseActorSang {
         newCompData.system.niveau += 1;
         newCompData.system.xp = newXP;
         let checkXp = {
-          alias: this.getAlias(),
+          alias: this.name,
           competence: newCompData.name,
           niveau: newCompData.system.niveau,
           xp: newCompData.system.xp,
@@ -1567,7 +1548,7 @@ export class RdDActor extends RdDBaseActorSang {
 
   /* -------------------------------------------- */
   async appliquerAjoutExperience(rollData, hideChatMessage = 'show') {
-    if (!Misc.isFirstConnectedGM()) {
+    if (!Misc.isFirstConnectedGM()){
       return
     }
     hideChatMessage = hideChatMessage == 'hide' || (Misc.isRollModeHiddenToPlayer() && !game.user.isGM)
@@ -1784,7 +1765,7 @@ export class RdDActor extends RdDBaseActorSang {
     }
     const competence = this.getCompetence(compName);
     let rollData = {
-      alias: this.getAlias(),
+      alias: this.name,
       caracValue: Number(carac.value),
       selectedCarac: carac,
       competence: competence,
@@ -1857,7 +1838,7 @@ export class RdDActor extends RdDBaseActorSang {
       label: 'Jet ' + Grammar.apostrophe('de', competence.name),
       template: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-competence.html',
       rollData: {
-        alias: this.getAlias(),
+        alias: this.name,
         carac: this.system.carac,
         selectedCarac: this.getCaracByName(caracName),
         selectedCaracName: caracName,
@@ -2634,7 +2615,7 @@ export class RdDActor extends RdDBaseActorSang {
 
   /* -------------------------------------------- */
   async resetItemUse() {
-    await this.unsetFlag(SYSTEM_RDD, 'itemUse');
+    await this.setFlag(SYSTEM_RDD, 'itemUse', {});
   }
 
   /* -------------------------------------------- */
@@ -2930,7 +2911,7 @@ export class RdDActor extends RdDBaseActorSang {
 
     let newQuantite = herbeData.system.quantite - herbeData.nbBrins;
     let messageData = {
-      alias: this.getAlias(),
+      alias: this.name,
       nbBrinsReste: newQuantite,
       potion: newPotion,
       herbe: herbeData
@@ -3017,16 +2998,15 @@ 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)
   }
 
   /* -------------------------------------------- */
@@ -3087,7 +3067,7 @@ export class RdDActor extends RdDBaseActorSang {
     incarnation.name = 'Réincarnation de ' + incarnation.name
     incarnation.system = {
       carac: foundry.utils.duplicate(this.system.carac),
-      heure: RdDTimestamp.defHeure(await RdDDice.rollHeure({ rollMode: "selfroll", showDice: SHOW_DICE })).key,
+      heure: RdDTimestamp.defHeure(await RdDDice.rollHeure( { rollMode: "selfroll", showDice: SHOW_DICE })).key,
       age: 18,
       biographie: '',
       notes: '',

module/actor/base-actor-reve.js

@@ -15,7 +15,7 @@ import { StatusEffects } from "../settings/status-effects.js";
 import { ITEM_TYPES } from "../item.js";
 import { Targets } from "../targets.js";
 import { RdDPossession } from "../rdd-possession.js";
-import { RdDCombat, RdDCombatManager } from "../rdd-combat.js";
+import { RdDCombat } from "../rdd-combat.js";
 import { RdDConfirm } from "../rdd-confirm.js";
 import { ENTITE_INCARNE, SHOW_DICE, SYSTEM_RDD } from "../constants.js";
 import { RdDItemArme } from "../item-arme.js";
@@ -78,27 +78,8 @@ export class RdDBaseActorReve extends RdDBaseActor {
   }
   async jetEndurance(resteEndurance = undefined) { return { jetEndurance: 0, sonne: false } }
   isDead() { return false }
-  isSonne() { return false }
   blessuresASoigner() { return [] }
   getEtatGeneral(options = { ethylisme: false }) { return 0 }
-  isActorCombat() { return true }
-
-  getCaracInit(competence) {
-    if (!competence){
-      return 0
-    }
-    if (competence.type == ITEM_TYPES.competencecreature) {
-      return competence.system.carac_value
-    }
-    return this.system.carac[competence.system.defaut_carac].value;
-  }
-  listActionsCombat() {
-    return this.itemTypes[ITEM_TYPES.competencecreature]
-      .filter(it => RdDItemCompetenceCreature.isAttaque(it))
-      .map(it => RdDItemCompetenceCreature.armeCreature(it))
-      .filter(it => it != undefined);
-  }
-
 
   async computeArmure(attackerRoll) { return this.getProtectionNaturelle() }
   async remiseANeuf() { }
@@ -117,7 +98,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
     for (let effect of this.getEffects()) {
       if (effect.duration.type !== 'none' && (effect.duration.remaining <= 0 || options.terminer)) {
         await effect.delete();
-        ChatMessage.create({ content: `${this.getAlias()} n'est plus ${Misc.lowerFirst(game.i18n.localize(effect.system.label))} !` });
+        ChatMessage.create({ content: `${this.name} n'est plus ${Misc.lowerFirst(game.i18n.localize(effect.system.label))} !` });
       }
     }
   }
@@ -172,6 +153,9 @@ export class RdDBaseActorReve extends RdDBaseActor {
   getPossession(possessionId) {
     return this.itemTypes[ITEM_TYPES.possession].find(it => it.system.possessionid == possessionId);
   }
+  getPossessions() {
+    return this.itemTypes[ITEM_TYPES.possession];
+  }
   getEmpoignades() {
     return this.itemTypes[ITEM_TYPES.empoignade];
   }
@@ -288,7 +272,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
 
     await this.openRollDialog({
       name: `jet-${this.id}`,
-      label: `Jet de ${this.getAlias()}`,
+      label: `Jet de ${this.name}`,
       template: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll.html',
       rollData: {
         carac: carac,
@@ -384,7 +368,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
   rollArme(arme, categorieArme, token) {
     token = token ?? RdDUtility.getSelectedToken(this)
     const compToUse = this.$getCompetenceArme(arme, categorieArme)
-    if (!RdDItemArme.isUtilisable(arme)) {
+    if (!RdDItemArme.isArmeUtilisable(arme)) {
       ui.notifications.warn(`Arme inutilisable: ${arme.name} a une résistance de 0 ou moins`)
       return
     }
@@ -421,7 +405,12 @@ export class RdDBaseActorReve extends RdDBaseActor {
     return RdDItemArme.getCompetenceArme(arme, competenceName)
   }
 
-  verifierForceMin(item) { }
+  verifierForceMin(item) {
+  }
+  /* -------------------------------------------- */
+  async resetItemUse() { }
+  async incDecItemUse(itemId, inc = 1) { }
+  getItemUse(itemId) { return 0; }
 
   /* -------------------------------------------- */
   async encaisser() { await RdDEncaisser.encaisser(this) }
@@ -463,10 +452,10 @@ export class RdDBaseActorReve extends RdDBaseActor {
 
   async $afficherEncaissement(encaissement, show, defenderToken) {
     foundry.utils.mergeObject(encaissement, {
-      alias: defenderToken?.name ?? this.getAlias(),
+      alias: defenderToken?.name ?? this.name,
       hasPlayerOwner: this.hasPlayerOwner,
       show: show ?? {}
-    }, { overwrite: false });
+    }, {overwrite: false});
 
     await ChatUtility.createChatWithRollMode(
       {
@@ -496,7 +485,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
     }
     const rolled = await RdDResolutionTable.roll(this.getReveActuel(), - Number(entite.system.carac.niveau.value));
     const rollData = {
-      alias: this.getAlias(),
+      alias: this.name,
       rolled: rolled,
       entite: entite.name,
       selectedCarac: this.system.carac.reve
@@ -516,7 +505,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
   isEntiteAccordee(attacker) { return true }
 
   async setEntiteReveAccordee(actor) {
-    ui.notifications.error("Impossible de s'accorder à " + this.getAlias() + ": ce n'est pas une entité incarnée");
+    ui.notifications.error("Impossible de s'accorder à " + this.name + ": ce n'est pas une entité incarnée");
   }
 
 }

module/actor/base-actor-sang.js

@@ -191,7 +191,7 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
       encaissement.mort = true;
       ChatMessage.create({
         content: `<img class="chat-icon" src="icons/svg/skull.svg" data-tooltip="charge" />
-        <strong>${this.getAlias()} vient de succomber à une seconde blessure critique ! Que les Dragons gardent son Archétype en paix !</strong>`
+        <strong>${this.name} vient de succomber à une seconde blessure critique ! Que les Dragons gardent son Archétype en paix !</strong>`
       });
     }
     return blessure;
@@ -218,7 +218,7 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
   async jetDeVie() {
     if (this.isDead()) {
       ChatMessage.create({
-        content: `Jet de Vie: ${this.getAlias()} est déjà mort, ce n'est pas la peine d'en rajouter !!!!!`,
+        content: `Jet de Vie: ${this.name} est déjà mort, ce n'est pas la peine d'en rajouter !!!!!`,
         whisper: ChatUtility.getOwners(this)
       })
       return
@@ -242,7 +242,7 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
       await this.santeIncDec("vie", -perte);
     }
     if (this.isDead()) {
-      msgText += `<br><strong>${this.getAlias()} est mort !!!!</strong>`;
+      msgText += `<br><strong>${this.name} est mort !!!!</strong>`;
     }
     else if (prochainJet > 0) {
       msgText += `<br>Prochain jet de vie dans ${prochainJet} ${isCritique ? 'round' : 'minute'}${prochainJet > 1 ? 's' : ''} ${isCritique ? '(état critique)' : '(état grave)'}`
@@ -273,14 +273,14 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
 
   async setSonne(sonne = true) {
     if (!game.combat && sonne) {
-      ui.notifications.info(`${this.getAlias()} est hors combat, il ne reste donc pas sonné`);
+      ui.notifications.info(`${this.name} est hors combat, il ne reste donc pas sonné`);
       return;
     }
-    await this.setEffect(STATUSES.StatusStunned, sonne)
+    await this.setEffect(STATUSES.StatusStunned, sonne);
   }
 
-  isSonne() {
-    return this.getEffect(STATUSES.StatusStunned)
+  getSonne() {
+    return this.getEffect(STATUSES.StatusStunned);
   }
 
   isEffectAllowed(effectId) { return true }

module/actor/base-actor.js

@@ -78,13 +78,6 @@ export class RdDBaseActor extends Actor {
     return game.actors.get(actorId)
   }
 
-  getAlias() {
-    if (this.token?.name != null && this.token != this.prototypeToken) {
-      return this.token.name
-    }
-    return this.name
-  }
-
   isPersonnageJoueur() { return false }
 
   static extractActorMin = (actor) => { return { id: actor?.id, type: actor?.type, name: actor?.name, img: actor?.img }; };
@@ -212,21 +205,12 @@ export class RdDBaseActor extends Actor {
 
   /* -------------------------------------------- */
   async onPreUpdateItem(item, change, options, id) { }
-  async onCreateItem(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 onCreateItem(item, options, id) { }
+
+  async onDeleteItem(item, options, id) { }
+
+  async onUpdateActor(update, options, actorId) { }
 
   async onTimeChanging(oldTimestamp, newTimestamp) {
     this.items.filter(it => it.isFinPeriode(oldTimestamp, newTimestamp))
@@ -333,7 +317,7 @@ export class RdDBaseActor extends Actor {
 
       RdDAudio.PlayContextAudio("argent"); // Petit son
       ChatMessage.create({
-        whisper: ChatUtility.getOwners(this),
+        whisper: ChatUtility.getOwners(this.name),
         content: `Vous avez reçu <strong>${sols} Sols</strong> ${fromActor ? " de " + fromActor.name : ''}, qui ont été ajoutés à votre argent.`
       });
     }
@@ -386,7 +370,7 @@ export class RdDBaseActor extends Actor {
     chatAchatItem.quantiteTotal = quantite;
     ChatMessage.create({
       user: achat.userId,
-      speaker: { alias: (acheteur ?? vendeur).getAlias() },
+      speaker: { alias: (acheteur ?? vendeur).name },
       whisper: ChatUtility.getOwners(this),
       content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-achat-item.html', chatAchatItem)
     });
@@ -702,7 +686,7 @@ export class RdDBaseActor extends Actor {
       type: this.type,
       img: this.img,
       pack: this.pack,
-      name: this.getAlias(),
+      name: this.name,
       system: { description: this.system.description }
     }
     renderTemplate('systems/foundryvtt-reve-de-dragon/templates/post-actor.html', chatData)
@@ -710,10 +694,10 @@ export class RdDBaseActor extends Actor {
   }
 
   actionImpossible(action) {
-    ui.notifications.info(`${this.getAlias()} ne peut pas faire cette action: ${action}`)
+    ui.notifications.info(`${this.name} ne peut pas faire cette action: ${action}`)
 
   }
-
+  async roll() { this.actionImpossible("jet de caractéristiques") }
   async jetEthylisme() { this.actionImpossible("jet d'éthylisme") }
   async rollAppelChance() { this.actionImpossible("appel à la chance") }
   async jetDeMoral() { this.actionImpossible("jet de moral") }
@@ -724,24 +708,5 @@ export class RdDBaseActor extends Actor {
     }
     return undefined
   }
-  async resetItemUse() { }
-  async incDecItemUse(itemId, inc = 1) { }
-  getItemUse(itemId) { return 0; }
-  async finDeRound(options = { terminer: false }) { }
-  isActorCombat() { return false }
-  getCaracInit(competence) { return 0 }
-  listActionsCombat() { return [] }
-  listActionsPossessions() {
-    return this.itemTypes[ITEM_TYPES.possession]
-      .map(p => {
-        return {
-          name: p.name,
-          action: 'possession',
-          system: {
-            competence: p.name,
-            possessionid: p.system.possessionid,
-          }
-        }
-      })
-  }
+
 }

module/actor/commerce-sheet.js

@@ -73,7 +73,7 @@ export class RdDCommerceSheet extends RdDBaseActorSheet {
     }
     const disponible = this.actor.getQuantiteDisponible(item)
     if (disponible == 0) {
-      ui.notifications.warn(`${this.getAlias()} n'a plus de ${item.name} en vente`);
+      ui.notifications.warn(`${this.name} n'a plus de ${item.name} en vente`);
       return;
     }
 

module/actor/export-scriptarium/mapping.js

@@ -84,7 +84,7 @@ const MAPPING_BASE = [
   { column: "malus_armure", getter: (actor, context) => Mapping.getMalusArmure(actor, context) },
   { column: "reve_actuel", rollClass: 'roll-reve-actuel', colName: 'Rêve actuel', getter: (actor, context) => actor.system.reve.reve.value },
   { column: "vie_actuel", rollClass: 'jet-vie', getter: (actor, context) => actor.system.sante.vie.value },
-  { column: "endurance_actuel", rollClass: 'jet-endurance', getter: (actor, context) => actor.system.sante.endurance.value },
+  { column: "endurance_actuel", rollClass: 'jet-vie', getter: (actor, context) => actor.system.sante.endurance.value },
   { column: "esquive", getter: (actor, context) => Mapping.getEsquive(context) },
   { column: "esquive_armure", getter: (actor, context) => Mapping.getEsquiveArmure(context) },
   { column: "competences", getter: (actor, context) => Mapping.getCompetences(actor, CATEGORIES_COMPETENCES) },
@@ -140,53 +140,45 @@ export class Mapping {
 
   static prepareArmes(actor) {
     const armes = actor.items.filter(it => it.type == ITEM_TYPES.arme)
-    armes.push(RdDItemArme.corpsACorps(actor));
-    armes.push(RdDItemArme.empoignade(actor));
-    return armes.map(arme => [
-      arme.system.unemain ? Mapping.prepareArme(actor, arme, 'unemain') : undefined,
-      arme.system.deuxmains ? Mapping.prepareArme(actor, arme, 'deuxmains') : undefined,
-      !(arme.system.unemain || arme.system.deuxmains) ? Mapping.prepareArme(actor, arme, 'competence') : undefined,
-      arme.system.lancer != "" ? Mapping.prepareArme(actor, arme, 'lancer') : undefined,
-      arme.system.tir != "" ? Mapping.prepareArme(actor, arme, 'tir') : undefined]
-      .filter(it => it != undefined))
-      .reduce((a, b) => a.concat(b), [])
+    return armes.map(arme =>
+      [
+        arme.system.unemain ? Mapping.prepareArme(actor, arme, 'unemain') : undefined,
+        arme.system.deuxmains ? Mapping.prepareArme(actor, arme, 'deuxmains') : undefined,
+        !(arme.system.unemain || arme.system.deuxmains) ? Mapping.prepareArme(actor, arme, 'competence') : undefined,
+        arme.system.lancer != "" ? Mapping.prepareArme(actor, arme, 'lancer') : undefined,
+        arme.system.tir != "" ? Mapping.prepareArme(actor, arme, 'tir') : undefined
+      ]
+        .filter(it => it != undefined)
+    ).reduce((a, b) => a.concat(b), [])
   }
 
   static prepareArme(actor, arme, maniement) {
-    const nameCompetenceArme = RdDItemArme.getCompetenceArme(arme, maniement)
-    const competence = actor.getCompetence(nameCompetenceArme)
+    const nameCompArme = RdDItemArme.getCompetenceArme(arme, maniement)
+    const competence = actor.getCompetence(nameCompArme)
     if (RdDItemCompetence.isNiveauBase(competence)) {
       return undefined
     }
+    const dmgArme = RdDItemArme.dommagesReels(arme, maniement)
+    const dommages = dmgArme + RdDBonus.bonusDmg(actor, maniement, dmgArme)
     const categorie = Mapping.complementCategorie(arme, maniement)
-    const dommages = Mapping.dommagesArme(actor, arme, maniement)
     return {
       name: arme.name + categorie,
       niveau: Misc.toSignedString(competence.system.niveau),
       init: Mapping.calculBaseInit(actor, competence.system.categorie) + competence.system.niveau,
-      dommages: dommages,
+      dommages: Misc.toSignedString(dommages),
       competence: competence,
       arme: arme
     }
   }
-  static dommagesArme(actor, arme, maniement){
-    const dmgArme = RdDItemArme.dommagesReels(arme, maniement)
-    const dommages = Misc.toSignedString(dmgArme + RdDBonus.bonusDmg(actor, maniement, dmgArme))
-    switch(arme.system.mortalite) {
-      case 'non-mortel': return `(${dommages})`
-      case 'empoignade': return '-'
-    }
-    return dommages
-  }
 
   static complementCategorie(arme, maniement) {
     switch (maniement) {
-      case 'unemain': return (arme.system.deuxmains) ? ' 1 main' : (arme.system.lancer || arme.system.tir) ? ' mêlée' : ''
-      case 'deuxmains': return (arme.system.unemain) ? ' 2 mains' : (arme.system.lancer || arme.system.tir) ? ' mêlée' : ''
+      case 'unemain': return (arme.system.deuxmains) ? ' 1 main' : (arme.system.lancer||arme.system.tir) ? ' mêlée': '' 
+      case 'deuxmains': return (arme.system.unemain) ? ' 2 mains' : (arme.system.lancer||arme.system.tir) ? ' mêlée': '' 
       case 'lancer': return (arme.system.unemain || arme.system.deuxmains || arme.system.tir) ? ' jet' : ''
       case 'tir': return (arme.system.unemain || arme.system.deuxmains || arme.system.lancer) ? ' tir' : ''
     }
-    return ''
+    return '' 
   }
 
   static calculBaseInit(actor, categorie) {
@@ -238,7 +230,7 @@ export class Mapping {
 
   static prepareSorts(actor) {
     const codeVoies = Mapping.getCompetencesCategorie(actor, CATEGORIES_DRACONIC)
-      .map(it => RdDItemSort.getCodeVoie(it.name))
+      .map(it => RdDItemSort.getVoieCode(it))
 
     return actor.itemTypes[ITEM_TYPES.sort].map(it => Mapping.prepareSort(it, codeVoies))
       .sort(Misc.ascending(it => `${it.voie} : ${it.description}`))
@@ -246,7 +238,7 @@ export class Mapping {
 
   static prepareSort(sort, voies) {
     return {
-      voie: RdDItemSort.getCode(sort, voies),
+      voie: RdDItemSort.getCodeDraconic(sort, voies),
       description: Mapping.descriptionSort(sort),
       bonus: Mapping.bonusCase(sort)
     }
@@ -255,13 +247,21 @@ 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 coutReve = 'r' + RdDItemSort.addSpaceToNonNumeric(sort.system.ptreve)
-    const diff = 'R' + RdDItemSort.addSpaceToNonNumeric(sort.system.difficulte)
-    return `${sort.name}${ptSeuil} (${caseTMR}) ${diff} ${coutReve}`
+    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) ? value : ' ' + Mapping.toVar(value)
+  }
+
+  static toVar(value) {
+    return value.replace('variable', 'var')
   }
 
   static bonusCase(sort) {
-    const list = RdDItemSort.stringToBonuscases(sort.system.bonuscase).sort(Misc.descending(it => it.bonus))
+    const list = RdDItemSort.bonuscaseStringToList(sort.system.bonuscase).sort(Misc.descending(it => it.bonus))
     if (list.length > 0) {
       const bonus = list[0]
       return `+${bonus.bonus}% en ${bonus.case}`
@@ -327,8 +327,7 @@ export class Mapping {
     const txtByCategories = Object.values(byCategories)
       .map(it => it.competencesParNiveau)
       .map(byNiveau => {
-        const niveaux = Object.keys(byNiveau)
-          .map(it => Number(it)).sort(Misc.ascending())
+        const niveaux = Object.keys(byNiveau).map(it => Number(it)).sort(Misc.ascending())
         if (niveaux.length == 0) {
           return ''
         }

module/actor/random/app-personnage-aleatoire.js

@@ -19,7 +19,7 @@ const PATHS = [
 
 const RANDOM_VALUES = {
   'system.sexe': { 'masculin': 1, 'féminin': 1 },
-  'system.main': { 'droitier': 51, 'gaucher': 15, 'ambidextre': 6 },
+  'system.main': { 'droitier': 51, 'gaucher': 15, 'ambidectre': 6 },
   'system.cheveux': { 'noirs': 2, 'bruns': 5, 'châtains clair': 5, 'blonds': 4, 'blonds très clair': 1, 'roux carotte': 1, 'roux cuivré': 3 },
   'system.yeux': { 'noirs': 2, 'noisettes': 3, 'bruns vert': 4, 'verts': 3, 'bleus clair': 3, 'bleus gris': 2, 'gris': 1, 'mauves': 1, 'indigos': 1 },
 }

module/apps/rdd-import-stats.js

@@ -1,564 +0,0 @@
-/************************************************************************************/
-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
-let statBlock01 = `+$16(/, baron de Sylvedire, né à l’heure du
-Roseau, 40 ans, 1m78, 65 kg, Beauté 13.
-TAILLE
- 10
- Mêlée
- 14
-APPARENCE
- 13
- Tir
- 11
-CONSTITUTION
- 12
- Lancer
- 11
-FORCE
- 12
- Dérobée
- 13
-AGILITÉ
- 16
- Vie
- 11
-DEXTÉRITÉ
- 13
- Endurance
- 25
-VUE
- 10
- +dom
- 0
-OUÏE
- 11
- Protection
- 2 ou 4
-ODO-GOÛT
- 9
- cuir souple
-VOLONTÉ
- 14
- ou cuir / métal
-INTELLECT
- 9
-EMPATHIE
- 11
-RÊVE
- 13
-CHANCE
- 10
-niv
- init
- +dom
-Épée dragonne
- +5
- 12
- +3
-Hache de bataille
- +6
- 13
- +3
-Bouclier moyen
- +5
-Dague mêlée
- +4
- 11
- +1
-Corps à corps
- +4
- 11
- (0)
-Esquive
- +8
-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 
-`;
-
-let statBlock02 = `/HVJDUGHV
-TAILLE
- 11
- Mêlée
- 12
-CONSTITUTION
- 11
- Tir
- 11
-FORCE
- 12
- Lancer
- 11
-AGILITÉ
- 12
- Dérobée
- 11
-DEXTERITÉ
- 11
- Vie
- 11
-VUE
- 11
- Endurance
- 22
-OUÏE
- 11
- Vitesse
- 12
-VOLONTÉ
- 10
- +dom
- 0
-Protection
- 4
-cuir / métal
-niv
- init
- +dom
-Hache de bataille
- +4
- 10
- +3
-Bouclier moyen
- +4
-Dague mêlée
- +3
- 9
- +1
-Arc
- +5
- 10
- +2
-Corps à corps
- +3
- 9
- (0)
-Esquive avec armure
- +2
-Course +1/ Vigilance +4
-`;
-
-let statBlock03 = `rencontres sont laissées à /HVFKLHQVORXSVGXEDURQ
- chaque gardien des rêves.
-TAILLE
- 8
- Vie
- 10
-CONSTITUTION FORCE
- 12
- 11
- Endurance
- Vitesse
- 12/38
- 21
- /HVFKLHQV]RPELV
-PERCEPTION 13
- +dom
- 0
-VOLONTÉ
- 10
- Protection
- 0
- Les « monstres » apparaîtront un soir, durant
-RÊVE
- 10
- l’heure du Serpent, et attaqueront les voya-
-niv
- init
- +dom
- geurs à leur campement. Si ces derniers ne
-Morsure
- 13
- +4
- 10
- +1
- campent pas, ils apparaîtront tout de même à
-Esquive
- 11
- +3
- l’heure du Serpent. Le feu ne les effraie pas. Ils
-Course, Saut
- 12
- +3
- ne sont pas très rapides, mais en revanche, très
-Discrétion
- 12
- +3
- silencieux : ils n’aboient pas. Les voyageurs
-Vigilance
- 13
- +3
-`

module/dialog-create-signedraconique.js

@@ -51,7 +51,7 @@ export class DialogCreateSigneDraconique extends Dialog {
       whisper: ChatUtility.getOwners(actor),
       content: await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/chat-signe-draconique-actor.html", {
         signe: signe,
-        alias: actor.getAlias()
+        alias: actor.name
       })
     });
   }

module/grammar.js

@@ -24,7 +24,7 @@ export class Grammar {
   }
   
   static includesLowerCaseNoAccent(value, content) {
-    return Grammar.toLowerCaseNoAccent(value)?.includes(Grammar.toLowerCaseNoAccent(content));
+    return Grammar.toLowerCaseNoAccent(value).includes(Grammar.toLowerCaseNoAccent(content));
   }
 
   /* -------------------------------------------- */

module/item-arme.js

@@ -1,11 +1,10 @@
-import { Grammar } from "./grammar.js";
 import { RdDItemCompetenceCreature } from "./item-competencecreature.js"
 import { ITEM_TYPES } from "./item.js";
 import { RdDCombatManager } from "./rdd-combat.js";
 
 const nomCategorieParade = {
   "sans-armes": "Sans arme",
-  "armes-naturelles": "Armes naturelles",
+  "armes-naturelles": "Sans arme",
   "hast": "Armes d'hast",
   "batons": "Bâtons",
   "boucliers": "Boucliers",
@@ -31,7 +30,7 @@ export class RdDItemArme extends Item {
       case ITEM_TYPES.competencecreature:
         return RdDItemCompetenceCreature.armeCreature(arme);
     }
-    return RdDItemArme.corpsACorps();
+    return RdDItemArme.mainsNues();
   }
 
   static getCompetenceArme(arme, maniement) {
@@ -57,8 +56,8 @@ export class RdDItemArme extends Item {
   }
 
   static niveauCompetenceArme(arme, competences) {
-    const compArme = competences.find(it => Grammar.equalsInsensitive(it.name, arme.system.competence))
-    return compArme?.system.niveau ?? -8
+    const compArme = competences.find(it => it.name == arme.system.competence);
+    return compArme?.system.niveau ?? -8;
   }
 
   /* -------------------------------------------- */
@@ -82,59 +81,37 @@ export class RdDItemArme extends Item {
   /* -------------------------------------------- */
   static getCategorieParade(armeData) {
     if (armeData.system.categorie_parade) {
-      return armeData.system.categorie_parade
+      return armeData.system.categorie_parade;
     }
     // pour compatibilité avec des personnages existants
     if (armeData.type == ITEM_TYPES.competencecreature || armeData.system.categorie == 'creature') {
-      return armeData.system.categorie_parade || (armeData.system.isparade ? 'armes-naturelles' : '')
+      return armeData.system.categorie_parade || (armeData.system.isparade ? 'armes-naturelles' : '');
     }
     if (!armeData.type.match(/arme|competencecreature/)) {
-      return ''
+      return '';
     }
     if (armeData.system.competence == undefined) {
       return ITEM_TYPES.competencecreature;
     }
     let compname = armeData.system.competence.toLowerCase();
-    if (compname.match(/^(dague de jet|javelot|fouet|arc|arbalête|fronde|hache de jet|fléau)$/)) {
-      return ''
-    }
+    if (compname.match(/^(dague de jet|javelot|fouet|arc|arbalête|fronde|hache de jet|fléau)$/)) return '';
 
-    if (compname.match('hache')) return 'haches'
-    if (compname.match('hast')) return 'hast'
-    if (compname.match('lance')) return 'lances'
-    if (compname.match('bouclier')) return 'boucliers'
-    if (compname.match('masse')) return 'masses'
+    if (compname.match('hache')) return 'haches';
+    if (compname.match('hast')) return 'hast';
+    if (compname.match('lance')) return 'lances';
+    if (compname.match('bouclier')) return 'boucliers';
+    if (compname.match('masse')) return 'masses';
     if (compname.match('epée') || compname.match('épée')) {
       if (armeData.name.toLowerCase().match(/(gnome)/))
-        return 'epees-courtes'
+        return 'epees-courtes';
       if (armeData.name.toLowerCase().match(/((e|é)pée dragone|esparlongue|demi-dragonne)/))
-        return 'epees-longues'
-      return 'epees-lourdes'
+        return 'epees-longues';
+      return 'epees-lourdes';
     }
     if (compname.match('dague')) {
-      return 'dagues'
-    }
-    return 'sans-armes'
-  }
-
-  static defenseArmeParade(armeAttaque, armeParade) {
-    const defCategory = RdDItemArme.getCategorieParade(armeParade)
-    if (defCategory == 'bouclier') {
-      return 'norm'
-    }
-    if (armeAttaque.system.competence.toLowerCase().match(/(fléau)/)) {
-      return ''
-    }
-    if (armeParade.system.tir) {
-      return ''
-    }
-    const attCategory = RdDItemArme.getCategorieParade(armeAttaque)
-    switch (attCategory) {
-      case 'armes-naturelles': case 'sans-armes':
-        return defCategory == 'sans-armes' ? 'norm' : ''
-      default:
-        return RdDItemArme.needParadeSignificative(armeAttaque, armeParade) ? 'sign' : 'norm'
+      return 'dagues';
     }
+    return 'sans-armes';
   }
 
   /* -------------------------------------------- */
@@ -143,8 +120,8 @@ export class RdDItemArme extends Item {
       return false;
     }
     // categories d'armes à la parade (cf. page 115 )
-    const attCategory = RdDItemArme.getCategorieParade(armeAttaque)
-    const defCategory = RdDItemArme.getCategorieParade(armeParade)
+    let attCategory = RdDItemArme.getCategorieParade(armeAttaque);
+    let defCategory = RdDItemArme.getCategorieParade(armeParade);
     // bouclier et mêmes catégorie: peuvent se parer sans difficulté
     if (defCategory == 'boucliers') {
       return false;
@@ -207,7 +184,7 @@ export class RdDItemArme extends Item {
     return arme.system.competence.replace(" 1 main", " 2 mains");
   }
 
-  static isUtilisable(arme) {
+  static isArmeUtilisable(arme) {
     switch (arme.type) {
       case ITEM_TYPES.arme: return arme.system.equipe && (arme.system.resistance > 0 || arme.system.portee_courte > 0)
       case ITEM_TYPES.competencecreature: return true
@@ -215,24 +192,9 @@ export class RdDItemArme extends Item {
     return false
   }
 
-  static isAttaque(arme) {
-    switch (arme.type) {
-      case ITEM_TYPES.arme:
-        return arme.system.equipe && (arme.system.resistance > 0 || arme.system.portee_courte > 0)
-      case ITEM_TYPES.competencecreature:
-        return arme.system.iscombat && RdDItemCompetenceCreature.isAttaque(item)
-    }
-    return false
-  }
-
-  static isParade(arme) {
-    switch (arme.type) {
-      case ITEM_TYPES.arme:
-        return arme.system.equipe && arme.system.resistance > 0 && true/* TODO: regarder la categorie d'arme?*/
-      case ITEM_TYPES.competencecreature:
-        return arme.system.iscombat && RdDItemCompetenceCreature.isParade(arme)
-    }
-    return false
+  static ajoutCorpsACorps(armes, actor) {
+    armes.push(RdDItemArme.mainsNues(actor));
+    armes.push(RdDItemArme.empoignade(actor));
   }
 
   static corpsACorps(actor) {
@@ -253,8 +215,6 @@ export class RdDItemArme extends Item {
         mortalite: 'non-mortel',
         competence: 'Corps à corps',
         resistance: 1,
-        baseInit: 4,
-        cac: 'pugilat',
         deuxmains: true,
         categorie_parade: 'sans-armes'
       }
@@ -264,6 +224,8 @@ export class RdDItemArme extends Item {
   static mainsNues(actor) {
     const mainsNues = RdDItemArme.corpsACorps(actor)
     mainsNues.name = 'Mains nues'
+    mainsNues.system.cac = 'pugilat'
+    mainsNues.system.baseInit = 4
     return mainsNues;
   }
 

module/item-competence.js

@@ -190,7 +190,7 @@ export class RdDItemCompetence extends Item {
 
   /* -------------------------------------------- */
   static isNiveauBase(item) {
-    return item.system.niveau == undefined || Number(item.system.niveau) == RdDItemCompetence.getNiveauBase(item.system.categorie, item.type);
+    return Number(item.system.niveau) == RdDItemCompetence.getNiveauBase(item.system.categorie, item.type);
   }
 
   /* -------------------------------------------- */

module/item-competencecreature.js

@@ -27,29 +27,40 @@ export class RdDItemCompetenceCreature extends Item {
   static armeCreature(item) {
     const categorieAttaque = RdDItemCompetenceCreature.getCategorieAttaque(item)
     if (categorieAttaque != undefined) {
-      // cloner pour ne pas modifier la compétence
-      return foundry.utils.mergeObject(item, {
+      // si c'est un Item compétence: cloner pour ne pas modifier la compétence
+      let arme = item.clone();
+      return foundry.utils.mergeObject(arme, {
           action: item.isCompetencePossession() ? 'possession' : 'attaque',
           system: {
-            competence: item.name,
+            competence: arme.name,
             cac: categorieAttaque == "naturelle" ? "naturelle" : "",
             niveau: item.system.niveau,
             initiative: RdDCombatManager.calculInitiative(item.system.niveau, item.system.carac_value),
             equipe: true,
             resistance: 100,
-            dommagesReels: item.system.dommages,
+            dommagesReels: arme.system.dommages,
             penetration: 0,
             force: 0,
             rapide: true,
           }
-        }, { inplace: false, });
+        }, { inplace: false });
     }
     return undefined;
   }
 
   /* -------------------------------------------- */
-  static isAttaque(item) {
-    return RdDItemCompetenceCreature.getCategorieAttaque(item) != undefined
+  static isCompetenceAttaque(item) {
+    if (item.type == ITEM_TYPES.competencecreature) {
+      switch (item.system.categorie) {
+        case "melee":
+        case "tir":
+        case "lancer":
+        case "naturelle":
+        case "possession":
+          return true
+      }
+    }
+    return undefined
   }
 
   static getCategorieAttaque(item) {
@@ -60,12 +71,12 @@ export class RdDItemCompetenceCreature extends Item {
         case "lancer":
         case "naturelle":
         case "possession":
+        case "parade":
           return item.system.categorie
       }
     }
     return undefined
   }
-
   static isDommages(item) {
     if (item.type == ITEM_TYPES.competencecreature) {
       switch (item.system.categorie) {
@@ -78,12 +89,20 @@ export class RdDItemCompetenceCreature extends Item {
     }
     return false
   }
-
   static isParade(item) {
     if (item.type == ITEM_TYPES.competencecreature) {
-      return item.system.categorie_parade || item.system.isparade
+      switch (item.system.categorie) {
+        case "melee":
+        case "naturelle":
+        case "parade":
+          return true
+      }
     }
     return false
   }
 
-}
+  /* -------------------------------------------- */
+  static isCompetenceParade(item) {
+    return item.type == 'competencecreature' && item.system.categorie_parade !== "";
+  }
+}  

module/item-sheet.js

@@ -13,7 +13,6 @@ 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
@@ -101,59 +100,55 @@ 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)
     }
-    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) {
+
+    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') {
       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 == ITEM_TYPES.arme) {
-      formData.competences = formData.competences.filter(it => it.isCompetenceArme())
+    if (this.item.type == 'arme') {
+      formData.competences = competences.filter(it => it.isCompetenceArme())
     }
-    if (this.item.type == ITEM_TYPES.recettecuisine) {
+    if (['sort', 'sortreserve'].includes(this.item.type)) {
+      formData.competences = competences.filter(it => RdDItemCompetence.isDraconic(it));
+    }
+    if (this.item.type == 'recettecuisine') {
       formData.ingredients = await TextEditor.enrichHTML(this.object.system.ingredients, { async: true })
     }
-    if (this.item.type == ITEM_TYPES.extraitpoetique) {
+    if (this.item.type == '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 == ITEM_TYPES.recettealchimique) {
-      RdDAlchimie.processManipulation(this.item, this.actor?.id);
+    if (this.item.type == 'recettealchimique') {
+      RdDAlchimie.processManipulation(this.item, this.actor && 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 == ITEM_TYPES.gemme) {
+    if (this.item.type == 'gemme') {
       formData.gemmeTypeList = RdDGemme.getGemmeTypeOptionList();
-      RdDGemme.calculDataDerivees(this.item)
+      RdDGemme.calculDataDerivees(this.item);
     }
-    if (this.item.type == ITEM_TYPES.potion) {
-      RdDHerbes.calculFormData(formData, this.item)
+    if (this.item.type == 'potion') {
+      await RdDHerbes.addPotionFormData(formData);
     }
-    if (this.item.type == ITEM_TYPES.herbe) {
-      if (formData.options.isOwned && ['Soin', 'Repos'].includes(formData.system.categorie)) {
-        formData.isIngredientPotionBase = true;
-      }
+    if (formData.options.isOwned && this.item.type == 'herbe' && (formData.system.categorie == 'Soin' || formData.system.categorie == 'Repos')) {
+      formData.isIngredientPotionBase = true;
     }
-    if (this.item.type == ITEM_TYPES.sortreserve) {
+    if (this.item.type == '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);
     }
-    if (this.item.type == ITEM_TYPES.sort) {
-      formData.competences = formData.competences.filter(it => RdDItemCompetence.isDraconic(it));
-      formData.bonusCaseList = RdDItemSort.getBonusCaseList(this.item);
-    }
+    formData.bonusCaseList = RdDItemSort.getBonusCaseList(formData, true);
+
     return formData;
   }
 
@@ -190,9 +185,6 @@ 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());
@@ -272,66 +264,16 @@ 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:
-        formData['system.bonuscase'] = RdDItemSort.bonuscasesToString(RdDItemSheet._listCaseTmr(
-          formData.caseTmrCoord,
-          formData.caseTmrBonus,
-          formData.caseTmrAdd
-        ))
-        break
-      case ITEM_TYPES.competence:
-        formData['system.niveau'] = formData['system.niveau'] ?? formData['system.base']
-        break
+    if (this.item.type == 'sort') {
+      // Données de bonus de cases ?
+      formData['system.bonuscase'] = RdDItemSort.buildBonuscaseFromArrays(formData.bonusValue, formData.caseValue);
     }
-
     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) {
   }

module/item-sort.js

@@ -2,69 +2,52 @@ import { Grammar } from "./grammar.js";
 import { RdDItemCompetence } from "./item-competence.js";
 import { ITEM_TYPES } from "./item.js";
 import { Misc } from "./misc.js";
-import { FLEUVE_COORD, TMRUtility } from "./tmr-utility.js";
+import { TMRUtility } from "./tmr-utility.js";
 
-export const VOIES_DRACONIC = [
+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: 'O/H/N/T', ordre: 'e' },
-  { code: 'O/H/N', label: "Oniros/Hypnos/Narcos", short: "O/H/N", ordre: 'f' }
+  { 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' }
 ]
 
 /* -------------------------------------------- */
 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?
+  static getDraconicsSort(draconicList, sort) {
     switch (Grammar.toLowerCaseNoAccent(sort.name)) {
       case "lecture d'aura":
       case "detection d'aura":
-        return competencesDraconic;
+        return draconicList;
       case "annulation de magie":
-        return competencesDraconic.filter(it => !RdDItemCompetence.isThanatos(it));
+        return draconicList.filter(it => !RdDItemCompetence.isThanatos(it));
     }
-    const voies = sort.system.draconic.split('/')
-    return voies.map(voie => RdDItemCompetence.getVoieDraconic(competencesDraconic, voie))
+    return [RdDItemCompetence.getVoieDraconic(draconicList, sort.system.draconic)];
   }
 
   static getOrdreCode(code) {
     return (VOIES_DRACONIC.find(it => it.code == code)?.ordre ?? '?')
   }
 
-  static getCodeVoie(voie) {
-    return VOIES_DRACONIC.find(it => [it.code, it.short, it.label].includes(voie))?.code ?? '?'
+  static getVoieCode(voie) {
+    return VOIES_DRACONIC.find(it => voie.name.includes(it.short))?.code ?? '?'
   }
 
-  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']) {
+  static getCodeDraconic(sort, voies = ['O', 'H', 'N', 'T']) {
     switch (Grammar.toLowerCaseNoAccent(sort.name)) {
       case "lecture d'aura":
       case "detection d'aura":
-        return RdDItemSort.$voiesConnues('O/H/N/T', codeVoies)
+        return RdDItemSort.$voiesConnues('O/H/N/T', voies)
       case "annulation de magie":
-        return RdDItemSort.$voiesConnues('O/H/N', codeVoies)
+        return RdDItemSort.$voiesConnues('O/H/N', voies)
     }
-    return RdDItemSort.getCodeVoie(sort.system.draconic)
+    const voie = VOIES_DRACONIC.find(it => it.label.includes(sort.system.draconic))
+    return voie?.code ?? sort.system.draconic
   }
 
+
   static $voiesConnues(voiesSort, voies) {
     const codes = voies.filter(it => voiesSort.includes(it))
       .sort(Misc.ascending(it => RdDItemSort.getOrdreCode(it)))
@@ -96,60 +79,89 @@ 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) {
+  static getBonusCaseList(item, newCase = false) {
     // Gestion spéciale case bonus
     if (item.type == ITEM_TYPES.sort) {
-      return RdDItemSort.stringToBonuscases(item.system.bonuscase)
+      return RdDItemSort.buildBonusCaseList(item.system.bonuscase, newCase);
     }
-    return [];
+    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;
   }
 
   /* -------------------------------------------- */
   static incrementBonusCase(actor, sort, coord) {
-    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 })
+    if (TMRUtility.getTMR(coord).type == "fleuve") {
+      coord = 'Fleuve';
     }
+    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 };
 
-    actor.updateEmbeddedDocuments('Item', [{ _id: sort._id, 'system.bonuscase': RdDItemSort.bonuscasesToString(list) }]);
+    const bonuscase = RdDItemSort._bonuscaseListToString(
+      list.filter(it => it.case != coord).concat(modified)
+    );
+
+    // Sauvegarde/update
+    actor.updateEmbeddedDocuments('Item', [{ _id: sort._id, 'system.bonuscase': bonuscase }]);
   }
 
 
   /* -------------------------------------------- */
   static getCaseBonus(sort, coord) {
-    const search = TMRUtility.isFleuve(coord)
-      ? it => it.case == 'Fleuve'
-      : it => it.case == coord;
-    const bc = RdDItemSort.stringToBonuscases(sort.system.bonuscase)
-      .find(search)
+    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)
     return Number(bc?.bonus ?? 0);
   }
 
-  static bonuscasesToString(list) {
+  static _bonuscaseListToString(list) {
     return list.map(it => `${it.case}:${it.bonus}`)
       .sort(Misc.ascending())
       .join(',');
   }
-
-  static stringToBonuscases(bonuscase) {
+  static bonuscaseStringToList(bonuscase) {
     if (bonuscase == undefined || bonuscase == '') {
       return []
     }
-    return bonuscase.split(',')
-      .map(it => it.split(':'))
-      .map(it => { return { case: it[0], bonus: it[1] } });
+    return bonuscase.split(',').map(it => {
+      const b = it.split(':');
+      return { case: b[0], bonus: b[1] };
+    });
   }
 
 }

module/item.js

@@ -571,7 +571,6 @@ export class RdDItem extends Item {
     else {
       await this.quantiteIncDec(item.system.quantite);
     }
-    // TODO: suppression dans les conteneurs!
     await item.delete();
   }
 
@@ -602,9 +601,6 @@ 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`];
     }

module/item/blessure.js

@@ -67,7 +67,7 @@ export class RdDItemBlessure extends RdDItem {
 
   }
 
-  static async createBlessure(actor, gravite, localisation = '', attackerToken) {
+  static async createBlessure(actor, gravite, localisation = '', attacker) {
     const definition = RdDItemBlessure.getDefinition(gravite)
     const blessure = {
       name: definition.label,
@@ -77,7 +77,7 @@ export class RdDItemBlessure extends RdDItem {
         gravite: gravite,
         difficulte: - gravite,
         localisation: localisation,
-        origine: attackerToken?.name ?? ""
+        origine: attacker?.name ?? ""
       }
     }
     const blessures = await actor.createEmbeddedDocuments('Item', [blessure])

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 { VOIES_DRACONIC } from "./item-sort.js";
+import { RdDCalendrier } from "./time/rdd-calendrier.js";
 
 class Migration {
   get code() { return "sample"; }
@@ -530,32 +530,6 @@ 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 [

module/misc.js

@@ -139,7 +139,7 @@ export class Misc {
   }
 
   static join(params, separator = '') {
-    return (!params || params.length == 0) ? '' : params.reduce(Misc.joining(separator))
+    return params?.reduce(Misc.joining(separator)) ?? '';
   }
 
   static joining(separator = '') {
@@ -189,7 +189,13 @@ export class Misc {
    *  and there is no connected GM
    */
   static documentIfResponsible(document) {
-    if (Misc.isFirstConnectedGM() || (Misc.connectedGMs().length == 0 && Misc.isFirstOwnerPlayer(document))) {
+    if (foundry.utils.isNewerVersion(game.release.version, '12.0')) {
+      if (game.users.activeGM || (Misc.connectedGMs().length == 0 && Misc.isOwnerPlayer(document)))
+      {
+        return document
+      }
+    }
+    else if (Misc.isFirstConnectedGM() || (Misc.connectedGMs().length == 0 && Misc.isOwnerPlayer(document))) {
       return document
     }
     return undefined
@@ -199,15 +205,8 @@ export class Misc {
     return document.testUserPermission && document.testUserPermission(game.user, CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER)
   }
 
-  static isFirstOwnerPlayer(document) {
-    if (!document.testUserPermission){
-      return false
-    }
-    return game.users.filter(u => document.testUserPermission(u, CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER)) == game.user
-  }
-
   static isOwnerPlayerOrUniqueConnectedGM(actor) {
-    return Misc.isFirstOwnerPlayer(actor) ?? Misc.isFirstConnectedGM();
+    return Misc.isOwnerPlayer(actor) ?? Misc.isFirstConnectedGM();
   }
 
   /**

module/rdd-carac.js

@@ -53,14 +53,9 @@ export class RdDCarac {
     return selectedCarac?.label?.toLowerCase()?.match(/r(e|ê)ve(( |-)actuel)?/);
   }
 
-  /**
-   * L’appel à la chance n’est possible que pour recommencer les jets d’actions physiques :
-   * tous les jets de combat, de FORCE, d’AGILITÉ, de DEXTÉRITÉ, de Dérobée, d’APPARENCE,
-   * ainsi que de Perception active et volontaire.
-   */
   static isActionPhysique(selectedCarac) {
-    return Grammar.toLowerCaseNoAccent(selectedCarac?.label)
-      ?.match(/(apparence|force|agilite|dexterite|vue|ouie|gout|odorat|empathie|melee|tir|lancer|derobee)/) != null
+    return !selectedCarac ||
+      selectedCarac?.label.match(/(Apparence|Force|Agilité|Dextérité|Vue|Ouïe|Odorat-Goût|Empathie|Dérobée|Mêlée|Tir|Lancer)/);
   }
 
   static getCaracDerivee(value) {
@@ -95,4 +90,15 @@ export class RdDCarac {
   static getCaracXp(targetValue) {
     return RdDCarac.getCaracDerivee(targetValue)?.xp ?? 200;
   }
+
+
+  /**
+   * L’appel à la chance n’est possible que pour recommencer les jets d’actions physiques :
+   * tous les jets de combat, de FORCE, d’AGILITÉ, de DEXTÉRITÉ, de Dérobée, d’APPARENCE,
+   * ainsi que de Perception active et volontaire.
+   */
+  static isActionPhysique(selectedCarac) {
+    return Grammar.toLowerCaseNoAccent(selectedCarac?.label)?.match(/(apparence|force|agilite|dexterite|vue|ouie|odorat|empathie|melee|tir|lancer|derobee)/);
+  }
+
 }

module/rdd-combat.js

@@ -42,8 +42,7 @@ export class RdDCombatManager extends Combat {
     /* -------------------------------------------- */
     Hooks.on("getCombatTrackerEntryContext", (html, options) => { RdDCombatManager.pushInitiativeOptions(html, options); });
     Hooks.on("updateCombat", (combat, change, options, userId) => { RdDCombat.onUpdateCombat(combat, change, options, userId) });
-    Hooks.on("preDeleteCombat", (combat, html, id) => { combat.onPreDeleteCombat() })
-    Hooks.on("deleteCombat", (combat, html, id) => { combat.onDeleteCombat() })
+    Hooks.on("preDeleteCombat", (combat, html, id) => { combat.onPreDeleteCombat() });
   }
 
   /* -------------------------------------------- */
@@ -62,40 +61,20 @@ export class RdDCombatManager extends Combat {
       RdDEmpoignade.deleteAllEmpoignades()
     }
   }
-  async onDeleteCombat() {
-    if (Misc.isFirstConnectedGM()) {
-      if (game.combats.size <= 1) {
-        game.actors.forEach(actor => actor.resetItemUse())
-      }
-    }
-  }
 
   /* -------------------------------------------- */
   async finDeRound(options = { terminer: false }) {
-    this.combatants.map(it => RdDCombatManager.getActorCombatant(it, { warning: false }))
-      .filter(it => it != undefined)
-      .forEach(async actor => {
-        await actor.finDeRound(options)
-        await actor.resetItemUse()
-      })
-  }
+    this.turns.forEach(turn => turn.actor.resetItemUse());
 
-  static getActorCombatant(combatant, options = { warning: true }) {
-    if (!combatant.actor) {
-      if (options.warning) {
+    for (let combatant of this.combatants) {
+      if (combatant.actor) {
+        await combatant.actor.finDeRound(options);
+      }
+      else {
         ui.notifications.warn(`Le combatant ${combatant.name} n'est pas associé à un acteur!`)
       }
-      return undefined
     }
-    else if (!combatant.actor.isActorCombat()) {
-      if (options.warning) {
-        ui.notifications.warn(`${combatant.name} ne peut pas combattre!`)
-      }
-      return undefined
-    }
-    return combatant.actor
   }
-
   static calculAjustementInit(actor, arme) {
     const efficacite = (arme?.system.magique) ? arme.system.ecaille_efficacite : 0
     const etatGeneral = actor.getEtatGeneral() ?? 0
@@ -104,27 +83,57 @@ export class RdDCombatManager extends Combat {
   }
 
   /************************************************************************************/
-  async rollInitiative(ids, messageOptions = {}) {
-    console.log(`${game.system.title} | Combat.rollInitiative()`, ids, messageOptions)
-    ids = typeof ids === "string" ? [ids] : ids
-    ids.forEach(async id =>
-      await this.rollInitRdD(id, undefined, messageOptions)
-    )
-    return this
-  }
+  async rollInitiative(ids, formula = undefined, messageOptions = {}) {
+    console.log(`${game.system.title} | Combat.rollInitiative()`, ids, formula, messageOptions);
 
-  async rollInitRdD(id, formula, messageOptions = {}) {
-    const combatant = this.combatants.get(id);
-    const actor = RdDCombatManager.getActorCombatant(combatant)
-    if (actor) {
-      const rollFormula = formula ?? RdDCombatManager.getFirstInitRollFormula(actor)
+    ids = typeof ids === "string" ? [ids] : ids;
+    // calculate initiative
+    for (let cId = 0; cId < ids.length; cId++) {
+      const combatant = this.combatants.get(ids[cId]);
+      const ajustement = RdDCombatManager.calculAjustementInit(combatant.actor, undefined);
+      let rollFormula = formula ?? RdDCombatManager.formuleInitiative(2, 10, 0, ajustement);
+
+      if (!formula) {
+        if (combatant.actor.type == 'creature' || combatant.actor.type == 'entite') {
+          const competence = combatant.actor.items.find(it => RdDItemCompetenceCreature.isCompetenceAttaque(it))
+          if (competence) {
+            rollFormula = RdDCombatManager.formuleInitiative(2, competence.system.carac_value, competence.system.niveau, etatGeneral);
+          }
+        } else {
+          const armeCombat = combatant.actor.itemTypes['arme'].find(it => it.system.equipe)
+          let compName = "Corps à corps"
+          if (armeCombat) {
+            if (armeCombat.system.competence != "") {
+              compName = armeCombat.system.competence
+            }
+            if (armeCombat.system.lancer != "") {
+              compName = armeCombat.system.lancer
+            }
+            if (armeCombat.system.tir != "") {
+              compName = armeCombat.system.tir
+            }
+          }
+          const competence = RdDItemCompetence.findCompetence(combatant.actor.items, compName);
+          if (competence && competence.system.defaut_carac) {
+            const carac = combatant.actor.system.carac[competence.system.defaut_carac].value;
+            const niveau = competence.system.niveau;
+
+            const ajustement = RdDCombatManager.calculAjustementInit(combatant.actor, armeCombat)
+            rollFormula = RdDCombatManager.formuleInitiative(2, carac, niveau, ajustement);
+          } else {
+            ui.notifications.warn(`Votre arme ${armeCombat.name} n'a pas de compétence renseignée`);
+          }
+        }
+      }
+      //console.log("Combatat", c);
       const roll = combatant.getInitiativeRoll(rollFormula);
       if (!roll.total) {
         await roll.evaluate();
       }
       const total = Math.max(roll.total, 0.00);
       console.log("Compute init for", rollFormula, roll, total, combatant);
-      await this.updateEmbeddedDocuments("Combatant", [{ _id: combatant._id || combatant.id, initiative: total }]);
+      let id = combatant._id || combatant.id;
+      await this.updateEmbeddedDocuments("Combatant", [{ _id: id, initiative: total }]);
 
       // Send a chat message
       let rollMode = messageOptions.rollMode || game.settings.get("core", "rollMode");
@@ -133,10 +142,10 @@ export class RdDCombatManager extends Combat {
           scene: canvas.scene._id,
           actor: combatant.actor?._id,
           token: combatant.token._id,
-          alias: combatant.token?.name,
+          alias: combatant.token.name,
           sound: CONFIG.sounds.dice,
         },
-        flavor: `${combatant.token?.name} a fait son jet d'Initiative (${messageOptions.info})<br>`
+        flavor: `${combatant.token.name} a fait son jet d'Initiative (${messageOptions.initInfo})<br>`,
       },
         messageOptions);
       roll.toMessage(messageData, { rollMode, create: true });
@@ -144,20 +153,7 @@ export class RdDCombatManager extends Combat {
       RdDCombatManager.processPremierRoundInit();
     }
     return this;
-  }
-
-  static getFirstInitRollFormula(actor) {
-    const actions = actor.listActionsCombat()
-    if (actions.length > 0) {
-      const action = actions[0]
-      const init = RdDCombatManager.getInitData(actor, action)
-      const ajustement = RdDCombatManager.calculAjustementInit(actor, action)
-      return RdDCombatManager.formuleInitiative(init.offset, init.carac, init.niveau, ajustement);
-    }
-
-    let ajustement = RdDCombatManager.calculAjustementInit(actor, undefined);
-    return RdDCombatManager.formuleInitiative(2, 10, 0, ajustement);
-  }
+  };
 
   static formuleInitiative(rang, carac, niveau, bonusMalus) {
     return `${rang} +( (${RdDCombatManager.calculInitiative(niveau, carac, bonusMalus)} )/100)`;
@@ -226,7 +222,7 @@ export class RdDCombatManager extends Combat {
   }
 
   static $prepareAttaqueArme(infoAttaque) {
-    const comp = infoAttaque.competences.find(it => Grammar.equalsInsensitive(it.name, infoAttaque.competence))
+    const comp = infoAttaque.competences.find(c => c.name == infoAttaque.competence);
     const arme = infoAttaque.arme;
     const attaque = foundry.utils.duplicate(arme);
     attaque.action = 'attaque';
@@ -240,6 +236,58 @@ export class RdDCombatManager extends Combat {
     return attaque;
   }
 
+  static listActionsCreature(competences) {
+    return competences
+      .filter(it => RdDItemCompetenceCreature.isCompetenceAttaque(it))
+      .map(it => RdDItemCompetenceCreature.armeCreature(it))
+      .filter(it => it != undefined);
+  }
+
+  static listActionsPossessions(actor) {
+    return RdDCombatManager._indexActions(actor.getPossessions().map(p => {
+      return {
+        name: p.name,
+        action: 'possession',
+        system: {
+          competence: p.name,
+          possessionid: p.system.possessionid,
+        }
+      }
+    }));
+  }
+
+  /* -------------------------------------------- */
+  static listActionsCombat(combatant) {
+    const actor = combatant.actor;
+    let actions = RdDCombatManager.listActionsPossessions(actor);
+    if (actions.length > 0) {
+      return actions;
+    }
+    if (actor.isCreatureEntite()) {
+      actions = RdDCombatManager.listActionsCreature(actor.itemTypes['competencecreature']);
+    } else if (actor.isPersonnage()) {
+      // Recupération des items 'arme'
+      const competences = actor.itemTypes['competence'];
+      const armes = actor.itemTypes['arme'].filter(it => RdDItemArme.isArmeUtilisable(it))
+        .concat(RdDItemArme.empoignade(actor))
+        .concat(RdDItemArme.mainsNues(actor));
+      actions = RdDCombatManager.listActionsArmes(armes, competences, actor.system.carac);
+
+      if (actor.system.attributs.hautrevant.value) {
+        actions.push({ name: "Draconic", action: 'haut-reve', system: { initOnly: true, competence: "Draconic" } });
+      }
+    }
+
+    return RdDCombatManager._indexActions(actions);
+  }
+
+  static _indexActions(actions) {
+    for (let index = 0; index < actions.length; index++) {
+      actions[index].index = index;
+    }
+    return actions;
+  }
+
   /* -------------------------------------------- */
   static processPremierRoundInit() {
     // Check if we have the whole init !
@@ -252,7 +300,7 @@ export class RdDCombatManager extends Combat {
           if (action && action.type == "arme") {
             for (let initData of premierRoundInit) {
               if (Grammar.toLowerCaseNoAccentNoSpace(action.system.initpremierround).includes(initData.pattern)) {
-                let msg = `<h4>L'initiative de ${combatant.actor.getAlias()} a été modifiée !</h4>
+                let msg = `<h4>L'initiative de ${combatant.actor.name} a été modifiée !</h4>
                       <hr>
                       <div>
                         Etant donné son ${action.name}, son initative pour ce premier round est désormais de ${initData.init}.
@@ -277,13 +325,13 @@ export class RdDCombatManager extends Combat {
   /* -------------------------------------------- */
   static pushInitiativeOptions(html, options) {
     for (let i = 0; i < options.length; i++) {
-      let option = options[i]
+      let option = options[i];
       if (option.name == 'COMBAT.CombatantReroll') { // Replace !
-        option.name = "Sélectionner l'initiative..."
-        option.condition = true
-        option.icon = '<i class="far fa-question-circle"></i>'
+        option.name = "Sélectionner l'initiative...";
+        option.condition = true;
+        option.icon = '<i class="far fa-question-circle"></i>';
         option.callback = target => {
-          RdDCombatManager.displayInitiativeMenu(html, target.data('combatant-id'))
+          RdDCombatManager.displayInitiativeMenu(html, target.data('combatant-id'));
         }
       }
     }
@@ -294,83 +342,96 @@ export class RdDCombatManager extends Combat {
   }
   /* -------------------------------------------- */
   static rollInitiativeAction(combatantId, action) {
-    const combatant = game.combat.combatants.get(combatantId)
-    const actor = RdDCombatManager.getActorCombatant(combatant)
-    if (actor == undefined) { return [] }
+    const combatant = game.combat.combatants.get(combatantId);
+    if (combatant.actor == undefined) {
+      ui.notifications.warn(`Le combatant ${combatant.name} n'est pas associé à un acteur, impossible de déterminer ses actions de combat!`)
+      return [];
+    }
+    let initInfo = "";
+    let initOffset = 0;
+    let caracForInit = 0;
+    let compNiveau = 0;
+    let compData = { name: "Aucune" };
+    if (combatant.actor.getSurprise() == "totale") {
+      initOffset = -1; // To force 0
+      initInfo = "Surprise Totale"
+    } else if (combatant.actor.getSurprise() == "demi") {
+      initOffset = 0;
+      initInfo = "Demi Surprise"
+    } else if (action.action == 'possession') {
+      initOffset = 10;
+      caracForInit = combatant.actor.getReveActuel();
+      initInfo = "Possession"
+    } else if (action.action == 'autre') {
+      initOffset = 2;
+      initInfo = "Autre Action"
+    } else if (action.action == 'haut-reve') {
+      initOffset = 9;
+      initInfo = "Draconic"
+    } else {
+      compData = RdDItemCompetence.findCompetence(combatant.actor.items, action.system.competence);
+      compNiveau = compData.system.niveau;
+      initInfo = action.name + " / " + action.system.competence;
 
+      if (combatant.actor.type == 'creature' || combatant.actor.type == 'entite') {
+        caracForInit = compData.system.carac_value;
+      } else {
+        caracForInit = combatant.actor.system.carac[compData.system.defaut_carac].value;
+      }
+      initOffset = RdDCombatManager._baseInitOffset(compData.system.categorie, action);
+    }
+
+    // Cas des créatures et entités vs personnages
+    const ajustement = RdDCombatManager.calculAjustementInit(combatant.actor, action)
+    let rollFormula = RdDCombatManager.formuleInitiative(initOffset, caracForInit, compNiveau, ajustement);
+    // Garder la trace de l'arme/compétence utilisée pour l'iniative
     combatant.initiativeData = { arme: action } // pour reclasser l'init au round 0
-
-    const init = RdDCombatManager.getInitData(actor, action)
-    const ajustement = RdDCombatManager.calculAjustementInit(actor, action)
-    const rollFormula = RdDCombatManager.formuleInitiative(init.offset, init.carac, init.niveau, ajustement);
-
-    game.combat.rollInitRdD(combatantId, rollFormula, init);
+    game.combat.rollInitiative(combatantId, rollFormula, { initInfo: initInfo });
   }
 
-  static getInitData(actor, action) {
-    if (actor.getSurprise() == "totale") { return { offset: -1, info: "Surprise Totale", carac: 0, niveau: 0 } }
-    if (actor.getSurprise() == "demi") { return { offset: 0, info: "Demi Surprise", carac: 0, niveau: 0 } }
-    if (action.action == 'autre') { return { offset: 2, info: "Autre Action", carac: 0, niveau: 0 } }
-    if (action.action == 'possession') { return { offset: 10, info: "Possession", carac: actor.getReveActuel(), niveau: 0 } }
-    if (action.action == 'haut-reve') { return { offset: 9, info: "Draconic", carac: actor.getReveActuel(), niveau: 0 } }
-
-    const comp = RdDItemCompetence.findCompetence(actor.items, action.system.competence);
-    return {
-      offset: RdDCombatManager.initOffset(comp?.system.categorie, action),
-      info: action.name + " / " + action.system.competence,
-      carac: actor.getCaracInit(comp),
-      niveau: comp?.system.niveau ?? -8
+  /* -------------------------------------------- */
+  static _baseInitOffset(categorie, arme) {
+    if (categorie == "tir") { // Offset de principe pour les armes de jet
+      return 8;
     }
-  }
-
-  static initOffset(categorie, arme) {
-    switch (categorie) {
-      case "tir": return 8
-      case "lancer": return 7
-      default:
-        switch (arme.system.cac) {
-          case "empoignade": return 3
-          case "pugilat": return 4
-          case "naturelle": return 4
-          default: return 5
-        }
+    if (categorie == "lancer") { // Offset de principe pour les armes de jet
+      return 7;
     }
+    switch (arme.system.cac) {
+      case "empoignade":
+        return 3;
+      case "pugilat":
+      case "naturelle":
+        return 4;
+    }
+    return 5;
   }
 
   /* -------------------------------------------- */
   static displayInitiativeMenu(html, combatantId) {
-    const combatant = game.combat.combatants.get(combatantId)
-    const actor = RdDCombatManager.getActorCombatant(combatant, { warning: false })
-    if (actor) {
-      const actions = RdDCombatManager.listActionsActorCombatant(actor)
-      // Build the relevant submenu
-      const menuItems = actions.map(action => {
-        return {
+    console.log("Combatant ; ", combatantId);
+    const combatant = game.combat.combatants.get(combatantId);
+    if (!(combatant?.actor)) {
+      ui.notifications.warn(`Le combatant ${combatant.name ?? combatantId} n'est pas associé à un acteur, impossible de déterminer ses actions de combat!`)
+      return;
+    }
+
+    let actions = RdDCombatManager.listActionsCombat(combatant);
+
+    // Build the relevant submenu
+    if (actions) {
+      let menuItems = [];
+      for (let action of actions) {
+        menuItems.push({
           name: action.system.competence,
           icon: "<i class='fas fa-dice-d6'></i>",
           callback: target => { RdDCombatManager.rollInitiativeAction(combatantId, action) }
-        }
-      })
-      if (menuItems.length > 0) {
-        new ContextMenu(html, ".directory-list", menuItems).render();
+        });
       }
+      new ContextMenu(html, ".directory-list", menuItems).render();
     }
   }
 
-  /* -------------------------------------------- */
-  static listActionsActorCombatant( actor) {
-    const possessions = actor.listActionsPossessions()
-    const actions = possessions.length > 0
-      ? possessions
-      : actor.listActionsCombat()
-
-    for (let index = 0; index < actions.length; index++) {
-      actions[index].index = index
-    }
-    return actions
-  }
-
-
 }
 
 /* -------------------------------------------- */
@@ -396,8 +457,8 @@ export class RdDCombat {
     if (Misc.isFirstConnectedGM()) {
       let turn = combat.turns.find(t => t.token?.id == combat.current.tokenId);
       if (turn?.actor) {
-        // TODO Playaudio for player??
         RdDCombat.displayActorCombatStatus(combat, turn.actor, turn.token);
+        // TODO Playaudio for player??
       }
     }
   }
@@ -435,10 +496,11 @@ export class RdDCombat {
 
   /* -------------------------------------------- */
   static onMsgEncaisser(msg) {
-    let defender = canvas.tokens.get(msg.defenderToken.id).actor;
-    if (Misc.isOwnerPlayerOrUniqueConnectedGM(defender)) {
+    if (Misc.isOwnerPlayerOrUniqueConnectedGM()) {
       let attackerRoll = msg.attackerRoll;
       let attacker = msg.attackerId ? game.actors.get(msg.attackerId) : undefined;
+      let defender = canvas.tokens.get(msg.defenderToken.id).actor;
+
       defender.encaisserDommages(attackerRoll, attacker, msg.attackerToken);
       const rddCombat = RdDCombat.rddCombatForAttackerAndDefender(msg.attackerId, msg.attackerToken.id, msg.defenderToken.id);
       rddCombat?.removeChatMessageActionsPasseArme(attackerRoll.passeArme);
@@ -512,15 +574,15 @@ export class RdDCombat {
 
   static $extractAttackerTokenData(attacker, attackerTokenId) {
     const token = canvas.tokens.get(attackerTokenId);
-    return token ? Targets.extractTokenData(token) : Targets.buildActorTokenData(attackerTokenId, attacker)
+    return token ? Targets.extractTokenData(token) : Targets.buildActorTokenData(attackerTokenId, attacker) 
   }
-
+  
   static $extractDefenderTokenData(defender, defenderTokenId, target) {
     if (target) {
       return Targets.extractTokenData(target)
     }
     const token = canvas.tokens.get(defenderTokenId);
-    return token ? Targets.extractTokenData(token) : Targets.buildActorTokenData(defenderTokenId, defender)
+    return token ? Targets.extractTokenData(token) : Targets.buildActorTokenData(defenderTokenId, defender) 
   }
 
 
@@ -749,11 +811,11 @@ export class RdDCombat {
     dialog.render(true);
   }
 
-
+  
   /* -------------------------------------------- */
   _prepareAttaque(competence, arme) {
     let rollData = {
-      alias: this.attacker?.getAlias(),
+      alias: this.attackerToken.name,
       passeArme: foundry.utils.randomID(16),
       mortalite: arme?.system.mortalite,
       competence: competence,
@@ -763,7 +825,7 @@ export class RdDCombat {
       targetToken: this.defenderToken,
       essais: {}
     };
-
+    
     if (this.attacker.isCreatureEntite()) {
       RdDItemCompetenceCreature.setRollDataCreature(rollData);
     }
@@ -773,9 +835,9 @@ export class RdDCombat {
     }
     else {
       // sans armes: à mains nues
-      rollData.arme = RdDItemArme.corpsACorps(this.attacker)
-      rollData.arme.system.niveau = competence.system.niveau
-      rollData.arme.system.initiative = RdDCombatManager.calculInitiative(competence.system.niveau, this.attacker.system.carac['melee'].value);
+      const niveau = competence.system.niveau;
+      const init = RdDCombatManager.calculInitiative(niveau, this.attacker.system.carac['melee'].value);
+      rollData.arme = RdDItemArme.mainsNues({ niveau: niveau, initiative: init });
     }
     return rollData;
   }
@@ -802,10 +864,10 @@ export class RdDCombat {
     }
 
     const choixParticuliere = await ChatMessage.create({
-      alias: this.attacker.getAlias(),
+      alias: this.attacker.name,
       whisper: ChatUtility.getOwners(this.attacker),
       content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-demande-attaque-particuliere.html', {
-        alias: this.attacker.getAlias(),
+        alias: this.attackerToken.name,
         attackerId: this.attackerId,
         attackerToken: this.attackerToken,
         defenderToken: this.defenderToken,
@@ -825,7 +887,7 @@ export class RdDCombat {
     attackerRoll.dmg = RdDBonus.dmg(attackerRoll, this.attacker, this.defender.isEntite());
     let defenderRoll = { attackerRoll: attackerRoll, passeArme: attackerRoll.passeArme, show: {} }
     attackerRoll.show = {
-      cible: this.defender?.getAlias() ?? 'la cible',
+      cible: this.defenderToken?.name ?? 'la cible',
       isRecul: (attackerRoll.particuliere == 'force' || attackerRoll.tactique == 'charge')
     }
     await RdDResolutionTable.displayRollData(attackerRoll, this.attacker, 'chat-resultat-attaque.html');
@@ -856,7 +918,7 @@ export class RdDCombat {
     // # utilisation esquive
     const corpsACorps = this.defender.getCompetenceCorpsACorps({ onMessage: it => console.info(it, this.defender) });
     const esquives = foundry.utils.duplicate(this.defender.getCompetencesEsquive())
-    esquives.forEach(e => e.nbUsage = e?._id ? this.defender.getItemUse(e._id) : 0);
+    esquives.forEach(e => e.system.nbUsage = e?._id ? this.defender.getItemUse(e._id) : 0);
 
     const paramChatDefense = {
       passeArme: attackerRoll.passeArme,
@@ -891,7 +953,7 @@ export class RdDCombat {
     const choixDefense = await ChatMessage.create({
       // message privé: du défenseur à lui même (et aux GMs)
       speaker: ChatMessage.getSpeaker(this.defender, canvas.tokens.get(this.defenderTokenId)),
-      alias: this.attacker?.getAlias(),
+      alias: this.attackerToken.name,
       whisper: ChatUtility.getOwners(this.defender),
       content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-demande-defense.html', paramDemandeDefense),
     });
@@ -916,21 +978,20 @@ export class RdDCombat {
   }
 
   /* -------------------------------------------- */
-  _filterArmesParade(defender, competence, armeAttaque) {
-    let defenses = defender.items.filter(it => RdDItemArme.isParade(it))
-    defenses = foundry.utils.duplicate(defenses)
-    defenses.forEach(armeDefense => {
-      // Ajout du # d'utilisation ce round  
-      armeDefense.nbUsage = defender.getItemUse(armeDefense.id)
-      armeDefense.typeParade = RdDItemArme.defenseArmeParade(armeAttaque, armeDefense)
-    })
+  _filterArmesParade(defender, competence) {
+    let items = defender.items.filter(it => RdDItemArme.isArmeUtilisable(it) || RdDItemCompetenceCreature.isCompetenceParade(it))
+    items.forEach(item => item.system.nbUsage = defender.getItemUse(item.id)); // Ajout du # d'utilisation ce round  
 
     switch (competence.system.categorie) {
       case 'tir':
       case 'lancer':
-        return defenses.filter(armeDefense => RdDItemArme.getCategorieParade(armeDefense) == 'boucliers')
+        return items.filter(item => RdDItemArme.getCategorieParade(item) == 'boucliers')
       default:
-        return defenses.filter(armeDefense => armeDefense.typeParade != '')
+        // Le fléau ne peut être paré qu’au bouclier p115
+        if (competence.name == "Fléau") {
+          return items.filter(item => RdDItemArme.getCategorieParade(item) == 'boucliers')
+        }
+        return items.filter(item => RdDItemArme.getCategorieParade(item));
     }
   }
 
@@ -1014,7 +1075,7 @@ export class RdDCombat {
   /* -------------------------------------------- */
   _prepareParade(attackerRoll, armeParade, competenceParade) {
     let defenderRoll = {
-      alias: this.defender?.getAlias(),
+      alias: this.defenderToken?.name,
       passeArme: attackerRoll.passeArme,
       diffLibre: attackerRoll.diffLibre,
       attackerToken: this.attackerToken,
@@ -1071,7 +1132,7 @@ export class RdDCombat {
   async esquive(attackerRoll, compId, compName) {
     const esquive = this.defender.getCompetence(compId) ?? this.defender.getCompetence(compName)
     if (esquive == undefined) {
-      ui.notifications.error(this.defender.getAlias() + " n'a pas de compétence " + compName);
+      ui.notifications.error(this.defender.name + " n'a pas de compétence " + compName);
       return;
     }
     console.log("RdDCombat.esquive >>>", attackerRoll, esquive);
@@ -1098,7 +1159,7 @@ export class RdDCombat {
   /* -------------------------------------------- */
   _prepareEsquive(attackerRoll, competence) {
     let rollData = {
-      alias: this.defender.getAlias(),
+      alias: this.defenderToken?.name,
       passeArme: attackerRoll.passeArme,
       diffLibre: attackerRoll.diffLibre,
       attackerToken: this.attackerToken,
@@ -1274,15 +1335,11 @@ export class RdDCombat {
 
   /* -------------------------------------------- */
   static async displayActorCombatStatus(combat, actor, token) {
-    if (!actor?.isActorCombat()) {
-      return
-    }
-    const alias = token?.name ?? actor.getAlias();
-    const formData = {
+    let formData = {
       combatId: combat._id,
-      alias: alias,
+      alias: token.name ?? actor.name,
       etatGeneral: actor.getEtatGeneral(),
-      isSonne: actor.isSonne(),
+      isSonne: actor.getSonne(),
       blessuresStatus: actor.computeResumeBlessure(),
       SConst: actor.getSConst(),
       actorId: actor.id,
@@ -1293,12 +1350,12 @@ export class RdDCombat {
     }
     await ChatMessage.create({
       content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-actor-turn-acteur.hbs`, formData),
-      alias: alias
+      alias: token.name ?? actor.name
     })
     await ChatMessage.create({
       content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-actor-turn-sante.hbs`, formData),
       whisper: ChatUtility.getOwners(actor),
-      alias: alias
-    })
+      alias: token.name ?? actor.name
+    });
   }
 }

module/rdd-commands.js

@@ -360,14 +360,13 @@ export class RdDCommands {
 
   async getTMRAleatoire(msg, params) {
     if (params.length < 2) {
-      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}`)
-      }
+      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}`);
+    }
+    else {
+      return false;
     }
-    return false;
   }
 
   async findTMR(msg, params) {
@@ -385,11 +384,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(solvedTMRType.name)
+      return await game.system.rdd.rencontresTMR.chatTable(solvedTerrain);
     }
     return false;
   }

module/rdd-herbes.js

@@ -28,9 +28,9 @@ export class RdDHerbes extends Item {
   }
 
   /* -------------------------------------------- */
-  static calculFormData(formData, item) {
-    formData.isSoins = item.system.categorie.includes('Soin');
-    formData.isRepos = item.system.categorie.includes('Repos');
+  static async addPotionFormData(formData) {
+    formData.isSoins = formData.system.categorie.includes('Soin');
+    formData.isRepos = formData.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(item.system.prdate);
+    formData.enchantement = RdDTimestamp.splitIndexDate(formData.system.prdate);
   }
 
   /* -------------------------------------------- */

module/rdd-hotbar-drop.js

@@ -121,7 +121,7 @@ export class RdDHotbar {
         if (item.isCorpsACorps()) {
           switch (categorieArme) {
             case 'pugilat':
-              return actor.rollArme(RdDItemArme.corpsACorps(actor), 'competence');
+              return actor.rollArme(RdDItemArme.mainsNues(actor), 'competence');
             case 'empoignade':
               return actor.rollArme(RdDItemArme.empoignade(actor), 'competence');
           }

module/rdd-main.js

@@ -68,8 +68,6 @@ import { OptionsAvancees } from "./settings/options-avancees.js"
 import { ExportScriptarium } from "./actor/export-scriptarium/export-scriptarium.js"
 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
@@ -89,7 +87,6 @@ export class SystemReveDeDragon {
     this.config = RDD_CONFIG
     this.RdDUtility = RdDUtility
     this.RdDHotbar = RdDHotbar
-    this.RdDStatBlockParser = RdDStatBlockParser
     this.itemClasses = {
       armure: RdDItemArmure,
       blessure: RdDItemBlessure,
@@ -123,7 +120,6 @@ export class SystemReveDeDragon {
     // preload handlebars templates
     RdDUtility.preloadHandlebarsTemplates()
     AppPersonnageAleatoire.preloadHandlebars()
-    RdDItemSort.preloadHandlebars()
 
     /* -------------------------------------------- */
     ReglesOptionnelles.initSettings()
@@ -276,16 +272,6 @@ export class SystemReveDeDragon {
     })
   }
 
-  static async setupAccueil() {
-    let exists = game.scenes.find(j => j.name == "Accueil RdD");
-    if (!exists) {
-      const scenes = await SystemCompendiums.loadCompendium("foundryvtt-reve-de-dragon.scenes-rdd")
-      let newDocuments = scenes.filter(i => i.name == "Accueil RdD");
-      await game.scenes.documentClass.create(newDocuments);
-      game.scenes.find(i => i.name == "Accueil RdD").activate();
-    }
-  }
-
   async onReady() {
 
     /* -------------------------------------------- */
@@ -306,8 +292,6 @@ export class SystemReveDeDragon {
     StatusEffects.onReady()
     RdDHerbes.onReady()
     RdDDice.onReady()
-
-    RdDStatBlockParser.parseStatBlock()
     /* -------------------------------------------- */
     /* Affiche/Init le calendrier */
     game.system.rdd.calendrier.display()
@@ -319,8 +303,6 @@ export class SystemReveDeDragon {
         user: game.user.id
       })
     }
-
-    SystemReveDeDragon.setupAccueil()
   }
 
   /* -------------------------------------------- */

module/rdd-roll.js

@@ -7,7 +7,6 @@ import { RdDBonus } from "./rdd-bonus.js";
 import { RdDCarac } from "./rdd-carac.js";
 import { RdDResolutionTable } from "./rdd-resolution-table.js";
 import { ReglesOptionnelles } from "./settings/regles-optionnelles.js";
-import { Grammar } from "./grammar.js";
 
 /**
  * Extend the base Dialog entity to select roll parameters
@@ -33,7 +32,7 @@ export class RdDRoll extends Dialog {
   /* -------------------------------------------- */
   static _setDefaultOptions(actor, rollData) {
     let defaultRollData = {
-      alias: actor.getAlias(),
+      alias: actor.name,
       ajustementsConditions: CONFIG.RDD.ajustementsConditions,
       difficultesLibres: CONFIG.RDD.difficultesLibres,
       etat: actor.getEtatGeneral(),
@@ -174,8 +173,8 @@ export class RdDRoll extends Dialog {
       this.html.find("[name='diffLibre']").val(this.rollData.diffLibre);
     });
     this.html.find('.roll-carac-competence').change((event) => {
-      const competence = event.currentTarget.value
-      this.rollData.competence = this.rollData.competences.find(it => Grammar.equalsInsensitive(it.name, competence))
+      const competence = event.currentTarget.value;
+      this.rollData.competence = this.rollData.competences.find(it => it.name == competence);
       this.updateRollResult(html);
     });
     this.html.find('.select-suivant-coeur').change((event) => {
@@ -346,25 +345,24 @@ export class RdDRoll extends Dialog {
 
   /* -------------------------------------------- */
   _getTitle(rollData) {
-    const alias = rollData.alias
     const carac = rollData.selectedCarac.label;
     if (!rollData.competence) {
-      return `${alias}: ${carac}`
+      return carac;
     }
     const compName = rollData.competence.name;
     const niveau = Misc.toSignedString(rollData.competence.system.niveau)
     if (compName == carac) {
       // cas des créatures
-      return `${alias}: ${carac} Niveau ${niveau}`
+      return `${carac} Niveau ${niveau}`
     }
     if (rollData.draconicList && rollData.selectedSort) {
       // cas de lancer de sort
-      return `${alias}: ${rollData.competence.name} Niveau ${niveau} ${rollData.selectedSort.name}`
+      return `${rollData.competence.name} Niveau ${niveau} ${rollData.selectedSort.name}`
     }
     if (rollData.arme && rollData.arme.name != compName) {
       // ajouter l'arme au titre si son nom n'est pas la compétence
-      return `${alias}: ${carac} /  ${compName} (${rollData.arme.name}) Niveau ${niveau}`
+      return `${carac} /  ${compName} (${rollData.arme.name}) Niveau ${niveau}`
     }
-    return `${alias}: ${carac} / ${compName} Niveau ${niveau}`
+    return `${carac} / ${compName} Niveau ${niveau}`
   }
 }

module/rdd-rolltables.js

@@ -1,3 +1,4 @@
+import { Grammar } from "./grammar.js";
 import { CompendiumTable, CompendiumTableHelpers, SystemCompendiums } from "./settings/system-compendiums.js";
 
 export class RdDRollTables {

module/rdd-tmr-dialog.js

@@ -460,7 +460,7 @@ export class RdDTMRDialog extends Dialog {
 
     let rencontreData = {
       actor: this.actor,
-      alias: this.actor.getAlias(),
+      alias: this.actor.name,
       reveDepart: this.actor.getReveActuel(),
       competence: this.actor.getBestDraconic(),
       rencontre: this.currentRencontre,
@@ -641,7 +641,7 @@ export class RdDTMRDialog extends Dialog {
     // simuler une rencontre
     let rencontreData = {
       actor: this.actor,
-      alias: this.actor.getAlias(),
+      alias: this.actor.name,
       reveDepart: this.actor.getReveActuel(),
       competence: this.actor.getBestDraconic(),
       rencontre: this.currentRencontre,
@@ -1098,10 +1098,7 @@ export class RdDTMRDialog extends Dialog {
     if (!this.viewOnly && this.actor.isResonanceSigneDraconique(coord)) {
       ChatMessage.create({
         whisper: ChatUtility.getOwners(this.actor),
-        content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-signe-draconique-resonance.html`, {
-          alias: this.actor.getAlias(),
-          typeTMR: TMRUtility.getTMRType(coord)
-        })
+        content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-signe-draconique-resonance.html`, { alias: this.actor.name, typeTMR: TMRUtility.getTMRType(coord) })
       });
     }
   }

module/rdd-token-hud.js

@@ -28,15 +28,16 @@ export class RdDTokenHud {
     await RdDTokenHud.addExtensionHudSoins(html, actor);
 
     if (isCombat) {
-      const combatant = game.combat.combatants.find(c => c.tokenId == tokenId)
-      const actor = RdDCombatManager.getActorCombatant(combatant, { warning: false })
-      if (actor) {
-        let actions = RdDCombatManager.listActionsActorCombatant(actor)
-        // initiative
-        await RdDTokenHud.addExtensionHudInit(html, combatant, actions)
-        // combat
-        await RdDTokenHud.addExtensionHudCombat(html, combatant, token, actions)
+      let combatant = game.combat.combatants.find(c => c.tokenId == tokenId);
+      if (!(combatant?.actor)) {
+        ui.notifications.warn(`Le combatant ${token.name} n'est pas associé à un acteur, impossible de déterminer ses actions de combat!`)
+        return;
       }
+      let actions = RdDCombatManager.listActionsCombat(combatant);
+      // initiative
+      await RdDTokenHud.addExtensionHudInit(html, combatant, actions);
+      // combat
+      await RdDTokenHud.addExtensionHudCombat(html, combatant, token, actions);
     }
 
 

module/rdd-utility.js

@@ -609,12 +609,12 @@ export class RdDUtility {
     const encaissement = RdDUtility._selectEncaissement(jetTotal, rollData.dmg.mortalite);
     const over20 = Math.max(jetTotal - 20, 0);
     encaissement.dmg = rollData.dmg
-    if (ReglesOptionnelles.isUsing('localisation-aleatoire')) {
+    if (ReglesOptionnelles.isUsing('localisation-aleatoire')){
       encaissement.dmg.loc = rollData.dmg.loc ?? await RdDUtility.getLocalisation(actor.type)
       encaissement.dmg.loc.label = encaissement.dmg.loc.label ?? 'Corps;'
     }
-    else {
-      encaissement.dmg.loc = { label: '' }
+    else{
+      encaissement.dmg.loc = {label:''}
     }
     encaissement.dmg.bonusDegatsDiffLibre = bonusDegatsDiffLibre
     encaissement.roll = roll;
@@ -749,7 +749,7 @@ export class RdDUtility {
   static getSelectedToken(actor) {
     if (canvas.tokens.controlled.length > 0) {
       const tokens = canvas.tokens.controlled
-        .filter(it => it.actor.id == actor.id)
+         .filter(it => it.actor.id == actor.id)
       return tokens[0]
     }
     return undefined
@@ -881,10 +881,10 @@ export class RdDUtility {
   /* -------------------------------------------- */
   static afficherHeuresChanceMalchance(heureNaissance) {
     if (game.user.isGM) {
-      const heure = RdDTimestamp.findHeure(heureNaissance)
+      const heure = RdDTimestamp.findHeure(heureNaissance - 1);
       if (heureNaissance && heure) {
-        const ajustement = game.system.rdd.calendrier.getAjustementAstrologique(heureNaissance)
-        const current = game.system.rdd.calendrier.heureCourante()
+        let ajustement = game.system.rdd.calendrier.getAjustementAstrologique(heureNaissance);
+        const current = game.system.rdd.calendrier.heureCourante();
         ChatMessage.create({
           content: `A l'heure de <strong>${current.label}</strong>, le modificateur de Chance/Malchance est de <strong>${Misc.toSignedString(ajustement)}</strong> pour l'heure de naissance <strong>${heure.label}</strong>.`,
           whisper: ChatUtility.getGMs()

module/settings/status-effects.js

@@ -15,17 +15,17 @@ export const STATUSES = {
 }
 
 const rddStatusEffects = [
-  { rdd: true, id: STATUSES.StatusStunned, name:  'EFFECT.StatusStunned', img: 'icons/svg/stoned.svg', "duration.rounds": 1 },
-  { rdd: true, id: STATUSES.StatusBleeding, name:  'EFFECT.StatusBleeding', img: 'icons/svg/blood.svg' },
-  { rdd: true, id: STATUSES.StatusProne, name:  'EFFECT.StatusProne', img: 'icons/svg/falling.svg' },
-  { rdd: true, id: STATUSES.StatusGrappling, tint: '#33cc33', name:  'EFFECT.StatusGrappling', img: 'systems/foundryvtt-reve-de-dragon/icons/empoignade.webp' },
-  { rdd: true, id: STATUSES.StatusGrappled, tint: '#ff9900', name:  'EFFECT.StatusGrappled', img: 'systems/foundryvtt-reve-de-dragon/icons/empoignade.webp' },
-  { rdd: true, id: STATUSES.StatusRestrained, name:  'EFFECT.StatusRestrained', img: 'icons/svg/net.svg' },
-  { rdd: true, id: STATUSES.StatusUnconscious, name:  'EFFECT.StatusUnconscious', img: 'icons/svg/unconscious.svg' },
-  { rdd: true, id: STATUSES.StatusBlind, name:  'EFFECT.StatusBlind', img: 'icons/svg/blind.svg' },
-  { rdd: true, id: STATUSES.StatusComma, name:  'EFFECT.StatusComma', img: 'icons/svg/skull.svg' },
-  { rdd: true, id: STATUSES.StatusDead, name:  'EFFECT.StatusDead', img: 'icons/svg/skull.svg' },
-  { rdd: true, id: STATUSES.StatusDemiReve, name:  'EFFECT.StatusDemiReve', img: 'systems/foundryvtt-reve-de-dragon/icons/heures/hd12.svg' }
+  { rdd: true, id: STATUSES.StatusStunned, label: 'EFFECT.StatusStunned', icon: 'icons/svg/stoned.svg', "duration.rounds": 1 },
+  { rdd: true, id: STATUSES.StatusBleeding, label: 'EFFECT.StatusBleeding', icon: 'icons/svg/blood.svg' },
+  { rdd: true, id: STATUSES.StatusProne, label: 'EFFECT.StatusProne', icon: 'icons/svg/falling.svg' },
+  { rdd: true, id: STATUSES.StatusGrappling, tint: '#33cc33', label: 'EFFECT.StatusGrappling', icon: 'systems/foundryvtt-reve-de-dragon/icons/empoignade.webp' },
+  { rdd: true, id: STATUSES.StatusGrappled, tint: '#ff9900', label: 'EFFECT.StatusGrappled', icon: 'systems/foundryvtt-reve-de-dragon/icons/empoignade.webp' },
+  { rdd: true, id: STATUSES.StatusRestrained, label: 'EFFECT.StatusRestrained', icon: 'icons/svg/net.svg' },
+  { rdd: true, id: STATUSES.StatusUnconscious, label: 'EFFECT.StatusUnconscious', icon: 'icons/svg/unconscious.svg' },
+  { rdd: true, id: STATUSES.StatusBlind, label: 'EFFECT.StatusBlind', icon: 'icons/svg/blind.svg' },
+  { rdd: true, id: STATUSES.StatusComma, label: 'EFFECT.StatusComma', icon: 'icons/svg/skull.svg' },
+  { rdd: true, id: STATUSES.StatusDead, label: 'EFFECT.StatusDead', icon: 'icons/svg/skull.svg' },
+  { rdd: true, id: STATUSES.StatusDemiReve, label: 'EFFECT.StatusDemiReve', icon: 'systems/foundryvtt-reve-de-dragon/icons/heures/hd12.svg' }
 ];
 const demiReveStatusEffect = rddStatusEffects.find(it => it.id == STATUSES.StatusDemiReve);
 
@@ -57,7 +57,7 @@ export class StatusEffects extends FormApplication {
       restricted: true
     });
 
-    CONFIG.RDD.allEffects = rddStatusEffects.concat(CONFIG.statusEffects.filter(it => !rddEffectIds.includes(it.id)))
+    CONFIG.RDD.allEffects = rddStatusEffects.concat(CONFIG.statusEffects.filter(it => !rddEffectIds.includes(it.id)));
 
     StatusEffects._setUseStatusEffects(StatusEffects._getUseStatusEffects());
     console.log('statusEffects', CONFIG.statusEffects);

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,18 +71,16 @@ export class SystemCompendiums extends FormApplication {
 
   static async getCompetences(actorType) {
     switch (actorType ?? 'personnage') {
-      case 'personnage':
-        return await SystemCompendiums.getWorldOrCompendiumItems('competence', 'competences')
-      case 'entite':
-      case 'creature':
-        return await SystemCompendiums.getWorldOrCompendiumItems('competencecreature', 'competences-creatures')
+      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 '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());
@@ -114,19 +112,6 @@ export class SystemCompendiums extends FormApplication {
     return elements;
   }
 
-  /* -------------------------------------------- */
-  static async loadCompendiumData(compendium) {
-    const pack = game.packs.get(compendium);
-    return await pack?.getDocuments() ?? [];
-  }
-
-  /* -------------------------------------------- */
-  static async loadCompendium(compendium, filter = item => true) {
-    let compendiumData = await SystemCompendiums.loadCompendiumData(compendium);
-    return compendiumData.filter(filter);
-  }
-
-
   static async getDefaultItems(compendium) {
     const pack = game.packs.get(SystemCompendiums._getDefaultCompendium(compendium));
     if (pack.metadata.type == 'Item') {
@@ -286,20 +271,23 @@ export class CompendiumTableHelpers {
   }
 
   /* -------------------------------------------- */
-  static async tableRowToChatMessage(row, type, options = { showSource: true }) {
+  static async tableRowToChatMessage(row, type = 'Item') {
     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,
-      rolls: [row.roll],
+      type: CONST.CHAT_MESSAGE_TYPES.ROLL,
+      roll: row.roll,
       sound: CONFIG.sounds.dice,
       content: flavorContent
     };

module/time/auto-adjust-darkness.js

@@ -15,7 +15,7 @@ export class AutoAdjustDarkness {
   }
 
   static async adjust(darkness) {
-    if (game.user.isGM && AutoAdjustDarkness.isAuto()) {
+    if (AutoAdjustDarkness.isAuto()) {
       const scene = game.scenes.viewed;
       if (scene?.environment?.globalLight?.enabled && scene?.tokenVision) {
         await scene.update({ darkness });

module/time/rdd-timestamp.js

@@ -160,21 +160,15 @@ export class RdDTimestamp {
   }
 
   static findHeure(heure) {
-    let filtered
-    if (Number.isInteger(Number(heure))) {
-      filtered = DEFINITION_HEURES.filter(it => it.heure == Misc.modulo(Number(heure) - 1, RDD_HEURES_PAR_JOUR))
+    heure = Grammar.toLowerCaseNoAccentNoSpace(heure);
+    let parHeureOuLabel = DEFINITION_HEURES.filter(it => Grammar.toLowerCaseNoAccentNoSpace(it.label) == heure || it.heure == Misc.modulo(parseInt(heure), RDD_HEURES_PAR_JOUR));
+    if (parHeureOuLabel.length == 1) {
+      return parHeureOuLabel[0];
     }
-    else {
-      heure = Grammar.toLowerCaseNoAccentNoSpace(heure);
-      filtered = DEFINITION_HEURES.filter(it => Grammar.toLowerCaseNoAccentNoSpace(it.label) == heure || it.heure == Misc.modulo(parseInt(heure), RDD_HEURES_PAR_JOUR));
-    }
-    if (filtered.length == 1) {
-      return filtered[0]
-    }
-    filtered = DEFINITION_HEURES.filter(it => Grammar.toLowerCaseNoAccentNoSpace(it.label).includes(heure));
-    if (filtered.length > 0) {
-      filtered.sort(Misc.ascending(h => h.label.length));
-      return filtered[0]
+    let parLabelPartiel = DEFINITION_HEURES.filter(it => Grammar.toLowerCaseNoAccentNoSpace(it.label).includes(heure));
+    if (parLabelPartiel.length > 0) {
+      parLabelPartiel.sort(Misc.ascending(h => h.label.length));
+      return parLabelPartiel[0];
     }
     return undefined;
   }

module/tmr-rencontres.js

@@ -26,19 +26,22 @@ export class TMRRencontres {
    * @param {*} forcedRoll 
    */
   async rollRencontre(terrain, forcedRoll) {
-    const tmrType = TMRUtility.findTMRLike(terrain)?.type
-    if (tmrType == undefined) {
+    terrain = TMRUtility.findTMRLike(terrain);
+    if (terrain == undefined) {
       return undefined;
     }
 
     if (forcedRoll && (forcedRoll <= 0 || forcedRoll > 100)) {
       forcedRoll = undefined;
     }
-    const filtreMauvaise = tmrType == 'mauvaise' ? it => it.system.mauvaiseRencontre : it => !it.system.mauvaiseRencontre;
-    const frequence = it => it.system.frequence[tmrType];
+    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 row = await this.table.getRandom(frequence, filtreMauvaise, forcedRoll);
     if (row) {
-      await CompendiumTableHelpers.tableRowToChatMessage(row, 'Item', {showSource: false});
+      console.log("DORM", row);
+      //row.document.system.computedForce = new Roll(row.document.system.formula).roll({async: false}).total; 
+      await CompendiumTableHelpers.tableRowToChatMessage(row);
     }
 
     return row?.document;

module/tmr-utility.js

@@ -2,216 +2,228 @@ import { Misc } from "./misc.js";
 import { Grammar } from "./grammar.js";
 import { RdDDice } from "./rdd-dice.js";
 
-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" }
+/* -------------------------------------------- */
+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 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" }
+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" }
 }
 
 /* -------------------------------------------- */
@@ -239,16 +251,13 @@ const TMR_MOVE = {
  */
 export class TMRUtility {
   static init() {
-
     for (let coord in TMRMapping) {
-      const tmr = TMRMapping[coord]
-      tmr.coord = coord
-      tmr.genre = TMRType[tmr.type].genre
-      if (coord != FLEUVE_COORD) {
-        tmr.oddq = TMRUtility.coordTMRToOddq(coord)
-      }
+      const tmr = TMRMapping[coord];
+      tmr.coord = coord;
+      tmr.oddq = TMRUtility.coordTMRToOddq(coord);
+      tmr.genre = TMRType[tmr.type].genre;
     }
-    let tmrByType = Misc.classify(Object.values(TMRMapping).filter(it => it.coord != FLEUVE_COORD))
+    let tmrByType = Misc.classify(Object.values(TMRMapping));
     for (const [type, list] of Object.entries(tmrByType)) {
       TMRType[type].list = list;
     }
@@ -256,17 +265,14 @@ export class TMRUtility {
 
   /* -------------------------------------------- */
   static verifyTMRCoord(coord) {
-    return Grammar.equalsInsensitive(coord, FLEUVE_COORD) || TMRUtility.getTMR(coord);
+    return Grammar.equalsInsensitive(coord, 'Fleuve') || TMRUtility.getTMR(coord);
   }
 
   /* -------------------------------------------- */
   static getTMR(coord) {
-    return coord == FLEUVE_COORD ? TMRMapping['D1'] : TMRMapping[coord];
+    return coord == 'Fleuve' ? 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");
   }
@@ -284,18 +290,18 @@ export class TMRUtility {
   static findTMRLike(type, options = { inclusMauvaise: true }) {
     const choix = [...Object.values(TMRType)]
     if (options.inclusMauvaise) {
-      choix.push({ name: 'Mauvaise', type: 'mauvaise'});
+      choix.push({ name: 'Mauvaise' });
     }
-    const selection = Misc.findAllLike(type, choix)
+    const selection = Misc.findAllLike(type, choix).map(it => it.name);
     if (selection.length == 0) {
       ui.notifications.warn(`Un type de TMR doit être indiqué, '${type}' n'est pas trouvé dans ${choix}`);
-      return undefined
-    }
-    if (selection.length > 1) {
-      ui.notifications.warn(`Plusieurs types de TMR pourraient correspondre à '${type}': ${selection.map(it => it.name)}`);
       return undefined;
     }
-    return selection[0]
+    if (selection.length > 1) {
+      ui.notifications.warn(`Plusieurs types de TMR pourraient correspondre à '${type}': ${selection}`);
+      return undefined;
+    }
+    return selection[0];
   }
 
   static typeTmrName(type) {
@@ -320,7 +326,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
     }

pack_ref/animaux/CURRENT

@@ -1 +0,0 @@
-MANIFEST-000022

pack_ref/animaux/LOG

@@ -1,3 +0,0 @@
-2024/11/10-18:39:00.183093 7fed63e006c0 Recovering log #21
-2024/11/10-18:39:00.195436 7fed63e006c0 Delete type=0 #21
-2024/11/10-18:39:00.195482 7fed63e006c0 Delete type=3 #20

pack_ref/animaux/LOG.old

@@ -1,3 +0,0 @@
-2024/11/10-18:38:41.533242 7f4c0b8006c0 Recovering log #19
-2024/11/10-18:38:41.547823 7f4c0b8006c0 Delete type=0 #19
-2024/11/10-18:38:41.547917 7f4c0b8006c0 Delete type=3 #18

pack_ref/archetypes/CURRENT

@@ -1 +0,0 @@
-MANIFEST-000010

pack_ref/archetypes/LOG

@@ -1,3 +0,0 @@
-2024/11/10-18:39:00.253481 7fed62a006c0 Recovering log #8
-2024/11/10-18:39:00.263751 7fed62a006c0 Delete type=3 #6
-2024/11/10-18:39:00.263866 7fed62a006c0 Delete type=0 #8

pack_ref/archetypes/LOG.old

@@ -1,8 +0,0 @@
-2024/11/08-19:40:34.139501 7f9d7f4006c0 Recovering log #4
-2024/11/08-19:40:34.182207 7f9d7f4006c0 Delete type=3 #2
-2024/11/08-19:40:34.182311 7f9d7f4006c0 Delete type=0 #4
-2024/11/08-19:56:45.129455 7f9d7d6006c0 Level-0 table #9: started
-2024/11/08-19:56:45.129487 7f9d7d6006c0 Level-0 table #9: 0 bytes OK
-2024/11/08-19:56:45.135738 7f9d7d6006c0 Delete type=0 #7
-2024/11/08-19:56:45.142639 7f9d7d6006c0 Manual compaction at level-0 from '!actors!1Nng9d8r6lrPHCaJ' @ 72057594037927935 : 1 .. '!actors.items!ryUZTa17LzNv25UY.zyNYa3hYtrOcF2jA' @ 0 : 0; will stop at (end)
-2024/11/08-19:56:45.142697 7f9d7d6006c0 Manual compaction at level-1 from '!actors!1Nng9d8r6lrPHCaJ' @ 72057594037927935 : 1 .. '!actors.items!ryUZTa17LzNv25UY.zyNYa3hYtrOcF2jA' @ 0 : 0; will stop at (end)

pack_ref/arts-et-divertissements/CURRENT

@@ -1 +0,0 @@
-MANIFEST-000010

pack_ref/arts-et-divertissements/LOG

@@ -1,3 +0,0 @@
-2024/11/10-18:39:00.448675 7fed63e006c0 Recovering log #8
-2024/11/10-18:39:00.460061 7fed63e006c0 Delete type=3 #6
-2024/11/10-18:39:00.460115 7fed63e006c0 Delete type=0 #8

pack_ref/arts-et-divertissements/LOG.old

@@ -1,8 +0,0 @@
-2024/11/08-19:40:32.605216 7f9d7fe006c0 Recovering log #4
-2024/11/08-19:40:32.664872 7f9d7fe006c0 Delete type=3 #2
-2024/11/08-19:40:32.665020 7f9d7fe006c0 Delete type=0 #4
-2024/11/08-19:56:44.948429 7f9d7d6006c0 Level-0 table #9: started
-2024/11/08-19:56:44.948495 7f9d7d6006c0 Level-0 table #9: 0 bytes OK
-2024/11/08-19:56:44.954943 7f9d7d6006c0 Delete type=0 #7
-2024/11/08-19:56:44.975424 7f9d7d6006c0 Manual compaction at level-0 from '!items!240HPtZsgZQERFMF' @ 72057594037927935 : 1 .. '!items!zRQ5WnPI483CKm9Q' @ 0 : 0; will stop at (end)
-2024/11/08-19:56:44.975473 7f9d7d6006c0 Manual compaction at level-1 from '!items!240HPtZsgZQERFMF' @ 72057594037927935 : 1 .. '!items!zRQ5WnPI483CKm9Q' @ 0 : 0; will stop at (end)

pack_ref/competences-creatures/CURRENT

@@ -1 +0,0 @@
-MANIFEST-000010

pack_ref/competences-creatures/LOG

@@ -1,3 +0,0 @@
-2024/11/10-18:39:00.493027 7fed63e006c0 Recovering log #8
-2024/11/10-18:39:00.503119 7fed63e006c0 Delete type=3 #6
-2024/11/10-18:39:00.503242 7fed63e006c0 Delete type=0 #8

pack_ref/competences-creatures/LOG.old

@@ -1,8 +0,0 @@
-2024/11/08-19:40:32.670029 7f9d7ea006c0 Recovering log #4
-2024/11/08-19:40:32.734322 7f9d7ea006c0 Delete type=3 #2
-2024/11/08-19:40:32.734474 7f9d7ea006c0 Delete type=0 #4
-2024/11/08-19:56:44.968549 7f9d7d6006c0 Level-0 table #9: started
-2024/11/08-19:56:44.968601 7f9d7d6006c0 Level-0 table #9: 0 bytes OK
-2024/11/08-19:56:44.975299 7f9d7d6006c0 Delete type=0 #7
-2024/11/08-19:56:44.975466 7f9d7d6006c0 Manual compaction at level-0 from '!items!0zRL8bOpCXNQnIR4' @ 72057594037927935 : 1 .. '!items!yDHZfK4RmwQW4YaW' @ 0 : 0; will stop at (end)
-2024/11/08-19:56:44.975488 7f9d7d6006c0 Manual compaction at level-1 from '!items!0zRL8bOpCXNQnIR4' @ 72057594037927935 : 1 .. '!items!yDHZfK4RmwQW4YaW' @ 0 : 0; will stop at (end)

pack_ref/competences-entites/CURRENT

@@ -1 +0,0 @@
-MANIFEST-000010

pack_ref/competences-entites/LOG

@@ -1,3 +0,0 @@
-2024/11/10-18:39:00.509122 7fed634006c0 Recovering log #8
-2024/11/10-18:39:00.519320 7fed634006c0 Delete type=3 #6
-2024/11/10-18:39:00.519377 7fed634006c0 Delete type=0 #8

pack_ref/competences-entites/LOG.old

@@ -1,8 +0,0 @@
-2024/11/08-19:40:32.738419 7f9d7f4006c0 Recovering log #4
-2024/11/08-19:40:32.795459 7f9d7f4006c0 Delete type=3 #2
-2024/11/08-19:40:32.795589 7f9d7f4006c0 Delete type=0 #4
-2024/11/08-19:56:44.996588 7f9d7d6006c0 Level-0 table #9: started
-2024/11/08-19:56:44.996618 7f9d7d6006c0 Level-0 table #9: 0 bytes OK
-2024/11/08-19:56:45.003008 7f9d7d6006c0 Delete type=0 #7
-2024/11/08-19:56:45.003203 7f9d7d6006c0 Manual compaction at level-0 from '!items!0Ms9iKxqigNNpZEx' @ 72057594037927935 : 1 .. '!items!wDHR5UHWq568lfGa' @ 0 : 0; will stop at (end)
-2024/11/08-19:56:45.003226 7f9d7d6006c0 Manual compaction at level-1 from '!items!0Ms9iKxqigNNpZEx' @ 72057594037927935 : 1 .. '!items!wDHR5UHWq568lfGa' @ 0 : 0; will stop at (end)

pack_ref/competences/CURRENT

@@ -1 +0,0 @@
-MANIFEST-000010

pack_ref/competences/LOG

@@ -1,3 +0,0 @@
-2024/11/10-18:39:00.471288 7fed63e006c0 Recovering log #8
-2024/11/10-18:39:00.481737 7fed63e006c0 Delete type=3 #6
-2024/11/10-18:39:00.481786 7fed63e006c0 Delete type=0 #8

pack_ref/competences/LOG.old

@@ -1,8 +0,0 @@
-2024/11/08-19:40:32.544114 7f9d7e0006c0 Recovering log #4
-2024/11/08-19:40:32.600711 7f9d7e0006c0 Delete type=3 #2
-2024/11/08-19:40:32.600809 7f9d7e0006c0 Delete type=0 #4
-2024/11/08-19:56:44.962085 7f9d7d6006c0 Level-0 table #9: started
-2024/11/08-19:56:44.962125 7f9d7d6006c0 Level-0 table #9: 0 bytes OK
-2024/11/08-19:56:44.968340 7f9d7d6006c0 Delete type=0 #7
-2024/11/08-19:56:44.975455 7f9d7d6006c0 Manual compaction at level-0 from '!items!2JLK5e97WbTM5WxX' @ 72057594037927935 : 1 .. '!items!zyNYa3hYtrOcF2jA' @ 0 : 0; will stop at (end)
-2024/11/08-19:56:44.975495 7f9d7d6006c0 Manual compaction at level-1 from '!items!2JLK5e97WbTM5WxX' @ 72057594037927935 : 1 .. '!items!zyNYa3hYtrOcF2jA' @ 0 : 0; will stop at (end)

pack_ref/entites-de-cauchemar/CURRENT

@@ -1 +0,0 @@
-MANIFEST-000010

pack_ref/entites-de-cauchemar/LOG

@@ -1,3 +0,0 @@
-2024/11/10-18:39:00.523722 7fed690006c0 Recovering log #8
-2024/11/10-18:39:00.533930 7fed690006c0 Delete type=3 #6
-2024/11/10-18:39:00.533977 7fed690006c0 Delete type=0 #8

pack_ref/entites-de-cauchemar/LOG.old

@@ -1,8 +0,0 @@
-2024/11/08-19:40:34.274388 7f9d7f4006c0 Recovering log #4
-2024/11/08-19:40:34.331636 7f9d7f4006c0 Delete type=3 #2
-2024/11/08-19:40:34.331841 7f9d7f4006c0 Delete type=0 #4
-2024/11/08-19:56:45.135878 7f9d7d6006c0 Level-0 table #9: started
-2024/11/08-19:56:45.135910 7f9d7d6006c0 Level-0 table #9: 0 bytes OK
-2024/11/08-19:56:45.142458 7f9d7d6006c0 Delete type=0 #7
-2024/11/08-19:56:45.142680 7f9d7d6006c0 Manual compaction at level-0 from '!actors!47YUryMgpq1UnLuB' @ 72057594037927935 : 1 .. '!actors.items!xngqS9HtwWOLf3Vo.iwfr7ekbLFzDCayP' @ 0 : 0; will stop at (end)
-2024/11/08-19:56:45.142706 7f9d7d6006c0 Manual compaction at level-1 from '!actors!47YUryMgpq1UnLuB' @ 72057594037927935 : 1 .. '!actors.items!xngqS9HtwWOLf3Vo.iwfr7ekbLFzDCayP' @ 0 : 0; will stop at (end)

pack_ref/equipement/CURRENT

@@ -1 +0,0 @@
-MANIFEST-000010

pack_ref/equipement/LOG

@@ -1,3 +0,0 @@
-2024/11/10-18:39:00.544474 7fed690006c0 Recovering log #8
-2024/11/10-18:39:00.555177 7fed690006c0 Delete type=3 #6
-2024/11/10-18:39:00.555255 7fed690006c0 Delete type=0 #8

pack_ref/equipement/LOG.old

@@ -1,8 +0,0 @@
-2024/11/08-19:40:33.076530 7f9d7e0006c0 Recovering log #4
-2024/11/08-19:40:33.128870 7f9d7e0006c0 Delete type=3 #2
-2024/11/08-19:40:33.128972 7f9d7e0006c0 Delete type=0 #4
-2024/11/08-19:56:45.003377 7f9d7d6006c0 Level-0 table #9: started
-2024/11/08-19:56:45.003402 7f9d7d6006c0 Level-0 table #9: 0 bytes OK
-2024/11/08-19:56:45.009778 7f9d7d6006c0 Delete type=0 #7
-2024/11/08-19:56:45.031135 7f9d7d6006c0 Manual compaction at level-0 from '!items!0I30m9qcYJk6UR6o' @ 72057594037927935 : 1 .. '!items!zlDa1vwmls6Uf4pt' @ 0 : 0; will stop at (end)
-2024/11/08-19:56:45.031185 7f9d7d6006c0 Manual compaction at level-1 from '!items!0I30m9qcYJk6UR6o' @ 72057594037927935 : 1 .. '!items!zlDa1vwmls6Uf4pt' @ 0 : 0; will stop at (end)