From 96c6936c3e5f7f26a9a4c8fd25f259f318e0a1f1 Mon Sep 17 00:00:00 2001
From: Vincent Vandemeulebrouck <vincent.vandemeulebrouck@itiviti.com>
Date: Sat, 3 Apr 2021 23:51:25 +0200
Subject: [PATCH 1/3] =?UTF-8?q?Fix:=20message=20pour=20non=20haut-r=C3=AAv?=
 =?UTF-8?q?ant?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 templates/actor-sheet.html | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/templates/actor-sheet.html b/templates/actor-sheet.html
index f25e230d..98f99d1e 100644
--- a/templates/actor-sheet.html
+++ b/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}}

From f087b61c279778cd4965250324862d1293496351 Mon Sep 17 00:00:00 2001
From: Vincent Vandemeulebrouck <vincent.vandemeulebrouck@itiviti.com>
Date: Sat, 3 Apr 2021 23:59:29 +0200
Subject: [PATCH 2/3] =?UTF-8?q?Demi-surprise:=20R=C3=A9ussite=20normale=20?=
 =?UTF-8?q?=3D>=20=C3=A9chec=20#181?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

En demi-surprise, les résultats "réussite normaux" sont
maintenant présenté comme des réussite insuffisantes
---
 module/rdd-combat.js           | 23 +------------------
 module/rdd-resolution-table.js | 40 ++++++++++++++++++----------------
 module/rdd-roll.js             | 23 +++++++++++++++++--
 styles/simple.css              |  2 +-
 4 files changed, 44 insertions(+), 44 deletions(-)

diff --git a/module/rdd-combat.js b/module/rdd-combat.js
index cc0a6748..97b10eaf 100644
--- a/module/rdd-combat.js
+++ b/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);
diff --git a/module/rdd-resolution-table.js b/module/rdd-resolution-table.js
index ca5376a9..e1b373d7 100644
--- a/module/rdd-resolution-table.js
+++ b/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,23 +271,23 @@ 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;
     cell.etotal = cell.etotal > 100 ? 'N/A' : cell.etotal;
     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>
+    `
   }
 
   /* -------------------------------------------- */
diff --git a/module/rdd-roll.js b/module/rdd-roll.js
index 4f796a60..878d4174 100644
--- a/module/rdd-roll.js
+++ b/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
@@ -63,14 +64,33 @@ export class RdDRoll extends Dialog {
       surprise: actor.getSurprise(false),
       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)) {
diff --git a/styles/simple.css b/styles/simple.css
index 7b875ce2..c76e8e8a 100644
--- a/styles/simple.css
+++ b/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));
 }

From 4aaa72ed1a74d274b624a337e18cf62d28ae9d33 Mon Sep 17 00:00:00 2001
From: Vincent Vandemeulebrouck <vincent.vandemeulebrouck@itiviti.com>
Date: Sun, 4 Apr 2021 00:16:49 +0200
Subject: [PATCH 3/3] =?UTF-8?q?Erreur=20si=20draconic=20sans=20=C3=AAtre?=
 =?UTF-8?q?=20haut-r=C3=AAvant?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 module/actor-sheet.js | 4 ++++
 module/actor.js       | 4 ++++
 2 files changed, 8 insertions(+)

diff --git a/module/actor-sheet.js b/module/actor-sheet.js
index 6d12a300..c8e575e0 100644
--- a/module/actor-sheet.js
+++ b/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;
   }
 
diff --git a/module/actor.js b/module/actor.js
index d3b47629..68b2fc60 100644
--- a/module/actor.js
+++ b/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;