Nouveau roll-dialog: mode attaque

README.md

@@ -12,8 +12,8 @@ Pseudo : LeRatierBretonnien
 
 Mainteneur/Développeur : LeRatierBretonnien
 Développeur : VincentVk
-Tests, Compendiums, Données: Fred, Fab, Grendel
-Styles/CSS : Mandar
+Tests, Compendiums, Données: Fred, Fab, Grendel, LeRatierBretonnien, VincentVk
+Styles/CSS : Mandar, VincentVk
 
 # Mentions Légales
 
@@ -23,6 +23,6 @@ La carte des Terres Médianes du Rêve est une illustration de **Jidus**, utilis
 Les silhouettes des créatures, humanoïdes et entités sont des illustrations de **Roland Barthélémy**, et sont utilisés dans le cadre de ce projet avec son aimable autorisation.
 Merci à eux !!
 
-Toute la propriété intellectuelle leur appartient, ce système est une adpatation destinée à fonctionner sous FoundryVTT.
+Toute la propriété intellectuelle leur appartient, ce système est une adaptation destinée à fonctionner sous FoundryVTT.
 
 L'ensemble du code est sous licence Creative Commons.

module/actor-sheet.js

@@ -49,7 +49,7 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
     });
     foundry.utils.mergeObject(formData.calc, {
       surenc: this.actor.computeMalusSurEncombrement(),
-      surprise: RdDBonus.find(this.actor.getSurprise(false)).descr,
+      surprise: RdDBonus.find(this.actor.getSurprise(false)).label,
       resumeBlessures: this.actor.computeResumeBlessure(this.actor.system.blessures),
       caracTotal: RdDCarac.computeTotal(this.actor.system.carac, this.actor.system.beaute),
       surEncombrementMessage: this.actor.isSurenc() ? "Sur-Encombrement!" : "",

module/rdd-bonus.js

@@ -1,20 +1,23 @@
 import { RdDPossession } from "./rdd-possession.js";
 
 const conditionsTactiques = [
-  { type: '', descr: '', dmg: 0, attaque: 0, parade: 0, esquive: true },
-  { type: 'charge', descr: 'Charge', dmg: 2, attaque: 4, parade: -4, esquive: false },
-  { type: 'feinte', descr: 'Feinte', dmg: 1, attaque: 1, parade: 0, esquive: true },
-  { type: 'pret', descr: 'prêt', dmg: 0, attaque: 0, parade: 0, esquive: true },
-  { type: 'demi', descr: 'Demi-surprise', dmg: 1, attaque: 0, parade: 0, esquive: true },
-  { type: 'totale', descr: 'Surprise totale', dmg: 10, attaque: 6, parade: 0, esquive: true },
+  { key: '', label: '', dmg: 0, attaque: 0, parade: 0, esquive: true, isTactique: false },
+  { key: 'normale', label: 'Attaque normale', dmg: 0, attaque: 0, parade: 0, esquive: true, isTactique: true },
+  { key: 'charge', label: 'Charge', dmg: 2, attaque: 4, parade: -4, esquive: false, isTactique: true },
+  { key: 'feinte', label: 'Feinte', dmg: 1, attaque: 1, parade: 0, esquive: true, isTactique: true },
+  { key: 'pret', label: 'prêt', dmg: 0, attaque: 0, parade: 0, esquive: true, isTactique: false },
+  { key: 'demi', label: 'Demi-surprise', dmg: 1, attaque: 0, parade: 0, esquive: true, isTactique: false },
+  { key: 'totale', label: 'Surprise totale', dmg: 10, attaque: 6, parade: 0, esquive: true, isTactique: false },
 ];
 
 /* -------------------------------------------- */
 export class RdDBonus {
-
+  static get tactiques(){
+    return conditionsTactiques.filter(it => it.isTactique)
+  }
   /* -------------------------------------------- */
   static find(condition) {
-    return conditionsTactiques.find(e => e.type == condition) || conditionsTactiques.find(e => e.type == 'pret');
+    return conditionsTactiques.find(e => e.key == condition) || conditionsTactiques[0];
   }
 
 
@@ -48,17 +51,17 @@ export class RdDBonus {
 
   /* -------------------------------------------- */
   static description(condition) {
-    return RdDBonus.find(condition).descr;
+    return RdDBonus.find(condition).label
   }
 
   /* -------------------------------------------- */
   static dmgBonus(condition) {
-    return RdDBonus.find(condition).dmg;
+    return RdDBonus.find(condition).dmg
   }
 
   /* -------------------------------------------- */
   static bonusAttaque(condition) {
-    return RdDBonus.find(condition).attaque;
+    return RdDBonus.find(condition).attaque
   }
 
   /* -------------------------------------------- */
@@ -66,7 +69,7 @@ export class RdDBonus {
     return RdDBonus.mortalite(rollData.dmg?.mortalite, rollData.arme?.system.mortalite, isEntiteIncarnee)
   }
 
-  static mortalite( mortaliteSelect, mortaliteArme, isEntiteIncarnee) {
+  static mortalite(mortaliteSelect, mortaliteArme, isEntiteIncarnee) {
     return isEntiteIncarnee ? "entiteincarnee"
       : mortaliteSelect
       ?? mortaliteArme

module/roll/roll-part-attaque.mjs

@@ -5,15 +5,11 @@ import { ROLL_MODE_ATTAQUE } from "./roll-constants.mjs"
 import { PART_CARAC } from "./roll-part-carac.mjs"
 import { PART_COMP } from "./roll-part-comp.mjs"
 import { RollPartSelect } from "./roll-part-select.mjs"
-import { ROLLDIALOG_SECTION, RollPart } from "./roll-part.mjs"
+import { ROLLDIALOG_SECTION } from "./roll-part.mjs"
 
 export const PART_ATTAQUE = 'attaque'
 
-const TACTIQUES = [
-  { key: "", label: "Attaque normale" },
-  { key: "charge", label: "Charge" },
-  { key: "feinte", label: "Feinte" },
-]
+const TACTIQUES = RdDBonus.tactiques.filter(it => it.isTactique)
 
 export class RollPartAttaque extends RollPartSelect {
 
@@ -39,7 +35,7 @@ export class RollPartAttaque extends RollPartSelect {
       key: `${action.action}::${action.name}`,
       label: action.name,
       action: action,
-      tactique: "",
+      tactique: TACTIQUES[0],
       arme: action.arme,
       comp: action.comp,
     }
@@ -47,16 +43,31 @@ export class RollPartAttaque extends RollPartSelect {
 
   prepareContext(rollData) {
     const current = this.getCurrent(rollData)
-    const defenseurSurpris = rollData.opponent?.actor?.getSurprise(true) ?? ''
-    current.defenseur = defenseurSurpris
+    const effetsSurprise = rollData.opponent?.actor?.getEffects(it => StatusEffects.niveauSurprise(it, true) > 0) ?? []
+    current.defenseur = effetsSurprise
       ? {
-        surprise: RdDBonus.find(defenseurSurpris),
-        effects: rollData.opponent.actor.getEffects(it => StatusEffects.niveauSurprise(it, true) > 0)
+        surprise: RdDBonus.find(rollData.opponent?.actor?.getSurprise(true)),
+        effects: effetsSurprise
       }
       : undefined
     current.dmg = this.dmgRollV2(rollData, current)
   }
 
+  getAjustements(rollData) {
+    const current = this.getCurrent(rollData)
+    const tactique = current.tactique
+    const surprise = current.defenseur?.surprise
+    const ajustements = []
+    if (tactique) {
+      ajustements.push({ label: tactique.label, diff: tactique.attaque })
+    }
+    if (surprise) {
+      ajustements.push({ label: surprise.label, diff: surprise.attaque })
+    }
+    return ajustements
+  }
+
+
   dmgRollV2(rollData, current) {
     const actor = rollData.active.actor
     const defender = rollData.opponent.actor
@@ -65,9 +76,9 @@ export class RollPartAttaque extends RollPartSelect {
       total: 0,
       dmgArme: dmgArme,
       penetration: current.arme.penetration(),
-      dmgTactique: RdDBonus.dmgBonus(current.tactique),
+      dmgTactique: current.tactique?.dmg ?? 0,
       dmgParticuliere: 0, // TODO RdDBonus._dmgParticuliere(rollData),
-      dmgSurprise: RdDBonus.dmgBonus(current.defenseur.surprise),
+      dmgSurprise: current.defenseur?.surprise.dmg,
       mortalite: RdDBonus.mortalite(current.dmg?.mortalite, current.arme.system.mortalite, defender?.isEntite()),
       dmgActor: RdDBonus.bonusDmg(actor, current.action.carac.key, dmgArme)
     }
@@ -96,7 +107,7 @@ export class RollPartAttaque extends RollPartSelect {
     selectTactique.addEventListener("change", e => {
       const selectOptions = e.currentTarget.options
       const index = selectOptions.selectedIndex
-      current.tactique = TACTIQUES[index].key
+      current.tactique = RdDBonus.find(selectOptions[index]?.value)
       rollDialog.render()
     })
 

module/rolldata-ajustements.js

@@ -121,7 +121,7 @@ export const referenceAjustements = {
   },
   tactique: {
     isUsed: (rollData, actor) => rollData.tactique,
-    getLabel: (rollData, actor) => RdDBonus.find(rollData.tactique).descr,
+    getLabel: (rollData, actor) => RdDBonus.find(rollData.tactique).label,
     getValue: (rollData, actor) => RdDBonus.find(rollData.tactique).attaque,
   },
   finesse: {
@@ -130,11 +130,11 @@ export const referenceAjustements = {
   },
   surprise: {
     isUsed: (rollData, actor) => actor.getSurprise(rollData.passeArme),
-    getDescr: (rollData, actor) => RdDBonus.find(actor.getSurprise()).descr
+    getDescr: (rollData, actor) => RdDBonus.find(actor.getSurprise()).label
   },
   attaqueDefenseurSurpris: {
     isUsed: (rollData, actor) => rollData.surpriseDefenseur,
-    getLabel: (rollData, actor) => RdDBonus.find(rollData.surpriseDefenseur).descr + (rollData.attackerRoll ? '' : ' défenseur'),
+    getLabel: (rollData, actor) => RdDBonus.find(rollData.surpriseDefenseur).label + (rollData.attackerRoll ? '' : ' défenseur'),
     getValue: (rollData, actor) => RdDBonus.find(rollData.surpriseDefenseur).attaque,
   },
   armeParade: {

templates/roll/roll-part-attaque.hbs

@@ -14,7 +14,7 @@
   <subline>
     <label for="select-tactique">Tactique:</label>
     <select name="select-tactique" {{#if rollData.mode.retry}}disabled{{/if}}>
-      {{selectOptions refs.tactiques selected=current.tactique valueAttr="key" labelAttr="label"}}
+      {{selectOptions refs.tactiques selected=current.tactique.key valueAttr="key" labelAttr="label"}}
     </select>
   </subline>
   <subline>
@@ -32,7 +32,7 @@
   </subline>
   {{#if current.defenseur.surprise}}
   <subline>
-      Defenseur en {{lowerFirst current.defenseur.surprise.descr}}
+      Defenseur en {{lowerFirst current.defenseur.surprise.label}}
       {{#each current.defenseur.effects as  |effect|}}
         <img class="button-effect-img" src="{{effect.img}}" data-tooltip="{{localize effect.name}}" data-effect="{{effect.id}}"/>
         {{localize effect.name}}