Nouveau roll-dialog: mode attaque / defense

module/roll/roll-part-attaque.mjs

@@ -1,12 +1,16 @@
-import { Grammar } from "../grammar.js"
+import { RdDBonus } from "../rdd-bonus.js"
+import { StatusEffects } from "../settings/status-effects.js"
 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 { PART_SIGN } from "./roll-part-sign.mjs"
+import { ROLLDIALOG_SECTION } from "./roll-part.mjs"
 
 export const PART_ATTAQUE = 'attaque'
 
+const TACTIQUES = RdDBonus.tactiques.filter(it => it.isTactique)
+
 export class RollPartAttaque extends RollPartSelect {
 
   get code() { return PART_ATTAQUE }
@@ -18,29 +22,71 @@ export class RollPartAttaque extends RollPartSelect {
     const refs = this.getRefs(rollData)
     const attaques = rollData.active.actor.listAttaques()
     refs.attaques = attaques.map(it => RollPartAttaque.$extractAttaque(it, rollData.active.actor))
-    if (refs.attaques.length>0){
+    refs.tactiques = TACTIQUES
+    if (refs.attaques.length > 0) {
       this.$selectAttaque(rollData)
     }
   }
 
   choices(refs) { return refs.attaques }
 
-  static $extractAttaque(action, actor) {
+  static $extractAttaque(attaque, actor) {
     return {
-      key: `${action.action}::${action.arme.id}::${action.comp.id}`,
-      label: action.name,
-      action: action,
-      arme: action.arme,
-      comp: action.comp,
+      key: `${attaque.action}::${attaque.name}`,
+      label: attaque.name,
+      attaque: attaque,
+      tactique: TACTIQUES[0],
     }
   }
 
+  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 dmgArme = RdDBonus.dmgArme(current.attaque.arme, current.attaque.dommagesArme)
+    const dmg = {
+      total: 0,
+      dmgArme: dmgArme,
+      penetration: current.attaque.arme.penetration(),
+      dmgTactique: current.tactique?.dmg ?? 0,
+      dmgParticuliere: 0, // TODO RdDBonus._dmgParticuliere(rollData),
+      dmgSurprise: current.surpriseDefenseur?.dmg ?? 0,
+      mortalite: RdDBonus.mortalite(current.dmg?.mortalite, current.attaque.arme.system.mortalite, defender?.isEntite()),
+      dmgActor: RdDBonus.bonusDmg(actor, current.attaque.carac.key, dmgArme, current.attaque.forceRequise),
+      dmgForceInsuffisante: Math.min(0, actor.getForce() - current.attaque.forceRequise)
+    }
+    dmg.total = dmg.dmgSurprise + dmg.dmgTactique + dmg.dmgArme + dmg.dmgActor + dmg.dmgParticuliere + dmg.dmgForceInsuffisante
+    return dmg
+  }
+
+  getAjustements(rollData) {
+    const current = this.getCurrent(rollData)
+    const ajustements = []
+    if (current.tactique) {
+      ajustements.push({ label: current.tactique.label, diff: current.tactique.attaque })
+    }
+    if (current.surpriseDefenseur) {
+      ajustements.push({ label: current.surpriseDefenseur.label, diff: current.surpriseDefenseur.attaque })
+    }
+    return ajustements
+  }
+
+
   $selectAttaque(rollData, key) {
-    this.selectByKey(rollData, key, 0)
+    this.selectByKey(rollData, key)
   }
 
   async _onRender(rollDialog, context, options) {
     const selectAttaque = rollDialog.element.querySelector(`roll-section[name="${this.code}"] select[name="select-attaque"]`)
+    const selectTactique = rollDialog.element.querySelector(`roll-section[name="${this.code}"] select[name="select-tactique"]`)
+    const checkMortalite = rollDialog.element.querySelector(`roll-section[name="${this.code}"] input[name="check-mortalite"]`)
+    const current = this.getCurrent(rollDialog.rollData)
 
     selectAttaque.addEventListener("change", e => {
       const selectOptions = e.currentTarget.options
@@ -49,18 +95,29 @@ export class RollPartAttaque extends RollPartSelect {
       rollDialog.setModeTitle()
       rollDialog.render()
     })
+
+    selectTactique.addEventListener("change", e => {
+      const selectOptions = e.currentTarget.options
+      const index = selectOptions.selectedIndex
+      current.tactique = RdDBonus.find(selectOptions[index]?.value)
+      rollDialog.render()
+    })
+
+    checkMortalite?.addEventListener("change", e => {
+      current.dmg.mortalite = (e.currentTarget.checked ? 'mortel' : 'non-mortel')
+      rollDialog.render()
+    })
   }
 
-  getExternalPartsFilter(partCode, rollData) {
+  impactOtherPart(part, rollData) {
     if (this.visible(rollData)) {
       const current = this.getCurrent(rollData)
-      switch (partCode) {
-        case PART_CARAC: return p => Grammar.equalsInsensitive(current.action.carac.key, p.key)
-        case PART_COMP: return p => p.label == current.comp?.name
+      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
   }
-
-
 }