ADD - Characteristics as types & modifier applying order

Author: Julen-BZ

package.json

@@ -1,7 +1,7 @@
 {
   "private": true,
   "name": "anima-beyond-foundry",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Unofficial Anima Beyond Fantasy system for Foundry VTT",
   "type": "module",
   "scripts": {

src/animabf.mjs

@@ -1,5 +1,5 @@
 import { registerSettings, ABFSettingsKeys } from './utils/registerSettings';
-import { Logger, preloadTemplates } from './utils';
+import { Logger, TEMPLATE_PATHS } from './utils';
 import ABFActorSheet from './module/actor/ABFActorSheet';
 import ABFFoundryRoll from './module/rolls/ABFFoundryRoll';
 import ABFCombat from './module/combat/ABFCombat';
@@ -21,7 +21,7 @@ import { preloadClickHandlers } from './module/actor/utils/createClickHandlers.j
 
 import { ABFAttackData } from './module/combat/ABFAttackData.js';
 import { getChatContextMenuFactories } from './utils/buildChatContextMenu.js';
-import { Templates } from './module/utils/constants';
+import { Templates, HandlebarsPartials } from './module/utils/constants';
 
 import './scss/animabf.scss';
 
@@ -30,6 +30,8 @@ import { System, registerSystemOnGame } from './utils/systemMeta';
 import { resolveTokenName } from './utils/tokenName.js';
 import { FormulaEvaluator } from './utils/formulaEvaluator.js';
 
+import { registerHandlebarsPartials } from './utils/handlebarsPartials.js';
+
 /* ------------------------------------ */
 /* Initialize system */
 /* ------------------------------------ */
@@ -38,17 +40,18 @@ Hooks.once('init', async () => {
   registerSystemOnGame();
   Logger.log('Game Id:' + System.id);
 
-  // Preload Handlebars templates
-  await preloadTemplates();
+  window.ABFFoundryRoll = ABFFoundryRoll;
+  CONFIG.Dice.rolls = [ABFFoundryRoll, ...CONFIG.Dice.rolls];
+
+  // Load Handlebars templates
+  await loadTemplates(TEMPLATE_PATHS);
+  await registerHandlebarsPartials(HandlebarsPartials);
 
   // Assign custom classes and constants here
   CONFIG.Actor.documentClass = ABFActor;
 
   CONFIG.config = ABFConfig;
 
-  window.ABFFoundryRoll = ABFFoundryRoll;
-  CONFIG.Dice.rolls = [ABFFoundryRoll, ...CONFIG.Dice.rolls];
-
   CONFIG.Combat.documentClass = ABFCombat;
   CONFIG.Combatant.documentClass = ABFCombatant;
 

src/lang/en.json

@@ -461,6 +461,7 @@
   "anima.ui.resistances.poison": "Poison",
   "anima.ui.resistances.psychic": "Psychic",
   "anima.ui.resistances.title": "Resistances",
+  "anima.ui.characteristics.title": "Characteristics",
   "anima.ui.secondaries.acrobatics.title": "Acrobatics",
   "anima.ui.secondaries.alchemy.title": "Alchemy",
   "anima.ui.secondaries.animals.title": "Animals",
@@ -819,6 +820,7 @@
   "anima.ui.tooltips.base": "Final",
   "anima.ui.tooltips.special": "Special",
   "anima.ui.tooltips.final": "Final",
+  "anima.ui.tooltips.mod": "Modifier",
   "keyBindings.damageCalculator.name": "Damage calculator",
   "keyBindings.damageCalculator.hint": "Open damage calculator",
   "keyBindings.sendAttack.name": "Send Attack",

src/lang/es.json

@@ -463,6 +463,7 @@
   "anima.ui.resistances.poison": "Venenos",
   "anima.ui.resistances.psychic": "Psíquica",
   "anima.ui.resistances.title": "Resistencias",
+  "anima.ui.characteristics.title": "Características",
   "anima.ui.secondaries.acrobatics.title": "Acrobacias",
   "anima.ui.secondaries.alchemy.title": "Alquimia",
   "anima.ui.secondaries.animals.title": "Animales",
@@ -821,6 +822,7 @@
   "anima.ui.tooltips.base": "Final",
   "anima.ui.tooltips.special": "Especial",
   "anima.ui.tooltips.final": "Final",
+  "anima.ui.tooltips.mod": "Modificador",
   "keyBindings.damageCalculator.name": "Calculadora de daño",
   "keyBindings.damageCalculator.hint": "Abre la calculadora de daño.",
   "keyBindings.sendAttack.name": "Enviar ataque",

src/lang/fr.json

@@ -434,6 +434,7 @@
   "anima.ui.resistances.poison": "Poisons",
   "anima.ui.resistances.psychic": "Psychique",
   "anima.ui.resistances.title": "Résistances",
+  "anima.ui.characteristics.title": "Characteristics",
   "anima.ui.secondaries.acrobatics.title": "Acrobaties",
   "anima.ui.secondaries.alchemy.title": "Alchimie",
   "anima.ui.secondaries.animals.title": "Animaux",
@@ -539,6 +540,7 @@
   "anima.ui.tooltips.base": "Final",
   "anima.ui.tooltips.final": "Final",
   "anima.ui.tooltips.special": "Spécial",
+  "anima.ui.tooltips.mod": "Modifier",
   "anima.ui.weapons.different.title": "Différent / Mains nues",
   "anima.ui.weapons.known.title": "Connu",
   "anima.ui.weapons.mixed.title": "1 ou 2 mains",

src/module/actor/ABFActor.js

@@ -22,6 +22,9 @@ import ABFFoundryRoll from '../rolls/ABFFoundryRoll';
 import { openModDialog } from '../utils/dialogs/openSimpleInputDialog';
 import ABFItem from '../items/ABFItem';
 import { FormulaEvaluator } from '../../utils/formulaEvaluator.js';
+import { inflateSystemFromTypeMarkers } from './types/inflateSystemFromTypeMarkers.js';
+import { TYPED_PATHS } from './types/typedTemplateIndex.js';
+import { buildTypedNodes } from './types/runtimeTypedNodes.js';
 
 export class ABFActor extends Actor {
   i18n = game.i18n;
@@ -42,14 +45,31 @@ export class ABFActor extends Actor {
     }
   }
 
+  async _preCreate(data, options, user) {
+    // Ensure system exists + template defaults
+    data.system = foundry.utils.mergeObject(data.system ?? {}, INITIAL_ACTOR_DATA, {
+      overwrite: false
+    });
+
+    // Inflate typed nodes from __type and remove markers
+    data.system = inflateSystemFromTypeMarkers(data.system);
+
+    return super._preCreate(data, options, user);
+  }
+
   async prepareDerivedData() {
     super.prepareDerivedData();
 
-    this.system = foundry.utils.mergeObject(this.system, INITIAL_ACTOR_DATA, {
-      overwrite: false
-    });
+    // this.system = foundry.utils.mergeObject(this.system, INITIAL_ACTOR_DATA, {
+    //   overwrite: false
+    // });
+
+    // Safety: if some actor came without inflation (old data / imports)
+    this.system = inflateSystemFromTypeMarkers(this.system);
 
+    buildTypedNodes(this, TYPED_PATHS);
     await prepareActor(this);
+    // applyTypedDerived(this);
   }
 
   getRollData() {
@@ -871,40 +891,10 @@ 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];
-        }
-      }
-    }
+    // Active Effects are applied in prepareActor using the flow ordering (per-change).
+    // We keep _applyDynamicEffectValue for evaluating dynamic change values.
+    return this;
   }
 
   _applyDynamicEffectValue(value) {

src/module/actor/ABFActorSheet.js

@@ -31,7 +31,7 @@ export default class ABFActorSheet extends ActorSheet {
       ...{
         classes: [game.animabf.id, 'sheet', 'actor'],
         template: 'systems/animabf/templates/actor/actor-sheet.hbs',
-        width: 1000,
+        width: 1100,
         height: 850,
         submitOnChange: true,
         viewPermission: CONST.DOCUMENT_OWNERSHIP_LEVELS.OBSERVER,
@@ -76,7 +76,7 @@ export default class ABFActorSheet extends ActorSheet {
       return 1300;
     }
 
-    return 1000;
+    return 1100;
   }
 
   async _render(force, options = {}) {

src/module/actor/constants.js

@@ -183,36 +183,28 @@ export const INITIAL_ACTOR_DATA = {
   characteristics: {
     primaries: {
       agility: {
-        value: 0,
-        mod: 0
+        __type: '{"type":"Characteristic"}'
       },
       constitution: {
-        value: 0,
-        mod: 0
+        __type: '{"type":"Characteristic"}'
       },
       dexterity: {
-        value: 0,
-        mod: 0
+        __type: '{"type":"Characteristic"}'
       },
       strength: {
-        value: 0,
-        mod: 0
+        __type: '{"type":"Characteristic"}'
       },
       intelligence: {
-        value: 0,
-        mod: 0
+        __type: '{"type":"Characteristic"}'
       },
       perception: {
-        value: 0,
-        mod: 0
+        __type: '{"type":"Characteristic"}'
       },
       power: {
-        value: 0,
-        mod: 0
+        __type: '{"type":"Characteristic"}'
       },
       willPower: {
-        value: 0,
-        mod: 0
+        __type: '{"type":"Characteristic"}'
       }
     },
     secondaries: {

src/module/actor/types/BaseType.js

@@ -0,0 +1,106 @@
+export class BaseType {
+  static type = 'BaseType';
+
+  constructor(actor, systemPath) {
+    if (new.target === BaseType) {
+      throw new Error('BaseType is abstract and cannot be instantiated directly.');
+    }
+
+    this.actor = actor;
+    this.systemPath = systemPath;
+  }
+
+  _get(relPath, fallback = undefined) {
+    return (
+      foundry.utils.getProperty(this.actor, `${this.systemPath}.${relPath}`) ?? fallback
+    );
+  }
+
+  _set(relPath, value) {
+    foundry.utils.setProperty(this.actor, `${this.systemPath}.${relPath}`, value);
+  }
+
+  /**
+   * Returns derived calculation specs for effectFlow.
+   * Subclasses should override and may return multiple specs (e.g. "final", "mod").
+   *
+   * - deps/mods are RELATIVE to this.systemPath (e.g. "base.value")
+   * - compute must be a pure function (no side-effects) that returns an object
+   *   with keys matching the logical fields written by mods (e.g. { final: 10 }).
+   *
+   * @returns {Array<{
+   *   id: string,
+   *   deps: string[],
+   *   mods: string[],
+   *   compute: (inputs: Record<string, any>) => Record<string, any>
+   * }>}
+   */
+  getDerivedFlowSpecs() {
+    return [];
+  }
+
+  // Optionally keep applyDerived temporarily (legacy)
+  applyDerived() {
+    throw new Error(`${this.constructor.name}.applyDerived() not implemented.`);
+  }
+
+  /** Structure defaults used for migrations */
+  static defaults() {
+    return {};
+  }
+
+  static normalizeInflateInput(node) {
+    // Default: no-op
+    return node;
+  }
+
+  static inflate(overrides, nodeWithoutMarker) {
+    const combined = foundry.utils.mergeObject(overrides ?? {}, nodeWithoutMarker ?? {}, {
+      inplace: false,
+      insertKeys: true,
+      insertValues: true
+    });
+
+    const normalized = this.normalizeInflateInput(combined);
+
+    const merged = foundry.utils.mergeObject(this.defaults(), normalized, {
+      inplace: false,
+      insertKeys: true,
+      insertValues: true
+    });
+
+    // IMPORTANT: remove legacy keys like "value" or "__type"
+    return this.pruneToDefaults(merged);
+  }
+
+  /**
+   * Remove keys that are not part of this type's default shape.
+   * Mutates and returns the same object.
+   * @param {object} obj
+   * @returns {object}
+   */
+  static pruneToDefaults(obj) {
+    if (!obj || typeof obj !== 'object') return obj;
+
+    const allowed = new Set(Object.keys(this.defaults()));
+    for (const k of Object.keys(obj)) {
+      if (!allowed.has(k)) delete obj[k];
+    }
+    return obj;
+  }
+
+  /**
+   * Convenience: merge defaults + data, then prune to defaults shape.
+   * Returns a new object.
+   * @param {object} data
+   * @returns {object}
+   */
+  static sanitize(data) {
+    const merged = foundry.utils.mergeObject(this.defaults(), data ?? {}, {
+      inplace: false,
+      insertKeys: true,
+      insertValues: true
+    });
+    return this.pruneToDefaults(merged);
+  }
+}

src/module/actor/types/TypeRegistry.js

@@ -0,0 +1,27 @@
+export class TypeRegistry {
+  static #byType = new Map(); // type -> ctor
+
+  static get size() {
+    return this.#byType.size;
+  }
+
+  static register(ctor) {
+    this.#byType.set(ctor.type, ctor);
+  }
+
+  static get(type) {
+    return this.#byType.get(type) ?? null;
+  }
+
+  static create(type, actor, systemPath) {
+    const ctor = this.get(type);
+    if (!ctor) throw new Error(`Unknown type: ${type}`);
+    return new ctor(actor, systemPath);
+  }
+
+  static defaultsFor(type) {
+    const ctor = this.get(type);
+    if (!ctor) throw new Error(`Unknown type: ${type}`);
+    return ctor.defaults();
+  }
+}