Fix termes dans les fenetres de creation

2024-02-29 21:22:42 +01:00 · 2024-02-29 20:59:06 +01:00 · 2024-02-29 20:45:25 +01:00 · 2024-02-08 12:46:49 +01:00 · 2024-02-05 18:08:35 +01:00 · 2024-01-30 23:18:21 +01:00
71 changed files with 1123 additions and 402 deletions
--- a/changelog.md
+++ b/changelog.md
@ -1,4 +1,50 @@
 # 11.2
+
+## 11.2.16 - La Tri d'Akarlikarlikar
+- Tri alphabétique des items dans la fenêtre de création
+- Mise à jour comptage de monde
+
+## 11.2.15 - La Table d'Akarlikarlikar
+- Tirage automatique de la foce d'une rencontre (via la commande /tmrr)
+- Ajout de boutons pour ajouter des blessures "complètes" (ie avec perte d'endurance/vie)
+
+## 11.2.14 - Les petits pas d'Akarlikarlikar
+- Correction sur la gestion de la surprise
+- Ordre des messages sur les cases humides
+
+## 11.2.13 - Les cent pas d'Akarlikarlikar
+- Ajout de la commande /voyage pour gérer la fatigue de marche des voyageurs
+
+## 11.2.12 - Le somnifère  d'Akarlikarlikar
+- Fix: les potions enchantées n'empêchent plus de finir correctement Château Dormant
+
+## 11.2.11 - Le miroir d'Akarlikarlikar
+- Changement des images de compétence de créatures morsure/pinces pour être dans le thème
+- Suppression de la bordure autour des portraits d'acteurs, remplacés par un légèr éclaircissement du fond
+- Fix: le refoulement ajoute correctement un souffle et revient à 0 en cas d'échec
+
+## 11.2.10 - Les expériences d'Akarlikarlikar
+- En cas d'expérience des caractéristiques dérivées,
+  - si plusieurs caractéristiques pourraient recevoir l'expérience, une fenêtre demande au joueur
+  - si une seule caractéristique peut recevoir de l'expérience, c'est attribué automatiquement
+- Si la force est au maximum pour la taille personnage, on ne peut plus gagner d'expérience
+
+## 11.2.9 - La barbe d'Akarlikarlikar
+- Amélioration des textes de tooltips
+- Les tooltips sont plus dans le thème de couleur du système Rêve de Dragon 
+- Ajouts d'icones pour les attaque/initiative/soins dans les raccourcis sur les tokens (HUD)
+- Ajout d'une icône et transformation en bouton du lien pour accéder à l'astrologie et aux chiffres astraux
+- Suppression de message de log inutile sur chaque point de coeur
+- On peut désactiver l'ajustement astrologique sur les jets de chance (pour des jts de chances non liés à une heure)- Fix: suppression de quelques cas d'erreur lors de l'ouverture des TMR
+- Fix: suppression du warning de depréciation effects flags.core.statusId
+- Les sorts en réserve en fleuve sont indiqués sur toutes les cases fleuve
+- Changement de l'icône d'état d'empoignade pour suivre les couleurs des autres icônes d'état
+
+## 11.2.8 - L'éclairage d'Akarlikarlikar
+- l'ajustement de la lumière jour/nuit s'étale sur moins de temps (vaisseau et Lyre)
+- les nouveaux tooltips ne masquent plus l'information d'expérience
+- les jets de dés pour maîtriser les rencontres fonctionnent de nouveau
+
 ## 11.2.7 - Les explications d'Akarlikarlikar
 - Ajout de tooltips sur la plupart des boutons, liens clickables, objets, tâches, ...
 - Fix: on peut de nouveau regarder l'inventaire avec les droits limités/observateur
--- a/icons/compcreature-mandibules.webp
+++ b/icons/compcreature-mandibules.webp
--- a/icons/compcreature-morsure.webp
+++ b/icons/compcreature-morsure.webp
--- a/icons/empoignade.webp
+++ b/icons/empoignade.webp
--- a/icons/tmr/sort-reserve-humide.svg
+++ b/icons/tmr/sort-reserve-humide.svg
@ -0,0 +1,102 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   viewBox="0 0 512 512"
+   style="height: 256px; width: 256px;"
+   version="1.1"
+   id="svg24"
+   sodipodi:docname="sort-reserve-humide3.svg"
+   inkscape:version="1.0.1 (3bc2e813f5, 2020-09-07)">
+  <metadata
+     id="metadata30">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <defs
+     id="defs28" />
+  <sodipodi:namedview
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1"
+     objecttolerance="10"
+     gridtolerance="10"
+     guidetolerance="10"
+     inkscape:pageopacity="0"
+     inkscape:pageshadow="2"
+     inkscape:window-width="2794"
+     inkscape:window-height="1756"
+     id="namedview26"
+     showgrid="false"
+     inkscape:zoom="2.8786993"
+     inkscape:cx="323.66586"
+     inkscape:cy="227.70764"
+     inkscape:window-x="0"
+     inkscape:window-y="0"
+     inkscape:window-maximized="0"
+     inkscape:current-layer="svg24" />
+  <g
+     id="g881"
+     transform="translate(2.1482304,2.80716)">
+    <path
+       d="m 243.94189,104.37921 -82.23331,178.13543 82.23331,27.44784 z"
+       class=""
+       fill="#f4e3d7"
+       fill-opacity="1"
+       id="path2"
+       style="stroke-width:1.10232" />
+    <path
+       d="m 263.7837,104.37921 v 205.58327 l 82.23331,-27.44784 z"
+       class=""
+       fill="#f4e3d7"
+       fill-opacity="1"
+       id="path4"
+       style="stroke-width:1.10232" />
+    <path
+       d="M 168.21228,221.005 18.274279,239.7445 141.75653,278.32581 Z"
+       class=""
+       fill="#f4e3d7"
+       fill-opacity="1"
+       id="path6"
+       style="stroke-width:1.10232" />
+    <path
+       d="M 339.51331,221.005 365.96906,278.32581 489.5395,239.7445 Z"
+       class=""
+       fill="#f4e3d7"
+       fill-opacity="1"
+       id="path8"
+       style="stroke-width:1.10232" />
+    <path
+       d="M -0.24475089,254.73609 114.97007,398.80973 230.27308,326.7178 Z"
+       class=""
+       fill="#f4e3d7"
+       fill-opacity="1"
+       id="path10"
+       style="stroke-width:1.10232" />
+    <path
+       d="M 507.94829,254.73609 277.45251,326.7178 392.75552,398.80973 Z"
+       class=""
+       fill="#f4e3d7"
+       fill-opacity="1"
+       id="path12"
+       style="stroke-width:1.10232" />
+    <path
+       d="M 253.8628,335.42615 147.37837,402.00647 H 360.34722 Z"
+       class=""
+       fill="#f4e3d7"
+       fill-opacity="1"
+       id="path14"
+       style="stroke-width:1.10232" />
+  </g>
+</svg>
--- a/lang/fr.json
+++ b/lang/fr.json
@ -1,55 +1,56 @@
 {
  "TYPES": {
    "Actor": { 
-      "Personnage": "Personnage",
-      "Creature": "Créature",
-      "Entite": "Entité de cauchemar",
-      "Commerce": "Commerce",
-      "Vehicule": "Véhicule"
+      "personnage": "Personnage",
+      "creature": "Créature",
+      "entite": "Entité de cauchemar",
+      "commerce": "Commerce",
+      "vehicule": "Véhicule"
    },
    "Item": {
-      "Arme": "Arme",
-      "Armure": "Armure",
-      "Blessure": "Blessure",
-      "Casetmr": "TMR spéciale",
-      "Chant": "Chant",
-      "Competence": "Compétence",
-      "Competencecreature": "Compétence de créature",
-      "Conteneur": "Conteneur",
-      "Danse": "Danse",
-      "Extraitpoetique": "Extrait poetique",
-      "Faune": "Faune",
-      "Gemme": "Gemme",
-      "Herbe": "Herbe",
-      "Ingredient": "Ingrédient",
-      "Jeu": "Jeu",
-      "Livre": "Livre",
-      "Maladie": "Maladie",
-      "Meditation": "Méditation",
-      "Monnaie": "Monnaie",
-      "Munition": "Munition",
-      "Musique": "Musique",
-      "Nombreastral": "Nombre astral",
-      "Nourritureboisson": "Nourriture & boisson",
-      "Objet": "Objet",
-      "Oeuvre": "Oeuvre",
-      "Ombre": "Ombre de Thanatos",
-      "Plante": "Plante",
-      "Poison": "Poison",
-      "Possession": "Possession",
-      "Potion": "Potion",
-      "Queue": "Queue de Dragon",
-      "Recettealchimique": "Recette alchimique",
-      "Recettecuisine": "Recette de cuisine",
-      "Rencontre": "Rencontre TMR",
-      "Service": "Service",
-      "Signedraconique": "Signe draconique",
-      "Sort": "Sort",
-      "Sortreserve": "Sort en réserve",
-      "Souffle": "Souffle de Dragon",
-      "Tache": "Tâche",
-      "Tarot": "Carte de tarot",
-      "Tete": "Tête de Dragon"
+      "arme": "Arme",
+      "armure": "Armure",
+      "blessure": "Blessure",
+      "casetmr": "Case TMR spéciale",
+      "chant": "Chant",
+      "competence": "Compétence",
+      "competencecreature": "Compétence de créature",
+      "conteneur": "Conteneur",
+      "danse": "Danse",
+      "empoignade": "Empoignade",
+      "extraitpoetique": "Extrait poetique",
+      "faune": "Faune",
+      "gemme": "Gemme",
+      "herbe": "Herbe",
+      "ingredient": "Ingrédient",
+      "jeu": "Jeu",
+      "livre": "Livre",
+      "maladie": "Maladie",
+      "meditation": "Méditation",
+      "monnaie": "Monnaie",
+      "munition": "Munition",
+      "musique": "Musique",
+      "nombreastral": "Nombre astral",
+      "nourritureboisson": "Nourriture & boisson",
+      "objet": "Objet",
+      "oeuvre": "Oeuvre",
+      "ombre": "Ombre de Thanatos",
+      "plante": "Plante",
+      "poison": "Poison",
+      "possession": "Possession",
+      "potion": "Potion",
+      "queue": "Queue de Dragon",
+      "recettealchimique": "Recette alchimique",
+      "recettecuisine": "Recette de cuisine",
+      "rencontre": "Rencontre TMR",
+      "service": "Service",
+      "signedraconique": "Signe draconique",
+      "sort": "Sort",
+      "sortreserve": "Sort en réserve",
+      "souffle": "Souffle de Dragon",
+      "tache": "Tâche",
+      "tarot": "Carte de tarot",
+      "tete": "Tête de Dragon"
    }
  },
  "EFFECT": {
--- a/module/actor.js
+++ b/module/actor.js
@ -35,6 +35,7 @@ import { ExperienceLog, XP_TOPIC } from "./actor/experience-log.js";
 import { TYPES } from "./item.js";
 import { RdDBaseActorSang } from "./actor/base-actor-sang.js";
 import { RdDCoeur } from "./coeur/rdd-coeur.js";
+import { DialogChoixXpCarac } from "./dialog-choix-xp-carac.js";

 export const MAINS_DIRECTRICES = ['Droitier', 'Gaucher', 'Ambidextre']

@ -56,21 +57,20 @@ export class RdDActor extends RdDBaseActorSang {

  /* -------------------------------------------- */
  $computeCaracDerivee() {
+
    this.system.carac.force.value = Math.min(this.system.carac.force.value, parseInt(this.system.carac.taille.value) + 4);
-
-    this.system.carac.derobee.value = Math.floor(parseInt(((21 - this.system.carac.taille.value)) + parseInt(this.system.carac.agilite.value)) / 2);
-    let bonusDomKey = Math.floor((parseInt(this.system.carac.force.value) + parseInt(this.system.carac.taille.value)) / 2);
-    let tailleData = RdDCarac.getCaracDerivee(bonusDomKey);
-    this.system.attributs.plusdom.value = tailleData.plusdom;
-
-    this.system.attributs.sconst.value = RdDCarac.calculSConst(this.system.carac.constitution.value);
-    this.system.attributs.sust.value = RdDCarac.getCaracDerivee(this.system.carac.taille.value).sust;
-
-    this.system.attributs.encombrement.value = (parseInt(this.system.carac.force.value) + parseInt(this.system.carac.taille.value)) / 2;
    this.system.carac.melee.value = Math.floor((parseInt(this.system.carac.force.value) + parseInt(this.system.carac.agilite.value)) / 2);
    this.system.carac.tir.value = Math.floor((parseInt(this.system.carac.vue.value) + parseInt(this.system.carac.dexterite.value)) / 2);
    this.system.carac.lancer.value = Math.floor((parseInt(this.system.carac.tir.value) + parseInt(this.system.carac.force.value)) / 2);
+    this.system.carac.derobee.value = Math.floor(parseInt(((21 - this.system.carac.taille.value)) + parseInt(this.system.carac.agilite.value)) / 2);

+    let bonusDomKey = Math.floor((parseInt(this.system.carac.force.value) + parseInt(this.system.carac.taille.value)) / 2);
+    let tailleData = RdDCarac.getCaracDerivee(bonusDomKey);
+    this.system.attributs.plusdom.value = tailleData.plusdom;
+    this.system.attributs.encombrement.value = (parseInt(this.system.carac.force.value) + parseInt(this.system.carac.taille.value)) / 2;
+
+    this.system.attributs.sconst.value = RdDCarac.calculSConst(this.system.carac.constitution.value);
+    this.system.attributs.sust.value = RdDCarac.getCaracDerivee(this.system.carac.taille.value).sust;
    this.system.sante.vie.max = Math.ceil((parseInt(this.system.carac.taille.value) + parseInt(this.system.carac.constitution.value)) / 2);

    this.system.sante.vie.value = Math.min(this.system.sante.vie.value, this.system.sante.vie.max)
@ -152,23 +152,26 @@ export class RdDActor extends RdDBaseActorSang {
  /* -------------------------------------------- */
  async $perteRevePotionsEnchantees() {
    let potions = this.itemTypes[TYPES.potion]
-      .filter(it => it.system.categorie.toLowerCase().includes('enchant') && !potion.system.prpermanent)
+      .filter(it => Grammar.includesLowerCaseNoAccent(it.system.categorie, 'enchanté') && !it.system.prpermanent)

-    const potionUpdates = await Promise.all(potions.map(async potion => {
-      console.log(potion)
-      let nouveauReve = (potion.system.pr > 0) ? potion.system.pr - 1 : 0;
-      const message = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-potionenchantee-chateaudormant.html`, {
-        pr: nouveauReve,
-        alias: this.name,
-        potionName: potion.name,
-        potionImg: potion.img
-      })
+    const potionUpdates = await Promise.all(potions.map(async it => {
+      const nouveauReve = Math.max(it.system.pr - 1, 0)
      ChatMessage.create({
        whisper: ChatUtility.getWhisperRecipientsAndGMs(this.name),
-        content: message
-      });
-      return { _id: potion._id, 'system.pr': nouveauReve };
+        content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-potionenchantee-chateaudormant.html`, {
+          pr: nouveauReve,
+          alias: this.name,
+          potionName: it.name,
+          potionImg: it.img
+        })
+      })
+      return {
+        _id: it._id,
+        'system.pr': nouveauReve,
+        'system.quantite': nouveauReve > 0 ? it.system.quantite : 0
+      }
    }))
+
    await this.updateEmbeddedDocuments('Item', potionUpdates);
  }

@ -399,7 +402,7 @@ export class RdDActor extends RdDBaseActorSang {
      content: 'Remise à neuf de ' + this.name
    });
    await this.supprimerBlessures(it => true);
-    await this.removeEffects(e => e.flags.core.statusId !== STATUSES.StatusDemiReve);
+    await this.removeEffects(e => e.id != STATUSES.StatusDemiReve);
    const updates = {
      'system.sante.endurance.value': this.system.sante.endurance.max,
      'system.sante.vie.value': this.system.sante.vie.max,
@ -659,7 +662,7 @@ export class RdDActor extends RdDBaseActorSang {
        this.setPointsDeChance(to);
      }
    }
-    let selectedCarac = RdDBaseActor._findCaracByName(this.system.carac, caracName);
+    let selectedCarac = this.findCaracByName(caracName);
    const from = selectedCarac.value
    await this.update({ [`system.carac.${caracName}.value`]: to });
    await ExperienceLog.add(this, XP_TOPIC.CARAC, from, to, caracName);
@ -670,7 +673,7 @@ export class RdDActor extends RdDBaseActorSang {
    if (caracName == 'Taille') {
      return;
    }
-    let selectedCarac = RdDBaseActor._findCaracByName(this.system.carac, caracName);
+    let selectedCarac = this.findCaracByName(caracName);
    if (!selectedCarac.derivee) {
      const from = Number(selectedCarac.xp);
      await this.update({ [`system.carac.${caracName}.xp`]: to });
@ -684,7 +687,7 @@ export class RdDActor extends RdDBaseActorSang {
    if (caracName == 'Taille') {
      return;
    }
-    let carac = RdDBaseActor._findCaracByName(this.system.carac, caracName);
+    let carac = this.findCaracByName(caracName);
    if (carac) {
      carac = duplicate(carac);
      const fromXp = Number(carac.xp);
@ -896,7 +899,7 @@ export class RdDActor extends RdDBaseActorSang {

  /* -------------------------------------------- */
  async ajouterRefoulement(value = 1, refouler) {
-    const refoulement = this.system.reve.refoulement.value + value;
+    let refoulement = this.system.reve.refoulement.value + value;
    const roll = new Roll("1d20");
    await roll.evaluate({ async: true });
    await roll.toMessage({ flavor: `${this.name} refoule ${refouler} pour ${value} points de refoulement (total: ${refoulement})` });
@ -1166,8 +1169,8 @@ export class RdDActor extends RdDBaseActorSang {
          title: "Nourriture brute",
          content: `Que faire de votre ${item.name}`,
          buttons: {
-            'cuisiner': { icon: '<i class="fas fa-check"></i>', label: 'Cuisiner', callback: async () => await this.preparerNourriture(item) },
-            'manger': { icon: '<i class="fas fa-check"></i>', label: 'Manger cru', callback: async () => await this.mangerNourriture(item, onActionItem) }
+            'cuisiner': { icon: '<i class="fa-solid fa-utensils"></i>', label: 'Cuisiner', callback: async () => await this.preparerNourriture(item) },
+            'manger': { icon: '<i class="fa-solid fa-drumstick-bite"></i>', label: 'Manger cru', callback: async () => await this.mangerNourriture(item, onActionItem) }
          }
        });
        return utilisation.render(true);
@ -1472,8 +1475,14 @@ export class RdDActor extends RdDBaseActorSang {
  }

  /* -------------------------------------------- */
+  isCaracMax(code) {
+    if (code == 'force' && parseInt(this.system.carac.force.value) >= parseInt(this.system.carac.taille.value) + 4) {
+      return true;
+    }
+    return false
+  }
  async checkCaracXP(caracName, display = true) {
-    let carac = RdDBaseActor._findCaracByName(this.system.carac, caracName);
+    let carac = this.findCaracByName(caracName);
    if (carac && carac.xp > 0) {
      const niveauSuivant = Number(carac.value) + 1;
      let xpNeeded = RdDCarac.getCaracNextXp(niveauSuivant);
@ -1534,8 +1543,11 @@ export class RdDActor extends RdDBaseActorSang {
  async appliquerAjoutExperience(rollData, hideChatMessage = 'show') {
    hideChatMessage = hideChatMessage == 'hide' || (Misc.isRollModeHiddenToPlayer() && !game.user.isGM)
    let xpData = await this._appliquerExperience(rollData.rolled, rollData.selectedCarac.label, rollData.competence, rollData.jetResistance);
-    if (xpData) {
-      const content = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-actor-gain-xp.html`, xpData);
+    if (xpData.length) {
+      const content = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-actor-gain-xp.html`, {
+        actor: this,
+        xpData
+      });
      if (hideChatMessage) {
        ChatUtility.blindMessageToGM({ content: content });
      }
@ -1698,7 +1710,7 @@ export class RdDActor extends RdDBaseActorSang {
    if (rollData.competence.name.includes('Thanatos')) { // Si Thanatos
      await this.update({ "system.reve.reve.thanatosused": true });
    }
-    let reveActuel = this.system.reve.reve.value;
+    let reveActuel = parseInt(this.system.reve.reve.value)
    if (rolled.isSuccess) { // Réussite du sort !
      if (rolled.isPart) {
        rollData.depenseReve = Math.max(Math.floor(rollData.depenseReve / 2), 1);
@ -1804,7 +1816,10 @@ export class RdDActor extends RdDBaseActorSang {
  }

  blessuresASoigner() {
-    return this.filterItems(it => it.system.gravite > 0 && it.system.gravite <= 6 && !(it.system.premierssoins.done && it.system.soinscomplets.done), 'blessure')
+    return (this.itemTypes[TYPES.blessure])
+      .filter(it => it.system.gravite > 0 && it.system.gravite <= 6)
+      .filter(it => !(it.system.premierssoins.done && it.system.soinscomplets.done))
+      .sort(Misc.descending(b => (b.system.premierssoins.done ? "A" : "B") + b.system.gravite))
  }

  async getTacheBlessure(blesse, blessure) {
@ -2262,9 +2277,7 @@ export class RdDActor extends RdDBaseActorSang {
      });
      return undefined;
    }
-    if (caracName == 'Vie') caracName = 'constitution';
-    if (caracName == 'derobee') caracName = 'agilite';
-    if (caracName == 'reve-actuel') caracName = 'reve';
+
    let xp = Math.abs(rolled.finalLevel);
    // impair: arrondi inférieur en carac
    let xpCarac = competence ? Math.floor(xp / 2) : Math.max(Math.floor(xp / 2), 1);
@ -2277,11 +2290,10 @@ export class RdDActor extends RdDBaseActorSang {
      // max 1 xp sur jets de résistance
      xpCarac = Math.min(1, xpCarac);
    }
-    let xpData = { alias: this.name, caracName, xpCarac, competence, xpCompetence };
-
-    await this._xpCompetence(xpData);
-    await this._xpCarac(xpData);
-    return xpData;
+    return [
+      ...(await this._xpCompetence({ competence, xpCompetence })),
+      ...(await this._xpCarac({ caracName, xpCarac }))
+    ];
  }

  /* -------------------------------------------- */
@ -2289,31 +2301,67 @@ export class RdDActor extends RdDBaseActorSang {
    if (xpData.competence) {
      const from = Number(xpData.competence.system.xp);
      const to = from + xpData.xpCompetence;
-      let update = { _id: xpData.competence._id, 'system.xp': to };
-      await this.updateEmbeddedDocuments('Item', [update]);
+      await this.updateEmbeddedDocuments('Item', [{ _id: xpData.competence._id, 'system.xp': to }]);
      xpData.checkComp = await this.checkCompetenceXP(xpData.competence.name, undefined, false);
      await ExperienceLog.add(this, XP_TOPIC.XP, from, to, xpData.competence.name);
+      return [xpData]
    }
+    return []
  }

  /* -------------------------------------------- */
  async _xpCarac(xpData) {
    if (xpData.xpCarac > 0) {
-      let carac = duplicate(this.system.carac);
-      let selectedCarac = RdDBaseActor._findCaracByName(carac, xpData.caracName);
-      if (!selectedCarac.derivee) {
-        const from = Number(selectedCarac.xp);
-        const to = from + xpData.xpCarac;
-        selectedCarac.xp = to;
-        await this.update({ "system.carac": carac });
-        xpData.checkCarac = await this.checkCaracXP(selectedCarac.label, false);
-        await ExperienceLog.add(this, XP_TOPIC.XPCARAC, from, to, xpData.caracName);
+      const carac = duplicate(this.system.carac)
+      const code = RdDBaseActor._findCaracNode(carac, xpData.caracName)
+      const selectedCarac = carac[code]
+      if (this.isCaracMax(code)) {
+        ui.notifications.info(`Pas d'expérience: la caractéristique '${selectedCarac.label}' est déjà au maximum pour ${this.name}`)
+        return []
+      }
+      if (selectedCarac && !selectedCarac.derivee) {
+        const from = Number(selectedCarac.xp)
+        const to = from + xpData.xpCarac
+        selectedCarac.xp = to
+        await this.update({ "system.carac": carac })
+        xpData.checkCarac = await this.checkCaracXP(selectedCarac.label, false)
+        await ExperienceLog.add(this, XP_TOPIC.XPCARAC, from, to, xpData.caracName)
+        return [xpData]
      } else {
-        xpData.caracRepartitionManuelle = true;
+        return await this._xpCaracDerivee(xpData)
      }
    }
+    return []
  }

+  async _xpCaracDerivee(xpData) {
+    const caracs = RdDActor._getComposantsCaracDerivee(xpData.caracName)
+      .map(c => mergeObject(this.system.carac[c], { isMax: this.isCaracMax(c) }))
+    switch (caracs.filter(it => !it.isMax).length) {
+      case 0:
+        xpData.caracRepartitionManuelle = true;
+        return [xpData]
+      case 1:
+        xpData.caracName = caracs.find(it => !it.isMax).label
+        return this._xpCarac(xpData)
+      default:
+        await DialogChoixXpCarac.choix(this, xpData, caracs)
+        return []
+    }
+  }
+
+  static _getComposantsCaracDerivee(caracName) {
+    switch (Grammar.toLowerCaseNoAccent(caracName)) {
+      case 'vie': return ['constitution']
+      case 'tir': return ['vue', 'dexterite']
+      case 'lancer': return ['force', 'dexterite', 'vue']
+      case 'melee': return ['force', 'agilite']
+      case 'derobee': return ['agilite']
+    }
+    return []
+  }
+
+
  /* -------------------------------------------- */
  async resetNombresAstraux() {
    const deletions = this.itemTypes['nombreastral'].map(it => it._id);
@ -2415,7 +2463,7 @@ export class RdDActor extends RdDBaseActorSang {
      draconic: this.getDraconicList(),
      sort: this.itemTypes['sort'],
      signes: this.itemTypes['signedraconique'],
-      caracReve: this.system.carac.reve.value,
+      caracReve: parseInt(this.system.carac.reve.value),
      pointsReve: this.getReveActuel(),
      isRapide: isRapide,
      isGM: game.user.isGM,
@ -2506,7 +2554,7 @@ export class RdDActor extends RdDBaseActorSang {

  /* -------------------------------------------- */
  verifierForceMin(item) {
-    if (item.type == 'arme' && item.system.force > this.system.carac.force.value) {
+    if (item.type == 'arme' && item.system.force > parseInt(this.system.carac.force.value)) {
      ChatMessage.create({
        content: `<strong>${this.name} s'est équipé(e) de l'arme ${item.name}, mais n'a pas une force suffisante pour l'utiliser normalement </strong>
                  (${item.system.force} nécessaire pour une Force de ${this.system.carac.force.value})`
@ -2920,9 +2968,7 @@ export class RdDActor extends RdDBaseActorSang {
  }

  /* -------------------------------------------- */
-  isEffectAllowed(statusId) {
-    return true
-  }
+  isEffectAllowed(effectId) { return true }

  /* -------------------------------------------- */
  async onPreUpdateItem(item, change, options, id) {
--- a/module/actor/base-actor-reve.js
+++ b/module/actor/base-actor-reve.js
@ -180,32 +180,32 @@ export class RdDBaseActorReve extends RdDBaseActor {
  }

  /* -------------------------------------------- */
-  isEffectAllowed(statusId) { return true }
+  isEffectAllowed(effectId) { 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);
+  getEffect(effectId) {
+    return this.getEmbeddedCollection("ActiveEffect").find(it => it.statuses?.has(effectId));
  }
-
-  async setEffect(statusId, status) {
-    if (this.isEffectAllowed(statusId)) {
-      const effect = this.getEffect(statusId);
+  
+  async setEffect(effectId, status) {
+    if (this.isEffectAllowed(effectId)) {
+      const effect = this.getEffect(effectId);
      if (!status && effect) {
        await this.deleteEmbeddedDocuments('ActiveEffect', [effect.id]);
      }
      if (status && !effect) {
-        await this.createEmbeddedDocuments("ActiveEffect", [StatusEffects.status(statusId)]);
+        await this.createEmbeddedDocuments("ActiveEffect", [StatusEffects.prepareActiveEffect(effectId)]);
      }
    }
  }
-
-  async removeEffect(statusId) {
-    const effect = this.getEffect(statusId);
+  
+  async removeEffect(id) {
+    const effect = this.getEmbeddedCollection("ActiveEffect").find(it => it.id == id);
    if (effect) {
-      await this.deleteEmbeddedDocuments('ActiveEffect', [effect.id]);
+      await this.deleteEmbeddedDocuments('ActiveEffect', [id]);
    }
  }

--- a/module/actor/base-actor-sang-sheet.js
+++ b/module/actor/base-actor-sang-sheet.js
@ -21,6 +21,11 @@ export class RdDBaseActorSangSheet extends RdDBaseActorReveSheet {
    this.html.find('.creer-blessure-grave').click(async event => RdDItemBlessure.createBlessure(this.actor, 4));
    this.html.find('.creer-blessure-critique').click(async event => RdDItemBlessure.createBlessure(this.actor, 6));

+    this.html.find('.subir-blessure-contusion').click(async event => RdDItemBlessure.applyFullBlessure(this.actor, 2));
+    this.html.find('.subir-blessure-legere').click(async event => RdDItemBlessure.applyFullBlessure(this.actor, 2));
+    this.html.find('.subir-blessure-grave').click(async event => RdDItemBlessure.applyFullBlessure(this.actor, 4));
+    this.html.find('.subir-blessure-critique').click(async event => RdDItemBlessure.applyFullBlessure(this.actor, 6));
+
    this.html.find('.jet-vie').click(async event => this.actor.jetDeVie())
    this.html.find('.jet-endurance').click(async event => await this.jetEndurance())

--- a/module/actor/base-actor.js
+++ b/module/actor/base-actor.js
@ -11,16 +11,14 @@ 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;
-    }

+  static _findCaracNode(carac, name) {
+    return Object.entries(carac)
+      .filter(it => Grammar.equalsInsensitive(it[1].label, name))
+      .map(it => it[0])
+      .find(it => it);
+  }
+  static $findCaracByName(carac, name) {
    const caracList = Object.entries(carac);
    let entry = Misc.findFirstLike(name, caracList, { mapper: it => it[0], description: 'caractéristique' });
    if (!entry || entry.length == 0) {
@ -135,6 +133,21 @@ export class RdDBaseActor extends Actor {
    super(docData, context);
  }

+  findCaracByName(name) {
+    name = Grammar.toLowerCaseNoAccent(name)
+    switch (name) {
+      case 'reve-actuel': case 'reve actuel':
+        return this.system.carac.reve
+      case 'chance-actuelle': case 'chance actuelle':
+        return this.system.carac.chance
+      case 'vie':
+        return this.system.sante.vie
+    }
+
+    const carac = this.system.carac;
+    return RdDBaseActor.$findCaracByName(carac, name);
+  }
+
  getCaracByName(name) {
    switch (Grammar.toLowerCaseNoAccent(name)) {
      case 'reve-actuel': case 'reve actuel':
@ -142,7 +155,7 @@ export class RdDBaseActor extends Actor {
      case 'chance-actuelle': case 'chance-actuelle':
        return this.getCaracChanceActuelle();
    }
-    return RdDBaseActor._findCaracByName(this.system.carac, name);
+    return this.findCaracByName(name);
  }

  /* -------------------------------------------- */
@ -187,7 +200,7 @@ export class RdDBaseActor extends Actor {
  }

  listeSuivants(filter = suivant => true) { return [] }
-  listeSuivants(filter = suivant =>true) { return [] }
+  listeSuivants(filter = suivant => true) { return [] }
  listItems(type = undefined) { return (type ? this.itemTypes[type] : this.items); }
  filterItems(filter, type = undefined) { return (type ? this.itemTypes[type] : this.items)?.filter(filter) ?? []; }
  findItemLike(idOrName, type) {
--- a/module/actor/creature.js
+++ b/module/actor/creature.js
@ -33,8 +33,8 @@ export class RdDCreature extends RdDBaseActorSang {
    }
  }

-  isEffectAllowed(statusId) {
-    return [STATUSES.StatusComma].includes(statusId);
+  isEffectAllowed(effectId) {
+    return [STATUSES.StatusComma].includes(effectId);
  }

  isEntiteAccordee(attacker) {
--- a/module/actor/entite.js
+++ b/module/actor/entite.js
@ -70,8 +70,8 @@ export class RdDEntite extends RdDBaseActorReve {
    await RdDEncaisser.encaisser(this) 
  }

-  isEffectAllowed(statusId) {
-    return [STATUSES.StatusComma].includes(statusId);
+  isEffectAllowed(effectId) {
+    return [STATUSES.StatusComma].includes(effectId);
  }

  async onAppliquerJetEncaissement(encaissement, attacker) {
--- a/module/dialog-choix-xp-carac.js
+++ b/module/dialog-choix-xp-carac.js
@ -0,0 +1,84 @@
+
+export class DialogChoixXpCarac extends Dialog {
+
+  static async choix(actor, xpData, caracs) {
+    caracs = caracs.map(it => mergeObject({ ajout: 0 }, it))
+    xpData = mergeObject({ reste: xpData.xpCarac }, xpData)
+    const dialogData = {
+      title: `Choisissez la répartition d'expérience`,
+      content: await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/dialog-choix-xp-carac.hbs", {
+        actor,
+        caracDerivee: actor.findCaracByName(xpData.caracName),
+        xpData,
+        caracs
+      }),
+    }
+
+    const dialogOptions = {
+      classes: ["rdd-dialog-select"],
+      width: 400,
+      height: 'fit-content',
+      'z-index': 99999
+    }
+    new DialogChoixXpCarac(dialogData, dialogOptions, actor, xpData, caracs).render(true)
+  }
+
+  constructor(dialogData, dialogOptions, actor, xpData, caracs) {
+    dialogData = mergeObject(dialogData, {
+      default: 'appliquer',
+      buttons: {
+        'appliquer': { icon:'<i class="fa-solid fa-check"></i>', label: "Ajouter la répartition", callback: it => this.appliquerSelection() }
+      }
+    })
+    super(dialogData, dialogOptions)
+    this.actor = actor
+    this.xpData = xpData
+    this.caracs = caracs
+  }
+
+  activateListeners(html) {
+    //TODO
+    super.activateListeners(html)
+    this.html = html
+    this.html.find("li.xpCarac-option .xpCarac-moins").click(event =>
+      this.ajouterXp(event, -1)
+    )
+    this.html.find("li.xpCarac-option .xpCarac-plus").click(event =>
+      this.ajouterXp(event, 1)
+    )
+  }
+
+  async ajouterXp(event, delta) {
+    const liCarac = this.html.find(event.currentTarget)?.parents("li.xpCarac-option")
+    const label = liCarac?.data("carac-label")
+    const carac = this.caracs.find(c => c.label == label)
+    if (carac.ajout + delta < 0) {
+      ui.notifications.warn(`Impossible de diminuer les points à répartir en ${carac.label} en dessous de 0`)
+      return
+    }
+    if (this.xpData.reste - delta < 0) {
+      ui.notifications.warn(`Il ne reste plus de points à répartir en ${carac.label}`)
+      return
+    }
+    carac.ajout += delta
+    this.xpData.reste -= delta
+    liCarac.find("input.xpCarac-view-ajout").val(carac.ajout)
+    this.html.find("input.xpCarac-reste").val(this.xpData.reste)
+  }
+
+  async appliquerSelection() {
+    if (this.xpData.reste > 0) {
+      ui.notifications.warn(`Il vous reste ${this.xpData.reste} points à répartir`)
+      return
+    }
+    this.caracs.filter(c => c.ajout > 0).forEach(c => {
+      const xpData = { caracName: c.label, xpCarac: c.ajout }
+      this.actor._xpCarac(xpData)
+    })
+    await super.close()
+  }
+
+  async close() { }
+
+  _getHeaderButtons() { return [] }
+}
--- a/module/item/blessure.js
+++ b/module/item/blessure.js
@ -1,6 +1,7 @@
 import { RdDItem } from "../item.js";
 import { Misc } from "../misc.js";
 import { RdDTimestamp } from "../time/rdd-timestamp.js";
+import { ChatUtility } from "../chat-utility.js";

 const BASE_TACHE_SOIN_BLESSURE = {
  type: "tache",
@ -14,10 +15,10 @@ const TACHES_SOIN_BLESSURE = {
 }

 const definitionsBlessures = [
-  { type: "contusion", gravite: 0, label: 'Contusion/éraflure', max: 100, icon: "systems/foundryvtt-reve-de-dragon/icons/sante/eraflure.webp" },
-  { type: "legere", gravite: 2, label: 'Légère', max: 5, icon: "systems/foundryvtt-reve-de-dragon/icons/sante/blessure.webp" },
-  { type: "grave", gravite: 4, label: 'Grave', max: 2, icon: "systems/foundryvtt-reve-de-dragon/icons/sante/blessure.webp" },
-  { type: "critique", gravite: 6, label: 'Critique', max: 1, icon: "systems/foundryvtt-reve-de-dragon/icons/sante/blessure.webp" },
+  { type: "contusion", gravite: 0, endurance: "1d4", vie: 0, label: 'Contusion/éraflure', max: 100, icon: "systems/foundryvtt-reve-de-dragon/icons/sante/eraflure.webp" },
+  { type: "legere", gravite: 2, endurance: "1d6", vie: 0, label: 'Légère', max: 5, icon: "systems/foundryvtt-reve-de-dragon/icons/sante/blessure.webp" },
+  { type: "grave", gravite: 4, endurance: "2d6", vie: -2, label: 'Grave', max: 2, icon: "systems/foundryvtt-reve-de-dragon/icons/sante/blessure.webp" },
+  { type: "critique", gravite: 6, endurance: "-100", vie: -4, label: 'Critique', max: 1, icon: "systems/foundryvtt-reve-de-dragon/icons/sante/blessure.webp" },
  { type: "mort", gravite: 8, label: 'Mort', max: 1, icon: "systems/foundryvtt-reve-de-dragon/icons/sante/mort.webp" }
 ]

@ -40,6 +41,32 @@ export class RdDItemBlessure extends RdDItem {
    }
    return mergeObject(duplicate(BASE_TACHE_SOIN_BLESSURE), tache)
  }
+
+  static async applyFullBlessure(actor, gravite) {
+    const definition = RdDItemBlessure.getDefinition(gravite)
+    
+    let lostEndurance = 0
+    let lostVie = 0
+    if (definition.endurance) {
+      lostEndurance = new Roll(definition.endurance).roll({async: false}).total;
+      actor.santeIncDec("endurance", -Number(lostEndurance));
+    }
+    if (definition.vie) {
+      lostVie = definition.vie
+      actor.santeIncDec("vie", definition.vie)
+    }
+    
+    await this.createBlessure(actor, gravite)
+
+    ChatMessage.create({
+      content: `Blessure ${definition.label} appliquée à ${actor.name}`+
+        `<br>Perte d'endurance : ${lostEndurance}`+
+        `<br>Perte de Vie : ${lostVie}`,
+      whisper: ChatUtility.getWhisperRecipientsAndGMs(actor.name)
+    });
+
+  }
+
  static async createBlessure(actor, gravite, localisation = '', attacker) {
    const definition = RdDItemBlessure.getDefinition(gravite)
    const blessure = {
--- a/module/misc.js
+++ b/module/misc.js
@ -22,6 +22,10 @@ export class Misc {
    const isPositiveNumber = value != NaN && value > 0;
    return isPositiveNumber ? "+" + number : number
  }
+  
+  static modulo(n, m) {
+    return ((n % m) + m) % m;
+  }

  static sum() {
    return (a, b) => Number(a) + Number(b);
--- a/module/rdd-bonus.js
+++ b/module/rdd-bonus.js
@ -19,10 +19,6 @@ export class RdDBonus {
  }


-  static isAjustementAstrologique(rollData) {
-    return RdDCarac.isChance(rollData.selectedCarac) ||
-      rollData.selectedSort?.system.isrituel;
-  }
  /* -------------------------------------------- */
  static isDefenseAttaqueFinesse(rollData) {
    if (rollData.isEmpoignade && rollData.rolled?.isPart) {
--- a/module/rdd-combat.js
+++ b/module/rdd-combat.js
@ -328,8 +328,8 @@ export class RdDCombatManager extends Combat {
      }
    }
    options = [
-      { name: "Incrémenter initiative", condition: true, icon: '<i class="fas fa-plus"></i>', callback: target => { RdDCombatManager.incDecInit(target.data('combatant-id'), +0.01); } },
-      { name: "Décrémenter initiative", condition: true, icon: '<i class="fas fa-minus"></i>', callback: target => { RdDCombatManager.incDecInit(target.data('combatant-id'), -0.01); } }
+      { name: "Incrémenter initiative", condition: true, icon: '<i class="fa-solid fa-plus"></i>', callback: target => { RdDCombatManager.incDecInit(target.data('combatant-id'), +0.01); } },
+      { name: "Décrémenter initiative", condition: true, icon: '<i class="fa-solid fa-minus"></i>', callback: target => { RdDCombatManager.incDecInit(target.data('combatant-id'), -0.01); } }
    ].concat(options);
  }
  /* -------------------------------------------- */
@ -515,7 +515,7 @@ export class RdDCombat {
  static _callJetDeVie(event) {
    let actorId = event.currentTarget.attributes['data-actorId'].value;
    let tokenId = event.currentTarget.attributes['data-tokenId'].value;
-    let token = canvas.tokens.placeables.find(t => t.id == tokenId)
+    let token = canvas.tokens.get(tokenId)
    const actor = token?.actor ?? game.actors.get(actorId);
    if (actor?.isOwner) {
      actor.jetDeVie();
@ -1307,6 +1307,7 @@ export class RdDCombat {
      blessuresStatus: actor.computeResumeBlessure(),
      SConst: actor.getSConst(),
      actorId: actor.id,
+      actor: actor,
      tokenId: tokenId,
      isGrave: actor.countBlessures(it => it.isGrave()) > 0,
      isCritique: actor.countBlessures(it => it.isCritique()) > 0
--- a/module/rdd-commands.js
+++ b/module/rdd-commands.js
@ -16,6 +16,7 @@ import { RdDRollTables } from "./rdd-rolltables.js";
 import { RdDUtility } from "./rdd-utility.js";
 import { FenetreRechercheTirage } from "./tirage/fenetre-recherche-tirage.js";
 import { TMRUtility } from "./tmr-utility.js";
+import { DialogFatigueVoyage } from "./voyage/dialog-fatigue-voyage.js";

 const rddRollNumeric = /^(\d+)\s*([\+\-]?\d+)?\s*(s)?/;

@ -76,6 +77,7 @@ export class RdDCommands {
    this.registerCommand({ path: ["/tirer", "desir"], func: (content, msg, params) => RdDRollTables.getDesirLancinant('chat'), descr: "Tire un Désir Lancinant" });
    this.registerCommand({ path: ["/tirer", "rencontre"], func: (content, msg, params) => this.getRencontreTMR(params), descr: `Détermine une rencontre dans les TMR (synonyme de "/tmrr")` });
    this.registerCommand({ path: ["/tirage"], func: (content, msg, params) => this.tirage(), descr: "Ouvre la fenêtre de recherche et tirage" });
+    this.registerCommand({ path: ["/voyage"], func: (content, msg, params) => this.voyage(msg, params), descr: "Gérer le voyage" });

    this.registerCommand({ path: ["/sommeil"], func: (content, msg, params) => this.sommeil(msg, params), descr: "Prépare le passage de journée pour chateau dormant" });
    this.registerCommand({ path: ["/meteo"], func: (content, msg, params) => this.getMeteo(msg, params), descr: "Propose une météo marine" });
@ -298,7 +300,7 @@ export class RdDCommands {
  async getRencontreTMR(params) {
    if (params.length == 1 || params.length == 2) {
      return game.system.rdd.rencontresTMR.rollRencontre(params[0], params[1])
-    }
+    }    
    return false;
  }

@ -485,10 +487,13 @@ export class RdDCommands {
  }

  async tirage() {
-    FenetreRechercheTirage.create();
+    FenetreRechercheTirage.create()
+  }
+  async voyage() {
+    DialogFatigueVoyage.create()
  }
  async sommeil() {
-    DialogChateauDormant.create();
+    DialogChateauDormant.create()
  }
 }

--- a/module/rdd-main.js
+++ b/module/rdd-main.js
@ -266,16 +266,16 @@ export class SystemReveDeDragon {
    /* -------------------------------------------- */
    /*  Foundry VTT Initialization                  */
    /* -------------------------------------------- */
-    // CSS patch for v9
-    if (game.version) {
-      let sidebar = document.getElementById("sidebar");
-      sidebar.style.width = "min-content";
-    }
    game.system.rdd.calendrier = new RdDCalendrier();
    if (Misc.isUniqueConnectedGM()) {
      new Migrations().migrate();
      this.messageDeBienvenue();
-      this.registerUsageCount(SYSTEM_RDD);
+      import("https://www.uberwald.me/fvtt_appcount/count-class-ready.js").then(moduleCounter=>{
+        console.log("ClassCounter loaded", moduleCounter)
+        moduleCounter.ClassCounter.registerUsageCount()
+      }).catch(err=>
+        console.log("No stats available, giving up.")
+      )    
    }

    StatusEffects.onReady();
@ -306,30 +306,6 @@ export class SystemReveDeDragon {
      ` });
    }
  }
-
-  /* -------------------------------------------- */
-  // Register world usage statistics
-  async registerUsageCount(registerKey) {
-    if (game.user.isGM) {
-      game.settings.register("world", "world-key", {
-        name: "Unique world key",
-        scope: "world",
-        config: false,
-        default: "NONE",
-        type: String
-      });
-
-      let worldKey = game.settings.get("world", "world-key")
-      if (worldKey == undefined || worldKey == "") {
-        worldKey = randomID(32)
-        game.settings.set("world", "world-key", worldKey)
-      }
-      let regURL = `https://www.uberwald.me/fvtt_appcount/count.php?name="${registerKey}"&worldKey="${worldKey}"&version="${game.release.generation}.${game.release.build}"&system="${game.system.id}"&systemversion="${game.system.version}"`
-      $.ajax(regURL)
-      /* -------------------------------------------- */
-    }
-  }
-
 }

 SystemReveDeDragon.start();
--- a/module/rdd-roll.js
+++ b/module/rdd-roll.js
@ -44,6 +44,7 @@ export class RdDRoll extends Dialog {
      diffLibre: rollData.competence?.system.default_diffLibre ?? 0,
      perteMoralEchec: false, /* Pour l'affichage dans le chat */
      use: {
+        astrologique: true,
        moral: false, /* Est-ce que le joueur demande d'utiliser le moral ? Utile si le joueur change plusieurs fois de carac associée. */
        libre: true,
        coeur: undefined,
@ -214,6 +215,10 @@ export class RdDRoll extends Dialog {
      this.rollData[attribute] = event.currentTarget.checked;
      this.updateRollResult(html);
    });
+    this.html.find('input.use-astrologique').change((event) => {
+      this.rollData.use.astrologique = event.currentTarget.checked;
+      this.updateRollResult(html);
+    });
    this.html.find('input.use-encTotal').change((event) => {
      this.rollData.use.encTotal = event.currentTarget.checked;
      this.updateRollResult(html);
@ -314,6 +319,7 @@ export class RdDRoll extends Dialog {

    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(".use-astrologique"), rollData.ajustements.astrologique.visible);
    HtmlUtility.showControlWhen(this.html.find(".utilisation-moral"), rollData.use.appelAuMoral);
    HtmlUtility.showControlWhen(this.html.find(".divAppelAuMoral"), rollData.use.appelAuMoral);
    HtmlUtility.showControlWhen(this.html.find(".utilisation-coeur"), rollData.ajustements.coeur.visible);
--- a/module/rdd-tmr-dialog.js
+++ b/module/rdd-tmr-dialog.js
@ -17,6 +17,7 @@ import { STATUSES } from "./settings/status-effects.js";
 import { RdDRencontre } from "./item/rencontre.js";
 import { RdDTimestamp } from "./time/rdd-timestamp.js";
 import { TYPES } from "./item.js";
+import { Misc } from "./misc.js";

 const TMR_DISPLAY_SIZE = {
  code: 'tmr-display-size',
@ -141,7 +142,7 @@ export class RdDTMRDialog extends Dialog {
    // Le reste...
    this.updateValuesDisplay();
  }
-  
+
  async onDeplacement() {
    await this.manageRencontre(TMRUtility.getTMR(this._getCoordActor()));
  }
@ -162,9 +163,11 @@ export class RdDTMRDialog extends Dialog {
  }

  async forceTMRDisplay() {
-    this.bringToTop()
-    if (this.subdialog?.bringToTop) {
-      this.subdialog.bringToTop();
+    if (this.rendered) {
+      this.bringToTop()
+      if (this.subdialog?.bringToTop) {
+        this.subdialog.bringToTop();
+      }
    }
  }

@ -247,26 +250,21 @@ export class RdDTMRDialog extends Dialog {

  /* -------------------------------------------- */
  _getTokensCasesTmr() {
-    return this.casesSpeciales.map(c => this._tokenCaseSpeciale(c)).filter(token => token);
-  }
-  _getTokensRencontres() {
-    return this.rencontresExistantes.map(it => this._tokenRencontre(it));
-  }
-  _getTokensSortsReserve() {
-    return this.actor.itemTypes[TYPES.sortreserve].map(it => this._tokenSortEnReserve(it));
+    return Misc.concat(this.casesSpeciales.map(caseSpeciale =>
+      Draconique.get(caseSpeciale.system.specific)?.token(this.pixiTMR, caseSpeciale, () => caseSpeciale.system.coord)
+    ))
  }

-  /* -------------------------------------------- */
-  _tokenRencontre(rencontre) {
-    return EffetsDraconiques.rencontre.token(this.pixiTMR, rencontre, () => rencontre.system.coord);
+  _getTokensRencontres() {
+    return Misc.concat(this.rencontresExistantes.map(rencontre =>
+      EffetsDraconiques.rencontre.tokens(this.pixiTMR, rencontre, () => rencontre.system.coord)
+    ))
  }
-  _tokenCaseSpeciale(casetmr) {
-    const caseData = casetmr;
-    const draconique = Draconique.get(caseData.system.specific);
-    return draconique?.token(this.pixiTMR, caseData, () => caseData.system.coord);
-  }
-  _tokenSortEnReserve(sortReserve) {
-    return EffetsDraconiques.sortReserve.token(this.pixiTMR, sortReserve, () => sortReserve.system.coord);
+
+  _getTokensSortsReserve() {
+    const sortsReserve = this.actor.itemTypes[TYPES.sortreserve];
+    return Misc.concat(sortsReserve.map(sortReserve =>
+      EffetsDraconiques.sortReserve.tokens(this.pixiTMR, sortReserve, () => sortReserve.system.coord)))
  }

  _tokenDemiReve() {
@ -342,7 +340,7 @@ export class RdDTMRDialog extends Dialog {
        this._tellToGM(this.actor.name + " a quitté les terres médianes");
      }
      await this.actor.santeIncDec((ReglesOptionnelles.isUsing("appliquer-fatigue") ? "fatigue" : "endurance"),
-      this.cumulFatigue)
+        this.cumulFatigue)
    }
    await super.close();
    this.pixiTMR.close()
@ -581,7 +579,7 @@ export class RdDTMRDialog extends Dialog {
    }
    this.descenteTMR = false;
    this.currentRencontre = undefined;
-    if (this._presentCite(tmr)) {
+    if (await this._presentCite(tmr)) {
      return;
    }
    this.currentRencontre = await this._jetDeRencontre(tmr);
@ -592,7 +590,7 @@ export class RdDTMRDialog extends Dialog {
      }
      else {
        const dialog = new RdDTMRRencontreDialog(this.actor, this.currentRencontre, tmr);
-        dialog.render(true);
+        await dialog.render(true);
        this.setTMRPendingAction(dialog);
      }
    }
@ -602,11 +600,11 @@ export class RdDTMRDialog extends Dialog {
  }

  /* -------------------------------------------- */
-  _presentCite(tmr) {
+  async _presentCite(tmr) {
    const presentCite = this.casesSpeciales.find(c => EffetsDraconiques.presentCites.isCase(c, tmr.coord));
    if (presentCite) {
      const caseData = presentCite;
-      const dialog = EffetsDraconiques.presentCites.choisirUnPresent(caseData, present => {
+      const dialog = await EffetsDraconiques.presentCites.choisirUnPresent(caseData, present => {
        this._utiliserPresentCite(presentCite, present, tmr)
        this.restoreTMRAfterAction();
      });
@ -702,7 +700,6 @@ export class RdDTMRDialog extends Dialog {
  }

  async _resultatMaitriseCaseHumide(rollData) {
-    await this.souffleSiEchecTotal(rollData);
    if (rollData.rolled.isSuccess && rollData.double) {
      rollData.previous = { rolled: rollData.rolled, ajustements: rollData.ajustements };
      rollData.double = undefined;
@ -717,6 +714,7 @@ export class RdDTMRDialog extends Dialog {
    if (rollData.rolled.isEchec) {
      await this.close();
    }
+    await this.souffleSiEchecTotal(rollData);
  }

  /* -------------------------------------------- */
@ -1126,6 +1124,9 @@ export class RdDTMRDialog extends Dialog {

  /* -------------------------------------------- */
  _trackToken(token) {
+    if (!token) {
+      return
+    }
    if (this.demiReve === token && this.isDemiReveCache()) {
      return;
    }
--- a/module/rdd-token-hud.js
+++ b/module/rdd-token-hud.js
@ -90,7 +90,6 @@ export class RdDTokenHud {
    if (target?.actor) {
      const hudSoins = { blessures: target.actor.blessuresASoigner() ?? [] };
      if (hudSoins.blessures.length > 0) {
-        // soins
        const controlIconTarget = html.find('.control-icon[data-action=combat]');
        await RdDTokenHud._configureSubMenu(controlIconTarget,
          'systems/foundryvtt-reve-de-dragon/templates/hud-actor-soins.hbs',
--- a/module/rdd-utility.js
+++ b/module/rdd-utility.js
@ -63,12 +63,6 @@ const cumulFatigueMatrix = _cumulSegmentsFatigue(fatigueMatrix);
 const fatigueMalus = [0, 0, 0, -1, -1, -1, -2, -3, -4, -5, -6, -7]; // Provides the malus for each segment of fatigue
 const fatigueLineSize = [3, 6, 7, 8, 9, 10, 11, 12];
 const fatigueLineMalus = [0, -1, -2, -3, -4, -5, -6, -7];
-const fatigueMarche = {
-  "aise": { "4": 1, "6": 2, "8": 3, "10": 4, "12": 6 },
-  "malaise": { "4": 2, "6": 3, "8": 4, "10": 6 },
-  "difficile": { "4": 3, "6": 4, "8": 6 },
-  "tresdifficile": { "4": 4, "6": 6 }
-}

 /* -------------------------------------------- */
 const nomEthylisme = ["Emeché", "Gris", "Pinté", "Pas frais", "Ivre", "Bu", "Complètement fait", "Ivre mort"];
@ -208,6 +202,8 @@ export class RdDUtility {
      'systems/foundryvtt-reve-de-dragon/templates/coeur/afficher-coeur.hbs',
      'systems/foundryvtt-reve-de-dragon/templates/tirage/liste-resultats-recherche.hbs',
      'systems/foundryvtt-reve-de-dragon/templates/time/horloge.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/voyage/fatigue-actor.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/voyage/option-vitesse-fatigue.hbs',
      'systems/foundryvtt-reve-de-dragon/templates/common/timestamp.hbs',
      'systems/foundryvtt-reve-de-dragon/templates/common/periodicite.hbs',
      'systems/foundryvtt-reve-de-dragon/templates/common/enum-duree.hbs',
@ -215,15 +211,16 @@ export class RdDUtility {
      'systems/foundryvtt-reve-de-dragon/templates/partial-description-overflow.html',
      'systems/foundryvtt-reve-de-dragon/templates/partial-description-sort.html',
      'systems/foundryvtt-reve-de-dragon/templates/partial-roll-ajustements.html',
+      'systems/foundryvtt-reve-de-dragon/templates/partial-roll-astrologique.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/partial-roll-coeur.hbs',
+      'systems/foundryvtt-reve-de-dragon/templates/partial-roll-competences.html',
      'systems/foundryvtt-reve-de-dragon/templates/partial-roll-diffLibre.html',
      'systems/foundryvtt-reve-de-dragon/templates/partial-roll-diffFixe.html',
      'systems/foundryvtt-reve-de-dragon/templates/partial-roll-diffCondition.html',
-      'systems/foundryvtt-reve-de-dragon/templates/partial-roll-surenc.html',
      'systems/foundryvtt-reve-de-dragon/templates/partial-roll-enctotal.html',
-      'systems/foundryvtt-reve-de-dragon/templates/partial-roll-moral.html',
-      'systems/foundryvtt-reve-de-dragon/templates/partial-roll-coeur.hbs',
      'systems/foundryvtt-reve-de-dragon/templates/partial-roll-forcer.html',
-      'systems/foundryvtt-reve-de-dragon/templates/partial-roll-competences.html',
+      'systems/foundryvtt-reve-de-dragon/templates/partial-roll-moral.html',
+      'systems/foundryvtt-reve-de-dragon/templates/partial-roll-surenc.html',
      'systems/foundryvtt-reve-de-dragon/templates/partial-select-carac.html',
      'systems/foundryvtt-reve-de-dragon/templates/partial-item-hautrevant.html',
      'systems/foundryvtt-reve-de-dragon/templates/partial-item-frequence.html',
@ -287,6 +284,7 @@ export class RdDUtility {
    Handlebars.registerHelper('timestamp-formulesDuree', () => RdDTimestamp.formulesDuree());
    Handlebars.registerHelper('timestamp-formulesPeriode', () => RdDTimestamp.formulesPeriode());

+    Handlebars.registerHelper('array-includes', (array, value) => array.includes(value));
    Handlebars.registerHelper('min', (...args) => Math.min(...args.slice(0, -1)));
    Handlebars.registerHelper('regle-optionnelle', (option) => ReglesOptionnelles.isUsing(option));
    Handlebars.registerHelper('trier', list => list.sort((a, b) => a.name.localeCompare(b.name)));
--- a/module/rolldata-ajustements.js
+++ b/module/rolldata-ajustements.js
@ -64,19 +64,30 @@ export const referenceAjustements = {
  },
  encTotal: {
    isVisible: (rollData, actor) => RdDCarac.isAgiliteOuDerobee(rollData.selectedCarac) && RdDItemCompetence.isMalusEncombrementTotal(rollData.competence),
-    isUsed: (rollData, actor) => !rollData.oeuvre && RdDCarac.isAgiliteOuDerobee(rollData.selectedCarac) && RdDItemCompetence.isMalusEncombrementTotal(rollData.competence) && rollData.use.encTotal,
+    isUsed: (rollData, actor) => !rollData.oeuvre && RdDCarac.isAgiliteOuDerobee(rollData.selectedCarac) && RdDItemCompetence.isMalusEncombrementTotal(rollData.competence) && rollData.use?.encTotal,
    getLabel: (rollData, actor) => 'Encombrement total',
    getValue: (rollData, actor) => -actor.getEncTotal()
  },
  surenc: {
    isVisible: (rollData, actor) => RdDCarac.isActionPhysique(rollData.selectedCarac) && actor.isSurenc(),
-    isUsed: (rollData, actor) => rollData.use?.surenc && RdDCarac.isActionPhysique(rollData.selectedCarac),
+    isUsed: (rollData, actor) => rollData.use.surenc && RdDCarac.isActionPhysique(rollData.selectedCarac),
    getLabel: (rollData, actor) => 'Sur-encombrement',
    getValue: (rollData, actor) => actor.computeMalusSurEncombrement()
  },
+  rituel: {
+    isUsed: (rollData, actor) => actor.isPersonnage() && ReglesOptionnelles.isUsing("astrologie") && rollData.selectedSort?.system.isrituel,
+    getLabel: (rollData, actor) => 'Astrologique',
+    getValue: (rollData, actor) => actor.ajustementAstrologique()
+  },
+  astrologique: {
+    isVisible: (rollData, actor) => actor.isPersonnage() && ReglesOptionnelles.isUsing("astrologie") && RdDCarac.isChance(rollData.selectedCarac),
+    isUsed: (rollData, actor) =>  RdDCarac.isChance(rollData.selectedCarac) && rollData.use.astrologique,
+    getLabel: (rollData, actor) => 'Astrologique',
+    getValue: (rollData, actor) => actor.ajustementAstrologique()
+  },
  moral: {
    isVisible: (rollData, actor) => actor.isPersonnage() && RdDCarac.isActionPhysique(rollData.selectedCarac) && rollData.use?.moral,
-    isUsed: (rollData, actor) => rollData.use?.moral,
+    isUsed: (rollData, actor) => rollData.use.moral,
    getLabel: (rollData, actor) => 'Appel au moral',
    getValue: (rollData, actor) => 1
  },
@ -91,11 +102,6 @@ export const referenceAjustements = {
    getLabel: (rollData, actor) => 'Moral',
    getValue: (rollData, actor) => actor.getMoralTotal()
  },
-  astrologique: {
-    isUsed: (rollData, actor) => ReglesOptionnelles.isUsing("astrologie") && RdDBonus.isAjustementAstrologique(rollData),
-    getLabel: (rollData, actor) => 'Astrologique',
-    getValue: (rollData, actor) => actor.ajustementAstrologique()
-  },
  facteurSign: {
    isUsed: (rollData, actor) => rollData.diviseurSignificative > 1,
    getLabel: (rollData, actor) => Misc.getFractionHtml(rollData.diviseurSignificative),
@ -141,7 +147,7 @@ export const referenceAjustements = {
    getLabel: (rollData, actor) => "Force de l'alcool: ",
    getValue: (rollData, actor) => rollData.forceAlcool,
  },
-  ethylisme:{
+  ethylisme: {
    isVisible: (rollData, actor) => rollData.ethylisme != undefined,
    isUsed: (rollData, actor) => rollData.ethylisme != undefined,
    getLabel: (rollData, actor) => "Ethylisme - " + RdDUtility.getNomEthylisme(rollData.ethylisme),
@ -159,7 +165,9 @@ export class RollDataAjustements {

  /* -------------------------------------------- */
  static calcul(rollData, actor) {
-    rollData.ajustements = {};
+    // s'assurer de la correction des infos rollData
+    mergeObject(rollData, { ajustements: {}, use: {} }, { overwrite: false })
+
    for (var key in referenceAjustements) {
      const reference = referenceAjustements[key];
      rollData.ajustements[key] = {
@ -191,4 +199,5 @@ export class RollDataAjustements {
      RdDCarac.isChance(selectedCarac) ||
      (RdDCarac.isReve(selectedCarac) && !rollData.competence);
  }
+
 }
--- a/module/settings/status-effects.js
+++ b/module/settings/status-effects.js
@ -1,13 +1,13 @@
 import { SYSTEM_RDD } from "../constants.js";

 export const STATUSES = {
-  StatusStunned : 'stun',
+  StatusStunned: 'stun',
  StatusBleeding: 'bleeding',
  StatusProne: 'prone',
  StatusGrappling: 'grappling',
  StatusGrappled: 'grappled',
  StatusRestrained: 'restrain',
-  StatusUnconscious: 'unconscious', 
+  StatusUnconscious: 'unconscious',
  StatusBlind: 'blind',
  StatusComma: 'comma',
  StatusDead: 'dead',
@ -18,8 +18,8 @@ const rddStatusEffects = [
  { rdd: true, id: STATUSES.StatusStunned, label: 'EFFECT.StatusStunned', icon: 'icons/svg/stoned.svg', "duration.rounds": 1 },
  { rdd: true, id: STATUSES.StatusBleeding, label: 'EFFECT.StatusBleeding', icon: 'icons/svg/blood.svg' },
  { rdd: true, id: STATUSES.StatusProne, label: 'EFFECT.StatusProne', icon: 'icons/svg/falling.svg' },
-  { rdd: true, id: STATUSES.StatusGrappling, tint: '#33cc33', label: 'EFFECT.StatusGrappling', icon: 'systems/foundryvtt-reve-de-dragon/icons/competence_corps_a_corps.webp' },
-  { rdd: true, id: STATUSES.StatusGrappled, tint: '#ff9900', label: 'EFFECT.StatusGrappled', icon: 'systems/foundryvtt-reve-de-dragon/icons/competence_corps_a_corps.webp' },
+  { rdd: true, id: STATUSES.StatusGrappling, tint: '#33cc33', label: 'EFFECT.StatusGrappling', icon: 'systems/foundryvtt-reve-de-dragon/icons/empoignade.svg' },
+  { rdd: true, id: STATUSES.StatusGrappled, tint: '#ff9900', label: 'EFFECT.StatusGrappled', icon: 'systems/foundryvtt-reve-de-dragon/icons/empoignade.svg' },
  { rdd: true, id: STATUSES.StatusRestrained, label: 'EFFECT.StatusRestrained', icon: 'icons/svg/net.svg' },
  { rdd: true, id: STATUSES.StatusUnconscious, label: 'EFFECT.StatusUnconscious', icon: 'icons/svg/unconscious.svg' },
  { rdd: true, id: STATUSES.StatusBlind, label: 'EFFECT.StatusBlind', icon: 'icons/svg/blind.svg' },
@ -29,13 +29,16 @@ const rddStatusEffects = [
 ];
 const demiReveStatusEffect = rddStatusEffects.find(it => it.id == STATUSES.StatusDemiReve);

-const statusDemiSurprise = [STATUSES.StatusStunned, STATUSES.StatusProne, STATUSES.StatusRestrained];
-const statusSurpriseTotale = [STATUSES.StatusUnconscious, STATUSES.StatusBlind, STATUSES.StatusComma];
+const statusDemiSurprise = new Set([STATUSES.StatusStunned, STATUSES.StatusProne, STATUSES.StatusRestrained])
+const statusSurpriseTotale = new Set([STATUSES.StatusUnconscious, STATUSES.StatusBlind, STATUSES.StatusComma])

 export class StatusEffects extends FormApplication {
  static onReady() {
-    const rddStatusIds = rddStatusEffects.map(it => it.id);
-    rddStatusEffects.forEach(it => it.flags = { core: { statusId: it.id } });
+    const rddEffectIds = rddStatusEffects.map(it => it.id);
+    rddStatusEffects.forEach(it => {
+      it.statuses = new Set()
+      it.statuses.add(it.id)
+    })
    const defaultStatusEffectIds = CONFIG.statusEffects.map(it => it.id);
    game.settings.register(SYSTEM_RDD, "use-status-effects", {
      name: "use-status-effects",
@ -54,37 +57,47 @@ export class StatusEffects extends FormApplication {
      restricted: true
    });

-    CONFIG.RDD.allEffects = rddStatusEffects.concat(CONFIG.statusEffects.filter(it => !rddStatusIds.includes(it.id)));
+    CONFIG.RDD.allEffects = rddStatusEffects.concat(CONFIG.statusEffects.filter(it => !rddEffectIds.includes(it.id)));

    StatusEffects._setUseStatusEffects(StatusEffects._getUseStatusEffects());
    console.log('statusEffects', CONFIG.statusEffects);
  }

  static valeurSurprise(effect, isCombat) {
-    // const id = StatusEffects.statusId(effect);
-    if (statusSurpriseTotale.includes(effect.flags?.core?.statusId)) {
+    if (statusSurpriseTotale.intersects(effect.statuses)) {
      return 2;
    }
-    return statusDemiSurprise.includes(effect.flags?.core?.statusId) || (isCombat && effect.flags?.core?.statusId == STATUSES.StatusDemiReve) ? 1 : 0;
+    if (statusDemiSurprise.intersects(effect.statuses)) {
+      return 1
+    }
+    if (isCombat && effect.statuses.find(e => e == STATUSES.StatusDemiReve)) {
+      return 1
+    }
+    return 0
  }

  static _getUseStatusEffects() {
-     return game.settings.get(SYSTEM_RDD, "use-status-effects")?.split(',') ?? [];
+    return game.settings.get(SYSTEM_RDD, "use-status-effects")?.split(',') ?? [];
  }

-  static _setUseStatusEffects(statusIds) {
+  static _setUseStatusEffects(effectIds) {
    if (game.user.isGM) {
-      game.settings.set(SYSTEM_RDD, "use-status-effects", statusIds.join());
+      game.settings.set(SYSTEM_RDD, "use-status-effects", effectIds.join());
    }

    for (let effect of CONFIG.RDD.allEffects) {
-      effect.active = effect.rdd || statusIds.includes(effect.flags?.core?.statusId);
+      effect.active = effect.rdd || effectIds.includes(effect.id);
    }
    CONFIG.statusEffects = CONFIG.RDD.allEffects.filter(it => it.active);
  }

-  static status(statusId) {
-    return rddStatusEffects.find(it => it.flags?.core?.statusId == statusId);
+  static prepareActiveEffect(effectId) {
+    let status = rddStatusEffects.find(it => it.id == effectId)
+    if (status) {
+      status = duplicate(status)
+      status.statuses = [effectId]
+    }
+    return status;
  }

  static demiReve() {
--- a/module/sommeil/app-astrologie.js
+++ b/module/sommeil/app-astrologie.js
@ -116,10 +116,10 @@ export class AppAstrologie extends Application {
    super.activateListeners(html);
    this.html = html;
    this.html.find('select[name="signe-astral"]').change(event => {
-      this.selectNombreAstral(this.html.find('select[name="signe-astral"]').val());
+      this.selectNombreAstral(event.currentTarget.value);
    })
    this.html.find('select[name="signe-naissance"]').change(event => {
-      this.selectHeureNaissance(this.html.find('select[name="signe-naissance"]').val());
+      this.selectHeureNaissance(event.currentTarget.value);
    })
    this.html.find('td.nombre-astral').click(event => {
      this.selectNombreAstral(Number.parseInt(event.currentTarget.attributes['data-nombre-astral'].value) - 1);
--- a/module/sommeil/dialog-repos.js
+++ b/module/sommeil/dialog-repos.js
@ -21,7 +21,7 @@ export class DialogRepos extends Dialog {
  }

  constructor(html, actor) {
-    let options = { classes: ["DialogCreateSigneDraconiqueActorsActors"], width: 400, height: 'fit-content', 'z-index': 99999 };
+    let options = { classes: ["dialog-repos"], width: 400, height: 'fit-content', 'z-index': 99999 };
    let conf = {
      title: "Se reposer",
      content: html,
--- a/module/time/rdd-timestamp.js
+++ b/module/time/rdd-timestamp.js
@ -2,7 +2,6 @@ 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";

@ -16,14 +15,14 @@ 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" , 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: "vaisseau", label: "Vaisseau", lettreFont: 'v', saison: "Printemps", darkness: 0.9 },
+  { key: "sirene", label: "Sirène", lettreFont: 'i', saison: "Printemps", darkness: 0.1 },
+  { 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: "epees", label: "Epées", lettreFont: 'e', saison: "Eté", darkness: 0 },
+  { key: "lyre", label: "Lyre", lettreFont: 'l', saison: "Automne", darkness: 0.1 },
+  { key: "serpent", label: "Serpent", lettreFont: 's', saison: "Automne", darkness: 0.9 },
  { 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 },
@ -98,10 +97,10 @@ export class RdDTimestamp {
  */
  static definition(signe) {
    if (signe == undefined) {
-      signe = 0;
+      signe = 0
    }
    if (Number.isInteger(signe)) {
-      return DEFINITION_HEURES[signe % RDD_HEURES_PAR_JOUR];
+      return DEFINITION_HEURES[Misc.modulo(signe, RDD_HEURES_PAR_JOUR)]
    }
    let definition = DEFINITION_HEURES.find(it => it.key == signe);
    if (!definition) {
@ -119,10 +118,7 @@ export class RdDTimestamp {
  }

  static ajustementAstrologiqueHeure(hn, nbAstral, heure) {
-    let ecart = (hn + nbAstral - heure) % RDD_HEURES_PAR_JOUR;
-    if (ecart < 0) {
-      ecart = (ecart + RDD_HEURES_PAR_JOUR) % RDD_HEURES_PAR_JOUR;
-    }
+    let ecart = Misc.modulo(hn + nbAstral - heure, RDD_HEURES_PAR_JOUR);
    switch (ecart) {
      case 0: return 4;
      case 4: case 8: return 2;
@ -158,11 +154,13 @@ export class RdDTimestamp {
  }

  static defHeure(heure) {
-    return DEFINITION_HEURES.find(it => (it.heure) == heure % RDD_HEURES_PAR_JOUR);
+    heure = Misc.modulo(heure, RDD_HEURES_PAR_JOUR);
+    return DEFINITION_HEURES.find(it => it.heure == heure)
  }
+
  static findHeure(heure) {
    heure = Grammar.toLowerCaseNoAccentNoSpace(heure);
-    let parHeureOuLabel = DEFINITION_HEURES.filter(it => (it.heure) == parseInt(heure) % RDD_HEURES_PAR_JOUR || Grammar.toLowerCaseNoAccentNoSpace(it.label) == heure);
+    let parHeureOuLabel = DEFINITION_HEURES.filter(it => Grammar.toLowerCaseNoAccentNoSpace(it.label) == heure || it.heure == Misc.modulo(parseInt(heure), RDD_HEURES_PAR_JOUR));
    if (parHeureOuLabel.length == 1) {
      return parHeureOuLabel[0];
    }
@ -232,19 +230,19 @@ export class RdDTimestamp {
  }

  get annee() { return Math.floor(this.indexDate / RDD_JOURS_PAR_AN) }
-  get mois() { return Math.floor((this.indexDate % RDD_JOURS_PAR_AN) / RDD_JOURS_PAR_MOIS) }
-  get jour() { return (this.indexDate % RDD_JOURS_PAR_AN) % RDD_JOURS_PAR_MOIS }
+  get mois() { return Math.floor(Misc.modulo(this.indexDate, RDD_JOURS_PAR_AN) / RDD_JOURS_PAR_MOIS) }
+  get jour() { return Misc.modulo(Misc.modulo(this.indexDate, RDD_JOURS_PAR_AN), RDD_JOURS_PAR_MOIS) }
  get heure() { return Math.floor(this.indexMinute / RDD_MINUTES_PAR_HEURES) }
-  get minute() { return this.indexMinute % RDD_MINUTES_PAR_HEURES }
+  get minute() { return Misc.modulo(this.indexMinute, RDD_MINUTES_PAR_HEURES) }
  get round() { return ROUNDS_PAR_MINUTE * (this.indexMinute - Math.floor(this.indexMinute)) }
  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 darknessDebut = 100 * RdDTimestamp.definition(this.heure).darkness
+    const darknessFin =  100 * RdDTimestamp.definition(this.heure + 1).darkness
    const darknessMinute = Math.round((darknessFin - darknessDebut) * this.minute / RDD_MINUTES_PAR_HEURES);
-    return (darknessDebut + darknessMinute)/100
+    return (darknessDebut + darknessMinute) / 100
  }

  /**
@ -297,7 +295,7 @@ export class RdDTimestamp {
    const heure = this.heure + heures;
    return new RdDTimestamp({
      indexDate: this.indexDate + Math.floor(heure / RDD_HEURES_PAR_JOUR),
-      indexMinute: this.indexMinute + (heure % RDD_HEURES_PAR_JOUR) * RDD_MINUTES_PAR_HEURES
+      indexMinute: this.indexMinute + Misc.modulo(heure, RDD_HEURES_PAR_JOUR) * RDD_MINUTES_PAR_HEURES
    })
  }

@ -347,7 +345,7 @@ export class RdDTimestamp {
    return {
      jours: jours,
      heures: Math.floor(minutes / RDD_MINUTES_PAR_HEURES),
-      minutes: minutes % RDD_MINUTES_PAR_HEURES
+      minutes: Misc.modulo(minutes, RDD_MINUTES_PAR_HEURES)
    }
  }
 }
--- a/module/tmr-rencontres.js
+++ b/module/tmr-rencontres.js
@ -39,6 +39,8 @@ export class TMRRencontres {
    const frequence = it => it.system.frequence[codeTerrain];
    const row = await this.table.getRandom(frequence, filtreMauvaise, forcedRoll);
    if (row) {
+      console.log("DORM", row);
+      //row.document.system.computedForce = new Roll(row.document.system.formula).roll({async: false}).total; 
      await CompendiumTableHelpers.tableRowToChatMessage(row);
    }

--- a/module/tmr/draconique.js
+++ b/module/tmr/draconique.js
@ -18,8 +18,8 @@ export class Draconique {
  static isTeteDragon(item) { return item.type == TYPES.tete; }
  static isQueueSouffle(item) { return Draconique.isQueueDragon(item) || Draconique.isSouffleDragon(item); }

-  static register(draconique) {
-    registeredEffects[draconique.code()] = draconique;
+  static register(draconique, code = undefined) {
+    registeredEffects[code ?? draconique.code()] = draconique;
    if (draconique.img()) {
      PixiTMR.register(draconique.code(), draconique.img())
    }
@ -90,6 +90,15 @@ export class Draconique {
  */
  token(pixiTMR, linkData, coordTMR, type = undefined) {
    const tooltip = this.tooltip(linkData);
+    return this._createToken(pixiTMR, linkData, coordTMR, type, tooltip);
+  }
+  
+  tokens(pixiTMR, linkData, coordTMR, type = undefined) {
+    const tooltip = this.tooltip(linkData);
+    return [this._createToken(pixiTMR, linkData, coordTMR, type, tooltip)];
+  }
+
+  _createToken(pixiTMR, linkData, coordTMR, type, tooltip) {
    const token = {
      sprite: this.createSprite(pixiTMR),
      coordTMR: coordTMR,
--- a/module/tmr/effets-draconiques.js
+++ b/module/tmr/effets-draconiques.js
@ -6,7 +6,7 @@ import { ReserveExtensible } from "./reserve-extensible.js";
 import { DemiReve } from "./demi-reve.js";
 import { TrouNoir } from "./trou-noir.js";
 import { Rencontre } from "./rencontre.js";
-import { SortReserve } from "./sort-reserve.js";
+import { SortReserve, SortReserveHumide } from "./sort-reserve.js";
 import { CarteTmr } from "./carte-tmr.js";
 import { PontImpraticable } from "./pont-impraticable.js";
 import { Draconique } from "./draconique.js";
@ -26,6 +26,7 @@ export class EffetsDraconiques {
  static demiReve = new DemiReve();
  static rencontre = new Rencontre();
  static sortReserve = new SortReserve();
+  static sortReserveHumide = new SortReserveHumide();
  static debordement = new Debordement();
  static presentCites = new PresentCites();
  static fermetureCites = new FermetureCites();
@ -49,6 +50,7 @@ export class EffetsDraconiques {
    Draconique.register(EffetsDraconiques.demiReve);
    Draconique.register(EffetsDraconiques.rencontre);
    Draconique.register(EffetsDraconiques.sortReserve);
+    Draconique.register(EffetsDraconiques.sortReserveHumide);
    Draconique.register(EffetsDraconiques.debordement);
    Draconique.register(EffetsDraconiques.fermetureCites);
    Draconique.register(EffetsDraconiques.queteEaux);
--- a/module/tmr/pixi-tmr.js
+++ b/module/tmr/pixi-tmr.js
@ -58,7 +58,7 @@ export class PixiTMR {
    this.sizes = new TMRConstants({ size: displaySize })
    const appSize = PixiTMR.computeTMRSize(this.sizes)
    this.pixiApp.renderer.resize(appSize.width, appSize.height)
-    this.tooltipStyle.fontSize = Math.max(this.sizes.size / 4, 16)
+    this.tooltipStyle.fontSize = Math.max(this.sizes.size / 3, 16)
  }

  get view() {
@ -199,7 +199,7 @@ export class PixiTMR {
  setTooltipPosition(event) {
    const oddq = this.sizes.computeEventOddq(event);

-    this.tooltip.x = oddq.x + (oddq.col > 7 ? -3 * this.sizes.full : this.sizes.quarter);
+    this.tooltip.x = oddq.x + (oddq.col > 7 ? -2.5 * this.sizes.full : this.sizes.quarter);
    this.tooltip.y = oddq.y + (oddq.row > 10 ? -this.sizes.size : 0);
  }

--- a/module/tmr/present-cites.js
+++ b/module/tmr/present-cites.js
@ -49,7 +49,7 @@ export class PresentCites extends Draconique {
      content: `La ${this.tmrLabel(casetmr)} vous offre un présent, faites votre choix`,
      buttons: buttons
    });
-    dialog.render(true);
+    await dialog.render(true);
    return dialog
  }

--- a/module/tmr/sort-reserve.js
+++ b/module/tmr/sort-reserve.js
@ -1,5 +1,7 @@
 import { tmrTokenZIndex } from "../tmr-constants.js";
+import { TMRUtility } from "../tmr-utility.js";
 import { Draconique } from "./draconique.js";
+import { EffetsDraconiques } from "./effets-draconiques.js";

 export class SortReserve extends Draconique {

@ -19,4 +21,19 @@ export class SortReserve extends Draconique {
      taille: () => pixiTMR.sizes.third,
    });
  }
+
+  tokens(pixiTMR, linkData, coordTMR, type = undefined) {
+    if (TMRUtility.getTMR(coordTMR()).type == 'fleuve') {
+      const tooltip = this.tooltip(linkData)
+      const fleuves = TMRUtility.getListTMR('fleuve')
+      return fleuves.map(f => EffetsDraconiques.sortReserveHumide._createToken(pixiTMR, linkData, () => f.coord, type?? this.code(), tooltip))
+    }
+    return super.tokens(pixiTMR, linkData, coordTMR, type)
+  }
+}
+
+export class SortReserveHumide extends SortReserve {
+  code() { return 'sortreservehumide' }
+  tooltip(sort) { return `${sort.name} en fleuve, r${sort.system.ptreve}` }
+  img() { return 'systems/foundryvtt-reve-de-dragon/icons/tmr/sort-reserve-humide.svg' }
 }
--- a/module/voyage/dialog-fatigue-voyage.js
+++ b/module/voyage/dialog-fatigue-voyage.js
@ -0,0 +1,182 @@
+import { TYPES } from "../item.js"
+import { RdDItemCompetence } from "../item-competence.js"
+import { ChatUtility } from "../chat-utility.js"
+
+const CODES_COMPETENCES_VOYAGE = ['Extérieur', 'Forêt', 'Montagne', 'Marais', 'Glace', 'Equitation']
+const TABLEAU_FATIGUE_MARCHE = [
+  {
+    code: "aise", label: "Aisé", description: "Route ou chemin",
+    survies: ['Extérieur', 'Equitation'],
+    vitesses: [{ vitesse: 4, fatigue: 1 }, { vitesse: 6, fatigue: 2 }, { vitesse: 8, fatigue: 3 }, { vitesse: 10, fatigue: 4 }, { vitesse: 12, fatigue: 6 }],
+  },
+  {
+    code: "malaise", label: "Malaisé", description: "Hors piste (herbes et buissons)",
+    survies: ['Extérieur', 'Equitation'],
+    vitesses: [{ vitesse: 4, fatigue: 2 }, { vitesse: 6, fatigue: 3 }, { vitesse: 8, fatigue: 4 }, { vitesse: 10, fatigue: 6 }],
+  },
+  {
+    code: "difficile", label: "Difficile", description: "Hors piste (collines, forêt)",
+    survies: ['Extérieur', 'Forêt', 'Glace', 'Equitation'],
+    vitesses: [{ vitesse: 4, fatigue: 3 }, { vitesse: 6, fatigue: 4 }, { vitesse: 8, fatigue: 6 }],
+  },
+  {
+    code: "tresdifficile", label: "Très difficile", description: "Hors piste (montagne, jungle, marais)",
+    survies: ['Forêt', 'Montagne', 'Marais', 'Glace'],
+    vitesses: [{ vitesse: 4, fatigue: 4 }, { vitesse: 6, fatigue: 6 }],
+  },
+]
+
+export class DialogFatigueVoyage extends Dialog {
+  static dialog = undefined
+  static async create() {
+    if (!game.user.isGM) {
+      return
+    }
+    if (!DialogFatigueVoyage.dialog) {
+      const playerActors = game.actors.filter(actor => actor.hasPlayerOwner && actor.isPersonnage())
+        .map(actor => DialogFatigueVoyage.prepareActor(actor))
+      const parameters = {
+        tableauFatigueMarche: TABLEAU_FATIGUE_MARCHE,
+        playerActors: playerActors,
+        nombreHeures: 1,
+      }
+      DialogFatigueVoyage.setModeDeplacement(parameters, undefined, undefined)
+
+      const html = await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/voyage/dialog-fatigue-voyage.hbs", parameters);
+      DialogFatigueVoyage.dialog = new DialogFatigueVoyage(html, parameters);
+    }
+    DialogFatigueVoyage.dialog.render(true);
+  }
+
+  static setModeDeplacement(parameters, code, vitesse) {
+    const ligneFatigueMarche = TABLEAU_FATIGUE_MARCHE.find(it => it.code == code) ?? TABLEAU_FATIGUE_MARCHE[0]
+    const rythme = ligneFatigueMarche.vitesses.find(it => it.vitesse == vitesse) ?? ligneFatigueMarche.vitesses[0]
+    parameters.typeTerrain = ligneFatigueMarche
+    parameters.vitesseDeplacement = rythme.vitesse
+    parameters.fatigueHoraire = rythme.fatigue
+  }
+
+  static prepareActor(actor) {
+    const competencesVoyage = {}
+    CODES_COMPETENCES_VOYAGE.forEach(codeSurvie =>
+      competencesVoyage[codeSurvie] = RdDItemCompetence.findCompetence(actor.itemTypes[TYPES.competence], codeSurvie, { onMessage: () => { } })
+    )
+    return {
+      actor: actor,
+      selected: true,
+      ajustementFatigue: 0,
+      competencesVoyage: competencesVoyage
+    }
+  }
+
+
+  constructor(html, parameters) {
+    const options = {
+      classes: ["dialog-fatigue-voyage"],
+      width: 600,
+      height: 'fit-content',
+      'max-height': 900,
+      'z-index': 99999
+    }
+    const conf = {
+      title: "Fatigue de voyage",
+      content: html,
+      buttons: {}
+    }
+    super(conf, options);
+    this.parameters = parameters
+    this.controls = {}
+  }
+
+  activateListeners(html) {
+    if (this.html == undefined) {
+      html.find('select[name="code-terrain"]').trigger("focus")
+    }
+    this.html = html;
+    super.activateListeners(html);
+
+    this.html.find('select[name="code-terrain"]').change(event => this.changeParameters())
+    this.html.find('select[name="vitesse-deplacement"]').change(event => this.changeParameters())
+    this.html.find('input[name="nombre-heures"]').change(event => this.changeParameters())
+    this.html.find('button[name="appliquer-fatigue"]').click(event => this.appliquerFatigue())
+  }
+
+  changeParameters() {
+    this.changeTerrain(this.html.find('select[name="code-terrain"]').val())
+    this.changeVitesse(this.html.find('select[name="vitesse-deplacement"]').val())
+    this.changeNombreHeures(this.html.find('input[name="nombre-heures"]').val())
+    this.setFatigue()
+  }
+
+  async changeTerrain(codeTerrain) {
+    if (this.parameters.typeTerrain.code != codeTerrain) {
+      const selectVitesseDeplacement = this.html.find('select[name="vitesse-deplacement"]')
+      const vitesse = selectVitesseDeplacement.val()
+      selectVitesseDeplacement.empty()
+
+      DialogFatigueVoyage.setModeDeplacement(this.parameters, codeTerrain, vitesse)
+      this.parameters.typeTerrain.vitesses.forEach(async rythme => {
+        selectVitesseDeplacement.append(await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/voyage/option-vitesse-fatigue.hbs', rythme))
+      })
+      selectVitesseDeplacement.val(this.parameters.vitesseDeplacement).change()
+    }
+  }
+
+  async changeVitesse(vitesse) {
+    if (this.parameters.vitesseDeplacement != vitesse) {
+      DialogFatigueVoyage.setModeDeplacement(this.parameters, this.parameters.typeTerrain.code, vitesse)
+    }
+  }
+
+  async changeNombreHeures(nombreHeures) {
+    this.parameters.nombreHeures = parseInt(nombreHeures)
+  }
+
+  async setFatigue() {
+    this.html.find('input[name="base-fatigue"]').val(this.parameters.nombreHeures * this.parameters.fatigueHoraire)
+  }
+
+  async appliquerFatigue() {
+    const fatigueBase = parseInt(this.html.find('input[name="base-fatigue"]').val() ?? 0)
+    const actors = jQuery.map(
+      this.html.find('div.fatigue-actors-list li.list-item'),
+      it => this.$extractActor(this.html.find(it))
+    )
+    actors.filter(it => it.selected)
+    .forEach(async it => {
+        const perteFatigue = fatigueBase + it.ajustement
+        ChatMessage.create({
+          whisper: ChatUtility.getWhisperRecipientsAndGMs(it.actor.name),
+          content: await renderTemplate(
+            'systems/foundryvtt-reve-de-dragon/templates/voyage/chat-fatigue_voyage.hbs', mergeObject(it,
+              {
+                parameters: this.parameters,
+                fatigueBase: fatigueBase,
+                perteFatigue: perteFatigue,
+                isVoyage: fatigueBase == this.parameters.nombreHeures * this.parameters.fatigueHoraire
+              })
+          ),
+        })
+        await it.actor.santeIncDec("fatigue", perteFatigue)
+      })
+  }
+
+  $extractActor(actorRow) {
+    const actor = game.actors.get(actorRow.data('actor-id'))
+    if (!actor) {
+      ui.notifications.warn(`Acteur ${it.actorId} introuvable`)
+    }
+    return {
+      actor: actor,
+      ajustement: parseInt(actorRow.find('input[name="ajustement-fatigue"]').val() ?? 0),
+      selected: actor && actorRow.find('input[name="selectionner-acteur"]').is(':checked')
+    }
+  }
+
+  async close() {
+    DialogFatigueVoyage.dialog = undefined
+    await super.close()
+  }
+
+
+}
--- a/styles/simple.css
+++ b/styles/simple.css
@ -93,6 +93,7 @@
  --background-control-selected: linear-gradient(to bottom, hsla(0, 100%, 25%, 0.5) 5%, hsla(0, 100%, 12%, 0.5) 100%);
  --background-tooltip: hsla(60, 12%, 85%, 0.95);
  --background-error:hsla(16, 100%, 50%, 0.8);
+  --color-profile-border: hsla(0, 0%, 80%, 0.05);
 }

 /*@import url("https://fonts.googleapis.com/css2?family=Martel:wght@400;800&family=Roboto:wght@300;400;500&display=swap");*/
@ -195,11 +196,10 @@ i:is(.fas, .far, .fa-solid, .fa-regular, .fa-sharp ) {
  flex: 0 0 110px;
  height: 110px;
  width: 110px;
-  margin-right: 0.5rem;
-  object-fit: scale-down;
-  object-position: 50% 0;
-  margin: 0.1rem;
+  padding: 0.2rem;
  object-fit: contain;
+  background-color: var(--color-profile-border);
+  border: 1px solid var(--color-profile-border);
 }

 .system-foundryvtt-reve-de-dragon .rdd-item-sheet-tarot img.profile-img {
@ -440,7 +440,13 @@ table {border: 1px solid #7a7971;}
 .flex-grow-2 {
  flex-grow: 2;
 }
+.voyage-liste-survies {
+  max-width: 12rem;
+}
 /* Styles limited to foundryvtt-reve-de-dragon sheets */
+.texte-dans-liste {
+  text-align: left;
+}
 .equipement-nom {
  flex-grow : 4;
  margin: 0;
@ -788,6 +794,10 @@ input:is(.blessure-premiers_soins, .blessure-soins_complets) {
 .rdd-roll-dialog div.dialog-content input {
  font-size: 1rem;
 }
+.rdd-roll-dialog div.dialog-content input[type="checkbox"]{
+  width: 1rem;
+  vertical-align: sub;
+}
 .rdd-roll-part {
  align-items: center;
  border-radius: 6px; padding: 3px;
@ -959,12 +969,6 @@ section.sheet-body {
  padding: 0.25rem 0.5rem;
 }

-.sheet header.sheet-header :is(.profile-img, .profile-img-token) {
-  object-fit: scale-down;
-  object-position: 50% 0;
-  margin: 0.5rem 0 0.5rem  0.5rem;
-  padding: 0;
-}
 .sheet header.sheet-header h1 {
  flex: 3;
 }
@ -1170,7 +1174,7 @@ ul.chat-list li:nth-child(odd) {
  border-radius: 0.25rem;
  padding: 0.1rem;
  flex: 1 1 1.5rem;
-  display: flex !important;
+  display: flex;
  align-items: center !important;
 }

@ -1363,43 +1367,37 @@ table.table-nombres-astraux tr:hover {
  justify-content: flex-start;
  flex-direction: column;
  position: absolute;
-  top: 2.75rem;
-  right: 4rem;
+  top: 4.6rem;
+  right: 3.5rem;
 }
 .token-hud-ext.soins {
-  justify-content: flex-start;
  flex-direction: column;
  position: absolute;
-  top: 13.2rem;
-  left: -5rem;
-  max-width: 8.5rem
+  top: 14.7rem;
+  left: -6rem;
+  max-width: 8rem;
+  line-height: 1rem;
 }

 .token-hud-ext.right {
-  justify-content: flex-start;
  flex-direction: column;
  position: absolute;
-  top: 2.75rem;
-  left: 4rem;
+  top: 4.6rem;
+  left: 3.5rem;
 }
-.control-icon.token-hud-icon {
-  width: fit-content;
+div.control-icon.token-hud-icon {
+  width: 9rem;
  height: fit-content;
+  border-radius: 0.3rem;
  min-width: 6rem;
  flex-basis: auto;
  padding: 0;
-  line-height: 1rem;
+  line-height: 0.95rem;
  margin: 0.2rem;
 }
-.control-icon.token-hud-icon.right {
-  margin-left: 8px;
-}
 .rdd-hud-menu label {
  font-size: 0.8rem;
 }
-#token-hud .status-effects.active{
-  z-index: 2;
-}
 /* ======================================== */
 .item-checkbox {
  height: 25px;
@ -1941,6 +1939,14 @@ div.calendar-timestamp-edit select.calendar-signe-heure {
  padding: 3px;
 }

+aside#tooltip{
+  background: var(--background-tooltip);
+  color: var(--color-text-dark-primary);
+  font-size: 1rem;
+  border-radius: 0.2rem;
+  padding: 0.4rem;
+}
+
 .tooltip :is(.ttt-xp,.ttt-levelup) {
  width: 250px;
  background: var(--background-tooltip) !important;
--- a/system.json
+++ b/system.json
@ -1,8 +1,8 @@
 {
  "id": "foundryvtt-reve-de-dragon",
  "title": "Rêve de Dragon",
-  "version": "11.2.7",
-  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-11.2.7.zip",
+  "version": "11.2.16",
+  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-11.2.16.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": {
--- a/template.json
+++ b/template.json
@ -525,15 +525,11 @@
  },
  "Item": {
    "types": [
-        "competence", "competencecreature",
-        "recettealchimique", "musique", "chant", "danse", "jeu", "recettecuisine", "oeuvre",
-        "objet", "arme", "armure", "conteneur", "herbe", "plante", "ingredient", "faune", "livre", "potion", "munition",
-        "monnaie", "nourritureboisson", "gemme",
-        "service",
-        "meditation", "rencontre", "queue", "ombre", "souffle", "tete", "casetmr", "signedraconique", "sort", "sortreserve",
-        "nombreastral", "tache", "blessure", "maladie", "poison", "possession",
-        "tarot", "extraitpoetique", "empoignade"
-    ],
+        "arme", "armure", "blessure", "casetmr", "chant", "competence", "competencecreature", "conteneur", "danse", 
+        "empoignade", "extraitpoetique", "faune", "gemme", "herbe", "ingredient", "jeu", "livre", "maladie", "meditation",
+        "monnaie", "munition", "musique", "nombreastral", "nourritureboisson", "objet", "oeuvre", "ombre", "plante", "possession", 
+        "poison", "potion", "queue", "recettealchimique", "recettecuisine", "rencontre", 
+        "service" ,"signedraconique", "sort", "sortreserve", "souffle", "tarot", "tache", "tete" ],
    "templates": {
      "description": {
        "description": "",
--- a/templates/actor-sheet.html
+++ b/templates/actor-sheet.html
@ -70,9 +70,13 @@
            {{#if options.vueDetaillee}}
              &nbsp;&nbsp;
              {{#if @root.options.vueArchetype}}
-              <a class="competence-archetype toggle-archetype chat-card-button-pushed"><i class="fa-solid fa-up-right-from-square"></i>Incarnation</a>
+              <a class="competence-archetype toggle-archetype chat-card-button-pushed" data-tooltip="Retour à la vue détaillée des compétences">
+                <i class="fa-solid fa-up-right-from-square"></i>Incarnation
+              </a>
              {{else}}
-              <a class="competence-archetype toggle-archetype chat-card-button"><i class="fa-solid fa-people-line"></i>Archétype</a>
+              <a class="competence-archetype toggle-archetype chat-card-button" data-tooltip="Gestion de l'archétype et de la réincarnation">
+                <i class="fa-solid fa-people-line"></i>Archétype
+              </a>
              {{/if}}
            {{/if}}
          </span>
--- a/templates/actor-vehicule-sheet.html
+++ b/templates/actor-vehicule-sheet.html
@ -12,19 +12,19 @@
              <ul>
                <li data-attribute="resistance" class="flexrow">
                  <span class="carac-label">Résistance</span>
-                  <a class="resistance-moins"><i class="fas fa-minus-square"></i></a>
+                  <a class="resistance-moins"><i class="fa-solid fa-square-minus"></i></a>
                  <input type="text" name="system.etat.resistance.value" value="{{system.etat.resistance.value}}" data-dtype="Number" />
                  /
                  <input type="text" name="system.etat.resistance.max" value="{{system.etat.resistance.max}}" data-dtype="Number" {{#unless @root.options.vueDetaillee}}disabled{{/unless}} />
-                  <a class="resistance-plus"><i class="fas fa-plus-square"></i></a>
+                  <a class="resistance-plus"><i class="fa-solid fa-square-plus"></i></a>
                </li>
                <li data-attribute="structure" class="flexrow">
                  <span class="carac-label">Structure</span>
-                  <a class="structure-moins"><i class="fas fa-minus-square"></i></a>
+                  <a class="structure-moins"><i class="fa-solid fa-square-minus"></i></a>
                  <input type="text" name="system.etat.structure.value" value="{{system.etat.structure.value}}" data-dtype="Number" />
                  /
                  <input type="text" name="system.etat.structure.max" value="{{system.etat.structure.max}}" data-dtype="Number" {{#unless @root.options.vueDetaillee}}disabled{{/unless}} />
-                  <a class="structure-plus"><i class="fas fa-plus-square"></i></a>
+                  <a class="structure-plus"><i class="fa-solid fa-square-plus"></i></a>
                </li>
              </ul>
            </div>
--- a/templates/actor/archetype.hbs
+++ b/templates/actor/archetype.hbs
@ -2,7 +2,8 @@
  <ul class="item-list">
    {{#if @root.options.isGM}}
    <li>
-    <a class="nouvelle-incarnation chat-card-button"><i class="fa-solid fa-person-circle-plus"></i> Nouvelle incarnation</a>
+    <a class="nouvelle-incarnation chat-card-button" data-tooltip="Création d'une nouvelle incarnation de l'archétype">
+      <i class="fa-solid fa-person-circle-plus"></i> Nouvelle incarnation</a>
    </li>
    {{/if}}
    <li><hr></li>
--- a/templates/actor/astrologie.html
+++ b/templates/actor/astrologie.html
@ -1,2 +1,7 @@
 <h3>Astrologie</h3>
-<span class="astrologie-label"><a name="jet-astrologie">Astrologie : Nombres Astraux</a></span>
+<span class="astrologie-label chat-card-button">
+  <a name="jet-astrologie">
+    <i class="fa-solid fa-moon-over-sun"></i>
+    Astrologie: Nombres Astraux
+  </a>
+</span>
--- a/templates/actor/blessures.html
+++ b/templates/actor/blessures.html
@ -1,8 +1,14 @@
-<h4>blessures</h4>
+<h4>Blessures</h4>
 <div>
-  <a class="chat-card-button creer-blessure-legere" data-tooltip="Ajouter une blessure légère"><i class="fas fa-plus-circle"></i> légère</a>
-  <a class="chat-card-button creer-blessure-grave" data-tooltip="Ajouter une blessure grave"><i class="fas fa-plus-circle"></i> grave</a>
-  <a class="chat-card-button creer-blessure-critique" data-tooltip="Ajouter une blessure critque"><i class="fas fa-plus-circle"></i> critique</a>
+  <a class="chat-card-button creer-blessure-legere" data-tooltip="Ajouter une légère"><i class="fas fa-plus-circle"></i> légère</a>
+  <a class="chat-card-button creer-blessure-grave" data-tooltip="Ajouter une grave"><i class="fas fa-plus-circle"></i> grave</a>
+  <a class="chat-card-button creer-blessure-critique" data-tooltip="Ajouter une critique"><i class="fas fa-plus-circle"></i> critique</a>
+</div>
+<div>
+  <a class="chat-card-button subir-blessure-contusion" data-tooltip="Subir une contusion (avec perte d'Endurance)"><i class="fas fa-swords"></i> contusion</a>
+  <a class="chat-card-button subir-blessure-legere" data-tooltip="Subir une légère (avec perte d'Endurance)"><i class="fas fa-swords"></i> légère</a>
+  <a class="chat-card-button subir-blessure-grave" data-tooltip="Subir une grave (avec perte d'Endurance/Vie)"><i class="fas fa-swords"></i> grave</a>
+  <a class="chat-card-button subir-blessure-critique" data-tooltip="Subir une critique (avec perte d'Endurance/Vie)"><i class="fas fa-swords"></i> critique</a>
 </div>

 <ul class="item-list alterne-list">
--- a/templates/actor/commerce-inventaire-item.html
+++ b/templates/actor/commerce-inventaire-item.html
@ -17,13 +17,13 @@
  <span class="equipement-detail-buttons flexrow">
    {{#unless (or (eq item.type 'service') (and (eq item.type 'conteneur') (not vide)))}}
      {{#if options.isOwner}}
-      <a class="item-quantite-moins"><i class="fas fa-minus-square"></i></a>
+      <a class="item-quantite-moins"><i class="fa-solid fa-square-minus"></i></a>
      {{/if}}
      <input {{#unless options.isOwner}}disabled{{/unless}} type="number" data-dtype="Number" 
        class="item-quantite number-x3" name="items[{{item._id}}].system.quantite"
        value="{{item.system.quantite}}" />
      {{#if options.isOwner}}
-      <a class="item-quantite-plus"><i class="fas fa-plus-square"></i></a>
+      <a class="item-quantite-plus"><i class="fa-solid fa-square-plus"></i></a>
      {{/if}}
    {{/unless}}
  </span>
--- a/templates/actor/competence.html
+++ b/templates/actor/competence.html
@ -1,13 +1,13 @@
 {{#unless system.isHidden}}
-  <li class="item flexrow list-item {{#if system.isLevelUp}}xp-level-up tooltip{{/if}}" data-item-id="{{_id}}" data-tooltip="Niveau {{plusMoins system.niveau}} en {{name}}">
-    <a class="competence-label" name="{{name}}">
+  <li class="item flexrow list-item {{#if system.isLevelUp}}xp-level-up tooltip{{/if}}" data-item-id="{{_id}}">
+    <a class="competence-label" name="{{name}}" data-tooltip="Niveau {{plusMoins system.niveau}} en {{name}}">
      <img class="sheet-competence-img" src="{{img}}"/>
      <span>{{name}}</span>
    </a>

    {{#if system.isLevelUp}}
    <span class="tooltiptext ttt-levelup">Vous pouvez dépenser {{system.xpNext}} points d'Experience pour augmenter de 1 votre compétence {{name}}</span>
-    <a class="competence-xp-augmenter" compname="{{name}}" data-tooltip="Augmenter d'un niveau en {{name}}">
+    <a class="competence-xp-augmenter" compname="{{name}}">
      <i class="fas fa-arrow-alt-circle-up"></i>
    </a>
    {{/if}}
@ -19,7 +19,7 @@
    {{#if @root.options.vueDetaillee}}
    <span class="competence-xp {{#unless system.isLevelUp}}tooltip{{/unless}}">
      <input class="competence-xp " type="text" compname="{{name}}" name="comp-xp-{{name}}"
-          value="{{numberFormat system.xp decimals=0 sign=false}}" data-dtype="number" data-tooltip="Expérience {{system.xp}} en {{name}}"
+          value="{{numberFormat system.xp decimals=0 sign=false}}" data-dtype="number"
          {{#if (or (not @root.options.vueDetaillee) @root.options.vueArchetype)}}disabled{{/if}} />
      {{#unless system.isLevelUp}}
      <span class="tooltiptext left-competence ttt-xp">Vous devez acquérir {{system.xpNext}} points d'Experience pour augmenter de 1 votre compétence {{name}}</span>      
@ -28,7 +28,7 @@
    {{/if}}
    {{#if (eq system.categorie 'draconic')}}
    <input class="competence-xp-sort" type="text" compname="{{name}}" name="comp-xp-sort-{{name}}"
-          value="{{numberFormat system.xp_sort decimals=0 sign=false}}" data-dtype="number" data-tooltip="Expérience {{system.xp_sort}} en sorts de {{name}}"
+          value="{{numberFormat system.xp_sort decimals=0 sign=false}}" data-dtype="number"
          {{#if (or (not @root.options.vueDetaillee) @root.options.vueArchetype)}}disabled{{/if}} />
    {{/if}}
    {{#if @root.options.vueDetaillee}}
--- a/templates/actor/header-compteurs-creature.html
+++ b/templates/actor/header-compteurs-creature.html
@ -3,23 +3,23 @@
    <li data-attribute="vie">
      <label class="compteur">
        <a class="jet-vie" name="system.sante.vie.label" data-tooltip="Faire un jet de vie">Vie</a>
-        <a class="vie-moins"><i class="fas fa-minus-square"></i></a>
+        <a class="vie-moins"><i class="fa-solid fa-square-minus"></i></a>
        <input class="resource-content" type="text" name="system.sante.vie.value" value="{{system.sante.vie.value}}" data-dtype="Number" />
        / {{#if @root.options.vueDetaillee}}
        <input class="resource-content" type="text" name="system.sante.vie.max" value="{{system.sante.vie.max}}" data-dtype="Number"/>
        {{else}}{{system.sante.vie.max}}{{/if}}
-        <a class="vie-plus"><i class="fas fa-plus-square"></i></a>
+        <a class="vie-plus"><i class="fa-solid fa-square-plus"></i></a>
      </label>
    </li>
    <li data-attribute="endurance">
      <label class="compteur">
        <a class="jet-endurance" name="system.sante.endurance.label" data-tooltip="Faire un jet d'endurance pour ne pas être sonné">Endurance</a>
-        <a class="endurance-moins"><i class="fas fa-minus-square"></i></a>
+        <a class="endurance-moins"><i class="fa-solid fa-square-minus"></i></a>
        <input class="resource-content" type="text" name="system.sante.endurance.value" value="{{system.sante.endurance.value}}" data-dtype="Number"/>
        / {{#if @root.options.vueDetaillee}}
        <input class="resource-content" type="text" name="system.sante.endurance.max" value="{{system.sante.endurance.max}}" data-dtype="Number"/>
        {{else}}{{system.sante.endurance.max}}{{/if}}
-        <a class="endurance-plus"><i class="fas fa-plus-square"></i></a>
+        <a class="endurance-plus"><i class="fa-solid fa-square-plus"></i></a>
      </label>
    </li>
  </ul>
--- a/templates/actor/header-compteurs-entitee.html
+++ b/templates/actor/header-compteurs-entitee.html
@ -4,12 +4,12 @@
    <li data-attribute="endurance">
      <label class="compteur">
        Endurance
-        <a class="endurance-moins"><i class="fas fa-minus-square"></i></a>
+        <a class="endurance-moins"><i class="fa-solid fa-square-minus"></i></a>
        <input class="resource-content" type="text" name="system.sante.endurance.value" value="{{system.sante.endurance.value}}" data-dtype="Number" />
        / {{#if @root.options.vueDetaillee}}
        <input class="resource-content" type="text" name="system.sante.endurance.max" value="{{system.sante.endurance.max}}" data-dtype="Number"/>
        {{else}}{{system.sante.endurance.max}}{{/if}}
-        <a class="endurance-plus"><i class="fas fa-plus-square"></i></a>
+        <a class="endurance-plus"><i class="fa-solid fa-square-plus"></i></a>
      </label>
    </li>
  </ul>
--- a/templates/actor/header-compteurs.html
+++ b/templates/actor/header-compteurs.html
@ -3,38 +3,38 @@
    <li>
      <label class="compteur">
        <a class="jet-vie" data-tooltip="Faire un jet de vie">Vie</a>
-        <a class="vie-moins"><i class="fas fa-minus-square"></i></a>
+        <a class="vie-moins"><i class="fa-solid fa-square-minus"></i></a>
        <input class="resource-content" type="text" name="system.sante.vie.value" value="{{system.sante.vie.value}}" data-dtype="Number"/>
        <span>/ {{system.sante.vie.max}}</span>
-        <a class="vie-plus"><i class="fas fa-plus-square"></i></a>
+        <a class="vie-plus"><i class="fa-solid fa-square-plus"></i></a>
      </label>
    </li>
    <li>
      <label class="compteur">
        <a class="jet-endurance"  data-tooltip="Faire un jet d'endurance pour ne pas être sonné">Endurance</a>
-        <a class="endurance-moins"><i class="fas fa-minus-square"></i></a>
+        <a class="endurance-moins"><i class="fa-solid fa-square-minus"></i></a>
        <input class="resource-content" type="text" name="system.sante.endurance.value" value="{{system.sante.endurance.value}}" data-dtype="Number"/>
        <span>/ {{system.sante.endurance.max}}</span>
-        <a class="endurance-plus"><i class="fas fa-plus-square"></i></a>
+        <a class="endurance-plus"><i class="fa-solid fa-square-plus"></i></a>
      </label>
    </li>
    <li>
      <label class="appliquerFatigue compteur tooltip">
        <span class="tooltiptext ttt-fatigue">{{{calc.fatigue.html}}}</span>
        Fatigue ({{calc.fatigue.malus}})
-        <a class="fatigue-moins"><i class="fas fa-minus-square"></i></a>
+        <a class="fatigue-moins"><i class="fa-solid fa-square-minus"></i></a>
        <input class="resource-content" type="text" name="system.sante.fatigue.value" value="{{system.sante.fatigue.value}}" data-dtype="Number" />
        <span>/ {{system.sante.fatigue.max}}</span>
-        <a class="fatigue-plus"><i class="fas fa-plus-square"></i></a>
+        <a class="fatigue-plus"><i class="fa-solid fa-square-plus"></i></a>
      </label>
    </li>
    <li>
      <label class="compteur">
        <span class="ptreve-actuel"  data-tooltip="Faire un jet de Rêve actuel (ou jet de résistance)"><a>Rêve</a></span>
-        <a class="ptreve-actuel-moins"><i class="fas fa-minus-square"></i></a>
+        <a class="ptreve-actuel-moins"><i class="fa-solid fa-square-minus"></i></a>
        <input class="resource-content" class="pointsreve-value" type="text" name="system.reve.reve.value" value="{{system.reve.reve.value}}" data-dtype="Number" />
        <span>/ {{system.reve.seuil.value}}</span>
-        <a class="ptreve-actuel-plus"><i class="fas fa-plus-square"></i></a>
+        <a class="ptreve-actuel-plus"><i class="fa-solid fa-square-plus"></i></a>
      </label>
    </li>
  </ul>
--- a/templates/actor/header-effects.html
+++ b/templates/actor/header-effects.html
@ -1,7 +1,7 @@
 <div>
  {{#if effects}}
    {{#each effects as |effect key|}}
-    <span class="active-effect" data-effect="{{effect.flags.core.statusId}}">
+    <span class="active-effect" data-effect="{{effect.id}}">
      <img class="button-effect-img {{#if @root.options.isGM}}delete-active-effect{{/if}}" src="{{effect.icon}}" data-tooltip="{{localize effect.name}}" width="24" height="24" />
    </span>
    {{/each}}
--- a/templates/actor/inventaire-item.html
+++ b/templates/actor/inventaire-item.html
@ -22,7 +22,7 @@
  </span>
  <span class="equipement-detail">
    {{#if (gt item.system.quantite 1)}}
-    <a class="item-quantite-moins" data-tooltip="Diminuer la quantité de {{item.name}}"><i class="fas fa-minus-square"></i></a>
+    <a class="item-quantite-moins" data-tooltip="Diminuer la quantité de {{item.name}}"><i class="fa-solid fa-square-minus"></i></a>
    {{/if}}
    {{item.system.quantite}}
    {{#if (gt item.system.quantite 1)}}
--- a/templates/actor/inventaire-monnaie.html
+++ b/templates/actor/inventaire-monnaie.html
@ -10,7 +10,7 @@
    </span>
    {{#if @root.options.isOwner}}
    <span class="equipement-button item-controls">
-      <a class="item-quantite-moins"><i class="fas fa-minus-square"></i></a>
+      <a class="item-quantite-moins"><i class="fa-solid fa-square-minus"></i></a>
    </span>
    {{/if}}
    <span class="equipement-detail">
@ -18,7 +18,7 @@
    </span>
    {{#if @root.options.isOwner}}
    <span class="equipement-button item-controls">
-      <a class="item-quantite-plus"><i class="fas fa-plus-square"></i></a>
+      <a class="item-quantite-plus"><i class="fa-solid fa-square-plus"></i></a>
    </span>
    {{/if}}
    <span class="equipement-actions item-controls">
--- a/templates/chat-actor-gain-xp.html
+++ b/templates/chat-actor-gain-xp.html
@ -1,26 +1,29 @@
-<h4>{{alias}} a gagné de l'expérience en {{caracName}}{{#if competence}} / {{competence.name}}{{/if}}!</h4>
-{{#if (gt xpCarac 0)}}
-<hr>
-  {{xpCarac}} point{{#if (gt xpCarac 1)}}s{{/if}}
-  {{#if caracRepartitionManuelle}}à répartir manuellement dans la caractéristique dérivée{{else}}en{{/if}}
-  {{caracName}}.
-  {{#if checkCarac}}
-  L'expérience dans cette caractéristique est de {{checkCarac.xp}}, elle peut progresser!
-  <br>Vous devez ouvrir votre fiche de personnage et appliquer (ou pas) l'augmentation manuellement.
+<img class="chat-icon" src="{{actor.img}}" data-tooltip="{{actor.name}}" />
+<h4>{{actor.name}} a gagné de l'expérience</h4>
+{{#each xpData as |it|}}
+  {{#if (gt it.xpCarac 0)}}
+  <hr>
+    {{it.xpCarac}} point{{#if (gt it.xpCarac 1)}}s{{/if}}
+    {{#if it.caracRepartitionManuelle}}à répartir manuellement dans la caractéristique dérivée{{else}}en{{/if}}
+    {{it.caracName}}.
+    {{#if it.checkCarac}}
+      L'expérience dans cette caractéristique est de {{it.checkCarac.xp}}, elle peut progresser!
+      <br>Vous devez ouvrir votre fiche de personnage et appliquer l'augmentation manuellement.
+    {{/if}}
  {{/if}}
-{{/if}}
-
-{{#if (gt xpCompetence 0)}}
-<hr>
-  {{xpCompetence}} point{{#if (gt xpCompetence 1)}}s{{/if}} en {{competence.name}}.
-    {{#if checkComp}}
-    L'expérience dans cette compétence est de {{checkComp.xp}}, elle peut progresser jusqu'à {{checkComp.niveau}}!
-    Vous devez ouvrir votre fiche de personnage et appliquer l'augmentation manuellement.
-    {{#if (gt checkComp.niveau checkComp.archetype)}}<br>Le niveau d'archétype est de {{checkComp.archetype}}.
-    {{#if checkComp.archetypeWarning}}
-    <br><strong>ATTENTION !!</strong> Si vous appliquez cette augmentation, votre compétence dépassera l'archétype.
-    Veuillez contrôler que votre archétype est à jour, ou bien ne pas augmenter le niveau de cette compétence.
-    {{/if}}
-    {{/if}}
-    {{/if}}
-{{/if}}
+  {{#if (gt it.xpCompetence 0)}}
+  <hr>
+    {{it.xpCompetence}} point{{#if (gt it.xpCompetence 1)}}s{{/if}} en {{it.competence.name}}.
+      {{#if it.checkComp}}
+        L'expérience dans cette compétence est de {{it.checkComp.xp}}, elle peut progresser jusqu'à {{it.checkComp.niveau}}!
+        Vous devez ouvrir votre fiche de personnage et appliquer l'augmentation manuellement.
+        {{#if (gt it.checkComp.niveau it.checkComp.archetype)}}
+          <br>Le niveau d'archétype est de {{it.checkComp.archetype}}.
+          {{#if it.checkComp.archetypeWarning}}
+            <br><strong>ATTENTION !!</strong> Si vous appliquez cette augmentation, votre compétence dépassera l'archétype.
+            Veuillez contrôler que votre archétype est à jour, ou bien ne pas augmenter le niveau de cette compétence.
+          {{/if}}
+        {{/if}}
+      {{/if}}
+  {{/if}}
+{{/each}}
--- a/templates/chat-actor-turn-acteur.hbs
+++ b/templates/chat-actor-turn-acteur.hbs
@ -1 +1,2 @@
+<img class="chat-icon" src="{{actor.img}}" data-tooltip="{{actor.name}}" />
 <h4>C'est au tour de {{alias}} !</h4>
--- a/templates/chat-actor-turn-sante.hbs
+++ b/templates/chat-actor-turn-sante.hbs
@ -1,3 +1,4 @@
+<img class="chat-icon" src="{{actor.img}}" data-tooltip="{{actor.name}}" />
 <h4>Résumé de santé pour {{alias}}</h4>
 <div data-combatid="{{combatId}}" data-combatmessage="actor-turn-summary">{{blessuresStatus}}</div>
 <div>Son état général est de : {{etatGeneral}} {{#if isSonne}} et est <strong>sonné</strong>{{/if}}</div>
--- a/templates/chat-compendium-table-roll.html
+++ b/templates/chat-compendium-table-roll.html
@ -5,6 +5,11 @@
 <div>
  <img class="chat-icon" src="{{document.img}}" data-tooltip="{{document.name}}" />
  <p>{{linkCompendium document.pack document.id document.name}}</p>
+  {{#if document.system.formule}}
+  <div class="poesie-extrait">
+    [[/r {{document.system.formule}}]]
+  </div>
+  {{/if}}
  {{#if document.system.description}}
  <div class="poesie-extrait">
    {{{document.system.description}}}
--- a/templates/chat-infojet.html
+++ b/templates/chat-infojet.html
@ -9,7 +9,7 @@
        {{#if item.descr}}
        {{{item.descr}}}
        {{else}}
-        {{item.label}}: {{plusMoins item.value}}
+        {{{item.label}}}: {{plusMoins item.value}}
        {{/if}}
      </div>
      {{/if}}
--- a/templates/coeur/afficher-coeur.hbs
+++ b/templates/coeur/afficher-coeur.hbs
@ -1,4 +1,3 @@
-{{log 'C&oelig;ur' numero courant prochain}}
 <a data-numero-coeur="{{numero}}">
 {{#if (and (lte numero courant) (lte numero prochain))}}
    <i class="fa-solid fa-heart"></i>
--- a/templates/dialog-choix-xp-carac.hbs
+++ b/templates/dialog-choix-xp-carac.hbs
@ -0,0 +1,43 @@
+<form class="rdd-dialog-select">
+  <div>
+    <img class="chat-icon" src="{{actor.img}}" data-tooltip="{{actor.name}}" />
+    <label>Répartir l'expérience en {{caracDerivee.label}}</label>
+  </div>
+  <hr>
+  <span>
+    <label>Points à répartir:</label>
+    <input class="xpCarac-reste number-x2"
+      type="number" data-dtype="Number"
+      min="0" max="10" value="{{xpData.reste}}" disabled />
+    <label> sur {{xpData.xpCarac}}</label>
+  </span>
+  <ul class="flexcol item-list alterne-list">
+    <li class="competence-header flexrow">
+      <label class="flex-grow-2">Caractéristique</label>
+      <label>valeur</label>
+      <label>xp</label>
+      <span>ajout</span>
+    </li>
+    {{log 'choix-xp' @root}}
+    {{#each caracs as |carac key|}}
+
+    <li class="xpCarac-option item list-item flexrow" data-carac-label="{{carac.label}}">
+      <label class="flex-grow-2">{{carac.label}}</label>
+      <label>{{carac.value}}</label>
+
+      {{#if carac.isMax}}
+      <label>max</label>
+      <span class="flexrow">
+      </span>
+      {{else}}
+      <label>{{carac.xp}}</label>
+      <span class="flexrow">
+          <a class="xpCarac-moins"><i class="fa-solid fa-square-minus"></i></a>
+          <input class="xpCarac-view-ajout" value="{{carac.ajout}}" type="number" max="99" disabled/>
+          <a class="xpCarac-plus"><i class="fa-solid fa-square-plus"></i></a>
+      </span>
+      {{/if}}
+    </li>
+    {{/each}}
+  </ul>
+</form>
--- a/templates/dialog-chronologie.html
+++ b/templates/dialog-chronologie.html
@ -40,8 +40,8 @@
    </div>
    <div class="form-group">
      <label class="flex-shrink" for="information">Information
-        <a class="chronologie-preset-show"><i class="fas fa-plus-square"></i></a>
-        <a class="chronologie-preset-hide"><i class="fas fa-minus-square"></i></a>
+        <a class="chronologie-preset-show"><i class="fa-solid fa-square-plus"></i></a>
+        <a class="chronologie-preset-hide"><i class="fa-solid fa-square-minus"></i></a>
      </label>
      <textarea autocomplete="off" data-tooltip="Information" name="information" autofocus>{{information}}</textarea>
    </div>
--- a/templates/dialog-roll-carac.html
+++ b/templates/dialog-roll-carac.html
@ -6,9 +6,10 @@
      <div class="flexrow">
      </div>
      {{>"systems/foundryvtt-reve-de-dragon/templates/partial-roll-competences.html"}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/partial-roll-astrologique.hbs"}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/partial-roll-coeur.hbs"}}
      {{>"systems/foundryvtt-reve-de-dragon/templates/partial-roll-surenc.html"}}
      {{>"systems/foundryvtt-reve-de-dragon/templates/partial-roll-enctotal.html"}}
-      {{>"systems/foundryvtt-reve-de-dragon/templates/partial-roll-coeur.hbs"}}
    </div>
    <div class="flex-group-left">
      {{>"systems/foundryvtt-reve-de-dragon/templates/partial-roll-diffLibre.html"}}
--- a/templates/dialog-roll.html
+++ b/templates/dialog-roll.html
@ -8,9 +8,10 @@
        {{>"systems/foundryvtt-reve-de-dragon/templates/partial-select-carac.html"}}
      </div>
      {{>"systems/foundryvtt-reve-de-dragon/templates/partial-roll-competences.html"}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/partial-roll-astrologique.hbs"}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/partial-roll-coeur.hbs"}}
      {{>"systems/foundryvtt-reve-de-dragon/templates/partial-roll-surenc.html"}}
      {{>"systems/foundryvtt-reve-de-dragon/templates/partial-roll-enctotal.html"}}
-      {{>"systems/foundryvtt-reve-de-dragon/templates/partial-roll-coeur.hbs"}}
    </div>
    <div class="flex-group-left">
      {{>"systems/foundryvtt-reve-de-dragon/templates/partial-roll-diffLibre.html"}}
--- a/templates/hud-actor-attaque.html
+++ b/templates/hud-actor-attaque.html
@ -6,8 +6,8 @@
    <div class="control-icon token-hud-icon rdd-hud-menu rdd-attaque"
        data-combatant-id="{{../combatant.id}}"
        data-action-index="{{action.index}}"
-       data-tooltip="{{action.name}}">
-      <label>{{action.name}}  {{action.system.infoMain}}</label>
+        data-tooltip="Attaque: {{action.name}}">
+      <label><i class="fa-solid fa-sword"></i> {{action.name}} {{action.system.infoMain}}</label>
    </div>
    {{/unless}}
    {{/each}}
--- a/templates/hud-actor-init.html
+++ b/templates/hud-actor-init.html
@ -5,8 +5,8 @@
    <div class="control-icon token-hud-icon rdd-hud-menu"
        data-combatant-id="{{../combatant.id}}"
        data-action-index="{{action.index}}"
-       data-tooltip="{{action.name}}">
-      <label>init: {{action.name}} {{action.system.infoMain}}</label>
+        data-tooltip="Initiative {{action.name}}">
+      <label><i class="fa-solid fa-dice-d6"></i><span> {{action.name}} {{action.system.infoMain}}</span></label>
    </div>
    {{/each}}
    {{#each commandes as |commande key|}}
--- a/templates/hud-actor-soins.hbs
+++ b/templates/hud-actor-soins.hbs
@ -4,8 +4,14 @@
    {{#each blessures as |blessure|}}
      <div class="control-icon token-hud-icon rdd-hud-menu"
          data-blessure-id="{{blessure.id}}"
-         data-tooltip="{{blessure.name}}">
-        <label>Soigner: {{blessure.name}}</label>
+          data-tooltip="Jet de {{#if system.premierssoins.done}}Soins complets{{else}}Premiers soins{{/if}} sur blessure {{blessure.name}}">
+        <label>
+          {{#if system.premierssoins.done}}
+            <i class="fa-solid fa-user-nurse"></i> Soins complets blessure {{blessure.name}}
+          {{else}}
+            <i class="fa-solid fa-bandage"></i> Premiers soins blessure {{blessure.name}}
+          {{/if}}
+        </label>
      </div>
    {{/each}}
  </div>
--- a/templates/item-potion-sheet.html
+++ b/templates/item-potion-sheet.html
@ -57,7 +57,7 @@
        {{#if isRepos}}
        <div class="form-group">
          <label for="system.reposalchimique">Repos Alchimique ?</label>
-          <input class="attribute-value" type="checkbox" name="system.reposalchimique"  {{#if system.reposalchimique}}checked{{/if}}/>
+          <input class="attribute-value" type="checkbox" name="system.reposalchimique" {{#if system.reposalchimique}}checked{{/if}}/>
        </div>
        {{/if}}
        {{/if}}
@ -66,19 +66,22 @@
          <label for="system.pr">Points de rêve</label>
          <input class="attribute-value" type="text" name="system.pr" value="{{system.pr}}" data-dtype="Number" />
        </div>
+        {{#if isSoins}}
+        <div class="form-group">
+          <label>Points de guérison</label>
+          <input class="attribute-value" type="text" name="system.puissance" value="{{system.puissance}}" disabled />
+        </div>
+        {{/if}}
+        {{#if isRepos}}
+        <div class="form-group">
+          <label>Points de repos</label>
+          <input class="attribute-value" type="text" name="system.puissance" value="{{system.puissance}}" disabled />
+        </div>
+        {{/if}}
        <div class="form-group">
          <label for="system.prpermanent">Permanente ? </label>
          <input class="attribute-value" type="checkbox" name="system.prpermanent"  {{#if system.prpermanent}}checked{{/if}}/>
        </div>
-        {{#if (or isSoins isRepos)}}
-        <div class="form-group">
-          <label>Points de
-            {{#if isSoins}}guérison{{/if}}
-            {{#if isRepos}}repos{{/if}}
-            </label>
-            <label>{{system.puissance}}</label>
-          </div>
-        {{/if}}
        <div class="form-group">
          <label for="enchantement.jour">Date de l'Enchantement : Jour/Mois (date actuelle : {{dateActuelle}})</label>
        </div>
--- a/templates/partial-roll-ajustements.html
+++ b/templates/partial-roll-ajustements.html
@ -9,7 +9,7 @@
        {{#if item.descr}}
        {{{item.descr}}}
        {{else}}
-        {{item.label}}: {{plusMoins item.value}}
+        {{{item.label}}}: {{plusMoins item.value}}
        {{/if}}
      </div>
      {{/if}}
--- a/templates/partial-roll-astrologique.hbs
+++ b/templates/partial-roll-astrologique.hbs
@ -0,0 +1,6 @@
+<div class="flexrow use-astrologique">
+  <label>
+    Appliquer l'ajustement astrologique
+    <input class="attribute-value use-astrologique" type="checkbox" {{#if use.astrologique}}checked{{/if}}/>
+  </label>
+</div>
--- a/templates/voyage/chat-fatigue_voyage.hbs
+++ b/templates/voyage/chat-fatigue_voyage.hbs
@ -0,0 +1,10 @@
+<img class="chat-icon" src="{{actor.img}}" data-tooltip="{{actor.name}}" />
+<p>{{actor.name}} s'est fatigué de {{perteFatigue}}
+{{#if (and isVoyage (gt parameters.nombreHeures 0))}}
+après {{parameters.nombreHeures}} heure{{#if (gt parameters.nombreHeures 1)}}s{{/if}}
+de voyage {{lowerFirst parameters.typeTerrain.label}}
+à {{parameters.vitesseDeplacement}} km/h<sup>dr</sup> (Fatigue par heure: {{parameters.fatigueHoraire}})
+</p>
+<p>{{parameters.typeTerrain.description}}
+{{/if}}
+</p>
--- a/templates/voyage/dialog-fatigue-voyage.hbs
+++ b/templates/voyage/dialog-fatigue-voyage.hbs
@ -0,0 +1,58 @@
+<form class="dialog-fatigue-voyage">
+  <div class="flexcol">
+    <div class="flexrow">
+      <label for="code-terrain" class="flex-shrink">Type de terrain</label>
+      <div>
+      <select type="text" name="code-terrain" value="{{typeTerrain.code}}" data-dtype="String">
+        {{#select typeTerrain.code}}
+        {{#each tableauFatigueMarche as |ligne|}}
+        <option value="{{ligne.code}}">{{ligne.label}} - {{ligne.description}}</option>
+        {{/each}}
+        {{/select}}
+      </select>
+      </div>
+    </div>
+    <div class="flexrow">
+      <label for="vitesse-deplacement" class="flex-shrink">Vitesse de marche</label>
+      <div>
+      <select type="text" name="vitesse-deplacement" value="{{vitesseDeplacement}}" data-dtype="String">
+        {{#select vitesseDeplacement}}
+        {{#each typeTerrain.vitesses as |rythme|}}
+        {{> 'systems/foundryvtt-reve-de-dragon/templates/voyage/option-vitesse-fatigue.hbs' vitesse=rythme.vitesse fatigue=rythme.fatigue}}
+        {{/each}}
+        {{/select}}
+      </select>
+      </div>
+    </div>
+    <div class="flexrow">
+      <label for="nombre-heures" class="flex-shrink">Nombre d'heures</label>
+      <div>
+      <input type="number" name="nombre-heures" class="number-x2 nombre-heures" data-dtype="Number" value="{{nombreHeures}}" min="1" max="8"/> heures
+      </div>
+    </div>
+    <div class="flexrow">
+      <label for="base-fatigue" class="flex-shrink">Fatigue à appliquer</label>
+      <div>
+      <input type="number" name="base-fatigue" class="number-x2 base-fatigue" data-dtype="Number" value="{{nombreHeures}}" min="1" max="60"/>
+      </div>
+    </div>
+    <div><hr></div>
+    <div class="flexrow fatigue-actors-list">
+      <ul class="item-list alterne-list scrollable-list">
+        <li class="competence-header flexrow">
+          <span class="flex-grow-2">Personnage</span>
+          <span class="flex-grow-2">Survies</span>
+          <span class="flex-grow-1" data-tooltip="Ajustements à appliquer pour les personnages se reposant (par exemple, à cheval)">Ajustements</span>
+        </li>
+        {{#each playerActors as |selected|}}
+        {{>'systems/foundryvtt-reve-de-dragon/templates/voyage/fatigue-actor.hbs' voyageur=selected survies=@root.typeTerrain.survies}}
+        {{/each}}
+      </ul>
+    </div>
+    <hr>
+    <div class="flexrow">
+      <span class="flex-shrink"></span>
+      <button name="appliquer-fatigue">Appliquer la fatigue</button>
+    </div>
+  </div>
+</form>
--- a/templates/voyage/fatigue-actor.hbs
+++ b/templates/voyage/fatigue-actor.hbs
@ -0,0 +1,23 @@
+<li class="item flexrow list-item texte-dans-liste" data-actor-id="{{voyageur.actor.id}}">
+  <span class="flex-grow-2 flexrow">
+    <input type="checkbox" name="selectionner-acteur" {{#if voyageur.selected}}checked{{/if}}/>
+    <label>
+      <img class="chat-icon" src="{{voyageur.actor.img}}" data-tooltip="{{voyageur.actor.name}}" />
+      <span>{{voyageur.actor.name}}</span>
+    </label>
+  </span>
+  <span class="flex-grow-2">
+    <div class="flexcol ">
+      <label class="voyage-liste-survies">
+      {{#each voyageur.competencesVoyage as |comp key|}}
+      {{#if (array-includes ../survies key)}}
+        {{key}} {{comp.system.niveau}},
+      {{/if}}
+      {{/each}}
+      </label>
+    </div>
+  </span>
+  <span class="flex-grow-1">
+    <input type="number" name="ajustement-fatigue" class="number-x2 ajustement-fatigue" data-dtype="Number" value="{{voyageur.ajustementFatigue}}" min="-6" max="6"/>
+  </span>
+</li>
--- a/templates/voyage/option-vitesse-fatigue.hbs
+++ b/templates/voyage/option-vitesse-fatigue.hbs
@ -0,0 +1 @@
+<option value="{{vitesse}}">{{vitesse}} km/h<sup>dr</sup> (Fatigue: {{fatigue}})</option>
Author	SHA1	Message	Date
LeRatierBretonnien	dffaa29fd1	Fix termes dans les fenetres de creation	2024-02-29 21:22:42 +01:00
LeRatierBretonnien	c49e2a850b	Fix termes dans les fenetres de creation	2024-02-29 20:59:06 +01:00
LeRatierBretonnien	a5a9cc334e	Fix termes dans les fenetres de creation	2024-02-29 20:45:25 +01:00
LeRatierBretonnien	43e49a0eb8	New common CounterClass	2024-02-08 12:46:49 +01:00
LeRatierBretonnien	5ab551da9e	Rework usage log	2024-02-05 18:08:35 +01:00
LeRatierBretonnien	2a9e98f8c7	Ajout tirage de la force des rencontres avec /tmrr, ajout de bouton pour appliquer complètement les blessures	2024-01-30 23:18:21 +01:00
LeRatierBretonnien	669982ec4a	Ajout tirage de la force des rencontres avec /tmrr, ajout de bouton pour appliquer complètement les blessures	2024-01-28 20:43:23 +01:00
LeRatierBretonnien	34183cd1a7	Ajout tirage de la force des rencontres avec /tmrr, ajout de bouton pour appliquer complètement les blessures	2024-01-28 20:41:00 +01:00
LeRatierBretonnien	f7eae3ac1e	Fix version+changelog	2024-01-02 18:51:22 +01:00
LeRatierBretonnien	623044c936	Sync fiche	2024-01-02 18:43:42 +01:00
LeRatierBretonnien	94caf4040b	Affichage souffle	2023-12-30 14:20:05 +01:00
uberwald	d577e2d2ec	Merge pull request '11.2.13 - Les cent pas d'Akarlikarlikar' (#694 ) from VincentVk/foundryvtt-reve-de-dragon:v11 into v11 Reviewed-on: #694	2023-12-26 23:44:30 +01:00
Vincent Vandemeulebrouck	050cd80dae	Version 11.2.13	2023-12-26 19:07:36 +01:00
Vincent Vandemeulebrouck	3f098cab31	Commande /voyage Ajout de la commande /voyage pour gérer la fatigue en voyage	2023-12-26 19:06:13 +01:00
Vincent Vandemeulebrouck	4274bce7d5	minor cleanup	2023-12-26 19:06:13 +01:00
Vincent Vandemeulebrouck	25d68d265e	Image acteur dans les message de tours	2023-12-26 19:06:13 +01:00
uberwald	c1c192f710	Merge pull request '11.2.12 - Le somnifère d'Akarlikarlikar' (#693 ) from VincentVk/foundryvtt-reve-de-dragon:v11 into v11 Reviewed-on: #693	2023-12-24 12:42:15 +01:00
Vincent Vandemeulebrouck	7f64cd03f9	Version 11.2.12	2023-12-22 23:55:21 +01:00
Vincent Vandemeulebrouck	3ac9f487d0	Fix: perte de rêve potions enchantées La perte de rêve des potions enchantées bloquait le processus de récupération de château dormant	2023-12-22 20:12:58 +01:00
uberwald	fa67c3d9c1	Merge pull request 'Version 11.2.11' (#692 ) from VincentVk/foundryvtt-reve-de-dragon:v11 into v11 Reviewed-on: #692	2023-12-22 09:30:48 +01:00
Vincent Vandemeulebrouck	5b443f9ac0	Version 11.2.11	2023-12-22 02:25:30 +01:00
Vincent Vandemeulebrouck	b0098574a0	Fix: refoulement Le refoulement ne fonctionnait plus. Merci à javascript+VSCode pour l'incapacité de fournir de l'analyse de code statique...	2023-12-22 02:21:22 +01:00
Vincent Vandemeulebrouck	5729f7e926	Bordure des images de profils Remplacement de la bordure noire inesthétique avec des images de profil sous forme de badge ronds, en utilisant juste une variation de couleur de fond.	2023-12-22 02:21:22 +01:00
Vincent Vandemeulebrouck	0b66c945b8	Mise à jour couleur images compcreature Passage du blanc à la couleur habituelle	2023-12-22 02:21:22 +01:00
uberwald	f0fc44e00f	Merge pull request '11.2.10 - Les expériences d'Akarlikarlikar' (#691 ) from VincentVk/foundryvtt-reve-de-dragon:v11 into v11 Reviewed-on: #691	2023-12-11 09:34:21 +01:00
Vincent Vandemeulebrouck	6b7c2ad2f9	Version 11.2.10	2023-12-10 22:26:52 +01:00
Vincent Vandemeulebrouck	0ac5d317ce	Icônes des boutons cuisiner/manger	2023-12-10 22:19:51 +01:00
Vincent Vandemeulebrouck	f8a90fc3c3	Fontawsome solid traduction de fas => fa-solid	2023-12-10 22:19:51 +01:00
Vincent Vandemeulebrouck	6dd647b787	Expérience des caractéristiques dérivées Une fenêtre de répartition est ouverte quand plusieurs caractéristiques peuvent recevoir l'expérience. Sinon, l'expérience est attribuée automatiquement. L'expérience n'est plus ajoutée en Force si supérieure à Taille+4	2023-12-10 22:19:51 +01:00
Vincent Vandemeulebrouck	1c55491ac7	Ajustements des tooltips TMR	2023-12-10 22:19:50 +01:00
uberwald	2b08678518	Merge pull request 'Version 11.2.9 - La barbe d'Akarlikarlikar' (#690 ) from VincentVk/foundryvtt-reve-de-dragon:v11 into v11 Reviewed-on: #690	2023-12-09 16:23:41 +01:00
Vincent Vandemeulebrouck	355f2e4088	Version 11.2.9	2023-12-09 15:33:33 +01:00
Vincent Vandemeulebrouck	e0862105f9	Icône d'état empoignade	2023-12-09 15:33:33 +01:00
Vincent Vandemeulebrouck	3ab48511a0	Sort en réserve en fleuve Les sorts en réserve en fleuve sont indiqués sur toutes les cases fleuve	2023-12-09 15:33:33 +01:00
Vincent Vandemeulebrouck	05cd02b694	Fix: deprecation effects flags.core.statusId Remplacement de la logique basée sur les flags par le set de "statuses"	2023-12-09 15:33:33 +01:00
Vincent Vandemeulebrouck	56a5d06f16	Fix erreur console ouverture TMR quand TMR pas affichées, bringToTop ne marche pas	2023-12-09 15:33:32 +01:00
Vincent Vandemeulebrouck	f34db764cb	Permettre les jets de chance sans astrologie Quand on fait un jet de chance pour la journée, permettre de ne pas utiliser l'ajustement astrologique	2023-12-09 15:33:32 +01:00
Vincent Vandemeulebrouck	7267cd4096	Amélioration de tooltips - style en phase avec le système - icones attaque/d6/soins pour le HUD - tooltip plus détaillé pour le HUD - icône et bouton pour déterminer les chiffres astraux (astrologie) - tooltips pour les boutons archétype - suppression de log sur chaque point de coeur	2023-12-09 15:33:32 +01:00
uberwald	e4bd2d2f27	Merge pull request 'v11' (#689 ) from VincentVk/foundryvtt-reve-de-dragon:v11 into v11 Reviewed-on: #689	2023-12-08 13:24:05 +01:00
Vincent Vandemeulebrouck	eb09714579	Version 11.2.8	2023-12-08 04:03:53 +01:00
Vincent Vandemeulebrouck	62cc3fc96b	Correction de l'ajustement de luminosité On passe de la nuit début vaisseau au jour fin vaisseau	2023-12-08 04:00:17 +01:00
Vincent Vandemeulebrouck	5e140546ea	Les tooltips de compétences et l'expérience Limitation du tooltip sur les compétences qui masquait les informations d'expérience	2023-12-08 03:07:27 +01:00
Vincent Vandemeulebrouck	ab9a21f402	Utilisation de get plutôt que find par id	2023-12-08 02:38:57 +01:00
Vincent Vandemeulebrouck	8e41250f64	Affichage de cœur dans les ajustements	2023-12-08 02:38:23 +01:00
Vincent Vandemeulebrouck	095eed9da3	Fix: éliminer le risque de jets qui plante Bloquait les rencontres en TMR. Quand un rollData ne contient pas les sous-noeuds pouvant être utilisés par les ajustements possibles, le jet de dés était perdu. Le calcul d'ajustements ajoute maintenant les noeuds use/ajustements s'ils ne sont pas fournis, pour éviter le risque.	2023-12-08 02:37:47 +01:00
				`@ -0,0 +1 @@`
				`<option value="{{vitesse}}">{{vitesse}} km/h<sup>dr</sup> (Fatigue: {{fatigue}})</option>`