Fix conflict

module/data/_module.mjs

@@ -1,5 +1,3 @@
-export { default as DhClass } from './item/class.mjs';
-export { default as DhSubclass } from './item/subclass.mjs';
 export { default as DhCombat } from './combat.mjs';
 export { default as DhCombatant } from './combatant.mjs';
 
@@ -8,4 +6,3 @@ export * as items from './item/_module.mjs';
 export { actionsTypes } from './action/_module.mjs';
 export * as messages from './chat-message/_modules.mjs';
 export * as fields from './fields/_module.mjs';
-export * as pseudoDocuments from './pseudo-documents/_module.mjs';

module/data/actor/character.mjs

@@ -5,7 +5,7 @@ import BaseDataActor from './base.mjs';
 
 const attributeField = () =>
     new foundry.data.fields.SchemaField({
-        value: new foundry.data.fields.NumberField({ initial: 0, integer: true }),
+        value: new foundry.data.fields.NumberField({ initial: null, integer: true }),
         bonus: new foundry.data.fields.NumberField({ initial: 0, integer: true }),
         tierMarked: new foundry.data.fields.BooleanField({ initial: false })
     });
@@ -54,13 +54,7 @@ export default class DhCharacter extends BaseDataActor {
                     description: new fields.StringField({}),
                     value: new fields.NumberField({ integer: true, initial: 0 }),
                     bonus: new fields.NumberField({ integer: true, initial: 0 })
-                }),
-                {
-                    initial: {
-                        [foundry.utils.randomID()]: { description: '', value: 2 },
-                        [foundry.utils.randomID()]: { description: '', value: 2 }
-                    }
-                }
+                })
             ),
             gold: new fields.SchemaField({
                 coins: new fields.NumberField({ initial: 0, integer: true }),
@@ -93,6 +87,14 @@ export default class DhCharacter extends BaseDataActor {
         };
     }
 
+    get tier() {
+        return this.levelData.level.current === 1
+            ? 1
+            : Object.values(game.settings.get(SYSTEM.id, SYSTEM.SETTINGS.gameSettings.LevelTiers).tiers).find(
+                  tier => currentLevel >= tier.levels.start && currentLevel <= tier.levels.end
+              ).tier;
+    }
+
     get ancestry() {
         return this.parent.items.find(x => x.type === 'ancestry') ?? null;
     }
@@ -140,19 +142,6 @@ export default class DhCharacter extends BaseDataActor {
               : null;
     }
 
-    get refreshableFeatures() {
-        return this.parent.items.reduce(
-            (acc, x) => {
-                if (x.type === 'feature' && x.system.refreshData?.type === 'feature' && x.system.refreshData?.type) {
-                    acc[x.system.refreshData.type].push(x);
-                }
-
-                return acc;
-            },
-            { shortRest: [], longRest: [] }
-        );
-    }
-
     static async unequipBeforeEquip(itemToEquip) {
         const primary = this.primaryWeapon,
             secondary = this.secondaryWeapon;
@@ -235,7 +224,7 @@ export default class DhCharacter extends BaseDataActor {
 
         for (var traitKey in this.traits) {
             var trait = this.traits[traitKey];
-            trait.total = trait.value + trait.bonus;
+            trait.total = (trait.value ?? 0) + trait.bonus;
         }
 
         for (var experienceKey in this.experiences) {
@@ -248,6 +237,14 @@ export default class DhCharacter extends BaseDataActor {
         this.evasion.total = (this.class?.evasion ?? 0) + this.evasion.bonus;
         this.proficiency.total = this.proficiency.value + this.proficiency.bonus;
     }
+
+    getRollData() {
+        const data = super.getRollData();
+        return {
+            ...data,
+            tier: this.tier
+        };
+    }
 }
 
 class DhPCLevelData extends foundry.abstract.DataModel {

module/data/chat-message/_modules.mjs

@@ -18,4 +18,4 @@ export const config = {
   damageRoll: DHDamageRoll,
   dualityRoll: DHDualityRoll,
   applyEffect: DHApplyEffect
-};
+};

module/data/countdowns.mjs

@@ -0,0 +1,139 @@
+import { countdownTypes } from '../config/generalConfig.mjs';
+import { RefreshType, socketEvent } from '../helpers/socket.mjs';
+
+export default class DhCountdowns extends foundry.abstract.DataModel {
+    static defineSchema() {
+        const fields = foundry.data.fields;
+
+        return {
+            narrative: new fields.EmbeddedDataField(DhCountdownData),
+            encounter: new fields.EmbeddedDataField(DhCountdownData)
+        };
+    }
+
+    static CountdownCategories = { narrative: 'narrative', combat: 'combat' };
+}
+
+class DhCountdownData extends foundry.abstract.DataModel {
+    static LOCALIZATION_PREFIXES = ['DAGGERHEART.Countdown']; // Nots ure why this won't work. Setting labels manually for now
+
+    static defineSchema() {
+        const fields = foundry.data.fields;
+        return {
+            countdowns: new fields.TypedObjectField(new fields.EmbeddedDataField(DhCountdown)),
+            ownership: new fields.SchemaField({
+                default: new fields.NumberField({
+                    required: true,
+                    choices: Object.values(CONST.DOCUMENT_OWNERSHIP_LEVELS),
+                    initial: CONST.DOCUMENT_OWNERSHIP_LEVELS.NONE
+                }),
+                players: new fields.TypedObjectField(
+                    new fields.SchemaField({
+                        type: new fields.NumberField({
+                            required: true,
+                            choices: Object.values(CONST.DOCUMENT_OWNERSHIP_LEVELS),
+                            initial: CONST.DOCUMENT_OWNERSHIP_LEVELS.INHERIT
+                        })
+                    })
+                )
+            })
+        };
+    }
+
+    get playerOwnership() {
+        return Array.from(game.users).reduce((acc, user) => {
+            acc[user.id] = {
+                value: user.isGM
+                    ? CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER
+                    : this.ownership.players[user.id] && this.ownership.players[user.id].type !== -1
+                      ? this.ownership.players[user.id].type
+                      : this.ownership.default,
+                isGM: user.isGM
+            };
+
+            return acc;
+        }, {});
+    }
+}
+
+class DhCountdown extends foundry.abstract.DataModel {
+    static defineSchema() {
+        const fields = foundry.data.fields;
+        return {
+            name: new fields.StringField({
+                required: true,
+                label: 'DAGGERHEART.Countdown.FIELDS.countdowns.element.name.label'
+            }),
+            img: new fields.FilePathField({
+                categories: ['IMAGE'],
+                base64: false,
+                initial: 'icons/magic/time/hourglass-yellow-green.webp'
+            }),
+            ownership: new fields.SchemaField({
+                default: new fields.NumberField({
+                    required: true,
+                    choices: Object.values(CONST.DOCUMENT_OWNERSHIP_LEVELS),
+                    initial: CONST.DOCUMENT_OWNERSHIP_LEVELS.NONE
+                }),
+                players: new fields.TypedObjectField(
+                    new fields.SchemaField({
+                        type: new fields.NumberField({
+                            required: true,
+                            choices: Object.values(CONST.DOCUMENT_OWNERSHIP_LEVELS),
+                            initial: CONST.DOCUMENT_OWNERSHIP_LEVELS.INHERIT
+                        })
+                    })
+                )
+            }),
+            progress: new fields.SchemaField({
+                current: new fields.NumberField({
+                    required: true,
+                    integer: true,
+                    initial: 1,
+                    label: 'DAGGERHEART.Countdown.FIELDS.countdowns.element.progress.current.label'
+                }),
+                max: new fields.NumberField({
+                    required: true,
+                    integer: true,
+                    initial: 1,
+                    label: 'DAGGERHEART.Countdown.FIELDS.countdowns.element.progress.max.label'
+                }),
+                type: new fields.SchemaField({
+                    value: new fields.StringField({
+                        required: true,
+                        choices: countdownTypes,
+                        initial: countdownTypes.spotlight.id,
+                        label: 'DAGGERHEART.Countdown.FIELDS.countdowns.element.progress.type.value.label'
+                    }),
+                    label: new fields.StringField({
+                        label: 'DAGGERHEART.Countdown.FIELDS.countdowns.element.progress.type.label.label'
+                    })
+                })
+            })
+        };
+    }
+
+    get playerOwnership() {
+        return Array.from(game.users).reduce((acc, user) => {
+            acc[user.id] = {
+                value: user.isGM
+                    ? CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER
+                    : this.ownership.players[user.id] && this.ownership.players[user.id].type !== -1
+                      ? this.ownership.players[user.id].type
+                      : this.ownership.default,
+                isGM: user.isGM
+            };
+
+            return acc;
+        }, {});
+    }
+}
+
+export const registerCountdownHooks = () => {
+    Hooks.on(socketEvent.Refresh, ({ refreshType, application }) => {
+        if (refreshType === RefreshType.Countdown) {
+            foundry.applications.instances.get(application)?.render();
+            return false;
+        }
+    });
+};

module/data/fields/_module.mjs

@@ -1,3 +1,3 @@
 export { default as FormulaField } from './formulaField.mjs';
 export { default as ForeignDocumentUUIDField } from './foreignDocumentUUIDField.mjs';
-export { default as PseudoDocumentsField } from './pseudoDocumentsField.mjs';
+export { default as ForeignDocumentUUIDArrayField } from './foreignDocumentUUIDArrayField.mjs';

module/data/fields/foreignDocumentUUIDArrayField.mjs

@@ -0,0 +1,20 @@
+import ForeignDocumentUUIDField from './foreignDocumentUUIDField.mjs';
+/**
+ * A subclass of {@link foundry.data.fields.ArrayField} that defines an array of foreign document UUID references.
+ */
+export default class ForeignDocumentUUIDArrayField extends foundry.data.fields.ArrayField {
+    /**
+     * @param {foundry.data.types.DocumentUUIDFieldOptions} [fieldOption] - Options to configure each individual ForeignDocumentUUIDField.
+     * @param {foundry.data.types.ArrayFieldOptions} [options] - Options to configure the array behavior
+     * @param {foundry.data.types.DataFieldContext} [context] -  Optional context for schema processing
+     */
+    constructor(fieldOption = {}, options = {}, context = {}) {
+        super(new ForeignDocumentUUIDField(fieldOption), options, context);
+    }
+
+    /** @inheritdoc */
+    initialize(value, model, options = {}) {
+        const v = super.initialize(value, model, options);
+        return () => v.map(entry => (typeof entry === 'function' ? entry() : entry));
+    }
+}

module/data/fields/foreignDocumentUUIDField.mjs

@@ -23,7 +23,7 @@ export default class ForeignDocumentUUIDField extends foundry.data.fields.Docume
     /**@override */
     initialize(value, _model, _options = {}) {
         if (this.idOnly) return value;
-        return (() => {
+        return () => {
             try {
                 const doc = fromUuidSync(value);
                 return doc;
@@ -31,7 +31,7 @@ export default class ForeignDocumentUUIDField extends foundry.data.fields.Docume
                 console.error(error);
                 return value ?? null;
             }
-        })();
+        };
     }
 
     /**@override */

module/data/fields/pseudoDocumentsField.mjs

@@ -1,56 +0,0 @@
-import PseudoDocument from '../pseudo-documents/base/pseudoDocument.mjs';
-
-const { TypedObjectField, TypedSchemaField } = foundry.data.fields;
-
-/**
- * @typedef _PseudoDocumentsFieldOptions
- * @property {Number} [max] - The maximum amount of elements (default: `Infinity`)
- * @property {String[]} [validTypes] - Allowed pseudo-documents types (default: `[]`)
- * @property {Function} [validateKey] - callback for validate keys of the object;
-
- * @typedef {foundry.data.types.DataFieldOptions & _PseudoDocumentsFieldOptions} PseudoDocumentsFieldOptions
- */
-export default class PseudoDocumentsField extends TypedObjectField {
-    /**
-     * @param {PseudoDocument} model - The PseudoDocument of each entry in this collection.
-     * @param {PseudoDocumentsFieldOptions} [options] - Options which configure the behavior of the field
-     * @param {foundry.data.types.DataFieldContext} [context] - Additional context which describes the field
-     */
-    constructor(model, options = {}, context = {}) {
-        options.validateKey ||= key => foundry.data.validators.isValidId(key);
-        if (!foundry.utils.isSubclass(model, PseudoDocument)) throw new Error('The model must be a PseudoDocument');
-
-        const allTypes = model.TYPES;
-
-        const filteredTypes = options.validTypes
-            ? Object.fromEntries(
-                Object.entries(allTypes).filter(([key]) => options.validTypes.includes(key))
-            )
-            : allTypes;
-
-        const field = new TypedSchemaField(filteredTypes);
-        super(field, options, context);
-    }
-
-    /** @inheritdoc */
-    static get _defaults() {
-        return Object.assign(super._defaults, {
-            max: Infinity,
-            validTypes: []
-        });
-    }
-
-    /** @override */
-    _validateType(value, options = {}) {
-        if (Object.keys(value).length > this.max) throw new Error(`cannot have more than ${this.max} elements`);
-        return super._validateType(value, options);
-    }
-
-    /** @override */
-    initialize(value, model, options = {}) {
-        if (!value) return;
-        value = super.initialize(value, model, options);
-        const collection = new foundry.utils.Collection(Object.values(value).map(d => [d._id, d]));
-        return collection;
-    }
-}

module/data/item/base.mjs

@@ -5,52 +5,49 @@
  * @property {string} type - The system type that this data model represents.
  * @property {boolean} hasDescription - Indicates whether items of this type have description field
  * @property {boolean} isQuantifiable - Indicates whether items of this type have quantity field
- * @property {Record<string,string>} embedded - Record of document names of pseudo-documents and the path to the collection
  */
 
 const fields = foundry.data.fields;
 
 export default class BaseDataItem extends foundry.abstract.TypeDataModel {
-  /** @returns {ItemDataModelMetadata}*/
-  static get metadata() {
-    return {
-      label: "Base Item",
-      type: "base",
-      hasDescription: false,
-      isQuantifiable: false,
-      embedded: {},
-    };
-  }
+    /** @returns {ItemDataModelMetadata}*/
+    static get metadata() {
+        return {
+            label: 'Base Item',
+            type: 'base',
+            hasDescription: false,
+            isQuantifiable: false
+        };
+    }
 
-  /** @inheritDoc */
-  static defineSchema() {
-    const schema = {};
+    /** @inheritDoc */
+    static defineSchema() {
+        const schema = {};
 
-    if (this.metadata.hasDescription)
-      schema.description = new fields.HTMLField({ required: true, nullable: true });
+        if (this.metadata.hasDescription) schema.description = new fields.HTMLField({ required: true, nullable: true });
 
-    if (this.metadata.isQuantifiable)
-      schema.quantity = new fields.NumberField({ integer: true, initial: 1, min: 0, required: true });
+        if (this.metadata.isQuantifiable)
+            schema.quantity = new fields.NumberField({ integer: true, initial: 1, min: 0, required: true });
 
-    return schema;
-  }
+        return schema;
+    }
 
-  /**
-   * Convenient access to the item's actor, if it exists.
-   * @returns {foundry.documents.Actor | null}
-   */
-  get actor() {
-    return this.parent.actor;
-  }
+    /**
+     * Convenient access to the item's actor, if it exists.
+     * @returns {foundry.documents.Actor | null}
+     */
+    get actor() {
+        return this.parent.actor;
+    }
 
-  /**
-   * Obtain a data object used to evaluate any dice rolls associated with this Item Type
-   * @param {object} [options] - Options which modify the getRollData method. 
-   * @returns {object}
-   */
-  getRollData(options = {}) {
-    const actorRollData = this.actor?.getRollData() ?? {};
-    const data = { ...actorRollData, item: { ...this } };
-    return data;
-  }
-}
+    /**
+     * Obtain a data object used to evaluate any dice rolls associated with this Item Type
+     * @param {object} [options] - Options which modify the getRollData method.
+     * @returns {object}
+     */
+    getRollData(options = {}) {
+        const actorRollData = this.actor?.getRollData() ?? {};
+        const data = { ...actorRollData, item: { ...this } };
+        return data;
+    }
+}

module/data/item/class.mjs

@@ -1,5 +1,6 @@
 import BaseDataItem from './base.mjs';
 import ForeignDocumentUUIDField from '../fields/foreignDocumentUUIDField.mjs';
+import ForeignDocumentUUIDArrayField from '../fields/foreignDocumentUUIDArrayField.mjs';
 import ActionField from '../fields/actionField.mjs';
 
 export default class DHClass extends BaseDataItem {
@@ -18,23 +19,16 @@ export default class DHClass extends BaseDataItem {
         return {
             ...super.defineSchema(),
             domains: new fields.ArrayField(new fields.StringField(), { max: 2 }),
-            classItems: new fields.ArrayField(new ForeignDocumentUUIDField({ type: 'Item' })),
+            classItems: new ForeignDocumentUUIDArrayField({ type: 'Item', required: false }),
+
             evasion: new fields.NumberField({ initial: 0, integer: true }),
             hopeFeatures: new foundry.data.fields.ArrayField(new ActionField()),
             classFeatures: new foundry.data.fields.ArrayField(new ActionField()),
-            subclasses: new fields.ArrayField(
-                new ForeignDocumentUUIDField({ type: 'Item', required: false, nullable: true, initial: undefined })
-            ),
+            subclasses: new ForeignDocumentUUIDArrayField({ type: 'Item', required: false }),
             inventory: new fields.SchemaField({
-                take: new fields.ArrayField(
-                    new ForeignDocumentUUIDField({ type: 'Item', required: false, nullable: true, initial: undefined })
-                ),
-                choiceA: new fields.ArrayField(
-                    new ForeignDocumentUUIDField({ type: 'Item', required: false, nullable: true, initial: undefined })
-                ),
-                choiceB: new fields.ArrayField(
-                    new ForeignDocumentUUIDField({ type: 'Item', required: false, nullable: true, initial: undefined })
-                )
+                take: new ForeignDocumentUUIDArrayField({ type: 'Item', required: false }),
+                choiceA: new ForeignDocumentUUIDArrayField({ type: 'Item', required: false }),
+                choiceB: new ForeignDocumentUUIDArrayField({ type: 'Item', required: false })
             }),
             characterGuide: new fields.SchemaField({
                 suggestedTraits: new fields.SchemaField({

module/data/item/consumable.mjs

@@ -1,14 +1,14 @@
-import BaseDataItem from "./base.mjs";
+import BaseDataItem from './base.mjs';
 import ActionField from '../fields/actionField.mjs';
 
 export default class DHConsumable extends BaseDataItem {
-     /** @inheritDoc */
+    /** @inheritDoc */
     static get metadata() {
         return foundry.utils.mergeObject(super.metadata, {
-            label: "TYPES.Item.consumable",
-            type: "consumable",
+            label: 'TYPES.Item.consumable',
+            type: 'consumable',
             hasDescription: true,
-            isQuantifiable: true,
+            isQuantifiable: true
         });
     }
 

module/data/item/miscellaneous.mjs

@@ -5,10 +5,10 @@ export default class DHMiscellaneous extends BaseDataItem {
     /** @inheritDoc */
     static get metadata() {
         return foundry.utils.mergeObject(super.metadata, {
-            label: "TYPES.Item.miscellaneous",
-            type: "miscellaneous",
+            label: 'TYPES.Item.miscellaneous',
+            type: 'miscellaneous',
             hasDescription: true,
-            isQuantifiable: true,
+            isQuantifiable: true
         });
     }
 

module/data/item/subclass.mjs

@@ -1,11 +1,11 @@
 import ActionField from '../fields/actionField.mjs';
-import ForeignDocumentUUIDField from '../fields/foreignDocumentUUIDField.mjs';
+import ForeignDocumentUUIDArrayField from '../fields/foreignDocumentUUIDArrayField.mjs';
 import BaseDataItem from './base.mjs';
 
 const featureSchema = () => {
     return new foundry.data.fields.SchemaField({
         name: new foundry.data.fields.StringField({ required: true }),
-        effects: new foundry.data.fields.ArrayField(new ForeignDocumentUUIDField({ type: 'ActiveEffect' })),
+        effects: new ForeignDocumentUUIDArrayField({ type: 'ActiveEffect', required: false }),
         actions: new foundry.data.fields.ArrayField(new ActionField())
     });
 };
@@ -64,7 +64,7 @@ export default class DHSubclass extends BaseDataItem {
             } else if (subclassData) {
                 ui.notifications.error(game.i18n.localize('DAGGERHEART.Item.Errors.SubclassAlreadySelected'));
                 return false;
-            } else if (classData.system.subclasses.every(x => x.uuid !== `Item.${data._id}`)) {
+            } else if (classData.system.subclasses.every(x => x.uuid !== (data.uuid ?? `Item.${data._id}`))) {
                 ui.notifications.error(game.i18n.localize('DAGGERHEART.Item.Errors.SubclassNotInClass'));
                 return false;
             }

module/data/pseudo-documents/_module.mjs

@@ -1,2 +0,0 @@
-export { default as base } from './base/pseudoDocument.mjs';
-export * as feature from './feature/_module.mjs';

module/data/pseudo-documents/base/base.mjs

@@ -1,213 +0,0 @@
-/**
- * @typedef {object} PseudoDocumentMetadata
- * @property {string} name - The document name of this pseudo-document
- * @property {Record<string, string>} embedded - Record of document names and their collection paths
- * @property {typeof foundry.applications.api.ApplicationV2} [sheetClass] - The class used to render this pseudo-document
- * @property {string} defaultArtwork - The default image used for newly created documents
- */
-
-/**
- * @class Base class for pseudo-documents
- * @extends {foundry.abstract.DataModel}
- */
-export default class BasePseudoDocument extends foundry.abstract.DataModel {
-    /**
-     * Pseudo-document metadata.
-     * @returns {PseudoDocumentMetadata}
-     */
-    static get metadata() {
-        return {
-            name: '',
-            embedded: {},
-            defaultArtwork: foundry.documents.Item.DEFAULT_ICON,
-            sheetClass: CONFIG.daggerheart.pseudoDocuments.sheetClass,
-        };
-    }
-
-    /** @override */
-    static LOCALIZATION_PREFIXES = ['DOCUMENT'];
-
-    /** @inheritdoc */
-    static defineSchema() {
-        const { fields } = foundry.data;
-
-        return {
-            _id: new fields.DocumentIdField({ initial: () => foundry.utils.randomID() }),
-            name: new fields.StringField({ required: true, blank: false, textSearch: true }),
-            img: new fields.FilePathField({ categories: ['IMAGE'], initial: this.metadata.defaultArtwork }),
-            description: new fields.HTMLField({ textSearch: true })
-        };
-    }
-
-    /* -------------------------------------------- */
-    /*  Instance Properties                         */
-    /* -------------------------------------------- */
-
-    /**
-     * The id of this pseudo-document.
-     * @type {string}
-     */
-    get id() {
-        return this._id;
-    }
-
-    /* -------------------------------------------- */
-
-    /**
-     * The uuid of this document.
-     * @type {string}
-     */
-    get uuid() {
-        let parent = this.parent;
-        while (!(parent instanceof BasePseudoDocument) && !(parent instanceof foundry.abstract.Document))
-            parent = parent.parent;
-        return [parent.uuid, this.constructor.metadata.name, this.id].join('.');
-    }
-
-    /* -------------------------------------------- */
-
-    /**
-     * The parent document of this pseudo-document.
-     * @type {foundry.abstract.Document}
-     */
-    get document() {
-        let parent = this;
-        while (!(parent instanceof foundry.abstract.Document)) parent = parent.parent;
-        return parent;
-    }
-
-    /* -------------------------------------------- */
-
-    /**
-     * Item to which this PseudoDocument belongs, if applicable.
-     * @type {foundry.documents.Item|null}
-     */
-    get item() {
-        return this.parent?.parent instanceof Item ? this.parent.parent : null;
-    }
-
-    /* -------------------------------------------- */
-
-    /**
-     * Actor to which this PseudoDocument's item belongs, if the item is embedded.
-     * @type {foundry.documents.Actor|null}
-     */
-    get actor() {
-        return this.item?.parent ?? null;
-    }
-
-    /* -------------------------------------------- */
-
-    /**
-     * The property path to this pseudo document relative to its parent document.
-     * @type {string}
-     */
-    get fieldPath() {
-        const fp = this.schema.fieldPath;
-        let path = fp.slice(0, fp.lastIndexOf('element') - 1);
-
-        if (this.parent instanceof BasePseudoDocument) {
-            path = [this.parent.fieldPath, this.parent.id, path].join('.');
-        }
-
-        return path;
-    }
-
-    /* -------------------------------------------- */
-    /*  Embedded Document Methods                   */
-    /* -------------------------------------------- */
-
-    /**
-     * Retrieve an embedded pseudo-document.
-     * @param {string} embeddedName         The document name of the embedded pseudo-document.
-     * @param {string} id                   The id of the embedded pseudo-document.
-     * @param {object} [options]            Retrieval options.
-     * @param {boolean} [options.strinct]   Throw an error if the embedded pseudo-document does not exist?
-     * @returns {PseudoDocument|null}
-     */
-    getEmbeddedDocument(embeddedName, id, { strict = false } = {}) {
-        const embeds = this.constructor.metadata.embedded ?? {};
-        if (embeddedName in embeds) {
-            return foundry.utils.getProperty(this, embeds[embeddedName]).get(id, { strict }) ?? null;
-        }
-        return null;
-    }
-
-    /* -------------------------------------------- */
-    /*  CRUD Operations                             */
-    /* -------------------------------------------- */
-
-    /**
-     * Does this pseudo-document exist in the document's source?
-     * @type {boolean}
-     */
-    get isSource() {
-        const source = foundry.utils.getProperty(this.document._source, this.fieldPath);
-        if (foundry.utils.getType(source) !== 'Object') {
-            throw new Error('Source is not an object!');
-        }
-        return this.id in source;
-    }
-
-    /**
-     * Create a new instance of this pseudo-document.
-     * @param {object} [data]                                 The data used for the creation.
-     * @param {object} operation                              The context of the update operation.
-     * @param {foundry.abstract.Document} operation.parent    The parent of this document.
-     * @returns {Promise<foundry.abstract.Document>}          A promise that resolves to the updated document.
-     */
-    static async create(data = {}, { parent, ...operation } = {}) {
-        if (!parent) {
-            throw new Error('A parent document must be specified for the creation of a pseudo-document!');
-        }
-        const id =
-            operation.keepId && foundry.data.validators.isValidId(data._id) ? data._id : foundry.utils.randomID();
-
-        const fieldPath = parent.system.constructor.metadata.embedded?.[this.metadata.name];
-        if (!fieldPath) {
-            throw new Error(
-                `A ${parent.documentName} of type '${parent.type}' does not support ${this.metadata.name}!`
-            );
-        }
-
-        const update = { [`system.${fieldPath}.${id}`]: { ...data, _id: id } };
-        const updatedParent = await parent.update(update, operation);
-        return foundry.utils.getProperty(updatedParent, `system.${fieldPath}.${id}`);
-    }
-
-    /**
-     * Delete this pseudo-document.
-     * @param {object} [operation]                      The context of the operation.
-     * @returns {Promise<foundry.abstract.Document>}    A promise that resolves to the updated document.
-     */
-    async delete(operation = {}) {
-        if (!this.isSource) throw new Error('You cannot delete a non-source pseudo-document!');
-        const update = { [`${this.fieldPath}.-=${this.id}`]: null };
-        return this.document.update(update, operation);
-    }
-
-    /**
-     * Duplicate this pseudo-document.
-     * @returns {Promise<foundry.abstract.Document>}    A promise that resolves to the updated document.
-     */
-    async duplicate() {
-        if (!this.isSource) throw new Error('You cannot duplicate a non-source pseudo-document!');
-        const docData = foundry.utils.mergeObject(this.toObject(), {
-            name: game.i18n.format('DOCUMENT.CopyOf', { name: this.name })
-        });
-        return this.constructor.create(docData, { parent: this.document });
-    }
-
-    /**
-     * Update this pseudo-document.
-     * @param {object} [change]                         The change to perform.
-     * @param {object} [operation]                      The context of the operation.
-     * @returns {Promise<foundry.abstract.Document>}    A promise that resolves to the updated document.
-     */
-    async update(change = {}, operation = {}) {
-        if (!this.isSource) throw new Error('You cannot update a non-source pseudo-document!');
-        const path = [this.fieldPath, this.id].join('.');
-        const update = { [path]: change };
-        return this.document.update(update, operation);
-    }
-}

module/data/pseudo-documents/base/pseudoDocument.mjs

@@ -1,59 +0,0 @@
-import BasePseudoDocument from './base.mjs';
-import SheetManagementMixin from './sheetManagementMixin.mjs';
-
-/** @extends BasePseudoDocument */
-export default class PseudoDocument extends SheetManagementMixin(BasePseudoDocument) {
-    static get TYPES() {
-        const { types } = CONFIG.daggerheart.pseudoDocuments[this.metadata.name];
-        const typeEntries = Object.entries(types).map(([key, { documentClass }]) => [key, documentClass]);
-        return (this._TYPES ??= Object.freeze(Object.fromEntries(typeEntries)));
-    }
-
-    static _TYPES;
-
-    /**
-     * The type of this shape.
-     * @type {string}
-     */
-    static TYPE = '';
-
-    /* -------------------------------------------- */
-
-    static getTypesChoices(validTypes) {
-        const { types } = CONFIG.daggerheart.pseudoDocuments[model.metadata.name];
-        const typeEntries = Object.entries(types)
-            .map(([key, { label }]) => [key, label])
-            .filter(([key]) => !validTypes || validTypes.includes(key));
-
-        return Object.entries(typeEntries);
-    }
-
-    /* -------------------------------------------- */
-
-    /** @override */
-    static defineSchema() {
-        const { fields } = foundry.data;
-
-        return Object.assign(super.defineSchema(), {
-            type: new fields.StringField({
-                required: true,
-                blank: false,
-                initial: this.TYPE,
-                validate: value => value === this.TYPE,
-                validationError: `must be equal to "${this.TYPE}"`
-            })
-        });
-    }
-
-    /** @inheritdoc */
-    static async create(data = {}, { parent, ...operation } = {}) {
-        data = foundry.utils.deepClone(data);
-        if (!data.type) data.type = Object.keys(this.TYPES)[0];
-        if (!(data.type in this.TYPES)) {
-            throw new Error(
-                `The '${data.type}' type is not a valid type for a '${this.metadata.documentName}' pseudo-document!`
-            );
-        }
-        return super.create(data, { parent, ...operation });
-    }
-}

module/data/pseudo-documents/base/sheetManagementMixin.mjs

@@ -1,158 +0,0 @@
-import BasePseudoDocument from './base.mjs';
-const { ApplicationV2 } = foundry.applications.api;
-
-/**
- * A mixin that adds sheet management capabilities to pseudo-documents
- * @template {typeof BasePseudoDocument} T
- * @param {T} Base
- * @returns {T & typeof PseudoDocumentWithSheets}
- */
-export default function SheetManagementMixin(Base) {
-    class PseudoDocumentWithSheets extends Base {
-        /**
-         * Reference to the sheet of this pseudo-document.
-         * @type {ApplicationV2|null}
-         */
-        get sheet() {
-            if (this._sheet) return this._sheet;
-            const cls = this.constructor.metadata.sheetClass ?? ApplicationV2;
-            
-            if (!foundry.utils.isSubclass(cls, ApplicationV2)) {
-                return void ui.notifications.error(
-                    'Daggerheart | Error on PseudoDocument | sheetClass must be ApplicationV2'
-                );
-            }
-
-            const sheet = new cls({ document: this });
-            this._sheet = sheet;
-            return sheet;
-        }
-
-        /* -------------------------------------------- */
-        /*  Static Properties                           */
-        /* -------------------------------------------- */
-
-        /**
-         * Set of apps what should be re-render.
-         * @type {Set<ApplicationV2>}
-         * @internal
-         */
-        _apps = new Set();
-
-        /* -------------------------------------------- */
-
-        /**
-         * Existing sheets of a specific type for a specific document.
-         * @type {ApplicationV2 | null}
-         */
-        _sheet = null;
-
-        /* -------------------------------------------- */
-        /*  Display Methods                             */
-        /* -------------------------------------------- */
-
-        /**
-         * Render all the Application instances which are connected to this PseudoDocument.
-         * @param {ApplicationRenderOptions} [options]  Rendering options.
-         */
-        render(options) {
-            for (const app of this._apps ?? []) {
-                app.render({ window: { title: app.title }, ...options });
-            }
-        }
-
-        /* -------------------------------------------- */
-
-        /**
-         * Register an application to respond to updates to a certain document.
-         * @param {ApplicationV2} app     Application to update.
-         * @internal
-         */
-        _registerApp(app) {
-            this._apps.add(app);
-        }
-
-        /* -------------------------------------------- */
-
-        /**
-         * Remove an application from the render registry.
-         * @param {ApplicationV2} app     Application to stop watching.
-         */
-        _unregisterApp(app) {
-            this._apps.delete(app);
-        }
-
-        /* -------------------------------------------- */
-        /*  Drag and Drop                               */
-        /* -------------------------------------------- */
-
-        /**
-         * Serialize salient information for this PseudoDocument when dragging it.
-         * @returns {object}  An object of drag data.
-         */
-        toDragData() {
-            const dragData = { type: this.documentName, data: this.toObject() };
-            if (this.id) dragData.uuid = this.uuid;
-            return dragData;
-        }
-
-        /* -------------------------------------------- */
-        /*  Dialog Methods                              */
-        /* -------------------------------------------- */
-
-        /**
-         * Spawn a dialog for creating a new PseudoDocument.
-         * @param {object} [data]  Data to pre-populate the document with.
-         * @param {object} context
-         * @param {foundry.documents.Item} context.parent        A parent for the document.
-         * @param {string[]|null} [context.types]  A list of types to restrict the choices to, or null for no restriction.
-         * @returns {Promise<BasePseudoDocument|null>}
-         */
-        static async createDialog(data = {}, { parent, types = null, ...options } = {}) {
-            // TODO
-        }
-
-        /**
-         * Present a Dialog form to confirm deletion of this PseudoDocument.
-         * @param {object} [options] - Additional options passed to `DialogV2.confirm`;
-         * @returns {Promise<foundry.abstract.Document>}  A Promise which resolves to the deleted PseudoDocument.
-         */
-        async deleteDialog(options = {}) {
-            const type = game.i18n.localize(this.constructor.metadata.label);
-            const content = options.content ?? `<p>
-            <strong>${game.i18n.localize("AreYouSure")}</strong>
-            ${game.i18n.format("SIDEBAR.DeleteWarning", { type })}
-            </p>`;
-
-            return foundry.applications.api.DialogV2.confirm({
-                content,
-                yes: { callback: () => this.delete(operation) },
-                window: {
-                    icon: "fa-solid fa-trash",
-                    title: `${game.i18n.format("DOCUMENT.Delete", { type })}: ${this.name}`
-                },
-                ...options
-            });
-        }
-
-        /**
-         * Gets the default new name for a Document
-         * @param {object} collection - Collection of Documents
-         * @returns {string}
-         */
-        static defaultName(collection) {
-            const documentName = this.metadata.name;
-            const takenNames = new Set();
-            for (const document of collection) takenNames.add(document.name);
-
-            const config = CONFIG.daggerheart.pseudoDocuments[documentName];
-            const baseName = game.i18n.localize(config.label);
-            let name = baseName;
-            let index = 1;
-            while (takenNames.has(name)) name = `${baseName} (${++index})`;
-            return name;
-        }
-    }
-
-    return PseudoDocumentWithSheets;
-}

module/data/pseudo-documents/feature/_module.mjs

@@ -1,2 +0,0 @@
-export { default as BaseFeatureData } from './baseFeatureData.mjs';
-export { default as WeaponFeature } from './weaponFeature.mjs';

module/data/pseudo-documents/feature/baseFeatureData.mjs

@@ -1,24 +0,0 @@
-import PseudoDocument from '../base/pseudoDocument.mjs';
-
-export default class BaseFeatureData extends PseudoDocument {
-    /**@inheritdoc */
-    static get metadata() {
-        return foundry.utils.mergeObject(
-            super.metadata,
-            {
-                name: 'feature',
-                embedded: {},
-                //sheetClass: null //TODO: define feature-sheet
-            },
-            { inplace: false }
-        );
-    }
-
-    static defineSchema() {
-        const { fields } = foundry.data;
-        const schema = super.defineSchema();
-        return Object.assign(schema, {
-            subtype: new fields.StringField({ initial: 'test' })
-        });
-    }
-}

module/data/pseudo-documents/feature/weaponFeature.mjs

@@ -1,6 +0,0 @@
-import BaseFeatureData from './baseFeatureData.mjs';
-
-export default class WeaponFeature extends BaseFeatureData {
-    /**@override */
-    static TYPE = 'weapon';
-}

module/data/settings/Appearance.mjs

@@ -1,7 +1,15 @@
+import { fearDisplay } from '../../config/generalConfig.mjs';
+
 export default class DhAppearance extends foundry.abstract.DataModel {
     static defineSchema() {
         const fields = foundry.data.fields;
         return {
+            displayFear: new fields.StringField({
+                required: true,
+                choices: fearDisplay,
+                initial: fearDisplay.token.value,
+                label: 'DAGGERHEART.Settings.Appearance.FIELDS.displayFear.label'
+            }),
             dualityColorScheme: new fields.StringField({
                 required: true,
                 choices: DualityRollColor,
@@ -35,8 +43,6 @@ export default class DhAppearance extends foundry.abstract.DataModel {
             })
         };
     }
-
-    static defaultSchema = {};
 }
 
 export const DualityRollColor = {

module/data/settings/Automation.mjs

@@ -0,0 +1,12 @@
+export default class DhAutomation extends foundry.abstract.DataModel {
+    static LOCALIZATION_PREFIXES = ['DAGGERHEART.Settings.Automation']; // Doesn't work for some reason
+
+    static defineSchema() {
+        const fields = foundry.data.fields;
+        return {
+            hope: new fields.BooleanField({ required: true, initial: false }),
+            actionPoints: new fields.BooleanField({ required: true, initial: false }),
+            countdowns: new fields.BooleanField({ requireD: true, initial: false })
+        };
+    }
+}

module/data/settings/Homebrew.mjs

@@ -0,0 +1,55 @@
+import { defaultRestOptions } from '../../config/generalConfig.mjs';
+
+export default class DhHomebrew extends foundry.abstract.DataModel {
+    static LOCALIZATION_PREFIXES = ['DAGGERHEART.Settings.Homebrew']; // Doesn't work for some reason
+
+    static defineSchema() {
+        const fields = foundry.data.fields;
+        return {
+            maxFear: new fields.NumberField({
+                required: true,
+                integer: true,
+                min: 0,
+                initial: 12,
+                label: 'DAGGERHEART.Settings.Homebrew.FIELDS.maxFear.label'
+            }),
+            traitArray: new fields.ArrayField(new fields.NumberField({ required: true, integer: true }), {
+                initial: () => [2, 1, 1, 0, 0, -1]
+            }),
+            restMoves: new fields.SchemaField({
+                longRest: new fields.SchemaField({
+                    nrChoices: new fields.NumberField({ required: true, integer: true, min: 1, initial: 2 }),
+                    moves: new fields.TypedObjectField(
+                        new fields.SchemaField({
+                            name: new fields.StringField({ required: true }),
+                            img: new fields.FilePathField({
+                                initial: 'icons/magic/life/cross-worn-green.webp',
+                                categories: ['IMAGE'],
+                                base64: false
+                            }),
+                            description: new fields.HTMLField(),
+                            actions: new fields.ArrayField(new fields.ObjectField())
+                        }),
+                        { initial: defaultRestOptions.longRest() }
+                    )
+                }),
+                shortRest: new fields.SchemaField({
+                    nrChoices: new fields.NumberField({ required: true, integer: true, min: 1, initial: 2 }),
+                    moves: new fields.TypedObjectField(
+                        new fields.SchemaField({
+                            name: new fields.StringField({ required: true }),
+                            img: new fields.FilePathField({
+                                initial: 'icons/magic/life/cross-worn-green.webp',
+                                categories: ['IMAGE'],
+                                base64: false
+                            }),
+                            description: new fields.HTMLField(),
+                            actions: new fields.ArrayField(new fields.ObjectField())
+                        }),
+                        { initial: defaultRestOptions.shortRest() }
+                    )
+                })
+            })
+        };
+    }
+}

module/data/settings/RangeMeasurement.mjs

@@ -0,0 +1,17 @@
+export default class DhRangeMeasurement extends foundry.abstract.DataModel {
+    static defineSchema() {
+        const fields = foundry.data.fields;
+        return {
+            enabled: new fields.BooleanField({ required: true, initial: false, label: 'DAGGERHEART.General.Enabled' }),
+            melee: new fields.NumberField({ required: true, initial: 5, label: 'DAGGERHEART.Range.melee.name' }),
+            veryClose: new fields.NumberField({
+                required: true,
+                initial: 15,
+                label: 'DAGGERHEART.Range.veryClose.name'
+            }),
+            close: new fields.NumberField({ required: true, initial: 30, label: 'DAGGERHEART.Range.close.name' }),
+            far: new fields.NumberField({ required: true, initial: 60, label: 'DAGGERHEART.Range.far.name' }),
+            veryFar: new fields.NumberField({ required: true, initial: 120, label: 'DAGGERHEART.Range.veryFar.name' })
+        };
+    }
+}

module/data/settings/VariantRules.mjs

@@ -5,12 +5,22 @@ export default class DhVariantRules extends foundry.abstract.DataModel {
         const fields = foundry.data.fields;
         return {
             actionTokens: new fields.SchemaField({
-                enabled: new fields.BooleanField({ required: true, initial: false }),
-                tokens: new fields.NumberField({ required: true, integer: true, initial: 3 })
+                enabled: new fields.BooleanField({
+                    required: true,
+                    initial: false,
+                    label: 'DAGGERHEART.Settings.VariantRules.FIELDS.actionTokens.enabled.label'
+                }),
+                tokens: new fields.NumberField({
+                    required: true,
+                    integer: true,
+                    initial: 3,
+                    label: 'DAGGERHEART.Settings.VariantRules.FIELDS.actionTokens.tokens.label'
+                })
             }),
-            useCoins: new fields.BooleanField({ initial: false })
+            useCoins: new fields.BooleanField({
+                initial: false,
+                label: 'DAGGERHEART.Settings.VariantRules.FIELDS.useCoins.label'
+            })
         };
     }
-
-    static defaultSchema = {};
 }

module/data/settings/_module.mjs

@@ -0,0 +1,7 @@
+import DhAppearance from './Appearance.mjs';
+import DhAutomation from './Automation.mjs';
+import DhHomebrew from './Homebrew.mjs';
+import DhRangeMeasurement from './RangeMeasurement.mjs';
+import DhVariantRules from './VariantRules.mjs';
+
+export { DhAppearance, DhAutomation, DhHomebrew, DhRangeMeasurement, DhVariantRules };