Fix release

Reviewed-on: public/foundryvtt-reve-de-dragon#679

changelog.md

@@ -1,4 +1,112 @@
 # v11.0
+## v11.1.3 - Werther de Zloth l'Onirique
+- Ajout du facteur de significative à côté du pourcentage dans le résultat des jets de dés pour rappeler que le pourcentage n'est pas diviasé
+- Fix: dans les TMRs, les tooltips affichent bien les informations de tous les effets sur la case
+- Fix: la fatigue et l'éthylisme sont de nouveau pris en compte dans le calcul de l'éthylisme
+- Fix: Le MJ peut correctement masquer les points de tâche requis
+- Fix: le jet d'appréciation n'utilise pas la compétence
+- Fix: la qualité négative n'est pas exotique, elle est juste mauvaise: on n'utilise pas la cuisine pour se retenir de jeter l'assiette
+- Esthétique: ne pas afficher "+0" pour les ajustements de jets/encaissement
+
+## v11.1.2 - Les vertèbres de Werther de Zloth
+- Fix: les jets d'encaissement fonctionnent de nouveau normalement
+- Macro "Mon personnage" permettant au joueur d'accéder à sa feuille de personnage depuis la barre de macros
+
+## v11.1.1 - Les fumebols de Werther de Zloth
+- Fix: on peut de nouveau afficher les vues détaillées
+- Fix: on peut ouvrir les sacs et contenants portés par les véhicules et créatures
+- Fix: cuisiner du gibier prend maintenant bien les proportaions en compte
+
+## v11.1.0 - Les choix de Werther de Zloth
+- Les options suivantes peuvent être désactivées:
+  - La transformation de stress à Château Dormant
+  - La récuperation de chance à Château Dormant
+  - La récupération d'éthylisme
+  - La récupération de rêve (y compris fleurs de rêve et Rêves de Dragon: la rencontre a lieu, mais ne donne pas de rêve)
+  - Le jet de moral de Château Dormant
+- Séparation des véhicules dans leur propre acteur
+- Séparation des entités dans leur propre acteur
+- Séparation des créatures dans leur propre acteur
+- La fenêtre de signes draconiques ne sélectionne plus tout les haut-rêvants par défaut
+- Un nouveau personnage a automatiquement son token relié
+- corrections de bugs
+  - si on n'utilise pas les règles de fatigues, un reflet de rêve pouvait garder le Haut-rêvant dans les TMRs pour toujours
+  - certaines macros ne marchaient pas pour les créatures/entités/véhicules/commerces
+  - en cas de charge, les particulières sont toujours en force (p125)
+
+## v11.0.28 - les fractures de Khrachtchoum
+- La gravité de la blessure est affichée dans le résumé de l'encaissement
+- Lors du changement d'acteur pendant le round
+  - le message annonçant le joueur dont c'est le tour ne contient plus d'informations de santé
+  - un message avec les informations de santé est envoyé au Gardienn et au propriétaire du token.acteur
+  - le jet de vie est bien fait par le token si besoin
+  - seul les propriétaires peuvent faire les jets de vie 
+- Amélioration de la fenêtre de jets
+  - le type de dégâts pour les attaques est toujours affiché
+  - le moral est indiqué avant l'icone d'appel au moral
+
+## v11.0.27 - Khrachtchoum le méticuleux
+- le tooltip dans les TMR reste visible si on ne bouge pas la souris
+- le surencombrement n'affecte QUE les actions physiques
+- on peut de nouveau fabriquer une potion depuis la fenêtre d'édition de l'herbe
+- si les TMR sont minimisées alors qu'une action est requise, elles sont bien réaffichées lorsque l'action est faite
+
+## v11.0.26 - le crépuscule de Khrachtchoum
+- gestion correcte des TMRs
+  - les TMRs ne sont jamais minimisées (par le système) quand le haut-rêvant est en demi-rêve
+  - lorsqu'une fenêtre liée aux demi-rêve est affichée, cliquer sur les TMRs n'a pas d'effet
+  - les lancers de sorts et lectures de signes sont affichées en premier plan
+  - Les effets qui ouvrent une fenêtre sont bien affichés en premier plan
+  - en cas de rencontre suivie de maîtrises/conquêtes, les fenêtres s'enchaînent
+- Le drag&drop vers la barre de macro est corrigé
+  - pour les créatures, possibilités d'avoir les attaques ou autres compétences
+  - pour les personnages, les macros sont créées:
+    - pour les compétences
+    - pour le corps à corps, trois macros sont créées: compétence, pugilat, empoignade
+    - pour les armes
+      - deux macros sont créées pour les armes à 1/2 mains
+      - deux macros sont créées pour les armes de mélée et lancer
+      - 4 macros si votre arbalête se lance, tire, et se manie à 1 ou 2 mains...
+- les jets de compétences d'attaque des créatures fonctionnent de nouveau
+
+## v11.0.25 - la vision du rêve de Khrachtchoum
+- Les TMRs restent affichées tant que le Haut-rêvant est en demi-rêve
+
+## v11.0.24 - les couleurs de Khrachtchoum
+- nouvelle carte des TMRs
+
+## v11.0.23 - la lumière de Khrachtchoum
+- ajustement automatique de la luminosité selon l'heure pour les scènes:
+   - avec une vision des tokens (sinon: ce n'est pas une scène de carte pour tokens)
+   - avec illumination globale (correspondant à une illumination extérieure)
+   - quand lampe "allumée" dans la fenêtre du calendrier
+
+## v11.0.22 - les automatismes de Khrachtchoum le Problémeux
+- Macro pour attaquer avec les compétences de créatures
+
+## v11.0.20
+- Macro pour attaquer avec les armes des personnages
+
+## v11.0.17
+- Fix: les actions de commerce ne s'appliquait pas bien aux personnages des tokens non liés
+
+## v11.0.15 - L'apprentissage de Khrachtchoum
+- Fix: l'expérience ne s'appliquait plus sur certaines réussites particulières (régression depuis la 11.0.7)
+
+## v11.0.14 - Les pincettes de Khrachtchoum le Problémeux
+- Correction du calcul de la place restante lors de l'ajout dans un conteneur
+
+## v11.0.13 - La multiplication de l'eau de Khrachtchoum le Problémeux
+- Correction de la vente depuis un commerce ayant des quantités illimitées
+
+## v11.0.12 - Les poids de la mesure de Khrachtchoum le Problémeux
+- Correction des malus de surencombrement
+- Le malus armure est correctement affiché dans l'onglet des caractéristiques
+- Correction d'orthographe et amélioration des messages des oeuvres d'art
+
+## v11.0.11 - Les bleus de Khrachtchoum le Problémeux
+- si le gardien configure le sommeil, les joueurs sont notifiés que chateau dormant vient de passer
+- possibilité de créer des armes et des compétences de créatures non-mortelles.
 
 ## v11.0.10 - Les Songes de Khrachtchoum le Problémeux
 - on peut de nouveau se déplacer dans les TMRs d'un clic sur la case à atteindre

module/actor-sheet.js

@@ -11,29 +11,25 @@ import { ReglesOptionnelles } from "./settings/regles-optionnelles.js";
 import { RdDSheetUtility } from "./rdd-sheet-utility.js";
 import { STATUSES } from "./settings/status-effects.js";
 import { MAINS_DIRECTRICES } from "./actor.js";
-import { RdDBaseActorSheet } from "./actor/base-actor-sheet.js";
+import { RdDBaseActorReveSheet } from "./actor/base-actor-reve-sheet.js";
 import { RdDItem } from "./item.js";
 import { RdDItemBlessure } from "./item/blessure.js";
 import { RdDEmpoignade } from "./rdd-empoignade.js";
+import { ChatUtility } from "./chat-utility.js";
 
 /* -------------------------------------------- */
 /**
  * Extend the basic ActorSheet with some very simple modifications
  * @extends {ActorSheet}
  */
-export class RdDActorSheet extends RdDBaseActorSheet {
+export class RdDActorSheet extends RdDBaseActorReveSheet {
 
   /** @override */
   static get defaultOptions() {
-    RdDUtility.initAfficheContenu();
-    return mergeObject(super.defaultOptions, {
-      classes: ["rdd", "sheet", "actor"],
+    return mergeObject(RdDBaseActorReveSheet.defaultOptions, {
       template: "systems/foundryvtt-reve-de-dragon/templates/actor-sheet.html",
       width: 550,
-      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "carac" }],
-      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: undefined }],
       showCompNiveauBase: false,
-      vueDetaillee: false,
       vueArchetype: false,
     });
   }
@@ -56,7 +52,8 @@ export class RdDActorSheet extends RdDBaseActorSheet {
       surprise: RdDBonus.find(this.actor.getSurprise(false)).descr,
       resumeBlessures: this.actor.computeResumeBlessure(this.actor.system.blessures),
       caracTotal: RdDCarac.computeTotal(this.actor.system.carac, this.actor.system.beaute),
-      surEncombrementMessage: this.actor.getMessageSurEncombrement(),
+      surEncombrementMessage: this.actor.isSurenc() ? "Sur-Encombrement!" : "",
+      malusArmure: this.actor.getMalusArmure()
     })
 
     this.timerRecherche = undefined;
@@ -80,9 +77,12 @@ export class RdDActorSheet extends RdDBaseActorSheet {
       });
 
       // toujours avoir une liste d'armes (pour mettre esquive et corps à corps)
-      formData.combat = duplicate(formData.armes ?? []);
+      const actor = this.actor;
+      formData.combat = duplicate(formData.armes);
       RdDItemArme.computeNiveauArmes(formData.combat, formData.competences);
-      RdDItemArme.ajoutCorpsACorps(formData.combat, formData.competences, formData.system.carac);
+      formData.combat.push(RdDItemArme.mainsNues(actor));
+      formData.combat.push(RdDItemArme.empoignade(actor));
+
       formData.esquives = this.actor.getCompetences("Esquive");
       formData.combat = RdDCombatManager.listActionsArmes(formData.combat, formData.competences, formData.system.carac);
       formData.empoignades = this.actor.getEmpoignades();
@@ -111,7 +111,8 @@ export class RdDActorSheet extends RdDBaseActorSheet {
     return formData;
   }
 
-  /* -------------------------------------------- */  /** @override */
+  /* -------------------------------------------- */
+  /** @override */
   activateListeners(html) {
     super.activateListeners(html);
 
@@ -120,11 +121,18 @@ export class RdDActorSheet extends RdDBaseActorSheet {
     // Everything below here is only needed if the sheet is editable
     if (!this.options.editable) return;
 
-    this.html.find('.item-action').click(async event => {
-      const item = RdDSheetUtility.getItem(event, this.actor);
-      item?.actionPrincipale(this.actor, async () => this.render())
-    });
+    this.html.find('.sheet-possession-attack').click(async event => {
+      const poss = RdDSheetUtility.getItem(event, this.actor)
+      this.actor.conjurerPossession(poss)
+    })
 
+    this.html.find('.subacteur-label a').click(async event => {
+      let actorId = RdDSheetUtility.getEventItemData(event, 'actor-id');
+      let actor = game.actors.get(actorId);
+      if (actor) {
+        actor.sheet.render(true);
+      }
+    });
     this.html.find('.subacteur-delete').click(async event => {
       const li = RdDSheetUtility.getEventElement(event);
       const actorId = li.data("actor-id");
@@ -154,18 +162,6 @@ export class RdDActorSheet extends RdDBaseActorSheet {
       this.actor.updateCompteurValue("experience", parseInt(event.target.value));
     });
 
-    this.html.find('.encaisser-direct').click(async event => {
-      this.actor.encaisser();
-    })
-    this.html.find('.sheet-possession-attack').click(async event => {
-      const poss = RdDSheetUtility.getItem(event, this.actor)
-      this.actor.conjurerPossession(poss)
-    })
-    this.html.find('.remise-a-neuf').click(async event => {
-      if (game.user.isGM) {
-        this.actor.remiseANeuf();
-      }
-    });
     this.html.find('.creer-tache').click(async event => {
       this.createEmptyTache();
     });
@@ -175,9 +171,7 @@ export class RdDActorSheet extends RdDBaseActorSheet {
     this.html.find('.creer-blessure-legere').click(async event => RdDItemBlessure.createBlessure(this.actor, 2));
     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('.creer-une-oeuvre').click(async event => {
-      this.selectTypeOeuvreToCreate();
-    });
+    this.html.find('.creer-une-oeuvre').click(async event => this.selectTypeOeuvreToCreate());
 
     this.html.find('.blessure-premierssoins-done').change(async event => {
       const blessure = this.getBlessure(event);
@@ -202,11 +196,6 @@ export class RdDActorSheet extends RdDBaseActorSheet {
     });
 
     // Roll Carac
-    this.html.find('.carac-label a').click(async event => {
-      let caracName = event.currentTarget.attributes.name.value;
-      this.actor.rollCarac(caracName.toLowerCase());
-    });
-
     this.html.find('.chance-actuelle').click(async event => {
       this.actor.rollCarac('chance-actuelle');
     });
@@ -215,14 +204,10 @@ export class RdDActorSheet extends RdDBaseActorSheet {
       this.actor.rollAppelChance();
     });
 
+    // Roll Skill
     this.html.find('[name="jet-astrologie"]').click(async event => {
       this.actor.astrologieNombresAstraux();
     });
-
-    // Roll Skill
-    this.html.find('a.competence-label').click(async event => {
-      this.actor.rollCompetence(RdDSheetUtility.getItemId(event));
-    });
     this.html.find('.tache-label a').click(async event => {
       this.actor.rollTache(RdDSheetUtility.getItemId(event));
     });
@@ -247,13 +232,6 @@ export class RdDActorSheet extends RdDBaseActorSheet {
     this.html.find('.recettecuisine-label a').click(async event => {
       this.actor.rollRecetteCuisine(RdDSheetUtility.getItemId(event));
     });
-    this.html.find('.subacteur-label a').click(async event => {
-      let actorId = RdDSheetUtility.getEventItemData(event, 'actor-id');
-      let actor = game.actors.get(actorId);
-      if (actor) {
-        actor.sheet.render(true);
-      }
-    });
 
     // Boutons spéciaux MJs
     this.html.find('.forcer-tmr-aleatoire').click(async event => {
@@ -288,35 +266,12 @@ export class RdDActorSheet extends RdDBaseActorSheet {
         ui.notifications.info("Impossible de lancer l'initiative sans être dans un combat.");
       }
     });
-    // Display TMR, visualisation
-    this.html.find('.visu-tmr').click(async event => {
-      this.actor.displayTMR("visu");
-    });
+    // Display TMR
+    this.html.find('.visu-tmr').click(async event => { this.actor.displayTMR("visu") })
+    this.html.find('.monte-tmr').click(async event => { this.actor.displayTMR("normal") })
+    this.html.find('.monte-tmr-rapide').click(async event => { this.actor.displayTMR("rapide") })
 
-    // Display TMR, normal
-    this.html.find('.monte-tmr').click(async event => {
-      this.actor.displayTMR("normal");
-    });
-
-    // Display TMR, fast 
-    this.html.find('.monte-tmr-rapide').click(async event => {
-      this.actor.displayTMR("rapide");
-    });
-
-    this.html.find('.repos').click(async event => {
-      await this.actor.repos();
-    });
-    this.html.find('.delete-active-effect').click(async event => {
-      if (game.user.isGM) {
-        let effect = this.html.find(event.currentTarget).parents(".active-effect").data('effect');
-        this.actor.removeEffect(effect);
-      }
-    });
-    this.html.find('.enlever-tous-effets').click(async event => {
-      if (game.user.isGM) {
-        await this.actor.removeEffects();
-      }
-    });
+    this.html.find('.repos').click(async event => { await this.actor.repos() })
     this.html.find('.carac-xp-augmenter').click(async event => {
       let caracName = event.currentTarget.name.replace("augmenter.", "");
       this.actor.updateCaracXPAuto(caracName);
@@ -330,30 +285,20 @@ export class RdDActorSheet extends RdDBaseActorSheet {
 
     if (this.options.vueDetaillee) {
       // On carac change
-      this.html.find('.carac-value').change(async event => {
-        let caracName = event.currentTarget.name.replace(".value", "").replace("system.carac.", "");
-        this.actor.updateCarac(caracName, parseInt(event.target.value));
-      });
       this.html.find('input.carac-xp').change(async event => {
         let caracName = event.currentTarget.name.replace(".xp", "").replace("system.carac.", "");
         this.actor.updateCaracXP(caracName, parseInt(event.target.value));
       });
-      // On competence change
-      this.html.find('.competence-value').change(async event => {
-        let compName = event.currentTarget.attributes.compname.value;
-        //console.log("Competence changed :", compName);
-        this.actor.updateCompetence(compName, parseInt(event.target.value));
-      });
       // On competence xp change
       this.html.find('input.competence-xp').change(async event => {
         let compName = event.currentTarget.attributes.compname.value;
         this.actor.updateCompetenceXP(compName, parseInt(event.target.value));
       });
-      // On competence xp change
       this.html.find('input.competence-xp-sort').change(async event => {
         let compName = event.currentTarget.attributes.compname.value;
         this.actor.updateCompetenceXPSort(compName, parseInt(event.target.value));
       });
+
       this.html.find('.toggle-archetype').click(async event => {
         this.options.vueArchetype = !this.options.vueArchetype;
         this.render(true);
@@ -373,11 +318,6 @@ export class RdDActorSheet extends RdDBaseActorSheet {
       this.render(true);
     });
 
-    this.html.find('.vue-detaillee').click(async event => {
-      this.options.vueDetaillee = !this.options.vueDetaillee;
-      this.render(true);
-    });
-
     // On pts de reve change
     this.html.find('.pointsreve-value').change(async event => {
       let reveValue = event.currentTarget.value;
@@ -390,11 +330,6 @@ export class RdDActorSheet extends RdDBaseActorSheet {
       this.actor.setPointsDeSeuil(event.currentTarget.value);
     });
 
-    // On stress change
-    this.html.find('.compteur-edit').change(async event => {
-      let fieldName = event.currentTarget.attributes.name.value;
-      this.actor.updateCompteurValue(fieldName, parseInt(event.target.value));
-    });
 
     this.html.find('.stress-test').click(async event => {
       this.actor.transformerStress();
@@ -416,7 +351,7 @@ export class RdDActorSheet extends RdDBaseActorSheet {
       this.actor.jetVie();
     });
     this.html.find('.jet-endurance').click(async event => {
-      this.actor.jetEndurance();
+      await this.jetEndurance();
     });
 
     this.html.find('.vie-plus').click(async event => {
@@ -425,12 +360,6 @@ export class RdDActorSheet extends RdDBaseActorSheet {
     this.html.find('.vie-moins').click(async event => {
       this.actor.santeIncDec("vie", -1);
     });
-    this.html.find('.endurance-plus').click(async event => {
-      this.actor.santeIncDec("endurance", 1);
-    });
-    this.html.find('.endurance-moins').click(async event => {
-      this.actor.santeIncDec("endurance", -1);
-    });
     this.html.find('.ptreve-actuel-plus').click(async event => {
       this.actor.reveActuelIncDec(1);
     });
@@ -445,6 +374,16 @@ export class RdDActorSheet extends RdDBaseActorSheet {
     });
   }
 
+  async jetEndurance() {
+    const endurance = this.actor.getEnduranceActuelle()
+    const result = await this.actor.jetEndurance(endurance);
+    ChatMessage.create({
+      content: `Jet d'Endurance : ${result.jetEndurance} / ${endurance}
+        <br>${this.actor.name} a ${result.sonne ? 'échoué' : 'réussi'} son Jet d'Endurance ${result.sonne ? 'et devient Sonné' : ''}`,
+      whisper: ChatUtility.getWhisperRecipientsAndGMs(this.actor.name)
+    });
+  }
+
   getBlessure(event) {
     const itemId = this.html.find(event.currentTarget).parents(".item-blessure").data('item-id');
     const blessure = this.actor.getItem(itemId, 'blessure');

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

@@ -0,0 +1,64 @@
+import { RdDSheetUtility } from "../rdd-sheet-utility.js";
+import { RdDBaseActorSheet } from "./base-actor-sheet.js";
+
+/* -------------------------------------------- */
+/**
+ * Extend the basic ActorSheet with some very simple modifications
+ * @extends {ActorSheet}
+ */
+export class RdDBaseActorReveSheet extends RdDBaseActorSheet {
+
+  /** @override */
+  static get defaultOptions() {
+    return mergeObject(RdDBaseActorSheet.defaultOptions, {
+      width: 550
+    });
+  }
+
+  /* -------------------------------------------- */
+  /** @override */
+  activateListeners(html) {
+    super.activateListeners(html);
+
+    // Everything below here is only needed if the sheet is editable
+    if (!this.options.editable) return;
+
+    this.html.find('.encaisser-direct').click(async event => {
+      this.actor.encaisser();
+    })
+    this.html.find('.remise-a-neuf').click(async event => {
+      if (game.user.isGM) {
+        this.actor.remiseANeuf();
+      }
+    });
+
+    this.html.find('.carac-label a').click(async event => {
+      let caracName = event.currentTarget.attributes.name.value;
+      this.actor.rollCarac(caracName.toLowerCase());
+    });
+
+    this.html.find('a.competence-label').click(async event => {
+      this.actor.rollCompetence(RdDSheetUtility.getItemId(event));
+    });
+
+    this.html.find('.delete-active-effect').click(async event => {
+      if (game.user.isGM) {
+        let effect = this.html.find(event.currentTarget).parents(".active-effect").data('effect');
+        this.actor.removeEffect(effect);
+      }
+    });
+    this.html.find('.enlever-tous-effets').click(async event => {
+      if (game.user.isGM) {
+        await this.actor.removeEffects();
+      }
+    });
+
+    this.html.find('.endurance-plus').click(async event => {
+      this.actor.santeIncDec("endurance", 1);
+    });
+    this.html.find('.endurance-moins').click(async event => {
+      this.actor.santeIncDec("endurance", -1);
+    });
+  }
+
+}

module/actor/base-actor-reve.js

@@ -0,0 +1,509 @@
+import { ChatUtility } from "../chat-utility.js";
+import { DialogValidationEncaissement } from "../dialog-validation-encaissement.js";
+import { Grammar } from "../grammar.js";
+import { RdDItemCompetence } from "../item-competence.js";
+import { Misc } from "../misc.js";
+import { RdDEmpoignade } from "../rdd-empoignade.js";
+import { RdDResolutionTable } from "../rdd-resolution-table.js";
+import { RdDEncaisser } from "../rdd-roll-encaisser.js";
+import { RdDRoll } from "../rdd-roll.js";
+import { RdDUtility } from "../rdd-utility.js";
+import { ReglesOptionnelles } from "../settings/regles-optionnelles.js";
+import { RdDBaseActor } from "./base-actor.js";
+import { RdDItemCompetenceCreature } from "../item-competencecreature.js";
+import { StatusEffects } from "../settings/status-effects.js";
+import { TYPES } from "../item.js";
+import { Targets } from "../targets.js";
+import { RdDPossession } from "../rdd-possession.js";
+import { RdDCombat } from "../rdd-combat.js";
+import { RdDConfirm } from "../rdd-confirm.js";
+import { ENTITE_INCARNE, SHOW_DICE, SYSTEM_RDD } from "../constants.js";
+import { RdDItemArme } from "../item-arme.js";
+
+const POSSESSION_SANS_DRACONIC = {
+  img: 'systems/foundryvtt-reve-de-dragon/icons/entites/possession.webp',
+  name: 'Sans draconic',
+  system: {
+    niveau: 0,
+    defaut_carac: "reve-actuel",
+  }
+};
+
+/**
+ * Classe de base pour les acteurs disposant de rêve (donc, pas des objets)
+ * - Entités de rêve
+ * - Créatures de "sang": créatures et humanoides
+ */
+export class RdDBaseActorReve extends RdDBaseActor {
+
+  getCaracChanceActuelle() {
+    return {
+      label: 'Chance actuelle',
+      value: this.getChanceActuel(),
+      type: "number"
+    };
+  }
+
+  getCaracReveActuel() {
+    return {
+      label: 'Rêve actuel',
+      value: this.getReveActuel(),
+      type: "number"
+    };
+  }
+
+  getReveActuel() { return this.getReve() }
+  getChanceActuel() { return this.getChance() }
+
+  getReve() { return Number(this.system.carac.reve?.value ?? 0) }
+  getForce() { return this.getReve() }
+  getTaille() { return Number(this.system.carac.taille?.value ?? 0) }
+  getAgilite() { return this.getForce() }
+  getChance() { return this.getReve() }
+  getMoralTotal() { return 0 }
+  getBonusDegat() { return Number(this.system.attributs?.plusdom?.value ?? 0) }
+  getProtectionNaturelle() { return Number(this.system.attributs?.protection?.value ?? 0) }
+  getSConst() { return 0 }
+
+  /* -------------------------------------------- */
+  getEncombrementMax() { return 0 }
+  isSurenc() { return false }
+  computeMalusSurEncombrement() { return 0 }
+
+  ajustementAstrologique() { return 0 }
+  getMalusArmure() { return 0 }
+
+  getEnduranceActuelle() {
+    return Number(this.system.sante?.endurance?.value ?? 0);
+  }
+  async jetEndurance(resteEndurance = undefined) { return { jetEndurance: 0, sonne: false } }
+  isDead() { return false }
+  blessuresASoigner() { return [] }
+  getEtatGeneral(options = { ethylisme: false }) { return 0 }
+
+  async computeArmure(attackerRoll) { return this.getProtectionNaturelle() }
+  async remiseANeuf() { }
+  async appliquerAjoutExperience(rollData, hideChatMessage = 'show') { }
+
+  async santeIncDec(name, inc, isCritique = false) { }
+
+  async finDeRound(options = { terminer: false }) {
+    await this.$finDeRoundSuppressionEffetsTermines(options);
+    await this.finDeRoundBlessures();
+    await this.$finDeRoundSupprimerObsoletes();
+    await this.$finDeRoundEmpoignade();
+  }
+
+  async $finDeRoundSuppressionEffetsTermines(options) {
+    for (let effect of this.getEffects()) {
+      if (effect.duration.type !== 'none' && (effect.duration.remaining <= 0 || options.terminer)) {
+        await effect.delete();
+        ChatMessage.create({ content: `${this.name} n'est plus ${Misc.lowerFirst(game.i18n.localize(effect.system.label))} !` });
+      }
+    }
+  }
+
+  async finDeRoundBlessures() {
+  }
+
+  async $finDeRoundSupprimerObsoletes() {
+    const obsoletes = []
+      .concat(this.itemTypes[TYPES.empoignade].filter(it => it.system.pointsemp <= 0))
+      .concat(this.itemTypes[TYPES.possession].filter(it => it.system.compteur < -2 || it.system.compteur > 2))
+      .map(it => it.id);
+    await this.deleteEmbeddedDocuments('Item', obsoletes);
+  }
+
+  async $finDeRoundEmpoignade() {
+    const immobilisations = this.itemTypes[TYPES.empoignade].filter(it => it.system.pointsemp >= 2 && it.system.empoigneurid == this.id);
+    immobilisations.forEach(emp => RdDEmpoignade.onImmobilisation(this,
+      game.actors.get(emp.system.empoigneid),
+      emp
+    ))
+  }
+
+  async setSonne(sonne = true) { }
+
+  /* -------------------------------------------- */
+  getCompetence(idOrName, options = {}) {
+    if (idOrName instanceof Item) {
+      return idOrName.isCompetence() ? idOrName : undefined
+    }
+    return RdDItemCompetence.findCompetence(this.items, idOrName, options)
+  }
+  getCompetences(name) {
+    return RdDItemCompetence.findCompetences(this.items, name)
+  }
+  getCompetenceCorpsACorps(options = {}) {
+    return this.getCompetence("Corps à corps", options)
+  }
+  getCompetencesEsquive() {
+    return this.getCompetences("esquive")
+  }
+
+  getArmeParade(armeParadeId) {
+    const item = armeParadeId ? this.getEmbeddedDocument('Item', armeParadeId) : undefined;
+    return RdDItemArme.getArme(item);
+  }
+
+  getDraconicOuPossession() {
+    return POSSESSION_SANS_DRACONIC
+  }
+
+  getPossession(possessionId) {
+    return this.itemTypes[TYPES.possession].find(it => it.system.possessionid == possessionId);
+  }
+  getPossessions() {
+    return this.itemTypes[TYPES.possession];
+  }
+  getEmpoignades() {
+    return this.itemTypes[TYPES.empoignade];
+  }
+
+  /* -------------------------------------------- */
+  async updateCreatureCompetence(idOrName, fieldName, value) {
+    let competence = this.getCompetence(idOrName);
+    if (competence) {
+      function getFieldPath(fieldName) {
+        switch (fieldName) {
+          case "niveau": return 'system.niveau';
+          case "dommages": return 'system.dommages';
+          case "carac_value": return 'system.carac_value';
+        }
+        return undefined
+      }
+      const path = getFieldPath(fieldName);
+      if (path) {
+        await this.updateEmbeddedDocuments('Item', [{ _id: competence.id, [path]: value }]); // updates one EmbeddedEntity
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  isEffectAllowed(statusId) { return true }
+
+  getEffects(filter = e => true) {
+    return this.getEmbeddedCollection("ActiveEffect").filter(filter);
+  }
+
+  getEffect(statusId) {
+    return this.getEmbeddedCollection("ActiveEffect").find(it => it.flags?.core?.statusId == statusId);
+  }
+
+  async setEffect(statusId, status) {
+    if (this.isEffectAllowed(statusId)) {
+      const effect = this.getEffect(statusId);
+      if (!status && effect) {
+        await this.deleteEmbeddedDocuments('ActiveEffect', [effect.id]);
+      }
+      if (status && !effect) {
+        await this.createEmbeddedDocuments("ActiveEffect", [StatusEffects.status(statusId)]);
+      }
+    }
+  }
+
+  async removeEffect(statusId) {
+    const effect = this.getEffect(statusId);
+    if (effect) {
+      await this.deleteEmbeddedDocuments('ActiveEffect', [effect.id]);
+    }
+  }
+
+  async removeEffects(filter = e => true) {
+    if (game.user.isGM) {
+      const ids = this.getEffects(filter).map(it => it.id);
+      await this.deleteEmbeddedDocuments('ActiveEffect', ids);
+    }
+  }
+
+  /* -------------------------------------------- */
+  getSurprise(isCombat = undefined) {
+    let niveauSurprise = this.getEffects()
+      .map(effect => StatusEffects.valeurSurprise(effect, isCombat))
+      .reduce(Misc.sum(), 0);
+    if (niveauSurprise > 1) {
+      return 'totale';
+    }
+    if (niveauSurprise == 1) {
+      return 'demi';
+    }
+    return '';
+  }
+
+  /* -------------------------------------------- */
+  async computeEtatGeneral() {
+    // Par défaut, on ne calcule pas d'état général, seuls les personnages/créatures sont affectés
+    this.system.compteurs.etat.value = 0;
+  }
+
+  /* -------------------------------------------- */
+  async openRollDialog({ name, label, template, rollData, callbackAction }) {
+    const dialog = await RdDRoll.create(this, rollData,
+      { html: template, close: async html => await this._onCloseRollDialog(html) },
+      {
+        name: name,
+        label: label,
+        callbacks: [
+          this.createCallbackExperience(),
+          this.createCallbackAppelAuMoral(),
+          { action: callbackAction }
+        ]
+      });
+    dialog.render(true);
+    return dialog
+  }
+
+  createEmptyCallback() {
+    return {
+      condition: r => false,
+      action: r => { }
+    };
+  }
+  createCallbackExperience() { return this.createEmptyCallback(); }
+  createCallbackAppelAuMoral() { return this.createEmptyCallback(); }
+  async _onCloseRollDialog(html) { }
+
+  /* -------------------------------------------- */
+  async roll() {
+    RdDEmpoignade.checkEmpoignadeEnCours(this)
+
+    const carac = this.getCarac()
+    const selectedCaracName = ['apparence', 'perception', 'force', 'reve'].find(it => carac[it] != undefined)
+
+    await this.openRollDialog({
+      name: `jet-${this.id}`,
+      label: `Jet de ${this.name}`,
+      template: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll.html',
+      rollData: {
+        carac: carac,
+        selectedCarac: carac[selectedCaracName],
+        selectedCaracName: selectedCaracName,
+        competences: this.itemTypes['competence']
+      },
+      callbackAction: r => this.$onRollCaracResult(r)
+    });
+  }
+
+  getCarac() {
+    // TODO: le niveau d'une entité de cauchemar devrait être exclu...
+    const carac = mergeObject(duplicate(this.system.carac),
+    {
+      'reve-actuel': this.getCaracReveActuel(),
+      'chance-actuelle': this.getCaracChanceActuelle()
+    });
+    return carac;
+  }
+
+  /* -------------------------------------------- */
+  async rollCarac(caracName, jetResistance = undefined) {
+    RdDEmpoignade.checkEmpoignadeEnCours(this)
+    let selectedCarac = this.getCaracByName(caracName)
+    await this.openRollDialog({
+      name: 'jet-' + caracName,
+      label: 'Jet ' + Grammar.apostrophe('de', selectedCarac.label),
+      template: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-carac.html',
+      rollData: {
+        selectedCarac: selectedCarac,
+        competences: this.itemTypes['competence'],
+        jetResistance: jetResistance ? caracName : undefined
+      },
+      callbackAction: r => this.$onRollCaracResult(r)
+    });
+  }
+
+  /* -------------------------------------------- */
+  async $onRollCaracResult(rollData) {
+    // Final chat message
+    await RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-general.html');
+  }
+
+  /* -------------------------------------------- */
+  async rollCompetence(idOrName, options = { tryTarget: true }) {
+    RdDEmpoignade.checkEmpoignadeEnCours(this)
+    const competence = this.getCompetence(idOrName);
+    let rollData = { carac: this.system.carac, competence: competence }
+    if (competence.type == TYPES.competencecreature) {
+      const arme = RdDItemCompetenceCreature.armeCreature(competence)
+      if (arme && options.tryTarget && Targets.hasTargets()) {
+        Targets.selectOneToken(target => {
+          if (arme.action == "possession") {
+            RdDPossession.onAttaquePossession(target, this, competence)
+          }
+          else {
+            RdDCombat.rddCombatTarget(target, this).attaque(competence, arme)
+          }
+        });
+        return;
+      }
+      // Transformer la competence de créature
+      RdDItemCompetenceCreature.setRollDataCreature(rollData)
+    }
+
+    await this.openRollDialog({
+      name: 'jet-competence',
+      label: 'Jet ' + Grammar.apostrophe('de', competence.name),
+      template: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-competence.html',
+      rollData: rollData,
+      callbackAction: r => this.$onRollCompetence(r, options)
+    });
+  }
+
+  async $onRollCompetence(rollData, options) {
+    await RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-competence.html')
+    if (options?.onRollAutomate) {
+      options.onRollAutomate(rollData);
+    }
+  }
+
+  /** --------------------------------------------
+   * @param {*} arme item d'arme/compétence de créature
+   * @param {*} categorieArme catégorie d'attaque à utiliser: competence (== melee), lancer, tir; naturelle, possession
+   * @returns 
+   */
+  rollArme(arme, categorieArme = "competence") {
+    let compToUse = this.$getCompetenceArme(arme, categorieArme)
+    if (!Targets.hasTargets()) {
+      RdDConfirm.confirmer({
+        settingConfirmer: "confirmer-combat-sans-cible",
+        content: `<p>Voulez vous faire un jet de ${compToUse} sans choisir de cible valide?
+                  <br>Tous les jets de combats devront être gérés à la main
+                  </p>`,
+        title: 'Ne pas utiliser les automatisation de combat',
+        buttonLabel: "Pas d'automatisation",
+        onAction: async () => {
+          this.rollCompetence(compToUse, { tryTarget: false })
+        }
+      });
+      return;
+    }
+
+    Targets.selectOneToken(target => {
+      if (Targets.isTargetEntite(target)) {
+        ui.notifications.warn(`Vous ne pouvez pas attaquer une entité non incarnée avec votre ${arme.name}!!!!`);
+        return;
+      }
+
+      const competence = this.getCompetence(compToUse)
+      //console.log("RollArme", competence, arme)
+      if (competence.isCompetencePossession()) {
+        return RdDPossession.onAttaquePossession(target, this, competence);
+      }
+      RdDCombat.rddCombatTarget(target, this).attaque(competence, arme);
+    })
+  }
+
+  $getCompetenceArme(arme, competenceName) {
+    switch (arme.type) {
+      case TYPES.competencecreature:
+        return arme.name
+      case TYPES.arme:
+        switch (competenceName) {
+          case 'competence': return arme.system.competence;
+          case 'unemain': return RdDItemArme.competence1Mains(arme);
+          case 'deuxmains': return RdDItemArme.competence2Mains(arme);
+          case 'tir': return arme.system.tir;
+          case 'lancer': return arme.system.lancer;
+        }
+    }
+    return undefined
+  }
+
+  verifierForceMin(item) {
+  }
+  /* -------------------------------------------- */
+  async resetItemUse() { }
+  async incDecItemUse(itemId, inc = 1) { }
+  getItemUse(itemId) { return 0; }
+
+  /* -------------------------------------------- */
+  async encaisser() { await RdDEncaisser.encaisser(this) }
+
+  async encaisserDommages(rollData, attacker = undefined, show = undefined) {
+    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: 'appliquerEncaissement',
+        args: [rollData, show, attackerId]
+      });
+      return;
+    }
+
+    const armure = await this.computeArmure(rollData);
+    if (ReglesOptionnelles.isUsing('validation-encaissement-gr')) {
+      DialogValidationEncaissement.validerEncaissement(this, rollData, armure,
+        jet => this.$onEncaissement(jet, show, attacker));
+    }
+    else {
+      const jet = await RdDUtility.jetEncaissement(rollData, armure, { showDice: SHOW_DICE });
+      await this.$onEncaissement(jet, show, attacker);
+    }
+  }
+
+  async $onEncaissement(jet, show, attacker) {
+    await this.onAppliquerJetEncaissement(jet, attacker);
+    await this.$afficherEncaissement(jet, show);
+  }
+
+  async onAppliquerJetEncaissement(encaissement, attacker) { }
+
+  async $afficherEncaissement(encaissement, show) {
+    mergeObject(encaissement, {
+      alias: this.name,
+      hasPlayerOwner: this.hasPlayerOwner,
+      show: show ?? {}
+    });
+
+    await ChatUtility.createChatWithRollMode(this.name, {
+      roll: encaissement.roll,
+      content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-resultat-encaissement.html', encaissement)
+    });
+
+    if (!encaissement.hasPlayerOwner && encaissement.endurance != 0) {
+      encaissement = duplicate(encaissement);
+      encaissement.isGM = true;
+      ChatMessage.create({
+        whisper: ChatMessage.getWhisperRecipients("GM"),
+        content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-resultat-encaissement.html', encaissement)
+      });
+    }
+  }
+
+  /* -------------------------------------------- */
+  async accorder(entite, when = 'avant-encaissement') {
+    if (when != game.settings.get(SYSTEM_RDD, "accorder-entite-cauchemar")
+      || entite == undefined
+      || !entite.isEntite([ENTITE_INCARNE])
+      || entite.isEntiteAccordee(this)) {
+      return true;
+    }
+    const rolled = await RdDResolutionTable.roll(this.getReveActuel(), - Number(entite.system.carac.niveau.value));
+    const rollData = {
+      alias: this.name,
+      rolled: rolled,
+      entite: entite.name,
+      selectedCarac: this.system.carac.reve
+    };
+
+    if (rolled.isSuccess) {
+      await entite.setEntiteReveAccordee(this);
+    }
+
+    await RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-accorder-cauchemar.html');
+    if (rolled.isPart) {
+      await this.appliquerAjoutExperience(rollData, true);
+    }
+    return rolled.isSuccess;
+  }
+
+  isEntiteAccordee(attacker) { return true }
+
+  async setEntiteReveAccordee(attacker) {
+    ui.notifications.error("Impossible de s'accorder à " + this.name + ": ce n'est pas une entite de cauchemer/rêve");
+  }
+
+}

module/actor/base-actor-sang.js

@@ -0,0 +1,274 @@
+import { MAX_ENDURANCE_FATIGUE, RdDUtility } from "../rdd-utility.js";
+import { ReglesOptionnelles } from "../settings/regles-optionnelles.js";
+import { STATUSES } from "../settings/status-effects.js";
+import { TYPES } from "../item.js";
+import { RdDBaseActorReve } from "./base-actor-reve.js";
+import { RdDDice } from "../rdd-dice.js";
+import { RdDItemBlessure } from "../item/blessure.js";
+
+/**
+ * Classe de base pour les acteurs qui peuvent subir des blessures
+ * - créatures
+ * - humanoides
+ */
+export class RdDBaseActorSang extends RdDBaseActorReve {
+
+
+  getForce() { return Number(this.system.carac.force?.value ?? 0) }
+
+  getBonusDegat() { return Number(this.system.attributs?.plusdom?.value ?? 0) }
+  getProtectionNaturelle() { return Number(this.system.attributs?.protection?.value ?? 0) }
+  getSConst() { return 0 }
+
+  getEnduranceMax() {
+    return Math.max(1, Math.min(this.system.sante.endurance.max, MAX_ENDURANCE_FATIGUE));
+  }
+
+  getFatigueActuelle() {
+    if (ReglesOptionnelles.isUsing("appliquer-fatigue")) {
+      return Math.max(0, Math.min(this.getFatigueMax(), this.system.sante.fatigue?.value));
+    }
+    return 0;
+  }
+
+  getFatigueRestante() {
+    return this.getFatigueMax() - this.getFatigueActuelle();
+  }
+
+  getFatigueMin() {
+    return this.system.sante.endurance.max - this.system.sante.endurance.value;
+  }
+
+  getFatigueMax() { return this.getEnduranceMax() * 2 }
+
+  malusFatigue() {
+    if (ReglesOptionnelles.isUsing("appliquer-fatigue")) {
+      return RdDUtility.calculMalusFatigue(this.getFatigueActuelle(), this.getEnduranceMax())
+    }
+    return 0;
+  }
+
+  /* -------------------------------------------- */
+  getEncombrementMax() { return Number(this.system.attributs?.encombrement?.value ?? 0) }
+  isSurenc() { return this.computeMalusSurEncombrement() < 0 }
+
+  computeMalusSurEncombrement() {
+    return Math.min(0, Math.floor(this.getEncombrementMax() - this.encTotal));
+  }
+
+  isDead() {
+    return this.system.sante.vie.value < -this.getSConst()
+  }
+
+  /* -------------------------------------------- */
+  computeResumeBlessure() {
+    const blessures = this.filterItems(it => it.system.gravite > 0, 'blessure')
+
+    const nbLegeres = blessures.filter(it => it.isLegere()).length;
+    const nbGraves = blessures.filter(it => it.isGrave()).length;
+    const nbCritiques = blessures.filter(it => it.isCritique()).length;
+
+    if (nbLegeres + nbGraves + nbCritiques == 0) {
+      return "Aucune blessure";
+    }
+    let resume = "Blessures:";
+    if (nbLegeres > 0) {
+      resume += " " + nbLegeres + " légère" + (nbLegeres > 1 ? "s" : "");
+    }
+    if (nbGraves > 0) {
+      if (nbLegeres > 0)
+        resume += ",";
+      resume += " " + nbGraves + " grave" + (nbGraves > 1 ? "s" : "");
+    }
+    if (nbCritiques > 0) {
+      if (nbGraves > 0 || nbLegeres > 0)
+        resume += ",";
+      resume += " une CRITIQUE !";
+    }
+    return resume;
+  }
+
+  blessuresASoigner() { return [] }
+  getEtatGeneral(options = { ethylisme: false }) { return 0 }
+
+  async computeArmure(attackerRoll) { return this.getProtectionNaturelle() }
+  async remiseANeuf() { }
+  async appliquerAjoutExperience(rollData, hideChatMessage = 'show') { }
+
+  /* -------------------------------------------- */
+
+  async onAppliquerJetEncaissement(encaissement, attacker) {
+    const santeOrig = 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, {
+      resteEndurance: perteEndurance.newValue,
+      sonne: perteEndurance.sonne,
+      jetEndurance: perteEndurance.jetEndurance,
+      endurance: perteEndurance.perte,
+      vie: santeOrig.vie.value - perteVie.newValue,
+      blessure: blessure
+    });
+  }
+  /* -------------------------------------------- */
+  async santeIncDec(name, inc, isCritique = false) {
+    if (name == 'fatigue' && !ReglesOptionnelles.isUsing("appliquer-fatigue")) {
+      return;
+    }
+    const sante = duplicate(this.system.sante)
+    let compteur = sante[name];
+    if (!compteur) {
+      return;
+    }
+    let result = {
+      sonne: false,
+    };
+
+    let minValue = name == "vie" ? -this.getSConst() - 1 : 0;
+
+    result.newValue = Math.max(minValue, Math.min(compteur.value + inc, compteur.max));
+    //console.log("New value ", inc, minValue, result.newValue);
+    let fatigue = 0;
+    if (name == "endurance") {
+      if (result.newValue == 0 && inc < 0 && !isCritique) { // perte endurance et endurance devient 0 (sauf critique) -> -1 vie
+        sante.vie.value--;
+        result.perteVie = true;
+      }
+      result.newValue = Math.max(0, result.newValue);
+      if (inc > 0) { // le max d'endurance s'applique seulement à la récupération
+        result.newValue = Math.min(result.newValue, this._computeEnduranceMax())
+      }
+      const perte = compteur.value - result.newValue;
+      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));
+      } else if (inc > 0) {
+        await this.setSonne(false);
+      }
+      if (sante.fatigue && inc < 0) { // Each endurance lost -> fatigue lost
+        fatigue = perte;
+      }
+    }
+    compteur.value = result.newValue;
+    // If endurance lost, then the same amount of fatigue cannot be recovered
+    if (ReglesOptionnelles.isUsing("appliquer-fatigue") && sante.fatigue && fatigue > 0) {
+      sante.fatigue.value = Math.max(sante.fatigue.value + fatigue, this.getFatigueMin());
+    }
+    await this.update({ "system.sante": sante })
+    if (this.isDead()) {
+      await this.setEffect(STATUSES.StatusComma, true);
+    }
+    return result
+  }
+
+  /* -------------------------------------------- */
+
+  /* -------------------------------------------- */
+  async ajouterBlessure(encaissement, attacker = undefined) {
+    if (encaissement.gravite < 0) return;
+    if (encaissement.gravite > 0) {
+      while (this.countBlessures(it => it.system.gravite == encaissement.gravite) >= RdDItemBlessure.maxBlessures(encaissement.gravite) && encaissement.gravite <= 6) {
+        // Aggravation
+        encaissement.gravite += 2
+        if (encaissement.gravite > 2) {
+          encaissement.vie += 2;
+        }
+      }
+    }
+    const endActuelle = this.getEnduranceActuelle();
+    const blessure = await RdDItemBlessure.createBlessure(this, encaissement.gravite, encaissement.dmg.loc.label, attacker);
+    if (blessure.isCritique()) {
+      encaissement.endurance = endActuelle;
+    }
+
+    if (blessure.isMort()) {
+      this.setEffect(STATUSES.StatusComma, true);
+      encaissement.mort = true;
+      ChatMessage.create({
+        content: `<img class="chat-icon" src="icons/svg/skull.svg" alt="charge" />
+        <strong>${this.name} vient de succomber à une seconde blessure critique ! Que les Dragons gardent son Archétype en paix !</strong>`
+      });
+    }
+    return blessure;
+  }
+
+  async supprimerBlessures(filterToDelete) {
+    const toDelete = this.filterItems(filterToDelete, TYPES.blessure)
+      .map(it => it.id);
+    await this.deleteEmbeddedDocuments('Item', toDelete);
+  }
+
+  countBlessures(filter = it => !it.isContusion()) {
+    return this.filterItems(filter, 'blessure').length
+  }
+
+  /* -------------------------------------------- */
+  async jetVie() {
+    let roll = await RdDDice.roll("1d20");
+    let msgText = "Jet de Vie : " + roll.total + " / " + this.system.sante.vie.value + "<br>";
+    if (roll.total <= this.system.sante.vie.value) {
+      msgText += "Jet réussi, pas de perte de point de vie (prochain jet dans 1 round pour 1 critique, SC minutes pour une grave)";
+      if (roll.total == 1) {
+        msgText += "La durée entre 2 jets de vie est multipliée par 20 (20 rounds pour une critique, SCx20 minutes pour une grave)";
+      }
+    } else {
+      msgText += "Jet échoué, vous perdez 1 point de vie";
+      await this.santeIncDec("vie", -1);
+      if (roll.total == 20) {
+        msgText += "Votre personnage est mort !!!!!";
+      }
+    }
+    const message = {
+      content: msgText,
+      whisper: ChatMessage.getWhisperRecipients(this.name)
+    };
+    ChatMessage.create(message);
+  }
+
+  /* -------------------------------------------- */
+  async jetEndurance(resteEndurance = undefined) {
+    const jetEndurance = (await RdDDice.roll("1d20")).total;
+    const sonne = jetEndurance == 20 || jetEndurance > (resteEndurance ?? this.system.sante.endurance.value)
+    if (sonne) {
+      await this.setSonne();
+    }
+    return { jetEndurance, sonne }
+  }
+
+
+  async finDeRoundBlessures() {
+    const nbGraves = this.filterItems(it => it.isGrave(), 'blessure').length;
+    if (nbGraves > 0) {
+      // Gestion blessure graves : -1 pt endurance par blessure grave
+      await this.santeIncDec("endurance", -nbGraves);
+    }
+  }
+
+  async setSonne(sonne = true) {
+    if (!game.combat && sonne) {
+      ui.notifications.info(`${this.name} est hors combat, il ne reste donc pas sonné`);
+      return;
+    }
+    await this.setEffect(STATUSES.StatusStunned, sonne);
+  }
+
+  getSonne() {
+    return this.getEffect(STATUSES.StatusStunned);
+  }
+
+  /* -------------------------------------------- */
+  async computeEtatGeneral() {
+    this.system.compteurs.etat.value = this.malusVie() + this.malusFatigue() + this.malusEthylisme();
+  }
+
+  malusVie() {
+    return Math.min(this.system.sante.vie.value - this.system.sante.vie.max, 0);
+  }
+
+  malusEthylisme() { return 0 }
+
+
+}

module/actor/base-actor-sheet.js

@@ -16,13 +16,10 @@ export class RdDBaseActorSheet extends ActorSheet {
   /** @override */
   static get defaultOptions() {
     RdDUtility.initAfficheContenu();
-    return mergeObject(super.defaultOptions, {
+    return mergeObject(ActorSheet.defaultOptions, {
       classes: ["rdd", "sheet", "actor"],
-      template: "systems/foundryvtt-reve-de-dragon/templates/actor-sheet.html",
-      width: 550,
       tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "carac" }],
       dragDrop: [{ dragSelector: ".item-list .item", dropSelector: undefined }],
-      showCompNiveauBase: false,
       vueDetaillee: false
     });
   }
@@ -31,7 +28,7 @@ export class RdDBaseActorSheet extends ActorSheet {
   async getData() {
     Monnaie.validerMonnaies(this.actor.itemTypes['monnaie']);
 
-    this.actor.recompute();
+    this.actor.computeEtatGeneral();
     let formData = {
       title: this.title,
       id: this.actor.id,
@@ -135,6 +132,13 @@ export class RdDBaseActorSheet extends ActorSheet {
     super.activateListeners(html);
     this.html = html;
 
+    if (!this.options.editable) return;
+
+    this.html.find('.item-action').click(async event => {
+      const item = RdDSheetUtility.getItem(event, this.actor);
+      item?.actionPrincipale(this.actor, async () => this.render())
+    });
+
     this.html.find('.conteneur-name a').click(async event => {
       RdDUtility.toggleAfficheContenu(this.getItemId(event));
       this.render(true);
@@ -167,6 +171,26 @@ export class RdDBaseActorSheet extends ActorSheet {
     this.html.find('.nettoyer-conteneurs').click(async event => {
       this.actor.nettoyerConteneurs();
     });
+
+    this.html.find('.vue-detaillee').click(async event => {
+      this.options.vueDetaillee = !this.options.vueDetaillee;
+      this.render(true);
+    });
+
+    if (this.options.vueDetaillee) {
+      // On carac change
+      this.html.find('.carac-value').change(async event => {
+        let caracName = event.currentTarget.name.replace(".value", "").replace("system.carac.", "");
+        this.actor.updateCarac(caracName, parseInt(event.target.value));
+      });
+      // On competence change
+      this.html.find('.competence-value').change(async event => {
+        let compName = event.currentTarget.attributes.compname.value;
+        //console.log("Competence changed :", compName);
+        this.actor.updateCompetence(compName, parseInt(event.target.value));
+      });
+    }
+
   }
 
   _rechercherKeyup(event) {

module/actor/base-actor.js

@@ -1,6 +1,8 @@
 import { ChatUtility } from "../chat-utility.js";
 import { SYSTEM_SOCKET_ID } from "../constants.js";
+import { Grammar } from "../grammar.js";
 import { Monnaie } from "../item-monnaie.js";
+import { TYPES } from "../item.js";
 import { Misc } from "../misc.js";
 import { RdDAudio } from "../rdd-audio.js";
 import { RdDConfirm } from "../rdd-confirm.js";
@@ -9,6 +11,33 @@ import { SystemCompendiums } from "../settings/system-compendiums.js";
 import { APP_ASTROLOGIE_REFRESH } from "../sommeil/app-astrologie.js";
 
 export class RdDBaseActor extends Actor {
+  /* -------------------------------------------- */
+  static _findCaracByName(carac, name) {
+    name = Grammar.toLowerCaseNoAccent(name);
+    switch (name) {
+      case 'reve-actuel': case 'reve actuel':
+        return carac.reve;
+      case 'chance-actuelle': case 'chance actuelle':
+        return carac.chance;
+    }
+
+    const caracList = Object.entries(carac);
+    let entry = Misc.findFirstLike(name, caracList, { mapper: it => it[0], description: 'caractéristique' });
+    if (!entry || entry.length == 0) {
+      entry = Misc.findFirstLike(name, caracList, { mapper: it => it[1].label, description: 'caractéristique' });
+    }
+    return entry && entry.length > 0 ? carac[entry[0]] : undefined;
+  }
+
+  getCaracByName(name) {
+    switch (Grammar.toLowerCaseNoAccent(name)) {
+      case 'reve-actuel': case 'reve actuel':
+        return this.getCaracReveActuel();
+      case 'chance-actuelle': case 'chance-actuelle':
+        return this.getCaracChanceActuelle();
+    }
+    return RdDBaseActor._findCaracByName(this.system.carac, name);
+  }
 
   static getDefaultImg(itemType) {
     return game.system.rdd.actorClasses[itemType]?.defaultIcon ?? defaultItemImg[itemType];
@@ -50,7 +79,13 @@ export class RdDBaseActor extends Actor {
 
   static onRemoteActorCall(callData, userId) {
     if (userId == game.user.id) {
-      const actor = game.actors.get(callData?.actorId);
+      let actor = game.actors.get(callData?.actorId);
+      if (callData.tokenId) {
+        let token = canvas.tokens.placeables.find(t => t.id == callData.tokenId)
+        if (token) {
+          actor = token.actor
+        }
+      }
       if (Misc.isOwnerPlayerOrUniqueConnectedGM(actor)) { // Seul le joueur choisi effectue l'appel: le joueur courant si propriétaire de l'actor, ou le MJ sinon
         const args = callData.args;
         console.info(`RdDBaseActor.onRemoteActorCall: pour l'Actor ${callData.actorId}, appel de RdDBaseActor.${callData.method}(`, ...args, ')');
@@ -105,11 +140,39 @@ export class RdDBaseActor extends Actor {
     super(docData, context);
   }
 
-  isCreatureEntite() { return this.type == 'creature' || this.type == 'entite'; }
-  isCreature() { return this.type == 'creature'; }
-  isEntite() { return this.type == 'entite'; }
-  isPersonnage() { return this.type == 'personnage'; }
-  isVehicule() { return this.type == 'vehicule'; }
+  /* -------------------------------------------- */
+  async _preCreate(data, options, user) {
+    await super._preCreate(data, options, user);
+
+    // Configure prototype token settings
+    const prototypeToken = {};
+    if (this.type === "personnage") Object.assign(prototypeToken, {
+      sight: { enabled: true }, actorLink: true, disposition: CONST.TOKEN_DISPOSITIONS.FRIENDLY
+    });
+    this.updateSource({ prototypeToken });
+  }
+
+  /* -------------------------------------------- */
+  prepareData() {
+    super.prepareData()
+    this.prepareActorData()
+    this.cleanupConteneurs()
+    this.computeEtatGeneral()
+    this.computeEncTotal()
+  }
+
+  async prepareActorData() { }
+  async computeEtatGeneral() { }
+  /* -------------------------------------------- */
+  findPlayer() {
+    return game.users.players.find(player => player.active && player.character?.id == this.id);
+  }
+
+  isCreatureEntite() { return this.isCreature() || this.isEntite() }
+  isCreature() { return false }
+  isEntite(typeentite = []) { return false }
+  isVehicule() { return false }
+  isPersonnage() { return false }
   getItem(id, type = undefined) {
     const item = this.items.get(id);
     if (type == undefined || (item?.type == type)) {
@@ -126,9 +189,7 @@ export class RdDBaseActor extends Actor {
   }
 
   getMonnaie(id) { return this.findItemLike(id, 'monnaie'); }
-
-  recompute() { }
-
+  getEncombrementMax() { return 0 }
 
   /* -------------------------------------------- */
   async onPreUpdateItem(item, change, options, id) { }
@@ -144,9 +205,10 @@ export class RdDBaseActor extends Actor {
       .forEach(async it => await it.onFinPeriodeTemporel(oldTimestamp, newTimestamp))
   }
 
-  async creerObjetParMJ(object){
+  async creerObjetParMJ(object) {
     if (!Misc.isUniqueConnectedGM()) {
       RdDBaseActor.remoteActorCall({
+        tokenId: this.token?.id,
         actorId: this.id,
         method: 'creerObjetParMJ',
         args: [object]
@@ -156,6 +218,16 @@ export class RdDBaseActor extends Actor {
     await this.createEmbeddedDocuments('Item', [object])
   }
 
+  /* -------------------------------------------- */
+  async cleanupConteneurs() {
+    let updates = this.itemTypes['conteneur']
+      .filter(c => c.system.contenu.filter(id => this.getItem(id) == undefined).length > 0)
+      .map(c => { return { _id: c._id, 'system.contenu': c.system.contenu.filter(id => this.getItem(id) != undefined) } });
+    if (updates.length > 0) {
+      await this.updateEmbeddedDocuments("Item", updates)
+    }
+  }
+
   /* -------------------------------------------- */
   getFortune() {
     return Monnaie.getFortune(this.itemTypes['monnaie']);
@@ -220,6 +292,7 @@ export class RdDBaseActor extends Actor {
     if (fromActorId && !game.user.isGM) {
       RdDBaseActor.remoteActorCall({
         userId: Misc.connectedGMOrUser(),
+        tokenId: this.token?.id,
         actorId: this.id,
         method: 'ajouterSols', args: [sols, fromActorId]
       });
@@ -262,10 +335,10 @@ export class RdDBaseActor extends Actor {
     const quantite = (achat.choix.nombreLots ?? 1) * (achat.vente.tailleLot);
     const itemVendu = vendeur?.getItem(achat.vente.item._id) ?? game.items.get(achat.vente.item._id);
     if (!itemVendu) {
-      ChatUtility.notifyUser(achat.userId, 'warn', vendeur ? `Le vendeur n'a pas plus de ${achat.vente.item.name} !`: `Impossible de retrouver: ${achat.vente.item.name} !`);
+      ChatUtility.notifyUser(achat.userId, 'warn', vendeur ? `Le vendeur n'a pas plus de ${achat.vente.item.name} !` : `Impossible de retrouver: ${achat.vente.item.name} !`);
       return;
     }
-    if (vendeur && !this.verifierQuantite(itemVendu, quantite)) {
+    if (vendeur && !vendeur.verifierQuantite(itemVendu, quantite)) {
       ChatUtility.notifyUser(achat.userId, 'warn', `Le vendeur n'a pas assez de ${itemVendu.name} !`);
       return
     }
@@ -318,7 +391,7 @@ export class RdDBaseActor extends Actor {
   }
 
   verifierQuantite(item, quantiteDemande) {
-    const disponible = item?.getQuantite();
+    const disponible = this.getQuantiteDisponible(item);
     return disponible == undefined || disponible >= quantiteDemande;
   }
 
@@ -367,14 +440,6 @@ export class RdDBaseActor extends Actor {
   }
 
   /* -------------------------------------------- */
-  computeMalusSurEncombrement() {
-    return 0;
-  }
-
-  getEncombrementMax() {
-    return 0;
-  }
-
   async computeEncTotal() {
     if (!this.pack) {
       this.encTotal = this.items.map(it => it.getEncTotal()).reduce(Misc.sum(), 0);
@@ -383,6 +448,10 @@ export class RdDBaseActor extends Actor {
     return 0;
   }
 
+  getEncTotal() {
+    return Math.floor(this.encTotal ?? 0);
+  }
+
   async createItem(type, name = undefined) {
     if (!name) {
       name = 'Nouveau ' + Misc.typeName('Item', type);
@@ -447,62 +516,33 @@ export class RdDBaseActor extends Actor {
 
 
   /* -------------------------------------------- */
-  conteneurPeutContenir(dest, item) {
+  conteneurPeutContenir(dest, moved) {
     if (!dest) {
       return true;
     }
     if (!dest.isConteneur()) {
       return false;
     }
-    const destData = dest
-    if (this._isConteneurContenu(item, dest)) {
-      ui.notifications.warn(`Impossible de déplacer un conteneur parent (${item.name}) dans un de ses contenus ${destData.name} !`);
-      return false; // Loop detected !
+    if (moved.isConteneurContenu(dest)) {
+      ui.notifications.warn(`Impossible de déplacer un conteneur parent (${moved.name}) dans un de ses contenus ${dest.name} !`);
+      return false;
     }
 
     // Calculer le total actuel des contenus
-    let encContenu = this.getRecursiveEnc(dest) - Number(destData.system.encombrement);
-    let newEnc = this.getRecursiveEnc(item); // Calculer le total actuel du nouvel objet
+    const encContenu = dest.getEncContenu();
+    const newEnc = moved.getEncTotal(); // Calculer le total actuel du nouvel objet
+    const placeDisponible = Math.roundDecimals(dest.system.capacite - encContenu - newEnc, 4)
 
     // Teste si le conteneur de destination a suffisament de capacité pour recevoir le nouvel objet
-    if (Number(destData.system.capacite) < encContenu + newEnc) {
+    if (placeDisponible < 0) {
       ui.notifications.warn(
-        `Le conteneur ${dest.name} a une capacité de ${destData.system.capacite}, et contient déjà ${encContenu}.
-        Impossible d'y ranger: ${item.name} d'encombrement ${newEnc}!`);
+        `Le conteneur ${dest.name} a une capacité de ${dest.system.capacite}, et contient déjà ${encContenu}.
+        Impossible d'y ranger: ${moved.name} d'encombrement ${newEnc}!`);
       return false;
     }
     return true;
   }
 
-  /* -------------------------------------------- */
-  _isConteneurContenu(item, conteneur) {
-    if (item?.isConteneur()) { // Si c'est un conteneur, il faut vérifier qu'on ne le déplace pas vers un sous-conteneur lui appartenant
-      for (let id of item.system.contenu) {
-        let subObjet = this.getItem(id);
-        if (subObjet?.id == conteneur.id) {
-          return true; // Loop detected !
-        }
-        if (subObjet?.isConteneur()) {
-          return this._isConteneurContenu(subObjet, conteneur);
-        }
-      }
-    }
-    return false;
-  }
-  /* -------------------------------------------- */
-  getRecursiveEnc(objet) {
-    if (!objet) {
-      return 0;
-    }
-    const tplData = objet.system;
-    if (objet.type != 'conteneur') {
-      return Number(tplData.encombrement) * Number(tplData.quantite);
-    }
-    const encContenus = tplData.contenu.map(idContenu => this.getRecursiveEnc(this.getItem(idContenu)));
-    return encContenus.reduce(Misc.sum(), 0)
-      + Number(tplData.encombrement) /* TODO? Number(tplData.quantite) -- on pourrait avoir plusieurs conteneurs...*/
-  }
-
   /* -------------------------------------------- */
   /** Ajoute un item dans un conteneur, sur la base
    * de leurs ID */
@@ -640,5 +680,20 @@ export class RdDBaseActor extends Actor {
       .then(html => ChatMessage.create(RdDUtility.chatDataSetup(html, modeOverride)));
   }
 
+  actionImpossible(action) {
+    ui.notifications.info(`${this.name} ne peut pas faire cette action: ${action}`)
+
+  }
+  async roll() { this.actionImpossible("jet de caractéristiques") }
+  async jetEthylisme() { this.actionImpossible("jet d'éthylisme") }
+  async rollAppelChance() { this.actionImpossible("appel à la chance") }
+  async jetDeMoral() { this.actionImpossible("jet de moral") }
+
+  async actionPrincipale(item, onActionItem = async () => { }) { 
+    switch (item.type) {
+      case TYPES.conteneur: return await item.sheet.render(true);
+    }
+    return undefined
+  }
 
 }

module/actor/commerce-sheet.js

@@ -1,9 +1,7 @@
 import { DialogItemAchat } from "../dialog-item-achat.js";
 import { RdDItem } from "../item.js";
-import { RdDSheetUtility } from "../rdd-sheet-utility.js";
 import { RdDUtility } from "../rdd-utility.js";
 import { RdDBaseActorSheet } from "./base-actor-sheet.js";
-import { RdDCommerce } from "./commerce.js";
 
 /**
  * Extend the basic ActorSheet with some very simple modifications
@@ -14,12 +12,9 @@ export class RdDCommerceSheet extends RdDBaseActorSheet {
   /** @override */
   static get defaultOptions() {
     return mergeObject(super.defaultOptions, {
-      classes: ["rdd", "sheet", "actor"],
       template: "systems/foundryvtt-reve-de-dragon/templates/actor/commerce-actor-sheet.html",
-      width: 600,
-      height: 720,
-      tabs: [],
-      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: undefined }]
+      width: 600, height: 720,
+      tabs: []
     });
   }
   get title() {

module/actor/commerce.js

@@ -7,18 +7,8 @@ export class RdDCommerce extends RdDBaseActor {
     return "systems/foundryvtt-reve-de-dragon/icons/services/commerce.webp";
   }
 
-  prepareData() {
-    super.prepareData();
-  }
-  prepareDerivedData() {
-    super.prepareDerivedData();
-  }
-
   canReceive(item) {
-    if (item.isInventaire('all')) {
-      return true;
-    }
-    return super.canReceive(item);
+    return item.isInventaire('all');
   }
 
   getQuantiteDisponible(item) {
@@ -28,6 +18,7 @@ export class RdDCommerce extends RdDBaseActor {
   verifierFortune(cout) {
     return this.system.illimite || super.verifierFortune(cout);
   }
+
   async depenserSols(cout) {
     if (this.system.illimite) {
       return

module/actor/creature-sheet.js

@@ -1,20 +1,16 @@
-import { RdDActorSheet } from "./actor-sheet.js";
+import { RdDBaseActorReveSheet } from "./base-actor-reve-sheet.js";
 
 /**
  * Extend the basic ActorSheet with some very simple modifications
  * @extends {ActorSheet}
  */
-export class RdDActorCreatureSheet extends RdDActorSheet {
+export class RdDCreatureSheet extends RdDBaseActorReveSheet {
 
   /** @override */
   static get defaultOptions() {
-    return mergeObject(super.defaultOptions, {
-      classes: ["rdd", "sheet", "actor"],
+    return mergeObject(RdDBaseActorReveSheet.defaultOptions, {
       template: "systems/foundryvtt-reve-de-dragon/templates/actor-creature-sheet.html",
-      width: 640,
-      height: 720,
-      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "carac" }],
-      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: undefined }]
+      width: 640, height: 720
     });
   }
 

module/actor/creature.js

@@ -0,0 +1,65 @@
+import { ENTITE_INCARNE } from "../constants.js";
+import { STATUSES } from "../settings/status-effects.js";
+import { RdDBaseActorSang } from "./base-actor-sang.js";
+
+export class RdDCreature extends RdDBaseActorSang {
+
+  static get defaultIcon() {
+    return "systems/foundryvtt-reve-de-dragon/icons/creatures/bramart.svg";
+  }
+
+  isCreature() { return true }
+
+  canReceive(item) {
+    return item.type == TYPES.competencecreature || item.isInventaire();
+  }
+
+  async remiseANeuf() {
+    await this.removeEffects(e => true);
+    await this.supprimerBlessures(it => true);
+    const updates = {
+      'system.sante.endurance.value': this.system.sante.endurance.max,
+      'system.sante.vie.value': this.system.sante.vie.max,
+      'system.sante.fatigue.value': 0
+    };
+    await this.update(updates);
+  }
+
+  async finDeRoundBlessures() {
+    const nbGraves = this.filterItems(it => it.isGrave(), 'blessure').length;
+    if (nbGraves > 0) {
+      // Gestion blessure graves : -1 pt endurance par blessure grave
+      await this.santeIncDec("endurance", -nbGraves);
+    }
+  }
+
+  isEffectAllowed(statusId) {
+    return [STATUSES.StatusComma].includes(statusId);
+  }
+
+  isEntiteAccordee(attacker) {
+    if (this.isEntite([ENTITE_INCARNE])) {
+      let resonnance = this.system.sante.resonnance
+      return (resonnance.actors.find(it => it == attacker.id))
+    }
+    return true
+  }
+
+  /* -------------------------------------------- */
+  async setEntiteReveAccordee(attacker) {
+    if (this.isEntite([ENTITE_INCARNE])) {
+      let resonnance = duplicate(this.system.sante.resonnance);
+      if (resonnance.actors.find(it => it == attacker.id)) {
+        // déjà accordé
+        return;
+      }
+      resonnance.actors.push(attacker.id);
+      await this.update({ "system.sante.resonnance": resonnance });
+    }
+    else {
+      super.setEntiteReveAccordee(attacker)
+    }
+  }
+
+
+}

module/actor/entite-sheet.js

@@ -1,20 +1,17 @@
-import { RdDActorSheet } from "./actor-sheet.js";
-import { RdDSheetUtility } from "./rdd-sheet-utility.js";
-import { RdDUtility } from "./rdd-utility.js";
+import { RdDBaseActorReveSheet } from "./base-actor-reve-sheet.js";
+import { RdDSheetUtility } from "../rdd-sheet-utility.js";
+import { RdDUtility } from "../rdd-utility.js";
 
-export class RdDActorEntiteSheet extends RdDActorSheet {
+export class RdDActorEntiteSheet extends RdDBaseActorReveSheet {
 
   /** @override */
   static get defaultOptions() {
-    return mergeObject(super.defaultOptions, {
-      classes: ["rdd", "sheet", "actor"],
+    return mergeObject(RdDBaseActorReveSheet.defaultOptions, {
       template: "systems/foundryvtt-reve-de-dragon/templates/actor-entite-sheet.html",
-      width: 640,
-      height: 720,
-      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "carac" }],
-      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: undefined }]
+      width: 640, height: 720,
     });
   }
+
   async getData() {
     let formData = await super.getData();
     formData.resonances = this.actor.system.sante.resonnance.actors.map(actorId => game.actors.get(actorId))

module/actor/entite.js

@@ -0,0 +1,110 @@
+import { ENTITE_INCARNE, ENTITE_NONINCARNE } from "../constants.js";
+import { TYPES } from "../item.js";
+import { Misc } from "../misc.js";
+import { RdDEncaisser } from "../rdd-roll-encaisser.js";
+import { STATUSES } from "../settings/status-effects.js";
+import { RdDBaseActorReve } from "./base-actor-reve.js";
+
+export class RdDEntite extends RdDBaseActorReve {
+
+  static get defaultIcon() {
+    return "systems/foundryvtt-reve-de-dragon/icons/entites/darquoine.webp";
+  }
+
+  canReceive(item) {
+    return item.type == TYPES.competencecreature
+  }
+
+  isEntite(typeentite = []) {
+    return (typeentite.length == 0 || typeentite.includes(this.system.definition.typeentite));
+  }
+  isNonIncarnee() { return this.isEntite([ENTITE_NONINCARNE]) }
+
+  getReveActuel() {
+    return Misc.toInt(this.system.carac.reve?.value)
+  }
+
+  getForce() { return this.getReve() }
+  getAgilite() { return this.getReve() }
+  getChance() { return this.getReve() }
+
+  getDraconicOuPossession() {
+    return this.itemTypes[TYPES.competencecreature]
+      .filter(it => it.system.categorie == 'possession')
+      .sort(Misc.descending(it => it.system.niveau))
+      .find(it => true);
+  }
+
+  async remiseANeuf() {
+    await this.removeEffects(e => true);
+    if (!this.isNonIncarnee()) {
+      await this.update({
+        'system.sante.endurance.value': this.system.sante.endurance.max
+      });
+    }
+  }
+
+  isDead() {
+    return this.isNonIncarnee() ? false : this.system.sante.endurance.value <= 0
+  }
+
+  async santeIncDec(name, inc, isCritique = false) {
+    if (name == 'endurance' && !this.isNonIncarnee()) {
+      const oldValue = this.system.sante.endurance.value;
+      const endurance = Math.max(0,
+        Math.min(oldValue + inc,
+          this.system.sante.endurance.max));
+      await this.update({ "system.sante.endurance.value": endurance })
+      await this.setEffect(STATUSES.StatusComma, endurance <= 0);
+      return {
+        perte: oldValue - endurance,
+        newValue: endurance
+      }
+    }
+    return {}
+  }
+  async encaisser() {
+    if (this.isNonIncarnee()) {
+      return
+    }
+    await RdDEncaisser.encaisser(this) 
+  }
+
+  isEffectAllowed(statusId) {
+    return [STATUSES.StatusComma].includes(statusId);
+  }
+
+  async onAppliquerJetEncaissement(encaissement, attacker) {
+    const perteEndurance = await this.santeIncDec("endurance", -encaissement.endurance);
+    mergeObject(encaissement, {
+      resteEndurance: perteEndurance.newValue,
+      endurance: perteEndurance.perte
+    });
+  }
+
+  isEntiteAccordee(attacker) {
+    if (this.isEntite([ENTITE_INCARNE])) {
+      let resonnance = this.system.sante.resonnance
+      return (resonnance.actors.find(it => it == attacker.id))
+    }
+    return true
+  }
+
+  /* -------------------------------------------- */
+  async setEntiteReveAccordee(attacker) {
+    if (this.isEntite([ENTITE_INCARNE])) {
+      let resonnance = duplicate(this.system.sante.resonnance);
+      if (resonnance.actors.find(it => it == attacker.id)) {
+        // déjà accordé
+        return;
+      }
+      resonnance.actors.push(attacker.id);
+      await this.update({ "system.sante.resonnance": resonnance });
+    }
+    else {
+      super.setEntiteReveAccordee(attacker)
+    }
+  }
+
+
+}

module/actor/vehicule-sheet.js

@@ -1,23 +1,35 @@
-import { RdDUtility } from "./rdd-utility.js";
-import { RdDActorSheet } from "./actor-sheet.js";
+import { RdDUtility } from "../rdd-utility.js";
+import { RdDBaseActorSheet } from "./base-actor-sheet.js";
 
 /* -------------------------------------------- */
-export class RdDActorVehiculeSheet extends RdDActorSheet {
+export class RdDActorVehiculeSheet extends RdDBaseActorSheet {
 
   /** @override */
   static get defaultOptions() {
     RdDUtility.initAfficheContenu();
 
-    return mergeObject(super.defaultOptions, {
-      classes: ["rdd", "sheet", "actor"],
+    return mergeObject(RdDBaseActorSheet.defaultOptions, {
       template: "systems/foundryvtt-reve-de-dragon/templates/actor-vehicule-sheet.html",
-      width: 640,
-      height: 720,
-      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "carac" }],
-      dragDrop: [{ dragSelector: ".item-list .item", dropSelector: undefined }]
+      width: 640, height: 720,
     });
   }
 
+  /* -------------------------------------------- */
+  async getData() {
+    let formData = await super.getData();
+    mergeObject(formData,
+      {
+        editable: this.isEditable,
+        cssClass: this.isEditable ? "editable" : "locked",
+        effects: this.actor.effects.map(e => foundry.utils.deepClone(e)),
+        limited: this.actor.limited,
+        owner: this.actor.isOwner,
+      });
+
+    this.timerRecherche = undefined;
+    return formData;
+  }
+
   activateListeners(html) {
     super.activateListeners(html);
     if (!this.options.editable) return;

module/actor/vehicule.js

@@ -0,0 +1,28 @@
+import { RdDBaseActor } from "./base-actor.js";
+
+export class RdDVehicule extends RdDBaseActor {
+
+  static get defaultIcon() {
+    return "systems/foundryvtt-reve-de-dragon/icons/vehicules/charette.webp";
+  }
+  isVehicule() { return true }
+
+  canReceive(item) {
+    return item.isInventaire();
+  }
+
+  getEncombrementMax() {
+    return this.system.capacite_encombrement;
+  }
+
+  async vehicleIncDec(name, inc) {
+    if (!['resistance', 'structure'].includes(name)) {
+      return
+    }
+    const newValue = this.system.etat[name].value + inc;
+    if (0 <= newValue && newValue <= this.system.etat[name].max) {
+      await this.update({ [`system.etat.${name}.value`]: newValue })
+    }
+  }
+
+}

module/dialog-chronologie.js

@@ -114,7 +114,7 @@ export class DialogChronologie extends Dialog {
         heure: RdDTimestamp.definition(this.html.find("form.rdddialogchrono :input[name='chronologie.heure']").val()),
         minute: this.html.find("form.rdddialogchrono :input[name='chronologie.minute']").val(),
       },
-      dateReel: this.html.find("form.rdddialogchrono :input[name='dateReel']").val()
+      dateReel: this.html.find("form.rdddialogchrono :input[name='dateReel']").val().replace('T', ' ')
     }
   }
 

module/dialog-create-signedraconique.js

@@ -14,7 +14,7 @@ export class DialogCreateSigneDraconique extends Dialog {
         .map(actor => ({
           id: actor.id,
           name: actor.name,
-          selected: true
+          selected: false
         }))
     };
 

module/dialog-validation-encaissement.js

@@ -7,20 +7,19 @@ import { RdDUtility } from "./rdd-utility.js";
  */
 export class DialogValidationEncaissement extends Dialog {
 
-  static async validerEncaissement(actor, rollData, armure, show, attackerId, onEncaisser) {
+  static async validerEncaissement(actor, rollData, armure, onEncaisser) {
     let encaissement = await RdDUtility.jetEncaissement(rollData, armure, { showDice: HIDE_DICE });
     const html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/dialog-validation-encaissement.html', {
       actor: actor,
       rollData: rollData,
-      encaissement: encaissement,
-      show: show
+      encaissement: encaissement
     });
-    const dialog = new DialogValidationEncaissement(html, actor, rollData, armure, encaissement, show, attackerId, onEncaisser);
+    const dialog = new DialogValidationEncaissement(html, actor, rollData, armure, encaissement, onEncaisser);
     dialog.render(true);
   }
 
   /* -------------------------------------------- */
-  constructor(html, actor, rollData, armure, encaissement, show, attackerId, onEncaisser) {
+  constructor(html, actor, rollData, armure, encaissement, onEncaisser) {
     // Common conf
     let buttons = {
       "valider": { label: "Valider", callback: html => this.onValider() },
@@ -47,8 +46,6 @@ export class DialogValidationEncaissement extends Dialog {
     this.rollData = rollData;
     this.armure = armure;
     this.encaissement = encaissement;
-    this.show = show;
-    this.attackerId = attackerId;
     this.onEncaisser = onEncaisser;
     this.forceDiceResult = {total: encaissement.roll.result };
   }
@@ -67,6 +64,6 @@ export class DialogValidationEncaissement extends Dialog {
 
   async onValider() {
     this.encaissement = await RdDUtility.jetEncaissement(this.rollData, this.armure, { showDice: SHOW_DICE, forceDiceResult: this.forceDiceResult});
-    this.onEncaisser(this.encaissement, this.show, this.attackerId)
+    this.onEncaisser(this.encaissement)
   }
 }

module/item-arme.js

@@ -20,14 +20,14 @@ const nomCategorieParade = {
 export class RdDItemArme extends Item {
 
   static isArme(item) {
-    return RdDItemCompetenceCreature.getCategorieAttaque(item) || item.type == 'arme';
+    return item.type == TYPES.arme || RdDItemCompetenceCreature.getCategorieAttaque(item);
   }
 
   /* -------------------------------------------- */
   static getArme(arme) {
     switch (arme ? arme.type : '') {
-      case 'arme': return arme;
-      case 'competencecreature':
+      case TYPES.arme: return arme;
+      case TYPES.competencecreature:
         return RdDItemCompetenceCreature.armeCreature(arme);
     }
     return RdDItemArme.mainsNues();
@@ -68,14 +68,14 @@ export class RdDItemArme extends Item {
       return armeData.system.categorie_parade;
     }
     // pour compatibilité avec des personnages existants
-    if (armeData.type == 'competencecreature' || armeData.system.categorie == 'creature') {
+    if (armeData.type == TYPES.competencecreature || armeData.system.categorie == 'creature') {
       return armeData.system.categorie_parade || (armeData.system.isparade ? 'armes-naturelles' : '');
     }
     if (!armeData.type.match(/arme|competencecreature/)) {
       return '';
     }
     if (armeData.system.competence == undefined) {
-      return 'competencecreature';
+      return TYPES.competencecreature;
     }
     let compname = armeData.system.competence.toLowerCase();
     if (compname.match(/^(dague de jet|javelot|fouet|arc|arbalête|fronde|hache de jet|fléau)$/)) return '';
@@ -157,23 +157,33 @@ export class RdDItemArme extends Item {
     }
     return armeData;
   }
+  static competence2Mains(arme) {
+    return arme.system.competence.replace(" 1 main", " 2 mains");
+  }
+
+  static competence1Mains(arme) {
+    return arme.system.competence.replace(" 2 mains", " 1 main");
+  }
 
   static isArmeUtilisable(arme) {
     return arme.type == 'arme' && arme.system.equipe && (arme.system.resistance > 0 || arme.system.portee_courte > 0);
   }
 
-  static ajoutCorpsACorps(armes, competences, carac) {
-    let corpsACorps = competences.find(it => it.name == 'Corps à corps') ?? { system: { niveau: -6 } };
-    let init = RdDCombatManager.calculInitiative(corpsACorps.system.niveau, carac['melee'].value);
-    armes.push(RdDItemArme.mainsNues({ niveau: corpsACorps.system.niveau, initiative: init }));
-    armes.push(RdDItemArme.empoignade({ niveau: corpsACorps.system.niveau, initiative: init }));
+  static ajoutCorpsACorps(armes, actor) {
+    armes.push(RdDItemArme.mainsNues(actor));
+    armes.push(RdDItemArme.empoignade(actor));
   }
 
-  static corpsACorps(mainsNuesActor) {
-    const corpsACorps = {
+  static corpsACorps(actor) {
+    let competence = actor?.getCompetenceCorpsACorps() ?? { system: { niveau: -6 } };
+    let melee = actor? actor.system.carac['melee'].value : 0
+    return {
+      _id: competence?.id,
       name: 'Corps à corps',
+      type: TYPES.arme,
       img: 'systems/foundryvtt-reve-de-dragon/icons/competence_corps_a_corps.webp',
       system: {
+        initiative: RdDCombatManager.calculInitiative(competence.system.niveau, melee),
         equipe: true,
         rapide: true,
         force: 0,
@@ -181,23 +191,22 @@ export class RdDItemArme extends Item {
         dommagesReels: 0,
         mortalite: 'non-mortel',
         competence: 'Corps à corps',
+        deuxmains: true,
         categorie_parade: 'sans-armes'
       }
-    };
-    mergeObject(corpsACorps.system, mainsNuesActor ?? {}, { overwrite: false });
-    return corpsACorps;
+    }
   }
 
-  static mainsNues(mainsNuesActor) {
-    const mainsNues = RdDItemArme.corpsACorps(mainsNuesActor)
+  static mainsNues(actor) {
+    const mainsNues = RdDItemArme.corpsACorps(actor)
     mainsNues.name = 'Mains nues'
     mainsNues.system.cac = 'pugilat'
     mainsNues.system.baseInit = 4
     return mainsNues;
   }
-  
-  static empoignade(mainsNuesActor) {
-    const empoignade = RdDItemArme.corpsACorps(mainsNuesActor)
+
+  static empoignade(actor) {
+    const empoignade = RdDItemArme.corpsACorps(actor)
     empoignade.name = 'Empoignade'
     empoignade.system.cac = 'empoignade'
     empoignade.system.baseInit = 3

module/item-competence.js

@@ -79,10 +79,9 @@ export class RdDItemCompetence extends Item {
 
   /* -------------------------------------------- */
   static isCompetenceArme(competence) {
-    if (competence.isCompetence()) {
+    if (competence.isCompetence() && !competence.isCorpsACorps() && !competence.isEsquive()) {
       switch (competence.system.categorie) {
         case 'melee':
-          return !Grammar.toLowerCaseNoAccent(competence.name).includes('esquive');
         case 'tir':
         case 'lancer':
           return true;
@@ -93,10 +92,10 @@ export class RdDItemCompetence extends Item {
 
   /* -------------------------------------------- */
   static isArmeUneMain(competence) {
-    return RdDItemCompetence.isCompetenceArme(competence) && competence.name.toLowerCase().includes("1 main");
+    return competence.isCompetenceArme() && competence.name.toLowerCase().includes("1 main");
   }
   static isArme2Main(competence) {
-    return RdDItemCompetence.isCompetenceArme(competence) && competence.name.toLowerCase().includes("2 main");
+    return competence.isCompetenceArme() && competence.name.toLowerCase().includes("2 main");
   }
 
   static isThanatos(competence) {

module/item-competencecreature.js

@@ -1,5 +1,5 @@
 
-import { RdDItem, TYPES } from "./item.js";
+import { TYPES } from "./item.js";
 import { RdDCombatManager } from "./rdd-combat.js";
 
 const categories = {
@@ -55,6 +55,20 @@ export class RdDItemCompetenceCreature extends Item {
   }
 
   /* -------------------------------------------- */
+  static isCompetenceAttaque(item) {
+    if (item.type == TYPES.competencecreature) {
+      switch (item.system.categorie) {
+        case "melee":
+        case "tir":
+        case "lancer":
+        case "naturelle":
+        case "possession":
+          return true
+      }
+    }
+    return undefined
+  }
+
   static getCategorieAttaque(item) {
     if (item.type == TYPES.competencecreature) {
       switch (item.system.categorie) {
@@ -63,6 +77,7 @@ export class RdDItemCompetenceCreature extends Item {
         case "lancer":
         case "naturelle":
         case "possession":
+        case "parade":
           return item.system.categorie
       }
     }

module/item-sheet.js

@@ -113,7 +113,7 @@ export class RdDItemSheet extends ItemSheet {
       formData.competences = competences;
     }
     if (this.item.type == 'arme') {
-      formData.competences = competences.filter(it => RdDItemCompetence.isCompetenceArme(it))
+      formData.competences = competences.filter(it => it.isCompetenceArme())
     }
     if (['sort', 'sortreserve'].includes(this.item.type)) {
       formData.competences = competences.filter(it => RdDItemCompetence.isDraconic(it));
@@ -195,7 +195,8 @@ export class RdDItemSheet extends ItemSheet {
 
     this.html.find('.creer-tache-livre').click((event) => this._getEventActor(event).creerTacheDepuisLivre(this.item));
     this.html.find('.consommer-potion').click((event) => this._getEventActor(event).consommerPotion(this.item, this.getActionRenderItem()));
-    this.html.find('.creer-potion-base').click((event) => this._getEventActor(event).dialogFabriquerPotion(this.item));
+    this.html.find('.creer-potion-base').click((event) => this._getEventActor(event).actionHerbe(this.item));
+    this.html.find('input[name="system.cacher_points_de_tache"]').change(async event => await this.item.update({ 'system.cacher_points_de_tache': event.currentTarget.checked }));
 
     this.html.find('.alchimie-tache a').click((event) => {
       let actor = this._getEventActor(event);
@@ -256,7 +257,7 @@ export class RdDItemSheet extends ItemSheet {
 
     if (this.item.isCompetence()) {
       const categorie = event.currentTarget.value;
-      const level =  RdDItemCompetence.getNiveauBase(categorie, this.item.getCategories());
+      const level = RdDItemCompetence.getNiveauBase(categorie, this.item.getCategories());
       this.item.system.base = level;
       this.html.find('[name="system.base"]').val(level);
     }

module/item.js

@@ -220,6 +220,32 @@ export class RdDItem extends Item {
   isService() { return this.type == TYPES.service; }
 
   isCompetence() { return typesObjetsCompetence.includes(this.type) }
+  isEsquive() {
+    return (this.isCompetence()
+      && this.system.categorie == 'melee'
+      && Grammar.includesLowerCaseNoAccent(this.name, 'Esquive'));
+  }
+
+  isCorpsACorps() {
+    return (this.isCompetence()
+      && this.system.categorie == 'melee'
+      && Grammar.includesLowerCaseNoAccent(this.name, 'Corps à Corps'));
+  }
+
+  isCompetenceArme() {
+    if (this.isCompetence()) {
+      switch (this.system.categorie) {
+        case 'melee':
+          return !this.isCorpsACorps() && !this.isEsquive()
+        case 'tir':
+        case 'lancer':
+          return true;
+      }
+    }
+    return false;
+  }
+
+
   isCompetencePossession() { return TYPES.competencecreature == this.type && this.system.categorie == "possession" }
   isTemporel() { return typesObjetsTemporels.includes(this.type) }
   isOeuvre() { return typesObjetsOeuvres.includes(this.type) }
@@ -395,6 +421,16 @@ export class RdDItem extends Item {
     return Math.max(this.system.encombrement ?? 0, 0);
   }
 
+  getEncContenu() {
+    return this.getContenu()
+      .map(it => it.getRecursiveEnc())
+      .reduce(Misc.sum(), 0);
+  }
+
+  getRecursiveEnc() {
+    return this.getEncTotal() + this.getEncContenu()
+  }
+
   getEncHerbe() {
     switch (this.system.categorie) {
       case 'Repos': case 'Soin': case 'Alchimie':
@@ -404,6 +440,18 @@ export class RdDItem extends Item {
 
   }
 
+  getContenu() {
+    if (this.isConteneur()) {
+      return this.system.contenu.map(idContenu => this.actor.getItem(idContenu));
+    }
+    return []
+  }
+
+  isConteneurContenu(conteneur) {
+    return this.getContenu()
+      .find(it => it.id == conteneur.id || it.isConteneurContenu(conteneur))
+  }
+
   valeurTotale() {
     return (this.isService() ? 1 : this.getQuantite()) * this.valeur()
   }
@@ -450,11 +498,11 @@ export class RdDItem extends Item {
     if (this.actor?.isPersonnage()) {
       const warn = options.warnIfNot;
       if (this.getUtilisationCuisine() == 'brut') {
-        return 'Utiliser';
+        return 'Cuisiner';
       }
       switch (this.type) {
         case TYPES.nourritureboisson: return this._actionOrWarnQuantiteZero(this.system.boisson ? 'Boire' : 'Manger', warn);
-        case TYPES.potion: return this._actionOrWarnQuantiteZero('Boire', warn);
+        case TYPES.potion: return this._actionOrWarnQuantiteZero('Consommer', warn);
         case TYPES.livre: return this._actionOrWarnQuantiteZero('Lire', warn);
         case TYPES.herbe: return this.isHerbeAPotion() ? this._actionOrWarnQuantiteZero('Décoction', warn) : undefined;
         case TYPES.queue: case TYPES.ombre: return this.system.refoulement > 0 ? 'Refouler' : undefined;
@@ -465,19 +513,8 @@ export class RdDItem extends Item {
 
   /* -------------------------------------------- */
   async actionPrincipale(actor, onActionItem = async () => { }) {
-    if (!this.getActionPrincipale()) {
-      return;
-    }
-    if (await actor.actionNourritureboisson(this, onActionItem)) {
-      return;
-    }
-    switch (this.type) {
-      case TYPES.potion: return await actor.consommerPotion(this, onActionItem);
-      case TYPES.livre: return await actor.actionLire(this);
-      case TYPES.conteneur: return await this.sheet.render(true);
-      case TYPES.herbe: return await actor.actionHerbe(this, onActionItem);
-      case TYPES.queue: case TYPES.ombre: return await actor.actionRefoulement(this);
-    }
+    if (!this.getActionPrincipale()) { return }
+    await actor?.actionPrincipale(this, onActionItem);
   }
 
   _actionOrWarnQuantiteZero(actionName, warn) {
@@ -675,7 +712,7 @@ export class RdDItem extends Item {
   _armeChatData() {
     return [
       `<b>Compétence</b>: ${this.system.competence}`,
-      `<b>Dommages</b>: ${this.system.dommages}`,
+      `<b>Dommages</b>: ${this.system.dommages} ${this.system.mortalite == 'non-mortel' ? '(Non mortel)' : ''}`,
       `<b>Force minimum</b>: ${this.system.force}`,
       `<b>Resistance</b>: ${this.system.resistance}`,
       ...this._inventaireTemplateChatData()
@@ -760,7 +797,7 @@ export class RdDItem extends Item {
       `<b>Périodicité</b>: ${this.system.periodicite}`,
       `<b>Fatigue</b>: ${this.system.fatigue}`,
       `<b>Difficulté</b>: ${this.system.difficulte}`,
-      RdDItem.propertyIfDefined('Points de Tâche', this.system.points_de_tache, this.system.cacher_points_de_tache),
+      RdDItem.propertyIfDefined('Points de Tâche', this.system.points_de_tache, !this.system.cacher_points_de_tache),
       `<b>Points de Tâche atteints</b>: ${this.system.points_de_tache_courant}`]
   }
   /* -------------------------------------------- */
@@ -769,7 +806,7 @@ export class RdDItem extends Item {
       `<b>Compétence</b>: ${this.system.competence}`,
       `<b>Auteur</b>: ${this.system.auteur}`,
       `<b>Difficulté</b>: ${this.system.difficulte}`,
-      RdDItem.propertyIfDefined('Points de Tâche', this.system.points_de_tache, this.system.cacher_points_de_tache),
+      RdDItem.propertyIfDefined('Points de Tâche', this.system.points_de_tache, !this.system.cacher_points_de_tache),
       ...this._inventaireTemplateChatData()
     ]
   }

module/misc.js

@@ -63,8 +63,8 @@ export class Misc {
 
   static keepDecimals(num, decimals) {
     if (decimals <= 0 || decimals > 6) return num;
-    const decimal = Math.pow(10, parseInt(decimals));
-    return Math.round(num * decimal) / decimal;
+    const power10n = Math.pow(10, parseInt(decimals));
+    return Math.round(num * power10n) / power10n;
   }
 
   static getFractionHtml(diviseur) {

module/rdd-carac.js

@@ -1,7 +1,7 @@
 import { Grammar } from "./grammar.js";
 import { Misc } from "./misc.js";
 
-const tableCaracDerivee = {
+const TABLE_CARACTERISTIQUES_DERIVEES = {
   // xp: coût pour passer du niveau inférieur à ce niveau
   1: { xp: 3, poids: "moins de 1kg", plusdom: -5, sconst: 0.5, sust: 0.1 },
   2: { xp: 3, poids: "1-5", plusdom: -4, sconst: 0.5, sust: 0.3 },
@@ -58,6 +58,10 @@ export class RdDCarac {
       selectedCarac?.label.match(/(Apparence|Force|Agilité|Dextérité|Vue|Ouïe|Odorat-Goût|Empathie|Dérobée|Mêlée|Tir|Lancer)/);
   }
 
+  static getCaracDerivee(value) {
+    return TABLE_CARACTERISTIQUES_DERIVEES[Math.min(Math.max(Number(value), 1), 32)];
+  }
+
   static computeTotal(carac, beaute = undefined) {
     const total = Object.values(carac ?? {}).filter(c => !c.derivee)
       .map(it => parseInt(it.value))
@@ -73,7 +77,7 @@ export class RdDCarac {
 
   /* -------------------------------------------- */
   static calculSConst(constitution) {
-    return Number(tableCaracDerivee[Number(constitution)].sconst);
+    return RdDCarac.getCaracDerivee(constitution).sconst;
   }
 
   /* -------------------------------------------- */
@@ -84,7 +88,7 @@ export class RdDCarac {
   }
 
   static getCaracXp(targetValue) {
-    return tableCaracDerivee[targetValue]?.xp ?? 200;
+    return RdDCarac.getCaracDerivee(targetValue)?.xp ?? 200;
   }
 
 
@@ -97,37 +101,4 @@ export class RdDCarac {
     return Grammar.toLowerCaseNoAccent(selectedCarac?.label)?.match(/(apparence|force|agilite|dexterite|vue|ouie|odorat|empathie|melee|tir|lancer|derobee)/);
   }
 
-  /* -------------------------------------------- */
-  static computeCarac(system) {
-    system.carac.force.value = Math.min(system.carac.force.value, parseInt(system.carac.taille.value) + 4);
-
-    system.carac.derobee.value = Math.floor(parseInt(((21 - system.carac.taille.value)) + parseInt(system.carac.agilite.value)) / 2);
-    let bonusDomKey = Math.floor((parseInt(system.carac.force.value) + parseInt(system.carac.taille.value)) / 2);
-    bonusDomKey = Math.min(Math.max(bonusDomKey, 0), 32); // Clamp de securite
-
-    let tailleData = tableCaracDerivee[bonusDomKey];
-    system.attributs.plusdom.value = tailleData.plusdom;
-
-    system.attributs.sconst.value = RdDCarac.calculSConst(system.carac.constitution.value);
-    system.attributs.sust.value = tableCaracDerivee[Number(system.carac.taille.value)].sust;
-
-    system.attributs.encombrement.value = (parseInt(system.carac.force.value) + parseInt(system.carac.taille.value)) / 2;
-    system.carac.melee.value = Math.floor((parseInt(system.carac.force.value) + parseInt(system.carac.agilite.value)) / 2);
-    system.carac.tir.value = Math.floor((parseInt(system.carac.vue.value) + parseInt(system.carac.dexterite.value)) / 2);
-    system.carac.lancer.value = Math.floor((parseInt(system.carac.tir.value) + parseInt(system.carac.force.value)) / 2);
-
-    system.sante.vie.max = Math.ceil((parseInt(system.carac.taille.value) + parseInt(system.carac.constitution.value)) / 2);
-
-    system.sante.vie.value = Math.min(system.sante.vie.value, system.sante.vie.max)
-    system.sante.endurance.max = Math.max(parseInt(system.carac.taille.value) + parseInt(system.carac.constitution.value), parseInt(system.sante.vie.max) + parseInt(system.carac.volonte.value));
-    system.sante.endurance.value = Math.min(system.sante.endurance.value, system.sante.endurance.max);
-    system.sante.fatigue.max = system.sante.endurance.max * 2;
-    system.sante.fatigue.value = Math.min(system.sante.fatigue.value, system.sante.fatigue.max);
-
-    //Compteurs
-    system.reve.reve.max = system.carac.reve.value;
-    system.compteurs.chance.max = system.carac.chance.value;
-  }
-
-
 }

module/rdd-combat.js

@@ -87,7 +87,7 @@ export class RdDCombatManager extends Combat {
       let rollFormula = formula ?? RdDCombatManager.formuleInitiative(2, 10, 0, 0);
       if (!formula) {
         if (combatant.actor.type == 'creature' || combatant.actor.type == 'entite') {
-          const competence = combatant.actor.items.find(it => RdDItemCompetenceCreature.getCategorieAttaque(it))
+          const competence = combatant.actor.items.find(it => RdDItemCompetenceCreature.isCompetenceAttaque(it))
           if (competence) {
             rollFormula = RdDCombatManager.formuleInitiative(2, competence.system.carac_value, competence.system.niveau, 0);
           }
@@ -171,8 +171,7 @@ export class RdDCombatManager extends Combat {
         if (arme.system.unemain && arme.system.deuxmains && !dommages.includes("/")) {
           ui.notifications.info("Les dommages de l'arme à 1/2 mains " + arme.name + " ne sont pas corrects (ie sous la forme X/Y)");
         }
-        if ((arme.system.unemain && arme.system.competence) ||
-          (arme.system.competence.toLowerCase().includes("corps à corps"))) {
+        if (arme.system.unemain && arme.system.competence) {
           actions.push(RdDCombatManager.$prepareAttaqueArme({
             arme: arme,
             infoMain: "(1 main)",
@@ -187,7 +186,7 @@ export class RdDCombatManager extends Combat {
             arme: arme,
             infoMain: "(2 mains)",
             dommagesReel: Number(tableauDommages[1]),
-            competence: arme.system.competence.replace(" 1 main", " 2 mains"),
+            competence: RdDItemArme.competence2Mains(arme),
             carac: carac,
             competences: competences
           }));
@@ -230,7 +229,9 @@ export class RdDCombatManager extends Combat {
   }
 
   static listActionsCreature(competences) {
-    return competences.map(it => RdDItemCompetenceCreature.armeCreature(it))
+    return competences
+      .filter(it => RdDItemCompetenceCreature.isCompetenceAttaque(it))
+      .map(it => RdDItemCompetenceCreature.armeCreature(it))
       .filter(it => it != undefined);
   }
 
@@ -258,11 +259,10 @@ export class RdDCombatManager extends Combat {
       actions = RdDCombatManager.listActionsCreature(actor.itemTypes['competencecreature']);
     } else if (actor.isPersonnage()) {
       // Recupération des items 'arme'
-      const armes = actor.itemTypes['arme'].filter(it => RdDItemArme.isArmeUtilisable(it))
-        .concat(RdDItemArme.empoignade())
-        .concat(RdDItemArme.mainsNues());
-
       const competences = actor.itemTypes['competence'];
+      const armes = actor.itemTypes['arme'].filter(it => RdDItemArme.isArmeUtilisable(it))
+        .concat(RdDItemArme.empoignade(actor))
+        .concat(RdDItemArme.mainsNues(actor));
       actions = RdDCombatManager.listActionsArmes(armes, competences, actor.system.carac);
 
       if (actor.system.attributs.hautrevant.value) {
@@ -450,7 +450,7 @@ export class RdDCombat {
     if (Misc.isUniqueConnectedGM()) {
       let turn = combat.turns.find(t => t.token?.id == combat.current.tokenId);
       if (turn?.actor) {
-        RdDCombat.displayActorCombatStatus(combat, turn.actor);
+        RdDCombat.displayActorCombatStatus(combat, turn.actor, turn.token.id);
         // TODO Playaudio for player??
       }
     }
@@ -514,8 +514,12 @@ export class RdDCombat {
   /* -------------------------------------------- */
   static _callJetDeVie(event) {
     let actorId = event.currentTarget.attributes['data-actorId'].value;
-    let actor = game.actors.get(actorId);
-    actor.jetVie();
+    let tokenId = event.currentTarget.attributes['data-tokenId'].value;
+    let token = canvas.tokens.placeables.find(t => t.id == tokenId)
+    const actor = token?.actor ?? game.actors.get(actorId);
+    if (actor?.isOwner) {
+      actor.jetVie();
+    }
   }
 
   /* -------------------------------------------- */
@@ -541,7 +545,7 @@ export class RdDCombat {
         }
       });
     }
-    html.on("click", '#chat-jet-vie', event => {
+    html.on("click", 'a.chat-jet-vie', event => {
       event.preventDefault();
       RdDCombat._callJetDeVie(event);
     });
@@ -789,8 +793,7 @@ export class RdDCombat {
     let rollData = {
       passeArme: randomID(16),
       mortalite: arme?.system.mortalite,
-      coupsNonMortels: false,
-      competence: competence.clone(),
+      competence: competence,
       surprise: this.attacker.getSurprise(true),
       surpriseDefenseur: this.defender.getSurprise(true),
       targetToken: Targets.extractTokenData(this.target),
@@ -821,8 +824,8 @@ export class RdDCombat {
     // finesse seulement en mélée, pour l'empoignade, ou si la difficulté libre est de -1 minimum
     // rapidité seulement en mêlée, si l'arme le permet, et si la difficulté libre est de -1 minimum
     const isForce = !rollData.arme.system.empoignade;
-    const isFinesse = rollData.arme.system.empoignade || isMeleeDiffNegative;
-    const isRapide = !rollData.arme.system.empoignade && isMeleeDiffNegative && rollData.arme.system.rapide;
+    const isFinesse = rollData.tactique != 'charge' && (rollData.arme.system.empoignade || isMeleeDiffNegative);
+    const isRapide = rollData.tactique != 'charge' && !rollData.arme.system.empoignade && isMeleeDiffNegative && rollData.arme.system.rapide;
     // si un seul choix possible, le prendre
     if (isForce && !isFinesse && !isRapide) {
       return await this.choixParticuliere(rollData, "force");
@@ -886,8 +889,8 @@ export class RdDCombat {
     }
 
     // # utilisation esquive
-    const corpsACorps = this.defender.getCompetence("Corps à corps", { onMessage: it => console.info(it, this.defender) });
-    const esquives = duplicate(this.defender.getCompetences("esquive", { onMessage: it => console.info(it, this.defender) }))
+    const corpsACorps = this.defender.getCompetenceCorpsACorps({ onMessage: it => console.info(it, this.defender) });
+    const esquives = duplicate(this.defender.getCompetencesEsquive())
     esquives.forEach(e => e.system.nbUsage = e?._id ? this.defender.getItemUse(e._id) : 0);
 
     const paramChatDefense = {
@@ -1045,7 +1048,7 @@ export class RdDCombat {
       passeArme: attackerRoll.passeArme,
       diffLibre: attackerRoll.diffLibre,
       attackerRoll: attackerRoll,
-      competence: this.defender.getCompetence(competenceParade).clone(),
+      competence: this.defender.getCompetence(competenceParade),
       arme: armeParade,
       surprise: this.defender.getSurprise(true),
       needParadeSignificative: ReglesOptionnelles.isUsing('categorieParade') && RdDItemArme.needParadeSignificative(attackerRoll.arme, armeParade),
@@ -1126,7 +1129,7 @@ export class RdDCombat {
       passeArme: attackerRoll.passeArme,
       diffLibre: attackerRoll.diffLibre,
       attackerRoll: attackerRoll,
-      competence: competence.clone(),
+      competence: competence,
       surprise: this.defender.getSurprise(true),
       surpriseDefenseur: this.defender.getSurprise(true),
       carac: this.defender.system.carac,
@@ -1295,7 +1298,7 @@ export class RdDCombat {
   }
 
   /* -------------------------------------------- */
-  static async displayActorCombatStatus(combat, actor) {
+  static async displayActorCombatStatus(combat, actor, tokenId) {
     let formData = {
       combatId: combat._id,
       alias: actor.name,
@@ -1304,12 +1307,18 @@ export class RdDCombat {
       blessuresStatus: actor.computeResumeBlessure(),
       SConst: actor.getSConst(),
       actorId: actor.id,
+      tokenId: tokenId,
       isGrave: actor.countBlessures(it => it.isGrave()) > 0,
       isCritique: actor.countBlessures(it => it.isCritique()) > 0
     }
-
-    ChatUtility.createChatWithRollMode(actor.name, {
-      content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-actor-turn-summary.html`, formData)
+    await ChatMessage.create({
+      content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-actor-turn-acteur.hbs`, formData),
+      alias: actor.name
+    });
+    await ChatMessage.create({
+      content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-actor-turn-sante.hbs`, formData),
+      whisper: ChatUtility.getWhisperRecipientsAndGMs(actor.name),
+      alias: actor.name
     });
   }
-}
+}

module/rdd-empoignade.js

@@ -181,7 +181,7 @@ export class RdDEmpoignade {
     let rollData = {
       mode, empoignade, attacker, defender,
       isEmpoignade: true,
-      competence: attacker.getCompetence("Corps à corps").clone(),
+      competence: attacker.getCompetenceCorpsACorps(),
       selectedCarac: attacker.system.carac.melee,
       malusTaille: RdDEmpoignade.getMalusTaille(empoignade, attacker, defender)
     }
@@ -210,7 +210,7 @@ export class RdDEmpoignade {
       mode: "immobilise",
       empoignade, attacker, defender,
       isEmpoignade: true,
-      competence: attacker.getCompetence("Corps à corps").clone()
+      competence: attacker.getCompetenceCorpsACorps()
     }
     const msg = await ChatMessage.create({
       whisper: ChatUtility.getWhisperRecipientsAndGMs(attacker.name),
@@ -272,7 +272,7 @@ export class RdDEmpoignade {
       mode, attacker, defender, empoignade, attackerRoll,
       diffLibre: attackerRoll.diffLibre,
       attaqueParticuliere: attackerRoll.particuliere,
-      competence: defender.getCompetence(competenceName).clone(),
+      competence: defender.getCompetence(competenceName),
       surprise: defender.getSurprise(true),
       carac: defender.system.carac,
       selectedCarac: defender.system.carac[carac],

module/rdd-hotbar-drop.js

@@ -1,12 +1,17 @@
+import { RdDItemArme } from "./item-arme.js";
+import { RdDItemCompetenceCreature } from "./item-competencecreature.js";
+import { TYPES } from "./item.js";
 
 export class RdDHotbar {
 
-  static async addToHotbar(item, slot) {
-    let command = `game.system.rdd.RdDHotbar.rollMacro("${item.name}", "${item.type}");`;
-    let macro = game.macros.contents.find(m => (m.name === item.name) && (m.command === command));
+  static async createItemMacro(item, slot, armeCompetence = undefined) {
+    const itemName = item.name;
+    let macroName = itemName + RdDHotbar.$macroNameSuffix(armeCompetence);
+    let command = `game.system.rdd.RdDHotbar.rollMacro("${itemName}", "${item.type}", "${armeCompetence}");`
+    let macro = game.macros.contents.find(m => (m.name === itemName) && (m.command === command));
     if (!macro) {
       macro = await Macro.create({
-        name: item.name,
+        name: macroName,
         type: "script",
         img: item.img,
         command: command
@@ -15,6 +20,59 @@ export class RdDHotbar {
     await game.user.assignHotbarMacro(macro, slot);
   }
 
+  static $macroNameSuffix(armeCompetence) {
+    switch (armeCompetence) {
+      case 'unemain': return ' (1 main)';
+      case 'deuxmains': return ' (2 main)';
+      case 'tir': return ' (tir)';
+      case 'lancer': return ' (lancer)';
+      case 'pugilat': return ' (pugilat)';
+      case 'empoignade': return ' (empoignade)';
+
+    }
+    return ''
+  }
+
+  static async addToHotbar(item, slot) {
+    switch (item?.type ?? '') {
+      case TYPES.arme:
+        {
+          // Les armes peuvent avoir plusieurs usages
+          if (item.system.competence != '') {
+            if (item.system.unemain) {
+              await this.createItemMacro(item, slot++, 'unemain')
+            }
+            if (item.system.deuxmains) {
+              await this.createItemMacro(item, slot++, 'deuxmains')
+            }
+          }
+          if (item.system.lancer != '') {
+            await this.createItemMacro(item, slot++, 'lancer')
+          }
+          if (item.system.tir != '') {
+            await this.createItemMacro(item, slot++, 'lancer')
+          }
+        }
+        return
+      case TYPES.competencecreature:
+        const categorie = RdDItemCompetenceCreature.getCategorieAttaque(item) ?? 'competence';
+        await this.createItemMacro(item, slot, categorie)
+        return
+      default:
+      case TYPES.competence:
+        await this.createItemMacro(item, slot++, 'competence')
+        if (item.isCorpsACorps()) {
+          await this.createItemMacro(item, slot++, 'pugilat')
+          await this.createItemMacro(item, slot++, 'empoignade')
+        }
+        if (item.isCompetenceArme()) {
+          ui.notifications.info(`${item.name} est une compétence d'arme, la macro n'est pas liée à un arme.<br>
+          Créez la macro depuis l'arme ou l'onglet combat pour garder les automatisations de combat.`);
+        }
+        return
+    }
+  }
+
   /**
    * Create a macro when dropping an entity on the hotbar
    * Item      - open roll dialog for item
@@ -23,20 +81,19 @@ export class RdDHotbar {
    */
   static initDropbar() {
 
-    Hooks.on("hotbarDrop", (bar, documentData, slot) => {
+    Hooks.on('hotbarDrop', (bar, documentData, slot) => {
 
       // Create item macro if rollable item - weapon, spell, prayer, trait, or skill
-      if (documentData.type == "Item") {
-        let item = fromUuidSync(documentData.uuid)
-        if (item == undefined) {
-          item = this.actor.items.get(documentData.uuid)
+      if (documentData.type == 'Item') {
+        const item = fromUuidSync(documentData.uuid) ?? this.actor.items.get(documentData.uuid)
+        console.log('DROP', documentData, item)
+        switch (item?.type) {
+          case TYPES.arme:
+          case TYPES.competence:
+          case TYPES.competencecreature:
+            this.addToHotbar(item, slot)
+            return false
         }
-        console.log("DROP", documentData, item)
-        if (!item || (item.type != "arme" && item.type != "competence")) {
-          return true
-        }
-        this.addToHotbar(item, slot)
-        return false
       }
 
       return true
@@ -44,12 +101,14 @@ export class RdDHotbar {
   }
 
   /** Roll macro */
-  static rollMacro(itemName, itemType, bypassData) {
+  static rollMacro(itemName, itemType, categorieArme = 'competence') {
     const speaker = ChatMessage.getSpeaker();
     let actor;
     if (speaker.token) actor = game.actors.tokens[speaker.token];
     if (!actor) actor = game.actors.get(speaker.actor);
-
+    if (!actor) {
+      return ui.notifications.warn(`Impossible de trouver le personnage concerné`);
+    }
     let item = actor?.items.find(it => it.name === itemName && it.type == itemType) ?? undefined;
     if (!item) {
       return ui.notifications.warn(`Impossible de trouver l'objet de cette macro`);
@@ -57,10 +116,23 @@ export class RdDHotbar {
 
     // Trigger the item roll
     switch (item.type) {
-      case "arme":
-        return actor.rollArme(item);
-      case "competence":
-        return actor.rollCompetence(itemName);
+      case TYPES.arme:
+        return actor.rollArme(item, categorieArme);
+      case TYPES.competence:
+        if (item.isCorpsACorps()) {
+          switch (categorieArme) {
+            case 'pugilat':
+              return actor.rollArme(RdDItemArme.mainsNues(actor), 'competence');
+            case 'empoignade':
+              return actor.rollArme(RdDItemArme.empoignade(actor), 'competence');
+          }
+        }
+        return actor.rollCompetence(item);
+      case TYPES.competencecreature:
+        return item.system.iscombat && !item.system.isparade
+          ? actor.rollArme(item, categorieArme)
+          : actor.rollCompetence(item);
+
     }
   }
 

module/rdd-main.js

@@ -29,11 +29,13 @@ import { Environnement } from "./environnement.js";
 import { RdDActor } from "./actor.js";
 import { RdDBaseActor } from "./actor/base-actor.js";
 import { RdDCommerce } from "./actor/commerce.js";
+import { RdDEntite } from "./actor/entite.js";
+import { RdDVehicule } from "./actor/vehicule.js";
 import { RdDActorSheet } from "./actor-sheet.js";
 import { RdDCommerceSheet } from "./actor/commerce-sheet.js";
-import { RdDActorCreatureSheet } from "./actor-creature-sheet.js";
-import { RdDActorVehiculeSheet } from "./actor-vehicule-sheet.js";
-import { RdDActorEntiteSheet } from "./actor-entite-sheet.js";
+import { RdDCreatureSheet } from "./actor/creature-sheet.js";
+import { RdDActorEntiteSheet } from "./actor/entite-sheet.js";
+import { RdDActorVehiculeSheet } from "./actor/vehicule-sheet.js";
 
 import { RdDItem } from "./item.js";
 import { RdDItemBlessure } from "./item/blessure.js";
@@ -59,6 +61,8 @@ import { RdDSigneDraconiqueItemSheet } from "./item/sheet-signedraconique.js";
 import { RdDItemInventaireSheet } from "./item/sheet-base-inventaire.js";
 import { AppAstrologie } from "./sommeil/app-astrologie.js";
 import { RdDItemArmure } from "./item/armure.js";
+import { AutoAdjustDarkness as AutoAdjustDarkness } from "./time/auto-adjust-darkness.js";
+import { RdDCreature } from "./actor/creature.js";
 
 /**
  * RdD system
@@ -90,10 +94,10 @@ export class SystemReveDeDragon {
     }
     this.actorClasses = {
       commerce: RdDCommerce,
-      creature: RdDActor,
-      entite: RdDActor,
+      creature: RdDCreature,
+      entite: RdDEntite,
       personnage: RdDActor,
-      vehicule: RdDActor,
+      vehicule: RdDVehicule,
     }
   }
 
@@ -149,7 +153,7 @@ export class SystemReveDeDragon {
     Actors.unregisterSheet("core", ActorSheet);
     Actors.registerSheet(SYSTEM_RDD, RdDCommerceSheet, { types: ["commerce"], makeDefault: true });
     Actors.registerSheet(SYSTEM_RDD, RdDActorSheet, { types: ["personnage"], makeDefault: true });
-    Actors.registerSheet(SYSTEM_RDD, RdDActorCreatureSheet, { types: ["creature"], makeDefault: true });
+    Actors.registerSheet(SYSTEM_RDD, RdDCreatureSheet, { types: ["creature"], makeDefault: true });
     Actors.registerSheet(SYSTEM_RDD, RdDActorVehiculeSheet, { types: ["vehicule"], makeDefault: true });
     Actors.registerSheet(SYSTEM_RDD, RdDActorEntiteSheet, { types: ["entite"], makeDefault: true });
     Items.unregisterSheet("core", ItemSheet);
@@ -182,6 +186,7 @@ export class SystemReveDeDragon {
     CONFIG.Combat.documentClass = RdDCombatManager;
 
     // préparation des différents modules
+    AutoAdjustDarkness.init();
     RdDTimestamp.init();
     RdDCalendrier.init();
     SystemCompendiums.init();

module/rdd-possession.js

@@ -39,7 +39,7 @@ export class RdDPossession {
     let rollData = {
       mode: "attaque",
       isECNIDefender: false,
-      competence: competence.clone(),
+      competence: competence,
       possession: possession,
       attacker: attacker,
       defender: defender,

module/rdd-resolution-table.js

@@ -28,7 +28,7 @@ const reussites = [
 
 const reussiteInsuffisante = { code: "notSign", isPart: false, isSign: false, isSuccess: false, isEchec: true, isEPart: false, isETotal: false, ptTache: 0, ptQualite: -2, quality: "Réussite insuffisante", condition: (target, roll) => false }
 /* -------------------------------------------- */
-const caracMaximumResolution = 60;
+const CARAC_MAXIMUM_RESOLUTION = 40;
 /* -------------------------------------------- */
 export class RdDResolutionTable {
   static resolutionTable = this.build()
@@ -36,7 +36,7 @@ export class RdDResolutionTable {
   /* -------------------------------------------- */
   static build() {
     let table = []
-    for (var caracValue = 0; caracValue <= caracMaximumResolution; caracValue++) {
+    for (var caracValue = 0; caracValue <= CARAC_MAXIMUM_RESOLUTION; caracValue++) {
       table[caracValue] = this._computeRow(caracValue);
     }
     return table;

module/rdd-roll-resolution-table.js

@@ -112,7 +112,7 @@ export class RdDRollResolutionTable extends Dialog {
   async updateRollResult() {
     let rollData = this.rollData;
     rollData.caracValue = parseInt(rollData.selectedCarac.value)
-    rollData.finalLevel = this._computeFinalLevel(rollData);
+    rollData.finalLevel = Misc.toInt(rollData.diffConditions) + Misc.toInt(rollData.diffLibre);
 
     const htmlTable = await RdDResolutionTable.buildHTMLTable({
       carac: rollData.caracValue,
@@ -129,12 +129,6 @@ export class RdDRollResolutionTable extends Dialog {
   }
 
   /* -------------------------------------------- */
-  _computeFinalLevel(rollData) {
-    const diffConditions = Misc.toInt(rollData.diffConditions);
-    const diffLibre = Misc.toInt(rollData.diffLibre);
-
-    return diffLibre + diffConditions;
-  }
 
   async close() {
     await super.close();

module/rdd-roll.js

@@ -22,7 +22,7 @@ export class RdDRoll extends Dialog {
 
     const html = await renderTemplate(dialogConfig.html, rollData);
 
-    let options = { classes: ["rdd-roll-dialog"], width: 600, height: 'fit-content', 'z-index': 99999, close: html => {} };
+    let options = { classes: ["rdd-roll-dialog"], width: 650, height: 'fit-content', 'z-index': 99999, close: html => {} };
     if (dialogConfig.close) {
       options.close = dialogConfig.close;
     }
@@ -50,8 +50,6 @@ export class RdDRoll extends Dialog {
         encTotal: true
       },
       isMalusEncombrementTotal: RdDItemCompetence.isMalusEncombrementTotal(rollData.competence),
-      malusArmureValue: actor.getMalusArmure(),
-      surencMalusValue: actor.computeMalusSurEncombrement(),
       encTotal: actor.getEncTotal(),
       ajustementAstrologique: actor.ajustementAstrologique(),
       surprise: actor.getSurprise(false),
@@ -187,7 +185,7 @@ export class RdDRoll extends Dialog {
       console.log("RdDRollSelectDialog - Cout reve", ptreve);
       this.updateRollResult(html);
     });
-    this.html.find("[name='coupsNonMortels']").change((event) => {
+    this.html.find("input.check-mortalite").change((event) => {
       this.rollData.dmg.mortalite = event.currentTarget.checked ? "non-mortel" : "mortel";
       this.updateRollResult(html);
     });
@@ -291,36 +289,31 @@ export class RdDRoll extends Dialog {
 
   /* -------------------------------------------- */
   async updateRollResult(html) {
-    let rollData = this.rollData;
+    const rollData = this.rollData;
 
     rollData.dmg = rollData.attackerRoll?.dmg ?? RdDBonus.dmg(rollData, this.actor.getBonusDegat())
     rollData.caracValue = parseInt(rollData.selectedCarac.value)
-    rollData.mortalite = rollData.attackerRoll?.dmg.mortalite ?? rollData.dmg.mortalite ?? 'mortel';
-    rollData.coupsNonMortels = (rollData.attackerRoll?.dmg.mortalite ?? rollData.dmg.mortalite) == 'non-mortel';
+    rollData.dmg.mortalite = rollData.dmg.mortalite ?? 'mortel';
     rollData.use.appelAuMoral = this.actor.isPersonnage() && RdDCarac.isActionPhysique(rollData.selectedCarac);
-    let dmgText = Misc.toSignedString(rollData.dmg.total);
-
-    switch (rollData.mortalite) {
-      case 'non-mortel': dmgText = `(${dmgText}) non-mortel`; break;
-      case 'empoignade': dmgText = `empoignade`; break;
-    }
 
     RollDataAjustements.calcul(rollData, this.actor);
-    rollData.finalLevel = this._computeFinalLevel(rollData);
 
     const resolutionTable = await RdDResolutionTable.buildHTMLTable(RdDResolutionTable.subTable(rollData.caracValue, rollData.finalLevel))
     const adjustements = await this.buildAjustements(rollData);
-
+    
     HtmlUtility.showControlWhen(this.html.find(".use-encTotal"), rollData.ajustements.encTotal.visible && RdDCarac.isAgiliteOuDerobee(rollData.selectedCarac));
     HtmlUtility.showControlWhen(this.html.find(".use-surenc"), rollData.ajustements.surenc.visible && RdDCarac.isActionPhysique(rollData.selectedCarac));
     HtmlUtility.showControlWhen(this.html.find(".utilisation-moral"), rollData.use.appelAuMoral);
     HtmlUtility.showControlWhen(this.html.find(".divAppelAuMoral"), rollData.use.appelAuMoral);
-    HtmlUtility.showControlWhen(this.html.find(".diffMoral"), rollData.ajustements.moralTotal.used);
+    // HtmlUtility.showControlWhen(this.html.find(".diffMoral"), rollData.ajustements.moral.used);
 
     // Mise à jour valeurs
     this.html.find(".dialog-roll-title").text(this._getTitle(rollData));
-    this.html.find("[name='coupsNonMortels']").prop('checked', rollData.mortalite == 'non-mortel');
-    this.html.find(".dmg-arme-actor").text(dmgText);
+    this.html.find("input.check-mortalite").prop('checked', rollData.dmg.mortalite == 'non-mortel');
+    this.html.find("label.dmg-arme-actor").text(rollData.dmg.mortalite == 'empoignade'? 'empoignade': Misc.toSignedString(rollData.dmg.total) );
+    this.html.find("label.arme-mortalite").text(rollData.dmg.mortalite);
+    // this.html.find("[name='dmg-arme-actor']").text(rollData.dmg.mortalite == 'empoignade'? 'empoignade': Misc.toSignedString(rollData.dmg.total) );
+    // this.html.find("[name='arme-mortalite']").text(rollData.dmg.mortalite);
     this.html.find("div.placeholder-ajustements").empty().append(adjustements);
     this.html.find("div.placeholder-resolution").empty().append(resolutionTable)
   }
@@ -331,30 +324,6 @@ export class RdDRoll extends Dialog {
     return await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/partial-roll-ajustements.html`, rollData);
   }
 
-  /* -------------------------------------------- */
-  _computeFinalLevel(rollData) {
-    return RollDataAjustements.sum(rollData.ajustements);
-  }
-  /* -------------------------------------------- */
-  _computeDiffCompetence(rollData) {
-    if (rollData.competence) {
-      return Misc.toInt(rollData.competence.system.niveau);
-    }
-    if (rollData.draconicList) {
-      return Misc.toInt(rollData.competence.system.niveau);
-    }
-    return 0;
-  }
-
-  /* -------------------------------------------- */
-  _computeMalusArmure(rollData) {
-    let malusArmureValue = 0;
-    if (rollData.malusArmureValue && (rollData.selectedCarac.label == "Agilité" || rollData.selectedCarac.label == "Dérobée")) {
-      malusArmureValue = rollData.malusArmureValue;
-    }
-    return malusArmureValue;
-  }
-
   /* -------------------------------------------- */
   _getTitle(rollData) {
     const carac = rollData.selectedCarac.label;
@@ -362,16 +331,19 @@ export class RdDRoll extends Dialog {
       return carac;
     }
     const compName = rollData.competence.name;
-    if (rollData.draconicList && rollData.selectedSort) {
-      return compName + " - " + rollData.selectedSort.name;
-    }
-    // If a weapon is there, add it in the title
     const niveau = Misc.toSignedString(rollData.competence.system.niveau)
     if (compName == carac) {
       // cas des créatures
-      return carac + " Niveau " + niveau
+      return `${carac} Niveau ${niveau}`
     }
-    const armeTitle = (rollData.arme) ? " (" + rollData.arme.name + ") " : "";
-    return carac + "/" + compName + armeTitle + " Niveau " + niveau
+    if (rollData.draconicList && rollData.selectedSort) {
+      // cas de lancer de sort
+      return `${rollData.competence.name} Niveau ${niveau} ${rollData.selectedSort.name}`
+    }
+    if (rollData.arme && rollData.arme.name != compName) {
+      // ajouter l'arme au titre si son nom n'est pas la compétence
+      return `${carac} /  ${compName} (${rollData.arme.name}) Niveau ${niveau}`
+    }
+    return `${carac} / ${compName} Niveau ${niveau}`
   }
 }

module/rdd-tmr-dialog.js

@@ -2,7 +2,6 @@ import { SHOW_DICE } from "./constants.js";
 import { RollDataAjustements } from "./rolldata-ajustements.js";
 import { RdDUtility } from "./rdd-utility.js";
 import { TMRUtility } from "./tmr-utility.js";
-import { tmrConstants } from "./tmr-constants.js";
 import { RdDResolutionTable } from "./rdd-resolution-table.js";
 import { RdDTMRRencontreDialog } from "./rdd-tmr-rencontre-dialog.js";
 import { ChatUtility } from "./chat-utility.js";
@@ -39,14 +38,16 @@ export class RdDTMRDialog extends Dialog {
       title: "Terres Médianes de Rêve",
       content: html,
       buttons: {
-        closeButton: { label: "Fermer", callback: html => this.close(html) }
+        closeButton: {
+          label: "Fermer", callback: html => this.close()
+        }
       },
       default: "closeButton"
     }
 
     const dialogOptions = {
       classes: ["tmrdialog"],
-      width: 920, height: 980,
+      width: 920, maxheight: 1024, height: 'fit-content',
       'z-index': 40
     }
     super(dialogConf, dialogOptions);
@@ -55,15 +56,15 @@ export class RdDTMRDialog extends Dialog {
     this.actor = actor;
     this.actor.tmrApp = this; // reference this app in the actor structure
     this.viewOnly = tmrData.mode == "visu"
-    this.fatigueParCase = this.viewOnly || !ReglesOptionnelles.isUsing("appliquer-fatigue") ? 0 : this.actor.getTMRFatigue();
+    this.fatigueParCase = this.viewOnly ? 0 : this.actor.getCoutFatigueTMR();
     this.cumulFatigue = 0;
     this.loadRencontres();
     this.loadCasesSpeciales();
     this.allTokens = [];
     this.rencontreState = 'aucune';
-    this.pixiApp = new PIXI.Application({ width: 720, height: 860 });
+    this.pixiTMR = new PixiTMR(this);
 
-    this.pixiTMR = new PixiTMR(this, this.pixiApp);
+    this.subdialog = undefined
 
     this.callbacksOnAnimate = [];
     if (!this.viewOnly) {
@@ -74,6 +75,31 @@ export class RdDTMRDialog extends Dialog {
     this.pixiTMR.load((loader, resources) => this.createPixiSprites());
   }
 
+  async forceTMRDisplay() {
+    this.bringToTop();
+    if (this.subdialog) {
+      this.subdialog.bringToTop();
+    }
+  }
+  async restoreTMRAfterAction() {
+    this.subdialog = undefined
+    await this.maximize();
+    this.bringToTop();
+  }
+
+  forceTMRContinueAction() {
+    ui.notifications.warn('Vous devez finir votre action avant de continuer dans les TMR');
+    this.subdialog.bringToTop();
+    return;
+  }
+
+  setTMRPendingAction(dialog) {
+    this.subdialog = dialog
+    if (dialog instanceof Application) {
+      dialog.bringToTop();
+    }
+  }
+
   isDemiReveCache() {
     return !game.user.isGM && this.actor.isTMRCache();
   }
@@ -102,7 +128,7 @@ export class RdDTMRDialog extends Dialog {
 
   /* -------------------------------------------- */
   createPixiSprites() {
-    EffetsDraconiques.carteTmr.createSprite(this.pixiTMR);
+    this.pixiTMR.setup()
     this.updateTokens();
     this.forceDemiRevePositionView();
   }
@@ -113,13 +139,9 @@ export class RdDTMRDialog extends Dialog {
       this.demiReve = this._tokenDemiReve();
       this._trackToken(this.demiReve);
     }
-    let tokens = this._getTokensCasesTmr()
-      .concat(this._getTokensRencontres())
-      .concat(this._getTokensSortsReserve());
-
-    for (let t of tokens) {
-      this._trackToken(t);
-    }
+    this._getTokensCasesTmr().forEach(t => this._trackToken(t))
+    this._getTokensRencontres().forEach(t => this._trackToken(t))
+    this._getTokensSortsReserve().forEach(t => this._trackToken(t))
   }
 
   /* -------------------------------------------- */
@@ -175,6 +197,10 @@ export class RdDTMRDialog extends Dialog {
 
   /* -------------------------------------------- */
   async moveFromKey(move) {
+    if (this.subdialog) {
+      return this.forceTMRContinueAction();
+    }
+
     let oddq = TMRUtility.coordTMRToOddq(this._getActorCoord());
 
     if (move == 'top') oddq.row -= 1;
@@ -199,7 +225,10 @@ export class RdDTMRDialog extends Dialog {
     super.activateListeners(html);
     this.html = html;
 
-    document.getElementById("tmrrow1").insertCell(0).append(this.pixiApp.view);
+    document.getElementsByClassName("tmr-row")
+      .item(0)
+      .insertCell(0)
+      .append(this.pixiTMR.view);
 
     if (this.viewOnly) {
       this.html.find('.lancer-sort').remove();
@@ -210,28 +239,22 @@ export class RdDTMRDialog extends Dialog {
     HtmlUtility.showControlWhen(this.html.find(".appliquerFatigue"), ReglesOptionnelles.isUsing("appliquer-fatigue"));
     HtmlUtility.showControlWhen(this.html.find(".lire-signe-draconique"), this.actor.isResonanceSigneDraconique(this._getActorCoord()));
 
-    // Roll Sort
-    this.html.find('.lancer-sort').click((event) => {
-      this.actor.rollUnSort(this._getActorCoord());
-    });
-    this.html.find('.lire-signe-draconique').click((event) => {
-      this.actor.rollLireSigneDraconique(this._getActorCoord());
-    });
+    this.html.find('tr.tmr-row *').click(event => this.subdialog?.bringToTop());
 
-    this.html.find('#dir-top').click((event) => this.moveFromKey("top"));
-    this.html.find('#dir-top-left').click((event) => this.moveFromKey("top-left"));
-    this.html.find('#dir-top-right').click((event) => this.moveFromKey("top-right"));
-    this.html.find('#dir-bottom-left').click((event) => this.moveFromKey("bottom-left"));
-    this.html.find('#dir-bottom-right').click((event) => this.moveFromKey("bottom-right"));
-    this.html.find('#dir-bottom').click((event) => this.moveFromKey("bottom"));
+    // Roll Sort
+    this.html.find('.lancer-sort').click(event => this.actor.rollUnSort(this._getActorCoord()));
+    this.html.find('.lire-signe-draconique').click(event => this.actor.rollLireSigneDraconique(this._getActorCoord()));
+    this.html.find('#dir-top').click(event=> this.moveFromKey("top"));
+    this.html.find('#dir-top-left').click(event=> this.moveFromKey("top-left"));
+    this.html.find('#dir-top-right').click(event=> this.moveFromKey("top-right"));
+    this.html.find('#dir-bottom-left').click(event=> this.moveFromKey("bottom-left"));
+    this.html.find('#dir-bottom-right').click(event=> this.moveFromKey("bottom-right"));
+    this.html.find('#dir-bottom').click(event=> this.moveFromKey("bottom"));
 
     // Gestion du cout de montée en points de rêve
     let reveCout = ((this.tmrdata.isRapide && !EffetsDraconiques.isDeplacementAccelere(this.actor)) ? -2 : -1) - this.actor.countMonteeLaborieuse();
-    if (ReglesOptionnelles.isUsing("appliquer-fatigue")) {
-      this.cumulFatigue += this.fatigueParCase;
-    }
     await this.actor.reveActuelIncDec(reveCout);
-
+    this.cumulFatigue += this.fatigueParCase;
     // Le reste...
     this.updateValuesDisplay();
     let tmr = TMRUtility.getTMR(this._getActorCoord());
@@ -271,6 +294,10 @@ export class RdDTMRDialog extends Dialog {
 
   /* -------------------------------------------- */
   async close() {
+    if (this.subdialog) {
+      return this.forceTMRContinueAction()
+    }
+
     this.descenteTMR = true;
     if (this.actor.tmrApp) {
       this.actor.tmrApp = undefined; // Cleanup reference
@@ -278,7 +305,8 @@ export class RdDTMRDialog extends Dialog {
         await this.actor.setEffect(STATUSES.StatusDemiReve, false)
         this._tellToGM(this.actor.name + " a quitté les terres médianes");
       }
-      await this.actor.santeIncDec("fatigue", this.cumulFatigue)
+      await this.actor.santeIncDec((ReglesOptionnelles.isUsing("appliquer-fatigue") ? "fatigue" : "endurance"),
+        this.cumulFatigue)
     }
     await super.close();
   }
@@ -293,6 +321,7 @@ export class RdDTMRDialog extends Dialog {
     switch (action) {
       case 'derober':
         await this.derober();
+        this.restoreTMRAfterAction();
         return;
       case 'refouler':
         await this.refouler();
@@ -305,6 +334,7 @@ export class RdDTMRDialog extends Dialog {
         break;
     }
     await this.postRencontre(tmr);
+    this.restoreTMRAfterAction();
   }
 
   async derober() {
@@ -343,35 +373,27 @@ export class RdDTMRDialog extends Dialog {
 
   /* -------------------------------------------- */
   $marquerCasesTMR(listCoordTMR) {
-    this.currentRencontre.graphics = []; // Keep track of rectangles to delete it
     this.currentRencontre.locList = duplicate(listCoordTMR); // And track of allowed location
-    for (let coordTMR of listCoordTMR) {
-      const rect = this._getCaseRectangleCoord(coordTMR);
-      const rectDraw = new PIXI.Graphics();
-      rectDraw.beginFill(0xffff00, 0.3);
-      // set the line style to have a width of 5 and set the color to red
-      rectDraw.lineStyle(5, 0xff0000);
-      // draw a rectangle
-      rectDraw.drawRect(rect.x, rect.y, rect.w, rect.h);
-      this.pixiApp.stage.addChild(rectDraw);
-      this.currentRencontre.graphics.push(rectDraw); // garder les objets pour gestion post-click
-    }
+    this.currentRencontre.graphics = listCoordTMR.map(coordTMR => this.pixiTMR.addMarkTMR(coordTMR))
   }
 
   /* -------------------------------------------- */
   checkQuitterTMR() {
-
     if (this.actor.isDead()) {
       this._tellToGM("Vous êtes mort : vous quittez les Terres médianes !");
       this.close();
       return true;
     }
-    const resteAvantInconscience = this.actor.getFatigueMax() - this.actor.getFatigueActuelle() - this.cumulFatigue;
-    if (ReglesOptionnelles.isUsing("appliquer-fatigue") && resteAvantInconscience <= 0) {
+
+    if (ReglesOptionnelles.isUsing("appliquer-fatigue")
+      ? (this.actor.getFatigueRestante() <= this.cumulFatigue)
+      : (this.actor.getEnduranceActuelle() <= this.cumulFatigue)
+    ) {
       this._tellToGM("Vous vous écroulez de fatigue : vous quittez les Terres médianes !");
       this.quitterLesTMRInconscient();
       return true;
     }
+
     if (this.actor.getReveActuel() == 0) {
       this._tellToGM("Vos Points de Rêve sont à 0 : vous quittez les Terres médianes !");
       this.quitterLesTMRInconscient();
@@ -531,8 +553,9 @@ export class RdDTMRDialog extends Dialog {
         await this.maitriserRencontre();
       }
       else {
-        let dialog = new RdDTMRRencontreDialog(this, this.currentRencontre, tmr);
+        const dialog = new RdDTMRRencontreDialog(this.actor, this.currentRencontre, tmr);
         dialog.render(true);
+        this.setTMRPendingAction(dialog);
       }
     }
     else {
@@ -544,9 +567,12 @@ export class RdDTMRDialog extends Dialog {
   _presentCite(tmr) {
     const presentCite = this.casesSpeciales.find(c => EffetsDraconiques.presentCites.isCase(c, tmr.coord));
     if (presentCite) {
-      this.minimize();
       const caseData = presentCite;
-      EffetsDraconiques.presentCites.choisirUnPresent(caseData, (present => this._utiliserPresentCite(presentCite, present, tmr)));
+      const dialog = EffetsDraconiques.presentCites.choisirUnPresent(caseData, present => {
+        this._utiliserPresentCite(presentCite, present, tmr)
+        this.restoreTMRAfterAction();
+      });
+      this.setTMRPendingAction(dialog);
     }
     return presentCite;
   }
@@ -572,8 +598,6 @@ export class RdDTMRDialog extends Dialog {
       presentCite: presentCite
     };
     await this._tentativeMaitrise(rencontreData);
-
-    this.maximize();
     this.postRencontre(tmr);
   }
 
@@ -587,7 +611,10 @@ export class RdDTMRDialog extends Dialog {
       ? TMRUtility.getTMRType(tmr.coord) + " ??"
       : tmr.label + " (" + tmr.coord + ")");
 
+    const fakeDialogRencontre = { bringToTop: () => { } };
+    this.setTMRPendingAction(fakeDialogRencontre)
     let myRoll = await RdDDice.rollTotal("1dt", { showDice: SHOW_DICE });
+    this.restoreTMRAfterAction()
     if (myRoll == 7) {
       this._tellToUser(myRoll + ": Rencontre en " + locTMR);
       return await game.system.rdd.rencontresTMR.getRencontreAleatoire(tmr, this.actor.isMauvaiseRencontre())
@@ -777,22 +804,22 @@ export class RdDTMRDialog extends Dialog {
 
   /* -------------------------------------------- */
   async _maitriserTMR(rollData, callbackMaitrise) {
-    this.minimize(); // Hide
     rollData.isTMRCache = rollData.actor.isTMRCache();
     const dialog = await RdDRoll.create(this.actor, rollData,
       {
         html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-maitrise-tmr.html',
-        close: html => { this.maximize(); } // Re-display TMR
       },
       {
         name: rollData.maitrise.verbe, label: rollData.maitrise.action,
         callbacks: [
           this.actor.createCallbackExperience(),
+          { action: r => { this.restoreTMRAfterAction() } },
           { action: callbackMaitrise }
         ]
       }
     );
     dialog.render(true);
+    this.setTMRPendingAction(dialog);
   }
 
   /* -------------------------------------------- */
@@ -860,14 +887,11 @@ export class RdDTMRDialog extends Dialog {
 
   /* -------------------------------------------- */
   nettoyerRencontre() {
-    if (!this.currentRencontre) return; // Sanity check
-    if (this.currentRencontre.graphics) {
-      for (let drawRect of this.currentRencontre.graphics) { // Suppression des dessins des zones possibles
-        this.pixiApp.stage.removeChild(drawRect);
-      }
-    }
-    this.currentRencontre = undefined; // Nettoyage de la structure
-    this.rencontreState = 'aucune'; // Et de l'état
+    // Suppression des dessins des zones possibles
+    this.currentRencontre?.graphics?.forEach(graphic => this.pixiTMR.removeGraphic(graphic))
+    // Nettoyage de la structureet de l'état
+    this.currentRencontre = undefined;
+    this.rencontreState = 'aucune';
   }
 
   /* -------------------------------------------- */
@@ -895,8 +919,8 @@ export class RdDTMRDialog extends Dialog {
   }
 
   /* -------------------------------------------- */
-  isConnaissanceFleuve(currentTMR, nextTMR) {
-    return TMRUtility.getTMR(currentTMR).type == 'fleuve' &&
+  isConnaissanceFleuve(tmrApp, nextTMR) {
+    return TMRUtility.getTMR(tmrApp).type == 'fleuve' &&
       TMRUtility.getTMR(nextTMR).type == 'fleuve' &&
       EffetsDraconiques.isConnaissanceFleuve(this.actor);
   }
@@ -906,15 +930,15 @@ export class RdDTMRDialog extends Dialog {
     if (this.viewOnly) {
       return;
     }
-    let clickOddq = RdDTMRDialog._computeEventOddq(event.nativeEvent);
-    await this._onClickTMRPos(clickOddq); // Vérifier l'état des compteurs reve/fatigue/vie
-  }
-
-  /* -------------------------------------------- */
-  async _onClickTMRPos(clickOddq) {
+    if (this.subdialog) {
+      return this.forceTMRContinueAction()
+    }
+    let clickOddq = TMRUtility.computeEventOddq(event);
     let currentOddq = TMRUtility.coordTMRToOddq(this._getActorCoord());
+
     let targetCoord = TMRUtility.oddqToCoordTMR(clickOddq);
     let currentCoord = TMRUtility.oddqToCoordTMR(currentOddq);
+
     // Validation de la case de destination (gestion du cas des rencontres qui peuvent téléporter)
     let deplacementType = this._calculDeplacement(targetCoord, currentCoord, currentOddq, clickOddq);
 
@@ -946,7 +970,7 @@ export class RdDTMRDialog extends Dialog {
         await this._messagerDemiReve(targetCoord);
         break;
       default:
-        ui.notifications.error("Vous ne pouvez pas vous déplacer que sur des cases adjacentes à votre position ou valides dans le cas d'une rencontre");
+        ui.notifications.error("Vous ne pouvez vous déplacer que sur des cases adjacentes à votre position ou valides dans le cas d'une rencontre");
         console.log("STATUS :", this.rencontreState, this.currentRencontre);
     }
 
@@ -975,9 +999,11 @@ export class RdDTMRDialog extends Dialog {
   /* -------------------------------------------- */
   async _messagerDemiReve(targetCoord) {
     /*
-     TODO: si la case a un sort en réserve, lancer ce sort.
+     TODO:
+     Si la case a un sort en réserve, lancer ce sort.
      Si la case est le demi-rêve, ne pas lancer de sort.
-     Si un lancement de sort est en cours, trouver un moyen de réafficher cette fenêtre si on essaie de lancer un sort (ou bloquer le lancer de sort)
+     Si un lancement de sort est en cours, trouver un moyen de réafficher cette fenêtre
+       si on essaie de lancer un sort (ou bloquer le lancer de sort)
     */
     this.notifierResonanceSigneDraconique(targetCoord);
     await this.actor.rollUnSort(targetCoord);
@@ -994,6 +1020,9 @@ export class RdDTMRDialog extends Dialog {
 
   /* -------------------------------------------- */
   async _deplacerDemiReve(targetCoord, deplacementType) {
+    if (this.subdialog) {
+      return this.forceTMRContinueAction()
+    }
     if (this.currentRencontre != 'normal') {
       this.nettoyerRencontre();
     }
@@ -1043,6 +1072,10 @@ export class RdDTMRDialog extends Dialog {
 
   /* -------------------------------------------- */
   async positionnerDemiReve(coord) {
+    if (this.subdialog) {
+      return this.forceTMRContinueAction()
+    }
+
     await this.actor.updateCoordTMR(coord);
     this.forceDemiRevePositionView();
     let tmr = TMRUtility.getTMR(coord);
@@ -1050,30 +1083,9 @@ export class RdDTMRDialog extends Dialog {
     return tmr;
   }
 
-  /* -------------------------------------------- */
-  static _computeEventOddq(origEvent) {
-    console.log("EVENT", origEvent)
-    let canvasRect = origEvent.target.getBoundingClientRect();
-    let x = origEvent.clientX - canvasRect.left;
-    let y = origEvent.clientY - canvasRect.top;
-    let col = Math.floor(x / tmrConstants.cellw); //  [From 0 -> 12]
-    y -= col % 2 == 0 ? tmrConstants.col1_y : tmrConstants.col2_y;
-    let row = Math.floor(y / tmrConstants.cellh); //  [From 0 -> 14]
-    return { col: col, row: row };
-  }
-
-  /* -------------------------------------------- */
-  /** Retourne les coordonnées x, h, w, h du rectangle d'une case donnée */
-  _getCaseRectangleCoord(coord) {
-    return this.pixiTMR.getCaseRectangle(TMRUtility.coordTMRToOddq(coord));
-  }
-
   /* -------------------------------------------- */
   _removeTokens(filter) {
-    const tokensToRemove = this.allTokens.filter(filter);
-    for (let token of tokensToRemove) {
-      this.pixiApp.stage.removeChild(token.sprite);
-    }
+    this.allTokens.filter(filter).forEach(token => this.pixiTMR.removeToken(token))
   }
 
   /* -------------------------------------------- */
@@ -1081,7 +1093,9 @@ export class RdDTMRDialog extends Dialog {
     if (this.demiReve === token && this.isDemiReveCache()) {
       return;
     }
-    this.pixiTMR.setPosition(token.sprite, TMRUtility.coordTMRToOddq(token.coordTMR()));
-    this.allTokens.push(token);
+    this.pixiTMR.positionToken(token);
+    if (!this.allTokens.includes(token)) {
+      this.allTokens.push(token);
+    }
   }
 }

module/rdd-tmr-rencontre-dialog.js

@@ -2,7 +2,7 @@
 export class RdDTMRRencontreDialog extends Dialog {
 
   /* -------------------------------------------- */
-  constructor(tmrApp, rencontre, tmr) {
+  constructor(actor, rencontre, tmr) {
     const dialogConf = {
       title: "Rencontre en TMR!",
       content: "Vous rencontrez un " + rencontre.name + " de force " + rencontre.system.force + "<br>",
@@ -28,23 +28,30 @@ export class RdDTMRRencontreDialog extends Dialog {
 
     this.toClose = false;
     this.tmr = tmr;
-    this.tmrApp = tmrApp;
+    this.actor = actor;
     this.rencontre = rencontre;
-    this.tmrApp.minimize();
   }
 
   async onButtonAction(action) {
     this.toClose = true;
-    this.tmrApp.onActionRencontre(action, this.tmr, this.rencontre)
+    await this.actor.tmrApp?.restoreTMRAfterAction();
+    this.actor.tmrApp?.onActionRencontre(action, this.tmr, this.rencontre)
   }
   
   /* -------------------------------------------- */
-  close() {
-    if (this.toClose) {
-      this.tmrApp.maximize();
-      return super.close();
+  async close() {
+    if (this.actor.tmrApp){
+      if (this.toClose) {
+        return await super.close();
+      }
+      else {
+        ui.notifications.info("Vous devez résoudre la rencontre.");
+        return this.actor.tmrApp.forceTMRContinueAction();
+      }
+    }
+    else {
+      return await super.close();
     }
-    ui.notifications.info("Vous devez résoudre la rencontre.");
   }
 
 }

module/rdd-utility.js

@@ -28,7 +28,7 @@ const ajustementsEncaissement = Misc.intArray(-10, 26);
 /* -------------------------------------------- */
 function _buildAllSegmentsFatigue(max) {
   const cycle = [5, 2, 4, 1, 3, 0];
-  let fatigue = [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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 caseIncrementee = cycle[i % 6];
@@ -55,7 +55,8 @@ function _cumulSegmentsFatigue(matrix) {
 }
 
 /* -------------------------------------------- */
-const fatigueMatrix = _buildAllSegmentsFatigue(60);
+export const MAX_ENDURANCE_FATIGUE = 60;
+const fatigueMatrix = _buildAllSegmentsFatigue(MAX_ENDURANCE_FATIGUE);
 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
@@ -180,24 +181,25 @@ export class RdDUtility {
       'systems/foundryvtt-reve-de-dragon/templates/item-queue-sheet.html',
       'systems/foundryvtt-reve-de-dragon/templates/header-item.html',
       // partial enums
-      'systems/foundryvtt-reve-de-dragon/templates/enum-caracteristiques.html',
-      'systems/foundryvtt-reve-de-dragon/templates/enum-base-competence.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-aspect-tarot.html',
+      'systems/foundryvtt-reve-de-dragon/templates/enum-base-competence.html',
+      'systems/foundryvtt-reve-de-dragon/templates/enum-caracteristiques.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-categories.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-categorie-ingredient.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-categorie-parade.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-categorie-potion.html',
+      'systems/foundryvtt-reve-de-dragon/templates/enum-categorie-queue.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-categorie-vehicule.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-competence.html',
+      'systems/foundryvtt-reve-de-dragon/templates/enum-draconic.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-heures.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-initpremierround.html',
+      'systems/foundryvtt-reve-de-dragon/templates/enum-mortalite.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-niveau-ethylisme.html',
-      'systems/foundryvtt-reve-de-dragon/templates/enum-rarete.html',
-      'systems/foundryvtt-reve-de-dragon/templates/enum-categorie-queue.html',
-      'systems/foundryvtt-reve-de-dragon/templates/enum-draconic.html',
-      'systems/foundryvtt-reve-de-dragon/templates/enum-tmr-type.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-periode.html',
+      'systems/foundryvtt-reve-de-dragon/templates/enum-rarete.html',
       'systems/foundryvtt-reve-de-dragon/templates/enum-tmr-effet.html',
+      'systems/foundryvtt-reve-de-dragon/templates/enum-tmr-type.html',
       // Partials
       'systems/foundryvtt-reve-de-dragon/templates/tirage/liste-resultats-recherche.hbs',
       'systems/foundryvtt-reve-de-dragon/templates/time/horloge.hbs',
@@ -244,7 +246,8 @@ export class RdDUtility {
       'systems/foundryvtt-reve-de-dragon/templates/chat-description.html',
       'systems/foundryvtt-reve-de-dragon/templates/chat-info-appel-au-moral.html',
       'systems/foundryvtt-reve-de-dragon/templates/chat-info-distance.html',
-      'systems/foundryvtt-reve-de-dragon/templates/chat-actor-turn-summary.html',
+      'systems/foundryvtt-reve-de-dragon/templates/chat-actor-turn-acteur.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/chat-actor-turn-sante.hbs',
       'systems/foundryvtt-reve-de-dragon/templates/chat-actor-competence-xp.html',
       'systems/foundryvtt-reve-de-dragon/templates/chat-actor-carac-xp.html',
       'systems/foundryvtt-reve-de-dragon/templates/chat-potionenchantee-chateaudormant.html',
@@ -286,7 +289,8 @@ export class RdDUtility {
     Handlebars.registerHelper('uniteQuantite', (itemId, actorId) => RdDUtility.getItem(itemId, actorId)?.getUniteQuantite());
     Handlebars.registerHelper('isFieldInventaireModifiable', (type, field) => RdDItem.isFieldInventaireModifiable(type, field));
     Handlebars.registerHelper('rarete-getChamp', (rarete, field) => RdDRaretes.getChamp(rarete, field));
-
+    
+    Handlebars.registerHelper('plusMoins', diff => (diff > 0 ? '+' : '') + Math.round(diff))
     Handlebars.registerHelper('experienceLog-topic', topic => ExperienceLog.labelTopic(topic));
 
     return loadTemplates(templatePaths);
@@ -458,18 +462,15 @@ export class RdDUtility {
   }
 
   /* -------------------------------------------- */
-  static getSegmentsFatigue(maxEnd) {
-    maxEnd = Math.max(maxEnd, 1);
-    maxEnd = Math.min(maxEnd, fatigueMatrix.length);
-    return fatigueMatrix[maxEnd];
+  static getSegmentsFatigue(maxEndurance) {
+    return fatigueMatrix[Math.min(Math.max(maxEndurance, 1), fatigueMatrix.length)];
   }
 
   /* -------------------------------------------- */
-  static calculMalusFatigue(fatigue, maxEnd) {
-    maxEnd = Math.max(maxEnd, 1);
-    maxEnd = Math.min(maxEnd, cumulFatigueMatrix.length);
-    let segments = cumulFatigueMatrix[maxEnd];
-    for (let i = 0; i < 12; i++) {
+  static calculMalusFatigue(fatigue, endurance) {
+    endurance = Math.min(Math.max(endurance, 1), cumulFatigueMatrix.length);
+    let segments = cumulFatigueMatrix[endurance];
+    for (let i = 0; i < segments.length; i++) {
       if (fatigue <= segments[i]) {
         return fatigueMalus[i]
       }
@@ -489,7 +490,7 @@ export class RdDUtility {
   // Build the nice (?) html table used to manage fatigue.
   // max should be the endurance max value
   static makeHTMLfatigueMatrix(fatigue, maxEndurance) {
-    let segments = this.getSegmentsFatigue(maxEndurance);
+    const segments = this.getSegmentsFatigue(maxEndurance);
     return this.makeHTMLfatigueMatrixForSegment(fatigue, segments);
   }
 
@@ -623,25 +624,6 @@ export class RdDUtility {
     return perte.total;
   }
 
-  /* -------------------------------------------- */
-  static currentFatigueMalus(value, max) {
-    if (ReglesOptionnelles.isUsing("appliquer-fatigue")) {
-      max = Math.max(1, Math.min(max, 60));
-      value = Math.min(max * 2, Math.max(0, value));
-
-      let fatigueTab = fatigueMatrix[max];
-      let fatigueRem = value;
-      for (let idx = 0; idx < fatigueTab.length; idx++) {
-        fatigueRem -= fatigueTab[idx];
-        if (fatigueRem <= 0) {
-          return fatigueMalus[idx];
-        }
-      }
-      return -7; // This is the max !
-    }
-    return 0;
-  }
-
   /* -------------------------------------------- */
   static async responseNombreAstral(callData) {
     let actor = game.actors.get(callData.id);

module/rolldata-ajustements.js

@@ -69,8 +69,8 @@ export const referenceAjustements = {
     getValue: (rollData, actor) => -actor.getEncTotal()
   },
   surenc: {
-    isVisible: (rollData, actor) => actor.isSurenc(),
-    isUsed: (rollData, actor) => rollData.use?.surenc,
+    isVisible: (rollData, actor) => RdDCarac.isActionPhysique(rollData.selectedCarac) && actor.isSurenc(),
+    isUsed: (rollData, actor) => rollData.use?.surenc && RdDCarac.isActionPhysique(rollData.selectedCarac),
     getLabel: (rollData, actor) => 'Sur-encombrement',
     getValue: (rollData, actor) => actor.computeMalusSurEncombrement()
   },
@@ -164,7 +164,7 @@ export class RollDataAjustements {
         descr: reference.getDescr && reference.getDescr(rollData, actor)
       }
     }
-    rollData.finalLevel = RollDataAjustements.sum(rollData.ajustements);
+    rollData.finalLevel = RollDataAjustements.sum(rollData.ajustements)
   }
 
   /* -------------------------------------------- */

module/settings/regles-optionnelles.js

@@ -4,6 +4,12 @@ import { Misc } from "../misc.js";
 const listeReglesOptionnelles = [
   { group: 'Règles générales', name: 'appliquer-fatigue',           descr: "Appliquer les règles de fatigue"},
   { group: 'Règles générales', name: 'astrologie',                  descr: "Appliquer les ajustements astrologiques aux jets de chance et aux rituels"},
+  { group: 'Récupération', name: 'transformation-stress',           descr: "Transformer le stress durant Château Dormant"},
+  { group: 'Récupération', name: 'recuperation-chance',             descr: "Récupérer la chance durant Château Dormant"},
+  { group: 'Récupération', name: 'recuperation-ethylisme',          descr: "Récupérer l'éthylisme"},
+  { group: 'Récupération', name: 'recuperation-reve',               descr: "Récupérer le rêve pendant la nuit (les jets sont toujours faits pour les Rêves de Dragons)"},
+  { group: 'Récupération', name: 'recuperation-moral',              descr: "Le moral revient vers 0 durant Château Dormant"},
+
 
   { group: 'Règles de combat', name: 'recul',                       descr: "Appliquer le recul en cas de particulière en force ou de charge" },
   { group: 'Règles de combat', name: 'resistanceArmeParade',        descr: "Faire le jet de résistance des armes lors de parades pouvant les endommager" },

module/settings/system-compendiums.js

@@ -47,6 +47,7 @@ export class SystemCompendiums extends FormApplication {
       label: "Compendiums système",
       hint: "Ouvre la fenêtre de sélection des compendiums système",
       icon: "fas fa-bars",
+      restricted: true,
       type: SystemCompendiums
     })
   }

module/sommeil/app-astrologie.js

@@ -128,7 +128,7 @@ export class AppAstrologie extends Application {
       this.selectHeureNaissance(event.currentTarget.attributes['data-heure-naissance'].value);
     })
     this.html.find('[name="jet-astrologie"]').click(event => this.requestJetAstrologie());
-    this.html.find('[name="rebuild-nombres-astraux"]').click(event => this.rebuildNombresAstraux());
+    this.html.find('[name="rebuild-nombres-astraux"]').click(event => this.onRebuild());
 
     this.onCalculThemeAstral();
   }
@@ -144,7 +144,7 @@ export class AppAstrologie extends Application {
   }
 
   /* -------------------------------------------- */
-  async rebuildNombresAstraux() {
+  async onRebuild() {
     game.system.rdd.calendrier.resetNombresAstraux();
 
     await game.system.rdd.calendrier.rebuildNombresAstraux();

module/time/auto-adjust-darkness.js

@@ -0,0 +1,34 @@
+import { SYSTEM_RDD } from "../constants.js";
+
+export const AUTO_ADJUST_DARKNESS = "auto-adjust-darkness";
+
+export class AutoAdjustDarkness {
+
+  static init() {
+    game.settings.register(SYSTEM_RDD, AUTO_ADJUST_DARKNESS, {
+      name: AUTO_ADJUST_DARKNESS,
+      scope: "world",
+      config: false,
+      default: true,
+      type: Boolean
+    });
+  }
+
+  static async adjust(darkness) {
+    if (AutoAdjustDarkness.isAuto()) {
+      const scene = game.scenes.viewed;
+      if (scene?.globalLight && scene?.tokenVision) {
+        await scene.update({ darkness });
+      }
+    }
+  }
+
+  static isAuto() {
+    return game.settings.get(SYSTEM_RDD, AUTO_ADJUST_DARKNESS);
+  }
+
+  static async toggle() {
+    const previous = AutoAdjustDarkness.isAuto();
+    await game.settings.set(SYSTEM_RDD, AUTO_ADJUST_DARKNESS, !previous)
+  }
+}

module/time/rdd-calendrier.js

@@ -5,10 +5,11 @@ import { RdDUtility } from "../rdd-utility.js";
 import { RdDDice } from "../rdd-dice.js";
 import { Misc } from "../misc.js";
 import { DialogChronologie } from "../dialog-chronologie.js";
-import { HIDE_DICE, SHOW_DICE, SYSTEM_RDD, SYSTEM_SOCKET_ID } from "../constants.js";
+import { HIDE_DICE, SYSTEM_RDD, SYSTEM_SOCKET_ID } from "../constants.js";
 import { ReglesOptionnelles } from "../settings/regles-optionnelles.js";
 import { DialogChateauDormant } from "../sommeil/dialog-chateau-dormant.js";
 import { APP_ASTROLOGIE_REFRESH, AppAstrologie } from "../sommeil/app-astrologie.js";
+import { AutoAdjustDarkness } from "./auto-adjust-darkness.js";
 
 const TEMPLATE_CALENDRIER = "systems/foundryvtt-reve-de-dragon/templates/time/calendar.hbs";
 
@@ -51,7 +52,7 @@ export class RdDCalendrier extends Application {
     if (Misc.isUniqueConnectedGM()) { // Uniquement si GM
       RdDTimestamp.setWorldTime(this.timestamp);
       this.nombresAstraux = this.getNombresAstraux();
-      this.rebuildNombresAstraux(HIDE_DICE); // Ensure always up-to-date
+      this.rebuildNombresAstraux(); // Ensure always up-to-date
     }
     Hooks.on('updateSetting', async (setting, update, options, id) => this.onUpdateSetting(setting, update, options, id));
   }
@@ -84,33 +85,22 @@ export class RdDCalendrier extends Application {
   }
 
   display() {
+    AutoAdjustDarkness.adjust(RdDTimestamp.getWorldTime().darkness);
     const pos = this.getSavePosition()
     this.render(true, { left: pos.left, top: pos.top });
     return this;
   }
 
   _getHeaderButtons() {
-    const buttons = [];
     if (game.user.isGM) {
-      buttons.unshift({
-        class: "calendar-astrologie",
-        icon: "fa-solid fa-moon-over-sun",
-        onclick: ev => this.showAstrologieEditor()
-      },
-        {
-          class: "calendar-set-datetime",
-          icon: "fa-solid fa-calendar-pen",
-          onclick: ev => this.showCalendarEditor()
-        });
+      return [
+        { class: "calendar-astrologie", icon: "fa-solid fa-moon-over-sun", onclick: ev => this.showAstrologieEditor() },
+        { class: "calendar-set-datetime", icon: "fa-solid fa-calendar-pen", onclick: ev => this.showCalendarEditor() },
+      ]
     }
-    return buttons
+    return []
   }
 
-  /*async maximize() {
-    await super.maximize()
-    this.render(true)
-  }*/
-
   async close() { }
 
   async onUpdateSetting(setting, update, options, id) {
@@ -134,6 +124,7 @@ export class RdDCalendrier extends Application {
     formData.isGM = game.user.isGM;
     formData.heures = RdDTimestamp.definitions()
     formData.horlogeAnalogique = this.horlogeAnalogique;
+    formData.autoDarkness = AutoAdjustDarkness.isAuto()
     return formData;
   }
 
@@ -144,6 +135,7 @@ export class RdDCalendrier extends Application {
     this.html = html;
     this.html.find('.ajout-chronologie').click(ev => DialogChronologie.create());
     this.html.find('.toggle-horloge-analogique').click(ev => this.onToggleHorlogeAnalogique())
+    this.html.find('.toggle-auto-darkness').click(ev => this.onToggleAutoDarkness())
     this.html.find('.calendar-btn').click(ev => this.onCalendarButton(ev));
     this.html.find('.horloge-roue .horloge-heure').click(event => {
       const h = this.html.find(event.currentTarget)?.data('heure');
@@ -229,15 +221,8 @@ export class RdDCalendrier extends Application {
   }
 
   /* -------------------------------------------- */
-  async ajouterNombreAstral(indexDate, showDice = SHOW_DICE) {
-    const nombreAstral = await RdDDice.rollTotal("1dh", { showDice: showDice, rollMode: "selfroll" });
-    const dateFuture = RdDTimestamp.formatIndexDate(indexDate);
-    if (showDice != HIDE_DICE) {
-      ChatMessage.create({
-        whisper: ChatMessage.getWhisperRecipients("GM"),
-        content: `Le chiffre astrologique du ${dateFuture} sera le ${nombreAstral}`
-      });
-    }
+  async ajouterNombreAstral(indexDate) {
+    const nombreAstral = await RdDDice.rollTotal("1dh", { showDice: HIDE_DICE, rollMode: "selfroll" });
     return {
       nombreAstral: nombreAstral,
       valeursFausses: [],
@@ -272,9 +257,8 @@ export class RdDCalendrier extends Application {
   }
 
   /* -------------------------------------------- */
-  async rebuildNombresAstraux(showDice = HIDE_DICE) {
+  async rebuildNombresAstraux() {
     if (Misc.isUniqueConnectedGM()) {
-      console.log("Astral rebuild")
       let newList = [];
       for (let i = 0; i < MAX_NOMBRE_ASTRAL; i++) {
         let dayIndex = this.timestamp.indexDate + i;
@@ -282,7 +266,7 @@ export class RdDCalendrier extends Application {
         if (na) {
           newList[i] = na;
         } else {
-          newList[i] = await this.ajouterNombreAstral(dayIndex, showDice);
+          newList[i] = await this.ajouterNombreAstral(dayIndex);
         }
       }
       this.nombresAstraux = newList;
@@ -380,7 +364,7 @@ export class RdDCalendrier extends Application {
       if (request.rolled.isSuccess) {
         if (request.rolled.isPart) {
           // Gestion expérience (si existante)
-          request.competence = actor.getCompetence("astrologie")
+          request.competence = actor.getCompetence('Astrologie')
           request.selectedCarac = actor.system.carac["vue"];
           actor.appliquerAjoutExperience(request, 'hide');
         }
@@ -452,4 +436,9 @@ export class RdDCalendrier extends Application {
   async showAstrologieEditor() {
     await AppAstrologie.create();
   }
+
+  async onToggleAutoDarkness() {
+    await AutoAdjustDarkness.toggle()
+    this.display()
+  }
 }

module/time/rdd-timestamp.js

@@ -2,6 +2,7 @@ import { SHOW_DICE, SYSTEM_RDD } from "../constants.js";
 import { Grammar } from "../grammar.js";
 import { Misc } from "../misc.js";
 import { RdDDice } from "../rdd-dice.js";
+import { AutoAdjustDarkness } from "./auto-adjust-darkness.js";
 
 export const WORLD_TIMESTAMP_SETTING = "calendrier";
 
@@ -15,18 +16,18 @@ export const RDD_MINUTES_PAR_JOUR = 1440; //RDD_HEURES_PAR_JOUR * RDD_MINUTES_PA
 const ROUNDS_PAR_MINUTE = 10;
 
 const DEFINITION_HEURES = [
-  { key: "vaisseau", label: "Vaisseau", lettreFont: 'v', saison: "Printemps" },
-  { key: "sirene", label: "Sirène", lettreFont: 'i', saison: "Printemps" },
-  { key: "faucon", label: "Faucon", lettreFont: 'f', saison: "Printemps" },
-  { key: "couronne", label: "Couronne", lettreFont: '', saison: "Eté" },
-  { key: "dragon", label: "Dragon", lettreFont: 'd', saison: "Eté" },
-  { key: "epees", label: "Epées", lettreFont: 'e', saison: "Eté" },
-  { key: "lyre", label: "Lyre", lettreFont: 'l', saison: "Automne" },
-  { key: "serpent", label: "Serpent", lettreFont: 's', saison: "Automne" },
-  { key: "poissonacrobate", label: "Poisson Acrobate", lettreFont: 'p', saison: "Automne" },
-  { key: "araignee", label: "Araignée", lettreFont: 'a', saison: "Hiver" },
-  { key: "roseau", label: "Roseau", lettreFont: 'r', saison: "Hiver" },
-  { key: "chateaudormant", label: "Château Dormant", lettreFont: 'c', saison: "Hiver" },
+  { key: "vaisseau", label: "Vaisseau", lettreFont: 'v', saison: "Printemps" , darkness: 0.7},
+  { key: "sirene", label: "Sirène", lettreFont: 'i', saison: "Printemps" , darkness: 0.4},
+  { key: "faucon", label: "Faucon", lettreFont: 'f', saison: "Printemps" , darkness: 0},
+  { key: "couronne", label: "Couronne", lettreFont: '', saison: "Eté" , darkness: 0},
+  { key: "dragon", label: "Dragon", lettreFont: 'd', saison: "Eté", darkness: 0 },
+  { key: "epees", label: "Epées", lettreFont: 'e', saison: "Eté", darkness: 0},
+  { key: "lyre", label: "Lyre", lettreFont: 'l', saison: "Automne", darkness: 0.4 },
+  { key: "serpent", label: "Serpent", lettreFont: 's', saison: "Automne", darkness: 0.7 },
+  { key: "poissonacrobate", label: "Poisson Acrobate", lettreFont: 'p', saison: "Automne", darkness: 1 },
+  { key: "araignee", label: "Araignée", lettreFont: 'a', saison: "Hiver", darkness: 1 },
+  { key: "roseau", label: "Roseau", lettreFont: 'r', saison: "Hiver", darkness: 1 },
+  { key: "chateaudormant", label: "Château Dormant", lettreFont: 'c', saison: "Hiver", darkness: 1 },
 ]
 
 const FORMULES_DUREE = [
@@ -58,6 +59,7 @@ export class RdDTimestamp {
       type: Object
     });
 
+
     for (let i = 0; i < DEFINITION_HEURES.length; i++) {
       DEFINITION_HEURES[i].heure = i;
       DEFINITION_HEURES[i].hh = RdDTimestamp.hh(i);
@@ -66,7 +68,6 @@ export class RdDTimestamp {
     }
   }
 
-
   static hh(heure) {
     return heure < 9 ? `0${heure + 1}` : `${heure + 1}`;
   }
@@ -239,6 +240,13 @@ export class RdDTimestamp {
   get angleHeure() { return this.indexMinute / RDD_MINUTES_PAR_JOUR * 360 - 45 }
   get angleMinute() { return this.indexMinute / RDD_MINUTES_PAR_HEURES * 360 + 45 }
 
+  get darkness() {
+    const darknessDebut = RdDTimestamp.definition(this.heure).darkness *100
+    const darknessFin = RdDTimestamp.definition(this.heure + 1).darkness *100
+    const darknessMinute = Math.round((darknessFin - darknessDebut) * this.minute / RDD_MINUTES_PAR_HEURES);
+    return (darknessDebut + darknessMinute)/100
+  }
+
   /**
    * Convertit le timestamp en une structure avec les informations utiles
    * pour afficher la date et l'heure

module/tmr-utility.js

@@ -1,6 +1,7 @@
 import { Misc } from "./misc.js";
 import { Grammar } from "./grammar.js";
 import { RdDDice } from "./rdd-dice.js";
+import { tmrConstants } from "./tmr-constants.js";
 
 /* -------------------------------------------- */
 const TMRMapping = {
@@ -163,7 +164,7 @@ const TMRMapping = {
   C12: { type: "lac", label: "Lac de Fricassa" },
   D12: { type: "collines", label: "Collines d’Huaï" },
   E12: { type: "monts", label: "Monts Ajourés" },
-  F12: { type: "necropole", label: "Nécropole de Troat" },
+  F12: { type: "necropole", label: "Nécropole de Throat" },
   G12: { type: "plaines", label: "Plaines de Lufmil" },
   H12: { type: "collines", label: "Collines de Tooth" },
   I12: { type: "gouffre", label: "Gouffre Abimeux" },
@@ -199,7 +200,7 @@ const TMRMapping = {
   K14: { type: "necropole", label: "Nécropole d’Antinéar" },
   L14: { type: "plaines", label: "Plaines de Jislith" },
   M14: { type: "desolation", label: "Désolation d’Après" },
-  
+
   A15: { type: "cite", label: "Cité de Mielh" },
   C15: { type: "plaines", label: "Plaines de Toué" },
   E15: { type: "foret", label: "Forêt des Furies" },
@@ -274,11 +275,11 @@ export class TMRUtility {
     const tmr = TMRUtility.getTMR(coord);
     return Grammar.articleDetermine(tmr.type) + ' ' + tmr.label;
   }
-  
-  static findTMRLike(type, options = {inclusMauvaise:true}) {
+
+  static findTMRLike(type, options = { inclusMauvaise: true }) {
     const choix = [...Object.values(TMRType)]
-    if (options.inclusMauvaise){
-      choix.push({name: 'Mauvaise'});
+    if (options.inclusMauvaise) {
+      choix.push({ name: 'Mauvaise' });
     }
     const selection = Misc.findAllLike(type, choix).map(it => it.name);
     if (selection.length == 0) {
@@ -297,7 +298,7 @@ export class TMRUtility {
   }
 
   static buildSelectionTypesTMR(typesTMR) {
-    typesTMR = typesTMR?? [];
+    typesTMR = typesTMR ?? [];
     return Object.values(TMRType).map(value => Misc.upperFirst(value.name))
       .sort()
       .map(name => { return { name: name, selected: typesTMR.includes(name) } });
@@ -375,6 +376,36 @@ export class TMRUtility {
     return caseList;
   }
 
+  // /* -------------------------------------------- */
+  static computeEventPosition(event) {
+    if (!event.nativeEvent.target.getBoundingClientRect) {
+      return { x: 0, y: 0 }
+    }
+    const canvasRect = event.nativeEvent.target.getBoundingClientRect();
+    return {
+      x: event.nativeEvent.clientX - canvasRect.left,
+      y: event.nativeEvent.clientY - canvasRect.top
+    };
+  }
+
+  /* -------------------------------------------- */
+  static computeEventOddq(event) {
+    var { x, y } = TMRUtility.computeEventPosition(event);
+    return TMRUtility.computeOddq(x, y);
+  }
+
+  static computeOddq(x, y) {
+    const col = Math.floor(x / tmrConstants.cellw); //  [From 0 -> 12]
+    const decallageColonne = col % 2 == 0 ? tmrConstants.col1_y : tmrConstants.col2_y;
+    const row = Math.floor((y - decallageColonne) / tmrConstants.cellh); //  [From 0 -> 14]
+    return { col, row };
+  }
+
+  static computeEventCoord(event) {
+    const oddq = TMRUtility.computeEventOddq(event);
+    return TMRUtility.oddqToCoordTMR(oddq);
+  }
+
   /* -------------------------------------------- */
   // https://www.redblobgames.com/grids/hexagons/#distances
   // TMR Letter-row correspond to "odd-q" grid (letter => col, numeric => row )
@@ -400,7 +431,7 @@ export class TMRUtility {
       col >= 0 && col < 13 &&
       row >= 0 &&
       (row + col % 2 <= 14)
-      );
+    );
     // if (x >= 0 && x < 13 && y >= 0 && y < 14) return true;
     // if (x >= 0 && x < 13 && x % 2 == 0 && y == 14) return true;
     // return false;
@@ -444,7 +475,7 @@ export class TMRUtility {
 
   static axial_subtract(a, b) {
     return {
-      q: a.q- b.q,
+      q: a.q - b.q,
       r: a.r - b.r
     };
   }
@@ -456,7 +487,7 @@ export class TMRUtility {
   // return Cube(q, r, s)
   // }
 
-  
+
   // /* -------------------------------------------- */
   // static computeRealPictureCoordinates(coordOddq) {
   //   let decallagePairImpair = (coordOddq.col % 2 == 0) ? tmrConstants.col1_y : tmrConstants.col2_y;

module/tmr/carte-tmr.js

@@ -1,10 +1,10 @@
+import { TMRUtility } from "../tmr-utility.js";
 import { Draconique } from "./draconique.js";
 import { PixiTMR } from "./pixi-tmr.js";
 
 export class CarteTmr extends Draconique {
 
   constructor() {
-    console.log("Sprite create 1!!!!")
     super();
   }
 
@@ -14,9 +14,26 @@ export class CarteTmr extends Draconique {
   async onActorCreateOwned(actor, item) { }
 
   code() { return 'tmr' }
-  img() { return 'systems/foundryvtt-reve-de-dragon/styles/img/ui/tmp_main_r1.webp' }
+  img() { return 'systems/foundryvtt-reve-de-dragon/styles/img/ui/tmr.webp' }
 
   createSprite(pixiTMR) {
-    return pixiTMR.carteTmr(this.code());
+    const img = PixiTMR.getImgFromCode(this.code())
+    const sprite = new PIXI.Sprite(PIXI.utils.TextureCache[img]);
+    // Setup the position of the TMR
+    sprite.x = 0;
+    sprite.y = 0;
+    sprite.width = 722;
+    sprite.height = 860;
+    // Rotate around the center
+    sprite.anchor.set(0);
+    sprite.buttonMode = true;
+    sprite.tmrObject = pixiTMR;
+    return sprite;
   }
+
+  computeTooltip(coordTMR) {
+    const tmr = TMRUtility.getTMR(coordTMR)
+    return tmr? TMRUtility.getTMRLabel(coordTMR) : '';
+  }
+
 }

module/tmr/draconique.js

@@ -11,7 +11,7 @@ const registeredEffects = [
 export class Draconique {
   static isCaseTMR(item) { return item.type == TYPES.casetmr; }
   static isQueueDragon(item) { return item.isQueueDragon(); }
-  static isSouffleDragon(item) {return item.type == TYPES.souffle; }
+  static isSouffleDragon(item) { return item.type == TYPES.souffle; }
   static isTeteDragon(item) { return item.type == TYPES.tete; }
   static isQueueSouffle(item) { return Draconique.isQueueDragon(item) || Draconique.isSouffleDragon(item); }
 
@@ -78,25 +78,43 @@ export class Draconique {
   /**
    * @param {*} img l'url du fichier image à utiliser pour le token. Si indéfini (et si createSprite n'est pas surchargé),
    *  un disque est utilisé.
-   */
+  */
   img() { return undefined }
 
   /**
-   * factory d'élément graphique PIXI correpsondant à l'objet draconique
+   * factory d'élément graphique PIXI correspondant à l'objet draconique
    * @param {*} pixiTMR instance de PixiTMR qui gère les tooltips, les méthodes de création de sprite standard, les clicks.
-   */
+  */
   token(pixiTMR, linkData, coordTMR, type = undefined) {
+    const tooltip = this.tooltip(linkData);
     const token = {
       sprite: this.createSprite(pixiTMR),
-      coordTMR: coordTMR
+      coordTMR: coordTMR,
+      tooltip: tooltip
     };
     token[type ?? this.code()] = linkData;
-    console.log("SPRITE: ", token.sprite)
-    //PixiTMR.getImgFromCode()
-    pixiTMR.addTooltip(token.sprite, this.tooltip(linkData));
     return token;
   }
 
+  /**
+   * methode en charge de recalculer le tooltip lorsque la souris bouge
+   * @param {*} event evenement contenant les coordonnées
+   * @param {*} sprite sprite pour laquelle calculer le tooltip
+   */
+  computeTooltip(event, sprite) {
+    if (sprite.isOver) {
+      const oddq = TMRUtility.computeEventOddq(event);
+      const coord = TMRUtility.oddqToCoordTMR(oddq);
+      const tmr = TMRUtility.getTMR(coord)
+      if (tmr){
+        const label = TMRUtility.getTMRLabel(coord);
+        const text = this.tooltip(this.linkData);
+        return text ? `${coord}: ${label}\n${text}` : `${coord}: ${label}`
+      }
+    }
+    return '';
+  }
+
   /**
    * factory d'élément graphique PIXI correpsondant à l'objet draconique
    * @param {*} pixiTMR instance de PixiTMR qui gère les tooltips, les méthodes de création de sprite standard, les clicks.
@@ -118,11 +136,11 @@ export class Draconique {
   isCase(item, coord = undefined) {
     return Draconique.isCaseTMR(item) && item.system.specific == this.code() && (coord ? item.system.coord == coord : true);
   }
-  
+
   find(list, coord = undefined) {
     return list.find(c => this.isCase(c, coord));
   }
-  
+
   async createCaseTmr(actor, label, tmr, sourceId = undefined) {
     const casetmrData = {
       name: label, type: 'casetmr', img: this.img(),
@@ -130,12 +148,12 @@ export class Draconique {
     };
     await actor.createEmbeddedDocuments('Item', [casetmrData]);
   }
-  
+
   async deleteCasesTmr(actor, draconique) {
     let caseTmrs = actor.items.filter(it => this.isCaseForSource(it, draconique));
     await actor.deleteEmbeddedDocuments('Item', caseTmrs.map(it => it.id));
   }
-  
+
   isCaseForSource(item, draconique) {
     return Draconique.isCaseTMR(item) && item.system.specific == this.code() && item.system.sourceid == draconique.id;
   }

module/tmr/effets-rencontres.js

@@ -2,6 +2,7 @@ import { ExperienceLog, XP_TOPIC } from "../actor/experience-log.js";
 import { ChatUtility } from "../chat-utility.js";
 import { Poetique } from "../poetique.js";
 import { RdDDice } from "../rdd-dice.js";
+import { ReglesOptionnelles } from "../settings/regles-optionnelles.js";
 import { TMRUtility } from "../tmr-utility.js";
 
 export class EffetsRencontre {
@@ -9,7 +10,7 @@ export class EffetsRencontre {
   static messager = async (dialog, context) => {
     dialog.setRencontreState('messager', TMRUtility.getTMRPortee(context.tmr.coord, context.rencontre.system.force));
   }
-  
+
   static passeur = async (dialog, context) => {
     dialog.setRencontreState('passeur', TMRUtility.getTMRPortee(context.tmr.coord, context.rencontre.system.force));
   }
@@ -26,16 +27,25 @@ export class EffetsRencontre {
   static reve_plus_1 = async (dialog, context) => { await EffetsRencontre.$reve_plus(context.actor, 1) }
   static reve_moins_force = async (dialog, context) => { await EffetsRencontre.$reve_plus(context.actor, -context.rencontre.system.force) }
   static reve_moins_1 = async (dialog, context) => { await EffetsRencontre.$reve_plus(context.actor, -1) }
-  static $reve_plus = async (actor, valeur) => { await actor.reveActuelIncDec(valeur) }
+  static $reve_plus = async (actor, reve) => {
+    if (!ReglesOptionnelles.isUsing("recuperation-reve") && reve < 0) { 
+      ChatMessage.create({
+        whisper: ChatUtility.getWhisperRecipientsAndGMs(actor.name),
+        content: `Pas de récupération de rêve (${reve} points ignorés)`
+      });
+      return
+    }
+    await actor.reveActuelIncDec(reve)
+  }
 
   static vie_moins_1 = async (dialog, context) => { await EffetsRencontre.$vie_plus(context.actor, -1) }
   static vie_moins_force = async (dialog, context) => { await EffetsRencontre.$vie_plus(context.actor, -context.rencontre.system.force) }
   static $vie_plus = async (actor, valeur) => { await actor.santeIncDec("vie", valeur) }
-  
+
   static moral_plus_1 = async (dialog, context) => { await EffetsRencontre.$vie_plus(context.actor, 1) }
   static moral_moins_1 = async (dialog, context) => { await EffetsRencontre.$vie_plus(context.actor, -1) }
   static $moral_plus = async (actor, valeur) => { await actor.moralIncDec(valeur) }
-  
+
   static end_moins_1 = async (dialog, context) => { await EffetsRencontre.$vie_plus(context.actor, -1) }
   static end_moins_force = async (dialog, context) => { await EffetsRencontre.$vie_plus(context.actor, -context.rencontre.system.force) }
   static $end_plus = async (actor, valeur) => { await actor.santeIncDec("endurance", valeur) }
@@ -50,8 +60,8 @@ export class EffetsRencontre {
     const perte = context.rolled.isETotal ? context.rencontre.system.force : 1;
     await context.actor.chanceActuelleIncDec("fatigue", -perte);
   }
-  
-  static xp_sort_force = async (dialog, context) => { 
+
+  static xp_sort_force = async (dialog, context) => {
     let competence = context.competence;
     if (competence) {
       const fromXpSort = Number(competence.system.xp_sort);
@@ -60,7 +70,7 @@ export class EffetsRencontre {
       await ExperienceLog.add(this, XP_TOPIC.XPSORT, fromXpSort, toXpSort, `${competence.name} - ${context.rencontre.name} en TMR`);
     }
   }
-  
+
   static stress_plus_1 = async (dialog, context) => {
     await context.actor.addCompteurValue('stress', 1, `Rencontre d'un ${context.rencontre.name} en TMR`);
   }
@@ -75,7 +85,7 @@ export class EffetsRencontre {
 
   static demireve_rompu = async (dialog, context) => {
     dialog.close()
-   }
+  }
 
   static sort_aleatoire = async (dialog, context) => {
     context.sortReserve = await RdDDice.rollOneOf(context.actor.itemTypes['sortreserve']);
@@ -128,7 +138,7 @@ export class EffetsRencontre {
 
   static regain_seuil = async (dialog, context) => {
     await context.actor.regainPointDeSeuil()
-   }
+  }
 
   static async $reinsertion(dialog, actor, filter) {
     const newTMR = await TMRUtility.getTMRAleatoire(filter);

module/tmr/pixi-tmr.js

@@ -1,6 +1,10 @@
+import { Misc } from "../misc.js";
+import { RdDTMRDialog } from "../rdd-tmr-dialog.js";
 import { tmrConstants, tmrTokenZIndex } from "../tmr-constants.js";
+import { TMRUtility } from "../tmr-utility.js";
+import { EffetsDraconiques } from "./effets-draconiques.js";
 
-const tooltipStyle = new PIXI.TextStyle({
+export const tooltipStyle = new PIXI.TextStyle({
   fontFamily: 'CaslonAntique',
   fontSize: 18,
   fill: '#FFFFFF',
@@ -13,14 +17,38 @@ export class PixiTMR {
 
   static textures = []
 
-  constructor(tmrObject, pixiApp) {
-    this.tmrObject = tmrObject;
-    this.pixiApp = pixiApp ?? tmrObject.pixiApp;
-    this.pixiApp.stage.sortableChildren = true;
+  constructor(tmrDialog) {
+    this.tmrDialog = tmrDialog;
+
     this.callbacksOnAnimate = [];
+
+    this.pixiApp = new PIXI.Application({ width: 720, height: 860 });
+    this.pixiApp.eventMode = 'static';
+    this.pixiApp.stage.sortableChildren = true;
+    this.tooltip = new PIXI.Text('', tooltipStyle);
+    this.tooltip.zIndex = 1000
+
+    this.pixiApp.stage.addChild(this.tooltip);
+
   }
 
-  async load( onLoad = (loader, resources) => {} )  {
+  get view() {
+    return this.pixiApp.view
+  }
+
+  setup() {
+    this.carteTMR = EffetsDraconiques.carteTmr.createSprite(this);
+    this.pixiApp.stage.addChild(this.carteTMR);
+    this.carteTMR.isOver = false;
+    this.carteTMR.eventMode = 'static';
+    this.carteTMR
+      .on('pointermove', event => this.onPointerMove(event))
+      .on('pointerdown', event => this.onClickBackground(event))
+      .on('pointerover', event => this.onShowTooltip(event))
+      .on('pointerout', event => this.onHideTooltip(event));
+  }
+
+  async load(onLoad = (loader, resources) => { }) {
     // WIP - Deprecated since v7 : let loader = new PIXI.Loader();
     for (const [name, img] of Object.entries(PixiTMR.textures)) {
       const texture = await PIXI.Assets.load(img);
@@ -40,31 +68,24 @@ export class PixiTMR {
     PixiTMR.textures[name] = img;
   }
 
-  animate(animation = pixiApp=>{})
-  {
+  animate(animation = pixiApp => { }) {
     this.callbacksOnAnimate.push(() => animation(this.pixiApp));
   }
 
-  carteTmr(code) {
-    let img = PixiTMR.getImgFromCode(code)
-    const carteTmr = new PIXI.Sprite(PIXI.utils.TextureCache[img]);
-    console.log(code, carteTmr)
-    // Setup the position of the TMR
-    carteTmr.x = 0;
-    carteTmr.y = 0;
-    carteTmr.width = 720;
-    carteTmr.height = 860;
-    // Rotate around the center
-    carteTmr.anchor.set(0);
-    carteTmr.eventMode = 'dynamic'; // PIXI 7 : Not sure ..
-    // This one is deprecated ; carteTmr.interactive = true;
-    carteTmr.buttonMode = true;
-    carteTmr.tmrObject = this;
-    if (!this.tmrObject.viewOnly) {
-      carteTmr.on('pointerdown', event => this.onClickBackground(event));
-    }
-    this.pixiApp.stage.addChild(carteTmr);
-    return carteTmr;
+  addMarkTMR(coordTMR) {
+    const rect = this.getCaseRectangle(TMRUtility.coordTMRToOddq(coordTMR))
+    const markTMR = new PIXI.Graphics();
+    markTMR.beginFill(0xffff00, 0.3);
+    // set the line style to have a width of 5 and set the color to red
+    markTMR.lineStyle(5, 0xff0000);
+    // draw a rectangle
+    markTMR.drawRect(rect.x, rect.y, rect.w, rect.h);
+    this.pixiApp.stage.addChild(markTMR);
+    return markTMR
+  }
+
+  removeGraphic(graphic) {
+    this.pixiApp.stage.removeChild(graphic);
   }
 
   sprite(code, options = {}) {
@@ -73,7 +94,7 @@ export class PixiTMR {
     if (!texture) {
       console.error("Texture manquante", code, PIXI.utils.TextureCache)
       return;
-    }  
+    }
     let sprite = new PIXI.Sprite(texture);
     sprite.width = options.taille ?? tmrConstants.half;
     sprite.height = options.taille ?? tmrConstants.half;
@@ -81,14 +102,14 @@ export class PixiTMR {
     if (options.color) {
       sprite.tint = options.color;
     }
-    sprite.zIndex = options.zIndex ?? tmrTokenZIndex.casehumide+1;
+    sprite.zIndex = options.zIndex ?? tmrTokenZIndex.casehumide + 1;
     sprite.alpha = options.alpha ?? 0.75;
     sprite.decallage = options.decallage ?? tmrConstants.center;
     this.pixiApp.stage.addChild(sprite);
     return sprite;
-  }  
-  
-  circle(name, options = {}) {
+  }
+
+  circle(code, options = {}) {
     let sprite = new PIXI.Graphics();
     sprite.beginFill(options.color, options.opacity);
     sprite.drawCircle(0, 0, (options.taille ?? 12) / 2);
@@ -98,51 +119,74 @@ export class PixiTMR {
     return sprite;
   }
 
-  addTooltip(sprite, text) {
-    if (text) {
-      sprite.tooltip = new PIXI.Text(text, tooltipStyle);
-      sprite.tooltip.zIndex = tmrTokenZIndex.tooltip;
-      sprite.isOver = false;
-      // Deprecated : sprite.interactive = true; 
-      sprite.eventMode = 'dynamic'; // PIXI 7 To be checked
-      sprite.on('pointerdown', event => this.onClickBackground(event))
-        .on('pointerover', () => this.onShowTooltip(sprite))
-        .on('pointerout', () => this.onHideTooltip(sprite));
+  onClickBackground(event) {
+    if (!this.viewOnly) {
+      this.tmrDialog.onClickTMR(event)
+    }
+  }
+
+  onPointerMove(event) {
+    if (this.carteTMR.isOver) {
+      this.setTooltipPosition(event);
+      this.tooltip.text = this.computeTooltip(event);
     }
   }
   
-
-  onClickBackground(event) {
-    this.tmrObject.onClickTMR(event)
+  onShowTooltip(event) {
+    if (!this.carteTMR.isOver) {
+      this.setTooltipPosition(event);
+      this.pixiApp.stage.addChild(this.tooltip);
+      this.tooltip.text = this.computeTooltip(event);
+    }
+    this.carteTMR.isOver = true;
   }
 
-  onShowTooltip(sprite) {
-    if (sprite.tooltip) {
+  onHideTooltip(event) {
+    if (this.carteTMR.isOver) {
+      this.pixiApp.stage.removeChild(this.tooltip);
+    }
+    this.carteTMR.isOver = false;
+  }
 
-      if (!sprite.isOver) {
-        sprite.tooltip.x = sprite.x;
-        sprite.tooltip.y = sprite.y;
-        this.pixiApp.stage.addChild(sprite.tooltip);
-      }
-      sprite.isOver = true;
+  computeTooltip(event) {
+    const oddq = TMRUtility.computeEventOddq(event);
+    const coordTMR = TMRUtility.oddqToCoordTMR(oddq);
+    const tmr = TMRUtility.getTMR(coordTMR)
+    if (tmr) {
+      const labelTMR = TMRUtility.getTMRLabel(coordTMR);
+      const tokenTooltips = this.tmrDialog.allTokens
+        .filter(token => token.coordTMR() == coordTMR)
+        .map(token => token.tooltip);
+      const tmrTooltip = `${coordTMR}: ${labelTMR}`;
+      return [tmrTooltip, ...tokenTooltips].reduce(Misc.joining('\n'))
     }
   }
 
-  onHideTooltip(sprite) {
-    if (sprite.tooltip) {
-      if (sprite.isOver) {
-        this.pixiApp.stage.removeChild(sprite.tooltip);
-      }
-      sprite.isOver = false;
+  setTooltipPosition(event) {
+    var { x, y } = TMRUtility.computeEventPosition(event);
+    const oddq = TMRUtility.computeOddq(x, y);
+
+    this.tooltip.x = x + (oddq.col > 8 ? -3 * tmrConstants.full : tmrConstants.half);
+    this.tooltip.y = y + (oddq.row > 10 ? -tmrConstants.half : tmrConstants.half);
+  }
+
+  positionToken(token) {
+    if (token.sprite) {
+      const sprite = token.sprite;
+      const oddq = TMRUtility.coordTMRToOddq(token.coordTMR());
+
+      const decallagePairImpair = (oddq.col % 2 == 0) ? tmrConstants.col1_y : tmrConstants.col2_y;
+      const dx = (sprite.decallage == undefined) ? 0 : sprite.decallage.x;
+      const dy = (sprite.decallage == undefined) ? 0 : sprite.decallage.y;
+      sprite.x = tmrConstants.gridx + (oddq.col * tmrConstants.cellw) + dx;
+      sprite.y = tmrConstants.gridy + (oddq.row * tmrConstants.cellh) + dy + decallagePairImpair;
     }
   }
 
-  setPosition( sprite, oddq) {
-    let decallagePairImpair = (oddq.col % 2 == 0) ? tmrConstants.col1_y : tmrConstants.col2_y;
-    let dx = (sprite.decallage == undefined) ? 0 : sprite.decallage.x;
-    let dy = (sprite.decallage == undefined) ? 0 : sprite.decallage.y;
-    sprite.x = tmrConstants.gridx + (oddq.col * tmrConstants.cellw) + dx;
-    sprite.y = tmrConstants.gridy + (oddq.row * tmrConstants.cellh) + dy + decallagePairImpair;
+  removeToken(token) {
+    if (token.sprite) {
+      this.pixiApp.stage.removeChild(token.sprite)
+    }
   }
 
   getCaseRectangle(oddq) {

module/tmr/present-cites.js

@@ -49,12 +49,13 @@ export class PresentCites extends Draconique {
     const presents = await game.system.rdd.rencontresTMR.getPresentsCite()
     const buttons = {};
     presents.forEach(r =>  buttons['present'+r.id] = { icon: '<i class="fas fa-check"></i>', label: r.name, callback: async () => onChoixPresent(r) });
-    let d = new Dialog({
+    let dialog = new Dialog({
       title: "Présent des cités",
       content: `La ${this.tmrLabel(casetmr)} vous offre un présent, faites votre choix`,
       buttons: buttons
     });
-    d.render(true);
+    dialog.render(true);
+    return dialog
   }
 
   async ouvrirLePresent(actor, casetmr) {

packs/macros.db

@@ -1,13 +1,14 @@
-{"name":"Jet de moral","type":"script","author":"Hp9ImM4o9YRTSdfu","img":"icons/magic/control/mouth-smile-deception-purple.webp","scope":"global","command":"const selected = game.system.rdd.RdDUtility.getSelectedActor();\nif (!selected) {\n  ui.notifications.info('Pas de personnage sélectionné');\n  return;\n}\n\nconst dialogMoral = new Dialog({\n  title: `Jet de moral`,\n  content: `Jet de moral en situation`,\n  buttons: {\n    malheureuse: { label: `malheureuse`, icon: \"<i class='fa-regular fa-face-frown'></i>\", callback: () => selected.jetDeMoral('malheureuse') },\n    neutre: { label: `neutre`, icon: \"<i class='fa-regular fa-face-meh'></i>\", callback: () => selected.jetDeMoral('neutre') },\n    heureuse: { label: `heureuse`, icon: \"<i class='fa-regular fa-face-smile'></i>\", callback: () => selected.jetDeMoral('heureuse') }\n  },\n});\n\ndialogMoral.render(true)","ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3},"flags":{"core":{"sourceId":"Macro.aJ0QGnXAXT0WiXbk"}},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.15","coreVersion":"10.291","createdTime":1671235038906,"modifiedTime":1671236054480,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"folder":null,"sort":0,"_id":"2VvH2rmxV33jGjMU"}
-{"name":"Repos","type":"script","scope":"global","author":"Hp9ImM4o9YRTSdfu","img":"icons/svg/sleep.svg","command":"const selected = game.system.rdd.RdDUtility.getSelectedActor();\nif (selected) {\n  selected.repos();\n}\nelse {\n  ui.notifications.info('Pas de personnage sélectionné');\n}","ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3},"flags":{"core":{"sourceId":"Macro.XHNbjnGKXaCiCadq"}},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.15","coreVersion":"10.291","createdTime":1671220038331,"modifiedTime":1671234271278,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"folder":null,"sort":0,"_id":"6LRZ8DOVfqotIEsi"}
-{"name":"Météo marine","type":"chat","author":"Hp9ImM4o9YRTSdfu","img":"icons/magic/air/wind-weather-sailing-ship.webp","scope":"global","command":"/meteo","flags":{"core":{"sourceId":"Macro.EPhCYk7PFMPlIFhS"}},"ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.15","coreVersion":"10.291","createdTime":1671237060687,"modifiedTime":1671237060687,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"folder":null,"sort":0,"_id":"9mYZfKoi4ZYHydxa"}
-{"name":"Chuchoter aux joueurs","type":"script","author":"Hp9ImM4o9YRTSdfu","img":"icons/svg/deaf.svg","scope":"global","command":"/** \n * Provides a dialog to whisper specific players. If you have tokens selected, it will automatically default to try and whisper those players.\n * @Author: Nelson#3570\n */\n\nlet applyChanges = false;\n\nlet users = game.users.filter(user => user.active);\nlet checkOptions = \"\"\nlet playerTokenIds = users.map(u => u.character?.id).filter(id => id !== undefined);\nlet selectedPlayerIds = canvas.tokens.controlled.map(token => {\n  if (playerTokenIds.includes(token.actor.id)) return token.actor.id;\n});\n\n// Build checkbox list for all active players\nusers.forEach(user => {\n  let checked = !!user.character && selectedPlayerIds.includes(user.character.id) && 'checked';\n  checkOptions+=`\n    <br>\n    <input type=\"checkbox\" name=\"${user.id}\" id=\"${user.id}\" value=\"${user.name}\" ${checked}>\\n\n    <label for=\"${user.id}\">${user.name}</label>\n  `\n});\n\nnew Dialog({\n  title:\"Whisper\",\n  content:`Whisper To: ${checkOptions} <br>\n    <label for=\"message\">Message:</label>\n    <textarea id=\"message\" name=\"message\" rows=\"4\" cols=\"50\"></textarea><br>`,\n  buttons:{\n    whisper:{   \n      label:\"Whisper\",\n      callback: (html) => createMessage(html)\n    }\n  }\n}).render(true);\n\nfunction createMessage(html) {\n  var targets = [];\n  // build list of selected players ids for whispers target\n  for ( let user of users ) {\n    if (html.find('[name=\"'+user.id+'\"]')[0].checked){\n      applyChanges=true;\n      targets.push(user.id);\n    }\n    var messageText = html.find('[name=\"message\"]')[0].value\n  }\nif(!applyChanges)return;\n  ChatMessage.create({\n    content: messageText,\n    whisper: targets\n  });\n}","flags":{"core":{"sourceId":"Compendium.foundry_community_macros.community-macros-misc.QTDeg4HOYCAmr4dK"}},"ownership":{"default":2,"Hp9ImM4o9YRTSdfu":3},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.15","coreVersion":"10.291","createdTime":1671237211578,"modifiedTime":1671237211578,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"folder":null,"sort":0,"_id":"ALAVJEEP3iJosOoi"}
-{"name":"Terres médianes du rêve","type":"script","scope":"global","author":"Hp9ImM4o9YRTSdfu","img":"systems/foundryvtt-reve-de-dragon/styles/img/ui/icon-tmr-normal.svg","command":"const selected = game.system.rdd.RdDUtility.getSelectedActor();\nif (!selected) {\n  ui.notifications.info('Pas de personnage sélectionné');\n  return;\n}\nif (!selected.isHautRevant()) {\n  ui.notifications.info(`Le personnage ${selected.name} n'a pas le don de haut-rêve`);\n  return;\n}\n\nconst dialogMoral = new Dialog({\n  title: `Monter dans les TMR`,\n  content: `Monter dans les TMR`,\n  buttons: {\n    normale: { label: `normale`, icon: `<img class=\"button-img\" src=\"systems/foundryvtt-reve-de-dragon/styles/img/ui/icon-tmr-normal.svg\" alt=\"Montée dans les Terres M&eacute;dianes !\"/>`, callback: () => selected.displayTMR(\"normal\") },\n    rapide: { label: `rapide`, icon: `<img class=\"button-img\" src=\"systems/foundryvtt-reve-de-dragon/styles/img/ui/icon-tmr-rapide.svg\" alt=\"Montée accélérée dans les Terres M&eacute;dianes !\"/>`, callback: () => selected.displayTMR(\"rapide\") },\n  },\n});\n\ndialogMoral.render(true)","ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3},"flags":{"core":{"sourceId":"Macro.zCAQxg2duk0j3s5r"}},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.15","coreVersion":"10.291","createdTime":1669250715114,"modifiedTime":1671236057731,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"folder":null,"sort":0,"_id":"ERsBfwsodzH6UX4x"}
-{"name":"Signe draconique","type":"chat","author":"Hp9ImM4o9YRTSdfu","img":"systems/foundryvtt-reve-de-dragon/icons/tmr/signe_draconique.webp","scope":"global","command":"/signe +","flags":{"core":{"sourceId":"Macro.RmOLbONUNnINcqCO"}},"ownership":{"default":0,"klwAm8zAKxw8YBLf":3,"Hp9ImM4o9YRTSdfu":3},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.15","coreVersion":"10.291","createdTime":1671237375774,"modifiedTime":1671237375774,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"folder":null,"sort":0,"_id":"MJByzsEdneZ64P56"}
-{"name":"Appel à la chance","type":"script","scope":"global","author":"Hp9ImM4o9YRTSdfu","img":"icons/commodities/flowers/clover.webp","command":"const selected = game.system.rdd.RdDUtility.getSelectedActor();\nif (selected) {\n   selected.rollAppelChance();\n}\nelse {\n  ui.notifications.info('Pas de personnage sélectionné');\n}","ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3},"flags":{"core":{"sourceId":"Macro.XHNbjnGKXaCiCadq"}},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.15","coreVersion":"10.291","createdTime":1671220038331,"modifiedTime":1671233849101,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"folder":null,"sort":0,"_id":"UzAWljmFq5sY702w"}
-{"name":"Encaissement","type":"script","scope":"global","author":"Hp9ImM4o9YRTSdfu","img":"icons/svg/bones.svg","command":"const selected = game.system.rdd.RdDUtility.getSelectedActor();\nif (selected) {\n   selected.encaisser();\n}\nelse {\n  ui.notifications.info('Pas de personnage sélectionné');\n}","ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3},"flags":{"core":{"sourceId":"Macro.XHNbjnGKXaCiCadq"}},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.15","coreVersion":"10.291","createdTime":1671220038331,"modifiedTime":1671234017623,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"folder":null,"sort":0,"_id":"WD6T8AdRbX2Ylxqe"}
-{"name":"Jet quelconque","type":"script","scope":"global","author":"Hp9ImM4o9YRTSdfu","img":"icons/sundries/gaming/dice-runed-tan.webp","command":"const selected = game.system.rdd.RdDUtility.getSelectedActor();\nif (selected) {\n   selected.roll();\n}\nelse {\n  ui.notifications.info('Pas de personnage sélectionné');\n}","ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3},"flags":{"core":{"sourceId":"Macro.XHNbjnGKXaCiCadq"}},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.15","coreVersion":"10.291","createdTime":1671220038331,"modifiedTime":1671233500655,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"folder":null,"sort":0,"_id":"bnJnbKDHpbqY8Pr9"}
+{"name":"Jet de moral","type":"script","author":"Hp9ImM4o9YRTSdfu","img":"icons/magic/control/mouth-smile-deception-purple.webp","scope":"global","command":"const selected = game.system.rdd.RdDUtility.getSelectedActor();\nif (!selected) {\n  ui.notifications.info('Pas de personnage sélectionné');\n  return;\n}\n\nconst dialogMoral = new Dialog({\n  title: `Jet de moral`,\n  content: `Jet de moral en situation`,\n  buttons: {\n    malheureuse: { label: `malheureuse`, icon: \"<i class='fa-regular fa-face-frown'></i>\", callback: () => selected.jetDeMoral('malheureuse') },\n    neutre: { label: `neutre`, icon: \"<i class='fa-regular fa-face-meh'></i>\", callback: () => selected.jetDeMoral('neutre') },\n    heureuse: { label: `heureuse`, icon: \"<i class='fa-regular fa-face-smile'></i>\", callback: () => selected.jetDeMoral('heureuse') }\n  },\n});\n\ndialogMoral.render(true)","ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3},"flags":{"core":{"sourceId":"Macro.aJ0QGnXAXT0WiXbk"}},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"11.1.0","coreVersion":"10.291","createdTime":1671235038906,"modifiedTime":1671236054480,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"folder":null,"sort":0,"_id":"2VvH2rmxV33jGjMU"}
+{"name":"Repos","type":"script","scope":"global","author":"Hp9ImM4o9YRTSdfu","img":"icons/svg/sleep.svg","command":"const selected = game.system.rdd.RdDUtility.getSelectedActor();\nif (selected) {\n  selected.repos();\n}\nelse {\n  ui.notifications.info('Pas de personnage sélectionné');\n}","ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3},"flags":{"core":{"sourceId":"Macro.XHNbjnGKXaCiCadq"}},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"11.1.0","coreVersion":"10.291","createdTime":1671220038331,"modifiedTime":1671234271278,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"folder":null,"sort":0,"_id":"6LRZ8DOVfqotIEsi"}
+{"name":"Météo marine","type":"chat","author":"Hp9ImM4o9YRTSdfu","img":"icons/magic/air/wind-weather-sailing-ship.webp","scope":"global","command":"/meteo","flags":{"core":{"sourceId":"Macro.EPhCYk7PFMPlIFhS"}},"ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"11.1.0","coreVersion":"10.291","createdTime":1671237060687,"modifiedTime":1671237060687,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"folder":null,"sort":0,"_id":"9mYZfKoi4ZYHydxa"}
+{"name":"Chuchoter aux joueurs","type":"script","author":"Hp9ImM4o9YRTSdfu","img":"icons/svg/deaf.svg","scope":"global","command":"/** \n * Provides a dialog to whisper specific players. If you have tokens selected, it will automatically default to try and whisper those players.\n * @Author: Nelson#3570\n */\n\nlet applyChanges = false;\n\nlet users = game.users.filter(user => user.active);\nlet checkOptions = \"\"\nlet playerTokenIds = users.map(u => u.character?.id).filter(id => id !== undefined);\nlet selectedPlayerIds = canvas.tokens.controlled.map(token => {\n  if (playerTokenIds.includes(token.actor.id)) return token.actor.id;\n});\n\n// Build checkbox list for all active players\nusers.forEach(user => {\n  let checked = !!user.character && selectedPlayerIds.includes(user.character.id) && 'checked';\n  checkOptions+=`\n    <br>\n    <input type=\"checkbox\" name=\"${user.id}\" id=\"${user.id}\" value=\"${user.name}\" ${checked}>\\n\n    <label for=\"${user.id}\">${user.name}</label>\n  `\n});\n\nnew Dialog({\n  title:\"Whisper\",\n  content:`Whisper To: ${checkOptions} <br>\n    <label for=\"message\">Message:</label>\n    <textarea id=\"message\" name=\"message\" rows=\"4\" cols=\"50\"></textarea><br>`,\n  buttons:{\n    whisper:{   \n      label:\"Whisper\",\n      callback: (html) => createMessage(html)\n    }\n  }\n}).render(true);\n\nfunction createMessage(html) {\n  var targets = [];\n  // build list of selected players ids for whispers target\n  for ( let user of users ) {\n    if (html.find('[name=\"'+user.id+'\"]')[0].checked){\n      applyChanges=true;\n      targets.push(user.id);\n    }\n    var messageText = html.find('[name=\"message\"]')[0].value\n  }\nif(!applyChanges)return;\n  ChatMessage.create({\n    content: messageText,\n    whisper: targets\n  });\n}","flags":{"core":{"sourceId":"Compendium.foundry_community_macros.community-macros-misc.QTDeg4HOYCAmr4dK"}},"ownership":{"default":2,"Hp9ImM4o9YRTSdfu":3},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"11.1.0","coreVersion":"10.291","createdTime":1671237211578,"modifiedTime":1671237211578,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"folder":null,"sort":0,"_id":"ALAVJEEP3iJosOoi"}
+{"name":"Terres médianes du rêve","type":"script","scope":"global","author":"Hp9ImM4o9YRTSdfu","img":"systems/foundryvtt-reve-de-dragon/styles/img/ui/icon-tmr-normal.svg","command":"const selected = game.system.rdd.RdDUtility.getSelectedActor();\nif (!selected) {\n  ui.notifications.info('Pas de personnage sélectionné');\n  return;\n}\nif (!selected.isHautRevant()) {\n  ui.notifications.info(`Le personnage ${selected.name} n'a pas le don de haut-rêve`);\n  return;\n}\n\nconst dialogMoral = new Dialog({\n  title: `Monter dans les TMR`,\n  content: `Monter dans les TMR`,\n  buttons: {\n    normale: { label: `normale`, icon: `<img class=\"button-img\" src=\"systems/foundryvtt-reve-de-dragon/styles/img/ui/icon-tmr-normal.svg\" alt=\"Montée dans les Terres M&eacute;dianes !\"/>`, callback: () => selected.displayTMR(\"normal\") },\n    rapide: { label: `rapide`, icon: `<img class=\"button-img\" src=\"systems/foundryvtt-reve-de-dragon/styles/img/ui/icon-tmr-rapide.svg\" alt=\"Montée accélérée dans les Terres M&eacute;dianes !\"/>`, callback: () => selected.displayTMR(\"rapide\") },\n  },\n});\n\ndialogMoral.render(true)","ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3},"flags":{"core":{"sourceId":"Macro.zCAQxg2duk0j3s5r"}},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"11.1.0","coreVersion":"10.291","createdTime":1669250715114,"modifiedTime":1671236057731,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"folder":null,"sort":0,"_id":"ERsBfwsodzH6UX4x"}
+{"name":"Signe draconique","type":"chat","author":"Hp9ImM4o9YRTSdfu","img":"systems/foundryvtt-reve-de-dragon/icons/tmr/signe_draconique.webp","scope":"global","command":"/signe +","flags":{"core":{"sourceId":"Macro.RmOLbONUNnINcqCO"}},"ownership":{"default":0,"klwAm8zAKxw8YBLf":3,"Hp9ImM4o9YRTSdfu":3},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"11.1.0","coreVersion":"10.291","createdTime":1671237375774,"modifiedTime":1671237375774,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"folder":null,"sort":0,"_id":"MJByzsEdneZ64P56"}
+{"name":"Appel à la chance","type":"script","scope":"global","author":"Hp9ImM4o9YRTSdfu","img":"icons/commodities/flowers/clover.webp","command":"const selected = game.system.rdd.RdDUtility.getSelectedActor();\nif (selected) {\n   selected.rollAppelChance();\n}\nelse {\n  ui.notifications.info('Pas de personnage sélectionné');\n}","ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3},"flags":{"core":{"sourceId":"Macro.XHNbjnGKXaCiCadq"}},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"11.1.0","coreVersion":"10.291","createdTime":1671220038331,"modifiedTime":1671233849101,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"folder":null,"sort":0,"_id":"UzAWljmFq5sY702w"}
+{"name":"Encaissement","type":"script","scope":"global","author":"Hp9ImM4o9YRTSdfu","img":"icons/svg/bones.svg","command":"const selected = game.system.rdd.RdDUtility.getSelectedActor();\nif (selected) {\n   selected.encaisser();\n}\nelse {\n  ui.notifications.info('Pas de personnage sélectionné');\n}","ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3},"flags":{"core":{"sourceId":"Macro.XHNbjnGKXaCiCadq"}},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"11.1.0","coreVersion":"10.291","createdTime":1671220038331,"modifiedTime":1671234017623,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"folder":null,"sort":0,"_id":"WD6T8AdRbX2Ylxqe"}
+{"name":"Jet quelconque","type":"script","scope":"global","author":"Hp9ImM4o9YRTSdfu","img":"icons/sundries/gaming/dice-runed-tan.webp","command":"const selected = game.system.rdd.RdDUtility.getSelectedActor();\nif (selected) {\n   selected.roll();\n}\nelse {\n  ui.notifications.info('Pas de personnage sélectionné');\n}","ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3},"flags":{"core":{"sourceId":"Macro.XHNbjnGKXaCiCadq"}},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"11.1.0","coreVersion":"10.291","createdTime":1671220038331,"modifiedTime":1671233500655,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"folder":null,"sort":0,"_id":"bnJnbKDHpbqY8Pr9"}
 {"name":"Recherche et tirage","type":"script","scope":"global","author":"Hp9ImM4o9YRTSdfu","img":"icons/tools/scribal/magnifying-glass.webp","command":"game.system.rdd.commands.tirage()","ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3},"flags":{"core":{"sourceId":"Macro.ZFWPNdQBjQs9z0YW"}},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.5.4","coreVersion":"10.291","createdTime":1673472449426,"modifiedTime":1673655461651,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"folder":null,"sort":0,"_id":"iVZnxOxhCMpkvYh3"}
 {"name":"Thème astral","type":"script","scope":"global","author":"Hp9ImM4o9YRTSdfu","img":"icons/magic/nature/symbol-moon-stars-white.webp","command":"game.system.rdd.AppAstrologie.create()","ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3},"flags":{"core":{"sourceId":"Macro.oA0HPFeFK6YMspAX"}},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.6.19","coreVersion":"10.291","createdTime":1678127868791,"modifiedTime":1678237392810,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"folder":null,"sort":0,"_id":"koqhiDJSGP4gQ4vf"}
-{"name":"Jet d'éthylisme","type":"script","scope":"global","author":"Hp9ImM4o9YRTSdfu","img":"icons/consumables/drinks/alcohol-beer-stein-wooden-metal-brown.webp","command":"const selected = game.system.rdd.RdDUtility.getSelectedActor();\nif (selected) {\n   selected.jetEthylisme();\n}\nelse {\n  ui.notifications.info('Pas de personnage sélectionné');\n}","ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3},"flags":{"core":{"sourceId":"Macro.XHNbjnGKXaCiCadq"}},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.15","coreVersion":"10.291","createdTime":1671220038331,"modifiedTime":1671233646086,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"folder":null,"sort":0,"_id":"mvub1dRHNFmWjRr7"}
-{"name":"Tirer le tarot","type":"chat","scope":"global","author":"Hp9ImM4o9YRTSdfu","img":"systems/foundryvtt-reve-de-dragon/icons/tarots/dos-tarot.webp","command":"/tirer tarot","ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3},"flags":{"core":{"sourceId":"Macro.HBZSKR9OHCQbLcTC"}},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.15","coreVersion":"10.291","createdTime":1669469547231,"modifiedTime":1671237401618,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"folder":null,"sort":0,"_id":"vTfJTFYYiRu8X5LM"}
+{"name":"Jet d'éthylisme","type":"script","scope":"global","author":"Hp9ImM4o9YRTSdfu","img":"icons/consumables/drinks/alcohol-beer-stein-wooden-metal-brown.webp","command":"const selected = game.system.rdd.RdDUtility.getSelectedActor();\nif (selected) {\n   selected.jetEthylisme();\n}\nelse {\n  ui.notifications.info('Pas de personnage sélectionné');\n}","ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3},"flags":{"core":{"sourceId":"Macro.XHNbjnGKXaCiCadq"}},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"11.1.0","coreVersion":"10.291","createdTime":1671220038331,"modifiedTime":1671233646086,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"folder":null,"sort":0,"_id":"mvub1dRHNFmWjRr7"}
+{"name":"Tirer le tarot","type":"chat","scope":"global","author":"Hp9ImM4o9YRTSdfu","img":"systems/foundryvtt-reve-de-dragon/icons/tarots/dos-tarot.webp","command":"/tirer tarot","ownership":{"default":0,"Hp9ImM4o9YRTSdfu":3},"flags":{"core":{"sourceId":"Macro.HBZSKR9OHCQbLcTC"}},"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"11.1.0","coreVersion":"10.291","createdTime":1669469547231,"modifiedTime":1671237401618,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"},"folder":null,"sort":0,"_id":"vTfJTFYYiRu8X5LM"}
+{"name": "Mon personnage","type": "script","author": "Hp9ImM4o9YRTSdfu","img": "systems/foundryvtt-reve-de-dragon/icons/voyageurs/token_hr_dilettante.webp","scope": "global","command": "if (game.user.isGM) {\n  ui.notifications.warn(\"En tant que gardien, vous n'avez pas de personnage attitré\")\n  return\n}\nconst actor = game.users.get(game.userId)?.character\nif (!actor) {\n  ui.notifications.warn(\"Vous n'avez pas de personnage attitré\")\n  return\n}\nactor.sheet.render(true)","folder": null,"flags": {"core": {},"exportSource": {"world": "graine","system": "foundryvtt-reve-de-dragon","coreVersion": "11.313","systemVersion": "11.1.1"}},"_stats": {"systemId": "foundryvtt-reve-de-dragon","systemVersion": "11.1.1","coreVersion": "11.313","createdTime": 1699477824379,"modifiedTime": 1699485023429,"lastModifiedBy": "Hp9ImM4o9YRTSdfu"}}

packs/taches-courantes.db

@@ -1,3 +0,0 @@
-{"_id":"dlvK5Lks7WoSZ1Ko","name":"1er soins - Blessure critique","type":"tache","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.taches-courantes.dlvK5Lks7WoSZ1Ko"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_chirurgie.webp","effects":[],"system":{"description":"<p><span class=\"fontstyle0\">Effectuer les premiers soins consiste &agrave; obtenir le nombre de points de t&acirc;che demand&eacute; par la blessure. Un minimum de mat&eacute;riel est n&eacute;cessaire : de l&rsquo;eau, des chiffons propres pour servir de pansements.</span></p>\n<p>&nbsp;</p>","descriptionmj":"","carac":"dexterite","competence":"Chirurgie","periodicite":"1 round","fatigue":0,"difficulte":-6,"points_de_tache":6,"points_de_tache_courant":0,"nb_jet_echec":0,"nb_jet_succes":0,"cacher_points_de_tache":false},"ownership":{"default":0,"Q2G6GTdrotKzYGUC":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671050458426,"modifiedTime":1671050514673,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
-{"_id":"lHdfav9mvs68yj7J","name":"1er soins - Blessure légère","type":"tache","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.taches-courantes.lHdfav9mvs68yj7J"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_chirurgie.webp","effects":[],"system":{"description":"<p><span class=\"fontstyle0\">Effectuer les premiers soins consiste &agrave; obtenir le nombre de points de t&acirc;che demand&eacute; par la blessure. Un minimum de mat&eacute;riel est n&eacute;cessaire : de l&rsquo;eau, des chiffons propres pour servir de pansements.</span></p>\n<p>&nbsp;</p>","descriptionmj":"","carac":"dexterite","competence":"Chirurgie","periodicite":"1 round","fatigue":0,"difficulte":-2,"points_de_tache":2,"points_de_tache_courant":0,"nb_jet_echec":0,"nb_jet_succes":0,"cacher_points_de_tache":false},"ownership":{"default":0,"Q2G6GTdrotKzYGUC":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671050458426,"modifiedTime":1671050514673,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}
-{"_id":"nbkuXbhgSxHwXD4t","name":"1er soins - Blessure grave","type":"tache","flags":{"core":{"sourceId":"Compendium.foundryvtt-reve-de-dragon.taches-courantes.nbkuXbhgSxHwXD4t"}},"img":"systems/foundryvtt-reve-de-dragon/icons/competence_chirurgie.webp","effects":[],"system":{"description":"<p><span class=\"fontstyle0\">Effectuer les premiers soins consiste &agrave; obtenir le nombre de points de t&acirc;che demand&eacute; par la blessure. Un minimum de mat&eacute;riel est n&eacute;cessaire : de l&rsquo;eau, des chiffons propres pour servir de pansements.</span></p>\n<p>&nbsp;</p>","descriptionmj":"","carac":"dexterite","competence":"Chirurgie","periodicite":"1 round","fatigue":0,"difficulte":-4,"points_de_tache":4,"points_de_tache_courant":0,"nb_jet_echec":0,"nb_jet_succes":0,"cacher_points_de_tache":false},"ownership":{"default":0,"Q2G6GTdrotKzYGUC":3},"folder":null,"sort":0,"_stats":{"systemId":"foundryvtt-reve-de-dragon","systemVersion":"10.3.13","coreVersion":"10.291","createdTime":1671050458427,"modifiedTime":1671050514673,"lastModifiedBy":"Hp9ImM4o9YRTSdfu"}}

styles/simple.css

@@ -171,6 +171,9 @@ i:is(.fas, .far) {
   width: fit-content;
 }
 
+.tmr-dialog table {
+  border: none;
+}
 .system-foundryvtt-reve-de-dragon .sheet-header div.tmr-buttons {
   padding: 0;
   margin: 0;
@@ -773,7 +776,7 @@ input:is(.blessure-premiers_soins, .blessure-soins_complets) {
 }
 .rdd-diviseur{
   border-radius: 6px; padding: 3px;
-  background: var(--gradient-silver-light);
+  background: var(--gradient-red);
 }
 
 .rdd-niveau-requis{

system.json

@@ -1,14 +1,13 @@
 {
   "id": "foundryvtt-reve-de-dragon",
   "title": "Rêve de Dragon",
-  "version": "11.0.10",
-  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-11.0.10.zip",
+  "version": "11.1.4",
+  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-11.1.4.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": {
     "minimum": "11",
-    "verified": "11",
-    "maximum": "11"
+    "verified": "11"
   },
   "description": "Rêve de Dragon RPG for FoundryVTT",
   "authors": [

template.json

@@ -393,12 +393,6 @@
             "label": "Encombrement",
             "derivee": true
           },
-          "malusarmure": {
-            "type": "number",
-            "value": 0,
-            "label": "Malus Armure",
-            "derivee": true
-          },
           "protection": {
             "type": "number",
             "value": 0,
@@ -594,7 +588,8 @@
       "iscombat": false,
       "isnaturelle": true,
       "ispossession": false,
-      "dommages": 0
+      "dommages": 0,
+      "mortalite": "mortel"
     },
     "empoignade": {
       "templates": ["description"],
@@ -671,6 +666,7 @@
       "resistance": 0,
       "categorie_parade": "",
       "dommages": "0",
+      "mortalite": "mortel",
       "penetration": 0,
       "force": "0",
       "competence": "",

templates/actor/archetype.hbs

@@ -12,7 +12,7 @@
 
         <li class="item flexrow">
           <label class="generic-label">
-              Niveaux {{numberFormat archetype.niveau decimals=0 sign=true}} : {{archetype.nombre}} / {{archetype.nombreMax}} 
+              Niveaux {{plusMoins archetype.niveau}} : {{archetype.nombre}} / {{archetype.nombreMax}} 
           </label>
         </li>
       {{/each}}

templates/actor/carac-derivee.html

@@ -68,11 +68,11 @@
   </li>  
   <li class="caracteristique flexrow list-item" >
     <label class="carac-label">Bonus dom.</label>
-    <input class="derivee-value" type="text" disabled value="{{numberFormat system.attributs.plusdom.value decimals=0 sign=true}}"/>
+    <input class="derivee-value" type="text" disabled value="{{plusMoins system.attributs.plusdom.value}}"/>
   </li>  
   <li class="caracteristique flexrow list-item" >
     <label class="carac-label">Malus armure</label>
-    <input class="derivee-value" type="number" disabled value="{{system.attributs.malusarmure.value}}" data-dtype="number"/>
+    <input class="derivee-value" type="number" disabled value="{{calc.malusArmure}}" data-dtype="number"/>
   </li>  
   <li class="caracteristique flexrow list-item">
     <label class="carac-label" for="system.attributs.protection.value" >Protection naturelle</label>

templates/actor/combat.html

@@ -20,8 +20,8 @@
       </a>
       ({{arme.system.competence}})
     </span>
-    <span class="competence-value">{{numberFormat arme.system.niveau decimals=0 sign=true}}</span>
-    <span class="competence-value">{{numberFormat arme.system.dommagesReels decimals=0 sign=true}}</span>
+    <span class="competence-value">{{plusMoins arme.system.niveau}}</span>
+    <span class="competence-value">{{plusMoins arme.system.dommagesReels}}</span>
     <span class="competence-value"></span>
     <span class="initiative-value arme-initiative"><a>{{arme.system.initiative}}</a></span>
   </li>
@@ -34,7 +34,7 @@
         <span>{{esq.name}}</span>
       </a>
     </span>
-    <span class="competence-value">{{numberFormat esq.system.niveau decimals=0 sign=true}}</span>
+    <span class="competence-value">{{plusMoins esq.system.niveau}}</span>
     <span class="competence-value"></span>
     <span class="competence-value"></span>
     <span class="initiative-value"></span>

templates/actor/comp-creature.html

@@ -11,13 +11,13 @@
       {{#unless @root.options.vueDetaillee}}disabled{{/unless}}/>
     <input class="competence-value creature-niveau" type="text" data-dtype="number"
       compname="{{comp.name}}" name="{{comp._id}}.niveau"
-      value="{{numberFormat comp.system.niveau decimals=0 sign=true}}" 
+      value="{{plusMoins comp.system.niveau}}" 
       {{#unless @root.options.vueDetaillee}}disabled{{/unless}}
       />
     <input class="competence-damage creature-dommages" type="text" data-dtype="number" 
       {{#if comp.isdommages}}
         compname="{{comp.name}}" name="{{comp._id}}.dommages"
-        value="{{numberFormat comp.system.dommages decimals=0 sign=true}}" 
+        value="{{plusMoins comp.system.dommages}}" 
         {{#unless @root.options.vueDetaillee}}disabled{{/unless}}
       {{else}}disabled{{/if}}
       />

templates/actor/competence.html

@@ -13,7 +13,7 @@
     {{/if}}
 
     <input class="competence-value" type="text" compname="{{name}}" name="comp-value-{{name}}"
-          value="{{numberFormat system.niveau decimals=0 sign=true}}" data-dtype="number"
+          value="{{plusMoins system.niveau}}" data-dtype="number"
           {{#if (or (not @root.options.vueDetaillee) @root.options.vueArchetype)}}disabled{{/if}} />
 
     {{#if @root.options.vueDetaillee}}
@@ -42,7 +42,7 @@
       <i class="far fa-circle"></i>
       {{/if}}
       <input class="competence-archetype niveau-archetype" type="text" compname="{{name}}" name="comp-archetype-{{name}}"
-            value="{{numberFormat system.niveau_archetype decimals=0 sign=true}}" data-dtype="number"
+            value="{{plusMoins system.niveau_archetype}}" data-dtype="number"
             {{#if (not @root.options.vueArchetype)}}disabled{{/if}} />
       <a class="item-edit" title="Modifier"><i class="fas fa-edit"></i></a>
       {{#if @root.options.isGM}}

templates/chat-actor-turn-acteur.hbs

@@ -0,0 +1 @@
+<h4>C'est au tour de {{alias}} !</h4>

templates/chat-actor-turn-sante.hbs

@@ -1,4 +1,4 @@
-<h4>C'est au tour de {{alias}} !</h4>
+<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>
 {{#if isGrave}}
@@ -6,5 +6,7 @@
 {{/if}}
 {{#if isCritique}}
 <div>{{alias}} souffre d'une <strong>Blessure Critique</strong> : faites un 
-  <a id="chat-jet-vie" class="chat-card-button" data-actorId="{{actorId}}">Jet de Vie.<a></div>
+  <a class="chat-card-button chat-jet-vie"
+   data-tokenId="{{tokenId}}"
+   data-actorId="{{actorId}}">Jet de Vie.<a></div>
 {{/if}}

templates/chat-demande-defense.html

@@ -63,11 +63,9 @@
       {{/unless}}
     <a class='chat-card-button' id='encaisser-button' data-attackerId='{{attackerId}}'
       data-defenderTokenId='{{defenderTokenId}}'>
-      Encaisser à {{#if (eq dmg.mortalite 'non-mortel')~}}
-      ({{numberFormat dmg.total decimals=0 sign=true}})
-      {{~else~}}
-      {{numberFormat dmg.total decimals=0 sign=true}}
-      {{~/if}} !
+      Encaisser à {{plusMoins dmg.total}}
+      {{#if (eq dmg.mortalite 'non-mortel')~}}
+      (non-mortel) !
     </a>
   </span>
 </div>

templates/chat-info-appel-au-moral.html

@@ -1,6 +1,6 @@
 {{#if use.moral}}
 <span>
-  Vous avez fait appel {{#if (gt moral 0)}}au moral{{else}}à l'énergie du déspoir{{/if}}
+  Vous avez fait appel {{#if (gt moral 0)}}au moral{{else}}à l'énergie du désespoir{{/if}}
   {{#if (eq perteMoralEchec 'dissolution')}}et échoué, cous marquez un point de dissolution!.
   {{else if (eq perteMoralEchec 'perte')}}et échoué, votre moral baisse à {{moral}}.
   {{else}}et réussi, votre moral reste de {{moral}}.

templates/chat-infojet.html

@@ -1,6 +1,6 @@
 <div>
   <span {{#if ajustements}}class="tooltip tooltip-dotted" {{/if}}>
-    {{rolled.caracValue}} à {{numberFormat rolled.finalLevel decimals=0 sign=true}}
+    {{rolled.caracValue}} à {{plusMoins rolled.finalLevel}}
     {{#if ajustements}}
     <div class="tooltiptext ttt-ajustements">
       {{#each ajustements as |item key|}}
@@ -9,7 +9,7 @@
         {{#if item.descr}}
         {{{item.descr}}}
         {{else}}
-        {{item.label}}: {{numberFormat item.value decimals=0 sign=true}}
+        {{item.label}}: {{plusMoins item.value}}
         {{/if}}
       </div>
       {{/if}}
@@ -19,10 +19,13 @@
     {{#if rolled.factorHtml}}<span class="rdd-diviseur">&times;{{{rolled.factorHtml}}}</span>{{/if}}
   </span>
   <span>= {{rolled.score}}%</span>
+  {{#if rolled.factorHtml}}
+  <span class="rdd-diviseur">&times;{{{rolled.factorHtml}}}</span>
+  {{/if}}
 </div>
 <div>
   <span>{{rolled.roll}} : </span><span class="rdd-roll-{{rolled.code}} strong-text">{{rolled.quality}}</span>
   {{#if rolled.ajustementNecessaire}}
-  <span class="rdd-niveau-requis">(Réussite si {{numberFormat rolled.niveauNecessaire decimals=0 sign=true}} / avec niveau {{numberFormat rolled.ajustementNecessaire decimals=0 sign=true}}) </span>
+  <span class="rdd-niveau-requis">(Réussite si {{plusMoins rolled.niveauNecessaire}} / avec niveau {{plusMoins rolled.ajustementNecessaire}}) </span>
   {{/if}}
 </div>

templates/chat-resultat-attaque.html

@@ -20,11 +20,11 @@
  {{#if rolled.isSuccess}}
   <span><strong>{{show.cible}}</strong> doit se défendre à <strong>{{diffLibre}}</strong>, ou encaisser à
     {{~#if (eq dmg.mortalite 'non-mortel')}}
-    <span class="rdd-roll-norm">({{numberFormat dmg.total decimals=0 sign=true}})</span> (dommages non-mortel)
+    <span class="rdd-roll-norm">({{plusMoins dmg.total}})</span> (non-mortel)
     {{else if (eq dmg.mortalite 'mortel')}}
-    <span class="rdd-roll-echec">{{numberFormat dmg.total decimals=0 sign=true}}</span>
+    <span class="rdd-roll-echec">{{plusMoins dmg.total}}</span>
     {{else}}
-    <span class="rdd-roll-etotal">{{numberFormat dmg.total decimals=0 sign=true}}</span> (entités de cauchemar)
+    <span class="rdd-roll-etotal">{{plusMoins dmg.total}}</span> (entités de cauchemar)
     {{~/if}}.
     {{#if show.isRecul}}Si votre adversaire n'esquive pas, il devra résister à l'impact ou reculer sous le choc!{{/if}}
   </span>

templates/chat-resultat-chant.html

@@ -1,14 +1,14 @@
 <img class="chat-icon" src="{{competence.img}}" alt="{{oeuvre.system.competence}}" />
 <h4>
-  {{alias}} tente de chanter : {{oeuvre.name}} (niveau {{oeuvre.system.niveau}})
+  {{alias}} {{#if rolled.isSuccess}}chante{{else}}tente de chanter{{/if}} {{oeuvre.name}} (niveau {{oeuvre.system.niveau}})
 </h4>
 {{> "systems/foundryvtt-reve-de-dragon/templates/chat-infojet.html"}}
 <hr>
 <div>
   {{#if rolled.isSuccess}}
-  {{alias}} réussi son interprétation avec une qualité de {{qualiteFinale}} . 
+  {{alias}} réussit son interprétation avec une qualité de {{qualiteFinale}} . 
   {{else}}
-  {{alias}} est peu inspiré(e) et son interprétation a une qualité de {{qualiteFinale}}.
+  {{alias}} manque d'inspiration, son interprétation a une qualité de {{qualiteFinale}}.
   {{/if}}
   {{> "systems/foundryvtt-reve-de-dragon/templates/chat-info-appel-au-moral.html"}}
 </div>

templates/chat-resultat-competence.html

@@ -10,7 +10,7 @@
 {{> "systems/foundryvtt-reve-de-dragon/templates/chat-infojet.html"}}
 <hr>
 <div>
-  <span>{{#if rolled.ptTache}}{{rolled.ptTache}} points de tâche{{/if}}{{#if rolled.ptQualite}}{{#if rolled.ptTache}},{{/if}} Qualité ajustée de {{numberFormat rolled.ptQualite decimals=0 sign=true}}{{/if}}</span>
+  <span>{{#if rolled.ptTache}}{{rolled.ptTache}} points de tâche{{/if}}{{#if rolled.ptQualite}}{{#if rolled.ptTache}},{{/if}} Qualité ajustée de {{rolled.ptQualite}}{{/if}}</span>
 </div>
 {{> "systems/foundryvtt-reve-de-dragon/templates/chat-info-appel-au-moral.html"}}
 {{~#if show.explications}}

templates/chat-resultat-danse.html

@@ -1,14 +1,14 @@
 <img class="chat-icon" src="{{competence.img}}" alt="{{oeuvre.system.competence}}" />
 <h4>
-  {{alias}} tente de danser : {{oeuvre.name}} (niveau {{oeuvre.system.niveau}})
+  {{alias}} {{#if rolled.isSuccess}}danse{{else}}tente de danser{{/if}} {{oeuvre.name}} (niveau {{oeuvre.system.niveau}})
 </h4>
 {{> "systems/foundryvtt-reve-de-dragon/templates/chat-infojet.html"}}
 <hr>
 <div>
   {{#if rolled.isSuccess}}
-  {{alias}} réussi son interprétation avec une qualité de {{qualiteFinale}} . 
+  {{alias}} réussit son interprétation avec une qualité de {{qualiteFinale}} . 
   {{else}}
-  {{alias}} est peu inspiré(e) et son interprétation a une qualité de {{qualiteFinale}}.
+  {{alias}} manque d'inspiration, son interprétation a une qualité de {{qualiteFinale}}.
   {{/if}}
   {{> "systems/foundryvtt-reve-de-dragon/templates/chat-info-appel-au-moral.html"}}
 </div>

templates/chat-resultat-encaissement.html

@@ -10,7 +10,7 @@
 {{else}}
 <h4>{{alias}} encaisse à
   <span>
-    {{numberFormat dmg.total decimals=0 sign=true}}
+    {{plusMoins dmg.total}}
     {{#if (eq dmg.mortalite 'non-mortel')~}}(coups non mortels)
     {{~else if (eq dmg.mortalite 'entiteincarnee')}}(entité incarnée)
     {{~/if}}
@@ -26,7 +26,7 @@
   {{#if (eq dmg.mortalite 'entiteincarnee')}}subit le coup
   {{else if mort}}vient de mourir
   {{else if blessure}}
-    {{#if (gt blessure.system.gravite 0)}}subit une blessure {{blessure.system.labelGravite}}
+    {{#if (gt blessure.system.gravite 0)}}subit une blessure {{blessure.system.label}}
     {{else}}subit une contusion
     {{~/if~}}
   {{else}}s'en sort sans une égratignure
@@ -44,7 +44,7 @@
   {{#if (ne dmg.mortalite 'entiteincarnee')}}
   {{#if (gt endurance 1)}}et
   {{#if sonne}}est <strong>sonné</strong><img class="chat-icon" src="icons/svg/stoned.svg" alt="charge" height="16" width="16" /> jusqu'à la fin du prochain round{{else}}n'est pas sonné{{/if}}!
-  {{#if hasPlayerOwner}}Jet d'endurance : Jet d'endurance : {{jetEndurance}} / {{resteEndurance}}{{/if}}
+  {{#if hasPlayerOwner}}Jet d'endurance : {{jetEndurance}} / {{resteEndurance}}{{/if}}
   {{/if}}
   {{/if}}
   {{/if}}

templates/chat-resultat-general.html

@@ -5,13 +5,13 @@
   {{alias}} {{#if show.title}}{{show.title}}: {{/if}}
   {{#if selectedCarac}}{{selectedCarac.label}}
     {{#if competence}}{{#unless (eq selectedCarac.label competence.name)}} / {{competence.name}}{{/unless}}{{/if}}
-    à {{diffLibre}}
+    à {{plusMoins diffLibre}}
   {{/if}}
 </h4>
 {{> "systems/foundryvtt-reve-de-dragon/templates/chat-infojet.html"}}
 <hr>
 <div>
-  <span>{{#if rolled.ptTache}}{{rolled.ptTache}} points de tâche{{/if}}{{#if rolled.ptQualite}}{{#if rolled.ptTache}},{{/if}} ajustement Qualité {{numberFormat rolled.ptQualite decimals=0 sign=true}}{{/if}}</span>
+  <span>{{#if rolled.ptTache}}{{rolled.ptTache}} points de tâche{{/if}}{{#if rolled.ptQualite}}{{#if rolled.ptTache}},{{/if}} ajustement Qualité {{rolled.ptQualite}}{{/if}}</span>
   {{> "systems/foundryvtt-reve-de-dragon/templates/chat-info-appel-au-moral.html"}}
 </div>
 {{~#if show.explications}}

templates/chat-resultat-meteo.html

@@ -3,7 +3,7 @@
 <ul>
   <li>Vent: {{lowerFirst vent.description}} {{apostrophe 'de' vent.direction}}, force {{vent.force}}</li>
   <li>Mer {{lowerFirst mer.description}}, {{apostrophe 'de' mer.direction}}, force {{mer.force}}</li>
-  <li>Température {{lowerFirst temperature.description}} ({{numberFormat temperature.force decimals=0 sign=true}})</li>
+  <li>Température {{lowerFirst temperature.description}} ({{plusMoins temperature.force}})</li>
   <li>Couverture nuageuse: {{lowerFirst nuage.description}}</li>
   <li>Pluie: {{lowerFirst pluie.description}}</li>
 </div>

templates/chat-resultat-musique.html

@@ -1,6 +1,6 @@
 <img class="chat-icon" src="{{competence.img}}" alt="{{oeuvre.system.competence}}" />
 <h4>
-  {{alias}} tente de jouer le morceau : {{oeuvre.name}} (niveau {{oeuvre.system.niveau}})
+  {{alias}} {{#if rolled.isSuccess}}interprete{{else}}tente de jouer{{/if}} le morceau : {{oeuvre.name}} (niveau {{oeuvre.system.niveau}})
 </h4>
 {{> "systems/foundryvtt-reve-de-dragon/templates/chat-infojet.html"}}
 <hr>
@@ -8,7 +8,7 @@
   {{#if rolled.isSuccess}}
   {{alias}} réussit son interprétation avec une qualité de {{qualiteFinale}} . 
   {{else}}
-  {{alias}} est peu inspiré(e) et son interprétation a une qualité de {{qualiteFinale}}.
+  {{alias}} manque d'inspiration, son interprétation a une qualité de {{qualiteFinale}}.
   {{/if}}
   {{> "systems/foundryvtt-reve-de-dragon/templates/chat-info-appel-au-moral.html"}}
 </div>

templates/chat-resultat-oeuvre.html

@@ -7,9 +7,9 @@
 <hr>
 <div>
   {{#if rolled.isSuccess}}
-  {{alias}} réussi son interprétation avec une qualité de {{qualiteFinale}} . 
+  {{alias}} réussit son interprétation avec une qualité de {{qualiteFinale}} . 
   {{else}}
-  {{alias}} est peu inspiré(e) et son interprétation a une qualité de {{qualiteFinale}}.
+  {{alias}} manque d'inspiration, son interprétation a une qualité de {{qualiteFinale}}.
   {{/if}}
   {{> "systems/foundryvtt-reve-de-dragon/templates/chat-info-appel-au-moral.html"}}
 </div>

templates/chat-resultat-recettecuisine.html

@@ -1,6 +1,6 @@
 <img class="chat-icon" src="{{competence.img}}" alt="{{oeuvre.system.competence}}" />
 <h4>
-  {{alias}} tente de cuisiner la recette : {{oeuvre.name}} (niveau {{oeuvre.system.niveau}})
+  {{alias}} {{#if rolled.isSuccess}}réalise{{else}}tente de cuisiner{{/if}} la recette : {{oeuvre.name}} (niveau {{oeuvre.system.niveau}})
 </h4>
 {{> "systems/foundryvtt-reve-de-dragon/templates/chat-infojet.html"}}
 <hr>

templates/dialog-item-achat.html

@@ -64,14 +64,17 @@
     {{/if}}
     {{#if (gt item.system.qualite 0)}}
       {{#if (gt item.system.qualite cuisine.system.niveau)}}
-      <p>La qualité du plat est telle qu'un jet de Goût/Cuisine à {{numberFormat item.system.qualite decimals=0 sign=true}}
-        vous permettra un jet de moral heureux.</p>
+      <p>La qualité du plat est telle qu'un jet de Goût réussi vous permettra un jet de moral heureux.</p>
       {{/if}}
     {{/if}}
     
     {{#if (or (lt item.system.qualite 0) (lt item.system.exotisme 0))}}
       <p>
-        Pour surmonter {{#if (lt item.system.qualite 0)}}le mauvais goût{{else}}l'exotisme{{/if}}, vous devez effectuer un jet de Volonté/Cuisine à {{numberFormat (min item.system.exotisme item.system.qualite) decimals=0 sign=true}}.
+        {{#if (lt item.system.qualite 0)}}
+        Pour surmonter le mauvais goût, vous devez effectuer un jet de Volonté à {{plusMoins (min item.system.exotisme item.system.qualite)}}.
+        {{else}}
+        Pour surmonter l'exotisme, vous devez effectuer un jet de Volonté/Cuisine à {{plusMoins (min item.system.exotisme)}}.
+        {{/if}}
       <br/>
         <input class="attribute-value se-forcer" type="checkbox" name="se-forcer" {{#if choix.seForcer}}checked{{/if}}>
           <label for="se-forcer">En cas d'échec, voulez-vous vous forcer à manger (et subir un jet de moral en situation malheureuse)?</label>

templates/dialog-item-consommer.html

@@ -19,14 +19,17 @@
   {{/if}}
   {{#if (gt item.system.qualite 0)}}
   {{#if (gt item.system.qualite cuisine.system.niveau)}}
-  <p>La qualité du plat est telle qu'un jet de Goût/Cuisine à {{numberFormat item.system.qualite decimals=0 sign=true}}
-    vous permettra un jet de moral heureux.</p>
+  <p>La qualité du plat est telle qu'un jet de Goût vous permettra un jet de moral heureux.</p>
   {{/if}}
   {{/if}}
 
   {{#if (or (lt item.system.qualite 0) (lt item.system.exotisme 0))}}
   <p>
-    Pour surmonter {{#if (lt item.system.qualite 0)}}le mauvais goût{{else}}l'exotisme{{/if}}, vous devez effectuer un jet de Volonté/Cuisine à {{numberFormat (min item.system.exotisme item.system.qualite) decimals=0 sign=true}}.
+    {{#if (lt item.system.qualite 0)}}
+    Pour surmonter le mauvais goût, vous devez effectuer un jet de Volonté à {{plusMoins (min item.system.exotisme item.system.qualite)}}.
+    {{else}}
+    Pour surmonter l'exotisme, vous devez effectuer un jet de Volonté/Cuisine à {{plusMoins (min item.system.exotisme)}}.
+    {{/if}}
   <br/>
     <input class="attribute-value se-forcer" type="checkbox" name="se-forcer" {{#if choix.seForcer}}checked{{/if}}>
       <label for="se-forcer">En cas d'échec, voulez-vous vous forcer à manger (et subir un jet de moral en situation malheureuse)?</label>

templates/dialog-roll-alchimie.html

@@ -6,7 +6,7 @@
       <div class="grid grid-2col">
         <label>{{alchimie.tache}}:</label><label class="flex-grow">{{alchimie.texte}}</label>
         <label>Caractéristique: </label><label class="flex-grow">{{selectedCarac.label}}</label>
-        <label>{{competence.name}}:</label><label class="flex-grow">{{numberFormat competence.system.niveau decimals=0 sign=true}}</label></label>
+        <label>{{competence.name}}:</label><label class="flex-grow">{{plusMoins competence.system.niveau}}</label></label>
       </div>
     </div>
     <div class="flex-group-left">

templates/dialog-roll-chant.html

@@ -6,7 +6,7 @@
       <img class="chat-icon" src="{{competence.img}}" alt="{{competence.name}}" />
       <div class="grid grid-2col">
         <label>Caractéristique: </label><label class="flex-grow">{{selectedCarac.label}}</label>
-        <label>{{competence.name}}:</label><label class="flex-grow">{{numberFormat competence.system.niveau decimals=0 sign=true}}</label></label>
+        <label>{{competence.name}}:</label><label class="flex-grow">{{plusMoins competence.system.niveau}}</label></label>
       </div>
       {{> "systems/foundryvtt-reve-de-dragon/templates/partial-description-overflow.html" oeuvre.system}}
     </div>

templates/dialog-roll-competence.html

@@ -1,13 +1,29 @@
 <form class="skill-roll-dialog">
+  <img class="chat-icon" src="{{competence.img}}" alt="{{competence.name}}"/>
   <h2 class="dialog-roll-title"></h2>
 
   <div class="grid grid-2col">
     <div class="flex-group-left">
-      <img class="chat-icon" src="{{competence.img}}" alt="{{competence.name}}"/>
       <div class="flexrow">
         <label>Caractéristique</label>
-        {{>"systems/foundryvtt-reve-de-dragon/templates/partial-select-carac.html"}}
+        <span>
+          {{>"systems/foundryvtt-reve-de-dragon/templates/partial-select-carac.html"}}
+        </span>
       </div>
+      {{#if targetToken}}
+      <div class="flexrow">
+        <label>Cible:</label>
+        <label>
+          <img class="sheet-competence-img" src="{{targetToken.img}}" title="{{targetToken.name}}" />
+          {{targetToken.name}}
+        </label>
+      </div>
+      {{/if}}
+      {{#if ajustements.attaqueDefenseurSurpris.used}}
+      <div class="flexrow">
+        <label>{{ajustements.attaqueDefenseurSurpris.label}}</label>
+      </div>
+      {{/if}}
       {{#if arme}}
         {{#if attackerRoll}}
           {{#if attackerRoll.tactique}}
@@ -27,41 +43,28 @@
             <div class="tooltiptext ttt-ajustements">
               <div>
                 <strong>Charge</strong> : Les longueurs d'armes n'interviennent pas dans la charge, il faut gérer une initiative aléatoire dans ce cas.
-                <br><strong>Feinte</strong> : Vous devez avoir l'initative sur votre adversaire et y renoncer.
+                <br>
+                <strong>Feinte</strong> : Vous devez avoir l'initative sur votre adversaire et y renoncer.
               </div>
             </div>
           </span>
         </div>
-        {{/if}}
-        {{#if targetToken}}
-        <div class="flexrow">
-          Cible: {{targetToken.name}}
-          <img class="sheet-competence-img" src="{{targetToken.img}}" title="{{targetToken.name}}" />
-        </div>
-        {{/if}}
-        {{#if ajustements.attaqueDefenseurSurpris.used}}
-        <div class="flexrow">
-          <label>{{ajustements.attaqueDefenseurSurpris.label}}</label>
-        </div>
-        {{/if}}
-
-        {{#unless attackerRoll}}
         <div class="flexrow">
           <label>D&eacute;gats:</label>
-          {{#if (eq arme.system.mortalite 'non-mortel')}}
-          <label class="dmg-arme-actor"></label>
-          {{else if (eq arme.system.mortalite 'empoignade')}}
+          {{#if (eq arme.system.mortalite 'empoignade')}}
           <label>Empoignade</label>
           {{else}}
           <span>
-            <input class="attribute-value" type="checkbox" name="coupsNonMortels" {{#unless (eq mortalite 'mortel')}}checked{{/unless}} />
-            <label class="dmg-arme-actor"></label>
+            {{#unless (eq arme.system.mortalite 'non-mortel')}}
+            <input class="attribute-value check-mortalite" type="checkbox" name="mortalite" {{#unless (eq mortalite 'mortel')}}checked{{/unless}} />
+            {{/unless}}
+            <label class="dmg-arme-actor" name="dmg-arme-actor"></label> (<label class="arme-mortalite" name="arme-mortalite"></label>)
           </span>
           {{/if}}
         </div>
-        {{/unless}}
+        {{/if}}
       {{/if}}
-
+      <div class="flexrow"></div>
       {{>"systems/foundryvtt-reve-de-dragon/templates/partial-roll-surenc.html"}}
       {{>"systems/foundryvtt-reve-de-dragon/templates/partial-roll-enctotal.html"}}
     </div>
@@ -75,6 +78,7 @@
       {{>"systems/foundryvtt-reve-de-dragon/templates/partial-roll-diffCondition.html"}}
       {{>"systems/foundryvtt-reve-de-dragon/templates/partial-roll-forcer.html"}}
       {{>"systems/foundryvtt-reve-de-dragon/templates/partial-roll-moral.html"}}
+      <div class="flexrow"></div>
       <div class="placeholder-ajustements" class="flexrow"></div>
     </div>
   </div>

templates/dialog-roll-danse.html

@@ -6,7 +6,7 @@
       <img class="chat-icon" src="{{competence.img}}" alt="{{competence.name}}" />
       <div class="grid grid-2col">
         <label for="carac">Caractéristique:</label>{{>"systems/foundryvtt-reve-de-dragon/templates/partial-select-carac.html"}}
-        <label>{{competence.name}}:</label><label class="flex-grow">{{numberFormat competence.system.niveau decimals=0 sign=true}}</label></label>
+        <label>{{competence.name}}:</label><label class="flex-grow">{{plusMoins competence.system.niveau}}</label></label>
       </div>
       {{> "systems/foundryvtt-reve-de-dragon/templates/partial-description-overflow.html" oeuvre.system}}
     </div>

templates/dialog-roll-defense-empoignade.html

@@ -7,7 +7,7 @@
       <img class="chat-icon" src="{{competence.img}}" alt="{{competence.name}}"/>
       <div class="grid grid-2col">
         <label for="carac">{{selectedCarac.label}}:</label><label class="flex-grow" name="carac">{{selectedCarac.value}}</label>
-        <label for="competence">{{competence.name}}:</label><label class="flex-grow" name="competence">{{numberFormat competence.system.niveau decimals=0 sign=true}}</label>
+        <label for="competence">{{competence.name}}:</label><label class="flex-grow" name="competence">{{plusMoins competence.system.niveau}}</label>
       </div>
     </div>
     <div class="flex-group-left">

templates/dialog-roll-defense-possession.html

@@ -9,7 +9,7 @@
       <img class="chat-icon" src="{{competence.img}}" alt="{{competence.name}}"/>
       <div class="grid grid-2col">
         <label for="carac">Rêve actuel:</label><label class="flex-grow" name="carac">{{selectedCarac.value}}</label>
-        <label for="competence">{{competence.name}}:</label><label class="flex-grow" name="competence">{{numberFormat competence.system.niveau decimals=0 sign=true}}</label>
+        <label for="competence">{{competence.name}}:</label><label class="flex-grow" name="competence">{{plusMoins competence.system.niveau}}</label>
       </div>
     </div>
     <div class="flex-group-left">

templates/dialog-roll-encaisser.html

@@ -4,7 +4,7 @@
     <select class="competence-value flex-shrink" name="modificateurDegats" data-dtype="number">
       {{#select modificateurDegats}}
       {{#each ajustementsEncaissement as |key|}}
-      <option value={{key}}>{{numberFormat key decimals=0 sign=true}}</option>
+      <option value={{key}}>{{plusMoins key}}</option>
       {{/each}}
       {{/select}}
     </select>

templates/dialog-roll-jeu.html

@@ -7,7 +7,7 @@
       <div class="grid grid-2col">
         <label>Type:</label><label class="flex-grow">{{oeuvre.system.type}}</label>
         <label for="carac">Caractéristique:</label>{{>"systems/foundryvtt-reve-de-dragon/templates/partial-select-carac.html"}}
-        <label>{{competence.name}}:</label><label class="flex-grow">{{numberFormat competence.system.niveauReel decimals=0 sign=true}}</label></label>
+        <label>{{competence.name}}:</label><label class="flex-grow">{{plusMoins competence.system.niveauReel}}</label></label>
         <label>Niveau de base:</label><label class="flex-grow">{{oeuvre.system.base}}</label>
       </div>
     </div>

templates/dialog-roll-maitrise-tmr.html

@@ -10,7 +10,7 @@
       <img class="chat-icon" src="{{competence.img}}" alt="{{competence.name}}"/>
       <div class="grid grid-2col">
         <label for="carac">Rêve actuel:</label><label class="flex-grow" name="carac">{{selectedCarac.value}}</label>
-        <label for="draconic">{{competence.name}}:</label><label class="flex-grow" name="draconic">{{numberFormat competence.system.niveau decimals=0 sign=true}}</label>
+        <label for="draconic">{{competence.name}}:</label><label class="flex-grow" name="draconic">{{plusMoins competence.system.niveau}}</label>
       </div>
     </div>
     <div class="flex-group-left">

templates/dialog-roll-meditation.html

@@ -11,7 +11,7 @@
         <label>Durée: 60 minutes</label>
         <hr>
         <label>Intellect / {{competence.name}}:
-          {{numberFormat carac.intellect.value decimals=0 sign=false}} / {{numberFormat competence.system.niveau decimals=0 sign=true}}</label>
+          {{numberFormat carac.intellect.value decimals=0 sign=false}} / {{plusMoins competence.system.niveau}}</label>
       </div>
     </div>
     <div class="flex-group-left">

templates/dialog-roll-musique.html

@@ -6,7 +6,7 @@
       <img class="chat-icon" src="{{competence.img}}" alt="{{competence.name}}" />
       <div class="grid grid-2col">
         <label>Caractéristique: </label><label class="flex-grow">{{selectedCarac.label}}</label>
-        <label>{{competence.name}}:</label><label class="flex-grow">{{numberFormat competence.system.niveau decimals=0 sign=true}}</label></label>
+        <label>{{competence.name}}:</label><label class="flex-grow">{{plusMoins competence.system.niveau}}</label></label>
       </div>
       {{> "systems/foundryvtt-reve-de-dragon/templates/partial-description-overflow.html" oeuvre.system}}
     </div>

templates/dialog-roll-oeuvre.html

@@ -7,7 +7,7 @@
       <div class="grid grid-2col">
         <label>Caractéristique: </label><label class="flex-grow">{{selectedCarac.label}}
         </label>
-        <label>{{competence.name}}:</label><label class="flex-grow">{{numberFormat competence.system.niveau decimals=0 sign=true}}</label></label>
+        <label>{{competence.name}}:</label><label class="flex-grow">{{plusMoins competence.system.niveau}}</label></label>
       </div>
       {{> "systems/foundryvtt-reve-de-dragon/templates/partial-description-overflow.html" oeuvre.system}}
     </div>

templates/dialog-roll-recettecuisine.html

@@ -9,7 +9,7 @@
           <label>Caractéristique: </label><label>{{selectedCarac.label}}</label>
         </div>
         <div class="flexrow">
-          <label>{{competence.name}}: </label><label>{{numberFormat competence.system.niveau decimals=0 sign=true}}</label></label>
+          <label>{{competence.name}}: </label><label>{{plusMoins competence.system.niveau}}</label></label>
         </div>
         <div class="flexrow">
           <label>Exotisme: </label><label>{{oeuvre.system.exotisme}}</label>

templates/dialog-roll-reve-de-dragon.html

@@ -5,7 +5,7 @@
       <img class="chat-icon" src="{{competence.img}}" alt="{{competence.name}}"/>
       <div class="grid grid-2col">
         <label for="carac">Rêve actuel:</label><label class="flex-grow" name="carac">{{selectedCarac.value}}</label>
-        <label for="competence">{{competence.name}}:</label><label class="flex-grow" name="competence">{{numberFormat competence.system.niveau decimals=0 sign=true}}</label>
+        <label for="competence">{{competence.name}}:</label><label class="flex-grow" name="competence">{{plusMoins competence.system.niveau}}</label>
       </div>
     </div>
     <div class="flex-group-left">

templates/dialog-roll-signedraconique.html

@@ -24,7 +24,7 @@
         <select name="competence" class="roll-draconic" data-dtype="String">
           {{#select draconic}}
           {{#each draconicList as |draconic key|}}
-          <option value={{key}}>{{draconic.name}} : {{numberFormat draconic.system.niveau decimals=0 sign=true}}
+          <option value={{key}}>{{draconic.name}} : {{plusMoins draconic.system.niveau}}
           </option>
           {{/each}}
           {{/select}}

templates/dialog-roll-sort.html

@@ -43,7 +43,7 @@
         <select name="competence" class="roll-draconic" data-dtype="String">
           {{#select draconic}}
           {{#each draconicList as |draconic key|}}
-          <option value={{key}}>{{draconic.name}} : {{numberFormat draconic.system.niveau decimals=0 sign=true}}
+          <option value={{key}}>{{draconic.name}} : {{plusMoins draconic.system.niveau}}
           </option>
           {{/each}}
           {{/select}}
@@ -54,11 +54,11 @@
         <select name="diffLibre" class="div-sort-difficulte-var" data-dtype="number">
           {{#select diffLibre}}
           {{#each difficultesLibres as |key|}}
-          <option value={{key}}>{{numberFormat key decimals=0 sign=true}}</option>
+          <option value={{key}}>{{plusMoins key}}</option>
           {{/each}}
           {{/select}}
         </select>
-        <label class="div-sort-difficulte-fixe">{{numberFormat selectedSort.system.difficulte decimals=0 sign=true}}</label>
+        <label class="div-sort-difficulte-fixe">{{plusMoins selectedSort.system.difficulte}}</label>
       </div>
       {{>"systems/foundryvtt-reve-de-dragon/templates/partial-roll-diffCondition.html"}}
       {{>"systems/foundryvtt-reve-de-dragon/templates/partial-roll-forcer.html"}}

templates/dialog-tmr.html

@@ -1,8 +1,7 @@
 <form class="tmr-dialog">
-<h2 class="comptmrdialog" id="tmrDialogTitle"></h2>
-
-<table id="tmrsheet">
-  <tr id="tmrrow1">
+<h2 class="comptmrdialog" id="tmrDialogTitle" style="visibility: hidden;"></h2>
+<table>
+  <tr class="tmr-row">
     <td>
       {{#if (eq mode "visu")}}
       <div class="flex-group-center">
@@ -54,6 +53,5 @@
     </td>
   </tr>
 </table>
-
 </form>
 

templates/dialog-validation-encaissement.html

@@ -20,22 +20,22 @@
           {{/if}}
           <hr>
           {{#if encaissement.dmg.total}}
-          <div>+dom encaissement: {{numberFormat rollData.dmg.total decimals=0 sign=true}}</div>
+          <div>+dom encaissement: {{plusMoins rollData.dmg.total}}</div>
           {{/if}}
           {{#if rollData.dmg.dmgArme}}
-          <div>+dom arme: {{numberFormat rollData.dmg.dmgArme decimals=0 sign=true}}</div>
+          <div>+dom arme: {{plusMoins rollData.dmg.dmgArme}}</div>
           {{/if}}
           {{#if rollData.dmg.dmgActor}}
-          <div>+dom attaquant: {{numberFormat rollData.dmg.dmgActor decimals=0 sign=true}}</div>
+          <div>+dom attaquant: {{plusMoins rollData.dmg.dmgActor}}</div>
           {{/if}}
           {{#if rollData.dmg.dmgParticuliere}}
-          <div>+dom particulière: {{numberFormat rollData.dmg.dmgParticuliere decimals=0 sign=true}}</div>
+          <div>+dom particulière: {{plusMoins rollData.dmg.dmgParticuliere}}</div>
           {{/if}}
           {{#if rollData.dmg.dmgTactique}}
-          <div>+dom tactique: {{numberFormat rollData.dmg.dmgTactique decimals=0 sign=true}}</div>
+          <div>+dom tactique: {{plusMoins rollData.dmg.dmgTactique}}</div>
           {{/if}}
           {{#if rollData.dmg.dmgSurprise}}
-          <div>+dom surprise: {{numberFormat rollData.dmg.dmgSurprise decimals=0 sign=true}}</div>
+          <div>+dom surprise: {{plusMoins rollData.dmg.dmgSurprise}}</div>
           {{/if}}
         </div>
       </span>

templates/enum-mortalite.html

@@ -0,0 +1,3 @@
+<option value="mortel">Mortel</option>
+<option value="non-mortel">Non mortel</option>
+<option value="empoignade">Empoignade</option>