Amélioration de la gestion de la surprise

changelog.md

@@ -3,19 +3,23 @@
 ## 13.0.9 - Le combat d'Illysis
 - Fix
   - La montée en TMR fonctionne
+- ajout d'un status "Force insuffisante"
 - Nouvelle fenêtre de jets de dés
+  - ajout du statut "Force insuffisante" aux acteurs si la 
+    force est insuffisante pour l'arme
   - avancement du mode attaque
     - choix de tactique
-    - choix des dommages mortel/non-mortel, affichage
+    - choix mortel/non-mortel pour les dommages
+    - affichage des dommages ajustés delon les choix
     - affichage du statut de surprise de l'attaquant
     - affichage du statut de surprise du défenseur
-    - prise en compte des significatives (force insuffisante, demi-surprises)
+    - prise en compte des significatives (demi-surprises)
   - avancement du mode défense
     - sélection esquive/parade
     - affichage du statut de surprise du défenseur
     - prise en compte des significatives (demi-surprises, armes disparates,
-      force insuffisante, particulière en finesse)
+      particulière en finesse)
-
+  - impossible de faire un jet "actif" en surprise totale (attaque, parade, ...)
 
 ## 13.0.8 - Le renouveau d'Illysis
 

css/foundryvtt-reve-de-dragon.css

@@ -564,6 +564,9 @@ select,
 .system-foundryvtt-reve-de-dragon .roll-dialog roll-choix roll-section roll-part-detail subline span.status-surprise img {
   filter: invert(0.8);
 }
+.system-foundryvtt-reve-de-dragon .roll-dialog roll-choix roll-section roll-part-detail subline label {
+  align-content: center;
+}
 .system-foundryvtt-reve-de-dragon .roll-dialog roll-section selected-numeric-value {
   display: flow;
   width: 2.5rem;

less/roll-dialog.less

@@ -95,7 +95,7 @@
       display: flex;
       flex-direction: column;
       grid-area: img;
-      img{
+      img {
         border: 0;
         padding: 1px;
         max-height: 3rem;
@@ -126,6 +126,9 @@
             filter: invert(0.8);
           }
         }
+        label {
+          align-content: center;
+        }
       }
     }
   }

module/rdd-combat.js

@@ -567,6 +567,9 @@ export class RdDCombat {
 
   /* -------------------------------------------- */
   static isParticuliere(rollData) {
+    if (rollData.ids) {
+      return rollData.rolled.isPart
+    }
     if (!rollData.attackerRoll && rollData.ajustements.surprise.used) {
       return false;
     }
@@ -575,6 +578,9 @@ export class RdDCombat {
 
   /* -------------------------------------------- */
   static isReussite(rollData) {
+    if (rollData.ids) {
+      return rollData.rolled.is
+    }
     switch (rollData.ajustements.surprise.used) {
       case 'totale': return false;
       case 'demi': return rollData.rolled.isSign;
@@ -971,14 +977,14 @@ export class RdDCombat {
 
     await RollDialog.create(rollData, {
       onRoll: (dialog) => {
-        this._onCloseRollDialog(),
+        dialog.close()
-          dialog.close()
       },
       customChatMessage: true,
       callbacks: [async (actor, rd) => {
         this.removeChatMessageActionsPasseArme(rd.passeArme)
         // defense:  esquive / arme de parade / competence de défense
-        await rd.active.actor.incDecItemUse(rd.current[PART_DEFENSE].defense?.id, !RdDCombat.isParticuliere(rd))
+        if (!RdDCombat.isParticuliere(rd))
+        await rd.active.actor.incDecItemUse(rd.current[PART_DEFENSE].defense?.id, )
         await this._onDefenseV2(rd)
       }]
     })

module/rdd-resolution-table.js

@@ -184,47 +184,15 @@ export class RdDResolutionTable {
     return Math.max(Math.floor(carac * (diff + 10) / 2), 1);
   }
 
-  /* -------------------------------------------- */
-  static isEchec(rollData) {
-    switch (rollData.surprise) {
-      case 'demi': return !rollData.rolled.isSign;
-      case 'totale': return true;
-    }
-    return rollData.rolled.isEchec;
-  }
-
-  /* -------------------------------------------- */
-  static isEchecTotal(rollData) {
-    if (rollData.arme && rollData.surprise == 'demi') {
-      return rollData.rolled.isEchec;
-    }
-    return rollData.rolled.isETotal;
-  }
-
-  /* -------------------------------------------- */
-  static isParticuliere(rollData) {
-    if (rollData.arme && rollData.surprise) {
-      return false;
-    }
-    return rollData.rolled.isPart;
-  }
-
-  /* -------------------------------------------- */
-  static isReussite(rollData) {
-    switch (rollData.surprise) {
-      case 'demi': return rollData.rolled.isSign;
-      case 'totale': return false;
-    }
-    return rollData.rolled.isSuccess;
-  }
-
   /* -------------------------------------------- */
   static computeReussite(chances, roll, diviseur) {
-    const reussite = reussites.find(x => x.condition(chances, roll));
+    const reussite = reussites.find(x => x.condition(chances, roll))
-    if (diviseur > 1 && reussite.code == 'norm') {
+    if (diviseur > 1 && reussite.isSuccess) {
-      return reussiteInsuffisante;
+      if (chances > roll * diviseur){
+        return reussiteInsuffisante
+      }
     }
-    return reussite;
+    return reussite
   }
 
   /* -------------------------------------------- */

module/roll/roll-basic-parts.mjs

@@ -1,4 +1,8 @@
 import { ActorToken } from "../actor-token.mjs"
+import { StatusEffects } from "../settings/status-effects.js"
+import { ROLL_MODE_ATTAQUE, ROLL_MODE_DEFENSE } from "./roll-constants.mjs"
+import { PART_ATTAQUE } from "./roll-part-attaque.mjs"
+import { PART_DEFENSE } from "./roll-part-defense.mjs"
 
 export class RollBasicParts {
 
@@ -11,6 +15,29 @@ export class RollBasicParts {
     }
   }
 
+  loadSurprises(rollData, mode) {
+    if (!rollData.mode.passif) {
+      this.loadSurprise(rollData.active, this.getForceRequiseActiveActor(rollData, mode))
+      this.loadSurprise(rollData.opponent, 0)
+    }
+  }
+
+  loadSurprise(who, forceRequise) {
+    if (who?.actor) {
+      foundry.utils.mergeObject(who,
+        StatusEffects.getActorEffetSurprise(who.actor, forceRequise),
+        { overwrite: true, inPlace: true })
+    }
+  }
+
+  getForceRequiseActiveActor(rollData, mode) {
+    switch (mode) {
+      case ROLL_MODE_ATTAQUE: return rollData.current[PART_ATTAQUE].attaque.forceRequise
+      case ROLL_MODE_DEFENSE: return rollData.current[PART_DEFENSE].forceRequise
+      default: return 0
+    }
+  }
+
   initFrom(rollData) {
     return {
       selected: {},

module/roll/roll-dialog.mjs

@@ -217,7 +217,7 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
     })
   }
 
-  
+
   static async create(rollData, rollOptions = {}) {
     const rollDialog = new RollDialog(rollData, rollOptions)
     rollDialog.render(true)
@@ -250,9 +250,6 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
   constructor(rollData, rollOptions) {
     super()
     this.rollData = rollData
-    // const callbacks = this.rollOptions.callbacks.map(c =>
-    //   r => r.activve.actor Promise.all(this.rollOptions.callbacks.map(async callback => await callback(rollData.active.actor, rollData)))
-    // )
     this.rollOptions = {
       callbacks: [
         async (actor, r) => await actor.appliquerAjoutExperience(r),
@@ -361,6 +358,7 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
 
     const modes = ROLL_MODE_TABS.filter(m => m.isAllowed(rollData) && m.visible(rollData))
       .map(m => m.toModeData(rollData))
+    BASIC_PARTS.loadSurprises(this.rollData, this.getSelectedMode().code)
     this.setModeTitle()
 
     const visibleRollParts = this.getActiveParts()

module/roll/roll-part-attaque.mjs

@@ -41,25 +41,25 @@ export class RollPartAttaque extends RollPartSelect {
 
   prepareContext(rollData) {
     const current = this.getCurrent(rollData)
-    current.defenseur = StatusEffects.getActorEffetSurprise(rollData.opponent?.actor, 0)
-    current.attaquant = StatusEffects.getActorEffetSurprise(rollData.active.actor, current.attaque.forceRequise)
     current.dmg = this.$dmgRollV2(rollData, current)
   }
 
   $dmgRollV2(rollData, current) {
     const actor = rollData.active.actor
-    const defender = rollData.opponent?.actor
+    const attaque = current.attaque
-    const dmgArme = RdDBonus.dmgArme(current.attaque.arme, current.attaque.dommagesArme)
+    const arme = attaque.arme
+    const dmgArme = RdDBonus.dmgArme(arme, attaque.dommagesArme)
+
     const dmg = {
       total: 0,
       dmgArme: dmgArme,
-      penetration: current.attaque.arme.penetration(),
+      penetration: arme.penetration(),
       dmgTactique: current.tactique?.dmg ?? 0,
       dmgParticuliere: 0, // TODO RdDBonus._dmgParticuliere(rollData),
-      dmgSurprise: current.surpriseDefenseur?.dmg ?? 0,
+      dmgSurprise: rollData.opponent?.surprise?.dmg ?? 0,
-      mortalite: RdDBonus.mortalite(current.dmg?.mortalite, current.attaque.arme.system.mortalite, defender?.isEntite()),
+      mortalite: RdDBonus.mortalite(current.dmg?.mortalite, arme.system.mortalite, rollData.opponent?.actor?.isEntite()),
-      dmgActor: RdDBonus.bonusDmg(actor, current.attaque.carac.key, dmgArme, current.attaque.forceRequise),
+      dmgActor: RdDBonus.bonusDmg(actor, attaque.carac.key, dmgArme, attaque.forceRequise),
-      dmgForceInsuffisante: Math.min(0, actor.getForce() - current.attaque.forceRequise)
+      dmgForceInsuffisante: Math.min(0, actor.getForce() - attaque.forceRequise)
     }
     dmg.total = dmg.dmgSurprise + dmg.dmgTactique + dmg.dmgArme + dmg.dmgActor + dmg.dmgParticuliere + dmg.dmgForceInsuffisante
     return dmg
@@ -71,8 +71,8 @@ export class RollPartAttaque extends RollPartSelect {
     if (current.tactique) {
       ajustements.push({ label: current.tactique.label, diff: current.tactique.attaque })
     }
-    if (current.surpriseDefenseur) {
+    if (rollData.opponent?.surprise) {
-      ajustements.push({ label: current.surpriseDefenseur.label, diff: current.surpriseDefenseur.attaque })
+      ajustements.push({ label: rollData.opponent.surprise.label, diff: rollData.opponent.surprise.attaque })
     }
     return ajustements
   }
@@ -115,7 +115,6 @@ export class RollPartAttaque extends RollPartSelect {
       switch (part.code) {
         case PART_CARAC: return part.filterCaracs(rollData, [current.attaque.carac.key])
         case PART_COMP: return part.filterComps(rollData, [current.attaque.comp?.name])
-        case PART_SIGN: return part.setArme(rollData, current.attaque.forceRequise, false)
       }
     }
     return undefined

module/roll/roll-part-defense.mjs

@@ -69,9 +69,6 @@ export class RollPartDefense extends RollPartSelect {
   }
 
   prepareContext(rollData) {
-    const current = this.getCurrent(rollData)
-    current.defenseur = StatusEffects.getActorEffetSurprise(rollData.active.actor, current.forceRequise)
-
     // current.dmg = this.$dmgRollV2(rollData, current)
   }
 
@@ -104,7 +101,7 @@ export class RollPartDefense extends RollPartSelect {
         case PART_CARAC: return part.filterCaracs(rollData, [current.carac])
         case PART_COMP: return part.filterComps(rollData, [current.comp?.name])
         case PART_DIFF: return part.setDiff(rollData, this.getDiffDefense(rollData))
-        case PART_SIGN: return part.setArme(rollData, current.forceRequise, this.isArmeDisparate(rollData))
+        case PART_SIGN: return part.setArmeDisparate(rollData, this.isArmeDisparate(rollData))
       }
     }
     return undefined

module/roll/roll-part-sign.mjs

@@ -39,8 +39,7 @@ export class RollPartSign extends RollPart {
     const isCombat = this.isCombat(rollData)
     const current = this.getCurrent(rollData)
     current.armeDisparate = isCombat && current.armeDisparate
-    current.forceRequise = current.forceRequise ?? 0
+    current.surprise = actor.getSurprise(isCombat) // TODO: could be from rollData.active.surprise??
-    current.surprise = actor.getSurprise(isCombat)
     current.reasons = actor.getEffects(it => StatusEffects.niveauSurprise(it) > 0).map(it => it.name)
     current.diviseur = 1
     if (current.surprise == 'demi') {
@@ -53,10 +52,6 @@ export class RollPartSign extends RollPart {
       current.diviseur *= 2
       current.reasons.push('Armes disparates')
     }
-    if (this.isForceInsuffisante(actor, current)) {
-      current.diviseur *= 2
-      current.reasons.push('Force insuffisante')
-    }
     if (this.isAttaqueFinesse(rollData)) {
       current.diviseur *= 2
       current.reasons.push('Particulière en finesse')
@@ -73,15 +68,6 @@ export class RollPartSign extends RollPart {
     return ROLL_MODE_DEFENSE == rollData.mode.current && rollData.attaque.particuliere == 'finesse'
   }
 
-  isForceInsuffisante(actor, current) {
-    if (actor?.isPersonnage()) {
-      const requise = current.forceRequise
-      const force = parseInt(actor.system.carac.force.value)
-      return requise > force
-    }
-    return false
-  }
-
   isParadeArmeDisparate(current) {
     return current.armeDisparate
   }
@@ -106,9 +92,7 @@ export class RollPartSign extends RollPart {
     })
   }
 
-  setArme(rollData, forceRequise, armeDisparate) {
+  setArmeDisparate(rollData, armeDisparate) {
-    const current = this.getCurrent(rollData)
+    this.getCurrent(rollData).armeDisparate = armeDisparate
-    current.armeDisparate = armeDisparate
-    current.forceRequise = forceRequise
   }
 }

templates/chat-demande-defense.hbs

@@ -49,45 +49,46 @@
             {{/if}}
           </a>
           <br>
-          {{/if}}
+          {{else}}
-          {{#each armes as |arme key|}}
+            {{#each armes as |arme key|}}
-            <a class='chat-card-button parer-button'
+              <a class='chat-card-button parer-button'
-              data-attackerId='{{../attackerId}}' data-defenderTokenId='{{../defenderToken.id}}' data-attackerTokenId='{{../attackerToken.id}}'
+                data-attackerId='{{../attackerId}}' data-defenderTokenId='{{../defenderToken.id}}' data-attackerTokenId='{{../attackerToken.id}}'
-              data-armeid='{{arme._id}}'>
+                data-armeid='{{arme._id}}'>
-              Parer avec {{arme.name}}
+                Parer avec {{arme.name}}
-              {{#if (or (eq ../attaqueCategorie 'tir') (eq ../attaqueCategorie 'lancer'))}}
+                {{#if (or (eq ../attaqueCategorie 'tir') (eq ../attaqueCategorie 'lancer'))}}
-              (difficulté à déterminer)
+                (difficulté à déterminer)
-              {{else}}à {{../diffLibre }}
+                {{else}}à {{../diffLibre }}
-              {{/if}}
+                {{/if}}
-              {{#if (eq arme.typeParade 'sign')}}
+                {{#if (eq arme.typeParade 'sign')}}
-              <span class="rdd-diviseur">&times;&frac12;</span>
+                <span class="rdd-diviseur">&times;&frac12;</span>
-              {{/if}}
+                {{/if}}
-              {{#if arme.nbUsage}}(Utilisations : {{arme.nbUsage}}){{/if}}
+                {{#if arme.nbUsage}}(Utilisations : {{arme.nbUsage}}){{/if}}
-            </a>
+              </a>
-            <br>
+              <br>
             {{/each}}
             {{#if mainsNues}}
-            <a class='chat-card-button parer-button'
+              <a class='chat-card-button parer-button'
-              data-attackerId='{{attackerId}}' data-defenderTokenId='{{defenderToken.id}}' data-attackerTokenId='{{attackerToken.id}}'
+                data-attackerId='{{attackerId}}' data-defenderTokenId='{{defenderToken.id}}' data-attackerTokenId='{{attackerToken.id}}'
-              data-armeid='{{arme._id}}' data-competence='{{arme.system.competence}}'>
+                data-armeid='{{arme._id}}' data-competence='{{arme.system.competence}}'>
-              Parer à mains nues à {{diffLibre}}{{#if arme.nbUsage}} (Utilisations : {{arme.nbUsage}}){{/if}}
+                Parer à mains nues à {{diffLibre}}{{#if arme.nbUsage}} (Utilisations : {{arme.nbUsage}}){{/if}}
-          </a>
+              </a>
-          <br>
+              <br>
-          {{/if}}
+            {{/if}}
-          {{#if (ne attaqueCategorie 'tir')}}
+            {{#if (ne attaqueCategorie 'tir')}}
-          {{#each esquives as |esquive key|}}
+              {{#each esquives as |esquive key|}}
-            <a class='chat-card-button esquiver-button' 
+                <a class='chat-card-button esquiver-button' 
-              data-attackerId='{{../attackerId}}' data-defenderTokenId='{{../defenderToken.id}}' data-attackerTokenId='{{../attackerToken.id}}'
+                  data-attackerId='{{../attackerId}}' data-defenderTokenId='{{../defenderToken.id}}' data-attackerTokenId='{{../attackerToken.id}}'
-              data-compid='{{esquive._id}}'  data-competence='{{esquive.name}}'>
+                  data-compid='{{esquive._id}}'  data-competence='{{esquive.name}}'>
-              {{esquive.name}}
+                  {{esquive.name}}
-              {{#if (or (eq ../attaqueCategorie 'tir') (eq ../attaqueCategorie 'lancer'))}}
+                  {{#if (or (eq ../attaqueCategorie 'tir') (eq ../attaqueCategorie 'lancer'))}}
-              (difficulté à déterminer)
+                  (difficulté à déterminer)
-              {{else}}à {{../diffLibre }}
+                  {{else}}à {{../diffLibre }}
-              {{/if}}
+                  {{/if}}
-              {{#if esquive.nbUsage}}(Utilisations : {{esquive.nbUsage}}){{/if}}
+                  {{#if esquive.nbUsage}}(Utilisations : {{esquive.nbUsage}}){{/if}}
-            </a>
+                </a>
-            <br>
+                <br>
-            {{/each}}
+              {{/each}}
+            {{/if}}
           {{/if}}
         {{/if}}
       {{/unless}}

templates/roll/roll-button.hbs

@@ -1,6 +1,14 @@
+{{#if (or rollData.mode.passif (ne rollData.active.surprise.key 'totale'))}}
 <button name="roll-dialog-button">Lancer
  {{rollData.current.carac.value}} à {{plusMoins rollData.current.totaldiff}}
   {{#if rollData.current.significative.used}}
     <span class="rdd-diviseur">&times;{{{rollData.current.significative.label}}}</span>
   {{/if}}
 </button>
+{{else}}
+<button name="roll-dialog-button" disabled>
+  <i class="fa-solid fa-ban"></i>
+  Surprise totale!
+  <i class="fa-solid fa-ban"></i>
+</button>
+{{/if}}

templates/roll/roll-part-attaque.hbs

@@ -28,22 +28,22 @@
       </label>
     {{/if}}
   </subline>
-  {{#if current.attaquant.effets}}
+  {{#if rollData.active.effets}}
   <subline>
     <span class="status-surprise">
-      Attaquant en&nbsp;<strong>{{lowerFirst current.attaquant.surprise.label}}</strong>:&nbsp;
+      Attaquant en&nbsp;<strong>{{lowerFirst rollData.active.surprise.label}}</strong>:&nbsp;
-      {{#each current.attaquant.effets as |effect|}}
+      {{#each rollData.active.effets as |effect|}}
         {{localize effect.name}}
         <img class="button-effect-img" src="{{effect.img}}" data-tooltip="{{localize effect.name}}" data-effect="{{effect.id}}"/>
       {{/each}}
     </span>
   </subline>
   {{/if}}
-  {{#if current.defenseur.surprise}}
+  {{#if rollData.opponent.surprise}}
   <subline>
     <span class="status-surprise">
-      Defenseur en&nbsp;<strong>{{lowerFirst current.defenseur.surprise.label}}</strong>:&nbsp;
+      Defenseur en&nbsp;<strong>{{lowerFirst rollData.opponent.surprise.label}}</strong>:&nbsp;
-      {{#each current.defenseur.effets as |effect|}}
+      {{#each rollData.opponent.effets as |effect|}}
         {{localize effect.name}}
         <img class="button-effect-img" src="{{effect.img}}" data-tooltip="{{localize effect.name}}" data-effect="{{effect.id}}"/>
       {{/each}}

templates/roll/roll-part-defense.hbs

@@ -7,11 +7,11 @@
       {{selectOptions refs.defenses selected=current.key valueAttr="key" labelAttr="label"}}
     </select>
   </subline>
-  {{#if current.defenseur.effets}}
+  {{#if rollData.active.effets}}
   <subline>
     <span class="status-surprise">
-      Defense en&nbsp;<strong>{{lowerFirst current.defenseur.surprise.label}}</strong>:&nbsp;
+      Defense en&nbsp;<strong>{{lowerFirst rollData.active.surprise.label}}</strong>:&nbsp;
-      {{#each current.defenseur.effets as  |effect|}}
+      {{#each rollData.active.effets as  |effect|}}
         {{localize effect.name}}
         <img class="button-effect-img" src="{{effect.img}}" data-tooltip="{{localize effect.name}}" data-effect="{{effect.id}}"/>
       {{/each}}