Foundry v11/v12 support

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

changelog.md

@@ -1,4 +1,19 @@
 # 11.2
+## 11.2.21 - Le questionnement d'Akarlikarlikar
+- Une confirmation spécifique est demandée pour monter dans les terres médianes en cas de rencontre en attente
+- L'expérience en caractéristique sur les jets de chance et rêve actuels est mise dans la caractéristique correspondante
+- Les effets s'appliquent correctement sur les créatures
+- La date et l'heure (draconiques) sont affichées dans les messages du tchat
+
+## 11.2.20 - Le soulagement d'Akarlikarlikar
+- L'option "ajout de la difficulté d'attaque à l'encaissement" est affichée comme un modificateur d'encaissement
+- Les options d'encaissement alternatives fonctionnent avec la validation de l'encaissement par le gardien
+- La fenêtre d'astrologie du gardien affiche toutes les heures lues par un personnage
+- Si aucune expérience n'est gagnée, les autres effets à appliquer (comme la récupération de seuil après avoir vaincu un rêve de Dragon) s'appliquent normalement
+- Les tooltips de Foundry sont lisibles
+- On n'accorde plus les entités de cauchemar deux fois quand le gardien valide les encaissements
+- Les messages de récupération de rêve en cas de Rêve de Dragon sont clarifiés
+
 ## 11.2.19 - Les hémorroïdes d'Akarlikarlikar
 - La validation des jets d'encaissement par le Gardien fonctionne de nouveau
 

module/actor-sheet.js

@@ -16,7 +16,6 @@ import { RdDItem } from "./item.js";
 import { RdDItemBlessure } from "./item/blessure.js";
 import { RdDEmpoignade } from "./rdd-empoignade.js";
 import { RdDBaseActorSangSheet } from "./actor/base-actor-sang-sheet.js";
-import { ChatUtility } from "./chat-utility.js";
 import { RdDCoeur } from "./coeur/rdd-coeur.js";
 
 /* -------------------------------------------- */
@@ -43,7 +42,6 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
       {
         editable: this.isEditable,
         cssClass: this.isEditable ? "editable" : "locked",
-        effects: this.actor.effects.map(e => foundry.utils.deepClone(e)),
         limited: this.actor.limited,
         owner: this.actor.isOwner,
         biographie: await TextEditor.enrichHTML(this.actor.system.biographie, { async: true }),

module/actor.js

@@ -347,7 +347,7 @@ export class RdDActor extends RdDBaseActorSang {
     const timestamp = game.system.rdd.calendrier.getTimestamp()
     const blessures = this.filterItems(it => it.system.gravite > 0, TYPES.blessure).sort(Misc.ascending(it => it.system.gravite))
 
-    await Promise.all(blessures.map(b => b.recuperationBlessure({
+    await Promise.all(blessures.map(async b => b.recuperationBlessure({
       actor: this,
       timestamp,
       message,
@@ -429,7 +429,7 @@ export class RdDActor extends RdDBaseActorSang {
       let jetsReve = [];
       let dormi = await this.dormirDesHeures(jetsReve, message, heures, options);
       if (jetsReve.length > 0) {
-        message.content += `Vous récupérez ${jetsReve.map(it => it < 0 ? '(dragon)' : it).reduce(Misc.joining("+"))} Points de rêve. `;
+        message.content += `Vous récupérez ${jetsReve.map(it => it < 0 ? '0 (réveil)' : it).reduce(Misc.joining("+"))} Points de rêve. `;
       }
       if (dormi.etat == 'eveil') {
         await this.reveilReveDeDragon(message, dormi.heures);
@@ -450,7 +450,6 @@ export class RdDActor extends RdDBaseActorSang {
   }
 
   async reveilReveDeDragon(message, heures) {
-    message.content += 'Vous êtes réveillé par un Rêve de Dragon.';
     const restant = Math.max(this.system.sommeil?.heures - heures, 0)
     if (restant > 0) {
       await this.update({ 'system.sommeil': { heures: restant } });
@@ -992,25 +991,33 @@ export class RdDActor extends RdDBaseActorSang {
 
   /* -------------------------------------------- */
   buildTMRInnaccessible() {
-    const tmrInnaccessibles = this.filterItems(it => Draconique.isCaseTMR(it) &&
-      EffetsDraconiques.isInnaccessible(it));
-    return tmrInnaccessibles.map(it => it.system.coord);
+    return this.items[TYPES.casetmr]
+      .filter(it => EffetsDraconiques.isInnaccessible(it))
+      .map(it => it.system.coord)
   }
 
   /* -------------------------------------------- */
-  getTMRRencontres() {
-    return this.itemTypes['rencontre'];
+  getRencontresTMR() {
+    return this.itemTypes[TYPES.rencontre];
   }
 
   /* -------------------------------------------- */
-  async deleteTMRRencontreAtPosition() {
-    const demiReve = this.getDemiReve()
-    let rencontreIds = this.items.filter(it => it.type == 'rencontre' && it.system.coord == demiReve).map(it => it.id);
+  async deleteRencontreTMRAtPosition() {
+    const rencontreIds = this.itemTypes[TYPES.rencontre].filter(this.filterRencontreTMRDemiReve()).map(it => it.id)
     if (rencontreIds.length > 0) {
-      await this.deleteEmbeddedDocuments('Item', rencontreIds);
+      await this.deleteEmbeddedDocuments('Item', rencontreIds)
     }
   }
 
+  getRencontreTMREnAttente() {
+    return this.itemTypes[TYPES.rencontre].find(this.filterRencontreTMRDemiReve())
+  }
+
+  filterRencontreTMRDemiReve() {
+    const position = this.getDemiReve()
+    return it => it.system.coord == position
+  }
+
   /* -------------------------------------------- */
   async addTMRRencontre(currentRencontre) {
     const toCreate = currentRencontre.toObject();
@@ -1142,6 +1149,7 @@ export class RdDActor extends RdDBaseActorSang {
       finalLevel: 0,
       diffConditions: 0,
       ajustementsForce: CONFIG.RDD.difficultesLibres,
+      config: game.system.rdd.config
     }
     let html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/dialog-roll-ethylisme.html', rollData);
     new RdDRollDialogEthylisme(html, rollData, this, r => this.saouler(r.forceAlcool)).render(true);
@@ -1333,7 +1341,7 @@ export class RdDActor extends RdDBaseActorSang {
     }
 
     await RdDResolutionTable.rollData(ethylismeData.jetVie);
-    this._appliquerExperienceRollData(ethylismeData.jetVie);
+    this._gererExperience(ethylismeData.jetVie);
     RollDataAjustements.calcul(ethylismeData.jetVie, this);
     if (ethylismeData.jetVie.rolled.isSuccess) {
       ethylisme.nb_doses++;
@@ -1365,7 +1373,7 @@ export class RdDActor extends RdDBaseActorSang {
           finalLevel: Number(ethylisme.value) + Number(this.system.compteurs.moral.value)
         }
         await RdDResolutionTable.rollData(ethylismeData.jetVolonte);
-        this._appliquerExperienceRollData(ethylismeData.jetVolonte);
+        this._gererExperience(ethylismeData.jetVolonte);
         RollDataAjustements.calcul(ethylismeData.jetVolonte, this);
       }
     }
@@ -1549,7 +1557,7 @@ export class RdDActor extends RdDBaseActorSang {
       const content = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-actor-gain-xp.html`, {
         actor: this,
         xpData
-      });
+      })
       if (hideChatMessage) {
         ChatUtility.blindMessageToGM({ content: content });
       }
@@ -1779,13 +1787,13 @@ export class RdDActor extends RdDBaseActorSang {
     };
     RollDataAjustements.calcul(rollData, this);
     await RdDResolutionTable.rollData(rollData);
-    this._appliquerExperienceRollData(rollData);
+    this._gererExperience(rollData);
     await RdDResolutionTable.displayRollData(rollData, this)
     return rollData.rolled;
   }
 
   /* -------------------------------------------- */
-  _appliquerExperienceRollData(rollData) {
+  _gererExperience(rollData) {
     const callback = this.createCallbackExperience();
     if (callback.condition(rollData)) {
       callback.action(rollData);
@@ -2269,7 +2277,7 @@ export class RdDActor extends RdDBaseActorSang {
   async _appliquerExperience(rolled, caracName, competence, jetResistance) {
     // Pas d'XP
     if (!rolled.isPart || rolled.finalLevel >= 0) {
-      return undefined;
+      return []
     }
     if (this.checkDesirLancinant()) {
       // Cas de désir lancinant, pas d'expérience sur particulière
@@ -2277,7 +2285,7 @@ export class RdDActor extends RdDBaseActorSang {
         content: `Vous souffrez au moins d'un Désir Lancinant, vous ne pouvez pas gagner d'expérience sur une Particulière tant que le désir n'est pas assouvi`,
         whisper: ChatMessage.getWhisperRecipients(this.name)
       });
-      return undefined;
+      return []
     }
 
     let xp = Math.abs(rolled.finalLevel);
@@ -2354,6 +2362,8 @@ export class RdDActor extends RdDBaseActorSang {
 
   static _getComposantsCaracDerivee(caracName) {
     switch (Grammar.toLowerCaseNoAccent(caracName)) {
+      case 'reve-actuel': case 'reve actuel': return ['reve']
+      case 'chance-actuelle': case 'chance actuelle': return ['chance']
       case 'vie': return ['constitution']
       case 'tir': return ['vue', 'dexterite']
       case 'lancer': return ['force', 'dexterite', 'vue']
@@ -2365,26 +2375,25 @@ export class RdDActor extends RdDBaseActorSang {
 
 
   /* -------------------------------------------- */
-  async resetNombresAstraux() {
+  async deleteNombresAstraux() {
     const deletions = this.itemTypes['nombreastral'].map(it => it._id);
     await this.deleteEmbeddedDocuments("Item", deletions);
   }
 
   /* -------------------------------------------- */
-  async ajouteNombreAstral(callData) {
-    const indexDate = Number.parseInt(callData.date);
+  async ajouteNombreAstral(date, nbAstral, isValid) {
+    const indexDate = Number.parseInt(date);
     // Ajout du nombre astral
     const item = {
       name: "Nombre Astral", type: "nombreastral", system:
       {
-        value: callData.nbAstral,
-        istrue: callData.isvalid,
+        value: nbAstral,
+        istrue: isValid,
         jourindex: indexDate,
         jourlabel: RdDTimestamp.formatIndexDate(indexDate)
       }
     };
     await this.createEmbeddedDocuments("Item", [item]);
-    game.system.rdd.calendrier.notifyChangeNombresAstraux();
   }
 
   async supprimerAnciensNombresAstraux() {
@@ -2425,22 +2434,29 @@ export class RdDActor extends RdDBaseActorSang {
   /* -------------------------------------------- */
   async displayTMR(mode = "normal") {
     if (this.tmrApp) {
-      ui.notifications.warn("Vous êtes déja dans les TMR....");
-      this.tmrApp.forceTMRDisplay();
+      ui.notifications.warn("Vous êtes déja dans les TMR....")
+      this.tmrApp.forceTMRDisplay()
       return
     }
     if (mode != 'visu' && this.getEffect(STATUSES.StatusDemiReve)) {
-      ui.notifications.warn("Le joueur ou le MJ est déja dans les Terres Médianes avec ce personnage ! Visualisation uniquement");
+      ui.notifications.warn("Les personnage est déjà dans les Terres Médianes, elles s'affichent en visualisation")
       mode = "visu"; // bascule le mode en visu automatiquement
     }
-    RdDConfirm.confirmer({
-      bypass: mode == 'visu',
-      settingConfirmer: "confirmation-tmr",
-      content: `<p>Voulez vous monter dans les TMR en mode ${mode}?</p>`,
-      title: 'Confirmer la montée dans les TMR',
-      buttonLabel: 'Monter dans les TMR',
-      onAction: async () => await this._doDisplayTMR(mode)
-    });
+    if (mode == 'visu') {
+      await this._doDisplayTMR(mode)
+    }
+    else {
+      const rencontre = this.getRencontreTMREnAttente();
+      const settingConfirmer = rencontre ? "confirmation-tmr-rencontre" : "confirmation-tmr";
+      const messageRencontre = rencontre ? `<p>Vous devrez combattre ${rencontre.system.genre == 'f' ? 'la' : 'le'} ${rencontre.name} de ${rencontre.system.force} points de Rêve</p>` : '';
+      RdDConfirm.confirmer({
+        settingConfirmer: settingConfirmer,
+        content: `<p>Voulez vous monter dans les TMR en mode ${mode}?</p>` + messageRencontre,
+        title: 'Confirmer la montée dans les TMR',
+        buttonLabel: 'Monter dans les TMR',
+        onAction: async () => await this._doDisplayTMR(mode)
+      })
+    }
   }
 
   async _doDisplayTMR(mode) {
@@ -2969,9 +2985,6 @@ export class RdDActor extends RdDBaseActorSang {
     }
   }
 
-  /* -------------------------------------------- */
-  isEffectAllowed(effectId) { return true }
-
   /* -------------------------------------------- */
   async onPreUpdateItem(item, change, options, id) {
     if (item.isCompetencePersonnage() && item.system.defaut_carac && item.system.xp) {

module/actor/base-actor-reve.js

@@ -180,7 +180,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
   }
 
   /* -------------------------------------------- */
-  isEffectAllowed(effectId) { return true }
+  isEffectAllowed(effectId) { return false }
 
   getEffects(filter = e => true) {
     return this.getEmbeddedCollection("ActiveEffect").filter(filter);
@@ -421,36 +421,35 @@ export class RdDBaseActorReve extends RdDBaseActor {
   /* -------------------------------------------- */
   async encaisser() { await RdDEncaisser.encaisser(this) }
 
-  async encaisserDommagesRemote(rollData, attackerId, show) {
-    const attacker = game.actors.get(attackerId);
-    await this.encaisserDommages(rollData, attacker, show)
-  }
   async encaisserDommages(rollData, attacker = undefined, show = undefined) {
     if (attacker && !await attacker.accorder(this, 'avant-encaissement')) {
       return;
     }
-    const attackerId = attacker?.id;
-    if (ReglesOptionnelles.isUsing('validation-encaissement-gr') && !game.user.isGM) {
-      RdDBaseActor.remoteActorCall({
-        tokenId: this.token?.id,
-        actorId: this.id,
-        method: 'encaisserDommagesRemote',
-        args: [rollData, attackerId, show]
-      });
-      return;
-    }
-
     const armure = await this.computeArmure(rollData);
-    if (ReglesOptionnelles.isUsing('validation-encaissement-gr')) {
-      DialogValidationEncaissement.validerEncaissement(this, rollData, armure,
-        jet => this.$onEncaissement(jet, show, attacker));
-    }
+    if (ReglesOptionnelles.isUsing('validation-encaissement-gr')){
+      await this.encaisserDommagesValidationGR(rollData, armure, attacker?.id, show);
+    } 
     else {
       const jet = await RdDUtility.jetEncaissement(rollData, armure, { showDice: SHOW_DICE });
       await this.$onEncaissement(jet, show, attacker);
     }
   }
 
+  async encaisserDommagesValidationGR(rollData, armure, attackerId, show) {
+    if (!game.user.isGM) {
+      RdDBaseActor.remoteActorCall({
+        tokenId: this.token?.id,
+        actorId: this.id,
+        method: 'encaisserDommagesValidationGR',
+        args: [rollData, armure, attackerId, show]
+      });
+    } else {
+      const attacker = game.actors.get(attackerId);
+      DialogValidationEncaissement.validerEncaissement(this, rollData, armure,
+        jet => this.$onEncaissement(jet, show, attacker));
+    }
+  }
+
   async $onEncaissement(jet, show, attacker) {
     await this.onAppliquerJetEncaissement(jet, attacker);
     await this.$afficherEncaissement(jet, show);

module/actor/base-actor-sang.js

@@ -269,6 +269,8 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
     return this.getEffect(STATUSES.StatusStunned);
   }
 
+  isEffectAllowed(effectId) { return true }
+
   /* -------------------------------------------- */
   async computeEtatGeneral() { this.system.compteurs.etat.value = this.malusVie() + this.malusFatigue() + this.malusEthylisme() }
   getEtatGeneral(options = { ethylisme: false }) { return this.system.compteurs.etat.value }

module/actor/base-actor-sheet.js

@@ -37,7 +37,9 @@ export class RdDBaseActorSheet extends ActorSheet {
       system: this.actor.system,
       description: await TextEditor.enrichHTML(this.actor.system.description, { async: true }),
       notesmj: await TextEditor.enrichHTML(this.actor.system.notesmj, { async: true }),
-      options: RdDSheetUtility.mergeDocumentRights(this.options, this.actor, this.isEditable)
+      options: RdDSheetUtility.mergeDocumentRights(this.options, this.actor, this.isEditable),
+      effects: this.actor.effects,
+      config: game.system.rdd.config
     }
 
     RdDBaseActorSheet.filterItemsPerTypeForSheet(formData, this.actor.itemTypes);

module/actor/base-actor.js

@@ -8,7 +8,6 @@ import { RdDAudio } from "../rdd-audio.js";
 import { RdDConfirm } from "../rdd-confirm.js";
 import { RdDUtility } from "../rdd-utility.js";
 import { SystemCompendiums } from "../settings/system-compendiums.js";
-import { APP_ASTROLOGIE_REFRESH } from "../sommeil/app-astrologie.js";
 
 export class RdDBaseActor extends Actor {
 
@@ -16,7 +15,7 @@ export class RdDBaseActor extends Actor {
     return Object.entries(carac)
       .filter(it => Grammar.equalsInsensitive(it[1].label, name))
       .map(it => it[0])
-      .find(it => it);
+      .find(it => it)
   }
   static $findCaracByName(carac, name) {
     const caracList = Object.entries(carac);
@@ -42,13 +41,6 @@ export class RdDBaseActor extends Actor {
     switch (sockmsg.msg) {
       case "msg_remote_actor_call":
         return RdDBaseActor.onRemoteActorCall(sockmsg.data, sockmsg.userId);
-      case "msg_reset_nombre_astral":
-        game.user.character.resetNombresAstraux();
-        game.system.rdd.calendrier.notifyChangeNombresAstraux();
-        return;
-      case "msg_refresh_nombre_astral":
-        Hooks.callAll(APP_ASTROLOGIE_REFRESH);
-        return;
     }
   }
 

module/actor/creature.js

@@ -33,10 +33,6 @@ export class RdDCreature extends RdDBaseActorSang {
     }
   }
 
-  isEffectAllowed(effectId) {
-    return [STATUSES.StatusComma].includes(effectId);
-  }
-
   isEntiteAccordee(attacker) {
     if (this.isEntite([ENTITE_INCARNE])) {
       let resonnance = this.system.sante.resonnance

module/chat-utility.js

@@ -1,5 +1,6 @@
 import { Misc } from "./misc.js";
 import { SYSTEM_RDD, SYSTEM_SOCKET_ID } from "./constants.js";
+import { RdDTimestamp } from "./time/rdd-timestamp.js";
 
 
 /**
@@ -163,4 +164,17 @@ export class ChatUtility {
     return game.messages.get(chatMessageId);
   }
 
+  static async onRenderChatMessage(chatMessage, html, data) {
+    const rddTimestamp = chatMessage.getFlag(SYSTEM_RDD, 'rdd-timestamp')
+    if (rddTimestamp) {
+      const timestamp = new RdDTimestamp(rddTimestamp);
+      const timestampData = timestamp.toCalendrier();
+      const dateHeure = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/common/date-heure.hbs', timestampData);
+      html.find('header.message-header .message-sender').after(dateHeure)
+    }
+  }
+
+  static async onCreateChatMessage(chatMessage, options, id) {
+    await chatMessage.setFlag(SYSTEM_RDD, 'rdd-timestamp', game.system.rdd.calendrier.getTimestamp());
+  }
 }

module/constants.js

@@ -8,3 +8,26 @@ export const SHOW_DICE = 'show';
 export const ENTITE_INCARNE = 'incarne';
 export const ENTITE_NONINCARNE = 'nonincarne';
 export const ENTITE_BLURETTE = 'blurette';
+
+export const RDD_CONFIG = {
+  niveauEthylisme : [
+    {value: "1", label: "Aucun"},
+    {value: "0", label: "Eméché (0)"},
+    {value: "-1", label: "Gris (-1)"},
+    {value: "-2", label: "Pinté (-2)"},
+    {value: "-3", label: "Pas Frais (-3)"},
+    {value: "-4", label: "Ivre (-4)"},
+    {value: "-5", label: "Bu (-5)"},
+    {value: "-6", label: "Complètement fait (-6)"},
+    {value: "-7", label: "Ivre mort (-7)"}
+  ],
+  categorieEntite: {
+    "cauchemar": "Cauchemar",
+    "reve": "Rêve"
+  },
+  typeEntite: {
+    "incarne": "Incarnée",
+    "nonincarne": "Non Incarnée",
+    "blurette": "Blurette"
+  }
+}

module/item.js

@@ -177,7 +177,7 @@ export class RdDItem extends Item {
 
   constructor(docData, context = {}) {
     if (!context.rdd?.ready) {
-      mergeObject(context, { rdd: { ready: true } });
+      foundry.utils.mergeObject(context, { rdd: { ready: true } });
       const ItemConstructor = game.system.rdd.itemClasses[docData.type];
       if (ItemConstructor) {
         if (!docData.img) {

module/migrations.js

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

module/rdd-confirm.js

@@ -4,29 +4,23 @@ import { ReglesOptionnelles } from "./settings/regles-optionnelles.js";
 export class RdDConfirm {
   /* -------------------------------------------- */
   static confirmer(options, autresActions) {
-    options.bypass = options.bypass || !(options.settingConfirmer == undefined || ReglesOptionnelles.isUsing(options.settingConfirmer));
-    if (options.bypass) {
-      options.onAction();
+    let buttons = {
+      "action": RdDConfirm._createButtonAction(options),
+      "cancel": RdDConfirm._createButtonCancel()
+    };
+    if (options.settingConfirmer) {
+      buttons = foundry.utils.mergeObject(RdDConfirm._createButtonActionSave(options), buttons);
     }
-    else {
-      let buttons = {
-        "action": RdDConfirm._createButtonAction(options),
-        "cancel": RdDConfirm._createButtonCancel()
-      };
-      if (options.settingConfirmer) {
-        buttons = foundry.utils.mergeObject(RdDConfirm._createButtonActionSave(options), buttons);
-      }
-      if (autresActions) {
-        buttons = foundry.utils.mergeObject(autresActions, buttons);
-      }
-      const dialogDetails = {
-        title: options.title,
-        content: options.content,
-        default: "cancel",
-        buttons: buttons
-      };
-      new Dialog(dialogDetails, { width: 150 * Object.keys(buttons).length }).render(true);
+    if (autresActions) {
+      buttons = foundry.utils.mergeObject(autresActions, buttons);
     }
+    const dialogDetails = {
+      title: options.title,
+      content: options.content,
+      default: "cancel",
+      buttons: buttons
+    };
+    new Dialog(dialogDetails, { width: 150 * Object.keys(buttons).length }).render(true);
   }
 
   static _createButtonCancel() {

module/rdd-main.js

@@ -1,4 +1,4 @@
-import { SYSTEM_RDD, SYSTEM_SOCKET_ID } from "./constants.js";
+import { SYSTEM_RDD, SYSTEM_SOCKET_ID, RDD_CONFIG } from "./constants.js";
 import { Migrations } from './migrations.js';
 
 import { RdDUtility } from "./rdd-utility.js";
@@ -108,7 +108,8 @@ export class SystemReveDeDragon {
   /* -------------------------------------------- */
   async onInit() {
     game.system.rdd = this;
-    this.AppAstrologie = AppAstrologie;
+    game.system.rdd.config = RDD_CONFIG; 
+    this.AppAstrologie = AppAstrologie;    
 
 
     console.log(`Initializing Reve de Dragon System`);

module/rdd-tmr-dialog.js

@@ -212,7 +212,7 @@ export class RdDTMRDialog extends Dialog {
 
   /* -------------------------------------------- */
   loadRencontres() {
-    this.rencontresExistantes = this.actor.getTMRRencontres();
+    this.rencontresExistantes = this.actor.getRencontresTMR();
   }
 
   /* -------------------------------------------- */
@@ -382,7 +382,7 @@ export class RdDTMRDialog extends Dialog {
   async refouler() {
     console.log("-> refouler", this.currentRencontre);
     await this.actor.ajouterRefoulement(this.currentRencontre.system.refoulement, `${this.currentRencontre.system.genre == 'f' ? 'une' : 'un'} ${this.currentRencontre.name}`);
-    await this.actor.deleteTMRRencontreAtPosition(); // Remove the stored rencontre if necessary
+    await this.actor.deleteRencontreTMRAtPosition()
     this.updateTokens();
     this.updateValuesDisplay();
     this.nettoyerRencontre();
@@ -392,7 +392,7 @@ export class RdDTMRDialog extends Dialog {
   async ignorerRencontre() {
     console.log("-> ignorer", this.currentRencontre);
     this._tellToGM(this.actor.name + " a ignoré: " + this.currentRencontre.name);
-    await this.actor.deleteTMRRencontreAtPosition(); // Remove the stored rencontre if necessary
+    await this.actor.deleteRencontreTMRAtPosition()
     this.updateTokens();
     this.updateValuesDisplay();
     this.nettoyerRencontre();
@@ -446,7 +446,7 @@ export class RdDTMRDialog extends Dialog {
   async maitriserRencontre() {
     console.log("-> maitriser", this.currentRencontre);
 
-    await this.actor.deleteTMRRencontreAtPosition();
+    await this.actor.deleteRencontreTMRAtPosition()
     this.updateTokens();
 
     let rencontreData = {

module/rdd-utility.js

@@ -18,6 +18,7 @@ import { RdDRaretes } from "./item/raretes.js";
 import { RdDEmpoignade } from "./rdd-empoignade.js";
 import { ExperienceLog } from "./actor/experience-log.js";
 import { RdDCoeur } from "./coeur/rdd-coeur.js";
+import { APP_ASTROLOGIE_REFRESH } from "./sommeil/app-astrologie.js";
 
 /* -------------------------------------------- */
 // This table starts at 0 -> niveau -10
@@ -98,8 +99,9 @@ export class RdDUtility {
   static afficheContenu = {}
   /* -------------------------------------------- */
   static async init() {
-    Hooks.on("renderChatMessage", async (app, html, msg) => RdDUtility.onRenderChatMessage(app, html, msg));
-    Hooks.on('renderChatLog', (log, html, chatLog) => RdDUtility.chatListeners(html));
+    Hooks.on("renderChatMessage", async (app, html, msg) => await ChatUtility.onRenderChatMessage(app, html, msg))
+    Hooks.on("createChatMessage", async (chatMessage, options, id) => await ChatUtility.onCreateChatMessage(chatMessage, options, id))
+    Hooks.on('renderChatLog', (log, html, chatLog) => RdDUtility.chatListeners(html))
   }
 
   /* -------------------------------------------- */
@@ -205,6 +207,7 @@ export class RdDUtility {
       '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/date-heure.hbs',
       'systems/foundryvtt-reve-de-dragon/templates/common/periodicite.hbs',
       'systems/foundryvtt-reve-de-dragon/templates/common/enum-duree.hbs',
       'systems/foundryvtt-reve-de-dragon/templates/common/compendium-link.hbs',
@@ -549,49 +552,54 @@ export class RdDUtility {
 
   /* -------------------------------------------- */
   static async jetEncaissement(rollData, armure, options = { showDice: HIDE_DICE }) {
-    let formula = "2d10";
+    const diff = Math.abs(rollData.diffLibre);
+    let formula = RdDUtility.formuleEncaissement(diff, options)
+    const roll = await RdDDice.roll(formula, options);
 
-    // Chaque dé fait au minmum la difficulté libre
-    if (ReglesOptionnelles.isUsing('degat-minimum-malus-libre')) {
-      if (rollData.diffLibre < 0) {
-        let valeurMin = Math.abs(rollData.diffLibre);
-        formula += "min" + valeurMin;
-      }
-    }
-    // Chaque dé fait au minmum la difficulté libre
-    if (ReglesOptionnelles.isUsing('degat-ajout-malus-libre')) {
-      if (rollData.diffLibre < 0) {
-        let valeurMin = Math.abs(rollData.diffLibre);
-        formula += "+" + valeurMin;
-      }
-    }
-
-    let roll = await RdDDice.roll(formula, options);
-
-    // 1 dé fait au minmum la difficulté libre
-    if (ReglesOptionnelles.isUsing('degat-minimum-malus-libre-simple')) {
-      if (rollData.diffLibre < 0) {
-        let valeurMin = Math.abs(rollData.diffLibre);
-        if (roll.terms[0].results[0].result < valeurMin) {
-          roll.terms[0].results[0].result = valeurMin;
-        } else if (roll.terms[0].results[1].result < valeurMin) {
-          roll.terms[0].results[1].result = valeurMin;
-        }
-        roll._total = roll.terms[0].results[0].result + roll.terms[0].results[1].result;
-      }
-    }
+    RdDUtility.remplaceDeMinParDifficulte(roll, diff, options);
 
     return await RdDUtility.prepareEncaissement(rollData, roll, armure);
   }
 
+  static remplaceDeMinParDifficulte(roll, diff, options) {
+    if (!ReglesOptionnelles.isUsing('degat-minimum-malus-libre-simple')) {
+      return
+    }
+    // 1 dé fait au minmum la difficulté libre
+    const total = options.forceDiceResult?.total;
+    if (total) {
+      const reste = Math.max(total - diff, 1)
+      roll.terms[0].number = reste + diff
+    }
+    else {
+      if (roll.terms[0].results[0].result < diff) {
+        roll.terms[0].results[0].result = diff;
+      } else if (roll.terms[0].results[1].result < diff) {
+        roll.terms[0].results[1].result = diff;
+      }
+      roll._total = roll.terms[0].results[0].result + roll.terms[0].results[1].result;
+    }
+  }
+
+  static formuleEncaissement(diff, options) {
+    // Chaque dé fait au minimum la difficulté libre
+    if (ReglesOptionnelles.isUsing('degat-minimum-malus-libre')) {
+      return `2d10min${diff}`
+    }
+    return '2d10'
+  }
+
   /* -------------------------------------------- */
   static async prepareEncaissement(rollData, roll, armure) {
-    const jetTotal = roll.total + rollData.dmg.total - armure;
-    let encaissement = RdDUtility._selectEncaissement(jetTotal, rollData.dmg.mortalite);
-    let over20 = Math.max(jetTotal - 20, 0);
+    // La difficulté d'ataque s'ajoute aux dégâts
+    const bonusDegatsDiffLibre = ReglesOptionnelles.isUsing('degat-ajout-malus-libre') ? Math.abs(rollData.diffLibre ?? 0) : 0
+    const jetTotal = roll.total + rollData.dmg.total - armure + bonusDegatsDiffLibre
+    const encaissement = RdDUtility._selectEncaissement(jetTotal, rollData.dmg.mortalite);
+    const over20 = Math.max(jetTotal - 20, 0);
     encaissement.dmg = rollData.dmg;
     encaissement.dmg.loc = rollData.dmg.loc ?? await RdDUtility.getLocalisation(this.type);
     encaissement.dmg.loc.label = encaissement.dmg.loc.label ?? 'Corps;';
+    encaissement.dmg.bonusDegatsDiffLibre = bonusDegatsDiffLibre
     encaissement.roll = roll;
     encaissement.armure = armure;
     encaissement.penetration = rollData.arme?.system.penetration ?? 0;
@@ -620,21 +628,15 @@ export class RdDUtility {
     return perte.total;
   }
 
-  /* -------------------------------------------- */
-  static async responseNombreAstral(callData) {
-    let actor = game.actors.get(callData.id);
-    actor.ajouteNombreAstral(callData);
-  }
-
   /* -------------------------------------------- */
   static onSocketMessage(sockmsg) {
     switch (sockmsg.msg) {
       case "msg_gm_chat_message":
         return ChatUtility.handleGMChatMessage(sockmsg.data);
+      case "msg_app_astrologie_refresh":
+        return Hooks.callAll(APP_ASTROLOGIE_REFRESH);
       case "msg_request_nombre_astral":
         return game.system.rdd.calendrier.requestNombreAstral(sockmsg.data);
-      case "msg_response_nombre_astral":
-        return RdDUtility.responseNombreAstral(sockmsg.data);
       case "msg_tmr_move":
         let actor = game.actors.get(sockmsg.data.actorId);
         if (actor.isOwner || game.user.isGM) {
@@ -890,10 +892,4 @@ export class RdDUtility {
     }
   }
 
-  /*-------------------------------------------- */
-  static async onRenderChatMessage(app, html, msg) {
-    // TODO 
-    //console.log(app, html, msg);
-  }
-
 }

module/settings/regles-optionnelles.js

@@ -26,6 +26,7 @@ const listeReglesOptionnelles = [
   
   { group: 'Confirmations', name: 'confirmer-combat-sans-cible',         descr: "Confirmer avant une attaque sans cible", scope: "client"},
   { group: 'Confirmations', name: 'confirmation-tmr',                    descr: "Confirmer pour monter dans les TMR", scope: "client"},
+  { group: 'Confirmations', name: 'confirmation-tmr-rencontre',          descr: "Confirmer pour monter dans les TMR avec rencontre en attente", scope: "client"},
   { group: 'Confirmations', name: 'confirmation-refouler',               descr: "Confirmer avant de refouler", scope: "client"},
   { group: 'Confirmations', name: 'confirmation-vider',                  descr: "Confirmer pour vider l'équipement", scope: "client"},
   { group: 'Confirmations', name: 'confirmation-supprimer-lien-acteur',  descr: "Confirmer pour détacher un animal/suivant/véhicule", scope: "client"},

module/settings/status-effects.js

@@ -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/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.StatusGrappling, tint: '#33cc33', label: 'EFFECT.StatusGrappling', icon: 'systems/foundryvtt-reve-de-dragon/icons/empoignade.webp' },
+  { rdd: true, id: STATUSES.StatusGrappled, tint: '#ff9900', label: 'EFFECT.StatusGrappled', icon: 'systems/foundryvtt-reve-de-dragon/icons/empoignade.webp' },
   { rdd: true, id: STATUSES.StatusRestrained, label: 'EFFECT.StatusRestrained', icon: 'icons/svg/net.svg' },
   { rdd: true, id: STATUSES.StatusUnconscious, label: 'EFFECT.StatusUnconscious', icon: 'icons/svg/unconscious.svg' },
   { rdd: true, id: STATUSES.StatusBlind, label: 'EFFECT.StatusBlind', icon: 'icons/svg/blind.svg' },
@@ -65,7 +65,7 @@ export class StatusEffects extends FormApplication {
 
   static valeurSurprise(effect, isCombat) {
     if (statusSurpriseTotale.intersects(effect.statuses)) {
-      return 2;
+      return 2
     }
     if (statusDemiSurprise.intersects(effect.statuses)) {
       return 1
@@ -110,7 +110,7 @@ export class StatusEffects extends FormApplication {
 
   static get defaultOptions() {
     const options = super.defaultOptions;
-    mergeObject(options, {
+    foundry.utils.mergeObject(options, {
       id: "status-effects",
       template: "systems/foundryvtt-reve-de-dragon/templates/settings/status-effects.html",
       height: 800,

module/sommeil/app-astrologie.js

@@ -31,7 +31,6 @@ export class AppAstrologie extends Application {
   constructor(actor, options = {}) {
     super(options);
     this.actor = actor;
-    this.hookReference = Hooks.on(APP_ASTROLOGIE_REFRESH, () => this.refreshAstrologie());
   }
 
   getData(options) {
@@ -85,9 +84,10 @@ export class AppAstrologie extends Application {
       const nbAstral = calendrier.getNombreAstral()
       const heures = RdDTimestamp.heures();
       return {
-        ajustementsActors:game.actors.filter(actor => actor.isPersonnageJoueur())
+        ajustementsActors: game.actors.filter(actor => actor.isPersonnageJoueur())
           .map(actor => this.getAjustementActor(actor, nbAstral, heures)),
-        nombresAstraux: calendrier.getNombresAstraux().map(na => this.getDetailNombreAstral(na))
+        nombresAstraux: game.system.rdd.calendrier.getNombresAstraux()
+          .map(na => this.getDetailNombreAstral(na))
       }
     }
     return {}
@@ -107,12 +107,15 @@ export class AppAstrologie extends Application {
     const detail = foundry.utils.duplicate(nombreAstral);
     const timestamp = new RdDTimestamp({ indexDate: nombreAstral.index });
     detail.date = { mois: timestamp.mois, jour: timestamp.jour + 1 };
-    detail.valeursFausses.forEach(fausse => fausse.actorName = game.actors.get(fausse.actorId).name ?? "Inconnu");
+    detail.lectures.forEach(lecture => lecture.actorName = game.actors.get(lecture.actorId).name ?? "Inconnu");
     return detail;
   }
 
   /* -------------------------------------------- */
   activateListeners(html) {
+    if (!this.hookReference){
+      this.hookReference = Hooks.on(APP_ASTROLOGIE_REFRESH, () => this.refreshAstrologie());
+    }
     super.activateListeners(html);
     this.html = html;
     this.html.find('select[name="signe-astral"]').change(event => {
@@ -145,8 +148,7 @@ export class AppAstrologie extends Application {
 
   /* -------------------------------------------- */
   async onRebuild() {
-    game.system.rdd.calendrier.resetNombresAstraux();
-
+    await game.system.rdd.calendrier.resetNombresAstraux();
     await game.system.rdd.calendrier.rebuildNombresAstraux();
   }
 
@@ -195,6 +197,8 @@ export class AppAstrologie extends Application {
   }
 
   refreshAstrologie() {
+    this.count = (this.count ?? 0)+1
+    console.log(`Refreshing ${this.count}`);
     this.render(true)
   }
 

module/time/rdd-calendrier.js

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

module/time/rdd-timestamp.js

@@ -231,6 +231,7 @@ export class RdDTimestamp {
 
   get annee() { return Math.floor(this.indexDate / RDD_JOURS_PAR_AN) }
   get mois() { return Math.floor(Misc.modulo(this.indexDate, RDD_JOURS_PAR_AN) / RDD_JOURS_PAR_MOIS) }
+  get nomMois() { 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 Misc.modulo(this.indexMinute, RDD_MINUTES_PAR_HEURES) }

module/tmr/rencontre.js

@@ -16,7 +16,7 @@ export class Rencontre extends Draconique {
     return pixiTMR.sprite(this.code(), {
       zIndex: tmrTokenZIndex.rencontre,
       decallage: pixiTMR.sizes.decallage(0, 0),
-      taille: () => pixiTMR.sizes.twoThird,
+      taille: () => pixiTMR.sizes.full,
     })
   }
 }

styles/simple.css

@@ -92,6 +92,8 @@
   --background-custom-button-hover: linear-gradient(to bottom, rgb(128, 0, 0) 5%, rgb(62, 1, 1) 100%);
   --background-control-selected: linear-gradient(to bottom, hsla(0, 100%, 25%, 0.5) 5%, hsla(0, 100%, 12%, 0.5) 100%);
   --background-tooltip: hsla(60, 12%, 85%, 0.95);
+  --color-tooltip:hsla(282, 47%, 33%, 0.9);
+  --color-tooltip-faint:hsla(282, 47%, 66%, 0.5);
   --background-error:hsla(16, 100%, 50%, 0.8);
   --color-profile-border: hsla(0, 0%, 80%, 0.05);
 }
@@ -1525,6 +1527,11 @@ div.control-icon.token-hud-icon {
   font-size: 1rem;
 }
 
+.chat-message header.message-header .heure-rdd {
+  font-size: 0.7rem;
+  flex-grow: 3;
+}
+
 .chat-message.whisper {
   background: rgba(220,220,210,0.75);
   border: 2px solid #545469;
@@ -1943,7 +1950,7 @@ div.calendar-timestamp-edit select.calendar-signe-heure {
   padding: 3px;
 }
 
-aside#tooltip{
+aside#tooltip {
   background: var(--background-tooltip);
   color: var(--color-text-dark-primary);
   font-size: 1rem;
@@ -1951,6 +1958,15 @@ aside#tooltip{
   padding: 0.4rem;
 }
 
+aside#tooltip span.reference {
+  color: var(--color-tooltip);
+  border: 1px solid var(--color-tooltip-faint);
+}
+
+aside#tooltip .toolclip p.faint {
+  color: var(--color-tooltip-faint);
+}
+
 .tooltip :is(.ttt-xp,.ttt-levelup) {
   width: 250px;
   background: var(--background-tooltip) !important;

system.json

@@ -1,8 +1,8 @@
 {
   "id": "foundryvtt-reve-de-dragon",
   "title": "Rêve de Dragon",
-  "version": "11.2.19",
-  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-11.2.19.zip",
+  "version": "11.2.21",
+  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-11.2.21.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": {

templates/actor/carac-derivee.html

@@ -55,9 +55,7 @@
   <li class="caracteristique flexrow list-item"  data-tooltip="Niveau d'éthylisme">
     <label class="derivee-label" for="system.compteurs.ethylisme.value">{{system.compteurs.ethylisme.label}}</label>
     <select class="derivee-value" name="system.compteurs.ethylisme.value" data-dtype="Number">
-      {{#select system.compteurs.ethylisme.value}}
-      {{>"systems/foundryvtt-reve-de-dragon/templates/enum-niveau-ethylisme.html"}}
-      {{/select}}
+      {{selectOptions @root.config.niveauEthylisme selected=system.compteurs.ethylisme.value valueAttr="value" nameAttr="value" labelAttr="label"}} 
     </select>  
   </li>  
 

templates/actor/carac-entitee.html

@@ -2,20 +2,13 @@
   <li class="caracteristique flexrow list-item">
     <span class="carac-label" name="catEntite">Catégorie : </span>
     <select name="system.definition.categorieentite" value="{{system.definition.categorieentite}}" data-dtype="String" {{#unless @root.options.vueDetaillee}}disabled{{/unless}}>
-      {{#select system.definition.categorieentite}}
-      <option value="cauchemar">Cauchemar</option>
-      <option value="reve">Rêve</option>
-      {{/select}}
+      {{selectOptions @root.config.categorieEntite selected=system.definition.categorieentite}}
     </select>
   </li>
   <li class="caracteristique flexrow list-item">
     <span class="carac-label" name="typeEntite">Type d'entité : </span>
     <select name="system.definition.typeentite" value="{{system.definition.typeentite}}" data-dtype="String" {{#unless @root.options.vueDetaillee}}disabled{{/unless}}>
-      {{#select system.definition.typeentite}}
-      <option value="incarne">Incarnée</option>
-      <option value="nonincarne">Non Incarnée</option>
-      <option value="blurette">Blurette</option>
-      {{/select}}
+      {{selectOptions @root.config.typeEntite selected=system.definition.typeentite}}
     </select>
   </li>
   {{#each system.attributs as |attr key|}}

templates/common/date-heure.hbs

@@ -0,0 +1,3 @@
+<span class="message-metadata heure-rdd">
+  {{this.jourDuMois}} {{this.mois.label}} - {{timestamp-imgSigne this.heure}}
+</span>

templates/dialog-validation-encaissement.html

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

templates/sommeil/astrologie-gardien.hbs

@@ -15,8 +15,8 @@
       <td class="nombre-astral" data-nombre-astral="{{nba.nombreAstral}}">
         <ol>
         <b>{{nba.nombreAstral}}</b>
-        {{#each nba.valeursFausses as |fausse|}}
-        <li>{{fausse.actorName}} - {{fausse.nombreAstral}}</li>
+        {{#each nba.lectures as |lecture|}}
+        <li>{{lecture.actorName}} - {{lecture.nombreAstral}}</li>
         {{/each}}
         </ol>
       </td>