WIP - fix effects

Author: Julen-BZ

src/lang/en.json

@@ -817,7 +817,7 @@
   "anima.permissions.modifyDiceFormulasPermission.hint": "Allows the user to modify the dice settings used by the actors.",
   "customHotbar.damageCalculator": "Damage calculator",
   "customHotbar.sendAttack": "Send attack",
-  "anima.ui.tooltips.base": "Final",
+  "anima.ui.tooltips.base": "Base",
   "anima.ui.tooltips.special": "Special",
   "anima.ui.tooltips.final": "Final",
   "anima.ui.tooltips.mod": "Modifier",

src/lang/es.json

@@ -819,7 +819,7 @@
   "anima.permissions.modifyDiceFormulasPermission.hint": "Permite al usuario cambiar las fórmulas de dados usadas por los actores.",
   "customHotbar.damageCalculator": "Calculadora de daño",
   "customHotbar.sendAttack": "Enviar ataque",
-  "anima.ui.tooltips.base": "Final",
+  "anima.ui.tooltips.base": "Base",
   "anima.ui.tooltips.special": "Especial",
   "anima.ui.tooltips.final": "Final",
   "anima.ui.tooltips.mod": "Modificador",

src/lang/fr.json

@@ -537,7 +537,7 @@
   "anima.ui.tabs.secondaries": "Secondaires",
   "anima.ui.tabs.effects": "Efectos",
   "anima.ui.titleSection.title": "Titres",
-  "anima.ui.tooltips.base": "Final",
+  "anima.ui.tooltips.base": "Base",
   "anima.ui.tooltips.final": "Final",
   "anima.ui.tooltips.special": "Spécial",
   "anima.ui.tooltips.mod": "Modifier",

src/module/actor/ABFActor.js

@@ -51,9 +51,6 @@ export class ABFActor extends Actor {
       overwrite: false
     });
 
-    // Inflate typed nodes from __type and remove markers
-    data.system = inflateSystemFromTypeMarkers(data.system);
-
     return super._preCreate(data, options, user);
   }
 
@@ -68,10 +65,38 @@ export class ABFActor extends Actor {
     this.system = inflateSystemFromTypeMarkers(this.system);
 
     buildTypedNodes(this, TYPED_PATHS);
+    this._applyDefaultKeysToTypedNodes();
     await prepareActor(this);
     // applyTypedDerived(this);
   }
 
+  /**
+   * Ensure BaseType.key is persisted when empty.
+   * Derives it from the last segment of the system path.
+   */
+  _applyDefaultKeysToTypedNodes() {
+    const updates = {};
+
+    // typedNodes: Map<path, BaseTypeInstance>
+    for (const [path, node] of this.typedNodes ?? []) {
+      // Only if the type actually has a "key" field in its defaults/common defaults
+      // (BaseType.commonDefaults includes key)
+
+      const current = foundry.utils.getProperty(this.system, `${path}.key`);
+
+      if (current == null || String(current) === '') {
+        const parts = String(path).split('.');
+        const derivedKey = parts.length ? parts[parts.length - 1] : '';
+        if (derivedKey) updates[`${path}.key`] = derivedKey;
+      }
+    }
+
+    if (Object.keys(updates).length) {
+      // Persist without triggering another full update cycle
+      this.updateSource(updates);
+    }
+  }
+
   getRollData() {
     const data = super.getRollData();
 

src/module/actor/ABFActorSheet.js

@@ -11,6 +11,7 @@ import { ABFDialogs } from '../dialogs/ABFDialogs';
 import { Logger } from '../../utils';
 import { ABFSettingsKeys } from '../../utils/registerSettings';
 import { createClickHandlers } from './utils/createClickHandlers';
+import { TypeEditorRegistry } from './types/TypeEditorRegistry.js';
 
 /** @typedef {import('./constants').TActorData} TData */
 /** @typedef {typeof FormApplication<FormApplicationOptions, TData, TData>} TFormApplication */
@@ -129,6 +130,8 @@ export default class ABFActorSheet extends ActorSheet {
     // Everything below here is only needed if the sheet is editable
     if (!this.options.editable) return;
 
+    this._activateBaseTypeContextMenu(html);
+
     const handler = ev => this._onDragStart(ev);
 
     // Find all items on the character sheet.
@@ -180,6 +183,29 @@ export default class ABFActorSheet extends ActorSheet {
     html.find('.effect-control').click(this._onEffectControl.bind(this));
   }
 
+  _activateBaseTypeContextMenu(html) {
+    new ContextMenu(html, '.base-type-row', [
+      {
+        name: game.i18n.localize('contextualMenu.common.options.edit') ?? 'Edit…',
+        icon: '<i class="fas fa-edit fa-fw"></i>',
+        callback: target => this._openBaseTypeEditor(target[0])
+      }
+    ]);
+  }
+
+  _openBaseTypeEditor(el) {
+    const path = el?.dataset?.path;
+    if (!path) return;
+
+    const node = this.actor.typedNodes?.get(path) ?? null;
+    if (!node) return;
+
+    const type = node.constructor.type;
+
+    const app = TypeEditorRegistry.create(type, this.actor, { path });
+    app?.render(true);
+  }
+
   async _onEffectControl(event) {
     event.preventDefault();
     const a = event.currentTarget;

src/module/actor/constants.js

@@ -91,7 +91,7 @@ export const INITIAL_ACTOR_DATA = {
         }
       },
       extraDamage: {
-        value: 0
+        __type: '{"type":"NumericalValue"}'
       }
     },
     destinyPoints: {
@@ -973,15 +973,7 @@ export const INITIAL_ACTOR_DATA = {
     armors: [],
     supernaturalShields: [],
     damageReduction: {
-      base: {
-        value: 0
-      },
-      special: {
-        value: 0
-      },
-      final: {
-        value: 0
-      }
+      __type: '{"type":"NumericalValue"}'
     }
   },
 

src/module/actor/types/BaseType.js

@@ -10,6 +10,39 @@ export class BaseType {
     this.systemPath = systemPath;
   }
 
+  // ---- Instance extra deps (per derived spec id) ----
+  _instanceExtraDeps = new Map();
+
+  /** @param {string} specId @param {string[]} deps */
+  setInstanceDeps(specId, deps) {
+    const arr = Array.isArray(deps) ? deps.filter(Boolean) : [];
+    this._instanceExtraDeps.set(specId, arr);
+  }
+
+  /** @param {string} specId */
+  clearInstanceDeps(specId) {
+    this._instanceExtraDeps.delete(specId);
+  }
+
+  /** @param {string} specId @returns {string[]} */
+  getInstanceDeps(specId) {
+    return this._instanceExtraDeps.get(specId) ?? [];
+  }
+
+  /**
+   * Merge instance deps into the provided specs.
+   * Call this at the end of getDerivedFlowSpecs() in subclasses.
+   *
+   * @param {Array<{id:string,deps:string[],mods:string[],compute:Function}>} specs
+   */
+  _mergeInstanceDeps(specs) {
+    return (specs ?? []).map(s => {
+      const extra = this.getInstanceDeps(s.id);
+      if (!extra.length) return s;
+      return { ...s, deps: [...(s.deps ?? []), ...extra] };
+    });
+  }
+
   _get(relPath, fallback = undefined) {
     return (
       foundry.utils.getProperty(this.actor, `${this.systemPath}.${relPath}`) ?? fallback
@@ -44,7 +77,12 @@ export class BaseType {
     throw new Error(`${this.constructor.name}.applyDerived() not implemented.`);
   }
 
-  /** Structure defaults used for migrations */
+  /** Common fields shared by all typed nodes */
+  static commonDefaults() {
+    return { key: '' };
+  }
+
+  /** Type-specific defaults used for migrations */
   static defaults() {
     return {};
   }
@@ -63,13 +101,18 @@ export class BaseType {
 
     const normalized = this.normalizeInflateInput(combined);
 
-    const merged = foundry.utils.mergeObject(this.defaults(), normalized, {
+    const base = foundry.utils.mergeObject(BaseType.commonDefaults(), this.defaults(), {
+      inplace: false,
+      insertKeys: true,
+      insertValues: true
+    });
+
+    const merged = foundry.utils.mergeObject(base, normalized, {
       inplace: false,
       insertKeys: true,
       insertValues: true
     });
 
-    // IMPORTANT: remove legacy keys like "value" or "__type"
     return this.pruneToDefaults(merged);
   }
 
@@ -82,7 +125,11 @@ export class BaseType {
   static pruneToDefaults(obj) {
     if (!obj || typeof obj !== 'object') return obj;
 
-    const allowed = new Set(Object.keys(this.defaults()));
+    const allowed = new Set([
+      ...Object.keys(BaseType.commonDefaults()),
+      ...Object.keys(this.defaults())
+    ]);
+
     for (const k of Object.keys(obj)) {
       if (!allowed.has(k)) delete obj[k];
     }
@@ -96,11 +143,102 @@ export class BaseType {
    * @returns {object}
    */
   static sanitize(data) {
-    const merged = foundry.utils.mergeObject(this.defaults(), data ?? {}, {
+    const base = foundry.utils.mergeObject(BaseType.commonDefaults(), this.defaults(), {
       inplace: false,
       insertKeys: true,
       insertValues: true
     });
+
+    const merged = foundry.utils.mergeObject(base, data ?? {}, {
+      inplace: false,
+      insertKeys: true,
+      insertValues: true
+    });
+
     return this.pruneToDefaults(merged);
   }
+
+  getByKey(type, key) {
+    return this.actor.typedRepo?.get(type)?.get(key) ?? null;
+  }
+
+  getValueByKey(type, key, relPath) {
+    const node = this.getByKey(type, key);
+    if (!node) return undefined;
+    return foundry.utils.getProperty(this.actor, `${node.systemPath}.${relPath}`);
+  }
+
+  get key() {
+    // If key is not stored, default to the last segment of the system path
+    const stored = this._get('key', '');
+    if (stored) return stored;
+
+    const parts = String(this.systemPath ?? '').split('.');
+    return parts.length ? parts[parts.length - 1] : '';
+  }
+
+  set key(v) {
+    this._set('key', String(v ?? ''));
+  }
+
+  /**
+   * Persist the default key if it's missing or empty.
+   * This writes into the actor's system data (in-memory). Persisting to the document
+   * should be done by the caller (e.g. ABFActor.updateSource in prepareDerivedData).
+   *
+   * @returns {string} The key after ensuring.
+   */
+  ensureDefaultKey() {
+    const current = this._get('key', undefined);
+    if (current == null || current === '') {
+      const derived = BaseType.deriveKeyFromSystemPath(this.systemPath);
+      if (derived) this._set('key', derived);
+      return derived;
+    }
+    return String(current);
+  }
+
+  /**
+   * Static helper to persist a default key on raw system data, without needing an instance.
+   * Useful if you prefer to patch this.system directly in ABFActor.
+   *
+   * @param {object} systemRoot Usually actor.system
+   * @param {string} systemPath Path to the node (e.g. "system.characteristics.primaries.agility")
+   * @returns {boolean} True if it changed something
+   */
+  static ensureDefaultKeyOnNodeData(systemRoot, systemPath) {
+    if (!systemRoot || typeof systemRoot !== 'object') return false;
+    if (!systemPath || typeof systemPath !== 'string') return false;
+
+    const keyPath = `${systemPath}.key`;
+    const current = foundry.utils.getProperty(systemRoot, keyPath);
+
+    if (current == null || current === '') {
+      const derived = BaseType.deriveKeyFromSystemPath(systemPath);
+      if (!derived) return false;
+      foundry.utils.setProperty(systemRoot, keyPath, derived);
+      return true;
+    }
+
+    return false;
+  }
+
+  static deriveKeyFromSystemPath(systemPath) {
+    const parts = String(systemPath ?? '').split('.');
+    return parts.length ? parts[parts.length - 1] : '';
+  }
+
+  static editorConfig() {
+    return {
+      readonly: ['key'],
+      hidden: [],
+      labels: { key: 'Key' },
+      order: [],
+      overrides: {
+        // Example:
+        // key: { readonly: false },
+        // 'someField.value': { hidden: true }
+      }
+    };
+  }
 }