Merge pull request '## 11.2.20 - Le soulagement d'Akarlikarlikar' (#698) from VincentVk/foundryvtt-reve-de-dragon:v11 into v11

Reviewed-on: #698

changelog.md

@@ -1,4 +1,43 @@
 # 11.2
+## 11.2.20 - Le soulagement d'Akarlikarlikar
+
+- L'option 'ajout de la difficulté d'attaque à l'encaissement est affichée comme un modificateur d'encaissement
+- Les options d'encaissement alternative fonctionnent avec la validation du gardien
+- La fenêtre d'astrologie du gardien affiche toutes les heures lues par un personnage
+- Si aucune expérience n'est gagnée, les autres effets à appliquer (comme la récupération de seuil après avoir vaincu un rêve de Dragon) s'appliquent normalement
+- Les tooltips de Foundry sont maintenant lisibles
+- On n'accorde plus les entités de cauchemar deux fois quand le gardien valide les encaissements
+- Les messages de récupération de rêve en cas de Rêve de Dragon sont clarifiés
+
+## 11.2.19 - Les hémorroïdes d'Akarlikarlikar
+- La validation des jets d'encaissement par le Gardien fonctionne de nouveau
+
+## 11.2.18 - Le bourrichon d'Akarlikarlikar
+- Les différentes listes de la feuille de personnage ont maintenant le bouton pour envoyer dans le tchat
+
+## 11.2.17 - Le cache-oeil d'Akarlikarlikar
+- Le titre des fenêtre d'objet affiche de nouveau le type traduit
+- Les tooltips des boutons edit/delete sont maintenant en Français
+- La case à cocher "Cacher les points de tâches" fonctionne de nouveau
+- Les personnages non-liés ne sont plus dans les liste de personnages joueurs pour le repos, le stress, la fatigue
+- L'utilisation de Thanatos est visible dans l'onglet Haut-Rêve pour indiquer que la prochaine queue est une ombre
+- La fenêtre des TMRs ne devrait plus afficher une zone noire au lieu de la carte.
+
+## 11.2.16 - Le Tri d'Akarlikarlikar
+- Tri alphabétique des items dans la fenêtre de création
+- Mise à jour comptage de monde
+
+## 11.2.15 - La Table d'Akarlikarlikar
+- Tirage automatique de la foce d'une rencontre (via la commande /tmrr)
+- Ajout de boutons pour ajouter des blessures "complètes" (ie avec perte d'endurance/vie)
+
+## 11.2.14 - Les petits pas d'Akarlikarlikar
+- Correction sur la gestion de la surprise
+- Ordre des messages sur les cases humides
+
+## 11.2.13 - Les cent pas d'Akarlikarlikar
+- Ajout de la commande /voyage pour gérer la fatigue de marche des voyageurs
+
 ## 11.2.12 - Le somnifère  d'Akarlikarlikar
 - Fix: les potions enchantées n'empêchent plus de finir correctement Château Dormant
 

lang/fr.json

@@ -1,55 +1,56 @@
 {
   "TYPES": {
     "Actor": { 
-      "Personnage": "Personnage",
+      "personnage": "Personnage",
-      "Creature": "Créature",
+      "creature": "Créature",
-      "Entite": "Entité de cauchemar",
+      "entite": "Entité de cauchemar",
-      "Commerce": "Commerce",
+      "commerce": "Commerce",
-      "Vehicule": "Véhicule"
+      "vehicule": "Véhicule"
     },
     "Item": {
-      "Arme": "Arme",
+      "arme": "Arme",
-      "Armure": "Armure",
+      "armure": "Armure",
-      "Blessure": "Blessure",
+      "blessure": "Blessure",
-      "Casetmr": "TMR spéciale",
+      "casetmr": "Case TMR spéciale",
-      "Chant": "Chant",
+      "chant": "Chant",
-      "Competence": "Compétence",
+      "competence": "Compétence",
-      "Competencecreature": "Compétence de créature",
+      "competencecreature": "Compétence de créature",
-      "Conteneur": "Conteneur",
+      "conteneur": "Conteneur",
-      "Danse": "Danse",
+      "danse": "Danse",
-      "Extraitpoetique": "Extrait poetique",
+      "empoignade": "Empoignade",
-      "Faune": "Faune",
+      "extraitpoetique": "Extrait poetique",
-      "Gemme": "Gemme",
+      "faune": "Faune",
-      "Herbe": "Herbe",
+      "gemme": "Gemme",
-      "Ingredient": "Ingrédient",
+      "herbe": "Herbe",
-      "Jeu": "Jeu",
+      "ingredient": "Ingrédient",
-      "Livre": "Livre",
+      "jeu": "Jeu",
-      "Maladie": "Maladie",
+      "livre": "Livre",
-      "Meditation": "Méditation",
+      "maladie": "Maladie",
-      "Monnaie": "Monnaie",
+      "meditation": "Méditation",
-      "Munition": "Munition",
+      "monnaie": "Monnaie",
-      "Musique": "Musique",
+      "munition": "Munition",
-      "Nombreastral": "Nombre astral",
+      "musique": "Musique",
-      "Nourritureboisson": "Nourriture & boisson",
+      "nombreastral": "Nombre astral",
-      "Objet": "Objet",
+      "nourritureboisson": "Nourriture & boisson",
-      "Oeuvre": "Oeuvre",
+      "objet": "Objet",
-      "Ombre": "Ombre de Thanatos",
+      "oeuvre": "Oeuvre",
-      "Plante": "Plante",
+      "ombre": "Ombre de Thanatos",
-      "Poison": "Poison",
+      "plante": "Plante",
-      "Possession": "Possession",
+      "poison": "Poison",
-      "Potion": "Potion",
+      "possession": "Possession",
-      "Queue": "Queue de Dragon",
+      "potion": "Potion",
-      "Recettealchimique": "Recette alchimique",
+      "queue": "Queue de Dragon",
-      "Recettecuisine": "Recette de cuisine",
+      "recettealchimique": "Recette alchimique",
-      "Rencontre": "Rencontre TMR",
+      "recettecuisine": "Recette de cuisine",
-      "Service": "Service",
+      "rencontre": "Rencontre TMR",
-      "Signedraconique": "Signe draconique",
+      "service": "Service",
-      "Sort": "Sort",
+      "signedraconique": "Signe draconique",
-      "Sortreserve": "Sort en réserve",
+      "sort": "Sort",
-      "Souffle": "Souffle de Dragon",
+      "sortreserve": "Sort en réserve",
-      "Tache": "Tâche",
+      "souffle": "Souffle de Dragon",
-      "Tarot": "Carte de tarot",
+      "tache": "Tâche",
-      "Tete": "Tête de Dragon"
+      "tarot": "Carte de tarot",
+      "tete": "Tête de Dragon"
     }
   },
   "EFFECT": {

module/actor-sheet.js

@@ -28,7 +28,7 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
 
   /** @override */
   static get defaultOptions() {
-    return mergeObject(RdDBaseActorReveSheet.defaultOptions, {
+    return foundry.utils.mergeObject(RdDBaseActorReveSheet.defaultOptions, {
       template: "systems/foundryvtt-reve-de-dragon/templates/actor-sheet.html",
       width: 550,
       showCompNiveauBase: false,
@@ -39,7 +39,7 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
   /* -------------------------------------------- */
   async getData() {
     let formData = await super.getData();
-    mergeObject(formData,
+    foundry.utils.mergeObject(formData,
       {
         editable: this.isEditable,
         cssClass: this.isEditable ? "editable" : "locked",
@@ -49,7 +49,7 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
         biographie: await TextEditor.enrichHTML(this.actor.system.biographie, { async: true }),
         notes: await TextEditor.enrichHTML(this.actor.system.notes, { async: true }),
       });
-    mergeObject(formData.calc, {
+    foundry.utils.mergeObject(formData.calc, {
       surenc: this.actor.computeMalusSurEncombrement(),
       surprise: RdDBonus.find(this.actor.getSurprise(false)).descr,
       resumeBlessures: this.actor.computeResumeBlessure(this.actor.system.blessures),
@@ -80,7 +80,7 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
 
       // toujours avoir une liste d'armes (pour mettre esquive et corps à corps)
       const actor = this.actor;
-      formData.combat = duplicate(formData.armes);
+      formData.combat = foundry.utils.duplicate(formData.armes);
       RdDItemArme.computeNiveauArmes(formData.combat, formData.competences);
       formData.combat.push(RdDItemArme.mainsNues(actor));
       formData.combat.push(RdDItemArme.empoignade(actor));
@@ -221,7 +221,7 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
     // Points de reve actuel
     this.html.find('.ptreve-actuel a').click(async event => this.actor.rollCarac('reve-actuel', true))
     this.html.find('.empoignade-label a').click(async event => RdDEmpoignade.onAttaqueEmpoignadeFromItem(RdDSheetUtility.getItem(event, this.actor)))
-    this.html.find('.arme-label a').click(async event => this.actor.rollArme(duplicate(this._getEventArmeCombat(event))))
+    this.html.find('.arme-label a').click(async event => this.actor.rollArme(foundry.utils.duplicate(this._getEventArmeCombat(event))))
 
     // Initiative pour l'arme
     this.html.find('.arme-initiative a').click(async event => {
@@ -388,7 +388,7 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
   async _onSplitItem(item, split) {
     if (split >= 1 && split < item.system.quantite) {
       await item.diminuerQuantite(split);
-      const splitItem = duplicate(item);
+      const splitItem = foundry.utils.duplicate(item);
       splitItem.system.quantite = split;
       await this.actor.createEmbeddedDocuments('Item', [splitItem])
     }

module/actor.js

@@ -95,30 +95,32 @@ export class RdDActor extends RdDBaseActorSang {
     return ![TYPES.competencecreature, TYPES.tarot, TYPES.service].includes(item.type)
   }
 
+  isPersonnageJoueur() {
+    return this.hasPlayerOwner && this.prototypeToken.actorLink
+  }
+
   isPersonnage() { return true }
   isHautRevant() { return this.system.attributs.hautrevant.value != "" }
 
   /* -------------------------------------------- */
-  getAgilite() { return Number(this.system.carac.agilite?.value ?? 0) }
+  getAgilite() { return this.system.carac.agilite?.value ?? 0 }
-  getChance() { return Number(this.system.carac.chance?.value ?? 0) }
+  getChance() { return this.system.carac.chance?.value ?? 0 }
 
-  getReveActuel() { return Misc.toInt(this.system.reve?.reve?.value ?? this.carac.reve.value) }
+  getReveActuel() { return this.system.reve?.reve?.value ?? this.carac.reve.value ?? 0 }
-  getChanceActuel() { return Misc.toInt(this.system.compteurs.chance?.value ?? 10) }
+  getChanceActuel() { return this.system.compteurs.chance?.value ?? 10 }
-  getMoralTotal() { return Number(this.system.compteurs.moral?.value ?? 0) }
+  getMoralTotal() { return this.system.compteurs.moral?.value ?? 0 }
 
   /* -------------------------------------------- */
   getEtatGeneral(options = { ethylisme: false }) {
-    const etatGeneral = Misc.toInt(this.system.compteurs.etat?.value)
+    const etatGeneral = this.system.compteurs.etat?.value ?? 0
-    if (options.ethylisme) {
+    // Pour les jets d'Ethylisme, on retire le malus d'éthylisme (p.162)
-      // Pour les jets d'Ethylisme, on retire le malus d'éthylisme (p.162)
+    const annuleMalusEthylisme = options.ethylisme ? this.malusEthylisme() : 0
-      return etatGeneral - this.malusEthylisme()
+    return etatGeneral - annuleMalusEthylisme
-    }
-    return etatGeneral
   }
 
   /* -------------------------------------------- */
   getActivePoisons() {
-    return duplicate(this.items.filter(item => item.type == 'poison' && item.system.active))
+    return foundry.utils.duplicate(this.items.filter(item => item.type == 'poison' && item.system.active))
   }
 
   /* -------------------------------------------- */
@@ -141,7 +143,7 @@ export class RdDActor extends RdDBaseActorSang {
   /* -------------------------------------------- */
   getDemiReve() { return this.system.reve.tmrpos.coord }
   getDraconicList() { return this.itemTypes[TYPES.competence].filter(it => it.system.categorie == 'draconic') }
-  getBestDraconic() { return duplicate(this.getDraconicList().sort(Misc.descending(it => it.system.niveau)).find(it => true)) }
+  getBestDraconic() { return foundry.utils.duplicate(this.getDraconicList().sort(Misc.descending(it => it.system.niveau)).find(it => true)) }
   getDraconicOuPossession() {
     return [...this.getDraconicList().filter(it => it.system.niveau >= 0),
     super.getDraconicOuPossession()]
@@ -345,7 +347,7 @@ export class RdDActor extends RdDBaseActorSang {
     const timestamp = game.system.rdd.calendrier.getTimestamp()
     const blessures = this.filterItems(it => it.system.gravite > 0, TYPES.blessure).sort(Misc.ascending(it => it.system.gravite))
 
-    await Promise.all(blessures.map(b => b.recuperationBlessure({
+    await Promise.all(blessures.map(async b => b.recuperationBlessure({
       actor: this,
       timestamp,
       message,
@@ -427,7 +429,7 @@ export class RdDActor extends RdDBaseActorSang {
       let jetsReve = [];
       let dormi = await this.dormirDesHeures(jetsReve, message, heures, options);
       if (jetsReve.length > 0) {
-        message.content += `Vous récupérez ${jetsReve.map(it => it < 0 ? '(dragon)' : it).reduce(Misc.joining("+"))} Points de rêve. `;
+        message.content += `Vous récupérez ${jetsReve.map(it => it < 0 ? '0 (réveil)' : it).reduce(Misc.joining("+"))} Points de rêve. `;
       }
       if (dormi.etat == 'eveil') {
         await this.reveilReveDeDragon(message, dormi.heures);
@@ -448,7 +450,6 @@ export class RdDActor extends RdDBaseActorSang {
   }
 
   async reveilReveDeDragon(message, heures) {
-    message.content += 'Vous êtes réveillé par un Rêve de Dragon.';
     const restant = Math.max(this.system.sommeil?.heures - heures, 0)
     if (restant > 0) {
       await this.update({ 'system.sommeil': { heures: restant } });
@@ -689,7 +690,7 @@ export class RdDActor extends RdDBaseActorSang {
     }
     let carac = this.findCaracByName(caracName);
     if (carac) {
-      carac = duplicate(carac);
+      carac = foundry.utils.duplicate(carac);
       const fromXp = Number(carac.xp);
       const fromValue = Number(carac.value);
       let toXp = fromXp;
@@ -825,7 +826,7 @@ export class RdDActor extends RdDBaseActorSang {
 
   async deleteExperienceLog(from, count) {
     if (from >= 0 && count > 0) {
-      let expLog = duplicate(this.system.experiencelog);
+      let expLog = foundry.utils.duplicate(this.system.experiencelog);
       expLog.splice(from, count);
       await this.update({ [`system.experiencelog`]: expLog });
     }
@@ -1310,7 +1311,7 @@ export class RdDActor extends RdDBaseActorSang {
 
   /* -------------------------------------------- */
   async saouler(forceAlcool, alcool = undefined) {
-    let ethylisme = duplicate(this.system.compteurs.ethylisme);
+    let ethylisme = foundry.utils.duplicate(this.system.compteurs.ethylisme);
 
     const etat = this.getEtatGeneral({ ethylisme: true });
     const nbDoses = Number(this.system.compteurs.ethylisme.nb_doses || 0);
@@ -1331,7 +1332,7 @@ export class RdDActor extends RdDBaseActorSang {
     }
 
     await RdDResolutionTable.rollData(ethylismeData.jetVie);
-    this._appliquerExperienceRollData(ethylismeData.jetVie);
+    this._gererExperience(ethylismeData.jetVie);
     RollDataAjustements.calcul(ethylismeData.jetVie, this);
     if (ethylismeData.jetVie.rolled.isSuccess) {
       ethylisme.nb_doses++;
@@ -1363,7 +1364,7 @@ export class RdDActor extends RdDBaseActorSang {
           finalLevel: Number(ethylisme.value) + Number(this.system.compteurs.moral.value)
         }
         await RdDResolutionTable.rollData(ethylismeData.jetVolonte);
-        this._appliquerExperienceRollData(ethylismeData.jetVolonte);
+        this._gererExperience(ethylismeData.jetVolonte);
         RollDataAjustements.calcul(ethylismeData.jetVolonte, this);
       }
     }
@@ -1487,7 +1488,7 @@ export class RdDActor extends RdDBaseActorSang {
       const niveauSuivant = Number(carac.value) + 1;
       let xpNeeded = RdDCarac.getCaracNextXp(niveauSuivant);
       if (carac.xp >= xpNeeded) {
-        carac = duplicate(carac);
+        carac = foundry.utils.duplicate(carac);
         carac.value = niveauSuivant;
 
         let checkXp = {
@@ -1517,7 +1518,7 @@ export class RdDActor extends RdDBaseActorSang {
     if (compData && newXP > 0) {
       let xpNeeded = RdDItemCompetence.getCompetenceNextXp(compData.system.niveau + 1);
       if (newXP >= xpNeeded) {
-        let newCompData = duplicate(compData);
+        let newCompData = foundry.utils.duplicate(compData);
         newCompData.system.niveau += 1;
         newCompData.system.xp = newXP;
         let checkXp = {
@@ -1547,7 +1548,7 @@ export class RdDActor extends RdDBaseActorSang {
       const content = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-actor-gain-xp.html`, {
         actor: this,
         xpData
-      });
+      })
       if (hideChatMessage) {
         ChatUtility.blindMessageToGM({ content: content });
       }
@@ -1623,14 +1624,14 @@ export class RdDActor extends RdDBaseActorSang {
       return;
     }
     // Duplication car les pts de reve sont modifiés dans le sort
-    let sorts = duplicate(this.$filterSortList(this.itemTypes['sort'], coord));
+    let sorts = foundry.utils.duplicate(this.$filterSortList(this.itemTypes['sort'], coord));
     if (sorts.length == 0) {
       ui.notifications.info(`Aucun sort disponible en ${TMRUtility.getTMR(coord).label} !`);
       return;
     }
 
     const draconicList = this.computeDraconicAndSortIndex(sorts);
-    const reve = duplicate(this.system.carac.reve);
+    const reve = foundry.utils.duplicate(this.system.carac.reve);
 
     const dialog = await this.openRollDialog({
       name: 'lancer-un-sort',
@@ -1729,7 +1730,7 @@ export class RdDActor extends RdDBaseActorSang {
       else {
         rollData.depenseReve = 0;
         rollData.show.reveInsuffisant = true;
-        mergeObject(rollData.rolled, RdDResolutionTable.getResultat("echec"), { overwrite: true });
+        foundry.utils.mergeObject(rollData.rolled, RdDResolutionTable.getResultat("echec"), { overwrite: true });
       }
     } else {
       if (rolled.isETotal) { // Echec total !
@@ -1777,13 +1778,13 @@ export class RdDActor extends RdDBaseActorSang {
     };
     RollDataAjustements.calcul(rollData, this);
     await RdDResolutionTable.rollData(rollData);
-    this._appliquerExperienceRollData(rollData);
+    this._gererExperience(rollData);
     await RdDResolutionTable.displayRollData(rollData, this)
     return rollData.rolled;
   }
 
   /* -------------------------------------------- */
-  _appliquerExperienceRollData(rollData) {
+  _gererExperience(rollData) {
     const callback = this.createCallbackExperience();
     if (callback.condition(rollData)) {
       callback.action(rollData);
@@ -1871,7 +1872,7 @@ export class RdDActor extends RdDBaseActorSang {
         diffConditions: 0,
         use: { libre: false, conditions: true },
         carac: {
-          [tacheData.system.carac]: duplicate(this.system.carac[tacheData.system.carac])
+          [tacheData.system.carac]: foundry.utils.duplicate(this.system.carac[tacheData.system.carac])
         }
       },
       callbackAction: r => this._tacheResult(r, options)
@@ -1882,7 +1883,7 @@ export class RdDActor extends RdDBaseActorSang {
   async _tacheResult(rollData, options) {
     // Mise à jour de la tache
     rollData.appliquerFatigue = ReglesOptionnelles.isUsing("appliquer-fatigue");
-    rollData.tache = duplicate(rollData.tache);
+    rollData.tache = foundry.utils.duplicate(rollData.tache);
     rollData.tache.system.points_de_tache_courant += rollData.rolled.ptTache;
     if (rollData.rolled.isETotal) {
       rollData.tache.system.difficulte--;
@@ -1906,21 +1907,21 @@ export class RdDActor extends RdDBaseActorSang {
   /* -------------------------------------------- */
   async _rollArt(artData, selected, oeuvre, callbackAction = r => this._resultArt(r)) {
     oeuvre.system.niveau = oeuvre.system.niveau ?? 0;
-    mergeObject(artData,
+    foundry.utils.mergeObject(artData,
       {
         oeuvre: oeuvre,
         art: oeuvre.type,
-        competence: duplicate(this.getCompetence(artData.compName ?? oeuvre.system.competence ?? artData.art)),
+        competence: foundry.utils.duplicate(this.getCompetence(artData.compName ?? oeuvre.system.competence ?? artData.art)),
         diffLibre: - oeuvre.system.niveau,
         diffConditions: 0,
         use: { libre: false, conditions: true, surenc: false },
-        selectedCarac: duplicate(this.system.carac[selected])
+        selectedCarac: foundry.utils.duplicate(this.system.carac[selected])
       },
       { overwrite: false });
     artData.competence.system.defaut_carac = selected;
     if (!artData.forceCarac) {
       artData.forceCarac = {};
-      artData.forceCarac[selected] = duplicate(this.system.carac[selected]);
+      artData.forceCarac[selected] = foundry.utils.duplicate(this.system.carac[selected]);
     }
 
     await this.openRollDialog({
@@ -1944,19 +1945,19 @@ export class RdDActor extends RdDBaseActorSang {
   /* -------------------------------------------- */
   async rollChant(id) {
     const artData = { art: 'chant', verbe: 'Chanter' };
-    const oeuvre = duplicate(this.getChant(id));
+    const oeuvre = foundry.utils.duplicate(this.getChant(id));
     await this._rollArt(artData, "ouie", oeuvre);
   }
 
   /* -------------------------------------------- */
   async rollDanse(id) {
     const artData = { art: 'danse', verbe: 'Danser', forceCarac: {} };
-    const oeuvre = duplicate(this.findItemLike(id, artData.art));
+    const oeuvre = foundry.utils.duplicate(this.findItemLike(id, artData.art));
     if (oeuvre.system.agilite) {
-      artData.forceCarac['agilite'] = duplicate(this.system.carac.agilite);
+      artData.forceCarac['agilite'] = foundry.utils.duplicate(this.system.carac.agilite);
     }
     if (oeuvre.system.apparence) {
-      artData.forceCarac['apparence'] = duplicate(this.system.carac.apparence);
+      artData.forceCarac['apparence'] = foundry.utils.duplicate(this.system.carac.apparence);
     }
     const selectedCarac = this._getCaracDanse(oeuvre);
     await this._rollArt(artData, selectedCarac, oeuvre);
@@ -2059,7 +2060,7 @@ export class RdDActor extends RdDBaseActorSang {
     const artData = {
       art: 'jeu', verbe: 'Jeu',
       use: { libre: true, conditions: true, },
-      competence: duplicate(this.getCompetence('jeu')),
+      competence: foundry.utils.duplicate(this.getCompetence('jeu')),
       forceCarac: {}
     };
     listCarac.forEach(c => artData.forceCarac[c] = this.system.carac[c]);
@@ -2070,14 +2071,14 @@ export class RdDActor extends RdDBaseActorSang {
 
   async rollOeuvre(id) {
     const artData = { art: 'oeuvre', verbe: 'Interpréter' }
-    const oeuvre = duplicate(this.findItemLike(id, artData.art))
+    const oeuvre = foundry.utils.duplicate(this.findItemLike(id, artData.art))
     await this._rollArt(artData, oeuvre.system.default_carac, oeuvre)
   }
 
   /* -------------------------------------------- */
   async rollMeditation(id) {
-    const meditation = duplicate(this.getMeditation(id));
+    const meditation = foundry.utils.duplicate(this.getMeditation(id));
-    const competence = duplicate(this.getCompetence(meditation.system.competence));
+    const competence = foundry.utils.duplicate(this.getCompetence(meditation.system.competence));
     competence.system.defaut_carac = "intellect"; // Meditation = toujours avec intellect
     let meditationData = {
       competence: competence,
@@ -2143,7 +2144,7 @@ export class RdDActor extends RdDBaseActorSang {
     }
     let draconicList = this.getDraconicList()
       .map(draconic => {
-        let draconicLecture = duplicate(draconic);
+        let draconicLecture = foundry.utils.duplicate(draconic);
         draconicLecture.system.defaut_carac = "intellect";
         return draconicLecture;
       });
@@ -2267,7 +2268,7 @@ export class RdDActor extends RdDBaseActorSang {
   async _appliquerExperience(rolled, caracName, competence, jetResistance) {
     // Pas d'XP
     if (!rolled.isPart || rolled.finalLevel >= 0) {
-      return undefined;
+      return []
     }
     if (this.checkDesirLancinant()) {
       // Cas de désir lancinant, pas d'expérience sur particulière
@@ -2275,7 +2276,7 @@ export class RdDActor extends RdDBaseActorSang {
         content: `Vous souffrez au moins d'un Désir Lancinant, vous ne pouvez pas gagner d'expérience sur une Particulière tant que le désir n'est pas assouvi`,
         whisper: ChatMessage.getWhisperRecipients(this.name)
       });
-      return undefined;
+      return []
     }
 
     let xp = Math.abs(rolled.finalLevel);
@@ -2312,7 +2313,7 @@ export class RdDActor extends RdDBaseActorSang {
   /* -------------------------------------------- */
   async _xpCarac(xpData) {
     if (xpData.xpCarac > 0) {
-      const carac = duplicate(this.system.carac)
+      const carac = foundry.utils.duplicate(this.system.carac)
       const code = RdDBaseActor._findCaracNode(carac, xpData.caracName)
       const selectedCarac = carac[code]
       if (this.isCaracMax(code)) {
@@ -2336,7 +2337,7 @@ export class RdDActor extends RdDBaseActorSang {
 
   async _xpCaracDerivee(xpData) {
     const caracs = RdDActor._getComposantsCaracDerivee(xpData.caracName)
-      .map(c => mergeObject(this.system.carac[c], { isMax: this.isCaracMax(c) }))
+      .map(c => foundry.utils.mergeObject(this.system.carac[c], { isMax: this.isCaracMax(c) }))
     switch (caracs.filter(it => !it.isMax).length) {
       case 0:
         xpData.caracRepartitionManuelle = true;
@@ -2363,26 +2364,25 @@ export class RdDActor extends RdDBaseActorSang {
 
 
   /* -------------------------------------------- */
-  async resetNombresAstraux() {
+  async deleteNombresAstraux() {
     const deletions = this.itemTypes['nombreastral'].map(it => it._id);
     await this.deleteEmbeddedDocuments("Item", deletions);
   }
 
   /* -------------------------------------------- */
-  async ajouteNombreAstral(callData) {
+  async ajouteNombreAstral(date, nbAstral, isValid) {
-    const indexDate = Number.parseInt(callData.date);
+    const indexDate = Number.parseInt(date);
     // Ajout du nombre astral
     const item = {
       name: "Nombre Astral", type: "nombreastral", system:
       {
-        value: callData.nbAstral,
+        value: nbAstral,
-        istrue: callData.isvalid,
+        istrue: isValid,
         jourindex: indexDate,
         jourlabel: RdDTimestamp.formatIndexDate(indexDate)
       }
     };
     await this.createEmbeddedDocuments("Item", [item]);
-    game.system.rdd.calendrier.notifyChangeNombresAstraux();
   }
 
   async supprimerAnciensNombresAstraux() {
@@ -2616,7 +2616,7 @@ export class RdDActor extends RdDBaseActorSang {
 
   /* -------------------------------------------- */
   async incDecItemUse(itemId, inc = 1) {
-    let itemUse = duplicate(this.getFlag(SYSTEM_RDD, 'itemUse') ?? {});
+    let itemUse = foundry.utils.duplicate(this.getFlag(SYSTEM_RDD, 'itemUse') ?? {});
     itemUse[itemId] = (itemUse[itemId] ?? 0) + inc;
     await this.setFlag(SYSTEM_RDD, 'itemUse', itemUse);
     console.log("ITEM USE INC", inc, itemUse);
@@ -2684,7 +2684,7 @@ export class RdDActor extends RdDBaseActorSang {
 
   /* -------------------------------------------- */
   static $transformSubActeurSuivant = (suivant, link) => {
-    return mergeObject(RdDBaseActor.extractActorMin(suivant), {
+    return foundry.utils.mergeObject(RdDBaseActor.extractActorMin(suivant), {
       ephemere: !suivant.prototypeToken.actorLink,
       coeur: link.coeur ?? 0,
       prochainCoeur: link.prochainCoeur ?? link.coeur ?? 0
@@ -2710,7 +2710,7 @@ export class RdDActor extends RdDBaseActorSang {
   }
 
   async setPointsCoeur(subActorId, coeurs, options = { immediat: false }) {
-    const newSuivants = duplicate(this.system.subacteurs.suivants)
+    const newSuivants = foundry.utils.duplicate(this.system.subacteurs.suivants)
     const amoureux = newSuivants.find(it => it.id == subActorId);
     if (amoureux) {
       amoureux[options.immediat ? 'coeur' : 'prochainCoeur'] = coeurs
@@ -2720,7 +2720,7 @@ export class RdDActor extends RdDBaseActorSang {
 
   /* -------------------------------------------- */
   static $transformSubActeurVehicule = (vehicle, link) => {
-    return mergeObject(RdDBaseActor.extractActorMin(vehicle), {
+    return foundry.utils.mergeObject(RdDBaseActor.extractActorMin(vehicle), {
       system: { categorie: vehicle.system.categorie, etat: vehicle.system.etat }
     })
   };
@@ -3064,7 +3064,7 @@ export class RdDActor extends RdDBaseActorSang {
 
     incarnation.name = 'Réincarnation de ' + incarnation.name
     incarnation.system = {
-      carac: duplicate(this.system.carac),
+      carac: foundry.utils.duplicate(this.system.carac),
       heure: RdDTimestamp.defHeure(await RdDDice.rollTotal("1dh", { rollMode: "selfroll", showDice: SHOW_DICE })).key,
       age: 18,
       biographie: '',

module/actor/base-actor-reve-sheet.js

@@ -11,7 +11,7 @@ export class RdDBaseActorReveSheet extends RdDBaseActorSheet {
 
   /** @override */
   static get defaultOptions() {
-    return mergeObject(RdDBaseActorSheet.defaultOptions, {
+    return foundry.utils.mergeObject(RdDBaseActorSheet.defaultOptions, {
       width: 550
     });
   }

module/actor/base-actor-reve.js

@@ -286,7 +286,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
 
   getCarac() {
     // TODO: le niveau d'une entité de cauchemar devrait être exclu...
-    const carac = mergeObject(duplicate(this.system.carac),
+    const carac = foundry.utils.mergeObject(foundry.utils.duplicate(this.system.carac),
       {
         'reve-actuel': this.getCaracReveActuel(),
         'chance-actuelle': this.getCaracChanceActuelle()
@@ -425,28 +425,31 @@ export class RdDBaseActorReve extends RdDBaseActor {
     if (attacker && !await attacker.accorder(this, 'avant-encaissement')) {
       return;
     }
-    const attackerId = attacker?.id;
-    if (ReglesOptionnelles.isUsing('validation-encaissement-gr') && !game.user.isGM) {
-      RdDBaseActor.remoteActorCall({
-        tokenId: this.token?.id,
-        actorId: this.id,
-        method: 'encaisserDommages',
-        args: [rollData, show, attackerId]
-      });
-      return;
-    }
-
     const armure = await this.computeArmure(rollData);
-    if (ReglesOptionnelles.isUsing('validation-encaissement-gr')) {
+    if (ReglesOptionnelles.isUsing('validation-encaissement-gr')){
-      DialogValidationEncaissement.validerEncaissement(this, rollData, armure,
+      await this.encaisserDommagesValidationGR(rollData, armure, attacker?.id, show);
-        jet => this.$onEncaissement(jet, show, attacker));
+    } 
-    }
     else {
       const jet = await RdDUtility.jetEncaissement(rollData, armure, { showDice: SHOW_DICE });
       await this.$onEncaissement(jet, show, attacker);
     }
   }
 
+  async encaisserDommagesValidationGR(rollData, armure, attackerId, show) {
+    if (!game.user.isGM) {
+      RdDBaseActor.remoteActorCall({
+        tokenId: this.token?.id,
+        actorId: this.id,
+        method: 'encaisserDommagesValidationGR',
+        args: [rollData, armure, attackerId, show]
+      });
+    } else {
+      const attacker = game.actors.get(attackerId);
+      DialogValidationEncaissement.validerEncaissement(this, rollData, armure,
+        jet => this.$onEncaissement(jet, show, attacker));
+    }
+  }
+
   async $onEncaissement(jet, show, attacker) {
     await this.onAppliquerJetEncaissement(jet, attacker);
     await this.$afficherEncaissement(jet, show);
@@ -455,7 +458,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
   async onAppliquerJetEncaissement(encaissement, attacker) { }
 
   async $afficherEncaissement(encaissement, show) {
-    mergeObject(encaissement, {
+    foundry.utils.mergeObject(encaissement, {
       alias: this.name,
       hasPlayerOwner: this.hasPlayerOwner,
       show: show ?? {}
@@ -467,7 +470,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
     });
 
     if (!encaissement.hasPlayerOwner && encaissement.endurance != 0) {
-      encaissement = duplicate(encaissement);
+      encaissement = foundry.utils.duplicate(encaissement);
       encaissement.isGM = true;
       ChatMessage.create({
         whisper: ChatMessage.getWhisperRecipients("GM"),

module/actor/base-actor-sang-sheet.js

@@ -21,6 +21,11 @@ export class RdDBaseActorSangSheet extends RdDBaseActorReveSheet {
     this.html.find('.creer-blessure-grave').click(async event => RdDItemBlessure.createBlessure(this.actor, 4));
     this.html.find('.creer-blessure-critique').click(async event => RdDItemBlessure.createBlessure(this.actor, 6));
 
+    this.html.find('.subir-blessure-contusion').click(async event => RdDItemBlessure.applyFullBlessure(this.actor, 2));
+    this.html.find('.subir-blessure-legere').click(async event => RdDItemBlessure.applyFullBlessure(this.actor, 2));
+    this.html.find('.subir-blessure-grave').click(async event => RdDItemBlessure.applyFullBlessure(this.actor, 4));
+    this.html.find('.subir-blessure-critique').click(async event => RdDItemBlessure.applyFullBlessure(this.actor, 6));
+
     this.html.find('.jet-vie').click(async event => this.actor.jetDeVie())
     this.html.find('.jet-endurance').click(async event => await this.jetEndurance())
 

module/actor/base-actor-sang.js

@@ -89,12 +89,12 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
   /* -------------------------------------------- */
 
   async onAppliquerJetEncaissement(encaissement, attacker) {
-    const santeOrig = duplicate(this.system.sante);
+    const santeOrig = foundry.utils.duplicate(this.system.sante);
     const blessure = await this.ajouterBlessure(encaissement, attacker); // Will update the result table
     const perteVie = await this.santeIncDec("vie", -encaissement.vie);
     const perteEndurance = await this.santeIncDec("endurance", -encaissement.endurance, blessure?.isCritique());
 
-    mergeObject(encaissement, {
+    foundry.utils.mergeObject(encaissement, {
       resteEndurance: perteEndurance.newValue,
       sonne: perteEndurance.sonne,
       jetEndurance: perteEndurance.jetEndurance,
@@ -108,7 +108,7 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
     if (name == 'fatigue' && !ReglesOptionnelles.isUsing("appliquer-fatigue")) {
       return;
     }
-    const sante = duplicate(this.system.sante)
+    const sante = foundry.utils.duplicate(this.system.sante)
     let compteur = sante[name];
     if (!compteur) {
       return;
@@ -135,7 +135,7 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
       result.perte = perte;
       if (perte > 1) {
         // Peut-être sonné si 2 points d'endurance perdus d'un coup
-        mergeObject(result, await this.jetEndurance(result.newValue));
+        foundry.utils.mergeObject(result, await this.jetEndurance(result.newValue));
       } else if (inc > 0) {
         await this.setSonne(false);
       }

module/actor/base-actor-sheet.js

@@ -15,7 +15,7 @@ export class RdDBaseActorSheet extends ActorSheet {
 
   /** @override */
   static get defaultOptions() {
-    return mergeObject(ActorSheet.defaultOptions, {
+    return foundry.utils.mergeObject(ActorSheet.defaultOptions, {
       classes: ["rdd", "sheet", "actor"],
       tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "carac" }],
       dragDrop: [{ dragSelector: ".item-list .item", dropSelector: undefined }],
@@ -312,7 +312,7 @@ export class RdDBaseActorSheet extends ActorSheet {
   async _onSplitItem(item, split) {
     if (split >= 1 && split < item.system.quantite) {
       await item.diminuerQuantite(split);
-      const splitItem = duplicate(item);
+      const splitItem = foundry.utils.duplicate(item);
       splitItem.system.quantite = split;
       await this.actor.createEmbeddedDocuments('Item', [splitItem])
     }

module/actor/base-actor.js

@@ -42,13 +42,6 @@ export class RdDBaseActor extends Actor {
     switch (sockmsg.msg) {
       case "msg_remote_actor_call":
         return RdDBaseActor.onRemoteActorCall(sockmsg.data, sockmsg.userId);
-      case "msg_reset_nombre_astral":
-        game.user.character.resetNombresAstraux();
-        game.system.rdd.calendrier.notifyChangeNombresAstraux();
-        return;
-      case "msg_refresh_nombre_astral":
-        Hooks.callAll(APP_ASTROLOGIE_REFRESH);
-        return;
     }
   }
 
@@ -85,6 +78,8 @@ export class RdDBaseActor extends Actor {
     return game.actors.get(actorId)
   }
 
+  isPersonnageJoueur() { return false }
+
   static extractActorMin = (actor) => { return { id: actor?.id, type: actor?.type, name: actor?.name, img: actor?.img }; };
 
   static getParentActor(document) {
@@ -121,7 +116,7 @@ export class RdDBaseActor extends Actor {
 
   constructor(docData, context = {}) {
     if (!context.rdd?.ready) {
-      mergeObject(context, { rdd: { ready: true } });
+      foundry.utils.mergeObject(context, { rdd: { ready: true } });
       const ActorConstructor = game.system.rdd.actorClasses[docData.type];
       if (ActorConstructor) {
         if (!docData.img) {
@@ -375,7 +370,7 @@ export class RdDBaseActor extends Actor {
     if (cout > 0) {
       RdDAudio.PlayContextAudio("argent");
     }
-    const chatAchatItem = duplicate(achat.vente);
+    const chatAchatItem = foundry.utils.duplicate(achat.vente);
     chatAchatItem.quantiteTotal = quantite;
     ChatMessage.create({
       user: achat.userId,
@@ -451,7 +446,7 @@ export class RdDBaseActor extends Actor {
         type: item.type,
         img: item.img,
         name: item.name,
-        system: mergeObject(item.system, { quantite: isItemEmpilable ? quantite : undefined })
+        system: foundry.utils.mergeObject(item.system, { quantite: isItemEmpilable ? quantite : undefined })
       };
       const newItems = isItemEmpilable ? [baseItem] : Array.from({ length: quantite }, (_, i) => baseItem);
       const items = await this.createEmbeddedDocuments("Item", newItems);
@@ -647,7 +642,7 @@ export class RdDBaseActor extends Actor {
     sourceActor.buildSubConteneurObjetList(itemId, itemsList); // Get itemId list
 
     const itemsDataToCreate = itemsList.map(it => sourceActor.getItem(it.id))
-      .map(it => duplicate(it))
+      .map(it => foundry.utils.duplicate(it))
       .map(it => { it.system.contenu = []; return it; });
     let newItems = await this.createEmbeddedDocuments('Item', itemsDataToCreate);
 

module/actor/commerce-sheet.js

@@ -11,7 +11,7 @@ export class RdDCommerceSheet extends RdDBaseActorSheet {
 
   /** @override */
   static get defaultOptions() {
-    return mergeObject(super.defaultOptions, {
+    return foundry.utils.mergeObject(super.defaultOptions, {
       template: "systems/foundryvtt-reve-de-dragon/templates/actor/commerce-actor-sheet.html",
       width: 600, height: 720,
       tabs: []
@@ -27,7 +27,7 @@ export class RdDCommerceSheet extends RdDBaseActorSheet {
   async getData() {
     const formData = await super.getData();
     if (this.actor.token && this.actor.token != this.actor.prototypeToken) {
-      mergeObject(formData,
+      foundry.utils.mergeObject(formData,
         {
           title: this.actor.token.name,
           token: {

module/actor/creature-sheet.js

@@ -9,7 +9,7 @@ export class RdDCreatureSheet extends RdDBaseActorSangSheet {
 
   /** @override */
   static get defaultOptions() {
-    return mergeObject(RdDBaseActorSangSheet.defaultOptions, {
+    return foundry.utils.mergeObject(RdDBaseActorSangSheet.defaultOptions, {
       template: "systems/foundryvtt-reve-de-dragon/templates/actor-creature-sheet.html",
       width: 640, height: 720
     });

module/actor/creature.js

@@ -48,7 +48,7 @@ export class RdDCreature extends RdDBaseActorSang {
   /* -------------------------------------------- */
   async setEntiteReveAccordee(attacker) {
     if (this.isEntite([ENTITE_INCARNE])) {
-      let resonnance = duplicate(this.system.sante.resonnance);
+      let resonnance = foundry.utils.duplicate(this.system.sante.resonnance);
       if (resonnance.actors.find(it => it == attacker.id)) {
         // déjà accordé
         return;

module/actor/entite-sheet.js

@@ -6,7 +6,7 @@ export class RdDActorEntiteSheet extends RdDBaseActorReveSheet {
 
   /** @override */
   static get defaultOptions() {
-    return mergeObject(RdDBaseActorReveSheet.defaultOptions, {
+    return foundry.utils.mergeObject(RdDBaseActorReveSheet.defaultOptions, {
       template: "systems/foundryvtt-reve-de-dragon/templates/actor-entite-sheet.html",
       width: 640, height: 720,
     });

module/actor/entite.js

@@ -76,7 +76,7 @@ export class RdDEntite extends RdDBaseActorReve {
 
   async onAppliquerJetEncaissement(encaissement, attacker) {
     const perteEndurance = await this.santeIncDec("endurance", -encaissement.endurance);
-    mergeObject(encaissement, {
+    foundry.utils.mergeObject(encaissement, {
       resteEndurance: perteEndurance.newValue,
       endurance: perteEndurance.perte
     });
@@ -93,7 +93,7 @@ export class RdDEntite extends RdDBaseActorReve {
   /* -------------------------------------------- */
   async setEntiteReveAccordee(attacker) {
     if (this.isEntite([ENTITE_INCARNE])) {
-      let resonnance = duplicate(this.system.sante.resonnance);
+      let resonnance = foundry.utils.duplicate(this.system.sante.resonnance);
       if (resonnance.actors.find(it => it == attacker.id)) {
         // déjà accordé
         return;

module/actor/experience-log.js

@@ -12,7 +12,7 @@ export const XP_TOPIC = {
 export class ExperienceLog {
 
   static async add(actor, topic, from, to, raison, manuel = false) {
-    if (!actor.hasPlayerOwner || !actor.isPersonnage()) {
+    if (!actor.isPersonnageJoueur()) {
       return
     }
     if (from == to) {

module/actor/vehicule-sheet.js

@@ -6,7 +6,7 @@ export class RdDActorVehiculeSheet extends RdDBaseActorSheet {
 
   /** @override */
   static get defaultOptions() {
-    return mergeObject(RdDBaseActorSheet.defaultOptions, {
+    return foundry.utils.mergeObject(RdDBaseActorSheet.defaultOptions, {
       template: "systems/foundryvtt-reve-de-dragon/templates/actor-vehicule-sheet.html",
       width: 640, height: 720,
     });
@@ -15,7 +15,7 @@ export class RdDActorVehiculeSheet extends RdDBaseActorSheet {
   /* -------------------------------------------- */
   async getData() {
     let formData = await super.getData();
-    mergeObject(formData,
+    foundry.utils.mergeObject(formData,
       {
         editable: this.isEditable,
         cssClass: this.isEditable ? "editable" : "locked",

module/chat-utility.js

@@ -131,7 +131,7 @@ export class ChatUtility {
 
   /* -------------------------------------------- */
   static blindMessageToGM(chatOptions) {
-    let chatGM = duplicate(chatOptions);
+    let chatGM = foundry.utils.duplicate(chatOptions);
     chatGM.whisper = ChatUtility.getUsers(user => user.isGM);
     chatGM.content = "Message aveugle de " + game.user.name + "<br>" + chatOptions.content;
     console.log("blindMessageToGM", chatGM);

module/coeur/rdd-coeur.js

@@ -69,7 +69,7 @@ export class RdDCoeur {
   }
 
   static async applyCoeurChateauDormant(actor, message) {
-    const newSuivants = duplicate(actor.system.subacteurs.suivants)
+    const newSuivants = foundry.utils.duplicate(actor.system.subacteurs.suivants)
     let count = 0
     newSuivants.forEach(async link => {
       const suivant = game.actors.get(link.id)

module/dialog-choix-xp-carac.js

@@ -2,8 +2,8 @@
 export class DialogChoixXpCarac extends Dialog {
 
   static async choix(actor, xpData, caracs) {
-    caracs = caracs.map(it => mergeObject({ ajout: 0 }, it))
+    caracs = caracs.map(it => foundry.utils.mergeObject({ ajout: 0 }, it))
-    xpData = mergeObject({ reste: xpData.xpCarac }, xpData)
+    xpData = foundry.utils.mergeObject({ reste: xpData.xpCarac }, xpData)
     const dialogData = {
       title: `Choisissez la répartition d'expérience`,
       content: await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/dialog-choix-xp-carac.hbs", {
@@ -24,7 +24,7 @@ export class DialogChoixXpCarac extends Dialog {
   }
 
   constructor(dialogData, dialogOptions, actor, xpData, caracs) {
-    dialogData = mergeObject(dialogData, {
+    dialogData = foundry.utils.mergeObject(dialogData, {
       default: 'appliquer',
       buttons: {
         'appliquer': { icon:'<i class="fa-solid fa-check"></i>', label: "Ajouter la répartition", callback: it => this.appliquerSelection() }

module/dialog-fabriquer-potion.js

@@ -21,7 +21,7 @@ export class DialogFabriquerPotion extends Dialog {
 
   /* -------------------------------------------- */
   static prepareData(actor, item) {
-    let potionData = duplicate(item)
+    let potionData = foundry.utils.duplicate(item)
     potionData.nbBrinsSelect = RdDUtility.buildListOptions(
       DialogFabriquerPotion.nombreBrinsMinimum(item),
       DialogFabriquerPotion.nombreBrinsOptimal(item));

module/dialog-item-consommer.js

@@ -47,7 +47,7 @@ export class DialogConsommer extends Dialog {
   /* -------------------------------------------- */
   static prepareData(actor, item) {
     let consommerData = {
-      item: duplicate(item),
+      item: foundry.utils.duplicate(item),
       cuisine: actor.getCompetence('cuisine'),
       choix: {
         doses: 1,

module/dialog-item-vente.js

@@ -56,7 +56,7 @@ export class DialogItemVente extends Dialog {
   }
 
   updateVente(update) {
-    mergeObject(this.venteData, update);
+    foundry.utils.mergeObject(this.venteData, update);
   }
 
   getChoixVente() {

module/item-arme.js

@@ -139,7 +139,7 @@ export class RdDItemArme extends Item {
       const uneOuDeuxMains = armeData.system.unemain && armeData.system.deuxmains;
       const containsSlash = !Number.isInteger(armeData.system.dommages) && armeData.system.dommages.includes("/");
       if (containsSlash) { // Sanity check
-        armeData = duplicate(armeData);
+        armeData = foundry.utils.duplicate(armeData);
 
         const tableauDegats = armeData.system.dommages.split("/");
         if (aUneMain)

module/item-competence.js

@@ -199,7 +199,7 @@ export class RdDItemCompetence extends Item {
     if (idOrName == undefined || idOrName == "") {
       return RdDItemCompetence.sansCompetence();
     }
-    options = mergeObject(options, { preFilter: it => it.isCompetence(), description: 'compétence' }, { overwrite: false });
+    options = foundry.utils.mergeObject(options, { preFilter: it => it.isCompetence(), description: 'compétence' }, { overwrite: false });
     return RdDItemCompetence.findFirstItem(list, idOrName, options);
   }
 
@@ -257,7 +257,7 @@ export class RdDItemCompetence extends Item {
 
   /* -------------------------------------------- */
   static computeResumeArchetype(competences) {
-    const computed = duplicate(limitesArchetypes);
+    const computed = foundry.utils.duplicate(limitesArchetypes);
     computed.forEach(it => { it.nombre = 0; it.reste = it.nombreMax; });
 
     competences.map(it => Math.max(0, it.system.niveau_archetype))

module/item-competencecreature.js

@@ -33,7 +33,7 @@ export class RdDItemCompetenceCreature extends Item {
     if (categorieAttaque != undefined) {
       // si c'est un Item compétence: cloner pour ne pas modifier la compétence
       let arme = item.clone();
-      mergeObject(arme,
+      foundry.utils.mergeObject(arme,
         {
           action: item.isCompetencePossession() ? 'possession' : 'attaque',
           system: {

module/item-monnaie.js

@@ -57,7 +57,7 @@ export class Monnaie {
   }
 
   static creerDeniers(fortune) {
-    const deniers = duplicate(MONNAIE_ETAIN);
+    const deniers = foundry.utils.duplicate(MONNAIE_ETAIN);
     deniers.system.quantite = fortune;
     return deniers;
   }

module/item-sheet.js

@@ -39,7 +39,7 @@ export class RdDItemSheet extends ItemSheet {
 
   /** @override */
   static get defaultOptions() {
-    return mergeObject(super.defaultOptions, {
+    return foundry.utils.mergeObject(super.defaultOptions, {
       classes: [SYSTEM_RDD, "sheet", "item"],
       template: RdDItemSheet.defaultTemplate(RdDItemSheet.ITEM_TYPE),
       width: 550,
@@ -108,8 +108,8 @@ export class RdDItemSheet extends ItemSheet {
     const competences = await SystemCompendiums.getCompetences('personnage');
     formData.categories = this.item.getCategories()
     if (this.item.type == 'tache' || this.item.type == 'livre' || this.item.type == 'meditation' || this.item.type == 'oeuvre') {
-      formData.caracList = duplicate(game.system.model.Actor.personnage.carac)
+      formData.caracList = foundry.utils.duplicate(game.system.model.Actor.personnage.carac)
-      formData.caracList["reve-actuel"] = duplicate(game.system.model.Actor.personnage.reve.reve)
+      formData.caracList["reve-actuel"] = foundry.utils.duplicate(game.system.model.Actor.personnage.reve.reve)
       formData.competences = competences;
     }
     if (this.item.type == 'arme') {
@@ -228,7 +228,7 @@ export class RdDItemSheet extends ItemSheet {
       });
     }
 
-    const updateItemTimestamp = (path, timestamp) => this.item.update({ [path]: duplicate(timestamp) })
+    const updateItemTimestamp = (path, timestamp) => this.item.update({ [path]: foundry.utils.duplicate(timestamp) })
 
     RdDTimestamp.handleTimestampEditor(this.html, 'system.temporel.debut', updateItemTimestamp);
     RdDTimestamp.handleTimestampEditor(this.html, 'system.temporel.fin', updateItemTimestamp);

module/item.js

@@ -317,8 +317,8 @@ export class RdDItem extends Item {
       const timestampFin = await this.calculerFinPeriodeTemporel(timestampDebut);
       await actor.updateEmbeddedDocuments('Item', [{
         _id: this.id,
-        'system.temporel.debut': duplicate(timestampDebut),
+        'system.temporel.debut': foundry.utils.duplicate(timestampDebut),
-        'system.temporel.fin': duplicate(timestampFin),
+        'system.temporel.fin': foundry.utils.duplicate(timestampFin),
       }])
     }
   }

module/item/blessure.js

@@ -1,6 +1,7 @@
 import { RdDItem } from "../item.js";
 import { Misc } from "../misc.js";
 import { RdDTimestamp } from "../time/rdd-timestamp.js";
+import { ChatUtility } from "../chat-utility.js";
 
 const BASE_TACHE_SOIN_BLESSURE = {
   type: "tache",
@@ -14,10 +15,10 @@ const TACHES_SOIN_BLESSURE = {
 }
 
 const definitionsBlessures = [
-  { type: "contusion", gravite: 0, label: 'Contusion/éraflure', max: 100, icon: "systems/foundryvtt-reve-de-dragon/icons/sante/eraflure.webp" },
+  { type: "contusion", gravite: 0, endurance: "1d4", vie: 0, label: 'Contusion/éraflure', max: 100, icon: "systems/foundryvtt-reve-de-dragon/icons/sante/eraflure.webp" },
-  { type: "legere", gravite: 2, label: 'Légère', max: 5, icon: "systems/foundryvtt-reve-de-dragon/icons/sante/blessure.webp" },
+  { type: "legere", gravite: 2, endurance: "1d6", vie: 0, label: 'Légère', max: 5, icon: "systems/foundryvtt-reve-de-dragon/icons/sante/blessure.webp" },
-  { type: "grave", gravite: 4, label: 'Grave', max: 2, icon: "systems/foundryvtt-reve-de-dragon/icons/sante/blessure.webp" },
+  { type: "grave", gravite: 4, endurance: "2d6", vie: -2, label: 'Grave', max: 2, icon: "systems/foundryvtt-reve-de-dragon/icons/sante/blessure.webp" },
-  { type: "critique", gravite: 6, label: 'Critique', max: 1, icon: "systems/foundryvtt-reve-de-dragon/icons/sante/blessure.webp" },
+  { type: "critique", gravite: 6, endurance: "-100", vie: -4, label: 'Critique', max: 1, icon: "systems/foundryvtt-reve-de-dragon/icons/sante/blessure.webp" },
   { type: "mort", gravite: 8, label: 'Mort', max: 1, icon: "systems/foundryvtt-reve-de-dragon/icons/sante/mort.webp" }
 ]
 
@@ -38,8 +39,34 @@ export class RdDItemBlessure extends RdDItem {
       ui.notifications.warn(`Pas de tâche de soins pour une blessure ${gravite}`)
       return undefined;
     }
-    return mergeObject(duplicate(BASE_TACHE_SOIN_BLESSURE), tache)
+    return foundry.utils.mergeObject(foundry.utils.duplicate(BASE_TACHE_SOIN_BLESSURE), tache)
   }
+
+  static async applyFullBlessure(actor, gravite) {
+    const definition = RdDItemBlessure.getDefinition(gravite)
+    
+    let lostEndurance = 0
+    let lostVie = 0
+    if (definition.endurance) {
+      lostEndurance = new Roll(definition.endurance).roll({async: false}).total;
+      actor.santeIncDec("endurance", -Number(lostEndurance));
+    }
+    if (definition.vie) {
+      lostVie = definition.vie
+      actor.santeIncDec("vie", definition.vie)
+    }
+    
+    await this.createBlessure(actor, gravite)
+
+    ChatMessage.create({
+      content: `Blessure ${definition.label} appliquée à ${actor.name}`+
+        `<br>Perte d'endurance : ${lostEndurance}`+
+        `<br>Perte de Vie : ${lostVie}`,
+      whisper: ChatUtility.getWhisperRecipientsAndGMs(actor.name)
+    });
+
+  }
+
   static async createBlessure(actor, gravite, localisation = '', attacker) {
     const definition = RdDItemBlessure.getDefinition(gravite)
     const blessure = {
@@ -79,7 +106,7 @@ export class RdDItemBlessure extends RdDItem {
   }
 
   async setSoinsBlessure(systemUpdate = {}) {
-    systemUpdate = mergeObject(systemUpdate, this.system, { overwrite: false }),
+    systemUpdate = foundry.utils.mergeObject(systemUpdate, this.system, { overwrite: false }),
       systemUpdate.soinscomplets.done = systemUpdate.premierssoins.done && systemUpdate.soinscomplets.done
     await this.update({
       img: this.getImgSoins(systemUpdate.gravite, systemUpdate.soinscomplets.done),
@@ -107,14 +134,14 @@ export class RdDItemBlessure extends RdDItem {
       if (rolled.isETotal) {
         message.content += ` -- une blessure ${label} s'infecte (temps de guérison augmenté de ${gravite} jours, perte de vie)`;
         await actor.santeIncDec("vie", -1);
-        mergeObject(update, {
+        foundry.utils.mergeObject(update, {
           system: { fin: { indexDate: timestamp.addJours(gravite).indexDate } }
         });
       }
       else {
         if (!isMaladeEmpoisonne && rolled.isSuccess && this.peutRetrograder(graviteMoindre, moindres)) {
           message.content += ` -- une blessure ${label} cicatrise`;
-          mergeObject(update, {
+          foundry.utils.mergeObject(update, {
             system: {
               gravite: graviteMoindre,
               temporel: { fin: { indexDate: timestamp.addJours(graviteMoindre).indexDate } }

module/item/maladie.js

@@ -38,7 +38,7 @@ export class RdDItemMaladie extends RdDItem {
 
       await mal.actor.updateEmbeddedDocuments('Item', [{
         _id: mal.id,
-        'system.temporel.fin': duplicate(timestampFin),
+        'system.temporel.fin': foundry.utils.duplicate(timestampFin),
       }])
     }
   }

module/item/sheet-base-inventaire.js

@@ -8,7 +8,7 @@ const TYPE_ITEMS_NATURELS = ["faune", "herbe", "plante", "ingredient"];
 export class RdDItemInventaireSheet extends RdDItemSheet {
 
   static get defaultOptions() {
-    return mergeObject(RdDItemSheet.defaultOptions, {
+    return foundry.utils.mergeObject(RdDItemSheet.defaultOptions, {
       tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "informations" }]
     });
   }
@@ -23,7 +23,7 @@ export class RdDItemInventaireSheet extends RdDItemSheet {
 
   async getData() {
     const formData = await super.getData();
-    return mergeObject(formData, {
+    return foundry.utils.mergeObject(formData, {
       milieux: await game.system.rdd.environnement.autresMilieux(this.item)
     });
   }

module/item/sheet-rencontre.js

@@ -6,7 +6,7 @@ export class RdDRencontreItemSheet extends RdDItemSheet {
   static get ITEM_TYPE() { return "rencontre" };
 
   static get defaultOptions() {
-    return mergeObject(super.defaultOptions, {
+    return foundry.utils.mergeObject(super.defaultOptions, {
       tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "carac" }]
     });
   }
@@ -24,7 +24,7 @@ export class RdDRencontreItemSheet extends RdDItemSheet {
   /* -------------------------------------------- */
   async getData() {
     const formData = await super.getData();
-    mergeObject(formData, {
+    foundry.utils.mergeObject(formData, {
       effets: {
         succes: {
           liste: RdDRencontre.getEffetsSucces(),

module/migrations.js

@@ -5,6 +5,7 @@ import { Monnaie } from "./item-monnaie.js";
 import { RdDItem, TYPES } from "./item.js";
 import { RdDTimestamp } from "./time/rdd-timestamp.js";
 import { RdDRaretes } from "./item/raretes.js";
+import { RdDCalendrier } from "./time/rdd-calendrier.js";
 
 class Migration {
   get code() { return "sample"; }
@@ -70,17 +71,17 @@ class _10_0_16_MigrationSortsReserve extends Migration {
   get version() { return "10.0.16"; }
 
   async migrate() {
-    await game.actors
+    const actors = game.actors.filter((actor) => actor.type == "personnage" && (actor.system.reve?.reserve?.list?.length ?? 0 > 0))
-      .filter((actor) => actor.type == "personnage")
+    Promise.all(actors.map(async it => await this.convertirSortsReserveActeur(it)))
-      .filter((actor) => actor.system.reve?.reserve?.list?.length ?? 0 > 0)
+  }
-      .forEach(async (actor) => {
+
-        const sortsReserve = actor.system.reve.reserve.list.map(this.conversionSortReserve);
+  async convertirSortsReserveActeur(actor) {
-        console.log(`${LOG_HEAD} Migration des sorts en réserve de ${actor.name}`, sortsReserve);
+    const sortsReserve = actor.system.reve.reserve.list.map(this.conversionSortReserve);
-        await actor.createEmbeddedDocuments("Item", sortsReserve, {
+    console.log(`${LOG_HEAD} Migration des sorts en réserve de ${actor.name}`, sortsReserve);
-          renderSheet: false,
+    await actor.createEmbeddedDocuments("Item", sortsReserve, {
-        });
+      renderSheet: false,
-        await actor.update({ 'system.reve.reserve': undefined })
+    });
-      });
+    await actor.update({ 'system.reve.reserve': undefined });
   }
 
   conversionSortReserve(it) {
@@ -189,7 +190,7 @@ class _10_2_5_ArmesTirLancer extends Migration {
   get version() { return "10.2.5"; }
 
   migrateArmeTirLancer(it) {
-    let updates = mergeObject({ _id: it.id }, this.getMapping(it).updates);
+    let updates = foundry.utils.mergeObject({ _id: it.id }, this.getMapping(it).updates);
     console.log(it.name, updates);
     return updates;
   }
@@ -364,7 +365,7 @@ class _10_4_6_ServicesEnCommerces extends Migration {
     const item = await RdDItem.getCorrespondingItem(serviceRefItem);
     const itemToCreate = {
       name: item.name, img: item.img, type: item.type,
-      system: mergeObject({ cout: serviceRefItem.system.cout, quantite: serviceRefItem.system.quantite }, item.system, { overwrite: false })
+      system: foundry.utils.mergeObject({ cout: serviceRefItem.system.cout, quantite: serviceRefItem.system.quantite }, item.system, { overwrite: false })
     };
     return itemToCreate;
   }
@@ -507,13 +508,28 @@ class _10_7_19_PossessionsEntiteVictime extends Migration {
   }
 
   migratePossession(it) {
-    return { _id: it.id,
+    return {
+      _id: it.id,
       'system.entite.actorid': it.system.possesseurid,
       'system.victime.actorid': it.system.possedeid
     }
   }
 }
 
+class _11_2_20_MigrationAstrologie extends Migration {
+  get code() { return "migration-astrologie" }
+  get version() { return "11.2.20" }
+
+  async migrate() {
+    const nombresAstraux = game.system.rdd.calendrier.getNombresAstraux()
+    nombresAstraux.forEach(na => {
+      na.lectures = na.valeursFausses
+      na.valeursFausses = undefined
+    })
+    await game.system.rdd.calendrier.setNombresAstraux(nombresAstraux)
+  }
+}
+
 export class Migrations {
   static getMigrations() {
     return [
@@ -532,6 +548,7 @@ export class Migrations {
       new _10_7_0_MigrationBlessures(),
       new _10_7_19_CategorieCompetenceCreature(),
       new _10_7_19_PossessionsEntiteVictime(),
+      new _11_2_20_MigrationAstrologie(),
     ];
   }
 
@@ -546,7 +563,10 @@ export class Migrations {
   }
 
   migrate() {
-    const currentVersion = game.settings.get(SYSTEM_RDD, "systemMigrationVersion");
+    let currentVersion = game.settings.get(SYSTEM_RDD, "systemMigrationVersion")
+    if (currentVersion.startsWith("v")) {
+      currentVersion = currentVersion.substring(1)
+    }
     if (isNewerVersion(game.system.version, currentVersion)) {
       // if (true) { /* comment previous and uncomment here to test before upgrade  */
       const migrations = Migrations.getMigrations().filter(m => isNewerVersion(m.version, currentVersion));
@@ -554,7 +574,7 @@ export class Migrations {
         migrations.sort((a, b) => this.compareVersions(a, b));
         migrations.forEach(async (m) => {
           ui.notifications.info(
-            `Executing migration ${m.code}: version ${currentVersion} is lower than ${m.version}`
+            `${LOG_HEAD} Executing migration ${m.code}: version ${currentVersion} is lower than ${m.version}`
           );
           await m.migrate();
         });
@@ -562,9 +582,7 @@ export class Migrations {
           `Migrations done, version will change to ${game.system.version}`
         );
       } else {
-        console.log(
+        console.log(`${LOG_HEAD} No migration needeed, version will change to ${game.system.version}`
-          LOG_HEAD +
-          `No migration needeed, version will change to ${game.system.version}`
         );
       }
 
@@ -574,7 +592,7 @@ export class Migrations {
         game.system.version
       );
     } else {
-      console.log(LOG_HEAD + `No system version changed`);
+      console.log(`${LOG_HEAD} No system version changed`);
     }
   }
 

module/misc.js

@@ -46,7 +46,7 @@ export class Misc {
   }
 
   static typeName(type, subType) {
-    return subType ? game.i18n.localize(`TYPES.${type}.${Misc.upperFirst(subType)}`)
+    return subType ? game.i18n.localize(`TYPES.${type}.${subType}`)
       : '';
   }
 
@@ -200,7 +200,7 @@ export class Misc {
 
   /* -------------------------------------------- */
   static findFirstLike(value, elements, options = {}) {
-    options = mergeObject({
+    options = foundry.utils.mergeObject({
       mapper: it => it.name,
       preFilter: it => true,
       description: 'valeur',
@@ -225,7 +225,7 @@ export class Misc {
   }
 
   static findAllLike(value, elements, options = {}) {
-    options = mergeObject({
+    options = foundry.utils.mergeObject({
       mapper: it => it.name,
       preFilter: it => true,
       description: 'valeur',

module/rdd-combat.js

@@ -128,7 +128,7 @@ export class RdDCombatManager extends Combat {
 
       // Send a chat message
       let rollMode = messageOptions.rollMode || game.settings.get("core", "rollMode");
-      let messageData = mergeObject(
+      let messageData = foundry.utils.mergeObject(
         {
           speaker: {
             scene: canvas.scene._id,
@@ -218,7 +218,7 @@ export class RdDCombatManager extends Combat {
 
   static $prepareAttaqueArme(infoAttaque) {
     const comp = infoAttaque.competences.find(c => c.name == infoAttaque.competence);
-    const attaque = duplicate(infoAttaque.arme);
+    const attaque = foundry.utils.duplicate(infoAttaque.arme);
     attaque.action = 'attaque';
     attaque.system.competence = infoAttaque.competence;
     attaque.system.dommagesReels = infoAttaque.dommagesReel;
@@ -885,12 +885,12 @@ export class RdDCombat {
 
     this.removeChatMessageActionsPasseArme(attackerRoll.passeArme);
     if (essaisPrecedents) {
-      mergeObject(attackerRoll.essais, essaisPrecedents, { overwrite: true });
+      foundry.utils.mergeObject(attackerRoll.essais, essaisPrecedents, { overwrite: true });
     }
 
     // # utilisation esquive
     const corpsACorps = this.defender.getCompetenceCorpsACorps({ onMessage: it => console.info(it, this.defender) });
-    const esquives = duplicate(this.defender.getCompetencesEsquive())
+    const esquives = foundry.utils.duplicate(this.defender.getCompetencesEsquive())
     esquives.forEach(e => e.system.nbUsage = e?._id ? this.defender.getItemUse(e._id) : 0);
 
     const paramChatDefense = {
@@ -1282,7 +1282,7 @@ export class RdDCombat {
       attackerRoll.defenderTokenId = defenderTokenId;
 
       await this.computeRecul(defenderRoll);
-      this.defender.encaisserDommages(attackerRoll, this.attacker, defenderRoll?.show);
+      await this.defender.encaisserDommages(attackerRoll, this.attacker, defenderRoll?.show);
     }
     else { // envoi à un GM: les joueurs n'ont pas le droit de modifier les personnages qu'ils ne possèdent pas
       game.socket.emit(SYSTEM_SOCKET_ID, {
@@ -1307,6 +1307,7 @@ export class RdDCombat {
       blessuresStatus: actor.computeResumeBlessure(),
       SConst: actor.getSConst(),
       actorId: actor.id,
+      actor: actor,
       tokenId: tokenId,
       isGrave: actor.countBlessures(it => it.isGrave()) > 0,
       isCritique: actor.countBlessures(it => it.isCritique()) > 0

module/rdd-commands.js

@@ -16,6 +16,7 @@ import { RdDRollTables } from "./rdd-rolltables.js";
 import { RdDUtility } from "./rdd-utility.js";
 import { FenetreRechercheTirage } from "./tirage/fenetre-recherche-tirage.js";
 import { TMRUtility } from "./tmr-utility.js";
+import { DialogFatigueVoyage } from "./voyage/dialog-fatigue-voyage.js";
 
 const rddRollNumeric = /^(\d+)\s*([\+\-]?\d+)?\s*(s)?/;
 
@@ -76,6 +77,7 @@ export class RdDCommands {
     this.registerCommand({ path: ["/tirer", "desir"], func: (content, msg, params) => RdDRollTables.getDesirLancinant('chat'), descr: "Tire un Désir Lancinant" });
     this.registerCommand({ path: ["/tirer", "rencontre"], func: (content, msg, params) => this.getRencontreTMR(params), descr: `Détermine une rencontre dans les TMR (synonyme de "/tmrr")` });
     this.registerCommand({ path: ["/tirage"], func: (content, msg, params) => this.tirage(), descr: "Ouvre la fenêtre de recherche et tirage" });
+    this.registerCommand({ path: ["/voyage"], func: (content, msg, params) => this.voyage(msg, params), descr: "Gérer le voyage" });
 
     this.registerCommand({ path: ["/sommeil"], func: (content, msg, params) => this.sommeil(msg, params), descr: "Prépare le passage de journée pour chateau dormant" });
     this.registerCommand({ path: ["/meteo"], func: (content, msg, params) => this.getMeteo(msg, params), descr: "Propose une météo marine" });
@@ -298,7 +300,7 @@ export class RdDCommands {
   async getRencontreTMR(params) {
     if (params.length == 1 || params.length == 2) {
       return game.system.rdd.rencontresTMR.rollRencontre(params[0], params[1])
-    }
+    }    
     return false;
   }
 
@@ -461,14 +463,13 @@ export class RdDCommands {
 
       let motif = params.slice(1, params.length - 2);
       let name = params[params.length - 1];
+      const personnages = game.actors.filter(actor => actor.isPersonnageJoueur());
       if (name == undefined) {
-        for (let actor of game.actors) {
+        for (let actor of personnages) {
-          // TODO: ne plus stresser les entités de cauchemar!
           await actor.distribuerStress('stress', stress, motif);
         }
       } else {
-        //console.log(stressValue, nomJoueur);
+        let actor = Misc.findActor(name, personnages) ?? Misc.findPlayer(name)?.character
-        let actor = Misc.findActor(name, game.actors.filter(it => it.hasPlayerOwner)) ?? Misc.findPlayer(name)?.character
         if (actor) {
           await actor.distribuerStress('stress', stress, motif);
         }
@@ -485,10 +486,13 @@ export class RdDCommands {
   }
 
   async tirage() {
-    FenetreRechercheTirage.create();
+    FenetreRechercheTirage.create()
+  }
+  async voyage() {
+    DialogFatigueVoyage.create()
   }
   async sommeil() {
-    DialogChateauDormant.create();
+    DialogChateauDormant.create()
   }
 }
 

module/rdd-confirm.js

@@ -14,10 +14,10 @@ export class RdDConfirm {
         "cancel": RdDConfirm._createButtonCancel()
       };
       if (options.settingConfirmer) {
-        buttons = mergeObject(RdDConfirm._createButtonActionSave(options), buttons);
+        buttons = foundry.utils.mergeObject(RdDConfirm._createButtonActionSave(options), buttons);
       }
       if (autresActions) {
-        buttons = mergeObject(autresActions, buttons);
+        buttons = foundry.utils.mergeObject(autresActions, buttons);
       }
       const dialogDetails = {
         title: options.title,

module/rdd-empoignade.js

@@ -98,7 +98,7 @@ export class RdDEmpoignade {
   /* -------------------------------------------- */
   static getEmpoignadeById(actor, id) {
     let emp = actor.itemTypes[TYPES.empoignade].find(it => it.system.empoignadeid == id)
-    return emp && duplicate(emp) || undefined;
+    return emp && foundry.utils.duplicate(emp) || undefined;
   }
 
   /* -------------------------------------------- */
@@ -108,7 +108,7 @@ export class RdDEmpoignade {
       (it.system.empoigneurid == defender.id && it.system.empoigneid == attacker.id)
     )
     if (emp) {
-      return duplicate(emp);
+      return foundry.utils.duplicate(emp);
     }
     return undefined;
   }
@@ -267,7 +267,7 @@ export class RdDEmpoignade {
       return
     }
 
-    empoignade = duplicate(empoignade)
+    empoignade = foundry.utils.duplicate(empoignade)
     let defenderRoll = {
       mode, attacker, defender, empoignade, attackerRoll,
       diffLibre: attackerRoll.diffLibre,

module/rdd-main.js

@@ -266,16 +266,16 @@ export class SystemReveDeDragon {
     /* -------------------------------------------- */
     /*  Foundry VTT Initialization                  */
     /* -------------------------------------------- */
-    // CSS patch for v9
-    if (game.version) {
-      let sidebar = document.getElementById("sidebar");
-      sidebar.style.width = "min-content";
-    }
     game.system.rdd.calendrier = new RdDCalendrier();
     if (Misc.isUniqueConnectedGM()) {
       new Migrations().migrate();
       this.messageDeBienvenue();
-      this.registerUsageCount(SYSTEM_RDD);
+      import("https://www.uberwald.me/fvtt_appcount/count-class-ready.js").then(moduleCounter=>{
+        console.log("ClassCounter loaded", moduleCounter)
+        moduleCounter.ClassCounter.registerUsageCount()
+      }).catch(err=>
+        console.log("No stats available, giving up.")
+      )    
     }
 
     StatusEffects.onReady();
@@ -306,30 +306,6 @@ export class SystemReveDeDragon {
       ` });
     }
   }
-
-  /* -------------------------------------------- */
-  // Register world usage statistics
-  async registerUsageCount(registerKey) {
-    if (game.user.isGM) {
-      game.settings.register("world", "world-key", {
-        name: "Unique world key",
-        scope: "world",
-        config: false,
-        default: "NONE",
-        type: String
-      });
-
-      let worldKey = game.settings.get("world", "world-key")
-      if (worldKey == undefined || worldKey == "") {
-        worldKey = randomID(32)
-        game.settings.set("world", "world-key", worldKey)
-      }
-      let regURL = `https://www.uberwald.me/fvtt_appcount/count.php?name="${registerKey}"&worldKey="${worldKey}"&version="${game.release.generation}.${game.release.build}"&system="${game.system.id}"&systemversion="${game.system.version}"`
-      $.ajax(regURL)
-      /* -------------------------------------------- */
-    }
-  }
-
 }
 
 SystemReveDeDragon.start();

module/rdd-possession.js

@@ -24,7 +24,7 @@ export class RdDPossession {
     if (!poss) {
       poss = defender.items.find(poss => poss.type == TYPES.possession && poss.system.victime.actorid == defender.id);
     }
-    return poss && duplicate(poss) || undefined;
+    return poss && foundry.utils.duplicate(poss) || undefined;
   }
 
   /* -------------------------------------------- */
@@ -52,7 +52,7 @@ export class RdDPossession {
 
   /* -------------------------------------------- */
   static async onConjurerPossession(attacker, possession) {
-    possession = duplicate(possession);
+    possession = foundry.utils.duplicate(possession);
     RdDPossession.$updateEtatPossession(possession)
 
     const defender = game.actors.get(possession.system.entite.actorid);
@@ -80,7 +80,7 @@ export class RdDPossession {
       ui.notifications.warn("Une erreur s'est produite : Aucune possession trouvée !!")
       return
     }
-    possession = duplicate(possession)
+    possession = foundry.utils.duplicate(possession)
     // Update for draconic roll
     let rollData = {
       mode: "defense",

module/rdd-resolution-table.js

@@ -114,7 +114,7 @@ export class RdDResolutionTable {
 
   /* -------------------------------------------- */
   static async roll(caracValue, finalLevel, rollData = {}) {
-    let chances = duplicate(this.computeChances(caracValue, finalLevel));
+    let chances = foundry.utils.duplicate(this.computeChances(caracValue, finalLevel));
     this._updateChancesWithBonus(chances, rollData.bonus, finalLevel);
     this._updateChancesFactor(chances, rollData.diviseurSignificative);
     chances.showDice = rollData.showDice;
@@ -158,7 +158,7 @@ export class RdDResolutionTable {
   static _updateChancesFactor(chances, diviseur) {
     if (chances.level > -11 && diviseur && diviseur > 1) {
       let newScore = Math.floor(chances.score / diviseur);
-      mergeObject(chances, this._computeCell(undefined, newScore), { overwrite: true });
+      foundry.utils.mergeObject(chances, this._computeCell(undefined, newScore), { overwrite: true });
     }
   }
 
@@ -166,27 +166,27 @@ export class RdDResolutionTable {
   static _updateChancesWithBonus(chances, bonus, finalLevel) {
     if (bonus && finalLevel > -11) {
       let newScore = Number(chances.score) + bonus;
-      mergeObject(chances, this._computeCell(undefined, newScore), { overwrite: true });
+      foundry.utils.mergeObject(chances, this._computeCell(undefined, newScore), { overwrite: true });
     }
   }
 
   /* -------------------------------------------- */
   static significativeRequise(chances) {
     chances.roll = Math.floor(chances.score / 2);
-    mergeObject(chances, reussites.find(x => x.code == 'sign'), { overwrite: true });
+    foundry.utils.mergeObject(chances, reussites.find(x => x.code == 'sign'), { overwrite: true });
   }
 
   /* -------------------------------------------- */
   static succesRequis(chances) {
     chances.roll = chances.score;
-    mergeObject(chances, reussites.find(x => x.code == 'norm'), { overwrite: true });
+    foundry.utils.mergeObject(chances, reussites.find(x => x.code == 'norm'), { overwrite: true });
   }
 
   /* -------------------------------------------- */
   static async rollChances(chances, diviseur, forceDiceResult = -1) {
     chances.forceDiceResult = forceDiceResult <= 0 || forceDiceResult > 100 ? undefined : { total: forceDiceResult };
     chances.roll = await RdDDice.rollTotal("1d100", chances);
-    mergeObject(chances, this.computeReussite(chances, chances.roll, diviseur), { overwrite: true });
+    foundry.utils.mergeObject(chances, this.computeReussite(chances, chances.roll, diviseur), { overwrite: true });
     return chances;
   }
 

module/rdd-roll-resolution-table.js

@@ -38,7 +38,7 @@ export class RdDRollResolutionTable extends Dialog {
       diffLibre: 0,
       use: { conditions:true, libre:true }
     }
-    mergeObject(rollData, defRollData, { overwrite: false });
+    foundry.utils.mergeObject(rollData, defRollData, { overwrite: false });
     for (let i = 1; i < 21; i++) {
       const key = `${i}`;
       rollData.carac[key] = { type: "number", value: i, label: key }

module/rdd-roll.js

@@ -65,7 +65,7 @@ export class RdDRoll extends Dialog {
       defaultRollData.carac["reve-actuel"] = actor.system.reve.reve
     }
 
-    mergeObject(rollData, defaultRollData, { recursive: true, overwrite: false });
+    foundry.utils.mergeObject(rollData, defaultRollData, { recursive: true, overwrite: false });
     if (rollData.forceCarac) {
       rollData.carac = rollData.forceCarac;
     }

module/rdd-sheet-utility.js

@@ -16,7 +16,7 @@ export class RdDSheetUtility {
       isObserver: userRightLevel >= CONST.DOCUMENT_OWNERSHIP_LEVELS.OBSERVER,
       isOwner: userRightLevel >= CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER
     }
-    mergeObject(options, newOptions);
+    foundry.utils.mergeObject(options, newOptions);
     return options;
   }
 
@@ -76,7 +76,7 @@ export class RdDSheetUtility {
   static async _onSplitItem(item, split, actor) {
     if (split >= 1 && split < item.system.quantite) {
       await item.diminuerQuantite(split);
-      const splitItem = duplicate(item);
+      const splitItem = foundry.utils.duplicate(item);
       // todo: ajouter dans le même conteneur?
       splitItem.system.quantite = split;
       await actor.createEmbeddedDocuments('Item', [splitItem])

module/rdd-tmr-dialog.js

@@ -44,16 +44,15 @@ export class RdDTMRDialog extends Dialog {
       type: Number,
       range: TMR_DISPLAY_SIZE.range
     })
-    await PixiTMR.init()
   }
 
   static async create(actor, tmrData) {
+    await PixiTMR.init()
     let html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/dialog-tmr.html', tmrData);
-
     if (tmrData.mode != 'visu' && !game.user.isGM) {
       ChatMessage.create({ content: actor.name + " est monté dans les TMR en mode : " + tmrData.mode, whisper: ChatMessage.getWhisperRecipients("GM") });
     }
-    return new RdDTMRDialog(html, actor, tmrData);
+    return new RdDTMRDialog(html, actor, tmrData)
   }
 
   /* -------------------------------------------- */
@@ -71,7 +70,7 @@ export class RdDTMRDialog extends Dialog {
       'z-index': 40
     }
     super(dialogConf, dialogOptions);
-    this.tmrdata = duplicate(tmrData);
+    this.tmrdata = foundry.utils.duplicate(tmrData);
     this.actor = actor;
     this.actor.tmrApp = this; // reference this app in the actor structure
     this.viewOnly = tmrData.mode == "visu"
@@ -298,13 +297,12 @@ export class RdDTMRDialog extends Dialog {
 
   /* -------------------------------------------- */
   async updateValuesDisplay() {
-    if (!this.rendered) {
+    if (this.viewOnly || !this.rendered) {
       return;
     }
     const coord = this._getCoordActor();
-
     HtmlUtility.showControlWhen(this.html.find(".lire-signe-draconique"), this.actor.isResonanceSigneDraconique(coord));
-
+    
     let ptsreve = document.getElementById("tmr-pointsreve-value");
     ptsreve.innerHTML = this.actor.system.reve.reve.value;
 
@@ -409,7 +407,7 @@ export class RdDTMRDialog extends Dialog {
 
   /* -------------------------------------------- */
   $marquerCasesTMR(listCoordTMR) {
-    this.currentRencontre.locList = duplicate(listCoordTMR); // And track of allowed location
+    this.currentRencontre.locList = foundry.utils.duplicate(listCoordTMR); // And track of allowed location
     this.currentRencontre.graphics = listCoordTMR.map(coordTMR => this.pixiTMR.addMarkTMR(coordTMR))
   }
 
@@ -538,7 +536,7 @@ export class RdDTMRDialog extends Dialog {
   /* -------------------------------------------- */
   _rollPresentCite(rencData) {
     let rolled = RdDResolutionTable.computeChances(rencData.reve, 0);
-    mergeObject(rolled, { caracValue: rencData.reve, finalLevel: 0, roll: rolled.score });
+    foundry.utils.mergeObject(rolled, { caracValue: rencData.reve, finalLevel: 0, roll: rolled.score });
     RdDResolutionTable.succesRequis(rolled);
     return rolled;
   }
@@ -681,7 +679,7 @@ export class RdDTMRDialog extends Dialog {
     if (this.isCaseHumide(tmr)) {
       let rollData = {
         actor: this.actor,
-        competence: duplicate(this.actor.getBestDraconic()),
+        competence: foundry.utils.duplicate(this.actor.getBestDraconic()),
         tmr: tmr,
         canClose: false,
         diffLibre: -7,
@@ -700,7 +698,6 @@ export class RdDTMRDialog extends Dialog {
   }
 
   async _resultatMaitriseCaseHumide(rollData) {
-    await this.souffleSiEchecTotal(rollData);
     if (rollData.rolled.isSuccess && rollData.double) {
       rollData.previous = { rolled: rollData.rolled, ajustements: rollData.ajustements };
       rollData.double = undefined;
@@ -715,6 +712,7 @@ export class RdDTMRDialog extends Dialog {
     if (rollData.rolled.isEchec) {
       await this.close();
     }
+    await this.souffleSiEchecTotal(rollData);
   }
 
   /* -------------------------------------------- */
@@ -806,7 +804,7 @@ export class RdDTMRDialog extends Dialog {
   async _conquerir(tmr, options) {
     let rollData = {
       actor: this.actor,
-      competence: duplicate(this.actor.getBestDraconic()),
+      competence: foundry.utils.duplicate(this.actor.getBestDraconic()),
       tmr: tmr,
       canClose: options.canClose ?? false,
       diffLibre: options.difficulte ?? -7,

module/rdd-utility.js

@@ -18,6 +18,7 @@ import { RdDRaretes } from "./item/raretes.js";
 import { RdDEmpoignade } from "./rdd-empoignade.js";
 import { ExperienceLog } from "./actor/experience-log.js";
 import { RdDCoeur } from "./coeur/rdd-coeur.js";
+import { APP_ASTROLOGIE_REFRESH } from "./sommeil/app-astrologie.js";
 
 /* -------------------------------------------- */
 // This table starts at 0 -> niveau -10
@@ -31,7 +32,7 @@ function _buildAllSegmentsFatigue(max) {
   const cycle = [5, 2, 4, 1, 3, 0];
   const fatigue = [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]];
   for (let i = 0; i <= max; i++) {
-    const ligneFatigue = duplicate(fatigue[i]);
+    const ligneFatigue = foundry.utils.duplicate(fatigue[i]);
     const caseIncrementee = cycle[i % 6];
     ligneFatigue[caseIncrementee]++;
     ligneFatigue[caseIncrementee + 6]++;
@@ -45,7 +46,7 @@ function _buildAllSegmentsFatigue(max) {
 function _cumulSegmentsFatigue(matrix) {
   let cumulMatrix = [];
   for (let line of matrix) {
-    let cumul = duplicate(line);
+    let cumul = foundry.utils.duplicate(line);
 
     for (let i = 1; i < 12; i++) {
       cumul[i] += cumul[i - 1];
@@ -63,12 +64,6 @@ const cumulFatigueMatrix = _cumulSegmentsFatigue(fatigueMatrix);
 const fatigueMalus = [0, 0, 0, -1, -1, -1, -2, -3, -4, -5, -6, -7]; // Provides the malus for each segment of fatigue
 const fatigueLineSize = [3, 6, 7, 8, 9, 10, 11, 12];
 const fatigueLineMalus = [0, -1, -2, -3, -4, -5, -6, -7];
-const fatigueMarche = {
-  "aise": { "4": 1, "6": 2, "8": 3, "10": 4, "12": 6 },
-  "malaise": { "4": 2, "6": 3, "8": 4, "10": 6 },
-  "difficile": { "4": 3, "6": 4, "8": 6 },
-  "tresdifficile": { "4": 4, "6": 6 }
-}
 
 /* -------------------------------------------- */
 const nomEthylisme = ["Emeché", "Gris", "Pinté", "Pas frais", "Ivre", "Bu", "Complètement fait", "Ivre mort"];
@@ -208,6 +203,8 @@ export class RdDUtility {
       'systems/foundryvtt-reve-de-dragon/templates/coeur/afficher-coeur.hbs',
       'systems/foundryvtt-reve-de-dragon/templates/tirage/liste-resultats-recherche.hbs',
       'systems/foundryvtt-reve-de-dragon/templates/time/horloge.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/voyage/fatigue-actor.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/voyage/option-vitesse-fatigue.hbs',
       'systems/foundryvtt-reve-de-dragon/templates/common/timestamp.hbs',
       'systems/foundryvtt-reve-de-dragon/templates/common/periodicite.hbs',
       'systems/foundryvtt-reve-de-dragon/templates/common/enum-duree.hbs',
@@ -288,6 +285,7 @@ export class RdDUtility {
     Handlebars.registerHelper('timestamp-formulesDuree', () => RdDTimestamp.formulesDuree());
     Handlebars.registerHelper('timestamp-formulesPeriode', () => RdDTimestamp.formulesPeriode());
 
+    Handlebars.registerHelper('array-includes', (array, value) => array.includes(value));
     Handlebars.registerHelper('min', (...args) => Math.min(...args.slice(0, -1)));
     Handlebars.registerHelper('regle-optionnelle', (option) => ReglesOptionnelles.isUsing(option));
     Handlebars.registerHelper('trier', list => list.sort((a, b) => a.name.localeCompare(b.name)));
@@ -552,49 +550,54 @@ export class RdDUtility {
 
   /* -------------------------------------------- */
   static async jetEncaissement(rollData, armure, options = { showDice: HIDE_DICE }) {
-    let formula = "2d10";
+    const diff = Math.abs(rollData.diffLibre);
+    let formula = RdDUtility.formuleEncaissement(diff, options)
+    const roll = await RdDDice.roll(formula, options);
 
-    // Chaque dé fait au minmum la difficulté libre
+    RdDUtility.remplaceDeMinParDifficulte(roll, diff, options);
-    if (ReglesOptionnelles.isUsing('degat-minimum-malus-libre')) {
-      if (rollData.diffLibre < 0) {
-        let valeurMin = Math.abs(rollData.diffLibre);
-        formula += "min" + valeurMin;
-      }
-    }
-    // Chaque dé fait au minmum la difficulté libre
-    if (ReglesOptionnelles.isUsing('degat-ajout-malus-libre')) {
-      if (rollData.diffLibre < 0) {
-        let valeurMin = Math.abs(rollData.diffLibre);
-        formula += "+" + valeurMin;
-      }
-    }
-
-    let roll = await RdDDice.roll(formula, options);
-
-    // 1 dé fait au minmum la difficulté libre
-    if (ReglesOptionnelles.isUsing('degat-minimum-malus-libre-simple')) {
-      if (rollData.diffLibre < 0) {
-        let valeurMin = Math.abs(rollData.diffLibre);
-        if (roll.terms[0].results[0].result < valeurMin) {
-          roll.terms[0].results[0].result = valeurMin;
-        } else if (roll.terms[0].results[1].result < valeurMin) {
-          roll.terms[0].results[1].result = valeurMin;
-        }
-        roll._total = roll.terms[0].results[0].result + roll.terms[0].results[1].result;
-      }
-    }
 
     return await RdDUtility.prepareEncaissement(rollData, roll, armure);
   }
 
+  static remplaceDeMinParDifficulte(roll, diff, options) {
+    if (!ReglesOptionnelles.isUsing('degat-minimum-malus-libre-simple')) {
+      return
+    }
+    // 1 dé fait au minmum la difficulté libre
+    const total = options.forceDiceResult?.total;
+    if (total) {
+      const reste = Math.max(total - diff, 1)
+      roll.terms[0].number = reste + diff
+    }
+    else {
+      if (roll.terms[0].results[0].result < diff) {
+        roll.terms[0].results[0].result = diff;
+      } else if (roll.terms[0].results[1].result < diff) {
+        roll.terms[0].results[1].result = diff;
+      }
+      roll._total = roll.terms[0].results[0].result + roll.terms[0].results[1].result;
+    }
+  }
+
+  static formuleEncaissement(diff, options) {
+    // Chaque dé fait au minimum la difficulté libre
+    if (ReglesOptionnelles.isUsing('degat-minimum-malus-libre')) {
+      return `2d10min${diff}`
+    }
+    return '2d10'
+  }
+
   /* -------------------------------------------- */
   static async prepareEncaissement(rollData, roll, armure) {
-    const jetTotal = roll.total + rollData.dmg.total - armure;
+    // La difficulté d'ataque s'ajoute aux dégâts
-    let encaissement = RdDUtility._selectEncaissement(jetTotal, rollData.dmg.mortalite);
+    const bonusDegatsDiffLibre = ReglesOptionnelles.isUsing('degat-ajout-malus-libre') ? Math.abs(rollData.diffLibre ?? 0) : 0
-    let over20 = Math.max(jetTotal - 20, 0);
+    const jetTotal = roll.total + rollData.dmg.total - armure + bonusDegatsDiffLibre
+    const encaissement = RdDUtility._selectEncaissement(jetTotal, rollData.dmg.mortalite);
+    const over20 = Math.max(jetTotal - 20, 0);
     encaissement.dmg = rollData.dmg;
     encaissement.dmg.loc = rollData.dmg.loc ?? await RdDUtility.getLocalisation(this.type);
     encaissement.dmg.loc.label = encaissement.dmg.loc.label ?? 'Corps;';
+    encaissement.dmg.bonusDegatsDiffLibre = bonusDegatsDiffLibre
     encaissement.roll = roll;
     encaissement.armure = armure;
     encaissement.penetration = rollData.arme?.system.penetration ?? 0;
@@ -610,10 +613,10 @@ export class RdDUtility {
     for (let encaissement of table) {
       if ((encaissement.minimum === undefined || encaissement.minimum <= degats)
         && (encaissement.maximum === undefined || degats <= encaissement.maximum)) {
-        return duplicate(encaissement);
+        return foundry.utils.duplicate(encaissement);
       }
     }
-    return duplicate(table[0]);
+    return foundry.utils.duplicate(table[0]);
   }
 
   /* -------------------------------------------- */
@@ -623,21 +626,15 @@ export class RdDUtility {
     return perte.total;
   }
 
-  /* -------------------------------------------- */
-  static async responseNombreAstral(callData) {
-    let actor = game.actors.get(callData.id);
-    actor.ajouteNombreAstral(callData);
-  }
-
   /* -------------------------------------------- */
   static onSocketMessage(sockmsg) {
     switch (sockmsg.msg) {
       case "msg_gm_chat_message":
         return ChatUtility.handleGMChatMessage(sockmsg.data);
+      case "msg_app_astrologie_refresh":
+        return Hooks.callAll(APP_ASTROLOGIE_REFRESH);
       case "msg_request_nombre_astral":
         return game.system.rdd.calendrier.requestNombreAstral(sockmsg.data);
-      case "msg_response_nombre_astral":
-        return RdDUtility.responseNombreAstral(sockmsg.data);
       case "msg_tmr_move":
         let actor = game.actors.get(sockmsg.data.actorId);
         if (actor.isOwner || game.user.isGM) {

module/rolldata-ajustements.js

@@ -166,7 +166,7 @@ export class RollDataAjustements {
   /* -------------------------------------------- */
   static calcul(rollData, actor) {
     // s'assurer de la correction des infos rollData
-    mergeObject(rollData, { ajustements: {}, use: {} }, { overwrite: false })
+    foundry.utils.mergeObject(rollData, { ajustements: {}, use: {} }, { overwrite: false })
 
     for (var key in referenceAjustements) {
       const reference = referenceAjustements[key];

module/settings/regles-optionnelles.js

@@ -71,7 +71,7 @@ export class ReglesOptionnelles extends FormApplication {
 
   static get defaultOptions() {
     const options = super.defaultOptions;
-    mergeObject(options, {
+    foundry.utils.mergeObject(options, {
       id: "regles-optionnelles",
       template: "systems/foundryvtt-reve-de-dragon/templates/settings/regles-optionnelles.html",
       height: 650,
@@ -86,7 +86,7 @@ export class ReglesOptionnelles extends FormApplication {
   getData() {
     let formData = super.getData();
     const regles = listeReglesOptionnelles.filter(it => game.user.isGM || it.scope == "client").map(it => {
-      it = duplicate(it);
+      it = foundry.utils.duplicate(it);
       it.id = ReglesOptionnelles._getIdRegle(it.name);
       it.active = ReglesOptionnelles.isSet(it.name);
       return it;

module/settings/status-effects.js

@@ -70,7 +70,7 @@ export class StatusEffects extends FormApplication {
     if (statusDemiSurprise.intersects(effect.statuses)) {
       return 1
     }
-    if (isCombat && effect.statuses.includes(STATUSES.StatusDemiReve)) {
+    if (isCombat && effect.statuses.find(e => e == STATUSES.StatusDemiReve)) {
       return 1
     }
     return 0
@@ -94,7 +94,7 @@ export class StatusEffects extends FormApplication {
   static prepareActiveEffect(effectId) {
     let status = rddStatusEffects.find(it => it.id == effectId)
     if (status) {
-      status = duplicate(status)
+      status = foundry.utils.duplicate(status)
       status.statuses = [effectId]
     }
     return status;
@@ -125,7 +125,7 @@ export class StatusEffects extends FormApplication {
   getData() {
     const used = StatusEffects._getUseStatusEffects();
     let formData = super.getData();
-    formData.effects = duplicate(CONFIG.RDD.allEffects);
+    formData.effects = foundry.utils.duplicate(CONFIG.RDD.allEffects);
     formData.effects.forEach(it => it.active = used.includes(it.id))
     return formData;
   }

module/settings/system-compendiums.js

@@ -27,7 +27,7 @@ export class SystemCompendiums extends FormApplication {
   static init() {
     Object.keys(CONFIGURABLE_COMPENDIUMS).forEach(compendium => {
       const definition = CONFIGURABLE_COMPENDIUMS[compendium];
-      mergeObject(definition, {
+      foundry.utils.mergeObject(definition, {
         compendium: compendium,
         default: SystemCompendiums._getDefaultCompendium(compendium),
         setting: SystemCompendiums._getSettingCompendium(compendium)
@@ -138,7 +138,7 @@ export class SystemCompendiums extends FormApplication {
 
   static get defaultOptions() {
     const options = super.defaultOptions;
-    mergeObject(options, {
+    foundry.utils.mergeObject(options, {
       id: "system-compendiums",
       template: "systems/foundryvtt-reve-de-dragon/templates/settings/system-compendiums.html",
       height: 'fit-content',
@@ -152,7 +152,7 @@ export class SystemCompendiums extends FormApplication {
 
   getData() {
     const systemCompendiums = Object.values(CONFIGURABLE_COMPENDIUMS)
-      .map(it => mergeObject(it, { value: SystemCompendiums.getCompendium(it.compendium) }));
+      .map(it => foundry.utils.mergeObject(it, { value: SystemCompendiums.getCompendium(it.compendium) }));
     const availableCompendiums = game.packs.map(pack => {
       return {
         name: pack.collection,
@@ -160,7 +160,7 @@ export class SystemCompendiums extends FormApplication {
         type: pack.metadata.type
       }
     });
-    return mergeObject(super.getData(), {
+    return foundry.utils.mergeObject(super.getData(), {
       systemCompendiums: systemCompendiums,
       availableCompendiums: availableCompendiums
     });

module/sommeil/app-astrologie.js

@@ -17,7 +17,7 @@ export class AppAstrologie extends Application {
 
 
   static get defaultOptions() {
-    return mergeObject(super.defaultOptions, {
+    return foundry.utils.mergeObject(super.defaultOptions, {
       template: "systems/foundryvtt-reve-de-dragon/templates/sommeil/app-astrologie.hbs",
       title: "Astrologie",
       width: 'fit-content',
@@ -31,13 +31,12 @@ export class AppAstrologie extends Application {
   constructor(actor, options = {}) {
     super(options);
     this.actor = actor;
-    this.hookReference = Hooks.on(APP_ASTROLOGIE_REFRESH, () => this.refreshAstrologie());
   }
 
   getData(options) {
     this.appData = super.getData(options)
     const calendrier = game.system.rdd.calendrier;
-    mergeObject(this.appData, {
+    foundry.utils.mergeObject(this.appData, {
       isGM: game.user.isGM,
       isActor: this.actor != undefined,
       calendrier: calendrier.getTimestamp().toCalendrier(),
@@ -85,9 +84,10 @@ export class AppAstrologie extends Application {
       const nbAstral = calendrier.getNombreAstral()
       const heures = RdDTimestamp.heures();
       return {
-        ajustementsActors: game.actors.filter(it => it.isPersonnage() && it.hasPlayerOwner)
+        ajustementsActors: game.actors.filter(actor => actor.isPersonnageJoueur())
           .map(actor => this.getAjustementActor(actor, nbAstral, heures)),
-        nombresAstraux: calendrier.getNombresAstraux().map(na => this.getDetailNombreAstral(na))
+        nombresAstraux: game.system.rdd.calendrier.getNombresAstraux()
+          .map(na => this.getDetailNombreAstral(na))
       }
     }
     return {}
@@ -104,22 +104,25 @@ export class AppAstrologie extends Application {
   }
 
   getDetailNombreAstral(nombreAstral) {
-    const detail = duplicate(nombreAstral);
+    const detail = foundry.utils.duplicate(nombreAstral);
     const timestamp = new RdDTimestamp({ indexDate: nombreAstral.index });
     detail.date = { mois: timestamp.mois, jour: timestamp.jour + 1 };
-    detail.valeursFausses.forEach(fausse => fausse.actorName = game.actors.get(fausse.actorId).name ?? "Inconnu");
+    detail.lectures.forEach(lecture => lecture.actorName = game.actors.get(lecture.actorId).name ?? "Inconnu");
     return detail;
   }
 
   /* -------------------------------------------- */
   activateListeners(html) {
+    if (!this.hookReference){
+      this.hookReference = Hooks.on(APP_ASTROLOGIE_REFRESH, () => this.refreshAstrologie());
+    }
     super.activateListeners(html);
     this.html = html;
     this.html.find('select[name="signe-astral"]').change(event => {
-      this.selectNombreAstral(this.html.find('select[name="signe-astral"]').val());
+      this.selectNombreAstral(event.currentTarget.value);
     })
     this.html.find('select[name="signe-naissance"]').change(event => {
-      this.selectHeureNaissance(this.html.find('select[name="signe-naissance"]').val());
+      this.selectHeureNaissance(event.currentTarget.value);
     })
     this.html.find('td.nombre-astral').click(event => {
       this.selectNombreAstral(Number.parseInt(event.currentTarget.attributes['data-nombre-astral'].value) - 1);
@@ -145,8 +148,7 @@ export class AppAstrologie extends Application {
 
   /* -------------------------------------------- */
   async onRebuild() {
-    game.system.rdd.calendrier.resetNombresAstraux();
+    await game.system.rdd.calendrier.resetNombresAstraux();
-
     await game.system.rdd.calendrier.rebuildNombresAstraux();
   }
 
@@ -195,6 +197,8 @@ export class AppAstrologie extends Application {
   }
 
   refreshAstrologie() {
+    this.count = (this.count ?? 0)+1
+    console.log(`Refreshing ${this.count}`);
     this.render(true)
   }
 

module/sommeil/dialog-chateau-dormant.js

@@ -3,10 +3,8 @@ export class DialogChateauDormant extends Dialog {
 
   static async create() {
     const date = game.system.rdd.calendrier.dateCourante();
-    const actors = game.actors.filter(actor => actor.hasPlayerOwner && actor.isPersonnage());
-
     const dialogData = {
-      actors: actors,
+      actors: game.actors.filter(actor => actor.isPersonnageJoueur()),
       date: date,
       motifStress: `Nuit du ${date}`,
       finChateauDormant: game.system.rdd.calendrier.getTimestampFinChateauDormant()

module/sommeil/dialog-repos.js

@@ -21,7 +21,7 @@ export class DialogRepos extends Dialog {
   }
 
   constructor(html, actor) {
-    let options = { classes: ["DialogCreateSigneDraconiqueActorsActors"], width: 400, height: 'fit-content', 'z-index': 99999 };
+    let options = { classes: ["dialog-repos"], width: 400, height: 'fit-content', 'z-index': 99999 };
     let conf = {
       title: "Se reposer",
       content: html,

module/sommeil/dialog-stress.js

@@ -6,7 +6,7 @@ export class DialogStress extends Dialog {
       motif: "Motif",
       stress: 10,
       immediat: false,
-      actors: game.actors.filter(actor => actor.hasPlayerOwner && actor.isPersonnage())
+      actors: game.actors.filter(actor => actor.isPersonnageJoueur())
         .map(actor => ({
             id: actor.id,
             name: actor.name,

module/time/rdd-calendrier-editor.js

@@ -61,7 +61,7 @@ export class RdDCalendrierEditor extends Dialog {
 
   /* -------------------------------------------- */
   updateData(calendrierData) {
-    this.calendrierData = duplicate(calendrierData);
+    this.calendrierData = foundry.utils.duplicate(calendrierData);
   }
 
 }

module/time/rdd-calendrier.js

@@ -35,7 +35,7 @@ export class RdDCalendrier extends Application {
   }
 
   static get defaultOptions() {
-    return mergeObject(super.defaultOptions, {
+    return foundry.utils.mergeObject(super.defaultOptions, {
       title: "Calendrier",
       template: TEMPLATE_CALENDRIER,
       classes: ["calendar"],
@@ -51,7 +51,6 @@ export class RdDCalendrier extends Application {
     this.timestamp = RdDTimestamp.getWorldTime();
     if (Misc.isUniqueConnectedGM()) { // Uniquement si GM
       RdDTimestamp.setWorldTime(this.timestamp);
-      this.nombresAstraux = this.getNombresAstraux();
       this.rebuildNombresAstraux(); // Ensure always up-to-date
     }
     Hooks.on('updateSetting', async (setting, update, options, id) => this.onUpdateSetting(setting, update, options, id));
@@ -108,7 +107,10 @@ export class RdDCalendrier extends Application {
       this.timestamp = RdDTimestamp.getWorldTime();
       this.positionAiguilles()
       this.render(false);
-      Hooks.callAll(APP_ASTROLOGIE_REFRESH);
+      Hooks.callAll(APP_ASTROLOGIE_REFRESH)
+    }
+    if (setting.key == SYSTEM_RDD + '.' + "liste-nombre-astral") {
+      Hooks.callAll(APP_ASTROLOGIE_REFRESH)
     }
   }
 
@@ -120,7 +122,7 @@ export class RdDCalendrier extends Application {
 
   /* -------------------------------------------- */
   fillCalendrierData(formData = {}) {
-    mergeObject(formData, this.timestamp.toCalendrier());
+    foundry.utils.mergeObject(formData, this.timestamp.toCalendrier());
     formData.isGM = game.user.isGM;
     formData.heures = RdDTimestamp.definitions()
     formData.horlogeAnalogique = this.horlogeAnalogique;
@@ -167,7 +169,11 @@ export class RdDCalendrier extends Application {
 
   /* -------------------------------------------- */
   getNombresAstraux() {
-    return game.settings.get(SYSTEM_RDD, "liste-nombre-astral") ?? [];
+    return game.settings.get(SYSTEM_RDD, "liste-nombre-astral") ?? []
+  }
+
+  async setNombresAstraux(nombresAstraux) {
+    await game.settings.set(SYSTEM_RDD, "liste-nombre-astral", nombresAstraux)
   }
 
   /* -------------------------------------------- */
@@ -225,20 +231,15 @@ export class RdDCalendrier extends Application {
     const nombreAstral = await RdDDice.rollTotal("1dh", { showDice: HIDE_DICE, rollMode: "selfroll" });
     return {
       nombreAstral: nombreAstral,
-      valeursFausses: [],
+      lectures: [],
       index: indexDate
     }
   }
 
   /* -------------------------------------------- */
-  resetNombresAstraux() {
+  async resetNombresAstraux() {
-    this.nombresAstraux = [];
+    await Promise.all(game.actors.filter(it => it.type == "personnage").map(async it => await it.deleteNombresAstraux()))
-    game.settings.set(SYSTEM_RDD, "liste-nombre-astral", []);
+    await this.setNombresAstraux([])
-
-    game.socket.emit(SYSTEM_SOCKET_ID, {
-      msg: "msg_reset_nombre_astral",
-      data: {}
-    });
   }
 
   /**
@@ -251,39 +252,30 @@ export class RdDCalendrier extends Application {
     if (indexDate == undefined) {
       indexDate = this.timestamp.indexDate;
     }
-    this.nombresAstraux = this.getNombresAstraux();
+    const nombresAstraux = this.getNombresAstraux()
-    let astralData = this.nombresAstraux.find((nombreAstral, i) => nombreAstral.index == indexDate);
+    let astralData = nombresAstraux.find(it => it.index == indexDate);
     return astralData?.nombreAstral ?? 0;
   }
 
   /* -------------------------------------------- */
   async rebuildNombresAstraux() {
     if (Misc.isUniqueConnectedGM()) {
-      let newList = [];
+      const nombresAstraux = this.getNombresAstraux()
+      let newNombresAstraux = [];
       for (let i = 0; i < MAX_NOMBRE_ASTRAL; i++) {
         let dayIndex = this.timestamp.indexDate + i;
-        let na = this.nombresAstraux.find(n => n.index == dayIndex);
+        let na = nombresAstraux.find(it => it.index == dayIndex);
         if (na) {
-          newList[i] = na;
+          newNombresAstraux[i] = na;
         } else {
-          newList[i] = await this.ajouterNombreAstral(dayIndex);
+          newNombresAstraux[i] = await this.ajouterNombreAstral(dayIndex);
         }
       }
-      this.nombresAstraux = newList;
-      game.settings.set(SYSTEM_RDD, "liste-nombre-astral", newList);
       game.actors.filter(it => it.isPersonnage()).forEach(actor => actor.supprimerAnciensNombresAstraux());
-      this.notifyChangeNombresAstraux();
+      await this.setNombresAstraux(newNombresAstraux);
     }
   }
 
-  notifyChangeNombresAstraux() {
-    Hooks.callAll(APP_ASTROLOGIE_REFRESH);
-    game.socket.emit(SYSTEM_SOCKET_ID, {
-      msg: "msg_refresh_nombre_astral",
-      data: {}
-    });
-  }
-
   /* -------------------------------------------- */
   async setNewTimestamp(newTimestamp) {
     const oldTimestamp = this.timestamp;
@@ -373,25 +365,22 @@ export class RdDCalendrier extends Application {
         request.nbAstral = await RdDDice.rollTotal("1dhr" + request.nbAstral, {
           rollMode: "selfroll", showDice: HIDE_DICE
         });
-        // Mise à jour des nombres astraux du joueur
-        this.addNbAstralIncorect(request.id, request.date, request.nbAstral);
-      }
-
-      if (Misc.getActiveUser(request.userId)?.isGM) {
-        RdDUtility.responseNombreAstral(request);
-      } else {
-        game.socket.emit(SYSTEM_SOCKET_ID, {
-          msg: "msg_response_nombre_astral",
-          data: request
-        });
       }
+      // Mise à jour des nombres astraux du joueur
+      await this.addNbAstralJoueur(actor, request.date, request.nbAstral, request.isValid)
+      Hooks.callAll(APP_ASTROLOGIE_REFRESH)
+      game.socket.emit(SYSTEM_SOCKET_ID, { msg: "msg_app_astrologie_refresh", data: {} })
     }
   }
-
+  
-  addNbAstralIncorect(actorId, date, nbAstral) {
+  async addNbAstralJoueur(actor, date, nbAstral, isValid) {
-    const astralData = this.nombresAstraux.find((nombreAstral, i) => nombreAstral.index == date);
+    const nombresAstraux = this.getNombresAstraux()
-    astralData.valeursFausses.push({ actorId: actorId, nombreAstral: nbAstral });
+    const astralData = nombresAstraux.find(it => it.index == date)
-    game.settings.set(SYSTEM_RDD, "liste-nombre-astral", this.nombresAstraux);
+    if (astralData) {
+      astralData.lectures.push({ actorId: actor.id, nombreAstral: nbAstral });
+      await this.setNombresAstraux(nombresAstraux);
+      await actor.ajouteNombreAstral(date, nbAstral, isValid);
+    }
   }
 
   /* -------------------------------------------- */

module/time/rdd-timestamp.js

@@ -202,7 +202,7 @@ export class RdDTimestamp {
   }
 
   static setWorldTime(timestamp) {
-    game.settings.set(SYSTEM_RDD, WORLD_TIMESTAMP_SETTING, duplicate(timestamp));
+    game.settings.set(SYSTEM_RDD, WORLD_TIMESTAMP_SETTING, foundry.utils.duplicate(timestamp));
   }
 
   /** construit un RdDTimestamp à partir de l'année/mois/jour/heure?/minute? */

module/tirage/fenetre-recherche-tirage.js

@@ -117,7 +117,7 @@ function $loadFilters(parameters) {
 
 export class FenetreRechercheTirage extends Application {
   static get defaultOptions() {
-    return mergeObject(super.defaultOptions, {
+    return foundry.utils.mergeObject(super.defaultOptions, {
       template: "systems/foundryvtt-reve-de-dragon/templates/tirage/fenetre-recherche-tirage.hbs",
       title: `Recherches et tirages`,
       width: 600,
@@ -133,7 +133,7 @@ export class FenetreRechercheTirage extends Application {
     const parameters = {
       milieux: milieux,
       filterMilieux: $filterMilieux(milieux),
-      filterGroups: duplicate(FILTER_GROUPS).filter(it => it.group),
+      filterGroups: foundry.utils.duplicate(FILTER_GROUPS).filter(it => it.group),
     }
     const options = {}
     $loadFilters(parameters);
@@ -147,7 +147,7 @@ export class FenetreRechercheTirage extends Application {
   }
 
   async getData() {
-    return mergeObject(await super.getData(), this.parameters)
+    return foundry.utils.mergeObject(await super.getData(), this.parameters)
   }
 
   _canDragStart() { return true; }
@@ -294,7 +294,7 @@ class FenetreRechercheConfiguration extends Dialog {
   static async create() {
     const configuration = {
       compendiums: game.packs.filter(it => it.metadata.type == 'Item').map(it => it.metadata)
-        .map(it => mergeObject({ selected: game.system.rdd.environnement.compendiums.includes(it.id) }, it))
+        .map(it => foundry.utils.mergeObject({ selected: game.system.rdd.environnement.compendiums.includes(it.id) }, it))
     }
     const html = await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/tirage/fenetre-recherche-configuration.hbs", configuration);
     new FenetreRechercheConfiguration(html).render(true);

module/tmr-rencontres.js

@@ -39,6 +39,8 @@ export class TMRRencontres {
     const frequence = it => it.system.frequence[codeTerrain];
     const row = await this.table.getRandom(frequence, filtreMauvaise, forcedRoll);
     if (row) {
+      console.log("DORM", row);
+      //row.document.system.computedForce = new Roll(row.document.system.formula).roll({async: false}).total; 
       await CompendiumTableHelpers.tableRowToChatMessage(row);
     }
 

module/tmr/effets-rencontres.js

@@ -107,7 +107,7 @@ export class EffetsRencontre {
   }
 
   static rdd_part_tete = async (dialog, context) => {
-    mergeObject(context, {
+    foundry.utils.mergeObject(context, {
       tete: context.rolled.isPart,
       poesie: await Poetique.getExtrait()
     })
@@ -118,7 +118,7 @@ export class EffetsRencontre {
   }
 
   static rdd_echec_queue = async (dialog, context) => {
-    mergeObject(context, {
+    foundry.utils.mergeObject(context, {
       queues: [await context.actor.ajouterQueue()],
       poesie: await Poetique.getExtrait()
     })

module/tmr/pixi-tmr.js

@@ -1,4 +1,3 @@
-import { SYSTEM_RDD } from "../constants.js";
 import { Misc } from "../misc.js";
 import { TMRConstants, tmrTokenZIndex } from "../tmr-constants.js";
 import { TMRUtility } from "../tmr-utility.js";
@@ -14,12 +13,12 @@ export class PixiTMR {
   static register(name, img) {
     PixiTMR.textures[name] = img;
   }
+
   static async init() {
     await Promise.all(
       Object.values(PixiTMR.textures)
-        .filter(img => img != undefined)
+        .filter(img => img != undefined && !PIXI.utils.TextureCache[img])
-        .map(async img => PIXI.Sprite.from(await PIXI.Assets.load(img)))
+        .map(async img => PIXI.Sprite.from(await PIXI.Assets.load(img))))
-    )
   }
 
   constructor(tmrDialog, displaySize) {
@@ -106,8 +105,9 @@ export class PixiTMR {
 
   sprite(code, options = {}) {
     let img = PixiTMR.getImgFromCode(code)
-    const texture = PIXI.utils.TextureCache[img]
+    let texture = PIXI.utils.TextureCache[img]
     if (!texture) {
+      // TODO: charger la texture
       console.error("Texture manquante", code, PIXI.utils.TextureCache)
       return;
     }

module/voyage/dialog-fatigue-voyage.js

@@ -0,0 +1,181 @@
+import { TYPES } from "../item.js"
+import { RdDItemCompetence } from "../item-competence.js"
+import { ChatUtility } from "../chat-utility.js"
+
+const CODES_COMPETENCES_VOYAGE = ['Extérieur', 'Forêt', 'Montagne', 'Marais', 'Glace', 'Equitation']
+const TABLEAU_FATIGUE_MARCHE = [
+  {
+    code: "aise", label: "Aisé", description: "Route ou chemin",
+    survies: ['Extérieur', 'Equitation'],
+    vitesses: [{ vitesse: 4, fatigue: 1 }, { vitesse: 6, fatigue: 2 }, { vitesse: 8, fatigue: 3 }, { vitesse: 10, fatigue: 4 }, { vitesse: 12, fatigue: 6 }],
+  },
+  {
+    code: "malaise", label: "Malaisé", description: "Hors piste (herbes et buissons)",
+    survies: ['Extérieur', 'Equitation'],
+    vitesses: [{ vitesse: 4, fatigue: 2 }, { vitesse: 6, fatigue: 3 }, { vitesse: 8, fatigue: 4 }, { vitesse: 10, fatigue: 6 }],
+  },
+  {
+    code: "difficile", label: "Difficile", description: "Hors piste (collines, forêt)",
+    survies: ['Extérieur', 'Forêt', 'Glace', 'Equitation'],
+    vitesses: [{ vitesse: 4, fatigue: 3 }, { vitesse: 6, fatigue: 4 }, { vitesse: 8, fatigue: 6 }],
+  },
+  {
+    code: "tresdifficile", label: "Très difficile", description: "Hors piste (montagne, jungle, marais)",
+    survies: ['Forêt', 'Montagne', 'Marais', 'Glace'],
+    vitesses: [{ vitesse: 4, fatigue: 4 }, { vitesse: 6, fatigue: 6 }],
+  },
+]
+
+export class DialogFatigueVoyage extends Dialog {
+  static dialog = undefined
+  static async create() {
+    if (!game.user.isGM) {
+      return
+    }
+    if (!DialogFatigueVoyage.dialog) {
+      const parameters = {
+        tableauFatigueMarche: TABLEAU_FATIGUE_MARCHE,
+        playerActors: game.actors.filter(actor => actor.isPersonnageJoueur())
+          .map(actor => DialogFatigueVoyage.prepareActor(actor)),
+        nombreHeures: 1,
+      }
+      DialogFatigueVoyage.setModeDeplacement(parameters, undefined, undefined)
+
+      const html = await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/voyage/dialog-fatigue-voyage.hbs", parameters);
+      DialogFatigueVoyage.dialog = new DialogFatigueVoyage(html, parameters);
+    }
+    DialogFatigueVoyage.dialog.render(true);
+  }
+
+  static setModeDeplacement(parameters, code, vitesse) {
+    const ligneFatigueMarche = TABLEAU_FATIGUE_MARCHE.find(it => it.code == code) ?? TABLEAU_FATIGUE_MARCHE[0]
+    const rythme = ligneFatigueMarche.vitesses.find(it => it.vitesse == vitesse) ?? ligneFatigueMarche.vitesses[0]
+    parameters.typeTerrain = ligneFatigueMarche
+    parameters.vitesseDeplacement = rythme.vitesse
+    parameters.fatigueHoraire = rythme.fatigue
+  }
+
+  static prepareActor(actor) {
+    const competencesVoyage = {}
+    CODES_COMPETENCES_VOYAGE.forEach(codeSurvie =>
+      competencesVoyage[codeSurvie] = RdDItemCompetence.findCompetence(actor.itemTypes[TYPES.competence], codeSurvie, { onMessage: () => { } })
+    )
+    return {
+      actor: actor,
+      selected: true,
+      ajustementFatigue: 0,
+      competencesVoyage: competencesVoyage
+    }
+  }
+
+
+  constructor(html, parameters) {
+    const options = {
+      classes: ["dialog-fatigue-voyage"],
+      width: 600,
+      height: 'fit-content',
+      'max-height': 900,
+      'z-index': 99999
+    }
+    const conf = {
+      title: "Fatigue de voyage",
+      content: html,
+      buttons: {}
+    }
+    super(conf, options);
+    this.parameters = parameters
+    this.controls = {}
+  }
+
+  activateListeners(html) {
+    if (this.html == undefined) {
+      html.find('select[name="code-terrain"]').trigger("focus")
+    }
+    this.html = html;
+    super.activateListeners(html);
+
+    this.html.find('select[name="code-terrain"]').change(event => this.changeParameters())
+    this.html.find('select[name="vitesse-deplacement"]').change(event => this.changeParameters())
+    this.html.find('input[name="nombre-heures"]').change(event => this.changeParameters())
+    this.html.find('button[name="appliquer-fatigue"]').click(event => this.appliquerFatigue())
+  }
+
+  changeParameters() {
+    this.changeTerrain(this.html.find('select[name="code-terrain"]').val())
+    this.changeVitesse(this.html.find('select[name="vitesse-deplacement"]').val())
+    this.changeNombreHeures(this.html.find('input[name="nombre-heures"]').val())
+    this.setFatigue()
+  }
+
+  async changeTerrain(codeTerrain) {
+    if (this.parameters.typeTerrain.code != codeTerrain) {
+      const selectVitesseDeplacement = this.html.find('select[name="vitesse-deplacement"]')
+      const vitesse = selectVitesseDeplacement.val()
+      selectVitesseDeplacement.empty()
+
+      DialogFatigueVoyage.setModeDeplacement(this.parameters, codeTerrain, vitesse)
+      this.parameters.typeTerrain.vitesses.forEach(async rythme => {
+        selectVitesseDeplacement.append(await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/voyage/option-vitesse-fatigue.hbs', rythme))
+      })
+      selectVitesseDeplacement.val(this.parameters.vitesseDeplacement).change()
+    }
+  }
+
+  async changeVitesse(vitesse) {
+    if (this.parameters.vitesseDeplacement != vitesse) {
+      DialogFatigueVoyage.setModeDeplacement(this.parameters, this.parameters.typeTerrain.code, vitesse)
+    }
+  }
+
+  async changeNombreHeures(nombreHeures) {
+    this.parameters.nombreHeures = parseInt(nombreHeures)
+  }
+
+  async setFatigue() {
+    this.html.find('input[name="base-fatigue"]').val(this.parameters.nombreHeures * this.parameters.fatigueHoraire)
+  }
+
+  async appliquerFatigue() {
+    const fatigueBase = parseInt(this.html.find('input[name="base-fatigue"]').val() ?? 0)
+    const actors = jQuery.map(
+      this.html.find('div.fatigue-actors-list li.list-item'),
+      it => this.$extractActor(this.html.find(it))
+    )
+    actors.filter(it => it.selected)
+    .forEach(async it => {
+        const perteFatigue = fatigueBase + it.ajustement
+        ChatMessage.create({
+          whisper: ChatUtility.getWhisperRecipientsAndGMs(it.actor.name),
+          content: await renderTemplate(
+            'systems/foundryvtt-reve-de-dragon/templates/voyage/chat-fatigue_voyage.hbs', foundry.utils.mergeObject(it,
+              {
+                parameters: this.parameters,
+                fatigueBase: fatigueBase,
+                perteFatigue: perteFatigue,
+                isVoyage: fatigueBase == this.parameters.nombreHeures * this.parameters.fatigueHoraire
+              })
+          ),
+        })
+        await it.actor.santeIncDec("fatigue", perteFatigue)
+      })
+  }
+
+  $extractActor(actorRow) {
+    const actor = game.actors.get(actorRow.data('actor-id'))
+    if (!actor) {
+      ui.notifications.warn(`Acteur ${it.actorId} introuvable`)
+    }
+    return {
+      actor: actor,
+      ajustement: parseInt(actorRow.find('input[name="ajustement-fatigue"]').val() ?? 0),
+      selected: actor && actorRow.find('input[name="selectionner-acteur"]').is(':checked')
+    }
+  }
+
+  async close() {
+    DialogFatigueVoyage.dialog = undefined
+    await super.close()
+  }
+
+
+}

styles/simple.css

@@ -92,6 +92,8 @@
   --background-custom-button-hover: linear-gradient(to bottom, rgb(128, 0, 0) 5%, rgb(62, 1, 1) 100%);
   --background-control-selected: linear-gradient(to bottom, hsla(0, 100%, 25%, 0.5) 5%, hsla(0, 100%, 12%, 0.5) 100%);
   --background-tooltip: hsla(60, 12%, 85%, 0.95);
+  --color-tooltip:hsla(282, 47%, 33%, 0.9);
+  --color-tooltip-faint:hsla(282, 47%, 66%, 0.5);
   --background-error:hsla(16, 100%, 50%, 0.8);
   --color-profile-border: hsla(0, 0%, 80%, 0.05);
 }
@@ -433,6 +435,7 @@ table {border: 1px solid #7a7971;}
 }
 .flex-shrink {
   flex: 'flex-shrink' ;
+  flex-shrink: 2;
 }
 :is(.flex-grow, .flex-grow-3) {
   flex-grow: 3;
@@ -440,7 +443,19 @@ table {border: 1px solid #7a7971;}
 .flex-grow-2 {
   flex-grow: 2;
 }
+.flex-grow-1 {
+  flex-grow: 1;
+}
+.flex-grow-0-5 {
+  flex-grow: 0.5;
+}
+.voyage-liste-survies {
+  max-width: 12rem;
+}
 /* Styles limited to foundryvtt-reve-de-dragon sheets */
+.texte-dans-liste {
+  text-align: left;
+}
 .equipement-nom {
   flex-grow : 4;
   margin: 0;
@@ -1168,7 +1183,7 @@ ul.chat-list li:nth-child(odd) {
   border-radius: 0.25rem;
   padding: 0.1rem;
   flex: 1 1 1.5rem;
-  display: flex !important;
+  display: flex;
   align-items: center !important;
 }
 
@@ -1309,10 +1324,7 @@ div.competence-column div.categorie-competence{
   margin-right: 0.2rem;
   margin-left: 0.2rem;
 }
-.blessures-title { 
+.item-label { 
-  font-weight: bold;
-}
-.alchimie-title { 
   font-weight: bold;
 }
 .pointsreve-value {
@@ -1933,7 +1945,7 @@ div.calendar-timestamp-edit select.calendar-signe-heure {
   padding: 3px;
 }
 
-aside#tooltip{
+aside#tooltip {
   background: var(--background-tooltip);
   color: var(--color-text-dark-primary);
   font-size: 1rem;
@@ -1941,6 +1953,15 @@ aside#tooltip{
   padding: 0.4rem;
 }
 
+aside#tooltip span.reference {
+  color: var(--color-tooltip);
+  border: 1px solid var(--color-tooltip-faint);
+}
+
+aside#tooltip .toolclip p.faint {
+  color: var(--color-tooltip-faint);
+}
+
 .tooltip :is(.ttt-xp,.ttt-levelup) {
   width: 250px;
   background: var(--background-tooltip) !important;

system.json

@@ -1,8 +1,8 @@
 {
   "id": "foundryvtt-reve-de-dragon",
   "title": "Rêve de Dragon",
-  "version": "11.2.12",
+  "version": "11.2.20",
-  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-11.2.12.zip",
+  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-11.2.20.zip",
   "manifest": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/raw/v11/system.json",
   "changelog": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/raw/branch/v11/changelog.md",
   "compatibility": {
@@ -528,8 +528,10 @@
     }
   ],
   "socket": true,
-  "gridDistance": 1,
+  "grid": {
-  "gridUnits": "m",
+    "distance": 1,
+    "units": "m"
+  },
   "primaryTokenAttribute": "sante.vie",
   "secondaryTokenAttribute": "sante.endurance",
   "media": [

template.json

@@ -525,15 +525,11 @@
   },
   "Item": {
     "types": [
-        "competence", "competencecreature",
+        "arme", "armure", "blessure", "casetmr", "chant", "competence", "competencecreature", "conteneur", "danse", 
-        "recettealchimique", "musique", "chant", "danse", "jeu", "recettecuisine", "oeuvre",
+        "empoignade", "extraitpoetique", "faune", "gemme", "herbe", "ingredient", "jeu", "livre", "maladie", "meditation",
-        "objet", "arme", "armure", "conteneur", "herbe", "plante", "ingredient", "faune", "livre", "potion", "munition",
+        "monnaie", "munition", "musique", "nombreastral", "nourritureboisson", "objet", "oeuvre", "ombre", "plante", "possession", 
-        "monnaie", "nourritureboisson", "gemme",
+        "poison", "potion", "queue", "recettealchimique", "recettecuisine", "rencontre", 
-        "service",
+        "service" ,"signedraconique", "sort", "sortreserve", "souffle", "tarot", "tache", "tete" ],
-        "meditation", "rencontre", "queue", "ombre", "souffle", "tete", "casetmr", "signedraconique", "sort", "sortreserve",
-        "nombreastral", "tache", "blessure", "maladie", "poison", "possession",
-        "tarot", "extraitpoetique", "empoignade"
-    ],
     "templates": {
       "description": {
         "description": "",

templates/actor/alchimie.html

@@ -3,10 +3,12 @@
 <ul class="item-list alterne-list">
   {{#each (trier recettesAlchimiques) as |recette id|}}
   <li class="item flexrow list-item" data-item-id="{{recette._id}}"><span class="competence-title recette-label item-edit"><a>{{recette.name}}</a></span>
-    <div class="item-controls flex-shrink">
+    <div class="item-controls">
-      <a class="item-edit" data-tooltip="Edit Item"><i class="fas fa-edit"></i></a>
+      <a class="item-edit" data-tooltip="Modifier"><i class="fas fa-edit"></i></a>
-      <a class="item-delete" data-tooltip="Delete Item"><i class="fas fa-trash"></i></a>
+      <a class="item-delete" data-tooltip="Supprimer"><i class="fas fa-trash"></i></a>
-    </div>
+      &nbsp;
+      <a class="item-montrer" data-tooltip="Montrer"><i class="fas fa-comment"></i></a>
+  </div>
   </li>
   {{/each}}
 </ul>

templates/actor/blessure.hbs

@@ -36,6 +36,7 @@
   <span class="item-controls">
     <a class="item-edit" data-tooltip="Editer"><i class="fas fa-edit"></i></a>
     <a class="item-delete" data-tooltip="Supprimer"><i class="fas fa-trash"></i></a>
+    &nbsp;
     <a class="item-montrer" data-tooltip="Montrer"><i class="fas fa-comment"></i></a>
   </span>
 </li>

templates/actor/blessures.html

@@ -1,8 +1,14 @@
-<h4>blessures</h4>
+<h4>Blessures</h4>
 <div>
-  <a class="chat-card-button creer-blessure-legere" data-tooltip="Ajouter une blessure légère"><i class="fas fa-plus-circle"></i> légère</a>
+  <a class="chat-card-button creer-blessure-legere" data-tooltip="Ajouter une légère"><i class="fas fa-plus-circle"></i> légère</a>
-  <a class="chat-card-button creer-blessure-grave" data-tooltip="Ajouter une blessure grave"><i class="fas fa-plus-circle"></i> grave</a>
+  <a class="chat-card-button creer-blessure-grave" data-tooltip="Ajouter une grave"><i class="fas fa-plus-circle"></i> grave</a>
-  <a class="chat-card-button creer-blessure-critique" data-tooltip="Ajouter une blessure critque"><i class="fas fa-plus-circle"></i> critique</a>
+  <a class="chat-card-button creer-blessure-critique" data-tooltip="Ajouter une critique"><i class="fas fa-plus-circle"></i> critique</a>
+</div>
+<div>
+  <a class="chat-card-button subir-blessure-contusion" data-tooltip="Subir une contusion (avec perte d'Endurance)"><i class="fas fa-swords"></i> contusion</a>
+  <a class="chat-card-button subir-blessure-legere" data-tooltip="Subir une légère (avec perte d'Endurance)"><i class="fas fa-swords"></i> légère</a>
+  <a class="chat-card-button subir-blessure-grave" data-tooltip="Subir une grave (avec perte d'Endurance/Vie)"><i class="fas fa-swords"></i> grave</a>
+  <a class="chat-card-button subir-blessure-critique" data-tooltip="Subir une critique (avec perte d'Endurance/Vie)"><i class="fas fa-swords"></i> critique</a>
 </div>
 
 <ul class="item-list alterne-list">

templates/actor/chirurgie.html

@@ -12,9 +12,11 @@
       <img class="sheet-competence-img" src="{{tache.img}}"/>
       <span class="competence-title tache-label"><a>{{tache.name}}
         ({{tache.system.points_de_tache_courant}}/{{tache.system.points_de_tache}})</a></span>
-      <div class="item-controls flex-shrink">
+      <div class="item-controls">
-        <a class="item-edit" data-tooltip="Edit Item"><i class="fas fa-edit"></i></a>
+        <a class="item-edit" data-tooltip="Modifier"><i class="fas fa-edit"></i></a>
-        <a class="item-delete" data-tooltip="Delete Item"><i class="fas fa-trash"></i></a>
+        <a class="item-delete" data-tooltip="Supprimer"><i class="fas fa-trash"></i></a>
+        &nbsp;
+        <a class="item-montrer" data-tooltip="Montrer"><i class="fas fa-comment"></i></a>
       </div>
     </li>
     {{/if}}

templates/actor/combat.html

@@ -64,8 +64,8 @@
     </span>
     <span class="competence-value">{{emp.system.pointsemp}}</span>
     <div class="item-controls">
-      <a class="item-edit" data-tooltip="Edit Item"><i class="fas fa-edit"></i></a>
+      <a class="item-edit" data-tooltip="Modifier"><i class="fas fa-edit"></i></a>
-      <a class="item-delete" data-tooltip="Delete Item"><i class="fas fa-trash"></i></a>
+      <a class="item-delete" data-tooltip="Supprimer"><i class="fas fa-trash"></i></a>
     </div>
   </li>
   {{/each}}

templates/actor/comp-creature.html

@@ -23,8 +23,8 @@
       />
     {{#if @root.options.vueDetaillee}}
     <div class="item-controls">
-      <a class="item-edit" data-tooltip="Edit Item"><i class="fas fa-edit"></i></a>
+      <a class="item-edit" data-tooltip="Modifier"><i class="fas fa-edit"></i></a>
-      <a class="item-delete" data-tooltip="Delete Item"><i class="fas fa-trash"></i></a>
+      <a class="item-delete" data-tooltip="Supprimer"><i class="fas fa-trash"></i></a>
     </div>
     {{/if}}
   </li>

templates/actor/comp-possession.html

@@ -6,8 +6,8 @@
       <img class="sheet-competence-img" src="{{possession.img}}" data-tooltip="{{possession.name}}"/>
       <span class="competence-label">{{possession.name}}</span>
       <div class="item-controls">
-        <a class="item-edit" data-tooltip="Edit Item"><i class="fas fa-edit"></i></a>
+        <a class="item-edit" data-tooltip="Modifier"><i class="fas fa-edit"></i></a>
-        <a class="item-delete" data-tooltip="Delete Item"><i class="fas fa-trash"></i></a>
+        <a class="item-delete" data-tooltip="Supprimer"><i class="fas fa-trash"></i></a>
       </div>
     </li>
     {{/each}}

templates/actor/competence.html

@@ -48,7 +48,9 @@
       {{#if @root.options.isGM}}
       <a class="item-delete" data-tooltip="Supprimer"><i class="fas fa-trash"></i></a>
       {{/if}}
-    </div>
+      &nbsp;
+      <a class="item-montrer" data-tooltip="Montrer"><i class="fas fa-comment"></i></a>
+  </div>
     {{/if}}
   </li>
 {{/unless}}

templates/actor/dragon-queue.html

@@ -8,7 +8,8 @@
     <a>{{queue.name}}</a>
   </span>
   <div class="item-controls">
-    <a class="item-delete" data-tooltip="Delete Item"><i class="fas fa-trash"></i></a>
+    <a class="item-delete" data-tooltip="Supprimer"><i class="fas fa-trash"></i></a>
+    <a class="item-montrer" data-tooltip="Montrer"><i class="fas fa-comment"></i></a>
     {{#if queue.system.refoulement}}
     <a class="item-action">Refouler</a>
     {{/if}}

templates/actor/dragon-souffles.html

@@ -5,8 +5,9 @@
   <li class="item flexrow" data-attribute={{key}} data-item-id="{{souffle._id}}" data-tooltip="Souffle: {{souffle.name}}">
     <img class="sheet-competence-img" src="{{souffle.img}}"/>
     <span class="item-edit flex-grow"><a>{{souffle.name}}</a></span>
-    <div class="item-controls flex-shrink">
+    <div class="item-controls">
-      <a class="item-delete" data-tooltip="Delete Item"><i class="fas fa-trash"></i></a>
+      <a class="item-delete" data-tooltip="Supprimer"><i class="fas fa-trash"></i></a>
+      <a class="item-montrer" data-tooltip="Montrer"><i class="fas fa-comment"></i></a>
     </div>
   </li>
   {{/each}}

templates/actor/dragon-tetes.html

@@ -5,8 +5,9 @@
   <li class="item flexrow" data-attribute={{key}} data-item-id="{{tete._id}}" data-tooltip="Tête: {{tete.name}}">
     <img class="sheet-competence-img" src="{{tete.img}}"/>
     <span class="item-edit flex-grow"><a>{{tete.name}}</a></span>
-    <div class="item-controls flex-shrink">
+    <div class="item-controls">
-      <a class="item-delete" data-tooltip="Delete Item"><i class="fas fa-trash"></i></a>
+      <a class="item-delete" data-tooltip="Supprimer"><i class="fas fa-trash"></i></a>
+      <a class="item-montrer" data-tooltip="Montrer"><i class="fas fa-comment"></i></a>
     </div>
   </li>
   {{/each}}

templates/actor/hr-casestmr.html

@@ -6,8 +6,10 @@
       <img class="sheet-competence-img" src="{{casetmr.img}}"/>
       <span class="item-edit"><a>{{casetmr.name}}</a></span>
       <span>{{casetmr.system.coord}} - {{caseTmr-label casetmr.system.coord}}</span> 
-      <div class="item-controls flex-shrink">
+      <div class="item-controls">
         <a class="item-delete" data-tooltip="Supprimer"><i class="fas fa-trash"></i></a>
+        &nbsp;
+        <a class="item-montrer" data-tooltip="Montrer"><i class="fas fa-comment"></i></a>
       </div>
     </li>
     {{/each}}

templates/actor/hr-meditations.html

@@ -5,9 +5,11 @@
   <li class="item flexrow" data-item-id="{{meditation._id}}" data-attribute="{{key}}" data-tooltip="Méditation: {{meditation.name}}">
     <img class="sheet-competence-img" src="{{meditation.img}}"/>
     <span class="meditation-label flex-grow"><a data-item-id="{{meditation._id}}">{{meditation.name}} - {{meditation.system.competence}}</a></span> 
-    <div class="item-controls flex-shrink">
+    <div class="item-controls">
       <a class="item-edit" data-tooltip="Editer"><i class="fas fa-edit"></i></a>
       <a class="item-delete" data-tooltip="Supprimer"><i class="fas fa-trash"></i></a>
+      &nbsp;
+      <a class="item-montrer" data-tooltip="Montrer"><i class="fas fa-comment"></i></a>
     </div>
   </li>
   {{/each}}

templates/actor/hr-rencontres.html

@@ -10,7 +10,7 @@
     {{#if rencontre.system.date}}
     <span class="flex-shrink">{{upperFirst rencontre.system.heure}}, le {{rencontre.system.date}}</span> 
     {{/if}}
-    <div class="item-controls flex-shrink">
+    <div class="item-controls">
       <a class="item-delete" data-tooltip="Supprimer"><i class="fas fa-trash"></i></a>
     </div>
   </li>

templates/actor/hr-signes-draconiques.html

@@ -6,7 +6,7 @@
       <img class="sheet-competence-img" src="{{signe.img}}"/>
       <span class="item-edit flex-grow"><a>{{signe.name}}</a></span> 
       <span class="flex-shrink">{{signe.system.difficulte}}</span>
-      <div class="item-controls flex-shrink">
+      <div class="item-controls">
         <a class="item-delete" data-tooltip="Supprimer"><i class="fas fa-trash"></i></a>
       </div>
     </li>

templates/actor/hr-sorts-reserve.html

@@ -7,7 +7,7 @@
     <img class="sheet-competence-img" src="{{sort.img}}"/>
     <span class="item-edit"><a>{{#if sort.system.echectotal}}Echec total: {{/if}}{{sort.name}} r{{sort.system.ptreve}}</a></span> 
     <span>{{sort.system.coord}} - {{caseTmr-label sort.system.coord}}</span> 
-    <div class="item-controls flex-shrink">
+    <div class="item-controls">
       <a class="item-delete flex-shrink" data-tooltip="Supprimer"><i class="fas fa-trash"></i></a>
     </div>
   </li>

templates/actor/hr-sorts.html

@@ -4,15 +4,16 @@
   {{#each (trier sorts) as |sort key|}}
   <li class="item list-item flexrow" data-item-id="{{sort._id}}" data-attribute="{{key}}"  data-tooltip="{{#if sort.system.isrituel}}Rituel{{else}}Sort{{/if}}: {{sort.name}}">
     <img class="sheet-competence-img" src="{{sort.img}}"/>
-    <span class="item-edit flex-grow-2">
+    <span class="item-edit flex-grow-3">
       <a data-item-id="{{sort._id}}">{{sort.name}}
         - {{#if sort.system.caseTMRspeciale}}{{sort.system.caseTMRspeciale}}{{else}}{{upperFirst sort.system.caseTMR}}{{/if}}
       </a>
     </span>
-    <span>{{#if sort.system.isrituel}}Rituel{{/if}}</span>
+    <span class="flex-grow-0-5">{{#if sort.system.isrituel}}Rituel{{/if}}</span>
-    <span>{{sort.system.draconic}} / {{sort.system.difficulte}}</span>
+    <span class="flex-grow-2">{{sort.system.draconic}}/{{sort.system.difficulte}}</span>
     <div class="item-controls flex-shrink">
       <a class="item-delete" data-tooltip="Supprimer"><i class="fas fa-trash"></i></a>
+      <a class="item-montrer" data-tooltip="Montrer"><i class="fas fa-comment"></i></a>
     </div>
   </li>
   {{/each}}

templates/actor/jeux.html

@@ -4,9 +4,11 @@
   {{#each jeux as |jeu id|}}
   <li class="item flexrow list-item" data-item-id="{{jeu._id}}">
     <span class="competence-title jeu-label"><a>{{jeu.name}} (base {{jeu.system.base}})</a></span>
-    <div class="item-controls flex-shrink">
+    <div class="item-controls">
-      <a class="item-edit" data-tooltip="Edit Item"><i class="fas fa-edit"></i></a>
+      <a class="item-edit" data-tooltip="Modifier"><i class="fas fa-edit"></i></a>
-      <a class="item-delete" data-tooltip="Delete Item"><i class="fas fa-trash"></i></a>
+      <a class="item-delete" data-tooltip="Supprimer"><i class="fas fa-trash"></i></a>
+      &nbsp;
+      <a class="item-montrer" data-tooltip="Montrer"><i class="fas fa-comment"></i></a>
     </div>
   </li>
   {{/each}}

templates/actor/liens-suivants.hbs

@@ -22,7 +22,7 @@
         {{/if}}
       </span>
     {{/if}}
-    <div class="item-controls flex-shrink">
+    <div class="item-controls">
       <a class="subacteur-delete" data-tooltip="Supprimer"><i class="fas fa-trash"></i></a>
     </div>
   </li>

templates/actor/maladies-poisons.html

@@ -1,5 +1,5 @@
 {{#if maladiesPoisons.length}}
-<h3 class="blessures-title">Maladies & Poisons:</h3>
+<h3 class="item-label">Maladies & Poisons:</h3>
 <ul class="item-list alterne-list">
   <li class="competence-header flexrow">
     <span class="competence-title flex-grow competence-label">Nom</span>

templates/actor/non-haut-revant.html

@@ -12,13 +12,21 @@
   <li class="item flexrow" >
     <span class="competence-label">Refoulement : </span>
     <span>
-    {{#if options.isGM}}
+      {{#if options.isGM}}
       <input class="competence-value" type="text" name="system.reve.refoulement.value" value="{{system.reve.refoulement.value}}" data-dtype="Number"/>
-    {{else}}
+      {{else}}
       {{system.reve.refoulement.value}}
-    {{/if}}
+      {{/if}}
     </span>
   </li>
+  {{#if system.reve.reve.thanatosused}}
+  <li class="item flexrow" >
+    <span class="competence-label">La prochaine queue est une Ombre</span>
+    <span>
+      <img class="sheet-competence-img" src="systems/foundryvtt-reve-de-dragon/icons/competence_thanatos.webp"/>
+    </span>
+  </li>
+  {{/if}}
 </ul>
 <hr>
 {{> "systems/foundryvtt-reve-de-dragon/templates/actor/dragon-queues.html"}}

templates/actor/oeuvre.html

@@ -5,8 +5,10 @@
     <a>{{oeuvre.name}} (niveau {{oeuvre.system.niveau}})</a>
   </span>
   <div class="item-controls">
-    <a class="item-edit" data-tooltip="Edit Item"><i class="fas fa-edit"></i></a>
+    <a class="item-edit" data-tooltip="Modifier"><i class="fas fa-edit"></i></a>
-    <a class="item-delete" data-tooltip="Delete Item"><i class="fas fa-trash"></i></a>
+    <a class="item-delete" data-tooltip="Supprimer"><i class="fas fa-trash"></i></a>
+    &nbsp;
+    <a class="item-montrer" data-tooltip="Montrer"><i class="fas fa-comment"></i></a>
   </div>
 </li>
 

templates/actor/possessions.html

@@ -1,6 +1,6 @@
 {{#if possessions.length}}
 {{!-- Possession --}}
-<h3 class="blessures-title">Possession:</h3>
+<h3 class="item-label">Possession:</h3>
 <ul class="item-list alterne-list">
   <li class="competence-header flexrow">
     <span class="competence-title flex-grow competence-label">Nom</span>
@@ -15,7 +15,9 @@
       <div class="item-controls">
         <a class="item-edit" data-tooltip="Modifier"><i class="fas fa-edit"></i></a>
         <a class="item-delete" data-tooltip="Supprimer"><i class="fas fa-trash"></i></a>
-      </div>          
+        &nbsp;
+        <a class="item-montrer" data-tooltip="Montrer"><i class="fas fa-comment"></i></a>
+      </div>
   </li>
   {{/each}}
   </ul>

templates/actor/taches.html

@@ -8,9 +8,11 @@
         ({{tache.system.points_de_tache_courant}}{{#if
           (or @root.options.isGM (not tache.system.cacher_points_de_tache))
         }}/{{tache.system.points_de_tache}}{{/if}})</a></span>
-      <div class="item-controls flex-shrink">
+      <div class="item-controls">
-        <a class="item-edit" data-tooltip="Edit Item"><i class="fas fa-edit"></i></a>
+        <a class="item-edit" data-tooltip="Modifier"><i class="fas fa-edit"></i></a>
-        <a class="item-delete" data-tooltip="Delete Item"><i class="fas fa-trash"></i></a>
+        <a class="item-delete" data-tooltip="Supprimer"><i class="fas fa-trash"></i></a>
+        &nbsp;
+        <a class="item-montrer" data-tooltip="Montrer"><i class="fas fa-comment"></i></a>
       </div>
     </li>
     {{/unless}}

templates/chat-actor-turn-acteur.hbs

@@ -1 +1,2 @@
+<img class="chat-icon" src="{{actor.img}}" data-tooltip="{{actor.name}}" />
 <h4>C'est au tour de {{alias}} !</h4>

templates/chat-actor-turn-sante.hbs

@@ -1,3 +1,4 @@
+<img class="chat-icon" src="{{actor.img}}" data-tooltip="{{actor.name}}" />
 <h4>Résumé de santé pour {{alias}}</h4>
 <div data-combatid="{{combatId}}" data-combatmessage="actor-turn-summary">{{blessuresStatus}}</div>
 <div>Son état général est de : {{etatGeneral}} {{#if isSonne}} et est <strong>sonné</strong>{{/if}}</div>

templates/chat-compendium-table-roll.html

@@ -5,6 +5,11 @@
 <div>
   <img class="chat-icon" src="{{document.img}}" data-tooltip="{{document.name}}" />
   <p>{{linkCompendium document.pack document.id document.name}}</p>
+  {{#if document.system.formule}}
+  <div class="poesie-extrait">
+    [[/r {{document.system.formule}}]]
+  </div>
+  {{/if}}
   {{#if document.system.description}}
   <div class="poesie-extrait">
     {{{document.system.description}}}

templates/dialog-tmr.html

@@ -21,49 +21,48 @@
       </div>
       {{else}}
         {{#if (and isGM hasPlayerOwner)}}
-      <div class="flex-group-center flex-shrink">
+          <div class="flex-group-center flex-shrink">
-          <h4>Le gardien gére les TMR du joueur, le joueur ne peut pas monter dans les TMR!</h4>
+            <h4>Le gardien gére les TMR du joueur, le joueur ne peut pas monter dans les TMR!</h4>
-        </div>
+          </div>
         {{/if}}
-      <div class="flex-group-center flex-shrink">
+        <div class="flex-group-center flex-shrink">
-        <img class="small-button-direction tmr-move" data-move="topleft" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/dir-topleft.svg">
+          <img class="small-button-direction tmr-move" data-move="topleft" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/dir-topleft.svg">
-        <img class="small-button-direction tmr-move" data-move="top" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/dir-top.svg">
+          <img class="small-button-direction tmr-move" data-move="top" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/dir-top.svg">
-        <img class="small-button-direction tmr-move" data-move="topright" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/dir-topright.svg">
+          <img class="small-button-direction tmr-move" data-move="topright" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/dir-topright.svg">
-      </div>
+        </div>
-      <div class="flex-group-center flex-shrink">
+        <div class="flex-group-center flex-shrink">
-        <label>Coordonnées : </label><span id="tmr-pos">0</span>
+          <label>Coordonnées : </label><span id="tmr-pos">0</span>
-      </div>
+        </div>
-      <div class="flex-group-center flex-shrink">
+        <div class="flex-group-center flex-shrink">
-        <img class="small-button-direction tmr-move" data-move="bottomleft" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/dir-bottomleft.svg">        
+          <img class="small-button-direction tmr-move" data-move="bottomleft" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/dir-bottomleft.svg">        
-        <img class="small-button-direction tmr-move" data-move="bottom" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/dir-bottom.svg">
+          <img class="small-button-direction tmr-move" data-move="bottom" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/dir-bottom.svg">
-        <img class="small-button-direction tmr-move" data-move="bottomright" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/dir-bottomright.svg">
+          <img class="small-button-direction tmr-move" data-move="bottomright" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/dir-bottomright.svg">
-      </div>
+        </div>
-      <div class="flex-group-center flex-shrink lire-signe-draconique">
+        <div class="flex-group-center flex-shrink lire-signe-draconique">
-        <a>Lire un signe draconique</a>
+          <a>Lire un signe draconique</a>
-      </div>
+        </div>
-      <div class="flex-group-center flex-shrink lancer-sort">
+        <div class="flex-group-center flex-shrink lancer-sort">
-        <a>Lancer un Sort</a>
+          <a>Lancer un Sort</a>
-      </div>
+        </div>
-      <hr>
+        <hr>
-      <div class="flex-group-center flex-shrink">
+        <div class="flex-group-center flex-shrink">
-        <label>Carac. Rêve : </label><label>{{caracReve}}</label>
+          <label>Carac. Rêve : </label><label>{{caracReve}}</label>
-      </div>
+        </div>
-      <div class="flex-group-center flex-shrink">
+        <div class="flex-group-center flex-shrink">
-        <label>Rêve actuel : </label><span id="tmr-pointsreve-value">0</span>
+          <label>Rêve actuel : </label><span id="tmr-pointsreve-value">0</span>
-      </div>
+        </div>
-      <div class="flex-group-center flex-shrink">
+        <div class="flex-group-center flex-shrink">
-        <label>Etat général : </label><span id="tmr-etatgeneral-value">0</span>
+          <label>Etat général : </label><span id="tmr-etatgeneral-value">0</span>
-      </div>
+        </div>
-      <div class="flex-group-center flex-shrink">
+        <div class="flex-group-center flex-shrink">
-        <label>Refoulement : </label><span id="tmr-refoulement-value">0</span>
+          <label>Refoulement : </label><span id="tmr-refoulement-value">0</span>
-      </div>
+        </div>
-      <div class="flex-group-center flex-actions-bar appliquerFatigue">
+        <div class="flex-group-center flex-actions-bar appliquerFatigue">
-        Fatigue 
+          Fatigue 
-        <span id="tmr-fatigue-table">{{{fatigue.html}}}</span>
+          <span id="tmr-fatigue-table">{{{fatigue.html}}}</span>
-      </div>
+        </div>
       {{/if}}
-      <div class="flex-group-center flex-grow">
+      <div class="flex-group-center flex-grow"></div>
-      </div>
     </div>
   </div>
 </form>

templates/dialog-validation-encaissement.html

@@ -15,33 +15,36 @@
         <label class="encaissement-total">{{encaissement.total}}</label>
         <div class="tooltiptext ttt-ajustements">
           <div>Armure: {{encaissement.armure}}</div>
-          {{#if rollData.dmg.penetration}}
+          {{#if encaissement.dmg.penetration}}
-          <div>Pénétration: -{{rollData.dmg.penetration}}</div>
+          <div>Pénétration: -{{encaissement.dmg.penetration}}</div>
           {{/if}}
           <hr>
           {{#if encaissement.dmg.total}}
-          <div>+dom encaissement: {{plusMoins rollData.dmg.total}}</div>
+          <div>+dom encaissement: {{plusMoins encaissement.dmg.total}}</div>
           {{/if}}
-          {{#if rollData.dmg.dmgArme}}
+          {{#if encaissement.dmg.dmgArme}}
-          <div>+dom arme: {{plusMoins rollData.dmg.dmgArme}}</div>
+          <div>+dom arme: {{plusMoins encaissement.dmg.dmgArme}}</div>
           {{/if}}
-          {{#if rollData.dmg.dmgActor}}
+          {{#if encaissement.dmg.dmgActor}}
-          <div>+dom attaquant: {{plusMoins rollData.dmg.dmgActor}}</div>
+          <div>+dom attaquant: {{plusMoins encaissement.dmg.dmgActor}}</div>
           {{/if}}
-          {{#if rollData.dmg.dmgParticuliere}}
+          {{#if encaissement.dmg.dmgParticuliere}}
-          <div>+dom particulière: {{plusMoins rollData.dmg.dmgParticuliere}}</div>
+          <div>+dom particulière: {{plusMoins encaissement.dmg.dmgParticuliere}}</div>
           {{/if}}
-          {{#if rollData.dmg.dmgTactique}}
+          {{#if encaissement.dmg.dmgTactique}}
-          <div>+dom tactique: {{plusMoins rollData.dmg.dmgTactique}}</div>
+          <div>+dom tactique: {{plusMoins encaissement.dmg.dmgTactique}}</div>
           {{/if}}
-          {{#if rollData.dmg.dmgSurprise}}
+          {{#if encaissement.dmg.dmgSurprise}}
-          <div>+dom surprise: {{plusMoins rollData.dmg.dmgSurprise}}</div>
+          <div>+dom surprise: {{plusMoins encaissement.dmg.dmgSurprise}}</div>
+          {{/if}}
+          {{#if encaissement.dmg.bonusDegatsDiffLibre}}
+          <div>+dom attaque: {{plusMoins encaissement.dmg.bonusDegatsDiffLibre}}</div>
           {{/if}}
         </div>
       </span>
     </li>
     <li class="flexrow flex-group-left">
-      <label>Blessure ({{rollData.dmg.mortalite}})</label>
+      <label>Blessure ({{encaissement.dmg.mortalite}})</label>
       <label class="encaissement-blessure">{{encaissement.blessures}}</label>
     </li>
   </ul>

templates/item-arme-sheet.html

@@ -8,7 +8,7 @@
     <div class="tab items flexcol" data-group="primary" data-tab="informations">
       <div class="form-group">
         <label for="system.competence">Compétence de mêlée</label>
-        <select name="system.competence" id="competence" data-dtype="String">
+        <select name="system.competence" data-dtype="String">
           {{#select system.competence}}
           <option value="">- impossible -</option>
           {{>"systems/foundryvtt-reve-de-dragon/templates/enum-competence.html" categorie='melee'}}
@@ -26,7 +26,7 @@
       </div>
       <div class="form-group">
         <label for="system.tir">Compétence de tir</label>
-        <select name="system.tir" id="tir" data-dtype="String">
+        <select name="system.tir" data-dtype="String">
           {{#select system.tir}}
           <option value="">- impossible -</option>
           {{>"systems/foundryvtt-reve-de-dragon/templates/enum-competence.html" categorie='tir'}}
@@ -52,7 +52,7 @@
       </div>
       <div class="form-group">
         <label for="system.categorie_parade">Catégorie parade </label>
-        <select name="system.categorie_parade" id="categorie_parade" data-dtype="String">
+        <select name="system.categorie_parade" data-dtype="String">
           {{#select system.categorie_parade}}
           {{>"systems/foundryvtt-reve-de-dragon/templates/enum-categorie-parade.html"}}
           {{/select}}
@@ -104,7 +104,7 @@
       </div>
       <div class="form-group">
         <label for="system.initpremierround">Classe d'initiative au premier round (mêlée seulement) </label>
-        <select name="system.initpremierround" id="initpremierround" data-dtype="String">
+        <select name="system.initpremierround" data-dtype="String">
           {{#select system.initpremierround}}
           {{>"systems/foundryvtt-reve-de-dragon/templates/enum-initpremierround.html"}}
           {{/select}}

templates/item-casetmr-sheet.html

@@ -7,8 +7,8 @@
       <input class="attribute-value" type="text" name="system.coord" value="{{system.coord}}" data-dtype="String"/>
     </div>
     <div class="form-group">
-      <label for="niveau">Mode spécifique</label>
+      <label for="system.specific">Mode spécifique</label>
-      <select name="system.specific" id="specific" data-dtype="String">
+      <select name="system.specific" data-dtype="String">
         {{#select system.specific}}
         {{>"systems/foundryvtt-reve-de-dragon/templates/enum-tmr-effet.html"}}
         {{/select}}

templates/item-chant-sheet.html

@@ -3,11 +3,11 @@
   {{!-- Sheet Body --}}
   <section class="sheet-body">
     <div class="form-group">
-      <label class="alchimie-title" for="xp">Niveau</label>
+      <label class="item-label" for="system.niveau">Niveau</label>
       <input class="attribute-value" type="text" name="system.niveau" value="{{system.niveau}}" data-dtype="Number"/>
     </div>
     <div class="form-group">
-      <label>Référence / Auteur</label>
+      <label for="system.reference">Référence / Auteur</label>
       <input class="attribute-value" type="text" name="system.reference" value="{{system.reference}}" data-dtype="String"/>
     </div>
 

templates/item-competencecreature-sheet.html

@@ -38,8 +38,8 @@
     {{/if}}
     {{#if isparade}}
       <div class="form-group">
-        <label>Catégorie parade</label>
+        <label for="system.categorie_parade">Catégorie parade</label>
-        <select name="system.categorie_parade" id="categorie_parade" data-dtype="String">
+        <select name="system.categorie_parade" data-dtype="String">
           {{#select system.categorie_parade}}
           {{>"systems/foundryvtt-reve-de-dragon/templates/enum-categorie-parade.html"}}
           {{/select}}

templates/item-conteneur-sheet.html

@@ -9,7 +9,7 @@
   <section class="sheet-body">
     <div class="tab items flexcol" data-group="primary" data-tab="informations">
       <div class="form-group">
-        <label for="xp">Capacite (points d'Enc.)</label>
+        <label for="system.capacite">Capacite (points d'Enc.)</label>
         <input class="attribute-value" type="text" name="system.capacite" value="{{system.capacite}}" data-dtype="Number"/>
       </div>
       {{>"systems/foundryvtt-reve-de-dragon/templates/item/partial-inventaire.html"}}