fatigue optionnelle #113

module/actor-sheet.js

@@ -13,6 +13,7 @@ import { RdDCombatManager } from "./rdd-combat.js";
 import { RdDCarac } from "./rdd-carac.js";
 import { RdDItem } from "./item.js";
 import { DialogSplitItem } from "./dialog-split-item.js";
+import { ReglesOptionelles } from "./regles-optionelles.js";
 
 /* -------------------------------------------- */
 export class RdDActorSheet extends ActorSheet {
@@ -68,10 +69,7 @@ export class RdDActorSheet extends ActorSheet {
       encTotal: await this.actor.computeEncombrementTotalEtMalusArmure(),
       prixTotalEquipement: this.actor.computePrixTotalEquipement(),
       surprise: RdDBonus.find(this.actor.getSurprise(false)).descr,
-      fatigue: {
+      fatigue: RdDUtility.calculFatigueHtml(formData.data.sante.fatigue.value, formData.data.sante.endurance.max),
-        malus: RdDUtility.calculMalusFatigue(formData.data.sante.fatigue.value, formData.data.sante.endurance.max),
-        html: "<table class='table-fatigue'>" + RdDUtility.makeHTMLfatigueMatrix(formData.data.sante.fatigue.value, formData.data.sante.endurance.max).html() + "</table>"
-      },
       resumeBlessures: this.actor.computeResumeBlessure(formData.data.blessures),
     };
     formData.calc.surEncombrementMessage = (formData.data.compteurs.surenc.value < 0) ? "Sur-Encombrement!" : "";
@@ -99,12 +97,6 @@ export class RdDActorSheet extends ActorSheet {
     formData.ajustementsConditions = CONFIG.RDD.ajustementsConditions;
     formData.difficultesLibres = CONFIG.RDD.difficultesLibres;
 
-    // low is normal, this the base used to compute the grid.
-    formData.fatigue = {
-      malus: RdDUtility.calculMalusFatigue(formData.data.sante.fatigue.value, formData.data.sante.endurance.max),
-      html: "<table class='table-fatigue'>" + RdDUtility.makeHTMLfatigueMatrix(formData.data.sante.fatigue.value, formData.data.sante.endurance.max).html() + "</table>"
-    }
-
     formData.hautreve = {
       sortsReserve: formData.data.reve.reserve.list,
       rencontres: duplicate(formData.data.reve.rencontre.list),
@@ -211,6 +203,7 @@ export class RdDActorSheet extends ActorSheet {
     super.activateListeners(html);
 
     HtmlUtility._showControlWhen($(".gm-only"), game.user.isGM);
+    HtmlUtility._showControlWhen($(".appliquerFatigue"), ReglesOptionelles.isUsing("appliquer-fatigue"));
 
     html.find('#show-hide-competences').click((event) => {
       this.options.showCompNiveauBase = !this.options.showCompNiveauBase;

module/actor.js

@@ -196,11 +196,11 @@ export class RdDActor extends Actor {
   }
   /* -------------------------------------------- */
   getFatigueActuelle() {
-    if (!this.isPersonnage()) {
+    if (ReglesOptionelles.isUsing("appliquer-fatigue") && this.isPersonnage()) {
-      return 0;
-    }
       return Misc.toInt(Misc.templateData(this).sante.fatigue?.value);
     }
+    return 0;
+  }
   /* -------------------------------------------- */
   getFatigueMax() {
     if (!this.isPersonnage()) {
@@ -544,7 +544,7 @@ export class RdDActor extends Actor {
 
       await this.santeIncDec("vie", actorData.data.sante.vie.max - actorData.data.sante.vie.value);
       await this.santeIncDec("endurance", actorData.data.sante.endurance.max - actorData.data.sante.endurance.value);
-      if (actorData.data.sante.fatigue) {
+      if (ReglesOptionelles.isUsing("appliquer-fatigue") && actorData.data.sante.fatigue) {
         await this.update({ "data.sante.fatigue.value": 0 });
       }
     }
@@ -594,6 +594,7 @@ export class RdDActor extends Actor {
 
   /* -------------------------------------------- */
   async recupererFatigue(message) {
+    if (ReglesOptionelles.isUsing("appliquer-fatigue")) {
       let fatigue = Misc.templateData(this).sante.fatigue.value;
       const fatigueMin = this._computeFatigueMin();
       if (fatigue <= fatigueMin) {
@@ -601,12 +602,12 @@ export class RdDActor extends Actor {
         return;
       }
       fatigue = Math.max(fatigueMin, this._calculRecuperationSegment(fatigue));
-    console.log("recupererFatigue", fatigue)
       await this.update({ "data.sante.fatigue.value": fatigue });
       if (fatigue == 0) {
         message.content += "Vous êtes complêtement reposé. ";
       }
     }
+  }
 
   /* -------------------------------------------- */
   _calculRecuperationSegment(actuel) {
@@ -1157,8 +1158,7 @@ export class RdDActor extends Actor {
     }
     // Pour les autres
     let state = - (actorData.data.sante.vie.max - actorData.data.sante.vie.value);
-    if (actorData.data.sante.fatigue) {
+    if (ReglesOptionelles.isUsing("appliquer-fatigue") && actorData.data.sante.fatigue) {
-      // Creatures n'ont pas de fatigue
       state += RdDUtility.currentFatigueMalus(actorData.data.sante.fatigue.value, actorData.data.sante.endurance.max);
     }
     // Ajout de l'éthylisme
@@ -1471,7 +1471,9 @@ export class RdDActor extends Actor {
 
   /* -------------------------------------------- */
   async santeIncDec(name, inc, options = { isCritique: false, ethylisme: false }) {
-
+    if (name=='fatigue' && !ReglesOptionelles.isUsing("appliquer-fatigue")) {
+      return;
+    }
     const sante = duplicate(Misc.templateData(this).sante);
     let compteur = sante[name];
     if (!compteur) {
@@ -1511,7 +1513,7 @@ export class RdDActor extends Actor {
     compteur.value = result.newValue;
     //console.log(name, inc, data.value, result.newValue, minValue, data.max);
     // If endurance lost, then the same amount of fatigue cannot be recovered
-    if (sante.fatigue && fatigue > 0) {
+    if (ReglesOptionelles.isUsing("appliquer-fatigue") && sante.fatigue && fatigue > 0) {
       sante.fatigue.value = Math.max(sante.fatigue.value + fatigue, this._computeFatigueMin());
     }
     await this.update({ "data.sante": sante });
@@ -2342,6 +2344,7 @@ export class RdDActor extends Actor {
   /* -------------------------------------------- */
   async _tacheResult(rollData) {
     // Mise à jour de la tache
+    rollData.appliquerFatigue = ReglesOptionelles.isUsing("appliquer-fatigue");
     rollData.tache = duplicate(rollData.tache);
     rollData.tache.data.points_de_tache_courant += rollData.rolled.ptTache;
     if (rollData.rolled.isETotal) {
@@ -2800,10 +2803,7 @@ export class RdDActor extends Actor {
     const endurance = actorData.data.sante.endurance.max;
     let tmrFormData = {
       mode: mode,
-      fatigue: {
+      fatigue: RdDUtility.calculFatigueHtml(fatigue, endurance),
-        malus: RdDUtility.calculMalusFatigue(fatigue, endurance),
-        html: "<table class='table-fatigue'>" + RdDUtility.makeHTMLfatigueMatrix(fatigue, endurance).html() + "</table>"
-      },
       draconic: this.getDraconicList(),
       sort: this.getSortList(),
       caracReve: actorData.data.carac.reve.value,

module/rdd-main.js

@@ -171,6 +171,7 @@ Hooks.once("init", async function () {
   CONFIG.Combat.documentClass = RdDCombatManager;
 
   // préparation des différents modules
+  ReglesOptionelles.init();
   RdDUtility.init();
   RdDDice.init();
   RdDCommands.init();
@@ -179,7 +180,6 @@ Hooks.once("init", async function () {
   RdDTokenHud.init();
   RdDActor.init();
   RddCompendiumOrganiser.init();
-  ReglesOptionelles.init();
   EffetsDraconiques.init()
   TMRUtility.init();
   TMRRencontres.init();

module/rdd-tmr-dialog.js

@@ -10,8 +10,9 @@ import { Poetique } from "./poetique.js";
 import { EffetsDraconiques } from "./tmr/effets-draconiques.js";
 import { PixiTMR } from "./tmr/pixi-tmr.js";
 import { Draconique } from "./tmr/draconique.js";
-import { Grammar } from "./grammar.js";
 import { Misc } from "./misc.js";
+import { HtmlUtility } from "./html-utility.js";
+import { ReglesOptionelles } from "./regles-optionelles.js";
 
 /* -------------------------------------------- */
 export class RdDTMRDialog extends Dialog {
@@ -49,7 +50,7 @@ export class RdDTMRDialog extends Dialog {
     this.actor = actor;
     this.actor.tmrApp = this; // reference this app in the actor structure
     this.viewOnly = tmrData.mode == "visu"
-    this.fatigueParCase = this.viewOnly ? 0 : this.actor.getTMRFatigue();
+    this.fatigueParCase = this.viewOnly || !ReglesOptionelles.isUsing("appliquer-fatigue") ? 0 : this.actor.getTMRFatigue();
     this.cumulFatigue = 0;
     this.loadRencontres();
     this.loadSortsReserve();
@@ -177,6 +178,7 @@ export class RdDTMRDialog extends Dialog {
   async activateListeners(html) {
     super.activateListeners(html);
 
+    HtmlUtility._showControlWhen($(".appliquerFatigue"), ReglesOptionelles.isUsing("appliquer-fatigue"));
     document.getElementById("tmrrow1").insertCell(0).append(this.pixiApp.view);
 
     if (this.viewOnly) {
@@ -214,7 +216,9 @@ export class RdDTMRDialog extends Dialog {
     
     // Gestion du cout de montée en points de rêve
     let reveCout = ((this.tmrdata.isRapide && !EffetsDraconiques.isDeplacementAccelere(this.actor)) ? -2 : -1) - this.actor.countMonteeLaborieuse();
+    if (ReglesOptionelles.isUsing("appliquer-fatigue")){
       this.cumulFatigue += this.fatigueParCase;
+    }
     await this.actor.reveActuelIncDec(reveCout);
 
     // Le reste...
@@ -245,10 +249,12 @@ export class RdDTMRDialog extends Dialog {
     let refoulement = document.getElementById("tmr-refoulement-value");
     refoulement.innerHTML = actorData.data.reve.refoulement.value;
 
+    if (ReglesOptionelles.isUsing("appliquer-fatigue")){
       let fatigueItem = document.getElementById("tmr-fatigue-table");
       //console.log("Refresh : ", actorData.data.sante.fatigue.value);
       fatigueItem.innerHTML = "<table class='table-fatigue'>" + RdDUtility.makeHTMLfatigueMatrix(actorData.data.sante.fatigue.value, actorData.data.sante.endurance.max).html() + "</table>";
     }
+  }
 
   /* -------------------------------------------- */
   close() {
@@ -333,7 +339,7 @@ export class RdDTMRDialog extends Dialog {
       return true;
     }
     const resteAvantInconscience = this.actor.getFatigueMax() - this.actor.getFatigueActuelle() - this.cumulFatigue;
-    if (resteAvantInconscience <= 0) {
+    if (ReglesOptionelles.isUsing("appliquer-fatigue") && resteAvantInconscience <= 0) {
       this._tellToGM("Vous vous écroulez de fatigue : vous quittez les Terres médianes !");
       this.quitterLesTMRInconscient();
       return true;
@@ -408,7 +414,9 @@ export class RdDTMRDialog extends Dialog {
     else if (rencData.rolled.isEchec && rencData.rencontre.isPersistant) {
       setTimeout(() => {
         rencData.nbRounds++;
+        if (ReglesOptionelles.isUsing("appliquer-fatigue")){
           this.cumulFatigue += this.fatigueParCase;
+        }
         this._tentativeMaitrise(rencData);
         this._deleteTmrMessages(rencData.actor, rencData.nbRounds);
       }, 2000);
@@ -916,7 +924,9 @@ export class RdDTMRDialog extends Dialog {
     await this.actor.updateCoordTMR(tmr.coord);
 
     this._updateDemiReve();
+    if (ReglesOptionelles.isUsing("appliquer-fatigue")){
       this.cumulFatigue += this.fatigueParCase;
+    }
     this.updateValuesDisplay();
     game.socket.emit("system.foundryvtt-reve-de-dragon", {
       msg: "msg_tmr_move", data: {

module/rdd-utility.js

@@ -6,6 +6,7 @@ import { Misc } from "./misc.js";
 import { Grammar } from "./grammar.js";
 import { TMRUtility } from "./tmr-utility.js";
 import { DialogItemAchat } from "./dialog-item-achat.js";
+import { ReglesOptionelles } from "./regles-optionelles.js";
 
 /* -------------------------------------------- */
 // This table starts at 0 -> niveau -10
@@ -388,6 +389,14 @@ export class RdDUtility {
     }
     return -7;
   }
+
+  static calculFatigueHtml(fatigue, endurance) {
+    return ReglesOptionelles.isUsing("appliquer-fatigue") ? {
+      malus: RdDUtility.calculMalusFatigue(fatigue, endurance),
+      html: "<table class='table-fatigue'>" + RdDUtility.makeHTMLfatigueMatrix(fatigue, endurance).html() + "</table>"
+    } : { malus:0, html:''};
+  }
+
   /* -------------------------------------------- */
   // Build the nice (?) html table used to manage fatigue.
   // max should be the endurance max value
@@ -475,6 +484,7 @@ export class RdDUtility {
 
   /* -------------------------------------------- */
   static currentFatigueMalus(value, max) {
+    if (ReglesOptionelles.isUsing("appliquer-fatigue")) {
       max = Math.max(1, Math.min(max, 60));
       value = Math.min(max * 2, Math.max(0, value));
       
@@ -488,6 +498,8 @@ export class RdDUtility {
       }
       return -7; // This is the max !
     }
+    return 0;
+  }
 
   /* -------------------------------------------- */
   static async loadCompendiumData(compendium) {

module/regles-optionelles.js

@@ -1,13 +1,15 @@
+import { Misc } from "./misc.js";
 
 const listeReglesOptionelles = [
-  { name: 'recul', group: 'combat', descr: "Appliquer le recul en cas de particulière en force ou de charge" },
+  { name: 'recul', group: 'Règles de combat', descr: "Appliquer le recul en cas de particulière en force ou de charge" },
-  { name: 'resistanceArmeParade', group: 'combat', descr: "Faire le jet de résistance des armes lors de parades pouvant les endommager" },
+  { name: 'resistanceArmeParade', group: 'Règles de combat', descr: "Faire le jet de résistance des armes lors de parades pouvant les endommager" },
-  { name: 'deteriorationArmure', group: 'combat', descr: "Tenir compte de la détérioration des armures" },
+  { name: 'deteriorationArmure', group: 'Règles de combat', descr: "Tenir compte de la détérioration des armures" },
-  { name: 'defenseurDesarme', group: 'combat', descr: "Le défenseur peut être désarmé en parant une particulière en force ou une charge avec une arme autre qu'un bouclier" },
+  { name: 'defenseurDesarme', group: 'Règles de combat', descr: "Le défenseur peut être désarmé en parant une particulière en force ou une charge avec une arme autre qu'un bouclier" },
-  { name: 'categorieParade', group: 'combat', descr: "Le défenseur doit obtenir une significative en cas de parade avec des armes de catégories différentes" },
+  { name: 'categorieParade', group: 'Règles de combat', descr: "Le défenseur doit obtenir une significative en cas de parade avec des armes de catégories différentes" },
-  { name: 'tripleSignificative', group: 'combat', descr: "En cas de demi-surprise, d'attaque particulière en finesse, et de catégories d'armes différentes, le défenseur doit obtenir 1/8 des chances de succès" },
+  { name: 'tripleSignificative', group: 'Règles de combat', descr: "En cas de demi-surprise, d'attaque particulière en finesse, et de catégories d'armes différentes, le défenseur doit obtenir 1/8 des chances de succès" },
-  { name: 'astrologie', group: 'generale', descr: "Appliquer les ajustements astrologiques aux jets de chance et aux rituels", default: true },
+  { 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: 'generale', descr: "Afficher le prix de l'équipement des joueurs", 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 },
 ];
 
 export class ReglesOptionelles extends FormApplication {
@@ -39,25 +41,27 @@ export class ReglesOptionelles extends FormApplication {
   static get defaultOptions() {
     const options = super.defaultOptions;
     mergeObject(options, {
-      id: "combat-settings",
+      id: "optional-settings",
       template: "systems/foundryvtt-reve-de-dragon/templates/regles-optionelles.html",
       height: 600,
       width: 350,
       minimizable: false,
       closeOnSubmit: true,
-      title: "Options de combat"
+      title: "Règles optionnelles"
     });
     return options;
   }
 
   getData() {
     let formData = super.getData();
-    formData.regles = listeReglesOptionelles.map(it => {
+    const regles = listeReglesOptionelles.map(it => {
-      let r = duplicate(it);
+      it = duplicate(it);
-      r.id = ReglesOptionelles._getIdRegle(r.name);
+      it.id = ReglesOptionelles._getIdRegle(it.name);
-      r.active = ReglesOptionelles.isUsing(r.name);
+      it.active = ReglesOptionelles.isUsing(it.name);
-      return r;
+      return it;
-    })
+    });
+    formData.regles = regles;
+    formData.groups = Misc.classify(regles, it => it.group);
     return formData;
   }
 

templates/actor-sheet.html

@@ -28,7 +28,7 @@
               </label>
             </li>
             <li>
-              <label class="ctn-fatigue tooltip">
+              <label class="appliquerFatigue ctn-fatigue tooltip">
                 <span class="tooltiptext ttt-fatigue">{{{calc.fatigue.html}}}</span>
                 Fatigue
                 <a id="fatigue-moins">-</a>
@@ -66,7 +66,7 @@
               {{/if}}
             </div>
             <div class="flexrow">
-              <span class="tooltip tooltip-dotted">Malus de fatigue : {{calc.fatigue.malus}}
+              <span class="appliquerFatigue tooltip tooltip-dotted">Malus de fatigue : {{calc.fatigue.malus}}
                 <span class="tooltiptext ttt-fatigue">{{{calc.fatigue.html}}}</span>
               </span>
               <span>{{calc.resumeBlessures}}</span>

templates/chat-resultat-tache.html

@@ -8,7 +8,7 @@
 <div>
   Après {{tache.data.periodicite}} vous avez obtenu {{rolled.ptTache}} point{{~#if (gt rolled.ptTache 1)}}s{{/if}} de tâche,
    votre avancement est de <span class="rdd-roll-{{#if (gt tache.data.points_de_tache_courant 0)}}norm{{else}}etotal{{/if}}">{{tache.data.points_de_tache_courant}} sur {{tache.data.points_de_tache}}</span> point{{~#if (gt tache.data.points_de_tache_courant 1)}}s{{/if}} de tâche.
-  {{#if tache.data.fatigue}}<br><span>Vous vous êtes fatigué de {{tache.data.fatigue}} case{{~#if (gt tache.data.fatigue 1)}}s{{/if}}.</span>{{/if}}
+  {{#if (and tache.data.fatigue appliquerFatigue)}}<br><span>Vous vous êtes fatigué de {{tache.data.fatigue}} case{{~#if (gt tache.data.fatigue 1)}}s{{/if}}.</span>{{/if}}
   {{#if rolled.isETotal}}<br><span>Votre échec total augmente de 1 la difficulté de la tâche!</span>{{/if~}}
   {{> "systems/foundryvtt-reve-de-dragon/templates/chat-info-appel-au-moral.html"}}
 </div>

templates/dialog-tmr.html

@@ -33,7 +33,7 @@
       <div class="flex-group-center">
         <label>Refoulement : </label><span id="tmr-refoulement-value">0</span>
       </div>
-      <div class="flex-group-center flex-actions-bar">
+      <div class="flex-group-center flex-actions-bar appliquerFatigue">
         Fatigue 
         <span id="tmr-fatigue-table">{{{fatigue.html}}}</span>
       </div>

templates/regles-optionelles.html

@@ -1,21 +1,13 @@
 <form autocomplete="off" onsubmit="event.preventDefault();">
-  <h3>Règles de combat</h3>
+  {{#each groups as |group key|}}
+  <h3>{{key}}</h3>
   <ul>
-  {{#each regles as |regle key|}}
+    {{#each group as |regle r|}}
-    {{#if (eq regle.group 'combat')}}
     <li>
       <input class="select-option" type="checkbox" name="{{regle.id}}" {{#if regle.active}}checked{{/if}}/>
       <label>{{regle.descr}}</label>
     </li>
-    {{/if}}
     {{/each}}
-  <h3>Autres règles</h3>
+  </ul>
-  {{#each regles as |regle key|}}
-    {{#if (eq regle.group 'generale')}}
-    <li>
-      <input class="select-option" type="checkbox" name="{{regle.id}}" {{#if regle.active}}checked{{/if}}/>
-      <label>{{regle.descr}}</label>
-    </li>
-    {{/if}}
   {{/each}}
 </form>