Merge branch 'master-demi-surprise' into 'master'

Demi-surprise: Réussite normale => échec #181

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

module/actor-sheet.js

@@ -126,6 +126,10 @@ export class RdDActorSheet extends ActorSheet {
       montures: this.actor.listeMontures(),
       suivants: this.actor.listeSuivants()
     }
+    if (this.actor.getBestDraconic().data.niveau > -11 && !this.actor.isHautRevant()) {
+      ui.notifications.error(`${this.actor.name} a des compétences draconiques, mais pas le don de Haut-Rêve!
+        <br>Ajoutez-lui la tête "Don de Haut-Rêve" pour lui permettre d'utiliser ses compétences et d'accéder aux terres médianes du rêve`);
+    }
     return formData;
   }
 

module/actor.js

@@ -157,6 +157,10 @@ export class RdDActor extends Actor {
     return this.data.type == 'personnage';
   }
   /* -------------------------------------------- */
+  isHautRevant() {
+    return Misc.templateData(this).attributs.hautrevant.value != ""
+  }
+  /* -------------------------------------------- */
   getFatigueActuelle() {
     if (!this.isPersonnage()) {
       return 0;

module/rdd-combat.js

@@ -666,7 +666,7 @@ export class RdDCombat {
   /* -------------------------------------------- */
   static isEchecTotal(rollData) {
     if (!rollData.attackerRoll && rollData.ajustements.surprise.used) {
-      return rollData.rolled.isEchec;
+      return rollData.rolled.isEchec && rollData.rolled.code != 'notSign';
     }
     return rollData.rolled.isETotal;
   }
@@ -731,7 +731,6 @@ export class RdDCombat {
       surpriseDefenseur: this.defender.getSurprise(true),
       essais: {}
     };
-    rollData.diviseurSignificative = this._getDiviseurSignificative(rollData);
 
     if (this.attacker.isCreature()) {
       RdDItemCompetenceCreature.setRollDataCreature(rollData);
@@ -974,7 +973,6 @@ export class RdDCombat {
       carac: this.defender.data.data.carac,
       show: {}
     };
-    defenderRoll.diviseurSignificative = this._getDiviseurSignificative(defenderRoll);
 
     if (this.defender.isCreature()) {
       RdDItemCompetenceCreature.setRollDataCreature(defenderRoll);
@@ -983,24 +981,6 @@ export class RdDCombat {
     return defenderRoll;
   }
 
-  /* -------------------------------------------- */
-  _getDiviseurSignificative(defenderRoll) {
-    let facteurSign = 1;
-    if (defenderRoll.surprise == 'demi') {
-      facteurSign *= 2;
-    }
-    if (defenderRoll.needParadeSignificative) {
-      facteurSign *= 2;
-    }
-    if (RdDBonus.isDefenseAttaqueFinesse(defenderRoll)) {
-      facteurSign *= 2;
-    }
-    if (!ReglesOptionelles.isUsing('tripleSignificative')) {
-      facteurSign = Math.min(facteurSign, 4);
-    }
-    return facteurSign;
-  }
-
   /* -------------------------------------------- */
   _onParadeParticuliere(defenderRoll) {
     console.log("RdDCombat._onParadeParticuliere >>>", defenderRoll);
@@ -1073,7 +1053,6 @@ export class RdDCombat {
       carac: this.defender.data.data.carac,
       show: {}
     };
-    rollData.diviseurSignificative = this._getDiviseurSignificative(rollData);
 
     if (this.defender.isCreature()) {
       RdDItemCompetenceCreature.setRollDataCreature(rollData);

module/rdd-resolution-table.js

@@ -51,10 +51,8 @@ const reussites = [
   { code: "error", isPart: false, isSign: false, isSuccess: false, isEchec: true, isEPart: true, isETotal: true, ptTache: 0, ptQualite: 0, quality: "Jet de dés invalide", condition: (target, roll) => (roll <= 0 || roll > 100) }
 ];
 
+const reussiteInsuffisante = { code: "notSign", isPart: false, isSign: false, isSuccess: false, isEchec: true, isEPart: false, isETotal: false, ptTache: 0, ptQualite: -2, quality: "Réussite insuffisante", condition: (target, roll) => false }
 /* -------------------------------------------- */
-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 {
@@ -115,7 +113,7 @@ export class RdDResolutionTable {
     this._updateChancesFactor(chances, diviseur);
     chances.showDice = showDice;
 
-    let rolled = await this.rollChances(chances);
+    let rolled = await this.rollChances(chances, diviseur);
     rolled.caracValue = caracValue;
     rolled.finalLevel = finalLevel;
     rolled.bonus = bonus;
@@ -150,12 +148,12 @@ export class RdDResolutionTable {
   }
 
   /* -------------------------------------------- */
-  static async rollChances(chances) {
+  static async rollChances(chances, diviseur) {
     let myRoll = new Roll("1d100").roll();
     myRoll.showDice = chances.showDice;
     await RdDDice.show(myRoll);
     chances.roll = myRoll.total;
-    mergeObject(chances, this.computeReussite(chances, chances.roll), { overwrite: true });
+    mergeObject(chances, this.computeReussite(chances, chances.roll, diviseur), { overwrite: true });
     return chances;
   }
 
@@ -216,8 +214,12 @@ export class RdDResolutionTable {
   }
 
   /* -------------------------------------------- */
-  static computeReussite(chances, roll) {
-    return reussites.find(x => x.condition(chances, roll));
+  static computeReussite(chances, roll, diviseur) {
+    const reussite = reussites.find(x => x.condition(chances, roll));
+    if (diviseur > 1 && reussite.code == 'norm') {
+      return reussiteInsuffisante;
+    }
+    return reussite;
   }
 
   /* -------------------------------------------- */
@@ -269,8 +271,8 @@ export class RdDResolutionTable {
 
   /* -------------------------------------------- */
   static buildHTMLResults(caracValue, levelValue) {
-    if ( caracValue == undefined || isNaN(caracValue )) caracValue = 10;
-    if ( levelValue == undefined || isNaN(levelValue )) levelValue = 0;
+    if (caracValue == undefined || isNaN(caracValue)) caracValue = 10;
+    if (levelValue == undefined || isNaN(levelValue)) levelValue = 0;
 
     let cell = this.computeChances(caracValue, levelValue);
     cell.epart = cell.epart > 99 ? 'N/A' : cell.epart;
@@ -278,14 +280,14 @@ export class RdDResolutionTable {
     cell.score = Math.min(cell.score, 99);
 
     return `
-<span class="table-proba-reussite competence-label">
-Particulière: <span class="rdd-roll-part">${cell.part}</span>
-- Significative: <span class="rdd-roll-sign">${cell.sign}</span>
-- Réussite: <span class="rdd-roll-norm">${cell.score}</span>
-- Echec Particulier: <span class="rdd-roll-epart">${cell.epart}</span>
-- Echec Total: <span class="rdd-roll-etotal">${cell.etotal}</span>
-</span>
-`
+    <span class="table-proba-reussite competence-label">
+    Particulière: <span class="rdd-roll-part">${cell.part}</span>
+    - Significative: <span class="rdd-roll-sign">${cell.sign}</span>
+    - Réussite: <span class="rdd-roll-norm">${cell.score}</span>
+    - Echec Particulier: <span class="rdd-roll-epart">${cell.epart}</span>
+    - Echec Total: <span class="rdd-roll-etotal">${cell.etotal}</span>
+    </span>
+    `
   }
 
   /* -------------------------------------------- */

module/rdd-roll.js

@@ -7,6 +7,7 @@ import { Misc } from "./misc.js";
 import { RdDBonus } from "./rdd-bonus.js";
 import { RdDCarac } from "./rdd-carac.js";
 import { RdDResolutionTable } from "./rdd-resolution-table.js";
+import { ReglesOptionelles } from "./regles-optionelles.js";
 
 /**
  * Extend the base Dialog entity to select roll parameters
@@ -64,13 +65,32 @@ export class RdDRoll extends Dialog {
       canClose: true
     };
     
-    
     mergeObject(rollData, defaultRollData, { recursive: true, overwrite: false });
     if (rollData.forceCarac) {
       rollData.carac = rollData.forceCarac;
     }
+    rollData.diviseurSignificative = RdDRoll.getDiviseurSignificative(rollData);
+
     RollDataAjustements.calcul(rollData, actor);
   }
+  /* -------------------------------------------- */
+  static getDiviseurSignificative(rollData) {
+    let facteurSign = 1;
+    if (rollData.surprise == 'demi') {
+      facteurSign *= 2;
+    }
+    if (rollData.needParadeSignificative) {
+      facteurSign *= 2;
+    }
+    if (RdDBonus.isDefenseAttaqueFinesse(rollData)) {
+      facteurSign *= 2;
+    }
+    if (!ReglesOptionelles.isUsing('tripleSignificative')) {
+      facteurSign = Math.min(facteurSign, 4);
+    }
+    return facteurSign;
+  }
+
 
   /* -------------------------------------------- */
   static _ensureCorrectActions(actions) {
@@ -122,7 +142,6 @@ export class RdDRoll extends Dialog {
     await RdDResolutionTable.rollData(this.rollData);
     console.log("RdDRoll -=>", this.rollData, this.rollData.rolled);
     this.actor.setRollWindowsOpened(false);
-
     if (action.callbacks)
       for (let callback of action.callbacks) {
         if (callback.condition == undefined || callback.condition(this.rollData)) {

styles/simple.css

@@ -406,7 +406,7 @@ table {border: 1px solid #7a7971;}
   border-radius: 6px; padding: 3px;
   background:linear-gradient(30deg, rgba(7, 76, 0, 0.3), rgba(66, 163, 65, 0.2), rgba(184, 226, 163, 0.1), rgba(66, 163, 65, 0.2), rgba(184, 226, 163, 0.3));
 }
-.rdd-roll-echec{
+.rdd-roll-notSign, .rdd-roll-echec{
   border-radius: 6px; padding: 3px;
   background-image: linear-gradient(150deg, rgba(255, 0, 0, 0.3), rgba(255, 200, 128, 0.05),rgba(255, 200, 128, 0.1), rgba(255,10,0,0.3));
 }

templates/actor-sheet.html

@@ -557,6 +557,8 @@
         <div>
           {{#if data.attributs.hautrevant.value}}
           <h3>Haut rêvant</h3>
+          {{else}}
+          <h3>Vous n'avez pas le don de haut-rêve!</h3>
           {{/if}}
           <ul class="item-list">
             {{#if data.attributs.hautrevant.value}}