FIX - spell & psi power targeting + resistance defense rolling dice

Julen-BZ · Julen-BZ · commit 302f80c33f9d · 2026-01-17T19:08:12.000+01:00
diff --git a/src/module/actor/ABFActor.js b/src/module/actor/ABFActor.js
@@ -21,6 +21,7 @@ import { INITIAL_SPELL_CASTING_DATA } from '../types/mystic/SpellItemConfig.js';
 import ABFFoundryRoll from '../rolls/ABFFoundryRoll';
 import { openModDialog } from '../utils/dialogs/openSimpleInputDialog';
 import ABFItem from '../items/ABFItem';
+import { FormulaEvaluator } from '../../utils/formulaEvaluator.js';
 
 export class ABFActor extends Actor {
   i18n = game.i18n;
@@ -870,4 +871,48 @@ export class ABFActor extends Actor {
   getItem(itemId) {
     return this.getEmbeddedDocument('Item', itemId);
   }
+
+  applyActiveEffects() {
+    const originals = new Map();
+
+    try {
+      for (const effect of this.effects.contents) {
+        if (!effect.active) continue;
+
+        const changes = effect.changes;
+        if (!Array.isArray(changes) || changes.length === 0) continue;
+
+        // Save originals
+        originals.set(
+          effect,
+          changes.map(c => c.value)
+        );
+
+        // Patch values (in-memory only)
+        for (const change of changes) {
+          change.value = this._applyDynamicEffectValue(change.value);
+        }
+      }
+
+      // Let Foundry core do the real AE logic (modes, priority, etc.)
+      return super.applyActiveEffects();
+    } finally {
+      // Restore original values so nothing "sticks" on the document
+      for (const [effect, values] of originals.entries()) {
+        const changes = effect.changes;
+        for (let i = 0; i < changes.length; i++) {
+          changes[i].value = values[i];
+        }
+      }
+    }
+  }
+
+  _applyDynamicEffectValue(value) {
+    if (typeof value !== 'string') return value;
+
+    const evaluated = FormulaEvaluator.evaluate(value, this);
+    if (evaluated !== null && !Number.isNaN(evaluated)) return evaluated;
+
+    return value;
+  }
 }
diff --git a/src/module/actor/utils/buttonCallbacks/castPsychicPower.js b/src/module/actor/utils/buttonCallbacks/castPsychicPower.js
@@ -3,6 +3,7 @@ import { ABFAttackData } from '../../../combat/ABFAttackData.js';
 import { ABFSupernaturalShieldData } from '../../../combat/ABFSupernaturalShieldData.js';
 import { shieldValueCheck } from '../../../combat/utils/shieldValueCheck.js';
 import { openModDialog } from '../../../utils/dialogs/openSimpleInputDialog.js';
+import { getSnapshotTargets } from '../getSnapshotTargets.js';
 
 function _getBestEffectKey(effects, rolledValue) {
   if (!effects) return null;
@@ -81,7 +82,8 @@ async function _sendPsychicAttackToChat({
   power,
   difficultyKey,
   effectData,
-  baseDamage
+  baseDamage,
+  targets
 }) {
   // Quick attack like spells: ask mod, roll offensive projection, post roll, then attack data to chat
   const mod = Number(await openModDialog({ title: 'Modificador de Proyección' })) || 0;
@@ -116,7 +118,7 @@ async function _sendPsychicAttackToChat({
     .critBonus(0)
     .attackerId(actor.id)
     .weaponId(power.id)
-    .targets([])
+    .targets(targets ?? [])
     .build()
     .toChatMessage({ actor, weapon: power });
 
@@ -195,12 +197,15 @@ export async function castPsychicPower(sheet, event) {
     if (fatigueResult === 0) {
       const baseDamage = Number(effectData?.damage?.value ?? 0) || 0;
 
+      const snapshotTargets = getSnapshotTargets();
+
       await _sendPsychicAttackToChat({
         actor,
         power,
         difficultyKey,
         effectData,
-        baseDamage
+        baseDamage,
+        targets: snapshotTargets
       });
 
       return;
@@ -272,12 +277,15 @@ export async function castPsychicPowerDifficulty(sheet, event) {
     if (fatigueResult === 0) {
       const baseDamage = Number(effectData?.damage?.value ?? 0) || 0;
 
+      const snapshotTargets = getSnapshotTargets();
+
       await _sendPsychicAttackToChat({
         actor,
         power,
         difficultyKey,
         effectData,
-        baseDamage
+        baseDamage,
+        targets: snapshotTargets
       });
 
       return;
diff --git a/src/module/actor/utils/buttonCallbacks/castSpellGrade.js b/src/module/actor/utils/buttonCallbacks/castSpellGrade.js
@@ -5,13 +5,12 @@ import { shieldValueCheck } from '../../../combat/utils/shieldValueCheck.js';
 import { Templates } from '../../../utils/constants';
 import { openModDialog } from '../../../utils/dialogs/openSimpleInputDialog.js';
 import { SpellAttackConfigurationDialog } from '../../../dialogs/SpellAttackConfigurationDialog.js';
+import { getSnapshotTargets } from '../getSnapshotTargets.js';
 
-// Comments in English
 function localizeGrade(grade) {
   return game.i18n.localize(`anima.ui.mystic.spell.grade.${grade}.title`);
 }
 
-// Comments in English
 async function openShieldConfigDialog({ spell, grade }) {
   const content = await renderTemplate(Templates.Dialog.SpellShieldConfigDialog, {
     formulaBonus: 0
@@ -81,7 +80,8 @@ export async function castSpellGrade(sheet, event) {
     new SpellAttackConfigurationDialog({
       attacker: token,
       spell,
-      grade
+      grade,
+      targets: getSnapshotTargets()
     });
 
     return;
@@ -116,7 +116,7 @@ export async function castSpellGrade(sheet, event) {
     .critBonus(0)
     .attackerId(actor.id)
     .weaponId(spell.id)
-    .targets([])
+    .targets(getSnapshotTargets())
     .build()
     .toChatMessage({ actor, weapon: spell });
 }
diff --git a/src/module/actor/utils/buttonCallbacks/createWeaponAttack.js b/src/module/actor/utils/buttonCallbacks/createWeaponAttack.js
@@ -1,4 +1,5 @@
 import { AttackConfigurationDialog } from '../../../dialogs/AttackConfigurationDialog.js';
+import { getSnapshotTargets } from '../getSnapshotTargets.js';
 
 /**
  * Open AttackConfigurationDialog with the selected weapon locked.
@@ -13,18 +14,7 @@ export function createWeaponAttack(sheet, e) {
   const attackerToken = sheet.token ?? sheet.actor?.getActiveTokens?.()[0];
   if (!attackerToken) return ui.notifications.warn('No attacker token found.');
 
-  const snapshotTargets = Array.from(game.user?.targets ?? [])
-    .map(t => {
-      const tok = t?.document ?? t;
-      const actorUuid = tok?.actor?.id ?? tok?.actorId ?? '';
-      // Prefer UUID; fallback to id
-      const tokenUuid = tok?.uuid ?? tok?.document?.uuid ?? tok?.id ?? '';
-      const label = tok?.name ?? tok?.actor?.name ?? '';
-      return actorUuid && tokenUuid
-        ? { actorUuid, tokenUuid, state: 'pending', label, updatedAt: Date.now() }
-        : null;
-    })
-    .filter(Boolean);
+  const snapshotTargets = getSnapshotTargets();
 
   new AttackConfigurationDialog(
     { attacker: attackerToken, weaponId, targets: snapshotTargets },
diff --git a/src/module/actor/utils/getSnapshotTargets.js b/src/module/actor/utils/getSnapshotTargets.js
@@ -0,0 +1,16 @@
+export function getSnapshotTargets(user = game.user) {
+  return Array.from(user?.targets ?? [])
+    .map(t => {
+      const tok = t?.document ?? t;
+
+      const actorUuid = tok?.actor?.id ?? tok?.actorId ?? '';
+      // Prefer UUID; fallback to id
+      const tokenUuid = tok?.uuid ?? tok?.document?.uuid ?? tok?.id ?? '';
+      const label = tok?.name ?? tok?.actor?.name ?? '';
+
+      return actorUuid && tokenUuid
+        ? { actorUuid, tokenUuid, state: 'pending', label, updatedAt: Date.now() }
+        : null;
+    })
+    .filter(Boolean);
+}
diff --git a/src/module/combat/ABFAttackData.js b/src/module/combat/ABFAttackData.js
@@ -53,7 +53,6 @@ export class ABFAttackData {
       : [];
   }
 
-  // Comments in English
   static _normalizeTarget(t = {}) {
     return {
       actorUuid: String(t.actorUuid ?? t.actorId ?? ''),
diff --git a/src/module/combat/ABFCombatResultData.js b/src/module/combat/ABFCombatResultData.js
@@ -1,39 +1,70 @@
-// Comments in English
 export class ABFCombatResultData {
   /** @param {Partial<ABFCombatResultData>} p */
   constructor(p = {}) {
-    this.difference = p.difference ?? 0;              // Diferencia
+    this.difference = p.difference ?? 0; // Diferencia
     this.counterAttackValue = p.counterAttackValue ?? 0; // Valor de contraataque
     this.hasCounterAttack = p.hasCounterAttack ?? false; // ¿Hay contraataque?
-    this.damageFinal = p.damageFinal ?? 0;            // Daño final
+    this.damageFinal = p.damageFinal ?? 0; // Daño final
     this.lifePercentRemoved = p.lifePercentRemoved ?? 0; // % de vida quitada
-    this.isCritical = p.isCritical ?? false;          // ¿Es crítico?
+    this.isCritical = p.isCritical ?? false; // ¿Es crítico?
     this.baseCriticalValue = p.baseCriticalValue ?? 0; // Valor base del crítico
-    this.attackBreak = p.attackBreak ?? 0;            // Rotura del ataque
+    this.attackBreak = p.attackBreak ?? 0; // Rotura del ataque
   }
 
-  toJSON() { return { ...this }; }
+  toJSON() {
+    return { ...this };
+  }
 
   static fromJSON(json) {
     const obj = typeof json === 'string' ? JSON.parse(json) : json;
     return new ABFCombatResultData(obj);
   }
 
   /** Fluent builder */
-  static builder() { return new ABFCombatResultDataBuilder(); }
+  static builder() {
+    return new ABFCombatResultDataBuilder();
+  }
 }
 
 export class ABFCombatResultDataBuilder {
-  constructor() { this._p = {}; }
+  constructor() {
+    this._p = {};
+  }
 
-  difference(v) { this._p.difference = Number(v) || 0; return this; }
-  counterAttackValue(v) { this._p.counterAttackValue = Number(v) || 0; return this; }
-  hasCounterAttack(v) { this._p.hasCounterAttack = !!v; return this; }
-  damageFinal(v) { this._p.damageFinal = Number(v) || 0; return this; }
-  lifePercentRemoved(v) { this._p.lifePercentRemoved = Number(v) || 0; return this; }
-  isCritical(v) { this._p.isCritical = !!v; return this; }
-  baseCriticalValue(v) { this._p.baseCriticalValue = Number(v) || 0; return this; }
-  attackBreak(v) { this._p.attackBreak = Number(v) || 0; return this; }
+  difference(v) {
+    this._p.difference = Number(v) || 0;
+    return this;
+  }
+  counterAttackValue(v) {
+    this._p.counterAttackValue = Number(v) || 0;
+    return this;
+  }
+  hasCounterAttack(v) {
+    this._p.hasCounterAttack = !!v;
+    return this;
+  }
+  damageFinal(v) {
+    this._p.damageFinal = Number(v) || 0;
+    return this;
+  }
+  lifePercentRemoved(v) {
+    this._p.lifePercentRemoved = Number(v) || 0;
+    return this;
+  }
+  isCritical(v) {
+    this._p.isCritical = !!v;
+    return this;
+  }
+  baseCriticalValue(v) {
+    this._p.baseCriticalValue = Number(v) || 0;
+    return this;
+  }
+  attackBreak(v) {
+    this._p.attackBreak = Number(v) || 0;
+    return this;
+  }
 
-  build() { return new ABFCombatResultData(this._p); }
+  build() {
+    return new ABFCombatResultData(this._p);
+  }
 }
diff --git a/src/module/combat/autoRollDefenseAgainstAttack.js b/src/module/combat/autoRollDefenseAgainstAttack.js
@@ -37,6 +37,43 @@ function getDefensesCounter(actor) {
   );
 }
 
+function buildZeroDefenseResult({ actor, defenderToken, attackData }) {
+  const armorType = attackData?.armorType;
+  const taFinal =
+    armorType != null ? actor.system?.combat?.totalArmor?.at?.[armorType]?.value ?? 0 : 0;
+
+  const defenseData = ABFDefenseData.builder()
+    .defenseAbility(0)
+    .armor(taFinal)
+    .inmodifiableArmor(false)
+    .defenseType('resistance')
+    .defenderId(actor.id)
+    .defenderTokenId(defenderToken?.id ?? '')
+    .weaponId('')
+    .shieldId('')
+    .stackDefense(false)
+    .applyMultipleDefensePenalty(false)
+    .projectilePenalty(0)
+    .build();
+
+  const combatResult = computeCombatResult(attackData, defenseData);
+
+  return {
+    actor,
+    token: defenderToken ?? null,
+    defenseType: 'resistance',
+    defenseTotal: 0,
+    weaponId: '',
+    shieldId: '',
+    defenseData,
+    combatResult,
+    appliedPenalties: {
+      projectilePenalty: 0,
+      multipleDefensePenalty: 0
+    }
+  };
+}
+
 export async function autoRollDefenseAgainstAttack({
   defenderToken = null,
   defenderActor = null,
@@ -46,6 +83,13 @@ export async function autoRollDefenseAgainstAttack({
   const actor = defenderActor ?? defenderToken?.actor ?? null;
   if (!actor) throw new Error('autoRollDefenseAgainstAttack: defender actor missing');
 
+  const defenseMode = actor.system?.general?.settings?.defenseType?.value;
+
+  // Accumulation/resistance defenders: base defense 0, no roll, no penalties.
+  if (defenseMode === 'resistance') {
+    return buildZeroDefenseResult({ actor, defenderToken, attackData });
+  }
+
   const defensesCounter = getDefensesCounter(actor);
 
   const candidate = pickBestDefenseCandidate(actor, { attackData, defensesCounter });
diff --git a/src/module/dialogs/AttackConfigurationDialog.js b/src/module/dialogs/AttackConfigurationDialog.js
@@ -1,6 +1,9 @@
 import { Templates } from '../utils/constants';
 import { ABFConfig } from '../ABFConfig';
 import { ABFAttackData } from '../combat/ABFAttackData';
+import { getSnapshotTargets } from '../actor/utils/getSnapshotTargets.js';
+///dialogs/AttackConfigurationDialog.js
+///actor/utils/getSnapshotTargets.js
 
 export class AttackConfigurationDialog extends FormApplication {
   constructor(object = {}, options = {}) {
@@ -16,6 +19,7 @@ export class AttackConfigurationDialog extends FormApplication {
       ui.notifications?.error('AttackConfigurationDialog: attacker is required');
       return { allowed: false };
     }
+
     const attackerActor = attacker.actor;
 
     const resolvedWeapon =
@@ -25,18 +29,8 @@ export class AttackConfigurationDialog extends FormApplication {
       ui.notifications?.warn('Arma no encontrada.');
     }
 
-    // Snapshot de targets si no te lo pasan (tokenUuid = UUID si existe)
-    const fallbackSnapshot = Array.from(game.user?.targets ?? [])
-      .map(t => {
-        const token = t?.document ?? t;
-        const actorUuid = token?.actor?.id ?? token?.actorId ?? '';
-        const tokenUuid = token?.uuid ?? token?.document?.uuid ?? token?.id ?? '';
-        const label = token?.name ?? token?.actor?.name ?? '';
-        return actorUuid && tokenUuid
-          ? { actorUuid, tokenUuid, state: 'pending', label, updatedAt: Date.now() }
-          : null;
-      })
-      .filter(Boolean);
+    // Fallback targets snapshot (reusing shared helper)
+    const fallbackSnapshot = getSnapshotTargets();
 
     const isOwner = attackerActor.testUserPermission?.(
       game.user,
diff --git a/src/module/dialogs/SpellAttackConfigurationDialog.js b/src/module/dialogs/SpellAttackConfigurationDialog.js
diff --git a/src/utils/chatActionHandlers/defendActionHandler.js b/src/utils/chatActionHandlers/defendActionHandler.js
diff --git a/src/utils/chatActionHandlers/defendTargetActionHandler.js b/src/utils/chatActionHandlers/defendTargetActionHandler.js
diff --git a/src/utils/sendAccumulationZeroDefense.js b/src/utils/sendAccumulationZeroDefense.js

Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,6 @@ export class ABFAttackData {`
`53`	`53`	`: [];`
`54`	`54`	`}`
`55`	`55`
`56`		`- // Comments in English`
`57`	`56`	`static _normalizeTarget(t = {}) {`
`58`	`57`	`return {`
`59`	`58`	`actorUuid: String(t.actorUuid ?? t.actorId ?? ''),`