Merge branch 'v1.5-stress' into 'v1.5'

Stress amélioré

See merge request LeRatierBretonnien/foundryvtt-reve-de-dragon!289

module/actor.js

@@ -1002,17 +1002,34 @@ export class RdDActor extends Actor {
   /* -------------------------------------------- */
   async updateCompteurValue(fieldName, fieldValue, raison = 'Inconnue') {
     await this.update({ [`data.compteurs.${fieldName}.value`]: fieldValue });
-    if (fieldName == 'stress') {
+    await this.addStressExperienceLog(fieldName, fieldValue, 'forcé: '+raison);
-      await this.updateExperienceLog('stress', fieldValue, raison);
-    }
   }
 
   /* -------------------------------------------- */
   async addCompteurValue(fieldName, fieldValue, raison = 'Inconnue') {
     let oldValue = (Misc.templateData(this)).compteurs[fieldName].value;
     await this.update({ [`data.compteurs.${fieldName}.value`]: Number(oldValue) + Number(fieldValue) });
-    if (fieldName == 'stress') {
+    await this.addStressExperienceLog(fieldName, fieldValue, raison);
-      await this.updateExperienceLog('stress', fieldValue, raison);
+  }
+
+  async addStressExperienceLog(fieldName, fieldValue, raison) {
+    switch (fieldName) {
+      case 'stress': case 'experience':
+        await this.updateExperienceLog(fieldName, fieldValue, raison);
+    }
+  }
+
+  /* -------------------------------------------- */
+  distribuerStress(compteur, stress, motif) {
+    if (game.user.isGM && this.hasPlayerOwner && this.isPersonnage()) {
+      switch (compteur) {
+         case 'stress': case 'experience':
+           const message = `${this.name} a reçu ${stress} points ${compteur == 'stress' ? "de stress" : "d'expérience"} (raison : ${motif})`;
+           this.addCompteurValue(compteur, stress, motif);
+           ui.notifications.info(message);
+           game.users.players.filter(player => player.active && player.character?.id == this.id)
+            .forEach(player => ChatUtility.notifyUser(player.id, 'info', message));
+      }
     }
   }
 
@@ -3020,17 +3037,8 @@ export class RdDActor extends Actor {
       case 'chance-actuelle': case 'chance actuelle':
         return carac.chance;
     }
-    const keys = Object.entries(carac)
+    let entry = Misc.findFirstLike(name, Object.entries(carac), it => it[1].label, 'caractéristiques');
-      .filter(it => it[0].includes(name) || Grammar.toLowerCaseNoAccent(it[1].label).includes(name))
+    return entry.length>0 ? carac[entry[0]] : undefined;
-      .map(it => it[0]);
-    if (keys.length > 1) {
-      const names = keys.reduce((a, b) => `${a}<br>${b}`);
-      ui.notifications.info(`Plusieurs caractéristiques possibles:<br>${names}<br>La première sera choisie.`);
-    }
-    if (keys.length > 0) {
-      return carac[keys[0]];
-    }
-    return undefined; // Per default
   }
 
   /* -------------------------------------------- */
@@ -3593,18 +3601,17 @@ export class RdDActor extends Actor {
         return;
       }
     }
-    const itemVendu = vendeur?.getObjet(itemId);
+    const itemVendu = Misc.data(vendeur?.getObjet(itemId));
     if (itemVendu) {
-      let itemVenduData = Misc.data(itemVendu);
+      if ("quantite" in itemVendu.data ? itemVendu.data.quantite < achat.quantiteTotal : achat.choix.nombreLots != 1) {
-      if ("quantite" in itemVenduData.data ? itemVenduData.data.quantite < achat.quantiteTotal : achat.choix.nombreLots != 1) {
         await acheteur?.ajouterDeniers(coutDeniers);
         ChatUtility.notifyUser(achat.userId, 'warn', `Le vendeur n'a plus assez de ${vente.item.name} !`);
         return;
       }
       vendeur.ajouterDeniers(coutDeniers);
-      let resteQuantite = (itemVenduData.data.quantite ?? 1) - achat.quantiteTotal;
+      let resteQuantite = (itemVendu.data.quantite ?? 1) - achat.quantiteTotal;
       if (resteQuantite == 0) {
-        vendeur.deleteEmbeddedDocuments("Item", itemId);
+        vendeur.deleteEmbeddedDocuments("Item", [itemId]);
       }
       else {
         vendeur.updateEmbeddedDocuments("Item", [{ _id: itemId, 'data.quantite': resteQuantite }]);
@@ -3615,10 +3622,11 @@ export class RdDActor extends Actor {
         type: vente.item.type,
         img: vente.item.img,
         name: vente.item.name,
-        data: vente.item.data
+        data: vente.item.data,
+        quantite: "quantite" in vente.item ? achat.quantiteTotal : undefined
       }
-      achatData.data.quantite = achat.quantiteTotal;
+      let listeAchat = ("quantite" in vente.item) ? [achatData] : Array.from({length: achat.quantiteTotal}, (_, i) => achatData)
-      let items = await acheteur.createEmbeddedDocuments("Item", [achatData]);
+      let items = await acheteur.createEmbeddedDocuments("Item", listeAchat)
       if (achat.choix.consommer && vente.item.type == 'nourritureboisson') {
         achat.choix.doses = achat.choix.nombreLots;
         await acheteur.consommerNourritureboisson(items[0], achat.choix);
@@ -3833,32 +3841,21 @@ export class RdDActor extends Actor {
     potionData.supprimer = true;
 
     if (potionData.data.magique) {
+      // Gestion de la résistance:
+      potionData.rolled = await RdDResolutionTable.roll(this.getReveActuel(), -8);
+      if (potionData.rolled.isEchec) {
+        await this.reveActuelIncDec(-1);
+        potionData.guerisonData = await this.buildPotionGuerisonList(potionData.data.puissance);
+        potionData.guerisonMinutes = potionData.guerisonData.pointsConsommes * 5;
+      }
+    }
+    if (!potionData.data.magique || potionData.rolled.isSuccess) { 
+      this.bonusRecuperationPotion = potionData.data.herbeBonus;
+    }
     ChatMessage.create({
       whisper: ChatUtility.getWhisperRecipientsAndGMs(game.user.name),
       content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-consommer-potion-soin.html`, potionData)
     });
-      // Gestion de la résistance:
-      let rolled = await RdDResolutionTable.roll(this.getReveActuel(), -8);
-      potionData.reveResultDice = rolled.roll;
-      potionData.scoreReve = rolled.score;
-      potionData.reussiteReve = false;
-      if (!rolled.isSuccess) {
-        await this.reveActuelIncDec(-1);
-        potionData.guerisonData = await this.buildPotionGuerisonList(potionData.data.puissance);
-        potionData.guerisonMinutes = potionData.guerisonData.pointsConsommes * 5;
-        potionData.reussiteReve = true;
-      }
-      ChatMessage.create({
-        whisper: ChatUtility.getWhisperRecipientsAndGMs(game.user.name),
-        content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-appliquer-potion-soin.html`, potionData)
-      });
-    } else {
-      ChatMessage.create({
-        whisper: ChatUtility.getWhisperRecipientsAndGMs(game.user.name),
-        content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-appliquer-potion-soin.html`, potionData)
-      });
-      this.bonusRecuperationPotion = potionData.data.herbeBonus;
-    }
   }
 
   /* -------------------------------------------- */
@@ -3867,22 +3864,14 @@ export class RdDActor extends Actor {
     potionData.supprimer = true;
 
     if (potionData.data.magique) {
-      ChatMessage.create({
-        whisper: ChatUtility.getWhisperRecipientsAndGMs(game.user.name),
-        content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-consommer-potion-repos.html`, potionData)
-      });
       // Gestion de la résistance:
-      let rolled = await RdDResolutionTable.roll(this.getReveActuel(), -8);
+      potionData.rolled = await RdDResolutionTable.roll(this.getReveActuel(), -8);
-      potionData.reveResultDice = rolled.roll;
+      if (potionData.rolled.isEchec) {
-      potionData.scoreReve = rolled.score;
-      potionData.reussiteReve = false;
-      if (!rolled.isSuccess) {
         await this.reveActuelIncDec(-1);
         let fatigueActuelle = this.getFatigueActuelle();
         potionData.caseFatigueReel = Math.min(fatigueActuelle, potionData.data.puissance);
         potionData.guerisonDureeUnite = (potionData.data.reposalchimique) ? "rounds" : "minutes";
         potionData.guerisonDureeValue = (potionData.data.reposalchimique) ? potionData.caseFatigueReel : potionData.caseFatigueReel * 5;
-        potionData.reussiteReve = true;
         potionData.aphasiePermanente = false;
         if (potionData.data.reposalchimique) {
           let chanceAphasie = await RdDDice.rollTotal("1d100");
@@ -3892,17 +3881,14 @@ export class RdDActor extends Actor {
         }
         await this.santeIncDec("fatigue", -potionData.caseFatigueReel);
       }
-      ChatMessage.create({
+    }
-        whisper: ChatUtility.getWhisperRecipientsAndGMs(game.user.name),
+    if (!potionData.data.magique || potionData.rolled.isSuccess) {
-        content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-appliquer-potion-repos.html`, potionData)
-      });
-    } else {
-      ChatMessage.create({
-        whisper: ChatUtility.getWhisperRecipientsAndGMs(game.user.name),
-        content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-appliquer-potion-repos.html`, potionData)
-      });
       this.bonusRepos = potionData.data.herbeBonus;
     }
+    ChatMessage.create({
+      whisper: ChatUtility.getWhisperRecipientsAndGMs(game.user.name),
+      content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-consommer-potion-repos.html`, potionData)
+    });
   }
   /* -------------------------------------------- */
   dialogFabriquerPotion(herbe) {
@@ -3930,10 +3916,9 @@ export class RdDActor extends Actor {
     let newQuantite = herbeData.data.quantite - herbeData.nbBrins;
     let messageData = {
       alias: this.name,
-      categorie: herbeData.data.categorie,
+      nbBrinsReste: newQuantite,
-      herbe: herbeData.name,
+      potion: newPotion,
-      nbBrinsPotion: herbeData.nbBrins,
+      herbe: herbeData
-      nbBrinsReste: newQuantite
     }
     this.diminuerQuantiteObjet(herbeData._id, herbeData.nbBrins);
 
@@ -3941,7 +3926,6 @@ export class RdDActor extends Actor {
       whisper: ChatUtility.getWhisperRecipientsAndGMs(game.user.name),
       content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-fabriquer-potion-base.html`, messageData)
     });
-
   }
 
   /* -------------------------------------------- */
@@ -3956,6 +3940,13 @@ export class RdDActor extends Actor {
   async consommerPotionGenerique(potionData) {
     potionData.alias = this.name;
 
+    if (potionData.data.magique) {
+      // Gestion de la résistance:
+      potionData.rolled = await RdDResolutionTable.roll(this.getReveActuel(), -8);
+      if (potionData.rolled.isEchec) {
+        await this.reveActuelIncDec(-1);
+      }
+    }
     ChatMessage.create({
       whisper: ChatUtility.getWhisperRecipientsAndGMs(game.user.name),
       content: await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-consommer-potion-generique.html`, potionData)

module/dialog-create-signedraconique.js

@@ -2,8 +2,7 @@ import { ChatUtility } from "./chat-utility.js";
 import { HtmlUtility } from "./html-utility.js";
 import { RdDItemSigneDraconique } from "./item-signedraconique.js";
 import { Misc } from "./misc.js";
-import { RdDRollTables } from "./rdd-rolltables.js";
+import { TMRUtility } from "./tmr-utility.js";
-import { TMRType, TMRUtility } from "./tmr-utility.js";
 
 export class DialogCreateSigneDraconique extends Dialog {
 

module/dialog-stress.js

@@ -0,0 +1,72 @@
+import { Misc } from "./misc.js";
+
+export class DialogStress extends Dialog {
+
+  static async distribuerStress() {
+    let dialogData = {
+      motif: "Motif",
+      stress: 10,
+      immediat: false,
+      actors: game.actors.filter(actor => actor.hasPlayerOwner && actor.isPersonnage())
+        .map(actor => {
+          let actorData = duplicate(Misc.data(actor));
+          actorData.selected = actor.hasPlayerOwner;
+          return actorData;
+        })
+    };
+
+    const html = await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/dialog-stress.html", dialogData);
+    new DialogStress(dialogData, html)
+      .render(true);
+  }
+
+  constructor(dialogData, html) {
+    let options = { classes: ["DialogStress"], width: 400, height: 320, 'z-index': 99999 };
+    let conf = {
+      title: "Donner du stress",
+      content: html,
+      buttons: {
+        "Stress": { label: "Stress !", callback: it => { this._onStress(); } }
+      }
+    };
+    super(conf, options);
+    this.dialogData = dialogData;
+  }
+
+  async _onStress() {
+    this.validerStress();
+    const compteur = this.dialogData.immediat ? 'experience' : 'stress';
+    const stress = this.dialogData.stress;
+    const motif = this.dialogData.motif;
+
+    this.dialogData.actors.filter(it => it.selected)
+      .map(it => game.actors.get(it._id))
+      .forEach(actor => actor.distribuerStress(compteur, stress, motif));
+  }
+
+
+  validerStress() {
+    this.dialogData.motif = $("[name='motif']").val();
+    this.dialogData.stress = $("[name='stress']").val();
+    this.dialogData.immediat = $("[name='immediat']").prop("checked");;
+  }
+
+  /* -------------------------------------------- */
+  activateListeners(html) {
+    super.activateListeners(html);
+    html.find(".select-actor").change((event) => this.onSelectActor(event));
+  }
+
+  async onSelectActor(event) {
+    event.preventDefault();
+    const options = event.currentTarget.options;
+    for (var i = 0; i < options.length; i++) { // looping over the options
+      const actorId = options[i].attributes["data-actor-id"].value;
+      const actor = this.dialogData.actors.find(it => it._id == actorId);
+      if (actor) {
+        actor.selected = options[i].selected;
+      }
+    };
+  }
+
+}

module/item-competence.js

@@ -209,20 +209,7 @@ export class RdDItemCompetence extends Item {
 
   /* -------------------------------------------- */
   static findCompetence(list, name) {
-    name = Grammar.toLowerCaseNoAccent(name);
+    return Misc.findFirstLike(name, list, it => it.name, 'compétences');
-    const competences = list.filter(it => Grammar.toLowerCaseNoAccent(it.name).includes(name) && (it.type == "competence" || it.type == "competencecreature"));
-    if (competences.length == 0) {
-      return undefined;
-    }
-    let competence = competences.find(it => Grammar.toLowerCaseNoAccent(it.name) == name);
-    if (!competence) {
-      competence = competences[0];
-      if (competences.length > 1) {
-        const names = competences.map(it => it.name).reduce((a, b) => `${a}<br>${b}`);
-        ui.notifications.info(`Plusieurs compétences possibles:<br>${names}<br>La première sera choisie: ${competence.name}`);
-      }
-    }
-    return competence;
   }
 
   /* -------------------------------------------- */

module/item-competencecreature.js

@@ -17,23 +17,23 @@ export class RdDItemCompetenceCreature extends Item {
   }
 
   /* -------------------------------------------- */
-  static toArme(itemData) {
+  static toArme(item) {
-    if (RdDItemCompetenceCreature.isCompetenceAttaque(itemData)) {
+    if (RdDItemCompetenceCreature.isCompetenceAttaque(item)) {
-      itemData = Misc.data(itemData);
+      // si c'est un Item compétence: cloner pour ne pas modifier lma compétence
-      let arme = { name: itemData.name, data: duplicate(itemData) };
+      let arme = Misc.data( (item instanceof Item) ? item.clone():  item);
       mergeObject(arme.data,
         {
-          competence: itemData.name,
+          competence: arme.name,
           resistance: 100,
           equipe: true,
-          dommagesReels: itemData.data.dommages,
+          dommagesReels: arme.data.dommages,
           penetration: 0,
           force: 0,
           rapide: true
         });
       return arme;
     }
-    console.error("RdDItemCompetenceCreature.toArme(", itemData, ") : impossible de transformer l'Item en arme");
+    console.error("RdDItemCompetenceCreature.toArme(", item, ") : impossible de transformer l'Item en arme");
     return undefined;
   }
 

module/misc.js

@@ -1,4 +1,4 @@
-import { RdDDice } from "./rdd-dice.js";
+import { Grammar } from "./grammar.js";
 
 /**
  * This class is intended as a placeholder for utility methods unrelated
@@ -131,4 +131,32 @@ export class Misc {
   static isElectedUser() {
     return game.user.id == Misc.connectedGMOrUser();
   }
+
+  /* -------------------------------------------- */
+  static findPlayer(name) {
+    return Misc.findFirstLike(name, game.users, it=>it.name,'joueurs');
+  }
+
+  /* -------------------------------------------- */
+  static findActor(name, actors = game.actors, description= 'acteurs') {
+    return Misc.findFirstLike(name, actors, it=>it.name, description);
+  }
+
+  /* -------------------------------------------- */
+  static findFirstLike(value, elements, mapper = it=>it.name, description = 'valeurs') {
+    value = Grammar.toLowerCaseNoAccent(value);
+    const subset = elements.filter(it => Grammar.toLowerCaseNoAccent(mapper(it)).includes(value));
+    if (subset.length == 0) {
+      return undefined;
+    }
+    let single = subset.find(it => Grammar.toLowerCaseNoAccent(mapper(it)) == value);
+    if (!single) {
+      single = subset[0];
+      if (subset.length > 1) {
+        const choices = subset.map(it => mapper(it)).reduce((a, b) => `${a}<br>${b}`);
+        ui.notifications.info(`Plusieurs choix de ${description} possibles:<br>${choices}<br>Le premier sera choisi: ${mapper(single)}`);
+      }
+    }
+    return single;
+  }
 }

module/rdd-combat.js

@@ -1165,11 +1165,11 @@ export class RdDCombat {
         const dmg = attackerRoll.dmg.dmgArme + attackerRoll.dmg.dmgActor;
         let arme = defenderRoll.arme;
         let msg = "";
+        let resistance = Misc.toInt(arme.data.resistance);
         if (arme.data.magique) {
           defenderRoll.show.deteriorationArme = 'resiste'; // Par défaut
           if (arme.data.resistance_magique == undefined) arme.data.resistance_magique = 0; // Quick fix
           if (dmg > arme.data.resistance_magique) { // Jet uniquement si dommages supérieur à résistance magique (cf. 274)
-            let resistance = Misc.toInt(arme.data.resistance);
             // Jet de résistance de l'arme de parade (p.132)
             let resistRoll = await RdDResolutionTable.rollData({
               caracValue: resistance,
@@ -1185,7 +1185,6 @@ export class RdDCombat {
             }
           }
         } else {
-          let resistance = Misc.toInt(arme.data.resistance);
           // Jet de résistance de l'arme de parade (p.132)
           let resistRoll = await RdDResolutionTable.rollData({
             caracValue: resistance,

module/rdd-commands.js

@@ -1,6 +1,7 @@
 /* -------------------------------------------- */
 
 import { DialogCreateSigneDraconique } from "./dialog-create-signedraconique.js";
+import { DialogStress } from "./dialog-stress.js";
 import { RdDItemCompetence } from "./item-competence.js";
 import { Misc } from "./misc.js";
 import { RdDCarac } from "./rdd-carac.js";
@@ -97,11 +98,12 @@ export class RdDCommands {
       });
 
       rddCommands.registerCommand({
-        path: ["/stress"], func: (content, msg, params) => RdDUtility.distribuerStress(params[0], params[1], params[2]),
+        path: ["/stress"], func: (content, msg, params) => rddCommands.distribuerStress(params),
         descr: `Distribue du stress aux personnages. Exemples:
+          <br><strong>/stress</strong> : Ouvre une fenêtre pour donner du stress ou de l'expérience à un ensemble de personnages
           <br><strong>/stress 6</strong> : Distribue 6 points des Stress à tout les personnages joueurs, sans raison renseignée
-          <br><strong>/stress 6 Tigre</strong> : Distribue 6 points des Stress à tout les personnages joueurs, à cause d'un Tigre Vert
+          <br><strong>/stress 6 Tigre</strong> : Distribue 6 points des Stress à tout les personnages joueurs, à cause d'un Tigre (Vert)
-          <br><strong>/stress 6 Glou Paulo</strong> : Distribue 6 points de Stres à l'acteur connecté au joueur Paulo, à cause d'un Glou`
+          <br><strong>/stress 6 Glou Paulo</strong> : Distribue 6 points de Stress au personnage Paulon ou au personnage joueur Paulo, à cause d'un Glou`
       });
 
       game.system.rdd.commands = rddCommands;
@@ -289,7 +291,7 @@ export class RdDCommands {
       finalLevel: diff,
       showDice: true,
       diviseurSignificative: significative ? 2 : 1,
-      show: { title: "Table de résolution"}
+      show: { title: "Table de résolution" }
     };
     await RdDResolutionTable.rollData(rollData);
     RdDCommands._chatAnswer(msg, await RdDResolutionTable.buildRollDataHtml(rollData));
@@ -297,7 +299,7 @@ export class RdDCommands {
 
   /* -------------------------------------------- */
   async rollDeDraconique(msg) {
-    let ddr = await RdDDice.rollTotal("1dr + 7", { showDice:true });
+    let ddr = await RdDDice.rollTotal("1dr + 7", { showDice: true });
     RdDCommands._chatAnswer(msg, `Lancer d'un Dé draconique: ${ddr}`);
   }
 
@@ -351,5 +353,41 @@ export class RdDCommands {
     });
     return true;
   }
+
+  async distribuerStress(params) {
+    if (!game.user.isGM) {
+      ui.notifications.warn("Seul le MJ est autorisé à utiliser la commande /stress");
+      return false;
+    }
+    if (params.length == 0) {
+      DialogStress.distribuerStress();
+    }
+    else {
+      let stress = params[0]
+      if (stress == undefined) {
+        ui.notifications.warn("Pas de valeur de stress à distribuer!");
+        return;
+      }
+
+      let motif = params[1];
+      let name = params[2];
+      if (name == undefined) {
+        for (let actor of game.actors) {
+          actor.distribuerStress('stress', stress, motif);
+        }
+      } else {
+        //console.log(stressValue, nomJoueur);
+        let actor = Misc.findActor(name, game.actors.filter(it => it.hasPlayerOwner)) ?? Misc.findPlayer(name)?.character
+        if (actor) {
+          actor.distribuerStress('stress', stress, motif);
+        }
+        else {
+          ui.notifications.warn(`Pas de personnage ou de joueur correspondant à ${name}!`);
+        }
+      }
+
+    }
+    return true;
+  }
 }
 

module/rdd-resolution-table.js

@@ -1,6 +1,7 @@
 import { ChatUtility } from "./chat-utility.js";
 import { Misc } from "./misc.js";
 import { RdDDice } from "./rdd-dice.js";
+import { ReglesOptionelles } from "./regles-optionelles.js";
 
 /**
  * difficultés au delà de -10
@@ -119,8 +120,11 @@ export class RdDResolutionTable {
     rolled.finalLevel = finalLevel;
     rolled.bonus = rollData.bonus;
     rolled.factorHtml = Misc.getFractionHtml(rollData.diviseurSignificative);
-    rolled.niveauNecessaire = this.findNiveauNecessaire(caracValue, rolled.roll );
+
+    if (ReglesOptionelles.isUsing("afficher-colonnes-reussite")){
+      rolled.niveauNecessaire = this.findNiveauNecessaire(caracValue, rolled.roll);
       rolled.ajustementNecessaire = rolled.niveauNecessaire - finalLevel;
+    }
     return rolled;
   }
 

module/rdd-roll-resolution-table.js

@@ -51,8 +51,7 @@ export class RdDRollResolutionTable extends Dialog {
       content: html,
       buttons: {
         'lancer-fermer': { label: 'Lancer les dés et fermer', callback: html => this.onLancerFermer() }
-      },
+      }
-      default: 'lancer'
     };
     super(conf, { classes: ["rdddialog"], width: 800, height: 800, 'z-index': 99999 });
 

module/rdd-utility.js

@@ -887,32 +887,6 @@ export class RdDUtility {
     }
   }
 
-  /*-------------------------------------------- */
-  static distribuerStress(stressValue, raison = 'Inconnu', nomJoueur = undefined) {
-    if (game.user.isGM) {
-      if (stressValue == undefined){
-        ui.notifications.warn("Pas de valeur de stress à distribuer!");
-        return;
-      }
-      if (nomJoueur == undefined) {
-        for (let actor of game.actors) {
-          if (actor.hasPlayerOwner && actor.isPersonnage() ) {
-            actor.addCompteurValue('stress', stressValue, raison);
-            ui.notifications.info(`${actor.name} a reçu ${stressValue} points de Stress (raison : ${raison})`);
-          }
-        }
-      } else {
-        //console.log(stressValue, nomJoueur);
-        let joueur = game.users.find(user => user.name.toLowerCase() == nomJoueur.toLowerCase());
-        //console.log("Player", joueur, joueur.character );
-        joueur.character.addCompteurValue('stress', stressValue, raison);
-        ui.notifications.info(`${joueur.character.name} a reçu ${stressValue} points de Stress (raison : ${raison})`);
-      }
-    } else {
-      ui.notifications.warn("Seul le MJ est autorisé à utiliser la commande /stress");
-    }
-  }
-
   /*-------------------------------------------- */
   static async onRenderChatMessage(app, html, msg) {
     // TODO 

module/regles-optionelles.js

@@ -10,6 +10,7 @@ const listeReglesOptionelles = [
   { name: 'astrologie', group: 'Règles de générales', descr: "Appliquer les ajustements astrologiques aux jets de chance et aux rituels", default: true },
   { name: 'afficher-prix-joueurs', group: 'Règles de générales', descr: "Afficher le prix de l'équipement des joueurs", default: true },
   { name: 'appliquer-fatigue', group: 'Règles de générales', descr: "Appliquer les règles de fatigue", default: true },
+  { name: 'afficher-colonnes-reussite', group: 'Règles de générales', descr: "Afficher le nombre de colonnes de réussite ou d'échec", default: false },
 ];
 
 export class ReglesOptionelles extends FormApplication {

styles/simple.css

@@ -503,6 +503,11 @@ table {border: 1px solid #7a7971;}
   background:linear-gradient(30deg, rgba(61, 55, 93, 0.2), rgba(178, 179, 196, 0.1), rgba(59, 62, 63, 0.2), rgba(206, 204, 199, 0.1), rgba(61, 46, 49, 0.2));
 }
 
+.rdd-niveau-requis{
+  font-size: 0.80rem;
+  text-align: right;
+}
+
 .table-resolution-carac {
   background-color: yellow;
 }

templates/chat-appliquer-potion-repos.html

@@ -1,22 +0,0 @@
-<img class="chat-icon" src="systems/foundryvtt-reve-de-dragon/icons/competence_botanique.png" alt="potion de repos" />
-<h4>
-  {{#if reussiteReve}}
-  {{alias}} a bu la potion et a échoué son Jet de Résistance (Rêve actuel à -8 : {{reveResultDice}}/{{scoreReve}}) : la potion fait effet !
-  {{else}}
-  {{alias}} a bu la potion et a réussi son Jet de Résistance (Rêve actuel à -8 : {{reveResultDice}}/{{scoreReve}}) : la potion ne fait pas effet !
-  {{/if}}
-</h4>
-<hr>
-<div>
-  {{#if reussiteReve}}
-  {{alias}} perd 1 point de rêve (déduit automatiquement) et s'endort pour {{guerisonDureeValue}} {{guerisonDureeUnite}} et
-  se repose de {{caseFatigueReel}} cases de fatigue.<br>
-    {{#if data.reposalchimique}}
-    De plus, étant donné que la potion était alchimique, {{alias}} est en aphasie pendant cette durée.
-      {{#if aphasiePermanente}}
-      Et malheureusement, l'aphasie est permanente tant que {{alias}} ne réussit pas un jet de VOLONTE à 0 à Chateau Dormant (le moral compte).
-      {{/if}}
-    {{/if}}
-  {{/if}}
-  La potion a également été supprimée de l'équipement.
-</div>

templates/chat-appliquer-potion-soin.html

@@ -1,21 +0,0 @@
-<img class="chat-icon" src="systems/foundryvtt-reve-de-dragon/icons/competence_botanique.png" alt="potion de soin" />
-<h4>
-  {{#if reussiteReve}}
-  {{alias}} a bu la potion et a échoué son Jet de Résistance (Rêve actuel à -8 : {{reveResultDice}}/{{scoreReve}}) : la potion fait effet !
-  {{else}}
-  {{alias}} a bu la potion et a réussi son Jet de Résistance (Rêve actuel à -8 : {{reveResultDice}}/{{scoreReve}}) : la potion ne fait pas effet !
-  {{/if}}
-</h4>
-<hr>
-<div>
-  {{#if reussiteReve}}
-  {{alias}} perd 1 point de rêve (déduit automatiquement) et s'endort pour {{guerisonMinutes}} minutes. A son réveil, les blessures suivantes seront guéries : 
-  <ul>
-    {{#each guerisonData.list as |guerison key|}}
-    <li>{{guerison}}</li>
-    {{/each}}
-  </ul>
-  <br>
-  {{/if}}
-  La potion a également été supprimée de l'équipement.
-</div>

templates/chat-consommer-potion-generique.html

@@ -1,9 +1,18 @@
-<img class="chat-icon" src="systems/foundryvtt-reve-de-dragon/icons/competence_botanique.png" alt="potion de repos" />
+<img class="chat-icon" src="{{img}}" alt="potion de repos" />
 <h4>
-  {{alias}} consomme sa <b>Potion {{#if data.magique}}enchantée{{/if}}</b> de {{name}}.
+  {{alias}} a bu une <strong>{{name}}{{#if data.magique}} enchantée{{/if}}</strong>
 </h4>
 <hr>
 <div>
-  Les effets de la potions sont à gérer manuellement, en fonction de sa nature{{#if data.magique}} et de son enchantement ({{data.pr}} Points de Rêve){{/if}}.
+  {{#if data.magique}}
+    Le Jet de Résistance est {{#if rolled.isSuccess}}réussi{{else}}échoué{{/if}}.
+    {{> "systems/foundryvtt-reve-de-dragon/templates/chat-infojet.html"}}
+  {{/if}}
+  <br>Les effets de la potions sont à gérer manuellement, en fonction de sa nature
+  {{#if data.magique}}
+    {{#if rolled.isEchec}}et de son enchantement ({{data.pr}} Points de Rêve)
+    {{else}}son enchantement n'a pas d'effet
+    {{/if}}
+  {{/if}}.
   <br>La potion a été supprimée de l'équipement.
 </div>

templates/chat-consommer-potion-repos.html

@@ -1,13 +1,27 @@
-<img class="chat-icon" src="systems/foundryvtt-reve-de-dragon/icons/competence_botanique.png" alt="potion de repos" />
+<img class="chat-icon" src="{{img}}" alt="potion de repos" />
 <h4>
-  {{alias}} consomme sa <b>Potion de Repos {{#if data.magique}}enchantée{{/if}}</b> de {{name}} ({{data.herbe}}, {{data.herbebrins}} brins).
+  {{alias}} a bu une <strong>{{name}}{{#if data.magique}} enchantée{{/if}}</strong>
 </h4>
 <hr>
 <div>
   {{#if data.magique}}
-  Elle permet de récupérer jusqu'à {{data.puissance}} cases de repos.
+    Le Jet de Résistance est {{#if rolled.isSuccess}}réussi{{else}}échoué{{/if}}.
-  {{else}}
+    {{> "systems/foundryvtt-reve-de-dragon/templates/chat-infojet.html"}}
-  Une fois consommée vers fin Lyre, elle vous octroie un bonus de {{data.herbebonus}} segments de fatigue récupérés en plus à la fin de Chateau Dormant (à gérer manuellement).
+    {{#if rolled.isEchec}}
-  <br>La potion a également été supprimée de l'équipement.
+    <br>La potion fait effet !
+      {{alias}} a perdu 1 point de rêve et s'endort pour {{guerisonDureeValue}} {{guerisonDureeUnite}} et
+      se récupère {{caseFatigueReel}} cases de fatigue.<br>
+      {{#if data.reposalchimique}}
+        De plus, la potion étant alchimique, {{alias}} est en aphasie pendant cette durée.
+        {{#if aphasiePermanente}}
+        Malheureusement, l'aphasie est permanente tant que {{alias}} ne réussit pas un jet de VOLONTE à 0 à Chateau Dormant (le moral compte).
         {{/if}}
+      {{/if}}
+    {{else}}
+    <br>La potion ne fait pas effet ! Elle vous octroie tout de même un bonus de {{data.herbebonus}} segments de fatigue récupérés en plus à la fin de Chateau Dormant (à gérer manuellement).
+    {{/if}}
+  {{else}}
+    Une fois consommée (vers fin Lyre), elle vous octroie un bonus de {{data.herbebonus}} segments de fatigue récupérés en plus à la fin de Chateau Dormant (à gérer manuellement).
+  {{/if}}
+  <br>La potion a été supprimée de l'équipement.
 </div>

templates/chat-consommer-potion-soin.html

@@ -1,13 +1,25 @@
-<img class="chat-icon" src="systems/foundryvtt-reve-de-dragon/icons/competence_botanique.png" alt="potion de soin" />
+<img class="chat-icon" src="{{img}}" alt="potion de soin" />
 <h4>
-  {{alias}} consomme sa <b>Potion de soins {{#if data.magique}}enchantée{{/if}}</b> de {{name}} ({{data.herbe}}, {{data.herbebrins}} brins).
+  {{alias}} a bu une <strong>{{name}}{{#if data.magique}} enchantée{{/if}}</strong>
 </h4>
 <hr>
 <div>
   {{#if data.magique}}
-  Elle permet de guérir {{data.puissance}} Points de Guérison.
+    Le Jet de Résistance est {{#if rolled.isSuccess}}réussi{{else}}échoué{{/if}}.
+    {{> "systems/foundryvtt-reve-de-dragon/templates/chat-infojet.html"}}
+    {{#if rolled.isEchec}}
+      <br>La potion fait effet!
+      {{alias}} a perdu 1 point de rêve et s'endort pour {{guerisonMinutes}} minutes. A son réveil, les blessures suivantes seront guéries : 
+      <ul>
+        {{#each guerisonData.list as |guerison key|}}
+        <li>{{guerison}}</li>
+        {{/each}}
+      </ul>
+    {{else}}
+      <br>La potion ne fait pas effet ! Lors de votre prochain jet de récupération à Chateau Dormant, vous bénéficierez d'un bonus de {{data.herbebonus}} (appliqué automatiquement).
+    {{/if}}
   {{else}}
     Lors de votre prochain jet de récupération à Chateau Dormant, vous bénéficierez d'un bonus de {{data.herbebonus}} (appliqué automatiquement).
-  <br>La potion a également été supprimée de l'équipement.
   {{/if}}
+  <br>La potion a été supprimée de l'équipement.
 </div>

templates/chat-fabriquer-potion-base.html

@@ -1,6 +1,6 @@
-<img class="chat-icon" src="systems/foundryvtt-reve-de-dragon/icons/competence_botanique.png" alt="fabrication" />
+<img class="chat-icon" src="{{herbe.img}}" alt="fabrication" />
 <h4>
-  {{alias}} a fabriqué une potion de {{categorie}} de {{herbe}}, avec {{nbBrinsPotion}} brins.
+  {{alias}} a fabriqué une potion de {{herbe.data.categorie}} de {{herbe.name}}, avec {{herbe.nbBrins}} brins.
 </h4>
 <hr>
 <div>

templates/chat-infojet.html

@@ -22,5 +22,7 @@
 </div>
 <div>
   <span>{{rolled.roll}} : </span><span class="rdd-roll-{{rolled.code}} strong-text">{{rolled.quality}}</span>
-  <span>(Min.:{{numberFormat rolled.niveauNecessaire decimals=0 sign=true}}/{{numberFormat rolled.ajustementNecessaire decimals=0 sign=true}}) </span>
+  {{#if rolled.ajustementNecessaire}}
+  <span class="rdd-niveau-requis">(Réussite si {{numberFormat rolled.niveauNecessaire decimals=0 sign=true}} / avec niveau {{numberFormat rolled.ajustementNecessaire decimals=0 sign=true}}) </span>
+  {{/if}}
 </div>

templates/chat-resultat-alchimie.html

@@ -1,4 +1,4 @@
-<img class="chat-icon" src="systems/foundryvtt-reve-de-dragon/icons/competence_alchimie.png" alt="préparation alchimique" />
+<img class="chat-icon" src="systems/foundryvtt-reve-de-dragon/icons/competence_alchimie.webp" alt="préparation alchimique" />
 <h4>
   {{alias}} essaye de réaliser sa recette Alchimique : {{recette.name}}
 </h4>

templates/chat-resultat-reve-de-dragon.html

@@ -1,4 +1,4 @@
-<img class="chat-icon" src="systems/foundryvtt-reve-de-dragon/icons/competence_legendes.png" alt="Rêve de Dragon"/>
+<img class="chat-icon" src="systems/foundryvtt-reve-de-dragon/icons/competence_legendes.webp" alt="Rêve de Dragon"/>
 <h4 data-categorie="tmr" data-actor-id="{{actor._id}}">
   {{alias}} tente de maîtriser un Rêve de Dragon!
 </h4>

templates/dialog-stress.html

@@ -0,0 +1,24 @@
+<form class="rdddialog">
+  <div class="flexcol">
+    <div class="form-group">
+      <label for="motif">Motif</label>
+      <input type="text" name="motif" value="{{motif}}" data-dtype="String" />
+    </div>
+    <div class="form-group">
+      <label for="stress">Stress</label>
+      <input type="number" name="stress" value="{{stress}}" data-dtype="Number" />
+    </div>
+    <div class="form-group">
+      <label for="immediat">Expérience immédiate</label>
+      <input class="flex-shrink" type="checkbox" name="immediat" {{#if immediat}}checked{{/if}} />
+    </div>
+    <div class="form-group">
+      <label for="actors">Personnages concernés</label>
+      <select class="select-actor" id="actors" size="7" multiple>
+        {{#each actors as |actor key|}}
+        <option value="{{actor.name}}" data-actor-id="{{actor._id}}" {{#if actor.selected}}selected{{/if}}>{{actor.name}}</option>
+        {{/each}}
+      </select>
+    </div>
+  </div>
+</form>