Merge branch 'roll-carac' into 'dev_1.1'

Roll carac

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

module/actor-sheet.js

@@ -263,12 +263,12 @@ export class RdDActorSheet extends ActorSheet {
       this.actor.rollCarac( caracName.toLowerCase() );
     });
 
-    html.find('#chance-actuel').click((event) => {
+    html.find('#chance-actuelle').click((event) => {
-      this.actor.rollCarac( 'chance-actuel' );
+      this.actor.rollCarac( 'chance-actuelle' );
     });
 
     html.find('#chance-appel').click((event) => {
-      this.actor.appelChance();
+      this.actor.rollAppelChance();
     });
 
     // Roll Skill
@@ -276,10 +276,12 @@ export class RdDActorSheet extends ActorSheet {
       let compName = event.currentTarget.text;
       this.actor.rollCompetence( compName);
     });
+
     // Points de reve actuel
     html.find('.ptreve-actuel a').click((event) => {
-      this.actor.rollCarac( 'reveActuel' );
+      this.actor.rollCarac( 'reve-actuel' );
     });
+
     // Roll Weapon1
     html.find('.arme-label a').click((event) => {
       let armeName = event.currentTarget.text;

module/actor.js

@@ -1355,61 +1355,90 @@ export class RdDActor extends Actor {
   }
   
   /* -------------------------------------------- */  
-  async rollCarac( caracName )
+  _createCallbackExperience() {
-  {
+    return {
-    let carac = this.getCaracByName(caracName);
+      condition: r => r.rolled.isPart && r.finalLevel < 0 && game.settings.get("core", "rollMode") != 'selfroll',
-    let rollData = { 
+      action: r => this._appliquerAjoutExperience(r)
-      selectedCarac: carac,
+    };
-      ajustementsConditions: CONFIG.RDD.ajustementsConditions,
+  }
-      difficultesLibres: CONFIG.RDD.difficultesLibres,
+
-      etat: this.data.data.compteurs.etat.value,       
+  async _appliquerAjoutExperience(rollData) {
-      finalLevel: 0,
+    // TODO: si pas de compétence, minimum 1 pour carac
-      diffConditions: 0,
+    // TODO: appliquer l'expérience automatiquement
-      diffLibre: 0,
+    let xpmsg = RdDResolutionTable.buildXpMessage(rollData.rolled, rollData.finalLevel);
-      malusArmureValue: (this.data.data.attributs) ? this.data.data.attributs.malusarmure.value : 0,
+    let message = ChatUtility.prepareChatMessage('gmroll', this.name);
-      surencMalusFlag: (this.data.data.compteurs.surenc.value < 0),
+    message.content = "<strong>" + rollData.selectedCarac.label + "</strong>"
-      surencMalusValue: this.data.data.compteurs.surenc.value,
+          + xpmsg;
-      surencMalusApply: false,
+    ChatMessage.create(message);
-      isNatation: false,
-      useEncForNatation: false
-    }
-    console.log(caracName, rollData);
-    let html = await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/dialog-roll-carac.html', rollData);
-    new RdDRollDialog("carac", html, rollData, this ).render(true);
   }
 
   /* -------------------------------------------- */  
-  async appelChance( )
+  async rollCarac( caracName )
   {
-    let rollData = { 
+    let rollData = { selectedCarac: this.getCaracByName(caracName) };
-      selectedCarac: this.getCaracByName('chance-actuelle'),
-      diffConditions: this.ajustementAstrologique()
-    }
 
-    const dialog = await RdDRoll.create(
+    const dialog = await RdDRoll.create(this, rollData,
-      'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-carac.html',
+      {html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-carac.html'},
-      this,
-      rollData,
       {
-        name: 'appelChance',
+        name: 'jet-'+caracName,
-        label: 'Appel à la chance',
+        label: 'Lancer : '+rollData.selectedCarac.label,
         callbacks: [
-          { action: rollData => this._appelChanceResultat(rollData) }
+          this._createCallbackExperience(),
+          { action: this._rollCaracResult }
         ]
       }
     );
     dialog.render(true);
   }
 
+  async _rollCaracResult(rollData) {
+    let rolled = rollData.rolled;
+
+    let resumeCompetence = (rollData.diffLibre + rollData.diffConditions);
+    let explications = "<br>Points de taches : " + rolled.ptTache;
+
+    // Final chat message
+    let chatOptions = {
+      content: "<strong>Test : " + rollData.selectedCarac.label + " / " + resumeCompetence + "</strong>"
+          + "<br>Difficultés <strong>libre : " + rollData.diffLibre + "</strong> / conditions : " + Misc.toSignedString(rollData.diffConditions) +" / état : " + rollData.etat
+          + RdDResolutionTable.explain(rolled)
+          + explications
+    }
+    
+    ChatUtility.chatWithRollMode(chatOptions, this.name)
+  }
+
+
   /* -------------------------------------------- */
-  _appelChanceResultat(rollData) {
+  async rollAppelChance( )
+  {
+    let rollData = { 
+      selectedCarac: this.getCaracByName('chance-actuelle'),
+      diffConditions: this.ajustementAstrologique()
+    }
+
+    const dialog = await RdDRoll.create(this, rollData,
+      { html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-carac.html'},
+      {
+        name: 'appelChance',
+        label: 'Appel à la chance',
+        callbacks: [
+          this._createCallbackExperience(),
+          { action: this._appelChanceResult }
+        ]
+      }
+    );
+    dialog.render(true);
+  }
+
+  _appelChanceResult(rollData) {
     const message = {
       user: game.user._id,
       alias: this.name,
       content: this.name + " fait appel à la chance" + RdDResolutionTable.explain(rollData.rolled)
     };
     if (rollData.rolled.isSuccess) {
-      message.content += "<br>Dépense d'un point de chance, l'action peut être retentée"
+      message.content += "<br>Un point de chance est dépensée, l'action peut être retentée"
       this.chanceActuelleIncDec(-1)
     }
     ChatMessage.create(message);
@@ -1432,7 +1461,7 @@ export class RdDActor extends Actor {
   getCaracByName(caracName) {
     switch (caracName)
     {
-      case 'reveActuel':
+      case 'reve-actuel':
         return {
           label: 'Rêve Actuel',
           value: this.getReveActuel(),
@@ -1631,6 +1660,7 @@ export class RdDActor extends Actor {
     let degatsReel = attackerRoll.degats - armure;
 
     let result = RdDUtility.computeBlessuresSante(degatsReel, attackerRoll.mortalite);
+    result.endurance = Math.max(result.endurance, -Number(this.data.data.sante.endurance.value));
     await this.santeIncDec("vie", result.vie);
     await this.santeIncDec("endurance", result.endurance, (result.critiques > 0));
     result.locName = (attackerRoll.loc) ?  attackerRoll.loc.label : "Corps";

module/chat-utility.js

@@ -6,7 +6,10 @@ export class ChatUtility {
 
   static chatWithRollMode(chatOptions, name) {
     let rollMode = game.settings.get("core", "rollMode");
-    chatOptions.user = game.user._id;
+    ChatUtility.createChatMessage(chatOptions, rollMode, name);
+  }
+
+  static createChatMessage( chatOptions, rollMode, name) {
     switch (rollMode) {
       case "blindroll": // GM only
         if (!game.user.isGM) {
@@ -19,24 +22,29 @@ export class ChatUtility {
           chatOptions.whisper = ChatUtility.getUsers(user => user.isGM);
         }
         break;
-      case "gmroll": // GM + rolling player
-        chatOptions.user = game.user._id;
-        chatOptions.whisper = ChatUtility.getWhisperRecipientsAndGMs(name);
-        break;
-      case "selfroll": // only the user
-        chatOptions.user = game.user._id;
-        chatOptions.whisper = [game.user._id];
-        break;
       default:
-      case "roll": // everybody
+        chatOptions.whisper = ChatUtility.getWhisperRecipients(rollMode, name);
-        chatOptions.whisper = undefined;
         break;
     }
-
-    console.log("roll message", chatOptions);
     ChatMessage.create(chatOptions);
   }
 
+  static prepareChatMessage( rollMode, name) {
+    return {
+      user: game.user._id,
+      whisper: ChatUtility.getWhisperRecipients(rollMode, name)
+    }
+  }
+
+  static getWhisperRecipients( rollMode, name) {
+    switch (rollMode) {
+      case "blindroll": return ChatUtility.getUsers(user => user.isGM);
+      case "gmroll": return ChatUtility.getWhisperRecipientsAndGMs(name);
+      case "selfroll": return [game.user._id];
+    }
+    return undefined;
+  }
+
   static getWhisperRecipientsAndGMs(name) {
     return ChatMessage.getWhisperRecipients(name)
       .concat(this.getUsers(user => user.isGM));

module/rdd-resolution-table.js

@@ -55,7 +55,7 @@ const reussites = [
 const reussiteSignificative = reussites.find(r => r.code == "sign");
 const reussiteNormale = reussites.find(r => r.code == "norm");
 const echecNormal = reussites.find(r => r.code == "echec");
-
+const caracMaximumResolution = 60;
 /* -------------------------------------------- */
 export class RdDResolutionTable {
   static resolutionTable = this.build()
@@ -63,7 +63,7 @@ export class RdDResolutionTable {
   /* -------------------------------------------- */
   static build() {
     let table = []
-    for (var caracValue = 0; caracValue <= 60; caracValue++) {
+    for (var caracValue = 0; caracValue <= caracMaximumResolution; caracValue++) {
       table[caracValue] = this._computeRow(caracValue);
     }
     return table;
@@ -84,7 +84,7 @@ export class RdDResolutionTable {
     if (rolled.caracValue != null && rolled.finalLevel!= null) {
       message += "(" + rolled.caracValue + " à " + Misc.toSignedString(rolled.finalLevel) + ") ";
     }
-    message += rolled.quality
+    message += '<strong>' + rolled.quality + '</strong>'
     return message;
 
   }
@@ -147,7 +147,6 @@ export class RdDResolutionTable {
     return "";
   }
 
-
   /* -------------------------------------------- */
   static _computeReussite(chances, roll) {
     const reussite = reussites.find(x => x.condition(chances, roll));
@@ -219,7 +218,7 @@ export class RdDResolutionTable {
   static _buildHTMLTable(caracValue, levelValue, minCarac, maxCarac, minLevel, maxLevel) {
     let countColonnes = maxLevel - minLevel;
     minCarac = Math.max(minCarac, 1);
-    maxCarac = Math.min(maxCarac, 30);
+    maxCarac = Math.min(maxCarac, caracMaximumResolution);
     minLevel = Math.max(minLevel, -10);
     maxLevel = Math.max(Math.min(maxLevel, 22), minLevel + countColonnes);
 

module/rdd-roll.js

@@ -10,17 +10,18 @@ import { RdDResolutionTable } from "./rdd-resolution-table.js";
 
 export class RdDRoll extends Dialog {
 
-  static async create(htmlTemplate, actor, rollData, ...actions) {
+  static async create(actor, rollData, dialogConfig, ...actions) {
-    RdDRoll._ensureCorrectActions(actions);
 
+    RdDRoll._ensureCorrectActions(actions);
     RdDRoll._setDefaultOptions(actor, rollData);
 
-    const html = await renderTemplate(htmlTemplate, rollData);
+    const html = await renderTemplate(dialogConfig.html, rollData);
 
-    return new RdDRoll(actor, rollData, html, {
+    let options = { classes: ["rdddialog"], width: 600, height: 500, 'z-index': 99999 };
-      classes: ["rdddialog"],
+    if (dialogConfig.options) {
-      width: 600, height: 500, 'z-index': 99999
+      mergeObject(options, dialogConfig.options, { overwrite: true })
-    }, actions);
+    }
+    return new RdDRoll(actor, rollData, html, options, actions);
   }
 
   static _setDefaultOptions(actor, rollData) {
@@ -33,8 +34,8 @@ export class RdDRoll extends Dialog {
         finalLevel: 0,
         diffConditions: 0,
         diffLibre: 0,
-        malusArmureValue: 0,
+        malusArmureValue: actor.data.data.attributs ? actor.data.data.attributs.malusarmure.value : 0,
-        surencMalusFlag: actor.data.data.attributs ? actor.data.data.attributs.malusarmure.value : 0,
+        surencMalusFlag: (actor.data.data.compteurs.surenc.value < 0),
         surencMalusValue: actor.data.data.compteurs.surenc.value,
         surencMalusApply: false,
         isNatation: false,
@@ -44,12 +45,12 @@ export class RdDRoll extends Dialog {
   }
 
   static _ensureCorrectActions(actions) {
-    if (actions.length==0) {
+    if (actions.length == 0) {
       throw 'No action defined';
     }
     actions.forEach(action => {
       if (action.callbacks == undefined) {
-        action.callbacks = [{action: r => console.log(action.name, r)}];
+        action.callbacks = [{ action: r => console.log(action.name, r) }];
       }
     });
   }
@@ -74,11 +75,11 @@ export class RdDRoll extends Dialog {
   async onAction(action, html) {
     await RdDResolutionTable.rollData(this.rollData);
     if (action.callbacks)
-    for (let callback of action.callbacks) {
+      for (let callback of action.callbacks) {
-      if (callback.condition == undefined || callback.condition(this.rollData.rolled)) {
+        if (callback.condition == undefined || callback.condition(this.rollData)) {
-        callback.action(this.rollData);
+          callback.action(this.rollData);
+        }
       }
-    }
   }
 
   /* -------------------------------------------- */

module/rdd-utility.js

@@ -396,17 +396,21 @@ export class RdDUtility  {
   {
     let xp = 0;
     for (let troncList of competenceTroncs) {
-      let minNiveau = 15;
+      let minNiveau = 0;
       for (let troncName of troncList) {
         let comp = RdDUtility.findCompetence( competenceList, troncName);
-        minNiveau = (comp.data.niveau < minNiveau) ? comp.data.niveau : minNiveau; 
+        if (comp) {
+          minNiveau = Math.min(comp.data.niveau, minNiveau); 
+        }
       }
-      if ( minNiveau > 0 ) minNiveau = 0; // Clamp à 0, pour le tronc commun
+      minNiveau = Math.max(minNiveau, 0); // Clamp à 0, pour le tronc commun
       let minNiveauXP = competence_xp_par_niveau[minNiveau+10];
       xp += minNiveauXP;
       for (let troncName of troncList) {
         let comp = RdDUtility.findCompetence( competenceList, troncName);
-        xp += competence_xp_par_niveau[comp.data.niveau+10] - minNiveauXP;
+        if (comp){
+          xp += competence_xp_par_niveau[comp.data.niveau+10] - minNiveauXP;
+        } 
       }
     }
     return xp;
@@ -569,9 +573,9 @@ export class RdDUtility  {
   /* -------------------------------------------- */
   static computeBlessuresSante( degats, mortalite="mortel" ) {
     let encaissement = RdDUtility.selectEncaissement(degats, mortalite)
-    let over20 =  degats > 20 ? degats - 20 : 0 
+    let over20 =  Math.max(degats - 20, 0);
-    encaissement.endurance = - RdDUtility._evaluatePerte(encaissement.endurance, over20)
+    encaissement.endurance = - RdDUtility._evaluatePerte(encaissement.endurance, over20);
-    encaissement.vie = - RdDUtility._evaluatePerte(encaissement.vie, over20)
+    encaissement.vie = - RdDUtility._evaluatePerte(encaissement.vie, over20);
     return encaissement;
   }