Merged with main

module/applications/_module.mjs

@@ -1,5 +1,6 @@
 export * as characterCreation from './characterCreation/_module.mjs';
 export * as dialogs from './dialogs/_module.mjs';
+export * as hud from './hud/_module.mjs';
 export * as levelup from './levelup/_module.mjs';
 export * as settings from './settings/_module.mjs';
 export * as sheets from './sheets/_module.mjs';

module/applications/characterCreation/characterCreation.mjs

@@ -11,13 +11,16 @@ export default class DhCharacterCreation extends HandlebarsApplicationMixin(Appl
 
         this.setup = {
             traits: this.character.system.traits,
-            ancestry: this.character.system.ancestry ?? {},
+            ancestryName: '',
+            mixedAncestry: false,
+            primaryAncestry: this.character.system.ancestry ?? {},
+            secondaryAncestry: {},
             community: this.character.system.community ?? {},
             class: this.character.system.class?.value ?? {},
             subclass: this.character.system.class?.subclass ?? {},
             experiences: {
-                [foundry.utils.randomID()]: { description: '', value: 2 },
-                [foundry.utils.randomID()]: { description: '', value: 2 }
+                [foundry.utils.randomID()]: { name: '', value: 2 },
+                [foundry.utils.randomID()]: { name: '', value: 2 }
             },
             domainCards: {
                 [foundry.utils.randomID()]: {},
@@ -47,12 +50,13 @@ export default class DhCharacterCreation extends HandlebarsApplicationMixin(Appl
     static DEFAULT_OPTIONS = {
         tag: 'form',
         classes: ['daggerheart', 'dialog', 'dh-style', 'character-creation'],
-        position: { width: 800, height: 'auto' },
+        position: { width: 700, height: 'auto' },
         actions: {
             viewCompendium: this.viewCompendium,
             viewItem: this.viewItem,
             useSuggestedTraits: this.useSuggestedTraits,
             equipmentChoice: this.equipmentChoice,
+            setupGoNext: this.setupGoNext,
             finish: this.finish
         },
         form: {
@@ -76,6 +80,12 @@ export default class DhCharacterCreation extends HandlebarsApplicationMixin(Appl
     static PARTS = {
         tabs: { template: 'systems/daggerheart/templates/characterCreation/tabs.hbs' },
         setup: { template: 'systems/daggerheart/templates/characterCreation/tabs/setup.hbs' },
+        ancestry: { template: 'systems/daggerheart/templates/characterCreation/setupTabs/ancestry.hbs' },
+        community: { template: 'systems/daggerheart/templates/characterCreation/setupTabs/community.hbs' },
+        class: { template: 'systems/daggerheart/templates/characterCreation/setupTabs/class.hbs' },
+        traits: { template: 'systems/daggerheart/templates/characterCreation/setupTabs/traits.hbs' },
+        experience: { template: 'systems/daggerheart/templates/characterCreation/setupTabs/experience.hbs' },
+        domainCards: { template: 'systems/daggerheart/templates/characterCreation/setupTabs/domainCards.hbs' },
         equipment: { template: 'systems/daggerheart/templates/characterCreation/tabs/equipment.hbs' },
         // story: { template: 'systems/daggerheart/templates/characterCreation/tabs/story.hbs' },
         footer: { template: 'systems/daggerheart/templates/characterCreation/footer.hbs' }
@@ -107,6 +117,51 @@ export default class DhCharacterCreation extends HandlebarsApplicationMixin(Appl
         // }
     };
 
+    static SETUPTABS = {
+        ancestry: {
+            active: true,
+            cssClass: '',
+            group: 'setup',
+            id: 'ancestry',
+            label: 'DAGGERHEART.APPLICATIONS.CharacterCreation.setupTabs.ancestry'
+        },
+        community: {
+            active: false,
+            cssClass: '',
+            group: 'setup',
+            id: 'community',
+            label: 'DAGGERHEART.APPLICATIONS.CharacterCreation.setupTabs.community'
+        },
+        class: {
+            active: false,
+            cssClass: '',
+            group: 'setup',
+            id: 'class',
+            label: 'DAGGERHEART.APPLICATIONS.CharacterCreation.setupTabs.class'
+        },
+        traits: {
+            active: false,
+            cssClass: '',
+            group: 'setup',
+            id: 'traits',
+            label: 'DAGGERHEART.APPLICATIONS.CharacterCreation.setupTabs.traits'
+        },
+        experience: {
+            active: false,
+            cssClass: '',
+            group: 'setup',
+            id: 'experience',
+            label: 'DAGGERHEART.APPLICATIONS.CharacterCreation.setupTabs.experience'
+        },
+        domainCards: {
+            active: false,
+            cssClass: '',
+            group: 'setup',
+            id: 'domainCards',
+            label: 'DAGGERHEART.APPLICATIONS.CharacterCreation.setupTabs.domainCards'
+        }
+    };
+
     _getTabs(tabs) {
         for (const v of Object.values(tabs)) {
             v.active = this.tabGroups[v.group] ? this.tabGroups[v.group] === v.id : v.active;
@@ -114,14 +169,16 @@ export default class DhCharacterCreation extends HandlebarsApplicationMixin(Appl
 
             switch (v.id) {
                 case 'setup':
+                    const ancestryFinished = this.setup.primaryAncestry.uuid;
+                    const communityFinished = this.setup.community.uuid;
                     const classFinished = this.setup.class.uuid && this.setup.subclass.uuid;
-                    const heritageFinished = this.setup.ancestry.uuid && this.setup.community.uuid;
                     const traitsFinished = Object.values(this.setup.traits).every(x => x.value !== null);
-                    const experiencesFinished = Object.values(this.setup.experiences).every(x => x.description);
+                    const experiencesFinished = Object.values(this.setup.experiences).every(x => x.name);
                     const domainCardsFinished = Object.values(this.setup.domainCards).every(x => x.uuid);
                     v.finished =
+                        ancestryFinished &&
+                        communityFinished &&
                         classFinished &&
-                        heritageFinished &&
                         traitsFinished &&
                         experiencesFinished &&
                         domainCardsFinished;
@@ -146,15 +203,44 @@ export default class DhCharacterCreation extends HandlebarsApplicationMixin(Appl
         return tabs;
     }
 
+    _getSetupTabs(tabs) {
+        for (const v of Object.values(tabs)) {
+            v.active = this.tabGroups[v.group] ? this.tabGroups[v.group] === v.id : v.active;
+            v.cssClass = v.active ? 'active' : '';
+
+            switch (v.id) {
+                case 'community':
+                    v.disabled = this.setup.visibility < 2;
+                    break;
+                case 'class':
+                    v.disabled = this.setup.visibility < 3;
+                    break;
+                case 'traits':
+                    v.disabled = this.setup.visibility < 4;
+                    break;
+                case 'experience':
+                    v.disabled = this.setup.visibility < 5;
+                    break;
+                case 'domainCards':
+                    v.disabled = this.setup.visibility < 6;
+                    break;
+            }
+        }
+
+        return tabs;
+    }
+
     changeTab(tab, group, options) {
         super.changeTab(tab, group, options);
 
-        for (var listTab of Object.keys(this.constructor.TABS)) {
-            const marker = options.navElement.querySelector(`a[data-action="tab"].${listTab} .finish-marker`);
-            if (listTab === tab) {
-                marker.classList.add('active');
-            } else {
-                marker.classList.remove('active');
+        if (group === 'primary') {
+            for (var listTab of Object.keys(this.constructor.TABS)) {
+                const marker = options.navElement.querySelector(`a[data-action="tab"].${listTab} .finish-marker`);
+                if (listTab === tab) {
+                    marker.classList.add('active');
+                } else {
+                    marker.classList.remove('active');
+                }
             }
         }
     }
@@ -163,6 +249,11 @@ export default class DhCharacterCreation extends HandlebarsApplicationMixin(Appl
         super._attachPartListeners(partId, htmlElement, options);
 
         this._dragDrop.forEach(d => d.bind(htmlElement));
+
+        htmlElement.querySelectorAll('.mixed-ancestry-slider').forEach(element => {
+            element.addEventListener('input', this.mixedAncestryToggle.bind(this));
+            element.addEventListener('click', this.mixedAncestryToggle.bind(this));
+        });
     }
 
     async _prepareContext(_options) {
@@ -174,7 +265,30 @@ export default class DhCharacterCreation extends HandlebarsApplicationMixin(Appl
 
     async _preparePartContext(partId, context) {
         switch (partId) {
+            case 'footer':
+                context.isLastTab = this.tabGroups.setup === 'domainCards';
+                switch (this.tabGroups.setup) {
+                    case null:
+                    case 'ancestry':
+                        context.nextDisabled = this.setup.visibility === 1;
+                        break;
+                    case 'community':
+                        context.nextDisabled = this.setup.visibility === 2;
+                        break;
+                    case 'class':
+                        context.nextDisabled = this.setup.visibility === 3;
+                        break;
+                    case 'traits':
+                        context.nextDisabled = this.setup.visibility === 4;
+                        break;
+                    case 'experience':
+                        context.nextDisabled = this.setup.visibility === 5;
+                        break;
+                }
+
+                break;
             case 'setup':
+                context.setupTabs = this._getSetupTabs(this.constructor.SETUPTABS);
                 const availableTraitModifiers = game.settings
                     .get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Homebrew)
                     .traitArray.map(trait => ({ key: trait, name: trait }));
@@ -215,13 +329,13 @@ export default class DhCharacterCreation extends HandlebarsApplicationMixin(Appl
                 context.experience = {
                     values: this.setup.experiences,
                     nrTotal: Object.keys(this.setup.experiences).length,
-                    nrSelected: Object.values(this.setup.experiences).reduce(
-                        (acc, exp) => acc + (exp.description ? 1 : 0),
-                        0
-                    )
+                    nrSelected: Object.values(this.setup.experiences).reduce((acc, exp) => acc + (exp.name ? 1 : 0), 0)
                 };
 
-                context.ancestry = { ...this.setup.ancestry, compendium: 'ancestries' };
+                context.mixedAncestry = Number(this.setup.mixedAncestry);
+                context.ancestryName = this.setup.ancestryName;
+                context.primaryAncestry = { ...this.setup.primaryAncestry, compendium: 'ancestries' };
+                context.secondaryAncestry = { ...this.setup.secondaryAncestry, compendium: 'ancestries' };
                 context.community = { ...this.setup.community, compendium: 'communities' };
                 context.class = { ...this.setup.class, compendium: 'classes' };
                 context.subclass = { ...this.setup.subclass, compendium: 'subclasses' };
@@ -278,18 +392,29 @@ export default class DhCharacterCreation extends HandlebarsApplicationMixin(Appl
         this.render();
     }
 
+    mixedAncestryToggle(event) {
+        event.preventDefault();
+        event.stopPropagation();
+        this.setup.mixedAncestry = !this.setup.mixedAncestry;
+        if (!this.setup.mixedAncestry) this.setup.secondaryAncestry = {};
+
+        this.render();
+    }
+
     getUpdateVisibility() {
         switch (this.setup.visibility) {
+            case 6:
+                return 6;
             case 5:
-                return 5;
+                return Object.values(this.setup.experiences).every(x => x.name) ? 6 : 5;
             case 4:
-                return Object.values(this.setup.experiences).every(x => x.description) ? 5 : 4;
+                return Object.values(this.setup.traits).every(x => x.value !== null) ? 5 : 4;
             case 3:
-                return Object.values(this.setup.traits).every(x => x.value !== null) ? 4 : 3;
+                return this.setup.class.uuid && this.setup.subclass.uuid ? 4 : 3;
             case 2:
-                return this.setup.ancestry.uuid && this.setup.community.uuid ? 3 : 2;
+                return this.setup.community.uuid ? 3 : 2;
             case 1:
-                return this.setup.class.uuid && this.setup.subclass.uuid ? 2 : 1;
+                return this.setup.primaryAncestry.uuid ? 2 : 1;
         }
     }
 
@@ -348,8 +473,44 @@ export default class DhCharacterCreation extends HandlebarsApplicationMixin(Appl
         this.render();
     }
 
+    static setupGoNext() {
+        switch (this.setup.visibility) {
+            case 2:
+                this.tabGroups.setup = 'community';
+                break;
+            case 3:
+                this.tabGroups.setup = 'class';
+                break;
+            case 4:
+                this.tabGroups.setup = 'traits';
+                break;
+            case 5:
+                this.tabGroups.setup = 'experience';
+                break;
+            case 6:
+                this.tabGroups.setup = 'domainCards';
+                break;
+        }
+
+        this.render();
+    }
+
     static async finish() {
-        await this.character.createEmbeddedDocuments('Item', [this.setup.ancestry]);
+        const primaryAncestryFeature = this.setup.primaryAncestry.system.primaryFeature;
+        const secondaryAncestryFeature = this.setup.secondaryAncestry?.uuid
+            ? this.setup.secondaryAncestry.system.secondaryFeature
+            : this.setup.primaryAncestry.system.secondaryFeature;
+
+        const ancestry = {
+            ...this.setup.primaryAncestry,
+            name: this.setup.ancestryName ?? this.setup.primaryAncestry.name,
+            system: {
+                ...this.setup.primaryAncestry.system,
+                features: [primaryAncestryFeature.uuid, secondaryAncestryFeature.uuid]
+            }
+        };
+
+        await this.character.createEmbeddedDocuments('Item', [ancestry]);
         await this.character.createEmbeddedDocuments('Item', [this.setup.community]);
         await this.character.createEmbeddedDocuments('Item', [this.setup.class]);
         await this.character.createEmbeddedDocuments('Item', [this.setup.subclass]);
@@ -396,8 +557,15 @@ export default class DhCharacterCreation extends HandlebarsApplicationMixin(Appl
     async _onDrop(event) {
         const data = foundry.applications.ux.TextEditor.implementation.getDragEventData(event);
         const item = await foundry.utils.fromUuid(data.uuid);
-        if (item.type === 'ancestry' && event.target.closest('.ancestry-card')) {
-            this.setup.ancestry = {
+        if (item.type === 'ancestry' && event.target.closest('.primary-ancestry-card')) {
+            this.setup.ancestryName = item.name;
+            this.setup.primaryAncestry = {
+                ...item,
+                effects: Array.from(item.effects).map(x => x.toObject()),
+                uuid: item.uuid
+            };
+        } else if (item.type === 'ancestry' && event.target.closest('.secondary-ancestry-card')) {
+            this.setup.secondaryAncestry = {
                 ...item,
                 effects: Array.from(item.effects).map(x => x.toObject()),
                 uuid: item.uuid

module/applications/dialogs/_module.mjs

@@ -1,5 +1,4 @@
 export { default as BeastformDialog } from './beastformDialog.mjs';
-export { default as costSelectionDialog } from './costSelectionDialog.mjs';
 export { default as d20RollDialog } from './d20RollDialog.mjs';
 export { default as DamageDialog } from './damageDialog.mjs';
 export { default as DamageReductionDialog } from './damageReductionDialog.mjs';
@@ -7,3 +6,4 @@ export { default as DamageSelectionDialog } from './damageSelectionDialog.mjs';
 export { default as DeathMove } from './deathMove.mjs';
 export { default as Downtime } from './downtime.mjs';
 export { default as OwnershipSelection } from './ownershipSelection.mjs';
+export { default as ResourceDiceDialog } from './resourceDiceDialog.mjs';

module/applications/dialogs/beastformDialog.mjs

@@ -1,67 +1,261 @@
 const { ApplicationV2, HandlebarsApplicationMixin } = foundry.applications.api;
 
 export default class BeastformDialog extends HandlebarsApplicationMixin(ApplicationV2) {
-    constructor(configData) {
+    constructor(configData, item) {
         super();
 
+        this.item = item;
+
         this.configData = configData;
         this.selected = null;
+        this.evolved = { form: null };
+        this.hybrid = { forms: {}, advantages: {}, features: {} };
+
+        this._dragDrop = this._createDragDropHandlers();
     }
 
     static DEFAULT_OPTIONS = {
         tag: 'form',
-        classes: ['daggerheart', 'views', 'dh-style', 'beastform-selection'],
+        classes: ['daggerheart', 'views', 'dialog', 'dh-style', 'beastform-selection'],
         position: {
             width: 600,
             height: 'auto'
         },
+        window: {
+            icon: 'fa-solid fa-paw'
+        },
         actions: {
             selectBeastform: this.selectBeastform,
+            toggleHybridFeature: this.toggleHybridFeature,
+            toggleHybridAdvantage: this.toggleHybridAdvantage,
             submitBeastform: this.submitBeastform
         },
         form: {
             handler: this.updateBeastform,
             submitOnChange: true,
             submitOnClose: false
-        }
+        },
+        dragDrop: [{ dragSelector: '.beastform-container', dropSelector: '.advanced-form-container' }]
     };
 
     get title() {
-        return game.i18n.localize('DAGGERHEART.ITEMS.Beastform.dialogTitle');
+        return this.item.name;
     }
 
     /** @override */
     static PARTS = {
-        beastform: {
-            template: 'systems/daggerheart/templates/dialogs/beastformDialog.hbs'
+        header: { template: 'systems/daggerheart/templates/dialogs/beastform/header.hbs' },
+        tabs: { template: 'systems/daggerheart/templates/dialogs/beastform/tabs.hbs' },
+        beastformTier: { template: 'systems/daggerheart/templates/dialogs/beastform/beastformTier.hbs' },
+        advanced: { template: 'systems/daggerheart/templates/dialogs/beastform/advanced.hbs' },
+        footer: { template: 'systems/daggerheart/templates/dialogs/beastform/footer.hbs' }
+    };
+
+    /** @inheritdoc */
+    static TABS = {
+        primary: {
+            tabs: [{ id: '1' }, { id: '2' }, { id: '3' }, { id: '4' }],
+            initial: '1',
+            labelPrefix: 'DAGGERHEART.GENERAL.Tiers'
         }
     };
 
+    changeTab(tab, group, options) {
+        super.changeTab(tab, group, options);
+
+        this.render();
+    }
+
+    _createDragDropHandlers() {
+        return this.options.dragDrop.map(d => {
+            d.callbacks = {
+                dragstart: this._onDragStart.bind(this),
+                drop: this._onDrop.bind(this)
+            };
+            return new foundry.applications.ux.DragDrop.implementation(d);
+        });
+    }
+
+    _attachPartListeners(partId, htmlElement, options) {
+        super._attachPartListeners(partId, htmlElement, options);
+
+        this._dragDrop.forEach(d => d.bind(htmlElement));
+    }
+
     async _prepareContext(_options) {
         const context = await super._prepareContext(_options);
 
-        context.beastformTiers = game.items.reduce((acc, x) => {
-            const tier = CONFIG.DH.GENERAL.tiers[x.system.tier];
-            if (x.type !== 'beastform' || tier.value > this.configData.tierLimit) return acc;
+        context.selected = this.selected;
+        context.selectedBeastformEffect = this.selected?.effects?.find?.(x => x.type === 'beastform');
 
-            if (!acc[tier.value]) acc[tier.value] = { label: game.i18n.localize(tier.label), values: {} };
-            acc[tier.value].values[x.uuid] = { selected: this.selected == x.uuid, value: x };
+        context.evolved = this.evolved;
 
+        context.hybridForms = Object.keys(this.hybrid.forms).reduce((acc, formKey) => {
+            if (!this.hybrid.forms[formKey]) {
+                acc[formKey] = null;
+            } else {
+                const data = this.hybrid.forms[formKey].toObject();
+                acc[formKey] = {
+                    ...data,
+                    system: {
+                        ...data.system,
+                        features: this.hybrid.forms[formKey].system.features.map(feature => ({
+                            ...feature.toObject(),
+                            uuid: feature.uuid,
+                            selected: Boolean(this.hybrid.features?.[formKey]?.[feature.uuid])
+                        })),
+                        advantageOn: Object.keys(data.system.advantageOn).reduce((acc, key) => {
+                            acc[key] = {
+                                ...data.system.advantageOn[key],
+                                selected: Boolean(this.hybrid.advantages?.[formKey]?.[key])
+                            };
+                            return acc;
+                        }, {})
+                    }
+                };
+            }
             return acc;
-        }, {}); // Also get from compendium when added
-        context.canSubmit = this.selected;
+        }, {});
+
+        const maximumDragTier = Math.max(
+            this.selected?.system?.evolved?.maximumTier ?? 0,
+            this.selected?.system?.hybrid?.maximumTier ?? 0
+        );
+
+        const compendiumBeastforms = await game.packs.get(`daggerheart.beastforms`)?.getDocuments();
+        const beastformTiers = [...(compendiumBeastforms ? compendiumBeastforms : []), ...game.items].reduce(
+            (acc, x) => {
+                const tier = CONFIG.DH.GENERAL.tiers[x.system.tier];
+                if (x.type !== 'beastform' || tier.id > this.configData.tierLimit) return acc;
+
+                if (!acc[tier.id]) acc[tier.id] = { label: game.i18n.localize(tier.label), values: {} };
+
+                acc[tier.id].values[x.uuid] = {
+                    selected: this.selected?.uuid == x.uuid,
+                    value: x,
+                    draggable:
+                        !['evolved', 'hybrid'].includes(x.system.beastformType) && maximumDragTier
+                            ? x.system.tier <= maximumDragTier
+                            : false
+                };
+
+                return acc;
+            },
+            {}
+        );
+
+        context.tier = beastformTiers[this.tabGroups.primary];
+        context.tierKey = this.tabGroups.primary;
+
+        context.canSubmit = this.canSubmit();
 
         return context;
     }
 
+    canSubmit() {
+        if (this.selected) {
+            switch (this.selected.system.beastformType) {
+                case 'normal':
+                    return true;
+                case 'evolved':
+                    return this.evolved.form;
+                case 'hybrid':
+                    const selectedAdvantages = Object.values(this.hybrid.advantages).reduce(
+                        (acc, form) => acc + Object.values(form).length,
+                        0
+                    );
+                    const selectedFeatures = Object.values(this.hybrid.features).reduce(
+                        (acc, form) => acc + Object.values(form).length,
+                        0
+                    );
+
+                    const advantagesSelected = selectedAdvantages === this.selected.system.hybrid.advantages;
+                    const featuresSelected = selectedFeatures === this.selected.system.hybrid.features;
+                    return advantagesSelected && featuresSelected;
+            }
+        }
+
+        return false;
+    }
+
     static updateBeastform(event, _, formData) {
         this.selected = foundry.utils.mergeObject(this.selected, formData.object);
 
         this.render();
     }
 
-    static selectBeastform(_, target) {
-        this.selected = this.selected === target.dataset.uuid ? null : target.dataset.uuid;
+    static async selectBeastform(_, target) {
+        this.element.querySelectorAll('.beastform-container ').forEach(element => {
+            if (element.dataset.uuid === target.dataset.uuid && this.selected?.uuid !== target.dataset.uuid) {
+                element.classList.remove('inactive');
+            } else {
+                element.classList.add('inactive');
+            }
+        });
+
+        const uuid = this.selected?.uuid === target.dataset.uuid ? null : target.dataset.uuid;
+        this.selected = uuid ? await foundry.utils.fromUuid(uuid) : null;
+
+        if (this.selected) {
+            if (this.selected.system.beastformType !== 'evolved') this.evolved.form = null;
+            if (this.selected.system.beastformType !== 'hybrid') {
+                this.hybrid.forms = {};
+                this.hybrid.advantages = {};
+                this.hybrid.features = {};
+            } else {
+                this.hybrid.forms = [...Array(this.selected.system.hybrid.beastformOptions).keys()].reduce((acc, _) => {
+                    acc[foundry.utils.randomID()] = null;
+                    return acc;
+                }, {});
+            }
+        }
+
+        this.render();
+    }
+
+    static toggleHybridFeature(_, button) {
+        const current = this.hybrid.features[button.dataset.form];
+        if (!current) this.hybrid.features[button.dataset.form] = {};
+
+        if (this.hybrid.features[button.dataset.form][button.id])
+            delete this.hybrid.features[button.dataset.form][button.id];
+        else {
+            const currentFeatures = Object.values(this.hybrid.features).reduce(
+                (acc, form) => acc + Object.values(form).length,
+                0
+            );
+            if (currentFeatures === this.selected.system.hybrid.features) {
+                ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.Notifications.beastformToManyFeatures'));
+                return;
+            }
+
+            const feature = this.hybrid.forms[button.dataset.form].system.features.find(x => x.uuid === button.id);
+            this.hybrid.features[button.dataset.form][button.id] = feature;
+        }
+
+        this.render();
+    }
+
+    static toggleHybridAdvantage(_, button) {
+        const current = this.hybrid.advantages[button.dataset.form];
+        if (!current) this.hybrid.advantages[button.dataset.form] = {};
+
+        if (this.hybrid.advantages[button.dataset.form][button.id])
+            delete this.hybrid.advantages[button.dataset.form][button.id];
+        else {
+            const currentAdvantages = Object.values(this.hybrid.advantages).reduce(
+                (acc, form) => acc + Object.values(form).length,
+                0
+            );
+            if (currentAdvantages === this.selected.system.hybrid.advantages) {
+                ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.Notifications.beastformToManyAdvantages'));
+                return;
+            }
+
+            const advantage = this.hybrid.forms[button.dataset.form].system.advantageOn[button.id];
+            this.hybrid.advantages[button.dataset.form][button.id] = advantage;
+        }
+
         this.render();
     }
 
@@ -71,14 +265,61 @@ export default class BeastformDialog extends HandlebarsApplicationMixin(Applicat
 
     /** @override */
     _onClose(options = {}) {
-        if (!options.submitted) this.config = false;
+        if (!options.submitted) this.selected = null;
     }
 
-    static async configure(configData) {
+    static async configure(configData, item) {
         return new Promise(resolve => {
-            const app = new this(configData);
-            app.addEventListener('close', () => resolve(app.selected), { once: true });
+            const app = new this(configData, item);
+            const featureItem = item;
+            app.addEventListener(
+                'close',
+                () => resolve({ selected: app.selected, evolved: app.evolved, hybrid: app.hybrid, item: featureItem }),
+                { once: true }
+            );
             app.render({ force: true });
         });
     }
+
+    async _onDragStart(event) {
+        const target = event.currentTarget;
+        const abort = () => event.preventDefault();
+        if (!this.selected) abort();
+
+        const draggedForm = await foundry.utils.fromUuid(target.dataset.uuid);
+        if (['evolved', 'hybrid'].includes(draggedForm.system.beastformType)) abort();
+
+        if (this.selected.system.beastformType === 'evolved') {
+            if (draggedForm.system.tier > this.selected.system.evolved.maximumTier) abort();
+        }
+        if (this.selected.system.beastformType === 'hybrid') {
+            if (draggedForm.system.tier > this.selected.system.hybrid.maximumTier) abort();
+        }
+
+        event.dataTransfer.setData('text/plain', JSON.stringify(target.dataset));
+        event.dataTransfer.setDragImage(target, 60, 0);
+    }
+
+    async _onDrop(event) {
+        event.stopPropagation();
+        const data = foundry.applications.ux.TextEditor.getDragEventData(event);
+        const item = await fromUuid(data.uuid);
+        if (!item) return;
+
+        if (event.target.closest('.advanced-form-container.evolved')) {
+            this.evolved.form = item;
+        } else {
+            const hybridContainer = event.target.closest('.advanced-form-container.hybridized');
+            if (hybridContainer) {
+                const existingId = Object.keys(this.hybrid.forms).find(
+                    key => this.hybrid.forms[key]?.uuid === item.uuid
+                );
+                if (existingId) this.hybrid.forms[existingId] = null;
+
+                this.hybrid.forms[hybridContainer.id] = item;
+            }
+        }
+
+        this.render();
+    }
 }

module/applications/dialogs/costSelectionDialog.mjs

@@ -1,66 +0,0 @@
-const { ApplicationV2, HandlebarsApplicationMixin } = foundry.applications.api;
-
-export default class CostSelectionDialog extends HandlebarsApplicationMixin(ApplicationV2) {
-    constructor(costs, uses, action, resolve) {
-        super({});
-        this.costs = costs;
-        this.uses = uses;
-        this.action = action;
-        this.resolve = resolve;
-    }
-
-    static DEFAULT_OPTIONS = {
-        tag: 'form',
-        classes: ['daggerheart', 'views', 'damage-selection'],
-        position: {
-            width: 400,
-            height: 'auto'
-        },
-        actions: {
-            sendCost: this.sendCost
-        },
-        form: {
-            handler: this.updateForm,
-            submitOnChange: true,
-            closeOnSubmit: false
-        }
-    };
-
-    /** @override */
-    static PARTS = {
-        costSelection: {
-            id: 'costSelection',
-            template: 'systems/daggerheart/templates/dialogs/dice-roll/costSelection.hbs'
-        }
-    };
-
-    /* -------------------------------------------- */
-
-    /** @inheritDoc */
-    get title() {
-        return `Cost Options`;
-    }
-
-    async _prepareContext(_options) {
-        const updatedCosts = this.action.calcCosts(this.costs),
-            updatedUses = this.action.calcUses(this.uses);
-        return {
-            costs: updatedCosts,
-            uses: updatedUses,
-            canUse: this.action.hasCost(updatedCosts) && this.action.hasUses(updatedUses)
-        };
-    }
-
-    static async updateForm(event, _, formData) {
-        const data = foundry.utils.expandObject(formData.object);
-        this.costs = foundry.utils.mergeObject(this.costs, data.costs);
-        this.uses = foundry.utils.mergeObject(this.uses, data.uses);
-        this.render(true);
-    }
-
-    static sendCost(event) {
-        event.preventDefault();
-        this.resolve({ costs: this.action.getRealCosts(this.costs), uses: this.uses });
-        this.close();
-    }
-}

module/applications/dialogs/d20RollDialog.mjs

@@ -22,7 +22,7 @@ export default class D20RollDialog extends HandlebarsApplicationMixin(Applicatio
         id: 'roll-selection',
         classes: ['daggerheart', 'dialog', 'dh-style', 'views', 'roll-selection'],
         position: {
-            width: 550
+            width: 'auto'
         },
         window: {
             icon: 'fa-solid fa-dice'
@@ -52,10 +52,6 @@ export default class D20RollDialog extends HandlebarsApplicationMixin(Applicatio
         rollSelection: {
             id: 'rollSelection',
             template: 'systems/daggerheart/templates/dialogs/dice-roll/rollSelection.hbs'
-        },
-        costSelection: {
-            id: 'costSelection',
-            template: 'systems/daggerheart/templates/dialogs/dice-roll/costSelection.hbs'
         }
     };
 
@@ -63,9 +59,22 @@ export default class D20RollDialog extends HandlebarsApplicationMixin(Applicatio
         const context = await super._prepareContext(_options);
         context.rollConfig = this.config;
         context.hasRoll = !!this.config.roll;
+        context.canRoll = true;
+        context.selectedRollMode = this.config.selectedRollMode;
+        context.rollModes = Object.entries(CONFIG.Dice.rollModes).map(([action, { label, icon }]) => ({
+            action,
+            label,
+            icon
+        }));
+
         if (this.config.costs?.length) {
             const updatedCosts = this.action.calcCosts(this.config.costs);
-            context.costs = updatedCosts;
+            context.costs = updatedCosts.map(x => ({
+                ...x,
+                label: x.keyIsID
+                    ? this.action.parent.parent.name
+                    : game.i18n.localize(CONFIG.DH.GENERAL.abilityCosts[x.key].label)
+            }));
             context.canRoll = this.action.hasCost(updatedCosts);
             this.config.data.scale = this.config.costs[0].total;
         }
@@ -73,9 +82,10 @@ export default class D20RollDialog extends HandlebarsApplicationMixin(Applicatio
             context.uses = this.action.calcUses(this.config.uses);
             context.canRoll = context.canRoll && this.action.hasUses(context.uses);
         }
-        if(this.roll) {
+        if (this.roll) {
             context.roll = this.roll;
             context.rollType = this.roll?.constructor.name;
+            context.rallyDie = this.roll.rallyChoices;
             context.experiences = Object.keys(this.config.data.experiences).map(id => ({
                 id,
                 ...this.config.data.experiences[id]
@@ -84,7 +94,6 @@ export default class D20RollDialog extends HandlebarsApplicationMixin(Applicatio
             context.advantage = this.config.roll?.advantage;
             context.disadvantage = this.config.roll?.disadvantage;
             context.diceOptions = CONFIG.DH.GENERAL.diceTypes;
-            context.canRoll = true;
             context.isLite = this.config.roll?.lite;
             context.extraFormula = this.config.extraFormula;
             context.formula = this.roll.constructFormula(this.config);
@@ -94,6 +103,8 @@ export default class D20RollDialog extends HandlebarsApplicationMixin(Applicatio
 
     static updateRollConfiguration(event, _, formData) {
         const { ...rest } = foundry.utils.expandObject(formData.object);
+        this.config.selectedRollMode = rest.selectedRollMode;
+
         if (this.config.costs) {
             this.config.costs = foundry.utils.mergeObject(this.config.costs, rest.costs);
         }
@@ -117,11 +128,6 @@ export default class D20RollDialog extends HandlebarsApplicationMixin(Applicatio
     }
 
     static selectExperience(_, button) {
-        /* if (this.config.experiences.find(x => x === button.dataset.key)) {
-            this.config.experiences = this.config.experiences.filter(x => x !== button.dataset.key);
-        } else {
-            this.config.experiences = [...this.config.experiences, button.dataset.key];
-        } */
         this.config.experiences =
             this.config.experiences.indexOf(button.dataset.key) > -1
                 ? this.config.experiences.filter(x => x !== button.dataset.key)

module/applications/dialogs/damageDialog.mjs

@@ -11,11 +11,14 @@ export default class DamageDialog extends HandlebarsApplicationMixin(Application
     static DEFAULT_OPTIONS = {
         tag: 'form',
         id: 'roll-selection',
-        classes: ['daggerheart', 'views', 'damage-selection'],
+        classes: ['daggerheart', 'dialog', 'dh-style', 'views', 'damage-selection'],
         position: {
             width: 400,
             height: 'auto'
         },
+        window: {
+            icon: 'fa-solid fa-dice'
+        },
         actions: {
             submitRoll: this.submitRoll
         },
@@ -34,17 +37,33 @@ export default class DamageDialog extends HandlebarsApplicationMixin(Application
         }
     };
 
+    get title() {
+        return game.i18n.localize('DAGGERHEART.EFFECTS.ApplyLocations.damageRoll.name');
+    }
+
     async _prepareContext(_options) {
         const context = await super._prepareContext(_options);
-        context.title = this.config.title;
-        context.extraFormula = this.config.extraFormula;
+        context.config = CONFIG.DH;
+        context.title = this.config.title
+            ? this.config.title
+            : game.i18n.localize('DAGGERHEART.EFFECTS.ApplyLocations.damageRoll.name');
+        // context.extraFormula = this.config.extraFormula;
         context.formula = this.roll.constructFormula(this.config);
+        context.directDamage = this.config.directDamage;
+        context.selectedRollMode = this.config.selectedRollMode;
+        context.rollModes = Object.entries(CONFIG.Dice.rollModes).map(([action, { label, icon }]) => ({
+            action,
+            label,
+            icon
+        }));
         return context;
     }
 
-    static updateRollConfiguration(event, _, formData) {
+    static updateRollConfiguration(_event, _, formData) {
         const { ...rest } = foundry.utils.expandObject(formData.object);
-        this.config.extraFormula = rest.extraFormula;
+        foundry.utils.mergeObject(this.config.roll, rest.roll);
+        this.config.selectedRollMode = rest.selectedRollMode;
+
         this.render();
     }
 

module/applications/dialogs/damageReductionDialog.mjs

@@ -1,9 +1,9 @@
 import { damageKeyToNumber, getDamageLabel } from '../../helpers/utils.mjs';
 
-const { ApplicationV2, HandlebarsApplicationMixin } = foundry.applications.api;
+const { DialogV2, ApplicationV2, HandlebarsApplicationMixin } = foundry.applications.api;
 
 export default class DamageReductionDialog extends HandlebarsApplicationMixin(ApplicationV2) {
-    constructor(resolve, reject, actor, damage) {
+    constructor(resolve, reject, actor, damage, damageType) {
         super({});
 
         this.resolve = resolve;
@@ -11,37 +11,46 @@ export default class DamageReductionDialog extends HandlebarsApplicationMixin(Ap
         this.actor = actor;
         this.damage = damage;
 
-        const maxArmorMarks = Math.min(
-            actor.system.armorScore - actor.system.armor.system.marks.value,
-            actor.system.rules.maxArmorMarked.total
-        );
+        const canApplyArmor = damageType.every(t => actor.system.armorApplicableDamageTypes[t] === true);
+        const maxArmorMarks = canApplyArmor
+            ? Math.min(
+                  actor.system.armorScore - actor.system.armor.system.marks.value,
+                  actor.system.rules.damageReduction.maxArmorMarked.value
+              )
+            : 0;
 
         const armor = [...Array(maxArmorMarks).keys()].reduce((acc, _) => {
             acc[foundry.utils.randomID()] = { selected: false };
             return acc;
         }, {});
-        const stress = [...Array(actor.system.rules.maxArmorMarked.stressExtra ?? 0).keys()].reduce((acc, _) => {
-            acc[foundry.utils.randomID()] = { selected: false };
-            return acc;
-        }, {});
+        const stress = [...Array(actor.system.rules.damageReduction.maxArmorMarked.stressExtra ?? 0).keys()].reduce(
+            (acc, _) => {
+                acc[foundry.utils.randomID()] = { selected: false };
+                return acc;
+            },
+            {}
+        );
         this.marks = { armor, stress };
 
-        this.availableStressReductions = Object.keys(actor.system.rules.stressDamageReduction).reduce((acc, key) => {
-            const dr = actor.system.rules.stressDamageReduction[key];
-            if (dr.enabled) {
-                if (acc === null) acc = {};
+        this.availableStressReductions = Object.keys(actor.system.rules.damageReduction.stressDamageReduction).reduce(
+            (acc, key) => {
+                const dr = actor.system.rules.damageReduction.stressDamageReduction[key];
+                if (dr.enabled) {
+                    if (acc === null) acc = {};
 
-                const damage = damageKeyToNumber(key);
-                acc[damage] = {
-                    cost: dr.cost,
-                    selected: false,
-                    from: getDamageLabel(damage),
-                    to: getDamageLabel(damage - 1)
-                };
-            }
+                    const damage = damageKeyToNumber(key);
+                    acc[damage] = {
+                        cost: dr.cost,
+                        selected: false,
+                        from: getDamageLabel(damage),
+                        to: getDamageLabel(damage - 1)
+                    };
+                }
 
-            return acc;
-        }, null);
+                return acc;
+            },
+            null
+        );
     }
 
     get title() {
@@ -90,7 +99,8 @@ export default class DamageReductionDialog extends HandlebarsApplicationMixin(Ap
 
         context.armorScore = this.actor.system.armorScore;
         context.armorMarks = currentMarks;
-        context.basicMarksUsed = selectedArmorMarks.length === this.actor.system.rules.maxArmorMarked.total;
+        context.basicMarksUsed =
+            selectedArmorMarks.length === this.actor.system.rules.damageReduction.maxArmorMarked.value;
 
         const stressReductionStress = this.availableStressReductions
             ? stressReductions.reduce((acc, red) => acc + red.cost, 0)
@@ -100,7 +110,7 @@ export default class DamageReductionDialog extends HandlebarsApplicationMixin(Ap
                 ? {
                       value:
                           this.actor.system.resources.stress.value + selectedStressMarks.length + stressReductionStress,
-                      maxTotal: this.actor.system.resources.stress.maxTotal
+                      max: this.actor.system.resources.stress.max
                   }
                 : null;
 
@@ -122,12 +132,15 @@ export default class DamageReductionDialog extends HandlebarsApplicationMixin(Ap
     getDamageInfo = () => {
         const selectedArmorMarks = Object.values(this.marks.armor).filter(x => x.selected);
         const selectedStressMarks = Object.values(this.marks.stress).filter(x => x.selected);
-        const stressReductions = Object.values(this.availableStressReductions).filter(red => red.selected);
+        const stressReductions = this.availableStressReductions
+            ? Object.values(this.availableStressReductions).filter(red => red.selected)
+            : [];
         const currentMarks =
             this.actor.system.armor.system.marks.value + selectedArmorMarks.length + selectedStressMarks.length;
 
-        const currentDamage =
-            this.damage - selectedArmorMarks.length - selectedStressMarks.length - stressReductions.length;
+        const armorMarkReduction =
+            selectedArmorMarks.length * this.actor.system.rules.damageReduction.increasePerArmorMark;
+        const currentDamage = this.damage - armorMarkReduction - selectedStressMarks.length - stressReductions.length;
 
         return { selectedArmorMarks, selectedStressMarks, stressReductions, currentMarks, currentDamage };
     };
@@ -184,7 +197,7 @@ export default class DamageReductionDialog extends HandlebarsApplicationMixin(Ap
                 : 0;
             const currentStress =
                 this.actor.system.resources.stress.value + selectedStressMarks.length + stressReductionStress;
-            if (currentStress + stressReduction.cost > this.actor.system.resources.stress.maxTotal) {
+            if (currentStress + stressReduction.cost > this.actor.system.resources.stress.max) {
                 ui.notifications.info(game.i18n.localize('DAGGERHEART.UI.Notifications.notEnoughStress'));
                 return;
             }
@@ -210,9 +223,17 @@ export default class DamageReductionDialog extends HandlebarsApplicationMixin(Ap
 
     async close(fromSave) {
         if (!fromSave) {
-            this.reject();
+            this.resolve();
         }
 
         await super.close({});
     }
+
+    static async armorStackQuery({ actorId, damage, type }) {
+        return new Promise(async (resolve, reject) => {
+            const actor = await fromUuid(actorId);
+            if (!actor || !actor?.isOwner) reject();
+            new DamageReductionDialog(resolve, reject, actor, damage, type).render({ force: true });
+        });
+    }
 }

module/applications/dialogs/damageSelectionDialog.mjs

@@ -23,7 +23,7 @@ export default class DamageSelectionDialog extends HandlebarsApplicationMixin(Ap
 
     static DEFAULT_OPTIONS = {
         tag: 'form',
-        classes: ['daggerheart', 'views', 'damage-selection'],
+        classes: ['daggerheart', 'dialog', 'dh-style', 'views', 'damage-selection'],
         position: {
             width: 400,
             height: 'auto'

module/applications/dialogs/downtime.mjs

@@ -7,8 +7,23 @@ export default class DhpDowntime extends HandlebarsApplicationMixin(ApplicationV
         this.actor = actor;
         this.shortrest = shortrest;
 
-        const options = game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Homebrew).restMoves;
-        this.moveData = shortrest ? options.shortRest : options.longRest;
+        this.moveData = foundry.utils.deepClone(
+            game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Homebrew).restMoves
+        );
+        this.nrChoices = {
+            shortRest: {
+                taken: 0,
+                max:
+                    (shortrest ? this.moveData.shortRest.nrChoices : 0) +
+                    actor.system.bonuses.rest[`${shortrest ? 'short' : 'long'}Rest`].shortMoves
+            },
+            longRest: {
+                taken: 0,
+                max:
+                    (!shortrest ? this.moveData.longRest.nrChoices : 0) +
+                    actor.system.bonuses.rest[`${shortrest ? 'short' : 'long'}Rest`].longMoves
+            }
+        };
     }
 
     get title() {
@@ -17,8 +32,8 @@ export default class DhpDowntime extends HandlebarsApplicationMixin(ApplicationV
 
     static DEFAULT_OPTIONS = {
         tag: 'form',
-        classes: ['daggerheart', 'views', 'downtime'],
-        position: { width: 680, height: 'auto' },
+        classes: ['daggerheart', 'views', 'dh-style', 'dialog', 'downtime'],
+        position: { width: 'auto', height: 'auto' },
         actions: {
             selectMove: this.selectMove,
             takeDowntime: this.takeDowntime
@@ -29,7 +44,7 @@ export default class DhpDowntime extends HandlebarsApplicationMixin(ApplicationV
     static PARTS = {
         application: {
             id: 'downtime',
-            template: 'systems/daggerheart/templates/dialogs/downtime.hbs'
+            template: 'systems/daggerheart/templates/dialogs/downtime/downtime.hbs'
         }
     };
 
@@ -37,46 +52,85 @@ export default class DhpDowntime extends HandlebarsApplicationMixin(ApplicationV
         super._attachPartListeners(partId, htmlElement, options);
 
         htmlElement
-            .querySelectorAll('.activity-image')
+            .querySelectorAll('.activity-container')
             .forEach(element => element.addEventListener('contextmenu', this.deselectMove.bind(this)));
     }
 
     async _prepareContext(_options) {
         const context = await super._prepareContext(_options);
+        context.title = game.i18n.localize(
+            `DAGGERHEART.APPLICATIONS.Downtime.${this.shortrest ? 'shortRest' : 'longRest'}.title`
+        );
         context.selectedActivity = this.selectedActivity;
         context.moveData = this.moveData;
-        context.nrCurrentChoices = Object.values(this.moveData.moves).reduce((acc, x) => acc + (x.selected ?? 0), 0);
-        context.disabledDowntime = context.nrCurrentChoices < context.moveData.nrChoices;
+
+        const shortRestMovesSelected = this.#nrSelectedMoves('shortRest');
+        const longRestMovesSelected = this.#nrSelectedMoves('longRest');
+        context.nrChoices = {
+            ...this.nrChoices,
+            shortRest: {
+                ...this.nrChoices.shortRest,
+                current: this.nrChoices.shortRest.taken + shortRestMovesSelected
+            },
+            longRest: {
+                ...this.nrChoices.longRest,
+                current: this.nrChoices.longRest.taken + longRestMovesSelected
+            }
+        };
+
+        context.shortRestMoves = this.nrChoices.shortRest.max > 0 ? this.moveData.shortRest : null;
+        context.longRestMoves = this.nrChoices.longRest.max > 0 ? this.moveData.longRest : null;
+
+        context.disabledDowntime = shortRestMovesSelected === 0 && longRestMovesSelected === 0;
 
         return context;
     }
 
-    static selectMove(_, button) {
-        const nrSelected = Object.values(this.moveData.moves).reduce((acc, x) => acc + (x.selected ?? 0), 0);
-        if (nrSelected === this.moveData.nrChoices) {
+    static selectMove(_, target) {
+        const { category, move } = target.dataset;
+
+        const nrSelected = this.#nrSelectedMoves(category);
+
+        if (nrSelected + this.nrChoices[category].taken >= this.nrChoices[category].max) {
             ui.notifications.error(game.i18n.localize('DAGGERHEART.UI.Notifications.noMoreMoves'));
             return;
         }
 
-        const move = button.dataset.move;
-        this.moveData.moves[move].selected = this.moveData.moves[move].selected
-            ? this.moveData.moves[move].selected + 1
+        this.moveData[category].moves[move].selected = this.moveData[category].moves[move].selected
+            ? this.moveData[category].moves[move].selected + 1
             : 1;
 
         this.render();
     }
 
     deselectMove(event) {
-        const move = event.currentTarget.dataset.move;
-        this.moveData.moves[move].selected = this.moveData.moves[move].selected
-            ? this.moveData.moves[move].selected - 1
+        const button = event.target.closest('.activity-container');
+        const { move, category } = button.dataset;
+        this.moveData[category].moves[move].selected = this.moveData[category].moves[move].selected
+            ? this.moveData[category].moves[move].selected - 1
             : 0;
 
         this.render();
+
+        // On macOS with a single-button mouse (e.g. a laptop trackpad),
+        // right-click is triggered with ctrl+click, which triggers both a
+        // `contextmenu` event and a regular click event. We need to stop
+        // event propagation to prevent the click event from triggering the
+        // `selectMove` function and undoing the change we just made.
+        event.stopPropagation();
+
+        // Having stopped propagation, we're no longer subject to Foundry's
+        // default `contextmenu` handler, so we also have to prevent the
+        // default behaviour to prevent a context menu from appearing.
+        event.preventDefault();
     }
 
     static async takeDowntime() {
-        const moves = Object.values(this.moveData.moves).filter(x => x.selected);
+        const moves = Object.values(this.moveData).flatMap(category => {
+            return Object.values(category.moves)
+                .filter(x => x.selected)
+                .flatMap(move => [...Array(move.selected).keys()].map(_ => move));
+        });
 
         const cls = getDocumentClass('ChatMessage');
         const msg = new cls({
@@ -88,7 +142,7 @@ export default class DhpDowntime extends HandlebarsApplicationMixin(ApplicationV
             content: await foundry.applications.handlebars.renderTemplate(
                 'systems/daggerheart/templates/ui/chat/downtime.hbs',
                 {
-                    title: `${this.actor.name} - ${game.i18n.localize(`DAGGERHEART.APPLICATIONS.Downtime.${this.shortRest ? 'shortRest' : 'longRest'}.title`)}`,
+                    title: `${this.actor.name} - ${game.i18n.localize(`DAGGERHEART.APPLICATIONS.Downtime.${this.shortrest ? 'shortRest' : 'longRest'}.title`)}`,
                     moves: moves
                 }
             )
@@ -96,11 +150,33 @@ export default class DhpDowntime extends HandlebarsApplicationMixin(ApplicationV
 
         cls.create(msg.toObject());
 
-        this.close();
+        // Reset selection and update number of taken moves
+        for (const [catName, category] of Object.entries(this.moveData)) {
+            for (const move of Object.values(category.moves)) {
+                if (move.selected > 0) {
+                    this.nrChoices[catName].taken += move.selected;
+                    move.selected = 0;
+                }
+            }
+        }
+
+        // We can close the window when all moves are taken
+        if (
+            this.nrChoices.shortRest.taken >= this.nrChoices.shortRest.max &&
+            this.nrChoices.longRest.taken >= this.nrChoices.longRest.max
+        ) {
+            this.close();
+        } else {
+            this.render();
+        }
     }
 
     static async updateData(event, element, formData) {
         this.customActivity = foundry.utils.mergeObject(this.customActivity, formData.object);
         this.render();
     }
+
+    #nrSelectedMoves(category) {
+        return Object.values(this.moveData[category].moves).reduce((acc, x) => acc + (x.selected ?? 0), 0);
+    }
 }

module/applications/dialogs/resourceDiceDialog.mjs

@@ -0,0 +1,99 @@
+import { itemAbleRollParse } from '../../helpers/utils.mjs';
+
+const { ApplicationV2, HandlebarsApplicationMixin } = foundry.applications.api;
+
+export default class ResourceDiceDialog extends HandlebarsApplicationMixin(ApplicationV2) {
+    constructor(item, actor, options = {}) {
+        super(options);
+
+        this.item = item;
+        this.actor = actor;
+        this.diceStates = foundry.utils.deepClone(item.system.resource.diceStates);
+    }
+
+    static DEFAULT_OPTIONS = {
+        tag: 'form',
+        classes: ['daggerheart', 'dialog', 'dh-style', 'views', 'resource-dice'],
+        window: {
+            icon: 'fa-solid fa-dice'
+        },
+        actions: {
+            rerollDice: this.rerollDice,
+            save: this.save
+        },
+        form: {
+            handler: this.updateResourceDice,
+            submitOnChange: true,
+            submitOnClose: false
+        }
+    };
+
+    /** @override */
+    static PARTS = {
+        resourceDice: {
+            id: 'resourceDice',
+            template: 'systems/daggerheart/templates/dialogs/dice-roll/resourceDice.hbs'
+        }
+    };
+
+    get title() {
+        return game.i18n.format('DAGGERHEART.APPLICATIONS.ResourceDice.title', { name: this.item.name });
+    }
+
+    async _prepareContext(_options) {
+        const context = await super._prepareContext(_options);
+        context.item = this.item;
+        context.actor = this.actor;
+        context.diceStates = this.diceStates;
+
+        return context;
+    }
+
+    static async updateResourceDice(event, _, formData) {
+        const { diceStates } = foundry.utils.expandObject(formData.object);
+        this.diceStates = Object.keys(diceStates).reduce((acc, key) => {
+            const resourceState = this.item.system.resource.diceStates[key];
+            acc[key] = { ...diceStates[key], used: Boolean(resourceState?.used) };
+            return acc;
+        }, {});
+
+        this.render();
+    }
+
+    static async save() {
+        this.rollValues = Object.values(this.diceStates);
+        this.close();
+    }
+
+    static async rerollDice() {
+        const max = itemAbleRollParse(this.item.system.resource.max, this.actor, this.item);
+        const diceFormula = `${max}${this.item.system.resource.dieFaces}`;
+        const roll = await new Roll(diceFormula).evaluate();
+        if (game.modules.get('dice-so-nice')?.active) await game.dice3d.showForRoll(roll, game.user, true);
+        this.rollValues = roll.terms[0].results.map(x => ({ value: x.result, used: false }));
+        this.resetUsed = true;
+
+        const cls = getDocumentClass('ChatMessage');
+        const msg = new cls({
+            user: game.user.id,
+            content: await foundry.applications.handlebars.renderTemplate(
+                'systems/daggerheart/templates/ui/chat/resource-roll.hbs',
+                {
+                    user: this.actor.name,
+                    name: this.item.name
+                }
+            )
+        });
+
+        cls.create(msg.toObject());
+        this.close();
+    }
+
+    static async create(item, actor, options = {}) {
+        return new Promise(resolve => {
+            const app = new this(item, actor, options);
+            app.addEventListener('close', () => resolve(app.rollValues), { once: true });
+            app.render({ force: true });
+        });
+    }
+}

module/applications/hud/_module.mjs

@@ -0,0 +1 @@
+export { default as DHTokenHUD } from './tokenHUD.mjs';

module/applications/hud/tokenHUD.mjs

@@ -0,0 +1,84 @@
+export default class DHTokenHUD extends foundry.applications.hud.TokenHUD {
+    static DEFAULT_OPTIONS = {
+        classes: ['daggerheart']
+    };
+
+    /** @override */
+    static PARTS = {
+        hud: {
+            root: true,
+            template: 'systems/daggerheart/templates/hud/tokenHUD.hbs'
+        }
+    };
+
+    async _prepareContext(options) {
+        const context = await super._prepareContext(options);
+        context.systemStatusEffects = Object.keys(context.statusEffects).reduce((acc, key) => {
+            const effect = context.statusEffects[key];
+            if (effect.systemEffect) acc[key] = effect;
+
+            return acc;
+        }, {});
+
+        const useGeneric = game.settings.get(
+            CONFIG.DH.id,
+            CONFIG.DH.SETTINGS.gameSettings.appearance
+        ).showGenericStatusEffects;
+        context.genericStatusEffects = useGeneric
+            ? Object.keys(context.statusEffects).reduce((acc, key) => {
+                  const effect = context.statusEffects[key];
+                  if (!effect.systemEffect) acc[key] = effect;
+
+                  return acc;
+              }, {})
+            : null;
+
+        return context;
+    }
+
+    _getStatusEffectChoices() {
+        // Include all HUD-enabled status effects
+        const choices = {};
+        for (const status of CONFIG.statusEffects) {
+            if (
+                status.hud === false ||
+                (foundry.utils.getType(status.hud) === 'Object' &&
+                    status.hud.actorTypes?.includes(this.document.actor.type) === false)
+            ) {
+                continue;
+            }
+            choices[status.id] = {
+                _id: status._id,
+                id: status.id,
+                systemEffect: status.systemEffect,
+                title: game.i18n.localize(status.name ?? /** @deprecated since v12 */ status.label),
+                src: status.img ?? /** @deprecated since v12 */ status.icon,
+                isActive: false,
+                isOverlay: false
+            };
+        }
+
+        // Update the status of effects which are active for the token actor
+        const activeEffects = this.actor?.effects || [];
+        for (const effect of activeEffects) {
+            for (const statusId of effect.statuses) {
+                const status = choices[statusId];
+                if (!status) continue;
+                if (status._id) {
+                    if (status._id !== effect.id) continue;
+                } else {
+                    if (effect.statuses.size !== 1) continue;
+                }
+                status.isActive = true;
+                if (effect.getFlag('core', 'overlay')) status.isOverlay = true;
+                break;
+            }
+        }
+
+        // Flag status CSS class
+        for (const status of Object.values(choices)) {
+            status.cssClass = [status.isActive ? 'active' : null, status.isOverlay ? 'overlay' : null].filterJoin(' ');
+        }
+        return choices;
+    }
+}

module/applications/levelup/characterLevelup.mjs

@@ -223,8 +223,8 @@ export default class DhCharacterLevelUp extends LevelUpBase {
 
                 context.achievements = {
                     proficiency: {
-                        old: this.actor.system.proficiency.total,
-                        new: this.actor.system.proficiency.total + achivementProficiency,
+                        old: this.actor.system.proficiency,
+                        new: this.actor.system.proficiency + achivementProficiency,
                         shown: achivementProficiency > 0
                     },
                     damageThresholds: {
@@ -332,16 +332,16 @@ export default class DhCharacterLevelUp extends LevelUpBase {
                             new: context.achievements.proficiency.new + (advancement.proficiency ?? 0)
                         },
                         hitPoints: {
-                            old: this.actor.system.resources.hitPoints.maxTotal,
-                            new: this.actor.system.resources.hitPoints.maxTotal + (advancement.hitPoint ?? 0)
+                            old: this.actor.system.resources.hitPoints.max,
+                            new: this.actor.system.resources.hitPoints.max + (advancement.hitPoint ?? 0)
                         },
                         stress: {
-                            old: this.actor.system.resources.stress.maxTotal,
-                            new: this.actor.system.resources.stress.maxTotal + (advancement.stress ?? 0)
+                            old: this.actor.system.resources.stress.max,
+                            new: this.actor.system.resources.stress.max + (advancement.stress ?? 0)
                         },
                         evasion: {
-                            old: this.actor.system.evasion.total,
-                            new: this.actor.system.evasion.total + (advancement.evasion ?? 0)
+                            old: this.actor.system.evasion,
+                            new: this.actor.system.evasion + (advancement.evasion ?? 0)
                         }
                     },
                     traits: Object.keys(this.actor.system.traits).reduce((acc, traitKey) => {
@@ -349,8 +349,8 @@ export default class DhCharacterLevelUp extends LevelUpBase {
                             if (!acc) acc = {};
                             acc[traitKey] = {
                                 label: game.i18n.localize(abilities[traitKey].label),
-                                old: this.actor.system.traits[traitKey].total,
-                                new: this.actor.system.traits[traitKey].total + advancement.trait[traitKey]
+                                old: this.actor.system.traits[traitKey].max,
+                                new: this.actor.system.traits[traitKey].max + advancement.trait[traitKey]
                             };
                         }
                         return acc;

module/applications/levelup/companionLevelup.mjs

@@ -122,12 +122,12 @@ export default class DhCompanionLevelUp extends BaseLevelUp {
                 context.advancements = {
                     statistics: {
                         stress: {
-                            old: this.actor.system.resources.stress.maxTotal,
-                            new: this.actor.system.resources.stress.maxTotal + (advancement.stress ?? 0)
+                            old: this.actor.system.resources.stress.max,
+                            new: this.actor.system.resources.stress.max + (advancement.stress ?? 0)
                         },
                         evasion: {
-                            old: this.actor.system.evasion.total,
-                            new: this.actor.system.evasion.total + (advancement.evasion ?? 0)
+                            old: this.actor.system.evasion,
+                            new: this.actor.system.evasion + (advancement.evasion ?? 0)
                         }
                     },
                     experiences:

module/applications/levelup/levelup.mjs

@@ -128,7 +128,7 @@ export default class DhlevelUp extends HandlebarsApplicationMixin(ApplicationV2)
                 context.tabs.advancements.progress = { selected: selections, max: currentLevel.maxSelections };
                 context.showTabs = this.tabGroups.primary !== 'summary';
                 break;
-                const { current: currentActorLevel, changed: changedActorLevel } = this.actor.system.levelData.level;
+
                 const actorArmor = this.actor.system.armor;
                 const levelKeys = Object.keys(this.levelup.levels);
                 let achivementProficiency = 0;
@@ -157,8 +157,8 @@ export default class DhlevelUp extends HandlebarsApplicationMixin(ApplicationV2)
 
                 context.achievements = {
                     proficiency: {
-                        old: this.actor.system.proficiency.total,
-                        new: this.actor.system.proficiency.total + achivementProficiency,
+                        old: this.actor.system.proficiency,
+                        new: this.actor.system.proficiency + achivementProficiency,
                         shown: achivementProficiency > 0
                     },
                     damageThresholds: {
@@ -265,16 +265,16 @@ export default class DhlevelUp extends HandlebarsApplicationMixin(ApplicationV2)
                             new: context.achievements.proficiency.new + (advancement.proficiency ?? 0)
                         },
                         hitPoints: {
-                            old: this.actor.system.resources.hitPoints.maxTotal,
-                            new: this.actor.system.resources.hitPoints.maxTotal + (advancement.hitPoint ?? 0)
+                            old: this.actor.system.resources.hitPoints.max,
+                            new: this.actor.system.resources.hitPoints.max + (advancement.hitPoint ?? 0)
                         },
                         stress: {
-                            old: this.actor.system.resources.stress.maxTotal,
-                            new: this.actor.system.resources.stress.maxTotal + (advancement.stress ?? 0)
+                            old: this.actor.system.resources.stress.max,
+                            new: this.actor.system.resources.stress.max + (advancement.stress ?? 0)
                         },
                         evasion: {
-                            old: this.actor.system.evasion.total,
-                            new: this.actor.system.evasion.total + (advancement.evasion ?? 0)
+                            old: this.actor.system.evasion,
+                            new: this.actor.system.evasion + (advancement.evasion ?? 0)
                         }
                     },
                     traits: Object.keys(this.actor.system.traits).reduce((acc, traitKey) => {
@@ -282,8 +282,8 @@ export default class DhlevelUp extends HandlebarsApplicationMixin(ApplicationV2)
                             if (!acc) acc = {};
                             acc[traitKey] = {
                                 label: game.i18n.localize(abilities[traitKey].label),
-                                old: this.actor.system.traits[traitKey].total,
-                                new: this.actor.system.traits[traitKey].total + advancement.trait[traitKey]
+                                old: this.actor.system.traits[traitKey].value,
+                                new: this.actor.system.traits[traitKey].value + advancement.trait[traitKey]
                             };
                         }
                         return acc;

module/applications/settings/appearanceSettings.mjs

@@ -12,14 +12,17 @@ export default class DHAppearanceSettings extends HandlebarsApplicationMixin(App
     }
 
     get title() {
-        return game.i18n.localize('DAGGERHEART.SETTINGS.Menu.appearance.name');
+        return game.i18n.localize('DAGGERHEART.SETTINGS.Menu.title');
     }
 
     static DEFAULT_OPTIONS = {
         tag: 'form',
         id: 'daggerheart-appearance-settings',
-        classes: ['daggerheart', 'setting', 'dh-style'],
+        classes: ['daggerheart', 'dialog', 'dh-style', 'setting'],
         position: { width: '600', height: 'auto' },
+        window: {
+            icon: 'fa-solid fa-gears'
+        },
         actions: {
             reset: this.reset,
             save: this.save

module/applications/settings/automationSettings.mjs

@@ -12,14 +12,17 @@ export default class DhAutomationSettings extends HandlebarsApplicationMixin(App
     }
 
     get title() {
-        return game.i18n.localize('DAGGERHEART.SETTINGS.Menu.automation.name');
+        return game.i18n.localize('DAGGERHEART.SETTINGS.Menu.title');
     }
 
     static DEFAULT_OPTIONS = {
         tag: 'form',
         id: 'daggerheart-automation-settings',
-        classes: ['daggerheart', 'setting', 'dh-style'],
+        classes: ['daggerheart', 'dh-style', 'dialog', 'setting'],
         position: { width: '600', height: 'auto' },
+        window: {
+            icon: 'fa-solid fa-gears'
+        },
         actions: {
             reset: this.reset,
             save: this.save

module/applications/settings/components/settingsActionsView.mjs

@@ -4,13 +4,14 @@ import DHActionConfig from '../../sheets-configs/action-config.mjs';
 const { HandlebarsApplicationMixin, ApplicationV2 } = foundry.applications.api;
 
 export default class DhSettingsActionView extends HandlebarsApplicationMixin(ApplicationV2) {
-    constructor(resolve, reject, title, name, img, description, actions) {
+    constructor(resolve, reject, title, name, icon, img, description, actions) {
         super({});
 
         this.resolve = resolve;
         this.reject = reject;
         this.viewTitle = title;
         this.name = name;
+        this.icon = icon;
         this.img = img;
         this.description = description;
         this.actions = actions;
@@ -23,7 +24,7 @@ export default class DhSettingsActionView extends HandlebarsApplicationMixin(App
     static DEFAULT_OPTIONS = {
         tag: 'form',
         classes: ['daggerheart', 'setting', 'dh-style'],
-        position: { width: '400', height: 'auto' },
+        position: { width: 440, height: 'auto' },
         actions: {
             editImage: this.onEditImage,
             addItem: this.addItem,
@@ -46,6 +47,7 @@ export default class DhSettingsActionView extends HandlebarsApplicationMixin(App
     async _prepareContext(_options) {
         const context = await super._prepareContext(_options);
         context.name = this.name;
+        context.icon = this.icon;
         context.img = this.img;
         context.description = this.description;
         context.enrichedDescription = await foundry.applications.ux.TextEditor.enrichHTML(context.description);
@@ -55,8 +57,9 @@ export default class DhSettingsActionView extends HandlebarsApplicationMixin(App
     }
 
     static async updateData(event, element, formData) {
-        const { name, img, description } = foundry.utils.expandObject(formData.object);
+        const { name, icon, description } = foundry.utils.expandObject(formData.object);
         this.name = name;
+        this.icon = icon;
         this.description = description;
 
         this.render();
@@ -65,6 +68,7 @@ export default class DhSettingsActionView extends HandlebarsApplicationMixin(App
     static async saveForm(event) {
         this.resolve({
             name: this.name,
+            icon: this.icon,
             img: this.img,
             description: this.description,
             actions: this.actions

module/applications/settings/homebrewSettings.mjs

@@ -13,14 +13,17 @@ export default class DhHomebrewSettings extends HandlebarsApplicationMixin(Appli
     }
 
     get title() {
-        return game.i18n.localize('DAGGERHEART.SETTINGS.Menu.homebrew.name');
+        return game.i18n.localize('DAGGERHEART.SETTINGS.Menu.title');
     }
 
     static DEFAULT_OPTIONS = {
         tag: 'form',
         id: 'daggerheart-homebrew-settings',
-        classes: ['daggerheart', 'setting', 'dh-style'],
+        classes: ['daggerheart', 'dh-style', 'dialog', 'setting'],
         position: { width: '600', height: 'auto' },
+        window: {
+            icon: 'fa-solid fa-gears'
+        },
         actions: {
             addItem: this.addItem,
             editItem: this.editItem,
@@ -76,6 +79,7 @@ export default class DhHomebrewSettings extends HandlebarsApplicationMixin(Appli
                 reject,
                 game.i18n.localize('DAGGERHEART.SETTINGS.Homebrew.downtimeMoves'),
                 move.name,
+                move.icon,
                 move.img,
                 move.description,
                 move.actions
@@ -87,6 +91,7 @@ export default class DhHomebrewSettings extends HandlebarsApplicationMixin(Appli
         await this.settings.updateSource({
             [`restMoves.${type}.moves.${id}`]: {
                 name: data.name,
+                icon: data.icon,
                 img: data.img,
                 description: data.description
             }

module/applications/settings/rangeMeasurementSettings.mjs

@@ -12,14 +12,17 @@ export default class DhRangeMeasurementSettings extends HandlebarsApplicationMix
     }
 
     get title() {
-        return game.i18n.localize('DAGGERHEART.SETTINGS.Menu.automation.name');
+        return game.i18n.localize('DAGGERHEART.SETTINGS.Menu.title');
     }
 
     static DEFAULT_OPTIONS = {
         tag: 'form',
         id: 'daggerheart-automation-settings',
-        classes: ['daggerheart', 'setting', 'dh-style'],
+        classes: ['daggerheart', 'dialog', 'dh-style', 'setting'],
         position: { width: '600', height: 'auto' },
+        window: {
+            icon: 'fa-solid fa-gears'
+        },
         actions: {
             reset: this.reset,
             save: this.save

module/applications/settings/variantRuleSettings.mjs

@@ -12,14 +12,17 @@ export default class DHVariantRuleSettings extends HandlebarsApplicationMixin(Ap
     }
 
     get title() {
-        return game.i18n.localize('DAGGERHEART.SETTINGS.Menu.variantRules.name');
+        return game.i18n.localize('DAGGERHEART.SETTINGS.Menu.title');
     }
 
     static DEFAULT_OPTIONS = {
         tag: 'form',
         id: 'daggerheart-appearance-settings',
-        classes: ['daggerheart', 'setting', 'dh-style'],
+        classes: ['daggerheart', 'dialog', 'dh-style', 'setting'],
         position: { width: '600', height: 'auto' },
+        window: {
+            icon: 'fa-solid fa-gears'
+        },
         actions: {
             reset: this.reset,
             save: this.save

module/applications/sheets-configs/_module.mjs

@@ -3,3 +3,5 @@ export { default as AdversarySettings } from './adversary-settings.mjs';
 export { default as CompanionSettings } from './companion-settings.mjs';
 export { default as EnvironmentSettings } from './environment-settings.mjs';
 export { default as ActiveEffectConfig } from './activeEffectConfig.mjs';
+export { default as DhTokenConfig } from './token-config.mjs';
+export { default as DhPrototypeTokenConfig } from './prototype-token-config.mjs';

module/applications/sheets-configs/action-config.mjs

@@ -56,10 +56,6 @@ export default class DHActionConfig extends DaggerheartSheet(ApplicationV2) {
             id: 'effect',
             template: 'systems/daggerheart/templates/sheets-settings/action-settings/effect.hbs'
         }
-        /* form: {
-            id: 'action',
-            template: 'systems/daggerheart/templates/config/action.hbs'
-        } */
     };
 
     static TABS = {
@@ -111,13 +107,14 @@ export default class DHActionConfig extends DaggerheartSheet(ApplicationV2) {
             context.hasBaseDamage = !!this.action.parent.attack;
         context.getRealIndex = this.getRealIndex.bind(this);
         context.getEffectDetails = this.getEffectDetails.bind(this);
+        context.costOptions = this.getCostOptions();
         context.disableOption = this.disableOption.bind(this);
-        context.isNPC = this.action.actor && this.action.actor.type !== 'character';
+        context.isNPC = this.action.actor?.isNPC;
         context.hasRoll = this.action.hasRoll;
 
         const settingsTiers = game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.LevelTiers).tiers;
         context.tierOptions = [
-            { key: 1, label: game.i18n.localize('DAGGERHEART.GENERAL.Tiers.tier1') },
+            { key: 1, label: game.i18n.localize('DAGGERHEART.GENERAL.Tiers.1') },
             ...Object.values(settingsTiers).map(x => ({ key: x.tier, label: x.name }))
         ];
 
@@ -129,8 +126,21 @@ export default class DHActionConfig extends DaggerheartSheet(ApplicationV2) {
         this.render(true);
     }
 
-    disableOption(index, options, choices) {
-        const filtered = foundry.utils.deepClone(options);
+    getCostOptions() {
+        const options = foundry.utils.deepClone(CONFIG.DH.GENERAL.abilityCosts);
+        const resource = this.action.parent.resource;
+        if (resource) {
+            options[this.action.parent.parent.id] = {
+                label: this.action.parent.parent.name,
+                group: 'TYPES.Actor.character'
+            };
+        }
+
+        return options;
+    }
+
+    disableOption(index, costOptions, choices) {
+        const filtered = foundry.utils.deepClone(costOptions);
         Object.keys(filtered).forEach(o => {
             if (choices.find((c, idx) => c.type === o && index !== idx)) filtered[o].disabled = true;
         });
@@ -146,11 +156,19 @@ export default class DHActionConfig extends DaggerheartSheet(ApplicationV2) {
         return this.action.item.effects.get(id);
     }
 
-    _prepareSubmitData(event, formData) {
+    _prepareSubmitData(_event, formData) {
         const submitData = foundry.utils.expandObject(formData.object);
         for (const keyPath of this.constructor.CLEAN_ARRAYS) {
             const data = foundry.utils.getProperty(submitData, keyPath);
-            if (data) foundry.utils.setProperty(submitData, keyPath, Object.values(data));
+            const dataValues = data ? Object.values(data) : [];
+            if (keyPath === 'cost') {
+                for (var value of dataValues) {
+                    const item = this.action.parent.parent.id === value.key;
+                    value.keyIsID = Boolean(item);
+                }
+            }
+
+            if (data) foundry.utils.setProperty(submitData, keyPath, dataValues);
         }
         return submitData;
     }
@@ -161,7 +179,7 @@ export default class DHActionConfig extends DaggerheartSheet(ApplicationV2) {
             container = foundry.utils.getProperty(this.action.parent, this.action.systemPath);
         let newActions;
         if (Array.isArray(container)) {
-            newActions = foundry.utils.getProperty(this.action.parent, this.action.systemPath).map(x => x.toObject()); // Find better way
+            newActions = foundry.utils.getProperty(this.action.parent, this.action.systemPath).map(x => x.toObject());
             if (!newActions.findSplice(x => x._id === data._id, data)) newActions.push(data);
         } else newActions = data;
 

module/applications/sheets-configs/activeEffectConfig.mjs

@@ -1,4 +1,24 @@
+import autocomplete from 'autocompleter';
+
 export default class DhActiveEffectConfig extends foundry.applications.sheets.ActiveEffectConfig {
+    constructor(options) {
+        super(options);
+
+        const ignoredActorKeys = ['config', 'DhEnvironment'];
+        this.changeChoices = Object.keys(game.system.api.models.actors).reduce((acc, key) => {
+            if (!ignoredActorKeys.includes(key)) {
+                const model = game.system.api.models.actors[key];
+                const attributes = CONFIG.Token.documentClass.getTrackedAttributes(model);
+                const group = game.i18n.localize(model.metadata.label);
+                const choices = CONFIG.Token.documentClass
+                    .getTrackedAttributeChoices(attributes, model)
+                    .map(x => ({ ...x, group: group }));
+                acc.push(...choices);
+            }
+            return acc;
+        }, []);
+    }
+
     static DEFAULT_OPTIONS = {
         classes: ['daggerheart', 'sheet', 'dh-style']
     };
@@ -27,36 +47,62 @@ export default class DhActiveEffectConfig extends foundry.applications.sheets.Ac
         }
     };
 
+    _attachPartListeners(partId, htmlElement, options) {
+        super._attachPartListeners(partId, htmlElement, options);
+        const changeChoices = this.changeChoices;
+
+        htmlElement.querySelectorAll('.effect-change-input').forEach(element => {
+            autocomplete({
+                input: element,
+                fetch: function (text, update) {
+                    if (!text) {
+                        update(changeChoices);
+                    } else {
+                        text = text.toLowerCase();
+                        var suggestions = changeChoices.filter(n => n.label.toLowerCase().includes(text));
+                        update(suggestions);
+                    }
+                },
+                render: function (item, search) {
+                    const label = game.i18n.localize(item.label);
+                    const matchIndex = label.toLowerCase().indexOf(search);
+
+                    const beforeText = label.slice(0, matchIndex);
+                    const matchText = label.slice(matchIndex, matchIndex + search.length);
+                    const after = label.slice(matchIndex + search.length, label.length);
+
+                    const element = document.createElement('li');
+                    element.innerHTML = `${beforeText}${matchText ? `<strong>${matchText}</strong>` : ''}${after}`;
+                    if (item.hint) {
+                        element.dataset.tooltip = game.i18n.localize(item.hint);
+                    }
+
+                    return element;
+                },
+                renderGroup: function (label) {
+                    const itemElement = document.createElement('div');
+                    itemElement.textContent = game.i18n.localize(label);
+                    return itemElement;
+                },
+                onSelect: function (item) {
+                    element.value = `system.${item.value}`;
+                },
+                click: e => e.fetch(),
+                customize: function (_input, _inputRect, container) {
+                    container.style.zIndex = foundry.applications.api.ApplicationV2._maxZ;
+                },
+                minLength: 0
+            });
+        });
+    }
+
     async _preparePartContext(partId, context) {
         const partContext = await super._preparePartContext(partId, context);
         switch (partId) {
             case 'changes':
-                const fieldPaths = [];
-                const validFieldPath = fieldPath => this.validFieldPath(fieldPath, this.#unapplicablePaths);
-                context.document.parent.system.schema.apply(function () {
-                    if (!(this instanceof foundry.data.fields.SchemaField)) {
-                        if (validFieldPath(this.fieldPath)) {
-                            fieldPaths.push(this.fieldPath);
-                        }
-                    }
-                });
-
-                context.fieldPaths = fieldPaths;
-
                 break;
         }
 
         return partContext;
     }
-
-    #unapplicablePaths = ['story', 'pronouns', 'description'];
-    validFieldPath(fieldPath, unapplicablePaths) {
-        const splitPath = fieldPath.split('.');
-        if (splitPath.length > 1 && unapplicablePaths.includes(splitPath[1])) return false;
-
-        /* The current value of a resource should not be modified */
-        if (new RegExp(/resources.*\.value/).exec(fieldPath)) return false;
-
-        return true;
-    }
 }

module/applications/sheets-configs/adversary-settings.mjs

@@ -70,6 +70,18 @@ export default class DHAdversarySettings extends DHBaseActorSettings {
      * @type {ApplicationClickAction}
      */
     static async #removeExperience(_, target) {
+        const experience = this.actor.system.experiences[target.dataset.experience];
+        const confirmed = await foundry.applications.api.DialogV2.confirm({
+            window: {
+                title: game.i18n.format('DAGGERHEART.APPLICATIONS.DeleteConfirmation.title', {
+                    type: game.i18n.localize(`DAGGERHEART.GENERAL.Experience.single`),
+                    name: experience.name
+                })
+            },
+            content: game.i18n.format('DAGGERHEART.APPLICATIONS.DeleteConfirmation.text', { name: experience.name })
+        });
+        if (!confirmed) return;
+
         await this.actor.update({ [`system.experiences.-=${target.dataset.experience}`]: null });
     }
 

module/applications/sheets-configs/environment-settings.mjs

@@ -1,3 +1,4 @@
+import { getDocFromElement } from '../../helpers/utils.mjs';
 import DHBaseActorSettings from '../sheets/api/actor-setting.mjs';
 
 /**@typedef {import('@client/applications/_types.mjs').ApplicationClickAction} ApplicationClickAction */
@@ -9,8 +10,7 @@ export default class DHEnvironmentSettings extends DHBaseActorSettings {
         actions: {
             addCategory: DHEnvironmentSettings.#addCategory,
             removeCategory: DHEnvironmentSettings.#removeCategory,
-            viewAdversary: this.#viewAdversary,
-            deleteAdversary: this.#deleteAdversary
+            deleteAdversary: DHEnvironmentSettings.#deleteAdversary
         },
         dragDrop: [
             { dragSelector: null, dropSelector: '.category-container' },
@@ -69,23 +69,30 @@ export default class DHEnvironmentSettings extends DHBaseActorSettings {
         await this.actor.update({ [`system.potentialAdversaries.-=${target.dataset.categoryId}`]: null });
     }
 
-    static async #viewAdversary(_, button) {
-        const adversary = await foundry.utils.fromUuid(button.dataset.adversary);
-        if (!adversary) {
-            ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.Notifications.adversaryMissing'));
-            return;
-        }
+    /**
+     *
+     * @type {ApplicationClickAction}
+     * @returns
+     */
+    static async #deleteAdversary(_event, target) {
+        const doc = getDocFromElement(target);
+        const { category } = target.dataset;
+        const path = `system.potentialAdversaries.${category}.adversaries`;
 
-        adversary.sheet.render({ force: true });
-    }
+        const confirmed = await foundry.applications.api.DialogV2.confirm({
+            window: {
+                title: game.i18n.format('DAGGERHEART.APPLICATIONS.DeleteConfirmation.title', {
+                    type: game.i18n.localize('TYPES.Actor.adversary'),
+                    name: doc.name
+                })
+            },
+            content: game.i18n.format('DAGGERHEART.APPLICATIONS.DeleteConfirmation.text', { name: doc.name })
+        });
 
-    static async #deleteAdversary(event, target) {
-        const adversaryKey = target.dataset.adversary;
-        const path = `system.potentialAdversaries.${target.dataset.potentialAdversary}.adversaries`;
-        console.log(target.dataset.potentialAdversar);
-        const newAdversaries = foundry.utils
-            .getProperty(this.actor, path)
-            .filter(x => x && (x?.uuid ?? x) !== adversaryKey);
+        if (!confirmed) return;
+
+        const adversaries = foundry.utils.getProperty(this.actor, path);
+        const newAdversaries = adversaries.filter(a => a.uuid !== doc.uuid);
         await this.actor.update({ [path]: newAdversaries });
     }
 

module/applications/sheets-configs/prototype-token-config.mjs

@@ -0,0 +1,20 @@
+export default class DhPrototypeTokenConfig extends foundry.applications.sheets.PrototypeTokenConfig {
+    /** @inheritDoc */
+    async _prepareResourcesTab() {
+        const token = this.token;
+        const usesTrackableAttributes = !foundry.utils.isEmpty(CONFIG.Actor.trackableAttributes);
+        const attributeSource =
+            this.actor?.system instanceof foundry.abstract.DataModel && usesTrackableAttributes
+                ? this.actor?.type
+                : this.actor?.system;
+        const TokenDocument = foundry.utils.getDocumentClass('Token');
+        const attributes = TokenDocument.getTrackedAttributes(attributeSource);
+        return {
+            barAttributes: TokenDocument.getTrackedAttributeChoices(attributes, attributeSource),
+            bar1: token.getBarAttribute?.('bar1'),
+            bar2: token.getBarAttribute?.('bar2'),
+            turnMarkerModes: DhPrototypeTokenConfig.TURN_MARKER_MODES,
+            turnMarkerAnimations: CONFIG.Combat.settings.turnMarkerAnimations
+        };
+    }
+}

module/applications/sheets-configs/token-config.mjs

@@ -0,0 +1,20 @@
+export default class DhTokenConfig extends foundry.applications.sheets.TokenConfig {
+    /** @inheritDoc */
+    async _prepareResourcesTab() {
+        const token = this.token;
+        const usesTrackableAttributes = !foundry.utils.isEmpty(CONFIG.Actor.trackableAttributes);
+        const attributeSource =
+            this.actor?.system instanceof foundry.abstract.DataModel && usesTrackableAttributes
+                ? this.actor?.type
+                : this.actor?.system;
+        const TokenDocument = foundry.utils.getDocumentClass('Token');
+        const attributes = TokenDocument.getTrackedAttributes(attributeSource);
+        return {
+            barAttributes: TokenDocument.getTrackedAttributeChoices(attributes, attributeSource),
+            bar1: token.getBarAttribute?.('bar1'),
+            bar2: token.getBarAttribute?.('bar2'),
+            turnMarkerModes: DhTokenConfig.TURN_MARKER_MODES,
+            turnMarkerAnimations: CONFIG.Combat.settings.turnMarkerAnimations
+        };
+    }
+}

module/applications/sheets/actors/adversary.mjs

@@ -8,9 +8,7 @@ export default class AdversarySheet extends DHBaseActorSheet {
         position: { width: 660, height: 766 },
         window: { resizable: true },
         actions: {
-            reactionRoll: AdversarySheet.#reactionRoll,
-            useItem: this.useItem,
-            toChat: this.toChat
+            reactionRoll: AdversarySheet.#reactionRoll
         },
         window: {
             resizable: true
@@ -28,7 +26,7 @@ export default class AdversarySheet extends DHBaseActorSheet {
     /** @inheritdoc */
     static TABS = {
         primary: {
-            tabs: [{ id: 'features' }, { id: 'notes' }, { id: 'effects' }],
+            tabs: [{ id: 'features' }, { id: 'effects' }, { id: 'notes' }],
             initial: 'features',
             labelPrefix: 'DAGGERHEART.GENERAL.Tabs'
         }
@@ -41,10 +39,63 @@ export default class AdversarySheet extends DHBaseActorSheet {
         return context;
     }
 
-    getItem(element) {
-        const itemId = (element.target ?? element).closest('[data-item-id]').dataset.itemId,
-            item = this.document.items.get(itemId);
-        return item;
+    /**@inheritdoc */
+    async _preparePartContext(partId, context, options) {
+        context = await super._preparePartContext(partId, context, options);
+        switch (partId) {
+            case 'header':
+                await this._prepareHeaderContext(context, options);
+                break;
+            case 'notes':
+                await this._prepareNotesContext(context, options);
+                break;
+        }
+        return context;
+    }
+
+    /**
+     * Prepare render context for the Biography part.
+     * @param {ApplicationRenderContext} context
+     * @param {ApplicationRenderOptions} options
+     * @returns {Promise<void>}
+     * @protected
+     */
+    async _prepareNotesContext(context, _options) {
+        const { system } = this.document;
+        const { TextEditor } = foundry.applications.ux;
+
+        const paths = {
+            notes: 'notes'
+        };
+
+        for (const [key, path] of Object.entries(paths)) {
+            const value = foundry.utils.getProperty(system, path);
+            context[key] = {
+                field: system.schema.getField(path),
+                value,
+                enriched: await TextEditor.implementation.enrichHTML(value, {
+                    secrets: this.document.isOwner,
+                    relativeTo: this.document
+                })
+            };
+        }
+    }
+
+    /**
+     * Prepare render context for the Header part.
+     * @param {ApplicationRenderContext} context
+     * @param {ApplicationRenderOptions} options
+     * @returns {Promise<void>}
+     * @protected
+     */
+    async _prepareHeaderContext(context, _options) {
+        const { system } = this.document;
+        const { TextEditor } = foundry.applications.ux;
+
+        context.description = await TextEditor.implementation.enrichHTML(system.description, {
+            secrets: this.document.isOwner,
+            relativeTo: this.document
+        });
     }
 
     /* -------------------------------------------- */
@@ -72,42 +123,4 @@ export default class AdversarySheet extends DHBaseActorSheet {
 
         this.actor.diceRoll(config);
     }
-
-    /**
-     *
-     * @type {ApplicationClickAction}
-     */
-    static async useItem(event) {
-        const action = this.getItem(event) ?? this.actor.system.attack;
-        action.use(event);
-    }
-
-    /**
-     *
-     * @type {ApplicationClickAction}
-     */
-    static async toChat(event, button) {
-        if (button?.dataset?.type === 'experience') {
-            const experience = this.document.system.experiences[button.dataset.uuid];
-            const cls = getDocumentClass('ChatMessage');
-            const systemData = {
-                name: game.i18n.localize('DAGGERHEART.GENERAL.Experience.single'),
-                description: `${experience.name} ${experience.total.signedString()}`
-            };
-            const msg = new cls({
-                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.toObject());
-        } else {
-            const item = this.getItem(event) ?? this.document.system.attack;
-            item.toChat(this.document.id);
-        }
-    }
 }

module/applications/sheets/actors/character.mjs

@@ -4,6 +4,7 @@ import { abilities } from '../../../config/actorConfig.mjs';
 import DhCharacterlevelUp from '../../levelup/characterLevelup.mjs';
 import DhCharacterCreation from '../../characterCreation/characterCreation.mjs';
 import FilterMenu from '../../ux/filter-menu.mjs';
+import { getDocFromElement, itemAbleRollParse } from '../../../helpers/utils.mjs';
 
 /**@typedef {import('@client/applications/_types.mjs').ApplicationClickAction} ApplicationClickAction */
 
@@ -14,7 +15,6 @@ export default class CharacterSheet extends DHBaseActorSheet {
         classes: ['character'],
         position: { width: 850, height: 800 },
         actions: {
-            triggerContextMenu: CharacterSheet.#triggerContextMenu,
             toggleVault: CharacterSheet.#toggleVault,
             rollAttribute: CharacterSheet.#rollAttribute,
             toggleHope: CharacterSheet.#toggleHope,
@@ -23,17 +23,39 @@ export default class CharacterSheet extends DHBaseActorSheet {
             makeDeathMove: CharacterSheet.#makeDeathMove,
             levelManagement: CharacterSheet.#levelManagement,
             toggleEquipItem: CharacterSheet.#toggleEquipItem,
-            useItem: this.useItem, //TODO Fix this
-            toChat: this.toChat
+            toggleResourceDice: CharacterSheet.#toggleResourceDice,
+            handleResourceDice: CharacterSheet.#handleResourceDice,
+            useDowntime: this.useDowntime
         },
         window: {
             resizable: true
         },
-        dragDrop: [],
+        dragDrop: [
+            {
+                dragSelector: '[data-item-id][draggable="true"]',
+                dropSelector: null
+            }
+        ],
         contextMenus: [
             {
-                handler: CharacterSheet._getContextMenuOptions,
-                selector: '[data-item-id]',
+                handler: CharacterSheet.#getDomainCardContextOptions,
+                selector: '[data-item-uuid][data-type="domainCard"]',
+                options: {
+                    parentClassHooks: false,
+                    fixed: true
+                }
+            },
+            {
+                handler: CharacterSheet.#getEquipamentContextOptions,
+                selector: '[data-item-uuid][data-type="armor"], [data-item-uuid][data-type="weapon"]',
+                options: {
+                    parentClassHooks: false,
+                    fixed: true
+                }
+            },
+            {
+                handler: CharacterSheet.#getItemContextOptions,
+                selector: '[data-item-uuid][data-type="consumable"], [data-item-uuid][data-type="miscellaneous"]',
                 options: {
                     parentClassHooks: false,
                     fixed: true
@@ -85,6 +107,22 @@ export default class CharacterSheet extends DHBaseActorSheet {
         }
     };
 
+    _attachPartListeners(partId, htmlElement, options) {
+        super._attachPartListeners(partId, htmlElement, options);
+
+        htmlElement.querySelectorAll('.inventory-item-resource').forEach(element => {
+            element.addEventListener('change', this.updateItemResource.bind(this));
+        });
+        htmlElement.querySelectorAll('.inventory-item-quantity').forEach(element => {
+            element.addEventListener('change', this.updateItemQuantity.bind(this));
+        });
+
+        // Add listener for armor marks input
+        htmlElement.querySelectorAll('.armor-marks-input').forEach(element => {
+            element.addEventListener('change', this.updateArmorMarks.bind(this));
+        });
+    }
+
     /** @inheritDoc */
     async _onRender(context, options) {
         await super._onRender(context, options);
@@ -97,20 +135,6 @@ export default class CharacterSheet extends DHBaseActorSheet {
         this._createSearchFilter();
     }
 
-    /* -------------------------------------------- */
-
-    getItem(element) {
-        const listElement = (element.target ?? element).closest('[data-item-id]');
-        const itemId = listElement.dataset.itemId;
-
-        switch (listElement.dataset.type) {
-            case 'effect':
-                return this.document.effects.get(itemId);
-            default:
-                return this.document.items.get(itemId);
-        }
-    }
-
     /* -------------------------------------------- */
     /*  Prepare Context                             */
     /* -------------------------------------------- */
@@ -160,98 +184,135 @@ export default class CharacterSheet extends DHBaseActorSheet {
             case 'sidebar':
                 await this._prepareSidebarContext(context, options);
                 break;
+            case 'biography':
+                await this._prepareBiographyContext(context, options);
+                break;
         }
         return context;
     }
 
+    /**
+     * Prepare render context for the Loadout part.
+     * @param {ApplicationRenderContext} context
+     * @param {ApplicationRenderOptions} options
+     * @returns {Promise<void>}
+     * @protected
+     */
     async _prepareLoadoutContext(context, _options) {
-        context.listView = game.user.getFlag(CONFIG.DH.id, CONFIG.DH.FLAGS.displayDomainCardsAsList);
+        context.cardView = !game.user.getFlag(CONFIG.DH.id, CONFIG.DH.FLAGS.displayDomainCardsAsList);
     }
 
+    /**
+     * Prepare render context for the Sidebar part.
+     * @param {ApplicationRenderContext} context
+     * @param {ApplicationRenderOptions} options
+     * @returns {Promise<void>}
+     * @protected
+     */
     async _prepareSidebarContext(context, _options) {
         context.isDeath = this.document.system.deathMoveViable;
     }
 
+    /**
+     * Prepare render context for the Biography part.
+     * @param {ApplicationRenderContext} context
+     * @param {ApplicationRenderOptions} options
+     * @returns {Promise<void>}
+     * @protected
+     */
+    async _prepareBiographyContext(context, _options) {
+        const { system } = this.document;
+        const { TextEditor } = foundry.applications.ux;
+
+        const paths = {
+            background: 'biography.background',
+            connections: 'biography.connections'
+        };
+
+        for (const [key, path] of Object.entries(paths)) {
+            const value = foundry.utils.getProperty(system, path);
+            context[key] = {
+                field: system.schema.getField(path),
+                value,
+                enriched: await TextEditor.implementation.enrichHTML(value, {
+                    secrets: this.document.isOwner,
+                    relativeTo: this.document
+                })
+            };
+        }
+    }
+
     /* -------------------------------------------- */
     /*  Context Menu                                */
     /* -------------------------------------------- */
 
     /**
-     * Get the set of ContextMenu options.
+     * Get the set of ContextMenu options for DomainCards.
      * @returns {import('@client/applications/ux/context-menu.mjs').ContextMenuEntry[]} - The Array of context options passed to the ContextMenu instance
      * @this {CharacterSheet}
      * @protected
      */
-    static _getContextMenuOptions() {
-        /**
-         * Get the item from the element.
-         * @param {HTMLElement} el
-         * @returns {foundry.documents.Item?}
-         */
-        const getItem = el => this.actor.items.get(el.closest('[data-item-id]')?.dataset.itemId);
-
-        return [
+    static #getDomainCardContextOptions() {
+        /**@type {import('@client/applications/ux/context-menu.mjs').ContextMenuEntry[]} */
+        const options = [
             {
-                name: 'DAGGERHEART.Sheets.PC.ContextMenu.UseItem',
-                icon: '<i class="fa-solid fa-burst"></i>',
-                condition: el => {
-                    const item = getItem(el);
-                    return !['class', 'subclass'].includes(item.type);
-                },
-                callback: (button, event) => CharacterSheet.useItem.call(this, event, button)
+                name: 'toLoadout',
+                icon: 'fa-solid fa-arrow-up',
+                condition: target => getDocFromElement(target).system.inVault,
+                callback: target => getDocFromElement(target).update({ 'system.inVault': false })
             },
             {
-                name: 'DAGGERHEART.Sheets.PC.ContextMenu.Equip',
-                icon: '<i class="fa-solid fa-hands"></i>',
-                condition: el => {
-                    const item = getItem(el);
-                    return ['weapon', 'armor'].includes(item.type) && !item.system.equipped;
-                },
-                callback: CharacterSheet.#toggleEquipItem.bind(this)
-            },
-            {
-                name: 'DAGGERHEART.Sheets.PC.ContextMenu.Unequip',
-                icon: '<i class="fa-solid fa-hands"></i>',
-                condition: el => {
-                    const item = getItem(el);
-                    return ['weapon', 'armor'].includes(item.type) && item.system.equipped;
-                },
-                callback: CharacterSheet.#toggleEquipItem.bind(this)
-            },
-            {
-                name: 'DAGGERHEART.Sheets.PC.ContextMenu.ToLoadout',
-                icon: '<i class="fa-solid fa-arrow-up"></i>',
-                condition: el => {
-                    const item = getItem(el);
-                    return ['domainCard'].includes(item.type) && item.system.inVault;
-                },
-                callback: target => getItem(target).update({ 'system.inVault': false })
-            },
-            {
-                name: 'DAGGERHEART.Sheets.PC.ContextMenu.ToVault',
-                icon: '<i class="fa-solid fa-arrow-down"></i>',
-                condition: el => {
-                    const item = getItem(el);
-                    return ['domainCard'].includes(item.type) && !item.system.inVault;
-                },
-                callback: target => getItem(target).update({ 'system.inVault': true })
-            },
-            {
-                name: 'DAGGERHEART.Sheets.PC.ContextMenu.SendToChat',
-                icon: '<i class="fa-regular fa-message"></i>',
-                callback: CharacterSheet.toChat.bind(this)
-            },
-            {
-                name: 'DAGGERHEART.Sheets.PC.ContextMenu.Edit',
-                icon: '<i class="fa-solid fa-pen-to-square"></i>',
-                callback: target => getItem(target).sheet.render({ force: true })
-            },
-            {
-                name: 'DAGGERHEART.Sheets.PC.ContextMenu.Delete',
-                icon: '<i class="fa-solid fa-trash"></i>',
-                callback: el => getItem(el).delete()
+                name: 'toVault',
+                icon: 'fa-solid fa-arrow-down',
+                condition: target => !getDocFromElement(target).system.inVault,
+                callback: target => getDocFromElement(target).update({ 'system.inVault': true })
             }
-        ];
+        ].map(option => ({
+            ...option,
+            name: `DAGGERHEART.APPLICATIONS.ContextMenu.${option.name}`,
+            icon: `<i class="${option.icon}"></i>`
+        }));
+
+        return [...options, ...this._getContextMenuCommonOptions.call(this, { usable: true, toChat: true })];
+    }
+
+    /**
+     * Get the set of ContextMenu options for Armors and Weapons.
+     * @returns {import('@client/applications/ux/context-menu.mjs').ContextMenuEntry[]} - The Array of context options passed to the ContextMenu instance
+     * @this {CharacterSheet}
+     * @protected
+     */
+    static #getEquipamentContextOptions() {
+        const options = [
+            {
+                name: 'equip',
+                icon: 'fa-solid fa-hands',
+                condition: target => !getDocFromElement(target).system.equipped,
+                callback: (target, event) => CharacterSheet.#toggleEquipItem.call(this, event, target)
+            },
+            {
+                name: 'unequip',
+                icon: 'fa-solid fa-hands',
+                condition: target => getDocFromElement(target).system.equipped,
+                callback: (target, event) => CharacterSheet.#toggleEquipItem.call(this, event, target)
+            }
+        ].map(option => ({
+            ...option,
+            name: `DAGGERHEART.APPLICATIONS.ContextMenu.${option.name}`,
+            icon: `<i class="${option.icon}"></i>`
+        }));
+
+        return [...options, ...this._getContextMenuCommonOptions.call(this, { usable: true, toChat: true })];
+    }
+
+    /**
+     * Get the set of ContextMenu options for Consumable and Miscellaneous.
+     * @returns {import('@client/applications/ux/context-menu.mjs').ContextMenuEntry[]} - The Array of context options passed to the ContextMenu instance
+     * @this {CharacterSheet}
+     * @protected
+     */
+    static #getItemContextOptions() {
+        return this._getContextMenuCommonOptions.call(this, { usable: true, toChat: true });
     }
     /* -------------------------------------------- */
     /*  Filter Tracking                             */
@@ -345,7 +406,7 @@ export default class CharacterSheet extends DHBaseActorSheet {
         this.#filteredItems.inventory.search.clear();
 
         for (const li of html.querySelectorAll('.inventory-item')) {
-            const item = this.document.items.get(li.dataset.itemId);
+            const item = getDocFromElement(li);
             const matchesSearch = !query || foundry.applications.ux.SearchFilter.testQuery(rgx, item.name);
             if (matchesSearch) this.#filteredItems.inventory.search.add(item.id);
             const { menu } = this.#filteredItems.inventory;
@@ -365,14 +426,14 @@ export default class CharacterSheet extends DHBaseActorSheet {
         this.#filteredItems.loadout.search.clear();
 
         for (const li of html.querySelectorAll('.items-list .inventory-item, .card-list .card-item')) {
-            const item = this.document.items.get(li.dataset.itemId);
+            const item = getDocFromElement(li);
             const matchesSearch = !query || foundry.applications.ux.SearchFilter.testQuery(rgx, item.name);
             if (matchesSearch) this.#filteredItems.loadout.search.add(item.id);
             const { menu } = this.#filteredItems.loadout;
             li.hidden = !(menu.has(item.id) && matchesSearch);
         }
     }
-  
+
     /* -------------------------------------------- */
     /*  Filter Menus                                */
     /* -------------------------------------------- */
@@ -416,7 +477,7 @@ export default class CharacterSheet extends DHBaseActorSheet {
         this.#filteredItems.inventory.menu.clear();
 
         for (const li of html.querySelectorAll('.inventory-item')) {
-            const item = this.document.items.get(li.dataset.itemId);
+            const item = getDocFromElement(li);
 
             const matchesMenu =
                 filters.length === 0 || filters.some(f => foundry.applications.ux.SearchFilter.evaluateFilter(item, f));
@@ -437,7 +498,7 @@ export default class CharacterSheet extends DHBaseActorSheet {
         this.#filteredItems.loadout.menu.clear();
 
         for (const li of html.querySelectorAll('.items-list .inventory-item, .card-list .card-item')) {
-            const item = this.document.items.get(li.dataset.itemId);
+            const item = getDocFromElement(li);
 
             const matchesMenu =
                 filters.length === 0 || filters.some(f => foundry.applications.ux.SearchFilter.evaluateFilter(item, f));
@@ -448,6 +509,35 @@ export default class CharacterSheet extends DHBaseActorSheet {
         }
     }
 
+    /* -------------------------------------------- */
+    /*  Application Listener Actions                */
+    /* -------------------------------------------- */
+
+    async updateItemResource(event) {
+        const item = getDocFromElement(event.currentTarget);
+        if (!item) return;
+
+        const max = item.system.resource.max ? itemAbleRollParse(item.system.resource.max, this.document, item) : null;
+        const value = max ? Math.min(Number(event.currentTarget.value), max) : event.currentTarget.value;
+        await item.update({ 'system.resource.value': value });
+    }
+
+    async updateItemQuantity(event) {
+        const item = getDocFromElement(event.currentTarget);
+        if (!item) return;
+
+        await item.update({ 'system.quantity': event.currentTarget.value });
+    }
+
+    async updateArmorMarks(event) {
+        const armor = this.document.system.armor;
+        if (!armor) return;
+
+        const maxMarks = this.document.system.armorScore;
+        const value = Math.min(Math.max(Number(event.currentTarget.value), 0), maxMarks);
+        await armor.update({ 'system.marks.value': value });
+    }
+
     /* -------------------------------------------- */
     /*  Application Clicks Actions                  */
     /* -------------------------------------------- */
@@ -495,7 +585,7 @@ export default class CharacterSheet extends DHBaseActorSheet {
         const config = {
             event: event,
             title: `${game.i18n.localize('DAGGERHEART.GENERAL.dualityRoll')}: ${this.actor.name}`,
-            headerTitle: game.i18n.format('DAGGERHEART.UI.Chat.dualityRoll.abilitychecktitle', {
+            headerTitle: game.i18n.format('DAGGERHEART.UI.Chat.dualityRoll.abilityCheckTitle', {
                 ability: abilityLabel
             }),
             roll: {
@@ -505,13 +595,14 @@ export default class CharacterSheet extends DHBaseActorSheet {
         this.document.diceRoll(config);
     }
 
+    //TODO: redo toggleEquipItem method
+
     /**
      * Toggles the equipped state of an item (armor or weapon).
      * @type {ApplicationClickAction}
      */
     static async #toggleEquipItem(_event, button) {
-        //TODO: redo this
-        const item = this.actor.items.get(button.closest('[data-item-id]')?.dataset.itemId);
+        const item = getDocFromElement(button);
         if (!item) return;
         if (item.system.equipped) {
             await item.update({ 'system.equipped': false });
@@ -528,6 +619,12 @@ export default class CharacterSheet extends DHBaseActorSheet {
                 await item.update({ 'system.equipped': true });
                 break;
             case 'weapon':
+                if (this.document.effects.find(x => x.type === 'beastform')) {
+                    return ui.notifications.warn(
+                        game.i18n.localize('DAGGERHEART.UI.Notifications.beastformEquipWeapon')
+                    );
+                }
+
                 await this.document.system.constructor.unequipBeforeEquip.bind(this.document.system)(item);
 
                 await item.update({ 'system.equipped': true });
@@ -559,76 +656,69 @@ export default class CharacterSheet extends DHBaseActorSheet {
      * Toggles whether an item is stored in the vault.
      * @type {ApplicationClickAction}
      */
-    static async #toggleVault(event, button) {
-        const docId = button.closest('[data-item-id]')?.dataset.itemId;
-        const doc = this.document.items.get(docId);
+    static async #toggleVault(_event, button) {
+        const doc = getDocFromElement(button);
         await doc?.update({ 'system.inVault': !doc.system.inVault });
     }
 
     /**
-     * Trigger the context menu.
+     * Toggle the used state of a resource dice.
      * @type {ApplicationClickAction}
      */
-    static #triggerContextMenu(event, _) {
-        return CONFIG.ux.ContextMenu.triggerContextMenu(event);
+    static async #toggleResourceDice(event, target) {
+        const item = getDocFromElement(target);
+
+        const { dice } = event.target.closest('.item-resource').dataset;
+        const diceState = item.system.resource.diceStates[dice];
+
+        await item.update({
+            [`system.resource.diceStates.${dice}.used`]: diceState ? !diceState.used : true
+        });
     }
 
     /**
-     * Use a item
+     * Handle the roll values of resource dice.
      * @type {ApplicationClickAction}
      */
-    static async useItem(event, button) {
-        const item = this.getItem(button);
+    static async #handleResourceDice(_, target) {
+        const item = getDocFromElement(target);
         if (!item) return;
 
-        // Should dandle its actions. Or maybe they'll be separate buttons as per an Issue on the board
-        if (item.type === 'feature') {
-            item.use(event);
-        } else if (item instanceof ActiveEffect) {
-            item.toChat(this);
-        } else {
-            const wasUsed = await item.use(event);
-            if (wasUsed && item.type === 'weapon') {
-                Hooks.callAll(CONFIG.DH.HOOKS.characterAttack, {});
-            }
-        }
+        const rollValues = await game.system.api.applications.dialogs.ResourceDiceDialog.create(item, this.document);
+        if (!rollValues) return;
+
+        await item.update({
+            'system.resource.diceStates': rollValues.reduce((acc, state, index) => {
+                acc[index] = { value: state.value, used: state.used };
+                return acc;
+            }, {})
+        });
     }
 
-    /**
-     * Send item to Chat
-     * @type {ApplicationClickAction}
-     */
-    static async toChat(event, button) {
-        if (button?.dataset?.type === 'experience') {
-            const experience = this.document.system.experiences[button.dataset.uuid];
-            const cls = getDocumentClass('ChatMessage');
-            const systemData = {
-                name: game.i18n.localize('DAGGERHEART.GENERAL.Experience.single'),
-                description: `${experience.name} ${experience.total < 0 ? experience.total : `+${experience.total}`}`
-            };
-            const msg = new cls({
-                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.toObject());
-        } else {
-            const item = this.getItem(event);
-            if (!item) return;
-            item.toChat(this.document.id);
-        }
+    static useDowntime(_, button) {
+        new game.system.api.applications.dialogs.Downtime(this.document, button.dataset.type === 'shortRest').render(
+            true
+        );
     }
 
-    async _onDragStart(_, event) {
+    async _onDragStart(event) {
+        const item = getDocFromElement(event.target);
+
+        const dragData = {
+            type: item.documentName,
+            uuid: item.uuid
+        };
+
+        event.dataTransfer.setData('text/plain', JSON.stringify(dragData));
+
         super._onDragStart(event);
     }
 
     async _onDrop(event) {
+        // Prevent event bubbling to avoid duplicate handling
+        event.preventDefault();
+        event.stopPropagation();
+
         super._onDrop(event);
         this._onDropItem(event, TextEditor.getDragEventData(event));
     }

module/applications/sheets/actors/companion.mjs

@@ -6,11 +6,7 @@ export default class DhCompanionSheet extends DHBaseActorSheet {
     static DEFAULT_OPTIONS = {
         classes: ['actor', 'companion'],
         position: { width: 300 },
-        actions: {
-            viewActor: this.viewActor,
-            useItem: this.useItem,
-            toChat: this.toChat
-        }
+        actions: {}
     };
 
     static PARTS = {
@@ -29,52 +25,4 @@ export default class DhCompanionSheet extends DHBaseActorSheet {
             labelPrefix: 'DAGGERHEART.GENERAL.Tabs'
         }
     };
-
-    /* -------------------------------------------- */
-    /*  Application Clicks Actions                  */
-    /* -------------------------------------------- */
-
-    static async viewActor(_, button) {
-        const target = button.closest('[data-item-uuid]');
-        const actor = await foundry.utils.fromUuid(target.dataset.itemUuid);
-        if (!actor) return;
-
-        actor.sheet.render(true);
-    }
-
-    getAction(element) {
-        const itemId = (element.target ?? element).closest('[data-item-id]').dataset.itemId,
-            item = this.document.system.actions.find(x => x.id === itemId);
-        return item;
-    }
-
-    static async useItem(event) {
-        const action = this.getAction(event) ?? this.actor.system.attack;
-        action.use(event);
-    }
-
-    static async toChat(event, button) {
-        if (button?.dataset?.type === 'experience') {
-            const experience = this.document.system.experiences[button.dataset.uuid];
-            const cls = getDocumentClass('ChatMessage');
-            const systemData = {
-                name: game.i18n.localize('DAGGERHEART.GENERAL.Experience.single'),
-                description: `${experience.name} ${experience.total < 0 ? experience.total : `+${experience.total}`}`
-            };
-            const msg = new cls({
-                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.toObject());
-        } else {
-            const item = this.getAction(event) ?? this.document.system.attack;
-            item.toChat(this.document.id);
-        }
-    }
 }

module/applications/sheets/actors/environment.mjs

@@ -9,10 +9,7 @@ export default class DhpEnvironment extends DHBaseActorSheet {
         position: {
             width: 500
         },
-        actions: {
-            useItem: this.useItem,
-            toChat: this.toChat
-        },
+        actions: {},
         dragDrop: [{ dragSelector: '.action-section .inventory-item', dropSelector: null }]
     };
 
@@ -35,47 +32,67 @@ export default class DhpEnvironment extends DHBaseActorSheet {
         }
     };
 
-    /* -------------------------------------------- */
-
-    getItem(element) {
-        const itemId = (element.target ?? element).closest('[data-item-id]').dataset.itemId,
-            item = this.document.items.get(itemId);
-        return item;
+    /**@inheritdoc */
+    async _preparePartContext(partId, context, options) {
+        context = await super._preparePartContext(partId, context, options);
+        switch (partId) {
+            case 'header':
+                await this._prepareHeaderContext(context, options);
+                break;
+            case 'notes':
+                await this._prepareNotesContext(context, options);
+                break;
+        }
+        return context;
     }
 
-    /* -------------------------------------------- */
-    /*  Application Clicks Actions                  */
-    /* -------------------------------------------- */
-
     /**
-     *
-     * @type {ApplicationClickAction}
+     * Prepare render context for the Biography part.
+     * @param {ApplicationRenderContext} context
+     * @param {ApplicationRenderOptions} options
+     * @returns {Promise<void>}
+     * @protected
      */
-    async viewAdversary(_, button) {
-        const target = button.closest('[data-item-uuid]');
-        const adversary = await foundry.utils.fromUuid(target.dataset.itemUuid);
-        if (!adversary) {
-            ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.Notifications.adversaryMissing'));
-            return;
-        }
+    async _prepareNotesContext(context, _options) {
+        const { system } = this.document;
+        const { TextEditor } = foundry.applications.ux;
 
-        adversary.sheet.render({ force: true });
-    }
+        const paths = {
+            notes: 'notes'
+        };
 
-    static async useItem(event, button) {
-        const action = this.getItem(event);
-        if (!action) {
-            await this.viewAdversary(event, button);
-        } else {
-            action.use(event);
+        for (const [key, path] of Object.entries(paths)) {
+            const value = foundry.utils.getProperty(system, path);
+            context[key] = {
+                field: system.schema.getField(path),
+                value,
+                enriched: await TextEditor.implementation.enrichHTML(value, {
+                    secrets: this.document.isOwner,
+                    relativeTo: this.document
+                })
+            };
         }
     }
 
-    static async toChat(event) {
-        const item = this.getItem(event);
-        item.toChat(this.document.id);
+    /**
+     * Prepare render context for the Header part.
+     * @param {ApplicationRenderContext} context
+     * @param {ApplicationRenderOptions} options
+     * @returns {Promise<void>}
+     * @protected
+     */
+    async _prepareHeaderContext(context, _options) {
+        const { system } = this.document;
+        const { TextEditor } = foundry.applications.ux;
+
+        context.description = await TextEditor.implementation.enrichHTML(system.description, {
+            secrets: this.document.isOwner,
+            relativeTo: this.document
+        });
     }
 
+    /* -------------------------------------------- */
+
     async _onDragStart(event) {
         const item = event.currentTarget.closest('.inventory-item');
 

module/applications/sheets/api/_modules.mjs

@@ -1,5 +1,6 @@
 export { default as DHApplicationMixin } from './application-mixin.mjs';
 export { default as DHBaseItemSheet } from './base-item.mjs';
 export { default as DHHeritageSheet } from './heritage-sheet.mjs';
+export { default as DHItemAttachmentSheet } from './item-attachment-sheet.mjs';
 export { default as DHBaseActorSheet } from './base-actor.mjs';
 export { default as DHBaseActorSettings } from './actor-setting.mjs';

module/applications/sheets/api/actor-setting.mjs

@@ -42,9 +42,12 @@ export default class DHBaseActorSettings extends DHApplicationMixin(DocumentShee
     /**@inheritdoc */
     async _prepareContext(options) {
         const context = await super._prepareContext(options);
-        context.systemFields.attack.fields = this.actor.system.attack.schema.fields;
         context.isNPC = this.actor.isNPC;
 
+        if (context.systemFields.attack) {
+            context.systemFields.attack.fields = this.actor.system.attack.schema.fields;
+        }
+
         return context;
     }
 }

module/applications/sheets/api/application-mixin.mjs

@@ -1,5 +1,10 @@
 const { HandlebarsApplicationMixin } = foundry.applications.api;
-import { tagifyElement } from '../../../helpers/utils.mjs';
+import { getDocFromElement, tagifyElement } from '../../../helpers/utils.mjs';
+import DHActionConfig from '../../sheets-configs/action-config.mjs';
+
+/**
+ * @typedef {import('@client/applications/_types.mjs').ApplicationClickAction} ApplicationClickAction
+ */
 
 /**
  * @typedef {object} DragDropConfig
@@ -71,11 +76,34 @@ export default function DHApplicationMixin(Base) {
         static DEFAULT_OPTIONS = {
             classes: ['daggerheart', 'sheet', 'dh-style'],
             actions: {
+                triggerContextMenu: DHSheetV2.#triggerContextMenu,
                 createDoc: DHSheetV2.#createDoc,
                 editDoc: DHSheetV2.#editDoc,
-                deleteDoc: DHSheetV2.#deleteDoc
+                deleteDoc: DHSheetV2.#deleteDoc,
+                toChat: DHSheetV2.#toChat,
+                useItem: DHSheetV2.#useItem,
+                useAction: DHSheetV2.#useAction,
+                toggleEffect: DHSheetV2.#toggleEffect,
+                toggleExtended: DHSheetV2.#toggleExtended
             },
-            contextMenus: [],
+            contextMenus: [
+                {
+                    handler: DHSheetV2.#getEffectContextOptions,
+                    selector: '[data-item-uuid][data-type="effect"]',
+                    options: {
+                        parentClassHooks: false,
+                        fixed: true
+                    }
+                },
+                {
+                    handler: DHSheetV2.#getActionContextOptions,
+                    selector: '[data-item-uuid][data-type="action"]',
+                    options: {
+                        parentClassHooks: false,
+                        fixed: true
+                    }
+                }
+            ],
             dragDrop: [],
             tagifyConfigs: []
         };
@@ -99,6 +127,27 @@ export default function DHApplicationMixin(Base) {
             this._createTagifyElements(this.options.tagifyConfigs);
         }
 
+        /* -------------------------------------------- */
+        /*  Sync Parts                                  */
+        /* -------------------------------------------- */
+
+        /**@inheritdoc */
+        _syncPartState(partId, newElement, priorElement, state) {
+            super._syncPartState(partId, newElement, priorElement, state);
+            for (const el of priorElement.querySelectorAll('.extensible.extended')) {
+                const { actionId, itemUuid } = el.parentElement.dataset;
+                const selector = `${actionId ? `[data-action-id="${actionId}"]` : `[data-item-uuid="${itemUuid}"]`} .extensible`;
+                const newExtensible = newElement.querySelector(selector);
+
+                if (!newExtensible) continue;
+                newExtensible.classList.add('extended');
+                const descriptionElement = newExtensible.querySelector('.invetory-description');
+                if (descriptionElement) {
+                    this.#prepareInventoryDescription(newExtensible, descriptionElement);
+                }
+            }
+        }
+
         /* -------------------------------------------- */
         /*  Tags                                        */
         /* -------------------------------------------- */
@@ -185,12 +234,146 @@ export default function DHApplicationMixin(Base) {
         /* -------------------------------------------- */
 
         /**
-         * Get the set of ContextMenu options which should be used for journal entry pages in the sidebar.
-         * @returns {import('@client/applications/ux/context-menu.mjs').ContextMenuEntry[]}
+         * Get the set of ContextMenu options for DomainCards.
+         * @returns {import('@client/applications/ux/context-menu.mjs').ContextMenuEntry[]} - The Array of context options passed to the ContextMenu instance
+         * @this {CharacterSheet}
          * @protected
          */
-        _getEntryContextOptions() {
-            return [];
+        static #getEffectContextOptions() {
+            /**@type {import('@client/applications/ux/context-menu.mjs').ContextMenuEntry[]} */
+            const options = [
+                {
+                    name: 'disableEffect',
+                    icon: 'fa-solid fa-lightbulb',
+                    condition: target => !getDocFromElement(target).disabled,
+                    callback: target => getDocFromElement(target).update({ disabled: true })
+                },
+                {
+                    name: 'enableEffect',
+                    icon: 'fa-regular fa-lightbulb',
+                    condition: target => getDocFromElement(target).disabled,
+                    callback: target => getDocFromElement(target).update({ disabled: false })
+                }
+            ].map(option => ({
+                ...option,
+                name: `DAGGERHEART.APPLICATIONS.ContextMenu.${option.name}`,
+                icon: `<i class="${option.icon}"></i>`
+            }));
+
+            return [...options, ...this._getContextMenuCommonOptions.call(this, { toChat: true })];
+        }
+
+        /**
+         * Get the set of ContextMenu options for Actions.
+         * @returns {import('@client/applications/ux/context-menu.mjs').ContextMenuEntry[]} - The Array of context options passed to the ContextMenu instance
+         * @this {DHSheetV2}
+         * @protected
+         */
+        static #getActionContextOptions() {
+            /**@type {import('@client/applications/ux/context-menu.mjs').ContextMenuEntry[]} */
+            const getAction = target => {
+                const { actionId } = target.closest('[data-action-id]').dataset;
+                const { actions, attack } = this.document.system;
+                return attack?.id === actionId ? attack : actions?.find(a => a.id === actionId);
+            };
+
+            const options = [
+                {
+                    name: 'DAGGERHEART.APPLICATIONS.ContextMenu.useItem',
+                    icon: 'fa-solid fa-burst',
+                    condition:
+                        this.document instanceof foundry.documents.Actor ||
+                        (this.document instanceof foundry.documents.Item && this.document.parent),
+                    callback: (target, event) => getAction(target).use(event)
+                },
+                {
+                    name: 'DAGGERHEART.APPLICATIONS.ContextMenu.sendToChat',
+                    icon: 'fa-solid fa-message',
+                    callback: target => getAction(target).toChat(this.document.id)
+                },
+                {
+                    name: 'CONTROLS.CommonEdit',
+                    icon: 'fa-solid fa-pen-to-square',
+                    callback: target => new DHActionConfig(getAction(target)).render({ force: true })
+                },
+                {
+                    name: 'CONTROLS.CommonDelete',
+                    icon: 'fa-solid fa-trash',
+                    condition: target => {
+                        const { actionId } = target.closest('[data-action-id]').dataset;
+                        const { attack } = this.document.system;
+                        return attack?.id !== actionId;
+                    },
+                    callback: async target => {
+                        const action = getAction(target);
+                        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: action.name
+                                })
+                            },
+                            content: game.i18n.format('DAGGERHEART.APPLICATIONS.DeleteConfirmation.text', {
+                                name: action.name
+                            })
+                        });
+                        if (!confirmed) return;
+
+                        return this.document.update({
+                            'system.actions': this.document.system.actions.filter(a => a.id !== action.id)
+                        });
+                    }
+                }
+            ].map(option => ({
+                ...option,
+                icon: `<i class="${option.icon}"></i>`
+            }));
+
+            return options;
+        }
+
+        /**
+         * Get the set of ContextMenu options.
+         * @returns {import('@client/applications/ux/context-menu.mjs').ContextMenuEntry[]} - The Array of context options passed to the ContextMenu instance
+         */
+        _getContextMenuCommonOptions({ usable = false, toChat = false, deletable = true }) {
+            const options = [
+                {
+                    name: 'CONTROLS.CommonEdit',
+                    icon: 'fa-solid fa-pen-to-square',
+                    callback: target => getDocFromElement(target).sheet.render({ force: true })
+                }
+            ];
+
+            if (usable)
+                options.unshift({
+                    name: 'DAGGERHEART.APPLICATIONS.ContextMenu.useItem',
+                    icon: 'fa-solid fa-burst',
+                    callback: (target, event) => getDocFromElement(target).use(event)
+                });
+
+            if (toChat)
+                options.unshift({
+                    name: 'DAGGERHEART.APPLICATIONS.ContextMenu.sendToChat',
+                    icon: 'fa-solid fa-message',
+                    callback: target => getDocFromElement(target).toChat(this.document.id)
+                });
+
+            if (deletable)
+                options.push({
+                    name: 'CONTROLS.CommonDelete',
+                    icon: 'fa-solid fa-trash',
+                    callback: (target, event) => {
+                        const doc = getDocFromElement(target);
+                        if (event.shiftKey) return doc.delete();
+                        else return doc.deleteDialog();
+                    }
+                });
+
+            return options.map(option => ({
+                ...option,
+                icon: `<i class="${option.icon}"></i>`
+            }));
         }
 
         /* -------------------------------------------- */
@@ -207,50 +390,233 @@ export default function DHApplicationMixin(Base) {
             return context;
         }
 
+        /* -------------------------------------------- */
+        /*  Prepare Descriptions                        */
+        /* -------------------------------------------- */
+
+        /**
+         * Prepares and enriches an inventory item or action description for display.
+         * @param {HTMLElement} extensibleElement - The parent element containing the description.
+         * @param {HTMLElement} descriptionElement - The element where the enriched description will be rendered.
+         * @returns {Promise<void>}
+         */
+        async #prepareInventoryDescription(extensibleElement, descriptionElement) {
+            const parent = extensibleElement.closest('[data-item-uuid], [data-action-id]');
+            const { actionId, itemUuid } = parent?.dataset || {};
+            if (!actionId && !itemUuid) return;
+
+            const doc = itemUuid
+                ? getDocFromElement(extensibleElement)
+                : this.document.system.attack?.id === actionId
+                  ? this.document.system.attack
+                  : this.document.system.actions?.find(a => a.id === actionId);
+            if (!doc) return;
+
+            const description = doc.system?.description ?? doc.description;
+            const isAction = !!actionId;
+            descriptionElement.innerHTML = await foundry.applications.ux.TextEditor.implementation.enrichHTML(
+                description,
+                {
+                    relativeTo: isAction ? doc.parent : doc,
+                    rollData: doc.getRollData?.(),
+                    secrets: isAction ? doc.parent.isOwner : doc.isOwner
+                }
+            );
+        }
+
         /* -------------------------------------------- */
         /*  Application Clicks Actions                  */
         /* -------------------------------------------- */
 
         /**
          * Create an embedded document.
-         * @param {PointerEvent} event - The originating click event
-         * @param {HTMLElement} button - The capturing HTML element which defines the [data-action="removeAction"]
+         * @type {ApplicationClickAction}
          */
-        static async #createDoc(event, button) {
-            const { documentClass, type } = button.dataset;
-            console.log(documentClass, type);
-            const parent = this.document;
+        static async #createDoc(event, target) {
+            const { documentClass, type, inVault, disabled } = target.dataset;
+            const parentIsItem = this.document.documentName === 'Item';
+            const parent = parentIsItem && documentClass === 'Item' ? null : this.document;
 
-            const cls = getDocumentClass(documentClass);
-            return await cls.createDocuments(
-                [
+            if (type === 'action') {
+                const { type: actionType } =
+                    (await foundry.applications.api.DialogV2.input({
+                        window: { title: 'Select Action Type' },
+                        classes: ['daggerheart', 'dh-style'],
+                        content: await foundry.applications.handlebars.renderTemplate(
+                            'systems/daggerheart/templates/actionTypes/actionType.hbs',
+                            {
+                                types: CONFIG.DH.ACTIONS.actionTypes,
+                                itemName: game.i18n.localize('DAGGERHEART.CONFIG.SelectAction.selectAction')
+                            }
+                        ),
+                        ok: {
+                            label: game.i18n.format('DOCUMENT.Create', {
+                                type: game.i18n.localize('DAGGERHEART.GENERAL.Action.single')
+                            })
+                        }
+                    })) ?? {};
+                if (!actionType) return;
+                const cls = game.system.api.models.actions.actionsTypes[actionType];
+                const action = new cls(
                     {
-                        name: cls.defaultName({ type, parent }),
-                        type
+                        _id: foundry.utils.randomID(),
+                        type: actionType,
+                        name: game.i18n.localize(CONFIG.DH.ACTIONS.actionTypes[actionType].name),
+                        ...cls.getSourceConfig(this.document)
+                    },
+                    {
+                        parent: this.document
                     }
-                ],
-                { parent, renderSheet: !event.shiftKey }
-            );
+                );
+                await this.document.update({ 'system.actions': [...this.document.system.actions, action] });
+                await new DHActionConfig(this.document.system.actions[this.document.system.actions.length - 1]).render({
+                    force: true
+                });
+                return action;
+            } else {
+                const cls = getDocumentClass(documentClass);
+                const data = {
+                    name: cls.defaultName({ type, parent }),
+                    type
+                };
+                if (inVault) data['system.inVault'] = true;
+                if (disabled) data.disabled = true;
+
+                const doc = await cls.create(data, { parent, renderSheet: !event.shiftKey });
+                if (parentIsItem && type === 'feature') {
+                    await this.document.update({
+                        'system.features': this.document.system.toObject().features.concat(doc.uuid)
+                    });
+                }
+                return doc;
+            }
         }
 
         /**
          * Renders an embedded document.
-         * @param {PointerEvent} event - The originating click event
-         * @param {HTMLElement} button - The capturing HTML element which defines the [data-action="removeAction"]
+         * @type {ApplicationClickAction}
          */
-        static #editDoc(_event, button) {
-            const { type, docId } = button.dataset;
-            this.document.getEmbeddedDocument(type, docId, { strict: true }).sheet.render({ force: true });
+        static #editDoc(_event, target) {
+            const doc = getDocFromElement(target);
+            if (doc) return doc.sheet.render({ force: true });
+
+            // TODO: REDO this
+            const { actionId } = target.closest('[data-action-id]').dataset;
+            const { actions, attack } = this.document.system;
+            const action = attack?.id === actionId ? attack : actions?.find(a => a.id === actionId);
+            new DHActionConfig(action).render({ force: true });
         }
 
         /**
          * Delete an embedded document.
-         * @param {PointerEvent} _event - The originating click event
-         * @param {HTMLElement} button - The capturing HTML element which defines the [data-action="removeAction"]
+         * @type {ApplicationClickAction}
          */
-        static async #deleteDoc(_event, button) {
-            const { type, docId } = button.dataset;
-            await this.document.getEmbeddedDocument(type, docId, { strict: true }).delete();
+        static async #deleteDoc(event, target) {
+            const doc = getDocFromElement(target);
+
+            if (doc) {
+                if (event.shiftKey) return doc.delete();
+                else return await doc.deleteDialog();
+            }
+
+            // TODO: REDO this
+            const { actionId } = target.closest('[data-action-id]').dataset;
+            const { actions, attack } = this.document.system;
+            if (attack?.id === actionId) return;
+            const action = actions.find(a => a.id === actionId);
+
+            if (!event.shiftKey) {
+                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: action.name
+                        })
+                    },
+                    content: game.i18n.format('DAGGERHEART.APPLICATIONS.DeleteConfirmation.text', { name: action.name })
+                });
+                if (!confirmed) return;
+            }
+
+            return await this.document.update({
+                'system.actions': actions.filter(a => a.id !== action.id)
+            });
+        }
+
+        /**
+         * Send item to Chat
+         * @type {ApplicationClickAction}
+         */
+        static async #toChat(_event, target) {
+            let doc = getDocFromElement(target);
+
+            // TODO: REDO this
+            if (!doc) {
+                const { actionId } = target.closest('[data-action-id]').dataset;
+                const { actions, attack } = this.document.system;
+                doc = attack?.id === actionId ? attack : actions?.find(a => a.id === actionId);
+            }
+            return doc.toChat(this.document.id);
+        }
+
+        /**
+         * Use a item
+         * @type {ApplicationClickAction}
+         */
+        static async #useItem(event, target) {
+            let doc = getDocFromElement(target);
+            // TODO: REDO this
+            if (!doc) {
+                const { actionId } = target.closest('[data-action-id]').dataset;
+                const { actions, attack } = this.document.system;
+                doc = attack?.id === actionId ? attack : actions?.find(a => a.id === actionId);
+                if (this.document instanceof foundry.documents.Item && !this.document.parent) return;
+            }
+
+            await doc.use(event);
+        }
+
+        /**
+         * Use a item
+         * @type {ApplicationClickAction}
+         */
+        static async #useAction(event, target) {
+            const doc = getDocFromElement(target);
+            const { actionId } = target.closest('[data-action-id]').dataset;
+            const { actions, attack } = doc.system;
+            const action = attack?.id === actionId ? attack : actions?.find(a => a.id === actionId);
+            await action.use(event, doc);
+        }
+
+        /**
+         * Toggle a ActiveEffect
+         * @type {ApplicationClickAction}
+         */
+        static async #toggleEffect(_, target) {
+            const doc = getDocFromElement(target);
+            await doc.update({ disabled: !doc.disabled });
+        }
+
+        /**
+         * Trigger the context menu.
+         * @type {ApplicationClickAction}
+         */
+        static #triggerContextMenu(event, _) {
+            return CONFIG.ux.ContextMenu.triggerContextMenu(event);
+        }
+
+        /**
+         * Toggle the 'extended' class on the .extensible element inside inventory-item-content
+         * @type {ApplicationClickAction}
+         * @this {DHSheetV2}
+         */
+        static async #toggleExtended(_, target) {
+            const container = target.closest('.inventory-item');
+            const extensible = container?.querySelector('.extensible');
+            const t = extensible?.classList.toggle('extended');
+
+            const descriptionElement = extensible?.querySelector('.invetory-description');
+            if (t && !!descriptionElement) this.#prepareInventoryDescription(extensible, descriptionElement);
         }
     }
 

module/applications/sheets/api/base-actor.mjs

@@ -21,11 +21,24 @@ export default class DHBaseActorSheet extends DHApplicationMixin(ActorSheetV2) {
             submitOnChange: true
         },
         actions: {
-            openSettings: DHBaseActorSheet.#openSettings
+            openSettings: DHBaseActorSheet.#openSettings,
+            sendExpToChat: DHBaseActorSheet.#sendExpToChat
         },
-        dragDrop: []
+        contextMenus: [
+            {
+                handler: DHBaseActorSheet.#getFeatureContextOptions,
+                selector: '[data-item-uuid][data-type="feature"]',
+                options: {
+                    parentClassHooks: false,
+                    fixed: true
+                }
+            }
+        ],
+        dragDrop: [{ dragSelector: '.inventory-item[data-type="attack"]', dropSelector: null }]
     };
 
+    /* -------------------------------------------- */
+
     /**@type {typeof DHBaseActorSettings}*/
     #settingSheet;
 
@@ -35,6 +48,10 @@ export default class DHBaseActorSheet extends DHApplicationMixin(ActorSheetV2) {
         return (this.#settingSheet ??= SheetClass ? new SheetClass({ document: this.document }) : null);
     }
 
+    /* -------------------------------------------- */
+    /*  Prepare Context                             */
+    /* -------------------------------------------- */
+
     /**@inheritdoc */
     async _prepareContext(_options) {
         const context = await super._prepareContext(_options);
@@ -42,6 +59,54 @@ export default class DHBaseActorSheet extends DHApplicationMixin(ActorSheetV2) {
         return context;
     }
 
+    /**@inheritdoc */
+    async _preparePartContext(partId, context, options) {
+        context = await super._preparePartContext(partId, context, options);
+        switch (partId) {
+            case 'effects':
+                await this._prepareEffectsContext(context, options);
+                break;
+        }
+        return context;
+    }
+
+    /**
+     * Prepare render context for the Effect part.
+     * @param {ApplicationRenderContext} context
+     * @param {ApplicationRenderOptions} options
+     * @returns {Promise<void>}
+     * @protected
+     */
+    async _prepareEffectsContext(context, _options) {
+        context.effects = {
+            actives: [],
+            inactives: []
+        };
+
+        for (const effect of this.actor.allApplicableEffects()) {
+            const list = effect.active ? context.effects.actives : context.effects.inactives;
+            list.push(effect);
+        }
+    }
+
+    /* -------------------------------------------- */
+    /*  Context Menu                                */
+    /* -------------------------------------------- */
+
+    /**
+     * Get the set of ContextMenu options for Features.
+     * @returns {import('@client/applications/ux/context-menu.mjs').ContextMenuEntry[]} - The Array of context options passed to the ContextMenu instance
+     * @this {DHSheetV2}
+     * @protected
+     */
+    static #getFeatureContextOptions() {
+        return this._getContextMenuCommonOptions.call(this, { usable: true, toChat: true });
+    }
+
+    /* -------------------------------------------- */
+    /*  Application Clicks Actions                  */
+    /* -------------------------------------------- */
+
     /**
      * Open the Actor Setting Sheet
      * @type {ApplicationClickAction}
@@ -49,4 +114,50 @@ export default class DHBaseActorSheet extends DHApplicationMixin(ActorSheetV2) {
     static async #openSettings() {
         await this.settingSheet.render({ force: true });
     }
+
+    /**
+     * Send Experience to Chat
+     * @type {ApplicationClickAction}
+     */
+    static async #sendExpToChat(_, button) {
+        const experience = this.document.system.experiences[button.dataset.id];
+
+        const systemData = {
+            name: game.i18n.localize('DAGGERHEART.GENERAL.Experience.single'),
+            description: `${experience.name} ${experience.value.signedString()}`
+        };
+
+        foundry.documents.ChatMessage.implementation.create({
+            type: 'abilityUse',
+            user: game.user.id,
+            system: systemData,
+            content: await foundry.applications.handlebars.renderTemplate(
+                'systems/daggerheart/templates/ui/chat/ability-use.hbs',
+                systemData
+            )
+        });
+    }
+
+    /* -------------------------------------------- */
+    /*  Application Drag/Drop                       */
+    /* -------------------------------------------- */
+
+    /**
+     * On dragStart on the item.
+     * @param {DragEvent} event - The drag event
+     */
+    async _onDragStart(event) {
+        const attackItem = event.currentTarget.closest('.inventory-item[data-type="attack"]');
+
+        if (attackItem) {
+            const attackData = {
+                type: 'Attack',
+                actorUuid: this.document.uuid,
+                img: this.document.system.attack.img,
+                fromInternal: true
+            };
+            event.dataTransfer.setData('text/plain', JSON.stringify(attackData));
+            event.dataTransfer.setDragImage(attackItem.querySelector('img'), 60, 0);
+        }
+    }
 }

module/applications/sheets/api/base-item.mjs

@@ -1,4 +1,4 @@
-import DHActionConfig from '../../sheets-configs/action-config.mjs';
+import { getDocFromElement } from '../../../helpers/utils.mjs';
 import DHApplicationMixin from './application-mixin.mjs';
 
 const { ItemSheetV2 } = foundry.applications.sheets;
@@ -15,20 +15,31 @@ export default class DHBaseItemSheet extends DHApplicationMixin(ItemSheetV2) {
     static DEFAULT_OPTIONS = {
         classes: ['item'],
         position: { width: 600 },
+        window: { resizable: true },
         form: {
             submitOnChange: true
         },
         actions: {
-            addAction: DHBaseItemSheet.#addAction,
-            editAction: DHBaseItemSheet.#editAction,
             removeAction: DHBaseItemSheet.#removeAction,
             addFeature: DHBaseItemSheet.#addFeature,
-            editFeature: DHBaseItemSheet.#editFeature,
-            removeFeature: DHBaseItemSheet.#removeFeature
+            deleteFeature: DHBaseItemSheet.#deleteFeature,
+            addResource: DHBaseItemSheet.#addResource,
+            removeResource: DHBaseItemSheet.#removeResource
         },
         dragDrop: [
             { dragSelector: null, dropSelector: '.tab.features .drop-section' },
-            { dragSelector: '.feature-item', dropSelector: null }
+            { dragSelector: '.feature-item', dropSelector: null },
+            { dragSelector: '.action-item', dropSelector: null }
+        ],
+        contextMenus: [
+            {
+                handler: DHBaseItemSheet.#getFeatureContextOptions,
+                selector: '[data-item-uuid][data-type="feature"]',
+                options: {
+                    parentClassHooks: false,
+                    fixed: true
+                }
+            }
         ]
     };
 
@@ -37,7 +48,7 @@ export default class DHBaseItemSheet extends DHApplicationMixin(ItemSheetV2) {
     /** @inheritdoc */
     static TABS = {
         primary: {
-            tabs: [{ id: 'description' }, { id: 'settings' }, { id: 'actions' }],
+            tabs: [{ id: 'description' }, { id: 'settings' }, { id: 'actions' }, { id: 'effects' }],
             initial: 'description',
             labelPrefix: 'DAGGERHEART.GENERAL.Tabs'
         }
@@ -48,8 +59,8 @@ export default class DHBaseItemSheet extends DHApplicationMixin(ItemSheetV2) {
     /* -------------------------------------------- */
 
     /**@inheritdoc */
-    async _preparePartContext(partId, context) {
-        await super._preparePartContext(partId, context);
+    async _preparePartContext(partId, context, options) {
+        await super._preparePartContext(partId, context, options);
         const { TextEditor } = foundry.applications.ux;
 
         switch (partId) {
@@ -61,77 +72,78 @@ export default class DHBaseItemSheet extends DHApplicationMixin(ItemSheetV2) {
                     secrets: this.item.isOwner
                 });
                 break;
+            case 'effects':
+                await this._prepareEffectsContext(context, options);
+                break;
+            case 'features':
+                context.isGM = game.user.isGM;
+                break;
         }
 
         return context;
     }
 
-    /* -------------------------------------------- */
-    /*  Application Clicks Actions                  */
-    /* -------------------------------------------- */
-
     /**
-     * Render a dialog prompting the user to select an action type.
-     *
-     * @returns {Promise<object>} An object containing the selected action type.
+     * Prepare render context for the Effect part.
+     * @param {ApplicationRenderContext} context
+     * @param {ApplicationRenderOptions} options
+     * @returns {Promise<void>}
+     * @protected
      */
-    static async selectActionType() {
-        const content = await foundry.applications.handlebars.renderTemplate(
-                'systems/daggerheart/templates/actionTypes/actionType.hbs',
-                { types: CONFIG.DH.ACTIONS.actionTypes }
-            ),
-            title = 'Select Action Type';
+    async _prepareEffectsContext(context, _options) {
+        context.effects = {
+            actives: [],
+            inactives: []
+        };
 
-        return foundry.applications.api.DialogV2.prompt({
-            window: { title },
-            content,
-            ok: {
-                label: title,
-                callback: (event, button, dialog) => button.form.elements.type.value
-            }
-        });
-    }
-
-    /**
-     * Add a new action to the item, prompting the user for its type.
-     * @type {ApplicationClickAction}
-     */
-    static async #addAction(_event, _button) {
-        const actionType = await DHBaseItemSheet.selectActionType();
-        if (!actionType) return;
-        try {
-            const cls =
-                    game.system.api.models.actions.actionsTypes[actionType] ??
-                    game.system.api.models.actions.actionsTypes.attack,
-                action = new cls(
-                    {
-                        _id: foundry.utils.randomID(),
-                        type: actionType,
-                        name: game.i18n.localize(CONFIG.DH.ACTIONS.actionTypes[actionType].name),
-                        ...cls.getSourceConfig(this.document)
-                    },
-                    {
-                        parent: this.document
-                    }
-                );
-            await this.document.update({ 'system.actions': [...this.document.system.actions, action] });
-            await new DHActionConfig(this.document.system.actions[this.document.system.actions.length - 1]).render({
-                force: true
-            });
-        } catch (error) {
-            console.log(error);
+        for (const effect of this.item.effects) {
+            const list = effect.active ? context.effects.actives : context.effects.inactives;
+            list.push(effect);
         }
     }
 
+    /* -------------------------------------------- */
+    /*  Context Menu                                */
+    /* -------------------------------------------- */
+
     /**
-     * Edit an existing action on the item
-     * @type {ApplicationClickAction}
+     * Get the set of ContextMenu options for Features.
+     * @returns {import('@client/applications/ux/context-menu.mjs').ContextMenuEntry[]} - The Array of context options passed to the ContextMenu instance
+     * @this {DHSheetV2}
+     * @protected
      */
-    static async #editAction(_event, button) {
-        const action = this.document.system.actions[button.dataset.index];
-        await new DHActionConfig(action).render({ force: true });
+    static #getFeatureContextOptions() {
+        const options = this._getContextMenuCommonOptions({ usable: true, toChat: true, deletable: false });
+        options.push({
+            name: 'CONTROLS.CommonDelete',
+            icon: '<i class="fa-solid fa-trash"></i>',
+            callback: async target => {
+                const feature = getDocFromElement(target);
+                if (!feature) return;
+                const confirmed = await foundry.applications.api.DialogV2.confirm({
+                    window: {
+                        title: game.i18n.format('DAGGERHEART.APPLICATIONS.DeleteConfirmation.title', {
+                            type: game.i18n.localize(`TYPES.Item.feature`),
+                            name: feature.name
+                        })
+                    },
+                    content: game.i18n.format('DAGGERHEART.APPLICATIONS.DeleteConfirmation.text', {
+                        name: feature.name
+                    })
+                });
+                if (!confirmed) return;
+                await this.document.update({
+                    'system.features': this.document.system.toObject().features.filter(uuid => uuid !== feature.uuid)
+                });
+            }
+        });
+        return options;
     }
 
+    /* -------------------------------------------- */
+    /*  Application Clicks Actions                  */
+    /* -------------------------------------------- */
+
     /**
      * Remove an action from the item.
      * @type {ApplicationClickAction}
@@ -139,6 +151,21 @@ export default class DHBaseItemSheet extends DHApplicationMixin(ItemSheetV2) {
     static async #removeAction(event, button) {
         event.stopPropagation();
         const actionIndex = button.closest('[data-index]').dataset.index;
+        const action = this.document.system.actions[actionIndex];
+
+        if (!event.shiftKey) {
+            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: action.name
+                    })
+                },
+                content: game.i18n.format('DAGGERHEART.APPLICATIONS.DeleteConfirmation.text', { name: action.name })
+            });
+            if (!confirmed) return;
+        }
+
         await this.document.update({
             'system.actions': this.document.system.actions.filter((_, index) => index !== Number.parseInt(actionIndex))
         });
@@ -148,43 +175,49 @@ export default class DHBaseItemSheet extends DHApplicationMixin(ItemSheetV2) {
      * Add a new feature to the item, prompting the user for its type.
      * @type {ApplicationClickAction}
      */
-    static async #addFeature(_event, _button) {
-        const feature = await game.items.documentClass.create({
-            type: 'feature',
-            name: game.i18n.format('DOCUMENT.New', { type: game.i18n.localize('TYPES.Item.feature') })
+    static async #addFeature(_, target) {
+        const { type } = target.dataset;
+        const cls = foundry.documents.Item.implementation;
+        const feature = await cls.create({
+            'type': 'feature',
+            'name': cls.defaultName({ type: 'feature' }),
+            'system.subType': CONFIG.DH.ITEM.featureSubTypes[type]
         });
         await this.document.update({
-            'system.features': [...this.document.system.features.filter(x => x).map(x => x.uuid), feature.uuid]
+            'system.features': [...this.document.system.features, feature].map(f => f.uuid)
         });
     }
 
-    /**
-     * Edit an existing feature on the item
-     * @type {ApplicationClickAction}
-     */
-    static async #editFeature(_event, button) {
-        const target = button.closest('.feature-item');
-        const feature = this.document.system.features.find(x => x?.id === target.id);
-        if (!feature) {
-            ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.notifications.featureIsMissing'));
-            return;
-        }
-
-        feature.sheet.render(true);
-    }
-
     /**
      * Remove a feature from the item.
      * @type {ApplicationClickAction}
      */
-    static async #removeFeature(event, button) {
-        event.stopPropagation();
-        const target = button.closest('.feature-item');
-
+    static async #deleteFeature(_, target) {
+        const feature = getDocFromElement(target);
+        if (!feature) return ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.Notifications.featureIsMissing'));
+        await feature.update({ 'system.subType': null });
         await this.document.update({
-            'system.features': this.document.system.features
-                .filter(feature => feature && feature.id !== target.id)
-                .map(x => x.uuid)
+            'system.features': this.document.system.features.map(x => x.uuid).filter(uuid => uuid !== feature.uuid)
+        });
+    }
+
+    /**
+     * Add a resource to the item.
+     * @type {ApplicationClickAction}
+     */
+    static async #addResource() {
+        await this.document.update({
+            'system.resource': { type: 'simple', value: 0 }
+        });
+    }
+
+    /**
+     * Remove the resource from the item.
+     * @type {ApplicationClickAction}
+     */
+    static async #removeResource() {
+        await this.document.update({
+            'system.resource': null
         });
     }
 
@@ -202,13 +235,30 @@ export default class DHBaseItemSheet extends DHApplicationMixin(ItemSheetV2) {
         if (featureItem) {
             const feature = this.document.system.features.find(x => x?.id === featureItem.id);
             if (!feature) {
-                ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.notifications.featureIsMissing'));
+                ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.Notifications.featureIsMissing'));
                 return;
             }
 
             const featureData = { type: 'Item', data: { ...feature.toObject(), _id: null }, fromInternal: true };
             event.dataTransfer.setData('text/plain', JSON.stringify(featureData));
             event.dataTransfer.setDragImage(featureItem.querySelector('img'), 60, 0);
+        } else {
+            const actionItem = event.currentTarget.closest('.action-item');
+            if (actionItem) {
+                const action = this.document.system.actions[actionItem.dataset.index];
+                if (!action) {
+                    ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.Notifications.actionIsMissing'));
+                    return;
+                }
+
+                const actionData = {
+                    type: 'Action',
+                    data: { ...action.toObject(), id: action.id, itemUuid: this.document.uuid },
+                    fromInternal: true
+                };
+                event.dataTransfer.setData('text/plain', JSON.stringify(actionData));
+                event.dataTransfer.setDragImage(actionItem.querySelector('img'), 60, 0);
+            }
         }
     }
 

module/applications/sheets/api/heritage-sheet.mjs

@@ -10,10 +10,6 @@ export default class DHHeritageSheet extends DHBaseItemSheet {
     static PARTS = {
         tabs: { template: 'systems/daggerheart/templates/sheets/global/tabs/tab-navigation.hbs' },
         description: { template: 'systems/daggerheart/templates/sheets/global/tabs/tab-description.hbs' },
-        feature: {
-            template: 'systems/daggerheart/templates/sheets/global/tabs/tab-features.hbs',
-            scrollable: ['.feature']
-        },
         effects: {
             template: 'systems/daggerheart/templates/sheets/global/tabs/tab-effects.hbs',
             scrollable: ['.effects']

module/applications/sheets/api/item-attachment-sheet.mjs

@@ -0,0 +1,85 @@
+export default function ItemAttachmentSheet(Base) {
+    return class extends Base {
+        static DEFAULT_OPTIONS = {
+            ...super.DEFAULT_OPTIONS,
+            dragDrop: [
+                ...(super.DEFAULT_OPTIONS.dragDrop || []),
+                { dragSelector: null, dropSelector: '.attachments-section' }
+            ],
+            actions: {
+                ...super.DEFAULT_OPTIONS.actions,
+                removeAttachment: this.#removeAttachment
+            }
+        };
+
+        static PARTS = {
+            ...super.PARTS,
+            attachments: {
+                template: 'systems/daggerheart/templates/sheets/global/tabs/tab-attachments.hbs',
+                scrollable: ['.attachments']
+            }
+        };
+
+        static TABS = {
+            ...super.TABS,
+            primary: {
+                ...super.TABS?.primary,
+                tabs: [...(super.TABS?.primary?.tabs || []), { id: 'attachments' }],
+                initial: super.TABS?.primary?.initial || 'description',
+                labelPrefix: super.TABS?.primary?.labelPrefix || 'DAGGERHEART.GENERAL.Tabs'
+            }
+        };
+
+        async _preparePartContext(partId, context) {
+            await super._preparePartContext(partId, context);
+
+            if (partId === 'attachments') {
+                context.attachedItems = await prepareAttachmentContext(this.document);
+            }
+
+            return context;
+        }
+
+        async _onDrop(event) {
+            const data = TextEditor.getDragEventData(event);
+
+            const attachmentsSection = event.target.closest('.attachments-section');
+            if (!attachmentsSection) return super._onDrop(event);
+
+            event.preventDefault();
+            event.stopPropagation();
+
+            const item = await Item.implementation.fromDropData(data);
+            if (!item) return;
+
+            // Call the data model's public method
+            await this.document.system.addAttachment(item);
+        }
+
+        static async #removeAttachment(event, target) {
+            // Call the data model's public method
+            await this.document.system.removeAttachment(target.dataset.uuid);
+        }
+
+        async _preparePartContext(partId, context) {
+            await super._preparePartContext(partId, context);
+
+            if (partId === 'attachments') {
+                // Keep this simple UI preparation in the mixin
+                const attachedUUIDs = this.document.system.attached;
+                context.attachedItems = await Promise.all(
+                    attachedUUIDs.map(async uuid => {
+                        const item = await fromUuid(uuid);
+                        return {
+                            uuid: uuid,
+                            name: item?.name || 'Unknown Item',
+                            img: item?.img || 'icons/svg/item-bag.svg'
+                        };
+                    })
+                );
+            }
+
+            return context;
+        }
+    };
+}

module/applications/sheets/items/ancestry.mjs

@@ -3,12 +3,80 @@ import DHHeritageSheet from '../api/heritage-sheet.mjs';
 export default class AncestrySheet extends DHHeritageSheet {
     /**@inheritdoc */
     static DEFAULT_OPTIONS = {
-        classes: ['ancestry']
+        classes: ['ancestry'],
+        actions: {
+            editFeature: AncestrySheet.#editFeature,
+            removeFeature: AncestrySheet.#removeFeature
+        },
+        dragDrop: [{ dragSelector: null, dropSelector: '.tab.features .drop-section' }]
     };
 
     /**@inheritdoc */
     static PARTS = {
         header: { template: 'systems/daggerheart/templates/sheets/items/ancestry/header.hbs' },
-        ...super.PARTS
+        ...super.PARTS,
+        features: { template: 'systems/daggerheart/templates/sheets/items/ancestry/features.hbs' }
     };
+
+    /* -------------------------------------------- */
+    /*  Application Clicks Actions                  */
+    /* -------------------------------------------- */
+
+    /**
+     * Edit an existing feature on the item
+     * @type {ApplicationClickAction}
+     */
+    static async #editFeature(_event, button) {
+        const target = button.closest('.feature-item');
+        const feature = this.document.system[`${target.dataset.type}Feature`];
+        if (!feature || Object.keys(feature).length === 0) {
+            ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.Notifications.featureIsMissing'));
+            return;
+        }
+
+        feature.sheet.render(true);
+    }
+
+    /**
+     * Remove a feature from the item.
+     * @type {ApplicationClickAction}
+     */
+    static async #removeFeature(event, button) {
+        event.stopPropagation();
+        const target = button.closest('.feature-item');
+        const feature = this.document.system[`${target.dataset.type}Feature`];
+
+        if (feature) await feature.update({ 'system.subType': null });
+        await this.document.update({
+            'system.features': this.document.system.features.filter(x => x && x.uuid !== feature.uuid).map(x => x.uuid)
+        });
+    }
+
+    /* -------------------------------------------- */
+    /*  Application Drag/Drop                       */
+    /* -------------------------------------------- */
+
+    /**
+     * On drop on the item.
+     * @param {DragEvent} event - The drag event
+     */
+    async _onDrop(event) {
+        event.stopPropagation();
+        const data = foundry.applications.ux.TextEditor.implementation.getDragEventData(event);
+
+        const item = await fromUuid(data.uuid);
+        if (item?.type === 'feature') {
+            const subType = event.target.closest('.primary-feature') ? 'primary' : 'secondary';
+            if (item.system.subType && item.system.subType !== CONFIG.DH.ITEM.featureSubTypes[subType]) {
+                const error = subType === 'primary' ? 'featureNotPrimary' : 'featureNotSecondary';
+                ui.notifications.warn(game.i18n.localize(`DAGGERHEART.UI.Notifications.${error}`));
+                return;
+            }
+
+            await item.update({ 'system.subType': subType });
+            await this.document.update({
+                'system.features': [...this.document.system.features.map(x => x.uuid), item.uuid]
+            });
+        }
+    }
 }

module/applications/sheets/items/armor.mjs

@@ -1,10 +1,10 @@
 import DHBaseItemSheet from '../api/base-item.mjs';
+import ItemAttachmentSheet from '../api/item-attachment-sheet.mjs';
 
-export default class ArmorSheet extends DHBaseItemSheet {
+export default class ArmorSheet extends ItemAttachmentSheet(DHBaseItemSheet) {
     /**@inheritdoc */
     static DEFAULT_OPTIONS = {
         classes: ['armor'],
-        dragDrop: [{ dragSelector: null, dropSelector: null }],
         tagifyConfigs: [
             {
                 selector: '.features-input',
@@ -26,7 +26,12 @@ export default class ArmorSheet extends DHBaseItemSheet {
         settings: {
             template: 'systems/daggerheart/templates/sheets/items/armor/settings.hbs',
             scrollable: ['.settings']
-        }
+        },
+        effects: {
+            template: 'systems/daggerheart/templates/sheets/global/tabs/tab-effects.hbs',
+            scrollable: ['.effects']
+        },
+        ...super.PARTS
     };
 
     /**@inheritdoc */
@@ -35,7 +40,7 @@ export default class ArmorSheet extends DHBaseItemSheet {
 
         switch (partId) {
             case 'settings':
-                context.features = this.document.system.features.map(x => x.value);
+                context.features = this.document.system.armorFeatures.map(x => x.value);
                 break;
         }
 
@@ -47,6 +52,6 @@ export default class ArmorSheet extends DHBaseItemSheet {
      * @param {Array<Object>} selectedOptions - The currently selected tag objects.
      */
     static async #onFeatureSelect(selectedOptions) {
-        await this.document.update({ 'system.features': selectedOptions.map(x => ({ value: x.value })) });
+        await this.document.update({ 'system.armorFeatures': selectedOptions.map(x => ({ value: x.value })) });
     }
 }

module/applications/sheets/items/beastform.mjs

@@ -1,4 +1,5 @@
 import DHBaseItemSheet from '../api/base-item.mjs';
+import Tagify from '@yaireo/tagify';
 
 export default class BeastformSheet extends DHBaseItemSheet {
     /**@inheritdoc */
@@ -15,6 +16,7 @@ export default class BeastformSheet extends DHBaseItemSheet {
             template: 'systems/daggerheart/templates/sheets/global/tabs/tab-features.hbs',
             scrollable: ['.features']
         },
+        advanced: { template: 'systems/daggerheart/templates/sheets/items/beastform/advanced.hbs' },
         effects: {
             template: 'systems/daggerheart/templates/sheets/global/tabs/tab-effects.hbs',
             scrollable: ['.effects']
@@ -23,16 +25,77 @@ export default class BeastformSheet extends DHBaseItemSheet {
 
     static TABS = {
         primary: {
-            tabs: [{ id: 'settings' }, { id: 'features' }, { id: 'effects' }],
+            tabs: [{ id: 'settings' }, { id: 'features' }, { id: 'advanced' }, { id: 'effects' }],
             initial: 'settings',
             labelPrefix: 'DAGGERHEART.GENERAL.Tabs'
         }
     };
 
+    _attachPartListeners(partId, htmlElement, options) {
+        super._attachPartListeners(partId, htmlElement, options);
+
+        const advantageOnInput = htmlElement.querySelector('.advantageon-input');
+        if (advantageOnInput) {
+            const tagifyElement = new Tagify(advantageOnInput, {
+                tagTextProp: 'name',
+                templates: {
+                    tag(tagData) {
+                        return `<tag
+                                    contenteditable='false'
+                                    spellcheck='false'
+                                    tabIndex="${this.settings.a11y.focusableTags ? 0 : -1}"
+                                    class="${this.settings.classNames.tag} ${tagData.class ? tagData.class : ''}"
+                                    ${this.getAttributes(tagData)}> 
+                            <x class="${this.settings.classNames.tagX}" role='button' aria-label='remove tag'></x>
+                            <div>
+                                <span class="${this.settings.classNames.tagText}">${tagData[this.settings.tagTextProp] || tagData.value}</span>
+                                ${tagData.src ? `<img src="${tagData.src}"></i>` : ''}
+                            </div>
+                        </tag>`;
+                    }
+                }
+            });
+            tagifyElement.on('add', this.advantageOnAdd.bind(this));
+            tagifyElement.on('remove', this.advantageOnRemove.bind(this));
+        }
+    }
+
     /**@inheritdoc */
-    async _preparePartContext(partId, context) {
-        await super._preparePartContext(partId, context);
+    async _preparePartContext(partId, context, options) {
+        await super._preparePartContext(partId, context, options);
+
+        switch (partId) {
+            case 'settings':
+                context.advantageOn = JSON.stringify(
+                    Object.keys(context.document.system.advantageOn).map(key => ({
+                        value: key,
+                        name: context.document.system.advantageOn[key].value
+                    }))
+                );
+                break;
+            case 'effects':
+                context.effects.actives = context.effects.actives.map(effect => {
+                    const data = effect.toObject();
+                    data.id = effect.id;
+                    if (effect.type === 'beastform') data.mandatory = true;
+
+                    return data;
+                });
+                break;
+        }
 
         return context;
     }
+
+    async advantageOnAdd(event) {
+        await this.document.update({
+            [`system.advantageOn.${foundry.utils.randomID()}`]: { value: event.detail.data.value }
+        });
+    }
+
+    async advantageOnRemove(event) {
+        await this.document.update({
+            [`system.advantageOn.-=${event.detail.data.value}`]: null
+        });
+    }
 }

module/applications/sheets/items/class.mjs

@@ -9,11 +9,7 @@ export default class ClassSheet extends DHBaseItemSheet {
         position: { width: 700 },
         actions: {
             removeItemFromCollection: ClassSheet.#removeItemFromCollection,
-            removeSuggestedItem: ClassSheet.#removeSuggestedItem,
-            viewDoc: ClassSheet.#viewDoc,
-            addFeature: this.addFeature,
-            editFeature: this.editFeature,
-            deleteFeature: this.deleteFeature
+            removeSuggestedItem: ClassSheet.#removeSuggestedItem
         },
         tagifyConfigs: [
             {
@@ -46,13 +42,17 @@ export default class ClassSheet extends DHBaseItemSheet {
         settings: {
             template: 'systems/daggerheart/templates/sheets/items/class/settings.hbs',
             scrollable: ['.settings']
+        },
+        effects: {
+            template: 'systems/daggerheart/templates/sheets/global/tabs/tab-effects.hbs',
+            scrollable: ['.effects']
         }
     };
 
     /** @inheritdoc */
     static TABS = {
         primary: {
-            tabs: [{ id: 'description' }, { id: 'features' }, { id: 'settings' }],
+            tabs: [{ id: 'description' }, { id: 'features' }, { id: 'settings' }, { id: 'effects' }],
             initial: 'description',
             labelPrefix: 'DAGGERHEART.GENERAL.Tabs'
         }
@@ -78,6 +78,7 @@ export default class ClassSheet extends DHBaseItemSheet {
     /* -------------------------------------------- */
 
     async _onDrop(event) {
+        event.stopPropagation();
         const data = TextEditor.getDragEventData(event);
         const item = await fromUuid(data.uuid);
         const target = event.target.closest('fieldset.drop-section');
@@ -85,6 +86,28 @@ export default class ClassSheet extends DHBaseItemSheet {
             await this.document.update({
                 'system.subclasses': [...this.document.system.subclasses.map(x => x.uuid), item.uuid]
             });
+        } else if (item.type === 'feature') {
+            if (target.classList.contains('hope-feature')) {
+                if (item.system.subType && item.system.subType !== CONFIG.DH.ITEM.featureSubTypes.hope) {
+                    ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.Notifications.featureNotHope'));
+                    return;
+                }
+
+                await item.update({ 'system.subType': CONFIG.DH.ITEM.featureSubTypes.hope });
+                await this.document.update({
+                    'system.features': [...this.document.system.features.map(x => x.uuid), item.uuid]
+                });
+            } else if (target.classList.contains('class-feature')) {
+                if (item.system.subType && item.system.subType !== CONFIG.DH.ITEM.featureSubTypes.class) {
+                    ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.Notifications.featureNotClass'));
+                    return;
+                }
+
+                await item.update({ 'system.subType': CONFIG.DH.ITEM.featureSubTypes.class });
+                await this.document.update({
+                    'system.features': [...this.document.system.features.map(x => x.uuid), item.uuid]
+                });
+            }
         } else if (item.type === 'weapon') {
             if (target.classList.contains('primary-weapon-section')) {
                 if (!this.document.system.characterGuide.suggestedPrimaryWeapon && !item.system.secondary)
@@ -144,7 +167,7 @@ export default class ClassSheet extends DHBaseItemSheet {
     static async #removeItemFromCollection(_event, element) {
         const { uuid, target } = element.dataset;
         const prop = foundry.utils.getProperty(this.document.system, target);
-        await this.document.update({ [target]: prop.filter(i => i.uuid !== uuid) });
+        await this.document.update({ [`system.${target}`]: prop.filter(i => i.uuid !== uuid) });
     }
 
     /**
@@ -156,56 +179,4 @@ export default class ClassSheet extends DHBaseItemSheet {
         const { target } = element.dataset;
         await this.document.update({ [`system.characterGuide.${target}`]: null });
     }
-
-    /**
-     * Open the sheet of a item by UUID.
-     * @param {PointerEvent} _event -
-     * @param {HTMLElement} button
-     */
-    static async #viewDoc(_event, button) {
-        const doc = await fromUuid(button.dataset.uuid);
-        doc.sheet.render({ force: true });
-    }
-
-    getActionPath(type) {
-        return type === 'hope' ? 'hopeFeatures' : 'classFeatures';
-    }
-
-    static async addFeature(_, target) {
-        const actionPath = this.getActionPath(target.dataset.type);
-        const feature = await game.items.documentClass.create({
-            type: 'feature',
-            name: game.i18n.format('DOCUMENT.New', { type: game.i18n.localize('TYPES.Item.feature') })
-        });
-        await this.document.update({
-            [`system.${actionPath}`]: [
-                ...this.document.system[actionPath].filter(x => x).map(x => x.uuid),
-                feature.uuid
-            ]
-        });
-    }
-
-    static async editFeature(_, button) {
-        const target = button.closest('.feature-item');
-        const actionPath = this.getActionPath(button.dataset.type);
-        const feature = this.document.system[actionPath].find(x => x?.id === target.dataset.featureId);
-        if (!feature) {
-            ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.notifications.featureIsMissing'));
-            return;
-        }
-
-        feature.sheet.render(true);
-    }
-
-    static async deleteFeature(event, button) {
-        event.stopPropagation();
-        const target = button.closest('.feature-item');
-        const actionPath = this.getActionPath(button.dataset.type);
-
-        await this.document.update({
-            [`system.${actionPath}`]: this.document.system[actionPath]
-                .filter(feature => feature && feature.id !== target.dataset.featureId)
-                .map(x => x.uuid)
-        });
-    }
 }

module/applications/sheets/items/community.mjs

@@ -9,6 +9,10 @@ export default class CommunitySheet extends DHHeritageSheet {
     /**@inheritdoc */
     static PARTS = {
         header: { template: 'systems/daggerheart/templates/sheets/items/community/header.hbs' },
-        ...super.PARTS
+        ...super.PARTS,
+        features: {
+            template: 'systems/daggerheart/templates/sheets/global/tabs/tab-features.hbs',
+            scrollable: ['.feature']
+        }
     };
 }

module/applications/sheets/items/consumable.mjs

@@ -19,6 +19,10 @@ export default class ConsumableSheet extends DHBaseItemSheet {
         settings: {
             template: 'systems/daggerheart/templates/sheets/items/consumable/settings.hbs',
             scrollable: ['.settings']
+        },
+        effects: {
+            template: 'systems/daggerheart/templates/sheets/global/tabs/tab-effects.hbs',
+            scrollable: ['.effects']
         }
     };
 }

module/applications/sheets/items/feature.mjs

@@ -1,5 +1,3 @@
-import { actionsTypes } from '../../../data/action/_module.mjs';
-import DHActionConfig from '../../sheets-configs/action-config.mjs';
 import DHBaseItemSheet from '../api/base-item.mjs';
 
 export default class FeatureSheet extends DHBaseItemSheet {
@@ -7,13 +5,7 @@ export default class FeatureSheet extends DHBaseItemSheet {
     static DEFAULT_OPTIONS = {
         id: 'daggerheart-feature',
         classes: ['feature'],
-        position: { height: 600 },
-        window: { resizable: true },
-        actions: {
-            addAction: FeatureSheet.#addAction,
-            editAction: FeatureSheet.#editAction,
-            removeAction: FeatureSheet.#removeAction
-        }
+        actions: {}
     };
 
     /**@override */
@@ -21,6 +13,7 @@ export default class FeatureSheet extends DHBaseItemSheet {
         header: { template: 'systems/daggerheart/templates/sheets/items/feature/header.hbs' },
         tabs: { template: 'systems/daggerheart/templates/sheets/global/tabs/tab-navigation.hbs' },
         description: { template: 'systems/daggerheart/templates/sheets/global/tabs/tab-description.hbs' },
+        settings: { template: 'systems/daggerheart/templates/sheets/items/feature/settings.hbs' },
         actions: {
             template: 'systems/daggerheart/templates/sheets/global/tabs/tab-actions.hbs',
             scrollable: ['.actions']
@@ -34,97 +27,9 @@ export default class FeatureSheet extends DHBaseItemSheet {
     /**@override */
     static TABS = {
         primary: {
-            tabs: [{ id: 'description' }, { id: 'actions' }, { id: 'effects' }],
+            tabs: [{ id: 'description' }, { id: 'settings' }, { id: 'actions' }, { id: 'effects' }],
             initial: 'description',
             labelPrefix: 'DAGGERHEART.GENERAL.Tabs'
         }
     };
-
-    /* -------------------------------------------- */
-
-    /**@inheritdoc */
-    async _prepareContext(_options) {
-        const context = await super._prepareContext(_options);
-
-        return context;
-    }
-
-    /* -------------------------------------------- */
-    /*  Application Clicks Actions                  */
-    /* -------------------------------------------- */
-
-    /**
-     * Render a dialog prompting the user to select an action type.
-     *
-     * @returns {Promise<object>} An object containing the selected action type.
-     */
-    static async selectActionType() {
-        const content = await foundry.applications.handlebars.renderTemplate(
-                'systems/daggerheart/templates/actionTypes/actionType.hbs',
-                { types: CONFIG.DH.ACTIONS.actionTypes }
-            ),
-            title = 'Select Action Type';
-
-        return foundry.applications.api.DialogV2.prompt({
-            window: { title },
-            content,
-            ok: {
-                label: title,
-                callback: (event, button, dialog) => button.form.elements.type.value
-            }
-        });
-    }
-
-    /**
-     * Add a new action to the item, prompting the user for its type.
-     * @param {PointerEvent} _event - The originating click event
-     * @param {HTMLElement} _button - The capturing HTML element which defines the [data-action="addAction"]
-     */
-    static async #addAction(_event, _button) {
-        const actionType = await FeatureSheet.selectActionType();
-        if (!actionType) return;
-        try {
-            const cls = actionsTypes[actionType] ?? actionsTypes.attack,
-                action = new cls(
-                    {
-                        _id: foundry.utils.randomID(),
-                        type: actionType,
-                        name: game.i18n.localize(CONFIG.DH.ACTIONS.actionTypes[actionType].name),
-                        ...cls.getSourceConfig(this.document)
-                    },
-                    {
-                        parent: this.document
-                    }
-                );
-            await this.document.update({ 'system.actions': [...this.document.system.actions, action] });
-            await new DHActionConfig(this.document.system.actions[this.document.system.actions.length - 1]).render({
-                force: true
-            });
-        } catch (error) {
-            console.log(error);
-        }
-    }
-
-    /**
-     * Edit an existing action on the item
-     * @param {PointerEvent} _event - The originating click event
-     * @param {HTMLElement} button - The capturing HTML element which defines the [data-action="editAction"]
-     */
-    static async #editAction(_event, button) {
-        const action = this.document.system.actions[button.dataset.index];
-        await new DHActionConfig(action).render({ force: true });
-    }
-
-    /**
-     * Remove an action from the item.
-     * @param {PointerEvent} event - The originating click event
-     * @param {HTMLElement} button - The capturing HTML element which defines the [data-action="removeAction"]
-     */
-    static async #removeAction(event, button) {
-        event.stopPropagation();
-        const actionIndex = button.closest('[data-index]').dataset.index;
-        await this.document.update({
-            'system.actions': this.document.system.actions.filter((_, index) => index !== Number.parseInt(actionIndex))
-        });
-    }
 }

module/applications/sheets/items/miscellaneous.mjs

@@ -19,6 +19,10 @@ export default class MiscellaneousSheet extends DHBaseItemSheet {
         settings: {
             template: 'systems/daggerheart/templates/sheets/items/miscellaneous/settings.hbs',
             scrollable: ['.settings']
+        },
+        effects: {
+            template: 'systems/daggerheart/templates/sheets/global/tabs/tab-effects.hbs',
+            scrollable: ['.effects']
         }
     };
 }

module/applications/sheets/items/subclass.mjs

@@ -6,11 +6,7 @@ export default class SubclassSheet extends DHBaseItemSheet {
         classes: ['subclass'],
         position: { width: 600 },
         window: { resizable: false },
-        actions: {
-            addFeature: this.addFeature,
-            editFeature: this.editFeature,
-            deleteFeature: this.deleteFeature
-        }
+        actions: {}
     };
 
     /**@override */
@@ -25,53 +21,29 @@ export default class SubclassSheet extends DHBaseItemSheet {
         settings: {
             template: 'systems/daggerheart/templates/sheets/items/subclass/settings.hbs',
             scrollable: ['.settings']
+        },
+        effects: {
+            template: 'systems/daggerheart/templates/sheets/global/tabs/tab-effects.hbs',
+            scrollable: ['.effects']
         }
     };
 
     /** @inheritdoc */
     static TABS = {
         primary: {
-            tabs: [{ id: 'description' }, { id: 'features' }, { id: 'settings' }],
+            tabs: [{ id: 'description' }, { id: 'features' }, { id: 'settings' }, { id: 'effects' }],
             initial: 'description',
             labelPrefix: 'DAGGERHEART.GENERAL.Tabs'
         }
     };
 
-    static async addFeature(_, target) {
-        const feature = await game.items.documentClass.create({
-            type: 'feature',
-            name: game.i18n.format('DOCUMENT.New', { type: game.i18n.localize('TYPES.Item.feature') })
-        });
-        await this.document.update({
-            [`system.${target.dataset.type}`]: feature.uuid
-        });
-    }
-
-    static async editFeature(_, button) {
-        const feature = this.document.system[button.dataset.type];
-        if (!feature) {
-            ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.notifications.featureIsMissing'));
-            return;
-        }
-
-        feature.sheet.render(true);
-    }
-
-    static async deleteFeature(event, button) {
-        event.stopPropagation();
-
-        await this.document.update({
-            [`system.${button.dataset.type}`]: null
-        });
-    }
-
     async _onDragStart(event) {
         const featureItem = event.currentTarget.closest('.drop-section');
 
         if (featureItem) {
             const feature = this.document.system[featureItem.dataset.type];
             if (!feature) {
-                ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.notifications.featureIsMissing'));
+                ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.Notifications.featureIsMissing'));
                 return;
             }
 
@@ -82,18 +54,45 @@ export default class SubclassSheet extends DHBaseItemSheet {
     }
 
     async _onDrop(event) {
+        event.stopPropagation();
+
         const data = foundry.applications.ux.TextEditor.implementation.getDragEventData(event);
         if (data.fromInternal) return;
 
         const item = await fromUuid(data.uuid);
-        if (item?.type === 'feature') {
-            const dropSection = event.target.closest('.drop-section');
-            if (this.document.system[dropSection.dataset.type]) {
-                ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.notifications.featureIsFull'));
-                return;
-            }
+        const target = event.target.closest('fieldset.drop-section');
+        if (item.type === 'feature') {
+            if (target.dataset.type === 'foundation') {
+                if (item.system.subType && item.system.subType !== CONFIG.DH.ITEM.featureSubTypes.foundation) {
+                    ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.Notifications.featureNotFoundation'));
+                    return;
+                }
 
-            await this.document.update({ [`system.${dropSection.dataset.type}`]: item.uuid });
+                await item.update({ 'system.subType': CONFIG.DH.ITEM.featureSubTypes.foundation });
+                await this.document.update({
+                    'system.features': [...this.document.system.features.map(x => x.uuid), item.uuid]
+                });
+            } else if (target.dataset.type === 'specialization') {
+                if (item.system.subType && item.system.subType !== CONFIG.DH.ITEM.featureSubTypes.specialization) {
+                    ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.Notifications.featureNotSpecialization'));
+                    return;
+                }
+
+                await item.update({ 'system.subType': CONFIG.DH.ITEM.featureSubTypes.specialization });
+                await this.document.update({
+                    'system.features': [...this.document.system.features.map(x => x.uuid), item.uuid]
+                });
+            } else if (target.dataset.type === 'mastery') {
+                if (item.system.subType && item.system.subType !== CONFIG.DH.ITEM.featureSubTypes.mastery) {
+                    ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.Notifications.featureNotMastery'));
+                    return;
+                }
+
+                await item.update({ 'system.subType': CONFIG.DH.ITEM.featureSubTypes.mastery });
+                await this.document.update({
+                    'system.features': [...this.document.system.features.map(x => x.uuid), item.uuid]
+                });
+            }
         }
     }
 }

module/applications/sheets/items/weapon.mjs

@@ -1,6 +1,7 @@
 import DHBaseItemSheet from '../api/base-item.mjs';
+import ItemAttachmentSheet from '../api/item-attachment-sheet.mjs';
 
-export default class WeaponSheet extends DHBaseItemSheet {
+export default class WeaponSheet extends ItemAttachmentSheet(DHBaseItemSheet) {
     /**@inheritdoc */
     static DEFAULT_OPTIONS = {
         classes: ['weapon'],
@@ -25,15 +26,20 @@ export default class WeaponSheet extends DHBaseItemSheet {
         settings: {
             template: 'systems/daggerheart/templates/sheets/items/weapon/settings.hbs',
             scrollable: ['.settings']
-        }
+        },
+        effects: {
+            template: 'systems/daggerheart/templates/sheets/global/tabs/tab-effects.hbs',
+            scrollable: ['.effects']
+        },
+        ...super.PARTS
     };
 
     /**@inheritdoc */
     async _preparePartContext(partId, context) {
-        super._preparePartContext(partId, context);
+        await super._preparePartContext(partId, context);
         switch (partId) {
             case 'settings':
-                context.features = this.document.system.features.map(x => x.value);
+                context.features = this.document.system.weaponFeatures.map(x => x.value);
                 context.systemFields.attack.fields = this.document.system.attack.schema.fields;
                 break;
         }
@@ -45,6 +51,6 @@ export default class WeaponSheet extends DHBaseItemSheet {
      * @param {Array<Object>} selectedOptions - The currently selected tag objects.
      */
     static async #onFeatureSelect(selectedOptions) {
-        await this.document.update({ 'system.features': selectedOptions.map(x => ({ value: x.value })) });
+        await this.document.update({ 'system.weaponFeatures': selectedOptions.map(x => ({ value: x.value })) });
     }
 }

module/applications/ui/_module.mjs

@@ -2,3 +2,4 @@ export { default as DhChatLog } from './chatLog.mjs';
 export { default as DhCombatTracker } from './combatTracker.mjs';
 export * as DhCountdowns from './countdowns.mjs';
 export { default as DhFearTracker } from './fearTracker.mjs';
+export { default as DhHotbar } from './hotbar.mjs';

module/applications/ui/chatLog.mjs

@@ -1,6 +1,6 @@
 export default class DhpChatLog extends foundry.applications.sidebar.tabs.ChatLog {
-    constructor() {
-        super();
+    constructor(options) {
+        super(options);
 
         this.targetTemplate = {
             activeLayer: undefined,
@@ -83,15 +83,15 @@ export default class DhpChatLog extends foundry.applications.sidebar.tabs.ChatLo
                 actor.system.attack?._id === actionId
                     ? actor.system.attack
                     : item.system.attack?._id === actionId
-                        ? item.system.attack
-                        : item?.system?.actions?.find(a => a._id === actionId);
+                      ? item.system.attack
+                      : item?.system?.actions?.find(a => a._id === actionId);
         return action;
     }
 
     onRollDamage = async (event, message) => {
         event.stopPropagation();
         const actor = await this.getActor(message.system.source.actor);
-        if (!actor || !game.user.isGM) return true;
+        if (game.user.character?.id !== actor.id && !game.user.isGM) return true;
         if (message.system.source.item && message.system.source.action) {
             const action = this.getAction(actor, message.system.source.item, message.system.source.action);
             if (!action || !action?.rollDamage) return;
@@ -190,7 +190,6 @@ export default class DhpChatLog extends foundry.applications.sidebar.tabs.ChatLo
             ui.notifications.info(game.i18n.localize('DAGGERHEART.UI.Notifications.attackTargetDoesNotExist'));
             return;
         }
-
         game.canvas.pan(token);
     };
 
@@ -212,13 +211,25 @@ export default class DhpChatLog extends foundry.applications.sidebar.tabs.ChatLo
         }
 
         if (targets.length === 0)
-            ui.notifications.info(game.i18n.localize('DAGGERHEART.UI.Notifications.noTargetsSelected'));
-        for (let target of targets) {
-            let damage = message.system.roll.total;
-            if (message.system.onSave && message.system.targets.find(t => t.id === target.id)?.saved?.success === true)
-                damage = Math.ceil(damage * (CONFIG.DH.ACTIONS.damageOnSave[message.system.onSave]?.mod ?? 1));
+            return ui.notifications.info(game.i18n.localize('DAGGERHEART.UI.Notifications.noTargetsSelected'));
 
-            await target.actor.takeDamage(damage, message.system.roll.type);
+        for (let target of targets) {
+            let damages = foundry.utils.deepClone(message.system.damage?.roll ?? message.system.roll);
+            if (
+                message.system.onSave &&
+                message.system.targets.find(t => t.id === target.id)?.saved?.success === true
+            ) {
+                const mod = CONFIG.DH.ACTIONS.damageOnSave[message.system.onSave]?.mod ?? 1;
+                Object.entries(damages).forEach(([k, v]) => {
+                    v.total = 0;
+                    v.parts.forEach(part => {
+                        part.total = Math.ceil(part.total * mod);
+                        v.total += part.total;
+                    });
+                });
+            }
+
+            target.actor.takeDamage(damages);
         }
     };
 
@@ -227,10 +238,10 @@ export default class DhpChatLog extends foundry.applications.sidebar.tabs.ChatLo
         const targets = Array.from(game.user.targets);
 
         if (targets.length === 0)
-            ui.notifications.info(game.i18n.localize('DAGGERHEART.UI.Notifications.noTargetsSelected'));
+            return ui.notifications.info(game.i18n.localize('DAGGERHEART.UI.Notifications.noTargetsSelected'));
 
         for (var target of targets) {
-            await target.actor.takeHealing([{ value: message.system.roll.total, type: message.system.roll.type }]);
+            target.actor.takeHealing(message.system.roll);
         }
     };
 
@@ -289,53 +300,54 @@ export default class DhpChatLog extends foundry.applications.sidebar.tabs.ChatLo
         await actor.useAction(action);
     };
 
-    actionUseButton = async (_, message) => {
+    actionUseButton = async (event, message) => {
+        const { moveIndex, actionIndex } = event.currentTarget.dataset;
         const parent = await foundry.utils.fromUuid(message.system.actor);
-        const actionType = Object.values(message.system.moves)[0].actions[0];
-        const cls = CONFIG.DH.ACTIONS.actionTypes[actionType.type];
+        const actionType = message.system.moves[moveIndex].actions[actionIndex];
+        const cls = game.system.api.models.actions.actionsTypes[actionType.type];
         const action = new cls(
             { ...actionType, _id: foundry.utils.randomID(), name: game.i18n.localize(actionType.name) },
-            { parent: parent }
+            { parent: parent.system }
         );
 
-        action.use();
+        action.use(event);
     };
 
     //Reroll Functionality
-    rerollEvent = async(event,message)=> {
-        let DieTerm=foundry.dice.terms.Die;
+    rerollEvent = async (event, message) => {
+        let DieTerm = foundry.dice.terms.Die;
         let dicetype = event.target.value;
-        let originalRoll_parsed=message.rolls.map(roll => JSON.parse(roll))[0];
-        console.log("Parsed Map:",originalRoll_parsed);
-        let originalRoll=Roll.fromData(originalRoll_parsed);
+        let originalRoll_parsed = message.rolls.map(roll => JSON.parse(roll))[0];
+        console.log('Parsed Map:', originalRoll_parsed);
+        let originalRoll = Roll.fromData(originalRoll_parsed);
         let diceIndex;
-        console.log("Dice to reroll is:",dicetype,", and the message id is:",message._id,originalRoll_parsed);
-        console.log("Original Roll Terms:",originalRoll.terms);
-        switch(dicetype){
-            case "hope": {
-                diceIndex=0; //Hope Die
+        console.log('Dice to reroll is:', dicetype, ', and the message id is:', message._id, originalRoll_parsed);
+        console.log('Original Roll Terms:', originalRoll.terms);
+        switch (dicetype) {
+            case 'hope': {
+                diceIndex = 0; //Hope Die
                 break;
-            };
-            case "fear" :{
-                diceIndex=2; //Fear Die
+            }
+            case 'fear': {
+                diceIndex = 2; //Fear Die
                 break;
-            };
-            default: 
-                ui.notifications.warn("Invalid Dice type selected.");
+            }
+            default:
+                ui.notifications.warn('Invalid Dice type selected.');
                 break;
         }
-        let rollClone=originalRoll.clone();
-        let rerolledTerm=originalRoll.terms[diceIndex];
-        console.log("originalRoll:",originalRoll,"rerolledTerm",rerolledTerm);
+        let rollClone = originalRoll.clone();
+        let rerolledTerm = originalRoll.terms[diceIndex];
+        console.log('originalRoll:', originalRoll, 'rerolledTerm', rerolledTerm);
         if (!(rerolledTerm instanceof DieTerm)) {
-            ui.notifications.error("Selected term is not a die.");
+            ui.notifications.error('Selected term is not a die.');
             return;
         }
-        await rollClone.reroll({allowStrings:true})[diceIndex];
+        await rollClone.reroll({ allowStrings: true })[diceIndex];
         console.log(rollClone);
-        await rollClone.evaluate({allowStrings:true});
+        await rollClone.evaluate({ allowStrings: true });
         console.log(rollClone.result);
- /*       
+        /*       
         const confirm = await foundry.applications.api.DialogV2.confirm({
             window: { title: 'Confirm Reroll' },
             content: `<p>You have rerolled your <strong>${dicetype}</strong> die to <strong>${rollClone.result}</strong>.</p><p>Apply this new roll?</p>`
@@ -343,5 +355,5 @@ export default class DhpChatLog extends foundry.applications.sidebar.tabs.ChatLo
         if (!confirm) return;
         rollClone.toMessage({flavor: 'Selective reroll applied for ${dicetype}.'});
         console.log("Updated Roll",rollClone);*/
-    }
+    };
 }

module/applications/ui/combatTracker.mjs

@@ -66,6 +66,11 @@ export default class DhCombatTracker extends foundry.applications.sidebar.tabs.C
     }
 
     async setCombatantSpotlight(combatantId) {
+        const update = {
+            system: {
+                'spotlight.requesting': false
+            }
+        };
         const combatant = this.viewed.combatants.get(combatantId);
 
         const toggleTurn = this.viewed.combatants.contents
@@ -73,10 +78,18 @@ export default class DhCombatTracker extends foundry.applications.sidebar.tabs.C
             .map(x => x.id)
             .indexOf(combatantId);
 
-        if (this.viewed.turn !== toggleTurn) Hooks.callAll(CONFIG.DH.HOOKS.spotlight, {});
+        if (this.viewed.turn !== toggleTurn) {
+            const { updateCountdowns } = game.system.api.applications.ui.DhCountdowns;
+            await updateCountdowns(CONFIG.DH.GENERAL.countdownTypes.spotlight.id);
+
+            const autoPoints = game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Automation).actionPoints;
+            if (autoPoints) {
+                update.system.actionTokens = Math.max(combatant.system.actionTokens - 1, 0);
+            }
+        }
 
         await this.viewed.update({ turn: this.viewed.turn === toggleTurn ? null : toggleTurn });
-        await combatant.update({ 'system.spotlight.requesting': false });
+        await combatant.update(update);
     }
 
     static async requestSpotlight(_, target) {

module/applications/ui/countdowns.mjs

@@ -1,4 +1,3 @@
-import { countdownTypes } from '../../config/generalConfig.mjs';
 import { GMUpdateEvent, RefreshType, socketEvent } from '../../systemRegistration/socket.mjs';
 import constructHTMLButton from '../../helpers/utils.mjs';
 import OwnershipSelection from '../dialogs/ownershipSelection.mjs';
@@ -328,43 +327,29 @@ export class EncounterCountdowns extends Countdowns {
     };
 }
 
-export const registerCountdownApplicationHooks = () => {
-    const updateCountdowns = async shouldProgress => {
-        if (game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Automation).countdowns) {
-            const countdownSetting = game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Countdowns);
-            for (let countdownCategoryKey in countdownSetting) {
-                const countdownCategory = countdownSetting[countdownCategoryKey];
-                for (let countdownKey in countdownCategory.countdowns) {
-                    const countdown = countdownCategory.countdowns[countdownKey];
-
-                    if (shouldProgress(countdown)) {
-                        await countdownSetting.updateSource({
-                            [`${countdownCategoryKey}.countdowns.${countdownKey}.progress.current`]:
-                                countdown.progress.current - 1
-                        });
-                        await game.settings.set(
-                            CONFIG.DH.id,
-                            CONFIG.DH.SETTINGS.gameSettings.Countdowns,
-                            countdownSetting
-                        );
-                        foundry.applications.instances.get(`${countdownCategoryKey}-countdowns`)?.render();
-                    }
+export async function updateCountdowns(progressType) {
+    const countdownSetting = game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Countdowns);
+    const update = Object.keys(countdownSetting).reduce((update, typeKey) => {
+        return foundry.utils.mergeObject(
+            update,
+            Object.keys(countdownSetting[typeKey].countdowns).reduce((acc, countdownKey) => {
+                const countdown = countdownSetting[typeKey].countdowns[countdownKey];
+                if (countdown.progress.current > 0 && countdown.progress.type.value === progressType) {
+                    acc[`${typeKey}.countdowns.${countdownKey}.progress.current`] = countdown.progress.current - 1;
                 }
-            }
-        }
-    };
 
-    Hooks.on(CONFIG.DH.HOOKS.characterAttack, async () => {
-        updateCountdowns(countdown => {
-            return (
-                countdown.progress.type.value === countdownTypes.characterAttack.id && countdown.progress.current > 0
-            );
-        });
-    });
+                return acc;
+            }, {})
+        );
+    }, {});
 
-    Hooks.on(CONFIG.DH.HOOKS.spotlight, async () => {
-        updateCountdowns(countdown => {
-            return countdown.progress.type.value === countdownTypes.spotlight.id && countdown.progress.current > 0;
-        });
+    await countdownSetting.updateSource(update);
+    await game.settings.set(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Countdowns, countdownSetting);
+
+    const data = { refreshType: RefreshType.Countdown };
+    await game.socket.emit(`system.${CONFIG.DH.id}`, {
+        action: socketEvent.Refresh,
+        data
     });
-};
+    Hooks.callAll(socketEvent.Refresh, data);
+}

module/applications/ui/hotbar.mjs

@@ -0,0 +1,129 @@
+export default class DhHotbar extends foundry.applications.ui.Hotbar {
+    constructor(options) {
+        super(options);
+
+        this.setupHooks();
+    }
+
+    static async useItem(uuid) {
+        const item = await fromUuid(uuid);
+        if (!item) {
+            return ui.notifications.warn('WARNING.ObjectDoesNotExist', {
+                format: {
+                    name: game.i18n.localize('Document'),
+                    identifier: uuid
+                }
+            });
+        }
+
+        await item.use({});
+    }
+
+    static async useAction(itemUuid, actionId) {
+        const item = await foundry.utils.fromUuid(itemUuid);
+        if (!item) {
+            return ui.notifications.warn('WARNING.ObjectDoesNotExist', {
+                format: {
+                    name: game.i18n.localize('Document'),
+                    identifier: itemUuid
+                }
+            });
+        }
+
+        const action = item.system.actions.find(x => x.id === actionId);
+        if (!action) {
+            return ui.notifications.warn('DAGGERHEART.UI.Notifications.actionIsMissing');
+        }
+
+        await action.use({});
+    }
+
+    static async useAttack(actorUuid) {
+        const actor = await foundry.utils.fromUuid(actorUuid);
+        if (!actor) {
+            return ui.notifications.warn('WARNING.ObjectDoesNotExist', {
+                format: {
+                    name: game.i18n.localize('Document'),
+                    identifier: actorUuid
+                }
+            });
+        }
+
+        const attack = actor.system.attack;
+        if (!attack) {
+            return ui.notifications.warn('DAGGERHEART.UI.Notifications.attackIsMissing');
+        }
+
+        await attack.use({});
+    }
+
+    setupHooks() {
+        Hooks.on('hotbarDrop', (bar, data, slot) => {
+            if (data.type === 'Item') {
+                const item = foundry.utils.fromUuidSync(data.uuid);
+                if (item.uuid.startsWith('Compendium') || !item.isOwned || !item.isOwner) return true;
+
+                switch (item.type) {
+                    case 'ancestry':
+                    case 'community':
+                    case 'class':
+                    case 'subclass':
+                        return true;
+                    default:
+                        this.createItemMacro(item, slot);
+                        return false;
+                }
+            } else if (data.type === 'Action') {
+                const item = foundry.utils.fromUuidSync(data.data.itemUuid);
+                if (item.uuid.startsWith('Compendium')) return true;
+                if (!item.isOwned || !item.isOwner) {
+                    ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.Notifications.unownedActionMacro'));
+                    return false;
+                }
+
+                this.createActionMacro(data, slot);
+                return false;
+            } else if (data.type === 'Attack') {
+                const actor = foundry.utils.fromUuidSync(data.actorUuid);
+                if (actor.uuid.startsWith('Compendium')) return true;
+                if (!actor.isOwner) {
+                    ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.Notifications.unownedAttackMacro'));
+                    return false;
+                }
+
+                this.createAttackMacro(data, slot);
+                return false;
+            }
+        });
+    }
+
+    async createItemMacro(data, slot) {
+        const macro = await Macro.implementation.create({
+            name: data.name,
+            type: CONST.MACRO_TYPES.SCRIPT,
+            img: data.img,
+            command: `await game.system.api.applications.ui.DhHotbar.useItem("${data.uuid}");`
+        });
+        await game.user.assignHotbarMacro(macro, slot);
+    }
+
+    async createActionMacro(data, slot) {
+        const macro = await Macro.implementation.create({
+            name: data.data.name,
+            type: CONST.MACRO_TYPES.SCRIPT,
+            img: data.data.img,
+            command: `await game.system.api.applications.ui.DhHotbar.useAction("${data.data.itemUuid}", "${data.data.id}");`
+        });
+        await game.user.assignHotbarMacro(macro, slot);
+    }
+
+    async createAttackMacro(data, slot) {
+        const macro = await Macro.implementation.create({
+            name: data.name,
+            type: CONST.MACRO_TYPES.SCRIPT,
+            img: data.img,
+            command: `await game.system.api.applications.ui.DhHotbar.useAttack("${data.actorUuid}");`
+        });
+        await game.user.assignHotbarMacro(macro, slot);
+    }
+}

module/applications/ux/contextMenu.mjs

@@ -100,7 +100,7 @@ export default class DHContextMenu extends foundry.applications.ux.ContextMenu {
         event.preventDefault();
         event.stopPropagation();
         const { clientX, clientY } = event;
-        const selector = '[data-item-id]';
+        const selector = '[data-item-uuid]';
         const target = event.target.closest(selector) ?? event.currentTarget.closest(selector);
         target?.dispatchEvent(
             new PointerEvent('contextmenu', {