UPDATED - Effects

Author: Julen-BZ

src/animabf.mjs

@@ -1,6 +1,7 @@
 import { registerSettings, ABFSettingsKeys } from './utils/registerSettings';
 import { Logger, preloadTemplates } from './utils';
 import ABFActorSheet from './module/actor/ABFActorSheet';
+import ABFTokenHUD from './module/actor/ABFTokenHUD';
 import ABFFoundryRoll from './module/rolls/ABFFoundryRoll';
 import ABFCombat from './module/combat/ABFCombat';
 import { ABFActor } from './module/actor/ABFActor';
@@ -54,6 +55,7 @@ Hooks.once('init', async () => {
 
   CONFIG.Item.documentClass = ABFItem;
   CONFIG.ui.actors = ABFActorDirectory;
+  CONFIG.Token.hudClass = ABFTokenHUD;
 
   // Register custom sheets (if any)
   Actors.unregisterSheet('core', ActorSheet);
@@ -319,6 +321,16 @@ Hooks.on('chatMessage', (chatLog, message, chatData) => {
   return false;
 });
 
+Hooks.on('renderActiveEffectConfig', (app, html) => {
+  const transfer = html.find('input[name="transfer"]');
+  if (!transfer.length) return;
+
+  transfer.prop('checked', false);
+  transfer.prop('disabled', true);
+
+  transfer.closest('.form-group').hide();
+});
+
 // // Auto-number unlinked tokens as "{name} (n)" when dropped
 // Hooks.on('createToken', async doc => {
 //   // Ignore linked tokens

src/lang/en.json

@@ -633,6 +633,7 @@
   "dialogs.items.technique.content": "Technique name",
   "dialogs.items.title.content": "Title name",
   "dialogs.items.weapons.content": "Weapon name",
+  "anima.ui.effects.effectsList.newEffectDialog.content": "Effect name",
   "dialogs.mod.content": "Modifier",
   "dialogs.newSupernaturalShield.title": "New Supernatural Shield",
   "dialogs.psychicShield.difficulty.special": "Dice Roll",

src/lang/es.json

@@ -635,6 +635,7 @@
   "dialogs.items.technique.content": "Nombre de la técnica",
   "dialogs.items.title.content": "Nombre del título",
   "dialogs.items.weapons.content": "Nombre del arma",
+  "anima.ui.effects.effectsList.newEffectDialog.content": "Nombre del efecto",
   "dialogs.mod.content": "Modificador",
   "dialogs.newSupernaturalShield.title": "Nuevo Escudo Sobrenatural",
   "dialogs.psychicShield.difficulty.special": "Realizar Tirada",

src/lang/fr.json

@@ -597,6 +597,7 @@
   "dialogs.items.technique.content": "Nom de la Technique",
   "dialogs.items.title.content": "Nom du Titre",
   "dialogs.items.weapons.content": "Nom de l'Arme",
+  "anima.ui.effects.effectsList.newEffectDialog.content": "Effect name",
   "dialogs.migrations.content": "Une migration va commencer. Pour éviter toute perte de données, sauvegardez votre dossier de données avant d'appliquer la migration. Êtes-vous prêt à continuer ?",
   "dialogs.migrations.error": "Échec de l'application de la migration n°{version} :\n{error}",
   "dialogs.migrations.success": "La migration n°{version} « {title} » a été appliquée avec succès.",

src/module/actor/ABFActor.js

@@ -344,10 +344,10 @@ export class ABFActor extends Actor {
     );
 
     for (const psychicShield of psychicShields) {
-      const psychic = psychicShield.getFlag(game.abf.id, 'psychic');
+      const psychic = psychicShield.getFlag(game.animabf.id, 'psychic');
       if (psychic?.overmantained) {
         if (psychic.maintainMax >= psychicShield.system.shieldPoints) {
-          psychicShield.unsetFlag(game.abf.id, 'psychic');
+          psychicShield.unsetFlag(game.animabf.id, 'psychic');
         } else {
           const supShield = {
             system: psychicShield.system,

src/module/actor/ABFActorSheet.js

@@ -3,6 +3,7 @@ import ABFFoundryRoll from '../rolls/ABFFoundryRoll';
 import { splitAsActorAndItemChanges } from './utils/splitAsActorAndItemChanges';
 import { unflat } from './utils/unflat';
 import { ALL_ITEM_CONFIGURATIONS } from './utils/prepareItems/constants';
+import { INITIAL_EFFECT_DATA } from '../types/effects/EffectItemConfig';
 import { getFieldValueFromPath } from './utils/prepareItems/util/getFieldValueFromPath';
 import { getUpdateObjectFromPath } from './utils/prepareItems/util/getUpdateObjectFromPath';
 import { ABFItems } from '../items/ABFItems';
@@ -98,18 +99,27 @@ export default class ABFActorSheet extends ActorSheet {
   async getData(options) {
     const sheet = await super.getData(options);
 
-    if (this.actor.type === 'character') {
-      await sheet.actor.prepareDerivedData();
-      sheet.system = sheet.actor.system;
+    const actor = this.actor; // use the real Document, not sheet.actor
+
+    if (actor?.type === 'character') {
+      await actor.prepareDerivedData();
+      sheet.system = actor.system;
     }
 
     sheet.config = CONFIG.config;
+
     const permissions = game.settings.get(
       game.animabf.id,
       ABFSettingsKeys.MODIFY_DICE_FORMULAS_PERMISSION
     );
     sheet.canModifyDice = permissions?.[game.user.role] === true;
-    sheet.effects = this.actor.effects?.contents ?? [];
+
+    // Use embedded item collection directly
+    const effectItems = actor.items.filter(i => i && i.type === ABFItems.EFFECT);
+    sheet.effects = effectItems;
+
+    console.log('EFFECT ITEMS EN SHEET', sheet.effects);
+
     return sheet;
   }
 
@@ -175,31 +185,74 @@ export default class ABFActorSheet extends ActorSheet {
     const a = event.currentTarget;
     const action = a.dataset.action;
     const li = a.closest('.effect');
-    const effectId = li?.dataset.effectId;
+    const itemId = li?.dataset.itemId;
+    const item = itemId ? this.actor.items.get(itemId) : null;
 
     switch (action) {
-      case 'create':
+      case 'create': {
         const name = game.i18n.localize('anima.effects.newEffect') ?? 'New Effect';
-        return this.actor.createEmbeddedDocuments('ActiveEffect', [
+        const [created] = await this.actor.createEmbeddedDocuments('Item', [
           {
+            type: ABFItems.EFFECT,
             name,
-            icon: 'icons/svg/aura.svg'
+            system: INITIAL_EFFECT_DATA
           }
         ]);
+        if (created?.sheet) created.sheet.render(true);
+        return;
+      }
 
       case 'edit': {
-        const effect = this.actor.effects.get(effectId);
-        return effect?.sheet?.render(true);
+        if (!item) return;
+
+        // Asegura que exista un AE vinculado a este item
+        const effect = await this._ensureEffectForItem(item);
+        if (!effect) return;
+
+        // Configura la sincronización item <-> AE
+        this._setupEffectSync(item, effect);
+
+        return effect.sheet?.render(true);
       }
 
-      case 'delete':
-        return this.actor.deleteEmbeddedDocuments('ActiveEffect', [effectId]);
+      case 'delete': {
+        if (!itemId) return;
+
+        const item = this.actor.items.get(itemId);
+        if (!item) return;
+
+        // get linked AE
+        const effect = this._getLinkedEffect(item);
+
+        const deletions = [];
+
+        // delete item
+        deletions.push(this.actor.deleteEmbeddedDocuments('Item', [itemId]));
+
+        // delete linked AE
+        if (effect) {
+          deletions.push(this.actor.deleteEmbeddedDocuments('ActiveEffect', [effect.id]));
+        }
+
+        return Promise.all(deletions);
+      }
 
       case 'toggle': {
-        const effect = this.actor.effects.get(effectId);
-        if (!effect) return;
-        return effect.update({ disabled: !effect.disabled });
+        if (!item) return;
+
+        const newActive = !item.system.active;
+        await item.update({ 'system.active': newActive });
+
+        const effect = this._getLinkedEffect(item);
+        if (effect) {
+          await effect.update({ disabled: !newActive });
+        }
+
+        return;
       }
+
+      default:
+        return;
     }
   }
 
@@ -356,4 +409,80 @@ export default class ABFActorSheet extends ActorSheet {
       ...otherItems
     ]);
   };
+
+  _getLinkedEffect(item) {
+    if (!item) return null;
+    return this.actor.effects.find(e => e.origin === item.uuid) ?? null;
+  }
+
+  async _linkItemToEffect(item, effect) {
+    if (!item || !effect) return;
+    await item.setFlag('animabf', 'linkedEffectId', effect.id);
+  }
+
+  async _ensureEffectForItem(item) {
+    if (!item) return null;
+
+    let effect = this._getLinkedEffect(item);
+    if (effect) return effect;
+
+    const rawBaseData = item.system?.effectData ?? {};
+    // Ignore old origin if it exists in stored data
+    const { origin, ...baseData } = rawBaseData;
+
+    const data = foundry.utils.mergeObject(
+      {
+        name: item.name,
+        icon: item.img || 'icons/svg/aura.svg',
+        disabled: !item.system?.active,
+        origin: item.uuid // always the current item
+      },
+      baseData,
+      { inplace: false }
+    );
+
+    const [created] = await this.actor.createEmbeddedDocuments('ActiveEffect', [data]);
+    return created ?? null;
+  }
+
+  async _onDropItem(event, data) {
+    const created = await super._onDropItem(event, data);
+
+    const items = Array.isArray(created) ? created : created ? [created] : [];
+
+    for (const item of items) {
+      if (item.type !== ABFItems.EFFECT) continue;
+
+      await item.update({
+        'system.active': false,
+        'system.effectData.disabled': true
+      });
+
+      await this._ensureEffectForItem(item);
+    }
+
+    return created;
+  }
+
+  _setupEffectSync(item, effect) {
+    const handler = async (doc, diff, options, userId) => {
+      if (doc.id !== effect.id) return;
+      if (userId !== game.user.id) return;
+
+      if (doc.transfer === true) {
+        await doc.update({ transfer: false });
+        return;
+      }
+
+      const obj = doc.toObject();
+      const { _id, _key, parent, ...clean } = obj;
+
+      await item.update({ 'system.effectData': clean });
+      await item.update({ 'system.active': !doc.disabled });
+
+      Hooks.off('updateActiveEffect', handler);
+    };
+
+    Hooks.on('updateActiveEffect', handler);
+  }
 }

src/module/actor/ABFTokenHUD.js

@@ -0,0 +1,58 @@
+export default class ABFTokenHUD extends TokenHUD {
+  /** @override */
+  async _onRender(context, options) {
+    await super._onRender(context, options);
+
+    const root = this.element;
+    if (!root) return;
+
+    const token = this.object;
+    const actor = token?.actor;
+    if (!actor) return;
+
+    const flagSystem = game.animabf.id;
+    const flagKey = 'defensesCounter';
+
+    const defensesCounter = (await actor.getFlag(flagSystem, flagKey)) ?? {
+      accumulated: 0,
+      keepAccumulating: true
+    };
+
+    const currentValue = Number(defensesCounter.accumulated) || 0;
+
+    const middleCol = root.querySelector('.col.middle');
+    if (!middleCol) return;
+
+    // Reuse control if exists
+    let control = middleCol.querySelector('.attribute.abf-flag-value');
+    if (!control) {
+      control = document.createElement('div');
+      control.classList.add('attribute', 'abf-flag-value');
+      control.dataset.tooltip = 'Defensas adicionales';
+
+      control.innerHTML = `
+        <label style="margin-right: 4px;">DEF</label>
+        <input type="number" name="abfFlagValue" min="0" step="1" value="0">
+      `;
+
+      middleCol.prepend(control);
+    }
+
+    const input = control.querySelector("input[name='abfFlagValue']");
+    if (!input) return;
+
+    input.value = currentValue;
+
+    input.onchange = async ev => {
+      ev.stopPropagation();
+      ev.preventDefault();
+
+      const newValue = Number(ev.target.value) || 0;
+
+      await actor.setFlag(flagSystem, flagKey, {
+        ...defensesCounter,
+        accumulated: newValue
+      });
+    };
+  }
+}

src/module/actor/utils/prepareItems/constants.js

@@ -34,6 +34,7 @@ import { ElanPowerItemConfig } from '../../../types/general/ElanPowerItemConfig'
 import { ArmorItemConfig } from '../../../types/combat/ArmorItemConfig';
 import { SupernaturalShieldItemConfig } from '../../../types/combat/SupernaturalShieldItemConfig';
 import { InventoryItemItemConfig } from '../../../types/general/InventoryItemItemConfig';
+import { EffectItemConfig } from '../../../types/effects/EffectItemConfig';
 
 export const INTERNAL_ITEM_CONFIGURATIONS = {
   [ArsMagnusItemConfig.type]: ArsMagnusItemConfig,
@@ -74,7 +75,8 @@ export const ITEM_CONFIGURATIONS = {
   [PsychicDisciplineItemConfig.type]: PsychicDisciplineItemConfig,
   [PsychicPowerItemConfig.type]: PsychicPowerItemConfig,
   [TechniqueItemConfig.type]: TechniqueItemConfig,
-  [WeaponItemConfig.type]: WeaponItemConfig
+  [WeaponItemConfig.type]: WeaponItemConfig,
+  [EffectItemConfig.type]: EffectItemConfig
 };
 
 export const ALL_ITEM_CONFIGURATIONS = {

src/module/items/ABFItem.js

@@ -1,9 +1,45 @@
 import { prepareItem } from './utils/prepareItem/prepareItem';
+import { ABFItems } from './ABFItems';
 
 export default class ABFItem extends Item {
   async prepareDerivedData() {
     await super.prepareDerivedData();
 
     await prepareItem(this);
   }
+
+  toActiveEffectData() {
+    if (this.type !== ABFItems.EFFECT) return null;
+
+    const effectData = this.system.effectData ?? {};
+    return {
+      name: this.name,
+      icon: effectData.icon ?? this.img ?? 'icons/svg/aura.svg',
+      disabled: effectData.disabled ?? true,
+      changes: effectData.changes ?? [],
+      duration: effectData.duration ?? {},
+      transfer: false,
+      flags: effectData.flags ?? {}
+    };
+  }
+
+  async fromActiveEffect(activeEffect) {
+    if (this.type !== ABFItems.EFFECT || !activeEffect) return;
+
+    const data = activeEffect.toObject();
+    const { name, icon, disabled, changes, duration, flags } = data;
+
+    await this.update({
+      name,
+      'system.active': !disabled,
+      'system.effectData': {
+        icon,
+        disabled,
+        changes,
+        duration,
+        transfer: false,
+        flags
+      }
+    });
+  }
 }