Gestion défense à distance

module/roll/roll-part-attaque.mjs

@@ -69,18 +69,10 @@ export class RollPartAttaque extends RollPartSelect {
     attaque.key = `${attaque.action}::${attaque.label}`
     attaque.tactique = TACTIQUES[0]
     attaque.initialDiff = attaque.comp?.system.default_diffLibre ?? 0
-    if (RollPartAttaque.isAttaqueDistance(attaque)) {
-      attaque.distance = Distance.ajustements(rollData.active.token,
-        rollData.opponent.token,
-        attaque.arme)
-    }
+    attaque.distance = Distance.ajustements(rollData.active.token, rollData.opponent.token, attaque)
     return attaque
   }
 
-  static isAttaqueDistance(attaque) {
-    return ['(lancer)', '(tir)'].includes(attaque.main)
-  }
-
   prepareContext(rollData) {
     this.filterAttaquesEmpoignade(rollData)
     const current = this.getCurrent(rollData)
@@ -167,7 +159,7 @@ export class RollPartAttaque extends RollPartSelect {
         case PART_CARAC: return part.filterCaracs(rollData, [current.carac.key])
         case PART_COMP: return part.filterComps(rollData, [current.comp.name])
         case PART_DIFF: {
-          if (RollPartAttaque.isAttaqueDistance(current)) {
+          if (Distance.typeAttaqueDistance(current)) {
             part.setDiff(rollData, { type: DIFF.DEFAUT })
           }
           else {

module/roll/roll-part-defense.mjs

@@ -1,4 +1,5 @@
-import { ITEM_TYPES, RDD_CONFIG } from "../constants.js"
+import { Distance } from "../combat/distance.mjs"
+import { ITEM_TYPES } from "../constants.js"
 import { ATTAQUE_TYPE, RdDItemArme } from "../item/arme.js"
 import { CARACS } from "../rdd-carac.js"
 import { DIFF, ROLL_TYPE_DEFENSE } from "./roll-constants.mjs"
@@ -19,53 +20,55 @@ export class RollPartDefense extends RollPartSelect {
   isValid(rollData) { return this.isRollType(rollData, ROLL_TYPE_DEFENSE) && rollData.attackerRoll != undefined }
   visible(rollData) { return this.isRollType(rollData, ROLL_TYPE_DEFENSE) && rollData.attackerRoll != undefined }
 
-  static getDiffAttaque(attackerRoll) {
-    // TODO: rollDataV2?
-    return attackerRoll.diffLibre;
-  }
-
   loadRefs(rollData) {
     const refs = this.getRefs(rollData)
     const attackerRoll = rollData.attackerRoll
     const defenseur = rollData.active.actor
-    refs.isDistance = [ATTAQUE_TYPE.TIR, ATTAQUE_TYPE.LANCER].find(it => it == attackerRoll?.main)
+    refs.distance = rollData.attackerRoll.current.attaque.distance
     const isEmpoignade = attackerRoll.dmg.isEmpoignade
     const isEmpoignadeEnCours = isEmpoignade && defenseur.itemTypes[ITEM_TYPES.empoignade].find(it =>
       [it.system.empoigneurid, it.system.empoigneid].includes(rollData.ids.opponentId) &&
       it.system.pointsemp != 0)
 
-    const esquives = (refs.isDistance == ATTAQUE_TYPE.TIR || isEmpoignadeEnCours)
+    const esquives = (refs.distance?.typeAttaque == ATTAQUE_TYPE.TIR || isEmpoignadeEnCours)
       ? []
       : defenseur.getCompetencesEsquive()
     const parades = isEmpoignade
       ? [RdDItemArme.empoignade(defenseur)]
-      : defenseur.items.filter(it => it.isParade() && (!refs.isDistance || it.isBouclier()))
+      : defenseur.items.filter(it => it.isParade() && (!refs.distance || it.isBouclier()))
 
     refs.defenses = [
-      ...esquives.map(it => RollPartDefense.$extractEsquive(it, defenseur)),
-      ...parades.map(it => RollPartDefense.$extractParade(it, attackerRoll?.arme, defenseur))
+      ...esquives.map(it => RollPartDefense.$extractEsquive(it, defenseur, attackerRoll)),
+      ...parades.map(it => RollPartDefense.$extractParade(it, defenseur, attackerRoll))
     ]
     this.$selectDefense(rollData)
   }
 
-  static $extractEsquive(esquive, defenseur) {
-    return {
+  static $extractEsquive(esquive, defenseur, attackerRoll) {
+    const defense = {
       key: esquive.id,
       label: esquive.name,
       img: esquive.img,
-      // TODO: carac pour créatures
+      // TODO: carac pour créatures à vérifier
       carac: defenseur.isPersonnage() ? CARACS.DEROBEE : esquive.name,
       verb: "esquive",
       comp: esquive,
       isEsquive: true
     }
+    if (attackerRoll.current.attaque.distance) {
+      defense.distance = {
+        ajustementDefense: Distance.ajustementDefense(attackerRoll.current.attaque),
+      }
+    }
+    return defense
   }
 
-  static $extractParade(armeDefense, armeAttaque, defenseur) {
+  static $extractParade(armeDefense, defenseur, attackerRoll) {
+    const armeAttaque = attackerRoll?.arme
     const comp = (ITEM_TYPES.competencecreature == armeDefense.type)
       ? armeDefense
       : defenseur.getCompetence(armeDefense.system.competence)
-    return {
+    const defense = {
       key: armeDefense.id,
       label: 'Parade ' + armeDefense.name,
       img: armeDefense.img,
@@ -78,6 +81,13 @@ export class RollPartDefense extends RollPartSelect {
       typeParade: armeAttaque ? RdDItemArme.defenseArmeParade(armeDefense, armeAttaque) : 'norm',
       isEsquive: false
     }
+    if (attackerRoll.current.attaque.distance) {
+      defense.distance = {
+        ajustementBouclier: Distance.ajustementBouclier(armeDefense),
+        ajustementDefense: Distance.ajustementDefense(attackerRoll.current.attaque),
+      }
+    }
+    return defense
   }
 
   prepareContext(rollData) {
@@ -107,10 +117,11 @@ export class RollPartDefense extends RollPartSelect {
 
   impactOtherPart(part, rollData) {
     if (this.visible(rollData)) {
+      const refs = this.getRefs(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_CARAC: return part.filterCaracs(rollData, refs.defenses.length > 0 ? [current.carac] : ['impossible'])
+        case PART_COMP: return part.filterComps(rollData, refs.defenses.length > 0 ? [current.comp?.name] : ['impossible'])
         case PART_DIFF: return part.setDiff(rollData, this.getDiffDefense(rollData))
         case PART_SIGN: return part.setArme(rollData, this.isArmeDisparate(rollData), current.forceRequise)
       }
@@ -129,16 +140,19 @@ export class RollPartDefense extends RollPartSelect {
 
   getDiffDefense(rollData) {
     const refs = this.getRefs(rollData)
-    if (refs.isDistance || !rollData.attackerRoll) {
-      // TODO: Déterminer la difficulté de parade
-      return { diff: 0, type: DIFF.LIBRE }
+    if (refs.distance) {
+      const current = this.getCurrent(rollData)
+      const diff = (current.distance?.ajustementBouclier?.value ?? 0)
+        + (current.distance?.ajustementDefense?.value ?? 0)
+      return { diff: diff, type: DIFF.DEFENSE }
     }
-    else {
+    if (rollData.attackerRoll) {
       const attackerRoll = rollData.attackerRoll
       const diff = attackerRoll.v2
         ? attackerRoll.selected.diff.value
         : attackerRoll.diff
       return { diff: diff ?? 0, type: DIFF.DEFENSE }
     }
+    return { diff: 0, type: DIFF.LIBRE }
   }
 }