WIP - update shields

Author: Julen-BZ

src/module/actor/ABFActor.js

@@ -132,77 +132,17 @@ export class ABFActor extends Actor {
     return roll.total;
   }
 
-  /**
-   * Creates a new supernatural shield item for the ABFActor class and execute a macro using the shield's name.
-   *
-   * @param {string} type The type of the supernatural shield ('psychic' or 'mystic').
-   * @param {any} power - The power object containing information about the psychic power. Only needed if type = 'psychic'.
-   * @param {number} psychicDifficulty - The difficulty level of the psychic power. Only needed if type = 'psychic'.
-   * @param {any} spell - The spell object containing information about the mystic spell. Only needed if type = 'mystic'.
-   * @param {string} spellGrade - The grade of the mystic spell. Only needed if type = 'mystic'.
-   * @returns {Promise<string>} - The ID of the newly created supernatural shield item.
-   */
-  async newSupernaturalShield(type, power, psychicDifficulty, spell, spellGrade) {
-    const supernaturalShieldData = {
-      name: '',
-      type: ABFItems.SUPERNATURAL_SHIELD,
-      system: {},
-      psychic: { overmantained: false, maintainMax: 0 }
-    };
-    if (type === 'psychic') {
-      const {
-        general: {
-          settings: { inhuman, zen }
-        },
-        psychic
-      } = this.system;
-
-      const potentialBaseDifficulty = psychicPotentialEffect(
-        psychic.psychicPotential.base.value,
-        0,
-        inhuman.value,
-        zen.value
-      );
-      const baseEffect =
-        shieldBaseValueCheck(potentialBaseDifficulty, power?.system.effects) ?? 0;
-      const finalEffect = shieldValueCheck(
-        power?.system.effects[psychicDifficulty].value ?? ''
-      );
-      supernaturalShieldData.name = power.name;
-      supernaturalShieldData.system = {
-        type: 'psychic',
-        damageBarrier: 0,
-        shieldPoints: finalEffect,
-        origin: this.uuid
-      };
-      supernaturalShieldData.psychic = {
-        overmantained: finalEffect > baseEffect,
-        maintainMax: baseEffect
-      };
-    } else if (type === 'mystic') {
-      const finalEffect = shieldValueCheck(
-        spell?.system.grades[spellGrade].description.value ?? ''
-      );
-      supernaturalShieldData.name = spell.name;
-      supernaturalShieldData.system = {
-        type: 'mystic',
-        spellGrade,
-        damageBarrier: 0,
-        shieldPoints: finalEffect,
-        origin: this.uuid
-      };
-    }
+  async newSupernaturalShield(shieldData) {
+    // Accept either DTO or plain create data
+    const itemCreateData =
+      typeof shieldData?.toItemCreateData === 'function'
+        ? shieldData.toItemCreateData()
+        : shieldData;
 
-    const item = await this.createItem(supernaturalShieldData);
-    let args = {
-      thisActor: this,
-      newShield: true,
-      shieldId: item._id
-    };
-    if (supernaturalShieldData.psychic.overmantained) {
-      item.setFlag(game.abf.id, 'psychic', supernaturalShieldData.psychic);
-    }
-    executeMacro(supernaturalShieldData.name, args);
+    const item = await this.createItem(itemCreateData);
+
+    const args = { thisActor: this, newShield: true, shieldId: item._id };
+    executeMacro(itemCreateData.name, args);
     return item._id;
   }
 

src/module/combat/ABFSupernaturalShieldData.js

@@ -0,0 +1,51 @@
+import { ABFItems } from '../items/ABFItems';
+
+export class ABFSupernaturalShieldData {
+  /** @param {{name?: string, shieldPoints?: number, abilityFormula?: string, flags?: object}} p */
+  constructor(p = {}) {
+    this.name = String(p.name ?? '');
+    this.type = ABFItems.SUPERNATURAL_SHIELD;
+    this.system = {
+      shieldPoints: Number(p.shieldPoints ?? 0) || 0,
+      abilityFormula: String(p.abilityFormula ?? '')
+    };
+    this.flags = p.flags ?? undefined;
+  }
+
+  toItemCreateData() {
+    const data = { name: this.name, type: this.type, system: { ...this.system } };
+    if (this.flags) data.flags = this.flags;
+    return data;
+  }
+
+  static builder() {
+    return new ABFSupernaturalShieldDataBuilder();
+  }
+}
+
+export class ABFSupernaturalShieldDataBuilder {
+  constructor() {
+    this._p = {};
+  }
+
+  name(v) {
+    this._p.name = String(v ?? '');
+    return this;
+  }
+  shieldPoints(v) {
+    this._p.shieldPoints = Number(v) || 0;
+    return this;
+  }
+  abilityFormula(v) {
+    this._p.abilityFormula = String(v ?? '');
+    return this;
+  }
+  flags(o) {
+    this._p.flags = o ?? undefined;
+    return this;
+  }
+
+  build() {
+    return new ABFSupernaturalShieldData(this._p);
+  }
+}

src/module/dialogs/combat/GMCombatDialog.js

@@ -3,6 +3,8 @@ import { calculateCombatResult } from '../../combat/utils/calculateCombatResult'
 import { ABFSettingsKeys } from '../../../utils/registerSettings';
 import { executeMacro } from '../../utils/functions/executeMacro';
 import ABFFoundryRoll from '../../rolls/ABFFoundryRoll.js';
+import { ABFSupernaturalShieldData } from '../../combat/ABFSupernaturalShieldData';
+import { shieldValueCheck } from '../../combat/utils/shieldValueCheck.js';
 
 const getInitialData = (attacker, defender, options = {}) => {
   const attackerActor = attacker.actor;
@@ -385,19 +387,21 @@ export class GMCombatDialog extends FormApplication {
 
   async newSupernaturalShieldIfBeAble() {
     const { supShield } = this.modalData.defender.result?.values;
-    if (
-      (this.modalData.defender.result?.type === 'mystic' ||
-        this.modalData.defender.result?.type === 'psychic') &&
-      supShield.create
-    ) {
-      const supShieldId = await this.defenderActor.newSupernaturalShield(
-        this.modalData.defender.result.type,
-        this.modalData.defender.result?.power ?? {},
-        this.modalData.defender.result.values?.psychicPotential ?? 0,
-        this.modalData.defender.result.spell ?? {},
-        this.modalData.defender.result.values?.spellGrade
-      );
-      return supShieldId;
+    const result = this.modalData.defender.result;
+
+    if ((result?.type === 'mystic' || result?.type === 'psychic') && supShield.create) {
+      const shieldPoints = Number(result.values?.supShield?.shieldPoints ?? 0);
+
+      const abilityFormula =
+        result.type === 'psychic' ? 'TU_FORMULA_PSIQUICA' : 'TU_FORMULA_MAGICA';
+
+      const shieldData = ABFSupernaturalShieldData.builder()
+        .name(result.type === 'psychic' ? result?.power?.name : result?.spell?.name)
+        .shieldPoints(shieldPoints)
+        .abilityFormula(abilityFormula)
+        .build();
+
+      return await this.defenderActor.newSupernaturalShield(shieldData);
     }
   }
 
@@ -427,10 +431,7 @@ export class GMCombatDialog extends FormApplication {
           attacker.result.values.total + this.modalData.attacker.customModifier,
           0
         );
-        newCombatResult.at = Math.max(
-          defender.result.values.at - reducedArmor,
-          0
-        );
+        newCombatResult.at = Math.max(defender.result.values.at - reducedArmor, 0);
         newCombatResult.halvedAbsorption =
           defender.result.type === 'resistance'
             ? defender.result.values.surprised
@@ -492,9 +493,7 @@ export class GMCombatDialog extends FormApplication {
 
     if (attacker.result?.type === 'combat') {
       const weaponName =
-        attacker.result.values?.weaponName ||
-        attacker.result.weapon?.name ||
-        'Unarmed';
+        attacker.result.values?.weaponName || attacker.result.weapon?.name || 'Unarmed';
       const { name } = { name: weaponName };
       macroName = macroPrefixAttack + name;
     } else if (attacker.result?.type === 'mystic') {

src/module/types/combat/SupernaturalShieldItemConfig.js

@@ -9,11 +9,8 @@ import { ABFItemConfigFactory } from '../ABFItemConfig';
  * @readonly
  */
 export const INITIAL_SUPERNATURAL_SHIELD_DATA = {
-  type: 'none',
-  spellGrade: SpellGrades.BASE,
-  damageBarrier: 0,
   shieldPoints: 0,
-  origin: ''
+  abilityFormula: ''
 };
 
 /** @type {import("../Items").SupernaturalShieldItemConfig} */

src/template.json

@@ -785,11 +785,8 @@
       "useCustomFormula": {"value": false }
     },
     "supernaturalShield": {
-      "type": { "value": "none" },
-      "spellGrade": { "value": "" },
-      "damageBarrier": { "value": 0 },
       "shieldPoints": { "value": 0 },
-      "origin": { "value": "" }
+      "abilityFormula": { "value": "" }
     },
     "effect": {
       "active":   { "value": true },