Refactor/actions v2 (#402)

* Action Refactor Part #1

* Fixed Weapon/Armor features. Fixed Feature actions

* f

* Action Refactor Part #2

* Fixes

* Remove ActionsField from Companion

* Fixes

* Localization fix

* BaseDataItem hasActions false

---------

Co-authored-by: WBHarry <williambjrklund@gmail.com>

module/data/fields/_module.mjs

@@ -1,3 +1,6 @@
+export { ActionCollection } from './actionField.mjs';
 export { default as FormulaField } from './formulaField.mjs';
 export { default as ForeignDocumentUUIDField } from './foreignDocumentUUIDField.mjs';
 export { default as ForeignDocumentUUIDArrayField } from './foreignDocumentUUIDArrayField.mjs';
+export { default as MappingField } from './mappingField.mjs';
+export * as ActionFields from './action/_module.mjs';

module/data/fields/action/_module.mjs

@@ -0,0 +1,10 @@
+export { default as CostField } from './costField.mjs';
+export { default as UsesField } from './usesField.mjs';
+export { default as RangeField } from './rangeField.mjs';
+export { default as TargetField } from './targetField.mjs';
+export { default as EffectsField } from './effectsField.mjs';
+export { default as SaveField } from './saveField.mjs';
+export { default as BeastformField } from './beastformField.mjs';
+export { default as DamageField } from './damageField.mjs';
+export { default as HealingField } from './healingField.mjs';
+export { default as RollField } from './rollField.mjs';

module/data/fields/action/beastformField.mjs

@@ -0,0 +1,12 @@
+const fields = foundry.data.fields;
+
+export default class BeastformField extends fields.SchemaField {
+    constructor(options={}, context={}) {
+        const beastformFields = {
+            tierAccess: new fields.SchemaField({
+                exact: new fields.NumberField({ integer: true, nullable: true, initial: null })
+            })
+        };
+        super(beastformFields, options, context);
+    }
+}

module/data/fields/action/costField.mjs

@@ -0,0 +1,82 @@
+const fields = foundry.data.fields;
+
+export default class CostField extends fields.ArrayField {
+    constructor(options={}, context={}) {
+        const element = new fields.SchemaField({
+            key: new fields.StringField({
+                nullable: false,
+                required: true,
+                initial: 'hope'
+            }),
+            keyIsID: new fields.BooleanField(),
+            value: new fields.NumberField({ nullable: true, initial: 1 }),
+            scalable: new fields.BooleanField({ initial: false }),
+            step: new fields.NumberField({ nullable: true, initial: null })
+        });
+        super(element, options, context);
+    }
+
+    static prepareConfig(config) {
+        const costs = this.cost?.length ? foundry.utils.deepClone(this.cost) : [];
+        config.costs = CostField.calcCosts.call(this, costs);
+        const hasCost = CostField.hasCost.call(this, config.costs);
+        if(config.isFastForward && !hasCost)
+            return ui.notifications.warn("You don't have the resources to use that action.");
+        return hasCost;
+    }
+
+    static calcCosts(costs) {
+        return costs.map(c => {
+            c.scale = c.scale ?? 1;
+            c.step = c.step ?? 1;
+            c.total = c.value * c.scale * c.step;
+            c.enabled = c.hasOwnProperty('enabled') ? c.enabled : true;
+            return c;
+        });
+    }
+
+    static hasCost(costs) {
+        const realCosts = CostField.getRealCosts.call(this, costs),
+            hasFearCost = realCosts.findIndex(c => c.key === 'fear');
+        if (hasFearCost > -1) {
+            const fearCost = realCosts.splice(hasFearCost, 1)[0];
+            if (
+                !game.user.isGM ||
+                fearCost.total > game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Resources.Fear)
+            )
+                return false;
+        }
+
+        /* isReversed is a sign that the resource is inverted, IE it counts upwards instead of down */
+        const resources = CostField.getResources.call(this, realCosts);
+        return realCosts.reduce(
+            (a, c) =>
+                a && resources[c.key].isReversed
+                    ? resources[c.key].value + (c.total ?? c.value) <= resources[c.key].max
+                    : resources[c.key]?.value >= (c.total ?? c.value),
+            true
+        );
+    }
+
+    static getResources(costs) {
+        const actorResources = this.actor.system.resources;
+        const itemResources = {};
+        for (var itemResource of costs) {
+            if (itemResource.keyIsID) {
+                itemResources[itemResource.key] = {
+                    value: this.parent.resource.value ?? 0
+                };
+            }
+        }
+
+        return {
+            ...actorResources,
+            ...itemResources
+        };
+    }
+
+    static getRealCosts(costs) {
+        const realCosts = costs?.length ? costs.filter(c => c.enabled) : [];
+        return realCosts;
+    }
+}

module/data/fields/action/damageField.mjs

@@ -0,0 +1,84 @@
+import FormulaField from "../formulaField.mjs";
+
+const fields = foundry.data.fields;
+
+export default class DamageField extends fields.SchemaField {
+    constructor(options, context = {}) {
+        const damageFields = {
+            parts: new fields.ArrayField(new fields.EmbeddedDataField(DHDamageData)),
+            includeBase: new fields.BooleanField({
+                initial: false,
+                label: 'DAGGERHEART.ACTIONS.Settings.includeBase.label'
+            })
+        };
+        super(damageFields, options, context);
+    }
+}
+
+export class DHActionDiceData extends foundry.abstract.DataModel {
+    /** @override */
+    static defineSchema() {
+        return {
+            multiplier: new fields.StringField({
+                choices: CONFIG.DH.GENERAL.multiplierTypes,
+                initial: 'prof',
+                label: 'Multiplier'
+            }),
+            flatMultiplier: new fields.NumberField({ nullable: true, initial: 1, label: 'Flat Multiplier' }),
+            dice: new fields.StringField({ choices: CONFIG.DH.GENERAL.diceTypes, initial: 'd6', label: 'Dice' }),
+            bonus: new fields.NumberField({ nullable: true, initial: null, label: 'Bonus' }),
+            custom: new fields.SchemaField({
+                enabled: new fields.BooleanField({ label: 'Custom Formula' }),
+                formula: new FormulaField({ label: 'Formula' })
+            })
+        };
+    }
+
+    getFormula() {
+        const multiplier = this.multiplier === 'flat' ? this.flatMultiplier : `@${this.multiplier}`,
+            bonus = this.bonus ? (this.bonus < 0 ? ` - ${Math.abs(this.bonus)}` : ` + ${this.bonus}`) : '';
+        return this.custom.enabled ? this.custom.formula : `${multiplier ?? 1}${this.dice}${bonus}`;
+    }
+}
+
+export class DHResourceData extends foundry.abstract.DataModel {
+    /** @override */
+    static defineSchema() {
+        return {
+            applyTo: new fields.StringField({
+                choices: CONFIG.DH.GENERAL.healingTypes,
+                required: true,
+                blank: false,
+                initial: CONFIG.DH.GENERAL.healingTypes.hitPoints.id,
+                label: 'DAGGERHEART.ACTIONS.Settings.applyTo.label'
+            }),
+            resultBased: new fields.BooleanField({
+                initial: false,
+                label: 'DAGGERHEART.ACTIONS.Settings.resultBased.label'
+            }),
+            value: new fields.EmbeddedDataField(DHActionDiceData),
+            valueAlt: new fields.EmbeddedDataField(DHActionDiceData)
+        };
+    }
+}
+
+export class DHDamageData extends DHResourceData {
+    /** @override */
+    static defineSchema() {
+        return {
+            ...super.defineSchema(),
+            base: new fields.BooleanField({ initial: false, readonly: true, label: 'Base' }),
+            type: new fields.SetField(
+                new fields.StringField({
+                    choices: CONFIG.DH.GENERAL.damageTypes,
+                    initial: 'physical',
+                    nullable: false,
+                    required: true
+                }),
+                {
+                    label: 'Type'
+                }
+            )
+        };
+    }
+}

module/data/fields/action/effectsField.mjs

@@ -0,0 +1,11 @@
+const fields = foundry.data.fields;
+
+export default class EffectsField extends fields.ArrayField {
+    constructor(options={}, context={}) {
+        const element = new fields.SchemaField({
+            _id: new fields.DocumentIdField(),
+            onSave: new fields.BooleanField({ initial: false })
+        });
+        super(element, options, context);
+    }
+}

module/data/fields/action/healingField.mjs

@@ -0,0 +1,9 @@
+import { DHDamageData } from "./damageField.mjs";
+
+const fields = foundry.data.fields;
+
+export default class HealingField extends fields.EmbeddedDataField {
+    constructor(options, context = {}) {
+        super(DHDamageData, options, context);
+    }
+}

module/data/fields/action/rangeField.mjs

@@ -0,0 +1,16 @@
+const fields = foundry.data.fields;
+
+export default class RangeField extends fields.StringField {
+    constructor(context={}) {
+        const options = {
+            choices: CONFIG.DH.GENERAL.range,
+            required: false,
+            blank: true
+        };
+        super(options, context);
+    }
+
+    static prepareConfig(config) {
+        return true;
+    }
+}

module/data/fields/action/rollField.mjs

@@ -0,0 +1,58 @@
+const fields = foundry.data.fields;
+
+export class DHActionRollData extends foundry.abstract.DataModel {
+    /** @override */
+    static defineSchema() {
+        return {
+            type: new fields.StringField({ nullable: true, initial: null, choices: CONFIG.DH.GENERAL.rollTypes }),
+            trait: new fields.StringField({ nullable: true, initial: null, choices: CONFIG.DH.ACTOR.abilities }),
+            difficulty: new fields.NumberField({ nullable: true, initial: null, integer: true, min: 0 }),
+            bonus: new fields.NumberField({ nullable: true, initial: null, integer: true }),
+            advState: new fields.StringField({ choices: CONFIG.DH.ACTIONS.advandtageState, initial: 'neutral' }),
+            diceRolling: new fields.SchemaField({
+                multiplier: new fields.StringField({
+                    choices: CONFIG.DH.GENERAL.diceSetNumbers,
+                    initial: 'prof',
+                    label: 'Dice Number'
+                }),
+                flatMultiplier: new fields.NumberField({ nullable: true, initial: 1, label: 'Flat Multiplier' }),
+                dice: new fields.StringField({
+                    choices: CONFIG.DH.GENERAL.diceTypes,
+                    initial: 'd6',
+                    label: 'Dice Type'
+                }),
+                compare: new fields.StringField({
+                    choices: CONFIG.DH.ACTIONS.diceCompare,
+                    initial: 'above',
+                    label: 'Should be'
+                }),
+                treshold: new fields.NumberField({ initial: 1, integer: true, min: 1, label: 'Treshold' })
+            }),
+            useDefault: new fields.BooleanField({ initial: false })
+        };
+    }
+
+    getFormula() {
+        if (!this.type) return;
+        let formula = '';
+        switch (this.type) {
+            case 'diceSet':
+                const multiplier =
+                    this.diceRolling.multiplier === 'flat'
+                        ? this.diceRolling.flatMultiplier
+                        : `@${this.diceRolling.multiplier}`;
+                formula = `${multiplier}${this.diceRolling.dice}cs${CONFIG.DH.ACTIONS.diceCompare[this.diceRolling.compare].operator}${this.diceRolling.treshold}`;
+                break;
+            default:
+                formula = '';
+                break;
+        }
+        return formula;
+    }
+}
+
+export default class RollField extends fields.EmbeddedDataField {
+    constructor(options, context = {}) {
+        super(DHActionRollData, options, context);
+    }
+}

module/data/fields/action/saveField.mjs

@@ -0,0 +1,19 @@
+const fields = foundry.data.fields;
+
+export default class SaveField extends fields.SchemaField {
+    constructor(options={}, context={}) {
+        const saveFields = {
+            trait: new fields.StringField({
+                nullable: true,
+                initial: null,
+                choices: CONFIG.DH.ACTOR.abilities
+            }),
+            difficulty: new fields.NumberField({ nullable: true, initial: 10, integer: true, min: 0 }),
+            damageMod: new fields.StringField({
+                initial: CONFIG.DH.ACTIONS.damageOnSave.none.id,
+                choices: CONFIG.DH.ACTIONS.damageOnSave
+            })
+        };
+        super(saveFields, options, context);
+    }
+}

module/data/fields/action/targetField.mjs

@@ -0,0 +1,62 @@
+const fields = foundry.data.fields;
+
+export default class TargetField extends fields.SchemaField {
+    constructor(options={}, context={}) {
+        const targetFields = {
+            type: new fields.StringField({
+                choices: CONFIG.DH.ACTIONS.targetTypes,
+                initial: CONFIG.DH.ACTIONS.targetTypes.any.id,
+                nullable: true,
+                initial: null
+            }),
+            amount: new fields.NumberField({ nullable: true, initial: null, integer: true, min: 0 })
+        };
+        super(targetFields, options, context);
+    }
+
+    static prepareConfig(config) {
+        if (!this.target?.type) return [];
+        let targets;
+        if (this.target?.type === CONFIG.DH.ACTIONS.targetTypes.self.id)
+            targets = TargetField.formatTarget.call(this, this.actor.token ?? this.actor.prototypeToken);
+        targets = Array.from(game.user.targets);
+        if (this.target.type !== CONFIG.DH.ACTIONS.targetTypes.any.id) {
+            targets = targets.filter(t => TargetField.isTargetFriendly.call(this, t));
+            if (this.target.amount && targets.length > this.target.amount) targets = [];
+        }
+        config.targets = targets.map(t => TargetField.formatTarget.call(this, t));
+        const hasTargets = TargetField.checkTargets.call(this, this.target.amount, config.targets);
+        if(config.isFastForward && !hasTargets)
+            return ui.notifications.warn('Too many targets selected for that actions.');
+        return hasTargets;
+    }
+
+    static checkTargets(amount, targets) {
+        return true
+        // return !amount || (targets.length > amount);
+    }
+
+    static isTargetFriendly(target) {
+        const actorDisposition = this.actor.token
+                ? this.actor.token.disposition
+                : this.actor.prototypeToken.disposition,
+            targetDisposition = target.document.disposition;
+        return (
+            (this.target.type === CONFIG.DH.ACTIONS.targetTypes.friendly.id &&
+                actorDisposition === targetDisposition) ||
+            (this.target.type === CONFIG.DH.ACTIONS.targetTypes.hostile.id &&
+                actorDisposition + targetDisposition === 0)
+        );
+    }
+
+    static formatTarget(actor) {
+        return {
+            id: actor.id,
+            actorId: actor.actor.uuid,
+            name: actor.actor.name,
+            img: actor.actor.img,
+            difficulty: actor.actor.system.difficulty,
+            evasion: actor.actor.system.evasion
+        };
+    }
+}

module/data/fields/action/usesField.mjs

@@ -0,0 +1,39 @@
+const fields = foundry.data.fields;
+
+export default class UsesField extends fields.SchemaField {
+    constructor(options={}, context={}) {
+        const usesFields = {
+            value: new fields.NumberField({ nullable: true, initial: null }),
+            max: new fields.NumberField({ nullable: true, initial: null }),
+            recovery: new fields.StringField({
+                choices: CONFIG.DH.GENERAL.refreshTypes,
+                initial: null,
+                nullable: true
+            })
+        };
+        super(usesFields, options, context);
+    }
+
+    static prepareConfig(config) {
+        const uses = this.uses?.max ? foundry.utils.deepClone(this.uses) : null;
+        if (uses && !uses.value) uses.value = 0;
+        config.uses = uses;
+        const hasUses = UsesField.hasUses.call(this, config.uses);
+        if(config.isFastForward && !hasUses)
+            return ui.notifications.warn("That action doesn't have remaining uses.");
+        return hasUses;
+    }
+
+    static calcUses(uses) {
+        if (!uses) return null;
+        return {
+            ...uses,
+            enabled: uses.hasOwnProperty('enabled') ? uses.enabled : true
+        };
+    }
+
+    static hasUses(uses) {
+        if (!uses) return true;
+        return (uses.hasOwnProperty('enabled') && !uses.enabled) || uses.value + 1 <= uses.max;
+    }
+}

module/data/fields/actionField.mjs

@@ -1,4 +1,85 @@
-export default class ActionField extends foundry.data.fields.ObjectField {
+import DHActionConfig from "../../applications/sheets-configs/action-config.mjs";
+import MappingField from "./mappingField.mjs";
+
+/**
+ * Specialized collection type for stored actions.
+ * @param {DataModel} model     The parent DataModel to which this ActionCollection belongs.
+ * @param {Action[]} entries  The actions to store.
+ */
+export class ActionCollection extends Collection {
+  constructor(model, entries) {
+    super();
+    this.#model = model;
+    for ( const entry of entries ) {
+      if ( !(entry instanceof game.system.api.models.actions.actionsTypes.base) ) continue;
+      this.set(entry._id, entry);
+    }
+  }
+
+  /* -------------------------------------------- */
+  /*  Properties                                  */
+  /* -------------------------------------------- */
+
+  /**
+   * The parent DataModel to which this ActionCollection belongs.
+   * @type {DataModel}
+   */
+  #model;
+
+  /* -------------------------------------------- */
+
+  /* -------------------------------------------- */
+  /*  Methods                                     */
+  /* -------------------------------------------- */
+
+  /* -------------------------------------------- */
+
+  /**
+   * Test the given predicate against every entry in the Collection.
+   * @param {function(*, number, ActionCollection): boolean} predicate  The predicate.
+   * @returns {boolean}
+   */
+  every(predicate) {
+    return this.reduce((pass, v, i) => pass && predicate(v, i, this), true);
+  }
+
+  /* -------------------------------------------- */
+
+  /**
+   * Convert the ActionCollection to an array of simple objects.
+   * @param {boolean} [source=true]  Draw data for contained Documents from the underlying data source?
+   * @returns {object[]}             The extracted array of primitive objects.
+   */
+  toObject(source=true) {
+    return this.map(doc => doc.toObject(source));
+  }
+}
+
+/* -------------------------------------------- */
+
+/**
+ * Field that stores actions.
+ */
+export class ActionsField extends MappingField {
+  constructor(options) {
+    super(new ActionField(), options);
+  }
+
+  /* -------------------------------------------- */
+
+  /** @inheritDoc */
+  initialize(value, model, options) {
+    const actions = Object.values(super.initialize(value, model, options));
+    return new ActionCollection(model, actions);
+  }
+}
+
+/* -------------------------------------------- */
+
+/**
+ * Field that stores action data and swaps class based on action type.
+ */
+export class ActionField extends foundry.data.fields.ObjectField {
     getModel(value) {
         return game.system.api.models.actions.actionsTypes[value.type] ?? game.system.api.models.actions.actionsTypes.attack;
     }
@@ -35,3 +116,141 @@ export default class ActionField extends foundry.data.fields.ObjectField {
         if (cls) cls.migrateDataSafe(fieldData);
     }
 }
+
+/* -------------------------------------------- */
+
+export function ActionMixin(Base) {
+    class Action extends Base {
+        static metadata = Object.freeze({
+          name: "Action",
+          label: "DAGGERHEART.GENERAL.Action.single",
+          sheetClass: DHActionConfig
+        });
+
+        static _sheets = new Map();
+        
+        static get documentName() {
+          return this.metadata.name;
+        }
+
+        get documentName() {
+          return this.constructor.documentName;
+        }
+
+        static defaultName() {
+          return this.documentName;
+        }
+        
+        get relativeUUID() {
+          return `.Item.${this.item.id}.Action.${this.id}`;
+        }
+
+        get uuid() {
+          return `${this.item.uuid}.${this.documentName}.${this.id}`;
+        }
+
+        get sheet() {
+          if(!this.constructor._sheets.has(this.uuid)) {
+            const sheet = new this.constructor.metadata.sheetClass(this);
+            this.constructor._sheets.set(this.uuid, sheet);
+          }
+          return this.constructor._sheets.get(this.uuid);
+        }
+
+        get inCollection() {
+          return foundry.utils.getProperty(this.parent, this.systemPath) instanceof Collection;
+        }
+
+        static async create(data, operation={}) {
+          const { parent, renderSheet } = operation;
+          let { type } = data;
+          if(!type || !game.system.api.models.actions.actionsTypes[type]) {
+            ({ type } =
+                (await foundry.applications.api.DialogV2.input({
+                    window: { title: 'Select Action Type' },
+                    content: await foundry.applications.handlebars.renderTemplate(
+                        'systems/daggerheart/templates/actionTypes/actionType.hbs',
+                        { types: CONFIG.DH.ACTIONS.actionTypes }
+                    ),
+                    ok: {
+                        label: game.i18n.format('DOCUMENT.Create', {
+                            type: game.i18n.localize('DAGGERHEART.GENERAL.Action.single')
+                        })
+                    }
+                })) ?? {});
+          }
+          if (!type) return;
+          
+          const cls = game.system.api.models.actions.actionsTypes[type];
+          const action = new cls(
+              {
+                type,
+                ...cls.getSourceConfig(parent)
+              },
+              {
+                parent
+              }
+          );
+          const created = await parent.parent.update({ [`system.actions.${action.id}`]: action.toObject() });
+          const newAction = parent.actions.get(action.id);
+          if(!newAction) return null;
+          if( renderSheet ) newAction.sheet.render({ force: true });
+          return newAction;
+        }
+
+        async update(updates, options={}) {
+          const path = this.inCollection ? `system.${this.systemPath}.${this.id}` : `system.${this.systemPath}`,
+            result = await this.item.update({[path]: updates}, options);
+          return this.inCollection ? foundry.utils.getProperty(result, `system.${this.systemPath}`).get(this.id) : foundry.utils.getProperty(result, `system.${this.systemPath}`);
+        }
+
+        delete() {
+          if(!this.inCollection) return this.item;
+          const action = foundry.utils.getProperty(this.item, `system.${this.systemPath}`)?.get(this.id);
+          if ( !action ) return this.item;
+          this.item.update({ [`system.${this.systemPath}.-=${this.id}`]: null });
+          this.constructor._sheets.get(this.uuid)?.close();
+        }
+
+        async deleteDialog() {
+          const confirmed = await foundry.applications.api.DialogV2.confirm({
+              window: {
+                  title: game.i18n.format('DAGGERHEART.APPLICATIONS.DeleteConfirmation.title', {
+                      type: game.i18n.localize(`DAGGERHEART.GENERAL.Action.single`),
+                      name: this.name
+                  })
+              },
+              content: game.i18n.format('DAGGERHEART.APPLICATIONS.DeleteConfirmation.text', {
+                  name: this.name
+              })
+          });
+          if (!confirmed) return;
+          return this.delete();
+        }
+
+        async toChat(origin) {
+          const cls = getDocumentClass('ChatMessage');
+          const systemData = {
+              title: game.i18n.localize('DAGGERHEART.CONFIG.ActionType.action'),
+              origin: origin,
+              img: this.img,
+              name: this.name,
+              description: this.description,
+              actions: []
+          };
+          const msg = {
+              type: 'abilityUse',
+              user: game.user.id,
+              system: systemData,
+              content: await foundry.applications.handlebars.renderTemplate(
+                  'systems/daggerheart/templates/ui/chat/ability-use.hbs',
+                  systemData
+              )
+          };
+
+          cls.create(msg);
+        }
+    }
+
+    return Action;
+}

module/data/fields/mappingField.mjs

@@ -0,0 +1,128 @@
+/**
+ * A subclass of ObjectField that represents a mapping of keys to the provided DataField type.
+ *
+ * @param {DataField} model                    The class of DataField which should be embedded in this field.
+ * @param {MappingFieldOptions} [options={}]   Options which configure the behavior of the field.
+ * @property {string[]} [initialKeys]          Keys that will be created if no data is provided.
+ * @property {MappingFieldInitialValueBuilder} [initialValue]  Function to calculate the initial value for a key.
+ * @property {boolean} [initialKeysOnly=false]  Should the keys in the initialized data be limited to the keys provided
+ *                                              by `options.initialKeys`?
+ */
+export default class MappingField extends foundry.data.fields.ObjectField {
+  constructor(model, options) {
+    if ( !(model instanceof foundry.data.fields.DataField) ) {
+      throw new Error("MappingField must have a DataField as its contained element");
+    }
+    super(options);
+
+    /**
+     * The embedded DataField definition which is contained in this field.
+     * @type {DataField}
+     */
+    this.model = model;
+    model.parent = this;
+  }
+
+  /* -------------------------------------------- */
+
+  /** @inheritDoc */
+  static get _defaults() {
+    return foundry.utils.mergeObject(super._defaults, {
+      initialKeys: null,
+      initialValue: null,
+      initialKeysOnly: false
+    });
+  }
+
+  /* -------------------------------------------- */
+
+  /** @inheritDoc */
+  _cleanType(value, options) {
+    Object.entries(value).forEach(([k, v]) => {
+      if ( k.startsWith("-=") ) return;
+      value[k] = this.model.clean(v, options);
+    });
+    return value;
+  }
+
+  /* -------------------------------------------- */
+
+  /** @inheritDoc */
+  getInitialValue(data) {
+    let keys = this.initialKeys;
+    const initial = super.getInitialValue(data);
+    if ( !keys || !foundry.utils.isEmpty(initial) ) return initial;
+    if ( !(keys instanceof Array) ) keys = Object.keys(keys);
+    for ( const key of keys ) initial[key] = this._getInitialValueForKey(key);
+    return initial;
+  }
+
+  /* -------------------------------------------- */
+
+  /**
+   * Get the initial value for the provided key.
+   * @param {string} key       Key within the object being built.
+   * @param {object} [object]  Any existing mapping data.
+   * @returns {*}              Initial value based on provided field type.
+   */
+  _getInitialValueForKey(key, object) {
+    const initial = this.model.getInitialValue();
+    return this.initialValue?.(key, initial, object) ?? initial;
+  }
+
+  /* -------------------------------------------- */
+
+  /** @override */
+  _validateType(value, options={}) {
+    if ( foundry.utils.getType(value) !== "Object" ) throw new Error("must be an Object");
+    const errors = this._validateValues(value, options);
+    if ( !foundry.utils.isEmpty(errors) ) {
+      const failure = new foundry.data.validation.DataModelValidationFailure();
+      failure.elements = Object.entries(errors).map(([id, failure]) => ({ id, failure }));
+      throw failure.asError();
+    }
+  }
+
+  /* -------------------------------------------- */
+
+  /**
+   * Validate each value of the object.
+   * @param {object} value     The object to validate.
+   * @param {object} options   Validation options.
+   * @returns {Record<string, Error>}  An object of value-specific errors by key.
+   */
+  _validateValues(value, options) {
+    const errors = {};
+    for ( const [k, v] of Object.entries(value) ) {
+      if ( k.startsWith("-=") ) continue;
+      const error = this.model.validate(v, options);
+      if ( error ) errors[k] = error;
+    }
+    return errors;
+  }
+
+  /* -------------------------------------------- */
+
+  /** @override */
+  initialize(value, model, options={}) {
+    if ( !value ) return value;
+    const obj = {};
+    const initialKeys = (this.initialKeys instanceof Array) ? this.initialKeys : Object.keys(this.initialKeys ?? {});
+    const keys = this.initialKeysOnly ? initialKeys : Object.keys(value);
+    for ( const key of keys ) {
+      const data = value[key] ?? this._getInitialValueForKey(key, value);
+      obj[key] = this.model.initialize(data, model, options);
+    }
+    return obj;
+  }
+
+  /* -------------------------------------------- */
+
+  /** @inheritDoc */
+  _getField(path) {
+    if ( path.length === 0 ) return this;
+    else if ( path.length === 1 ) return this.model;
+    path.shift();
+    return this.model._getField(path);
+  }
+}