Nouveau roll-dialog: mode attaque / defense

module/roll/roll-part-defense.mjs

@@ -1,17 +1,133 @@
-import { ROLL_MODE_DEFENSE } from "./roll-constants.mjs"
-import { ROLLDIALOG_SECTION, RollPart } from "./roll-part.mjs"
+import { ITEM_TYPES } from "../constants.js"
+import { Grammar } from "../grammar.js"
+import { ATTAQUE_TYPE, RdDItemArme } from "../item/arme.js"
+import { RdDBonus } from "../rdd-bonus.js"
+import { CARACS } from "../rdd-carac.js"
+import { StatusEffects } from "../settings/status-effects.js"
+import { DIFF_MODE, ROLL_MODE_DEFENSE } from "./roll-constants.mjs"
+import { PART_CARAC } from "./roll-part-carac.mjs"
+import { PART_COMP } from "./roll-part-comp.mjs"
+import { PART_DIFF } from "./roll-part-diff.mjs"
+import { RollPartSelect } from "./roll-part-select.mjs"
+import { PART_SIGN } from "./roll-part-sign.mjs"
+import { ROLLDIALOG_SECTION } from "./roll-part.mjs"
 
 export const PART_DEFENSE = 'defense'
 
-export class RollPartDefense extends RollPart {
+export class RollPartDefense extends RollPartSelect {
 
   get code() { return PART_DEFENSE }
   get section() { return ROLLDIALOG_SECTION.CHOIX }
   visible(rollData) { return this.isRollMode(rollData, ROLL_MODE_DEFENSE) }
 
-  loadRefs(rollData) {
-    const refs = this.getRefs(rollData)
-    refs.defenses =[]
+  static getDiffAttaque(attackerRoll) {
+    // TODO: rollDataV2?
+    return attackerRoll.diffLibre;
   }
 
+  loadRefs(rollData) {
+    const refs = this.getRefs(rollData)
+    const attaque = rollData.attaque
+    const defenseur = rollData.active.actor
+    refs.isDistance = [ATTAQUE_TYPE.TIR, ATTAQUE_TYPE.LANCER].find(it => it == attaque?.main)
+    const esquives = refs.isDistance == ATTAQUE_TYPE.TIR ? [] : defenseur.getCompetencesEsquive()
+      .map(it => RollPartDefense.$extractEsquive(it, defenseur))
+
+    const parades = defenseur.items.filter(it => it.isParade() && (!refs.isDistance || it.isBouclier()))
+      .map(it => RollPartDefense.$extractParade(it, attaque?.attaque.arme, defenseur))
+
+    refs.defenses = [...esquives, ...parades].filter(it => it != undefined)
+    this.$selectDefense(rollData)
+  }
+
+  static $extractEsquive(esquive, defenseur) {
+    return {
+      key: esquive.id,
+      label: esquive.name,
+      img: esquive.img,
+      // TODO: carac pour créatures
+      carac: defenseur.isPersonnage() ? CARACS.DEROBEE : esquive.name,
+      comp: esquive
+    }
+  }
+
+  static $extractParade(armeDefense, armeAttaque, defenseur) {
+    const comp = (ITEM_TYPES.competencecreature == armeDefense.type)
+      ? armeDefense
+      : defenseur.getCompetence(armeDefense.system.competence)
+    return {
+      key: armeDefense.id,
+      label: 'Parade ' + armeDefense.name,
+      img: armeDefense.img,
+      // TODO: carac pour créatures
+      carac: defenseur.isPersonnage() ? CARACS.MELEE : comp.name,
+      comp: comp,
+      arme: armeDefense,
+      forceRequise: armeDefense ? RdDItemArme.valeurMain(armeDefense.system.force ?? 0, RdDItemArme.getMainAttaque(comp)) : 0,
+      typeParade: armeAttaque ? RdDItemArme.defenseArmeParade(armeDefense, armeAttaque) : 'norm'
+    }
+  }
+
+  prepareContext(rollData) {
+    const current = this.getCurrent(rollData)
+    current.defenseur = StatusEffects.getActorEffetSurprise(rollData.active.actor, current.forceRequise)
+
+    // current.dmg = this.$dmgRollV2(rollData, current)
+  }
+
+  getAjustements(rollData) {
+    return []
+  }
+
+  choices(refs) { return refs.defenses }
+
+  $selectDefense(rollData, key) {
+    this.selectByKey(rollData, key)
+  }
+
+  async _onRender(rollDialog, context, options) {
+    const selectDefense = rollDialog.element.querySelector(`roll-section[name="${this.code}"] select[name="select-defense"]`)
+
+    selectDefense.addEventListener("change", e => {
+      const selectOptions = e.currentTarget.options
+      const index = selectOptions.selectedIndex
+      this.$selectDefense(rollDialog.rollData, selectOptions[index]?.value)
+      rollDialog.setModeTitle()
+      rollDialog.render()
+    })
+  }
+
+  impactOtherPart(part, rollData) {
+    if (this.visible(rollData)) {
+      const current = this.getCurrent(rollData)
+      switch (part.code) {
+        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))
+      }
+    }
+    return undefined
+  }
+
+  isArmeDisparate(rollData) {
+    const armeDefense = this.getCurrent(rollData).arme
+    if (armeDefense) {
+      const armeAttaque = rollData.attaque?.attaque.arme
+      return RdDItemArme.defenseArmeParade(armeAttaque, armeDefense) == 'sign'
+    }
+    return false
+  }
+
+  getDiffDefense(rollData) {
+    const current = this.getCurrent(rollData)
+    const refs = this.getRefs(rollData)
+    if (refs.isDistance) {
+      // Déterminer la difficulté de parade
+      return { diff: 0, mode: DIFF_MODE.LIBRE }
+    }
+    else {
+      return { diff: rollData.attaque.diff, mode: DIFF_MODE.DEFENSE }
+    }
+  }
 }