Merged with main

module/data/item/_module.mjs

@@ -0,0 +1,36 @@
+import DHAncestry from './ancestry.mjs';
+import DHArmor from './armor.mjs';
+import DHClass from './class.mjs';
+import DHCommunity from './community.mjs';
+import DHConsumable from './consumable.mjs';
+import DHDomainCard from './domainCard.mjs';
+import DHFeature from './feature.mjs';
+import DHMiscellaneous from './miscellaneous.mjs';
+import DHSubclass from './subclass.mjs';
+import DHWeapon from './weapon.mjs';
+
+export {
+    DHAncestry,
+    DHArmor,
+    DHClass,
+    DHCommunity,
+    DHConsumable,
+    DHDomainCard,
+    DHFeature,
+    DHMiscellaneous,
+    DHSubclass,
+    DHWeapon
+};
+
+export const config = {
+    ancestry: DHAncestry,
+    armor: DHArmor,
+    class: DHClass,
+    community: DHCommunity,
+    consumable: DHConsumable,
+    domainCard: DHDomainCard,
+    feature: DHFeature,
+    miscellaneous: DHMiscellaneous,
+    subclass: DHSubclass,
+    weapon: DHWeapon
+};

module/data/item/ancestry.mjs

@@ -0,0 +1,22 @@
+import ActionField from '../fields/actionField.mjs';
+import BaseDataItem from './base.mjs';
+
+export default class DHAncestry extends BaseDataItem {
+    /** @inheritDoc */
+    static get metadata() {
+        return foundry.utils.mergeObject(super.metadata, {
+            label: 'TYPES.Item.ancestry',
+            type: 'ancestry',
+            hasDescription: true
+        });
+    }
+
+    /** @inheritDoc */
+    static defineSchema() {
+        const fields = foundry.data.fields;
+        return {
+            ...super.defineSchema(),
+            actions: new fields.ArrayField(new ActionField())
+        };
+    }
+}

module/data/item/armor.mjs

@@ -0,0 +1,89 @@
+import BaseDataItem from './base.mjs';
+import ActionField from '../fields/actionField.mjs';
+import { armorFeatures } from '../../config/itemConfig.mjs';
+
+export default class DHArmor extends BaseDataItem {
+    /** @inheritDoc */
+    static get metadata() {
+        return foundry.utils.mergeObject(super.metadata, {
+            label: 'TYPES.Item.armor',
+            type: 'armor',
+            hasDescription: true,
+            isQuantifiable: true
+        });
+    }
+
+    /** @inheritDoc */
+    static defineSchema() {
+        const fields = foundry.data.fields;
+        return {
+            ...super.defineSchema(),
+            tier: new fields.NumberField({ required: true, integer: true, initial: 1, min: 1 }),
+            equipped: new fields.BooleanField({ initial: false }),
+            baseScore: new fields.NumberField({ integer: true, initial: 0 }),
+            features: new fields.ArrayField(
+                new fields.SchemaField({
+                    value: new fields.StringField({ required: true, choices: SYSTEM.ITEM.armorFeatures, blank: true }),
+                    effectIds: new fields.ArrayField(new fields.StringField({ required: true })),
+                    actionIds: new fields.ArrayField(new fields.StringField({ required: true }))
+                })
+            ),
+            marks: new fields.SchemaField({
+                max: new fields.NumberField({ initial: 6, integer: true }),
+                value: new fields.NumberField({ initial: 0, integer: true })
+            }),
+            baseThresholds: new fields.SchemaField({
+                major: new fields.NumberField({ integer: true, initial: 0 }),
+                severe: new fields.NumberField({ integer: true, initial: 0 })
+            }),
+            actions: new fields.ArrayField(new ActionField())
+        };
+    }
+
+    get featureInfo() {
+        return this.feature ? CONFIG.daggerheart.ITEM.armorFeatures[this.feature] : null;
+    }
+
+    async _preUpdate(changes, options, user) {
+        const allowed = await super._preUpdate(changes, options, user);
+        if (allowed === false) return false;
+
+        if (changes.system.features) {
+            const removed = this.features.filter(x => !changes.system.features.includes(x));
+            const added = changes.system.features.filter(x => !this.features.includes(x));
+
+            for (var feature of removed) {
+                for (var effectId of feature.effectIds) {
+                    await this.parent.effects.get(effectId).delete();
+                }
+
+                changes.system.actions = this.actions.filter(x => !feature.actionIds.includes(x._id));
+            }
+
+            for (var feature of added) {
+                const featureData = armorFeatures[feature.value];
+                if (featureData.effects?.length > 0) {
+                    const embeddedItems = await this.parent.createEmbeddedDocuments('ActiveEffect', [
+                        {
+                            name: game.i18n.localize(featureData.label),
+                            description: game.i18n.localize(featureData.description),
+                            changes: featureData.effects.flatMap(x => x.changes)
+                        }
+                    ]);
+                    feature.effectIds = embeddedItems.map(x => x.id);
+                }
+                if (featureData.actions?.length > 0) {
+                    const newActions = featureData.actions.map(action => {
+                        const cls = actionsTypes[action.type];
+                        return new cls(
+                            { ...action, _id: foundry.utils.randomID(), name: game.i18n.localize(action.name) },
+                            { parent: this }
+                        );
+                    });
+                    changes.system.actions = [...this.actions, ...newActions];
+                    feature.actionIds = newActions.map(x => x._id);
+                }
+            }
+        }
+    }
+}

module/data/item/base.mjs

@@ -0,0 +1,53 @@
+/**
+ * Describes metadata about the item data model type
+ * @typedef {Object} ItemDataModelMetadata
+ * @property {string} label - A localizable label used on application.
+ * @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
+ */
+
+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
+        };
+    }
+
+    /** @inheritDoc */
+    static defineSchema() {
+        const schema = {};
+
+        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 });
+
+        return schema;
+    }
+
+    /**
+     * 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;
+    }
+}

module/data/item/class.mjs

@@ -0,0 +1,87 @@
+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 {
+    /** @inheritDoc */
+    static get metadata() {
+        return foundry.utils.mergeObject(super.metadata, {
+            label: 'TYPES.Item.class',
+            type: 'class',
+            hasDescription: true
+        });
+    }
+
+    /** @inheritDoc */
+    static defineSchema() {
+        const fields = foundry.data.fields;
+        return {
+            ...super.defineSchema(),
+            domains: new fields.ArrayField(new fields.StringField(), { max: 2 }),
+            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 ForeignDocumentUUIDArrayField({ type: 'Item', required: false }),
+            inventory: new fields.SchemaField({
+                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({
+                    agility: new fields.NumberField({ initial: 0, integer: true }),
+                    strength: new fields.NumberField({ initial: 0, integer: true }),
+                    finesse: new fields.NumberField({ initial: 0, integer: true }),
+                    instinct: new fields.NumberField({ initial: 0, integer: true }),
+                    presence: new fields.NumberField({ initial: 0, integer: true }),
+                    knowledge: new fields.NumberField({ initial: 0, integer: true })
+                }),
+                suggestedPrimaryWeapon: new ForeignDocumentUUIDField({ type: 'Item' }),
+                suggestedSecondaryWeapon: new ForeignDocumentUUIDField({ type: 'Item' }),
+                suggestedArmor: new ForeignDocumentUUIDField({ type: 'Item' })
+            }),
+            isMulticlass: new fields.BooleanField({ initial: false })
+        };
+    }
+
+    get hopeFeature() {
+        return this.hopeFeatures.length > 0 ? this.hopeFeatures[0] : null;
+    }
+
+    async _preCreate(data, options, user) {
+        const allowed = await super._preCreate(data, options, user);
+        if (allowed === false) return;
+
+        if (this.actor?.type === 'character') {
+            const path = data.system.isMulticlass ? 'system.multiclass.value' : 'system.class.value';
+            if (foundry.utils.getProperty(this.actor, path)) {
+                ui.notifications.error(game.i18n.localize('DAGGERHEART.Item.Errors.ClassAlreadySelected'));
+                return false;
+            }
+        }
+    }
+
+    _onCreate(data, options, userId) {
+        super._onCreate(data, options, userId);
+        if (options.parent?.type === 'character') {
+            const path = `system.${data.system.isMulticlass ? 'multiclass.value' : 'class.value'}`;
+            options.parent.update({ [path]: `${options.parent.uuid}.Item.${data._id}` });
+        }
+    }
+
+    _onDelete(options, userId) {
+        super._onDelete(options, userId);
+
+        if (options.parent?.type === 'character') {
+            const path = `system.${this.isMulticlass ? 'multiclass' : 'class'}`;
+            options.parent.update({
+                [`${path}.value`]: null
+            });
+
+            foundry.utils.getProperty(options.parent, `${path}.subclass`)?.delete();
+        }
+    }
+}

module/data/item/community.mjs

@@ -0,0 +1,22 @@
+import ActionField from '../fields/actionField.mjs';
+import BaseDataItem from './base.mjs';
+
+export default class DHCommunity extends BaseDataItem {
+    /** @inheritDoc */
+    static get metadata() {
+        return foundry.utils.mergeObject(super.metadata, {
+            label: 'TYPES.Item.community',
+            type: 'community',
+            hasDescription: true
+        });
+    }
+
+    /** @inheritDoc */
+    static defineSchema() {
+        const fields = foundry.data.fields;
+        return {
+            ...super.defineSchema(),
+            actions: new fields.ArrayField(new ActionField())
+        };
+    }
+}

module/data/item/consumable.mjs

@@ -0,0 +1,24 @@
+import BaseDataItem from './base.mjs';
+import ActionField from '../fields/actionField.mjs';
+
+export default class DHConsumable extends BaseDataItem {
+    /** @inheritDoc */
+    static get metadata() {
+        return foundry.utils.mergeObject(super.metadata, {
+            label: 'TYPES.Item.consumable',
+            type: 'consumable',
+            hasDescription: true,
+            isQuantifiable: true
+        });
+    }
+
+    /** @inheritDoc */
+    static defineSchema() {
+        const fields = foundry.data.fields;
+        return {
+            ...super.defineSchema(),
+            consumeOnUse: new fields.BooleanField({ initial: false }),
+            actions: new fields.ArrayField(new ActionField())
+        };
+    }
+}

module/data/item/domainCard.mjs

@@ -0,0 +1,50 @@
+import BaseDataItem from './base.mjs';
+import ActionField from '../fields/actionField.mjs';
+
+export default class DHDomainCard extends BaseDataItem {
+    /** @inheritDoc */
+    static get metadata() {
+        return foundry.utils.mergeObject(super.metadata, {
+            label: 'TYPES.Item.domainCard',
+            type: 'domainCard',
+            hasDescription: true
+        });
+    }
+
+    /** @inheritDoc */
+    static defineSchema() {
+        const fields = foundry.data.fields;
+        return {
+            ...super.defineSchema(),
+            domain: new fields.StringField({ choices: SYSTEM.DOMAIN.domains, required: true, blank: true }),
+            level: new fields.NumberField({ initial: 1, integer: true }),
+            recallCost: new fields.NumberField({ initial: 0, integer: true }),
+            type: new fields.StringField({ choices: SYSTEM.DOMAIN.cardTypes, required: true, blank: true }),
+            foundation: new fields.BooleanField({ initial: false }),
+            inVault: new fields.BooleanField({ initial: false }),
+            actions: new fields.ArrayField(new ActionField())
+        };
+    }
+
+    async _preCreate(data, options, user) {
+        const allowed = await super._preCreate(data, options, user);
+        if (allowed === false) return;
+
+        if (this.actor?.type === 'character') {
+            if (!this.actor.system.class.value) {
+                ui.notifications.error(game.i18n.localize('DAGGERHEART.Item.Errors.NoClassSelected'));
+                return false;
+            }
+
+            if (!this.actor.system.domains.find(x => x === this.domain)) {
+                ui.notifications.error(game.i18n.localize('DAGGERHEART.Item.Errors.LacksDomain'));
+                return false;
+            }
+
+            if (this.actor.system.domainCards.total.find(x => x.name === this.parent.name)) {
+                ui.notifications.error(game.i18n.localize('DAGGERHEART.Item.Errors.DuplicateDomainCard'));
+                return false;
+            }
+        }
+    }
+}

module/data/item/feature.mjs

@@ -0,0 +1,152 @@
+import { getTier } from '../../helpers/utils.mjs';
+import DHAction from '../action/action.mjs';
+import BaseDataItem from './base.mjs';
+import ActionField from '../fields/actionField.mjs';
+
+export default class DHFeature extends BaseDataItem {
+    /** @inheritDoc */
+    static get metadata() {
+        return foundry.utils.mergeObject(super.metadata, {
+            label: 'TYPES.Item.feature',
+            type: 'feature',
+            hasDescription: true
+        });
+    }
+
+    /** @inheritDoc */
+    static defineSchema() {
+        const fields = foundry.data.fields;
+        return {
+            ...super.defineSchema(),
+
+            //A type of feature seems unnecessary
+            type: new fields.StringField({ choices: SYSTEM.ITEM.featureTypes }),
+
+            //TODO: remove  actionType field
+            actionType: new fields.StringField({
+                choices: SYSTEM.ITEM.actionTypes,
+                initial: SYSTEM.ITEM.actionTypes.passive.id
+            }),
+            //TODO: remove  featureType field
+            featureType: new fields.SchemaField({
+                type: new fields.StringField({
+                    choices: SYSTEM.ITEM.valueTypes,
+                    initial: Object.keys(SYSTEM.ITEM.valueTypes).find(x => x === 'normal')
+                }),
+                data: new fields.SchemaField({
+                    value: new fields.StringField({}),
+                    property: new fields.StringField({
+                        choices: SYSTEM.ACTOR.featureProperties,
+                        initial: Object.keys(SYSTEM.ACTOR.featureProperties).find(x => x === 'spellcastingTrait')
+                    }),
+                    max: new fields.NumberField({ initial: 1, integer: true }),
+                    numbers: new fields.TypedObjectField(
+                        new fields.SchemaField({
+                            value: new fields.NumberField({ integer: true }),
+                            used: new fields.BooleanField({ initial: false })
+                        })
+                    )
+                })
+            }),
+            refreshData: new fields.SchemaField(
+                {
+                    type: new fields.StringField({ choices: SYSTEM.GENERAL.refreshTypes }),
+                    uses: new fields.NumberField({ initial: 1, integer: true }),
+                    //TODO: remove refreshed field
+                    refreshed: new fields.BooleanField({ initial: true })
+                },
+                { nullable: true, initial: null }
+            ),
+            //TODO: remove refreshed field
+            multiclass: new fields.NumberField({ initial: null, nullable: true, integer: true }),
+            disabled: new fields.BooleanField({ initial: false }),
+
+            //TODO: re do it completely or just remove it
+            effects: new fields.TypedObjectField(
+                new fields.SchemaField({
+                    type: new fields.StringField({ choices: SYSTEM.EFFECTS.effectTypes }),
+                    valueType: new fields.StringField({ choices: SYSTEM.EFFECTS.valueTypes }),
+                    parseType: new fields.StringField({ choices: SYSTEM.EFFECTS.parseTypes }),
+                    initiallySelected: new fields.BooleanField({ initial: true }),
+                    options: new fields.ArrayField(
+                        new fields.SchemaField({
+                            name: new fields.StringField({}),
+                            value: new fields.StringField({})
+                        }),
+                        { nullable: true, initial: null }
+                    ),
+                    dataField: new fields.StringField({}),
+                    appliesOn: new fields.StringField(
+                        {
+                            choices: SYSTEM.EFFECTS.applyLocations
+                        },
+                        { nullable: true, initial: null }
+                    ),
+                    applyLocationChoices: new fields.TypedObjectField(new fields.StringField({}), {
+                        nullable: true,
+                        initial: null
+                    }),
+                    valueData: new fields.SchemaField({
+                        value: new fields.StringField({}),
+                        fromValue: new fields.StringField({ initial: null, nullable: true }),
+                        type: new fields.StringField({ initial: null, nullable: true }),
+                        hopeIncrease: new fields.StringField({ initial: null, nullable: true })
+                    })
+                })
+            ),
+            actions: new fields.ArrayField(new ActionField())
+        };
+    }
+
+    get multiclassTier() {
+        return getTier(this.multiclass);
+    }
+
+    async refresh() {
+        if (this.refreshData) {
+            if (this.featureType.type === SYSTEM.ITEM.valueTypes.dice.id) {
+                const update = { 'system.refreshData.refreshed': true };
+                Object.keys(this.featureType.data.numbers).forEach(
+                    x => (update[`system.featureType.data.numbers.-=${x}`] = null)
+                );
+                await this.parent.update(update);
+            } else {
+                await this.parent.update({ 'system.refreshData.refreshed': true });
+            }
+        }
+    }
+
+    get effectData() {
+        const effectValues = Object.values(this.effects);
+        const effectCategories = Object.keys(SYSTEM.EFFECTS.effectTypes).reduce((acc, effectType) => {
+            acc[effectType] = effectValues.reduce((acc, effect) => {
+                if (effect.type === effectType) {
+                    acc.push({ ...effect, valueData: this.#parseValues(effect.parseType, effect.valueData) });
+                }
+
+                return acc;
+            }, []);
+
+            return acc;
+        }, {});
+
+        return effectCategories;
+    }
+
+    #parseValues(parseType, values) {
+        return Object.keys(values).reduce((acc, prop) => {
+            acc[prop] = this.#parseValue(parseType, values[prop]);
+
+            return acc;
+        }, {});
+    }
+
+    #parseValue(parseType, value) {
+        switch (parseType) {
+            case SYSTEM.EFFECTS.parseTypes.number.id:
+                return Number.parseInt(value);
+            default:
+                return value;
+        }
+    }
+}

module/data/item/miscellaneous.mjs

@@ -0,0 +1,23 @@
+import BaseDataItem from './base.mjs';
+import ActionField from '../fields/actionField.mjs';
+
+export default class DHMiscellaneous extends BaseDataItem {
+    /** @inheritDoc */
+    static get metadata() {
+        return foundry.utils.mergeObject(super.metadata, {
+            label: 'TYPES.Item.miscellaneous',
+            type: 'miscellaneous',
+            hasDescription: true,
+            isQuantifiable: true
+        });
+    }
+
+    /** @inheritDoc */
+    static defineSchema() {
+        const fields = foundry.data.fields;
+        return {
+            ...super.defineSchema(),
+            actions: new fields.ArrayField(new ActionField())
+        };
+    }
+}

module/data/item/subclass.mjs

@@ -0,0 +1,91 @@
+import ActionField from '../fields/actionField.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 ForeignDocumentUUIDArrayField({ type: 'Item', required: false }),
+        actions: new foundry.data.fields.ArrayField(new ActionField())
+    });
+};
+
+export default class DHSubclass extends BaseDataItem {
+    /** @inheritDoc */
+    static get metadata() {
+        return foundry.utils.mergeObject(super.metadata, {
+            label: 'TYPES.Item.subclass',
+            type: 'subclass',
+            hasDescription: true
+        });
+    }
+
+    /** @inheritDoc */
+    static defineSchema() {
+        const fields = foundry.data.fields;
+        return {
+            ...super.defineSchema(),
+            spellcastingTrait: new fields.StringField({
+                choices: SYSTEM.ACTOR.abilities,
+                integer: false,
+                nullable: true,
+                initial: null
+            }),
+            foundationFeature: featureSchema(),
+            specializationFeature: featureSchema(),
+            masteryFeature: featureSchema(),
+            featureState: new fields.NumberField({ required: true, initial: 1, min: 1 }),
+            isMulticlass: new fields.BooleanField({ initial: false })
+        };
+    }
+
+    get features() {
+        return {
+            foundation: this.foundationFeature,
+            specialization: this.featureState >= 2 ? this.specializationFeature : null,
+            mastery: this.featureState === 3 ? this.masteryFeature : null
+        };
+    }
+
+    async _preCreate(data, options, user) {
+        const allowed = await super._preCreate(data, options, user);
+        if (allowed === false) return;
+
+        if (this.actor?.type === 'character') {
+            const classData = this.actor.items.find(
+                x => x.type === 'class' && x.system.isMulticlass === data.system.isMulticlass
+            );
+            const subclassData = this.actor.items.find(
+                x => x.type === 'subclass' && x.system.isMulticlass === data.system.isMulticlass
+            );
+            if (!classData) {
+                ui.notifications.error(game.i18n.localize('DAGGERHEART.Item.Errors.MissingClass'));
+                return false;
+            } else if (subclassData) {
+                ui.notifications.error(game.i18n.localize('DAGGERHEART.Item.Errors.SubclassAlreadySelected'));
+                return false;
+            } 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;
+            }
+        }
+    }
+
+    _onCreate(data, options, userId) {
+        super._onCreate(data, options, userId);
+
+        if (options.parent?.type === 'character') {
+            const path = `system.${data.system.isMulticlass ? 'multiclass.subclass' : 'class.subclass'}`;
+            options.parent.update({ [path]: `${options.parent.uuid}.Item.${data._id}` });
+        }
+    }
+
+    _onDelete(options, userId) {
+        super._onDelete(options, userId);
+
+        if (options.parent?.type === 'character') {
+            const path = `system.${this.isMulticlass ? 'multiclass.subclass' : 'class.subclass'}`;
+            options.parent.update({ [path]: null });
+        }
+    }
+}

module/data/item/weapon.mjs

@@ -0,0 +1,96 @@
+import BaseDataItem from './base.mjs';
+import FormulaField from '../fields/formulaField.mjs';
+import ActionField from '../fields/actionField.mjs';
+import { weaponFeatures } from '../../config/itemConfig.mjs';
+import { actionsTypes } from '../../data/_module.mjs';
+
+export default class DHWeapon extends BaseDataItem {
+    /** @inheritDoc */
+    static get metadata() {
+        return foundry.utils.mergeObject(super.metadata, {
+            label: 'TYPES.Item.weapon',
+            type: 'weapon',
+            hasDescription: true,
+            isQuantifiable: true,
+            embedded: {
+                feature: 'featureTest'
+            }
+        });
+    }
+
+    /** @inheritDoc */
+    static defineSchema() {
+        const fields = foundry.data.fields;
+        return {
+            ...super.defineSchema(),
+            tier: new fields.NumberField({ required: true, integer: true, initial: 1, min: 1 }),
+            equipped: new fields.BooleanField({ initial: false }),
+
+            //SETTINGS
+            secondary: new fields.BooleanField({ initial: false }),
+            trait: new fields.StringField({ required: true, choices: SYSTEM.ACTOR.abilities, initial: 'agility' }),
+            range: new fields.StringField({ required: true, choices: SYSTEM.GENERAL.range, initial: 'melee' }),
+            burden: new fields.StringField({ required: true, choices: SYSTEM.GENERAL.burden, initial: 'oneHanded' }),
+            //DAMAGE
+            damage: new fields.SchemaField({
+                value: new FormulaField({ initial: 'd6' }),
+                type: new fields.StringField({
+                    required: true,
+                    choices: SYSTEM.GENERAL.damageTypes,
+                    initial: 'physical'
+                })
+            }),
+            features: new fields.ArrayField(
+                new fields.SchemaField({
+                    value: new fields.StringField({ required: true, choices: SYSTEM.ITEM.weaponFeatures, blank: true }),
+                    effectIds: new fields.ArrayField(new fields.StringField({ required: true })),
+                    actionIds: new fields.ArrayField(new fields.StringField({ required: true }))
+                })
+            ),
+            actions: new fields.ArrayField(new ActionField())
+        };
+    }
+
+    async _preUpdate(changes, options, user) {
+        const allowed = await super._preUpdate(changes, options, user);
+        if (allowed === false) return false;
+
+        if (changes.system.features) {
+            const removed = this.features.filter(x => !changes.system.features.includes(x));
+            const added = changes.system.features.filter(x => !this.features.includes(x));
+
+            for (var feature of removed) {
+                for (var effectId of feature.effectIds) {
+                    await this.parent.effects.get(effectId).delete();
+                }
+
+                changes.system.actions = this.actions.filter(x => !feature.actionIds.includes(x._id));
+            }
+
+            for (var feature of added) {
+                const featureData = weaponFeatures[feature.value];
+                if (featureData.effects?.length > 0) {
+                    const embeddedItems = await this.parent.createEmbeddedDocuments('ActiveEffect', [
+                        {
+                            name: game.i18n.localize(featureData.label),
+                            description: game.i18n.localize(featureData.description),
+                            changes: featureData.effects.flatMap(x => x.changes)
+                        }
+                    ]);
+                    feature.effectIds = embeddedItems.map(x => x.id);
+                }
+                if (featureData.actions?.length > 0) {
+                    const newActions = featureData.actions.map(action => {
+                        const cls = actionsTypes[action.type];
+                        return new cls(
+                            { ...action, _id: foundry.utils.randomID(), name: game.i18n.localize(action.name) },
+                            { parent: this }
+                        );
+                    });
+                    changes.system.actions = [...this.actions, ...newActions];
+                    feature.actionIds = newActions.map(x => x._id);
+                }
+            }
+        }
+    }
+}