Fix conflicts

module/applications/config/Action.mjs

@@ -86,11 +86,11 @@ export default class DHActionConfig extends DaggerheartSheet(ApplicationV2) {
     static async updateForm(event, _, formData) {
         const submitData = this._prepareSubmitData(event, formData),
             data = foundry.utils.expandObject(foundry.utils.mergeObject(this.action.toObject(), submitData)),
-            newActions = this.action.parent.actions.map(x => x.toObject()); // Find better way
+            newActions = foundry.utils.getProperty(this.action.parent, this.action.systemPath).map(x => x.toObject()); // Find better way
         if (!newActions.findSplice(x => x._id === data._id, data)) newActions.push(data);
-        const updates = await this.action.parent.parent.update({ 'system.actions': newActions });
+        const updates = await this.action.parent.parent.update({ [`system.${this.action.systemPath}`]: newActions });
         if (!updates) return;
-        this.action = updates.system.actions[this.action.index];
+        this.action = foundry.utils.getProperty(updates.system, this.action.systemPath)[this.action.index];
         this.render();
     }
 

module/applications/sheets/items/ancestry.mjs

@@ -1,88 +1,13 @@
-import DaggerheartSheet from '../daggerheart-sheet.mjs';
+import DHHeritageSheetV2 from './heritage.mjs';
 
 const { ItemSheetV2 } = foundry.applications.sheets;
-export default class AncestrySheet extends DaggerheartSheet(ItemSheetV2) {
+export default class AncestrySheet extends DHHeritageSheetV2(ItemSheetV2) {
     static DEFAULT_OPTIONS = {
-        tag: 'form',
-        classes: ['daggerheart', 'sheet', 'item', 'dh-style', 'ancestry'],
-        position: { width: 450, height: 700 },
-        actions: {
-            editFeature: this.editFeature,
-            deleteFeature: this.deleteFeature
-        },
-        form: {
-            handler: this.updateForm,
-            submitOnChange: true,
-            closeOnSubmit: false
-        },
-        dragDrop: [{ dragSelector: null, dropSelector: null }]
+        classes: ['ancestry']
     };
 
     static PARTS = {
         header: { template: 'systems/daggerheart/templates/sheets/items/ancestry/header.hbs' },
-        tabs: { template: 'systems/daggerheart/templates/sheets/global/tabs/tab-navigation.hbs' },
-        description: { template: 'systems/daggerheart/templates/sheets/global/tabs/tab-description.hbs' },
-        features: {
-            template: 'systems/daggerheart/templates/sheets/global/tabs/tab-feature-section.hbs',
-            scrollable: ['.features']
-        }
+        ...super.PARTS
     };
-
-    static TABS = {
-        description: {
-            active: true,
-            cssClass: '',
-            group: 'primary',
-            id: 'description',
-            icon: null,
-            label: 'DAGGERHEART.Sheets.Feature.Tabs.Description'
-        },
-        features: {
-            active: false,
-            cssClass: '',
-            group: 'primary',
-            id: 'features',
-            icon: null,
-            label: 'DAGGERHEART.Sheets.Feature.Tabs.Features'
-        }
-    };
-
-    async _prepareContext(_options) {
-        const context = await super._prepareContext(_options);
-        context.document = this.document;
-        context.tabs = super._getTabs(this.constructor.TABS);
-
-        return context;
-    }
-
-    static async updateForm(event, _, formData) {
-        await this.document.update(formData.object);
-        this.render();
-    }
-
-    static async editFeature(_, target) {
-        const feature = await fromUuid(target.dataset.feature);
-        feature.sheet.render(true);
-    }
-
-    static async deleteFeature(event, target) {
-        event.preventDefault();
-        event.stopPropagation();
-        await this.item.update({
-            'system.abilities': this.item.system.abilities.filter(x => x.uuid !== target.dataset.feature)
-        });
-    }
-
-    async _onDrop(event) {
-        const data = TextEditor.getDragEventData(event);
-        const item = await fromUuid(data.uuid);
-        if (item.type === 'feature' && item.system.type === SYSTEM.ITEM.featureTypes.ancestry.id) {
-            await this.document.update({
-                'system.abilities': [
-                    ...this.document.system.abilities,
-                    { img: item.img, name: item.name, uuid: item.uuid }
-                ]
-            });
-        }
-    }
 }

module/applications/sheets/items/armor.mjs

@@ -1,3 +1,5 @@
+import { armorFeatures } from '../../../config/itemConfig.mjs';
+import { tagifyElement } from '../../../helpers/utils.mjs';
 import DHItemSheetV2 from '../item.mjs';
 
 const { ItemSheetV2 } = foundry.applications.sheets;
@@ -20,4 +22,28 @@ export default class ArmorSheet extends DHItemSheetV2(ItemSheetV2) {
             scrollable: ['.settings']
         }
     };
+
+    async _preparePartContext(partId, context) {
+        super._preparePartContext(partId, context);
+
+        switch (partId) {
+            case 'settings':
+                context.features = this.document.system.features.map(x => x.value);
+                break;
+        }
+
+        return context;
+    }
+
+    _attachPartListeners(partId, htmlElement, options) {
+        super._attachPartListeners(partId, htmlElement, options);
+
+        const featureInput = htmlElement.querySelector('.features-input');
+        tagifyElement(featureInput, armorFeatures, this.onFeatureSelect.bind(this));
+    }
+
+    async onFeatureSelect(features) {
+        await this.document.update({ 'system.features': features.map(x => ({ value: x.value })) });
+        this.render(true);
+    }
 }

module/applications/sheets/items/class.mjs

@@ -1,8 +1,11 @@
+import { actionsTypes } from '../../../data/_module.mjs';
 import { tagifyElement } from '../../../helpers/utils.mjs';
+import DHActionConfig from '../../config/Action.mjs';
 import DaggerheartSheet from '../daggerheart-sheet.mjs';
 
 const { ItemSheetV2 } = foundry.applications.sheets;
 const { TextEditor } = foundry.applications.ux;
+
 export default class ClassSheet extends DaggerheartSheet(ItemSheetV2) {
     static DEFAULT_OPTIONS = {
         tag: 'form',
@@ -11,8 +14,9 @@ export default class ClassSheet extends DaggerheartSheet(ItemSheetV2) {
         actions: {
             removeSubclass: this.removeSubclass,
             viewSubclass: this.viewSubclass,
-            deleteFeature: this.deleteFeature,
+            addFeature: this.addFeature,
             editFeature: this.editFeature,
+            deleteFeature: this.deleteFeature,
             removeItem: this.removeItem,
             viewItem: this.viewItem,
             removePrimaryWeapon: this.removePrimaryWeapon,
@@ -151,6 +155,69 @@ export default class ClassSheet extends DaggerheartSheet(ItemSheetV2) {
         await this.document.update({ 'system.characterGuide.suggestedArmor': null }, { diff: false });
     }
 
+    async selectActionType() {
+        const content = await foundry.applications.handlebars.renderTemplate(
+                'systems/daggerheart/templates/views/actionType.hbs',
+                { types: SYSTEM.ACTIONS.actionTypes }
+            ),
+            title = 'Select Action Type',
+            type = 'form',
+            data = {};
+        return Dialog.prompt({
+            title,
+            label: title,
+            content,
+            type,
+            callback: html => {
+                const form = html[0].querySelector('form'),
+                    fd = new foundry.applications.ux.FormDataExtended(form);
+                foundry.utils.mergeObject(data, fd.object, { inplace: true });
+
+                return data;
+            },
+            rejectClose: false
+        });
+    }
+
+    getActionPath(type) {
+        return type === 'hope' ? 'hopeFeatures' : 'classFeatures';
+    }
+
+    static async addFeature(_, target) {
+        const actionPath = this.getActionPath(target.dataset.type);
+        const actionType = await this.selectActionType();
+        const cls = actionsTypes[actionType?.type] ?? actionsTypes.attack,
+            action = new cls(
+                {
+                    _id: foundry.utils.randomID(),
+                    systemPath: actionPath,
+                    type: actionType.type,
+                    name: game.i18n.localize(SYSTEM.ACTIONS.actionTypes[actionType.type].name),
+                    ...cls.getSourceConfig(this.document)
+                },
+                {
+                    parent: this.document
+                }
+            );
+        await this.document.update({ [`system.${actionPath}`]: [...this.document.system[actionPath], action] });
+    }
+
+    static async editFeature(_, target) {
+        const action = this.document.system[this.getActionPath(target.dataset.type)].find(
+            x => x._id === target.dataset.feature
+        );
+        await new DHActionConfig(action).render(true);
+    }
+
+    static async deleteFeature(_, target) {
+        const actionPath = this.getActionPath(target.dataset.type);
+        await this.document.update({
+            [`system.${actionPath}`]: this.document.system[actionPath].filter(
+                action => action._id !== target.dataset.feature
+            )
+        });
+    }
+
     async _onDrop(event) {
         const data = TextEditor.getDragEventData(event);
         const item = await fromUuid(data.uuid);
@@ -158,10 +225,6 @@ export default class ClassSheet extends DaggerheartSheet(ItemSheetV2) {
             await this.document.update({
                 'system.subclasses': [...this.document.system.subclasses.map(x => x.uuid), item.uuid]
             });
-        } else if (item.type === 'feature') {
-            await this.document.update({
-                'system.features': [...this.document.system.features.map(x => x.uuid), item.uuid]
-            });
         } else if (item.type === 'weapon') {
             if (event.currentTarget.classList.contains('primary-weapon-section')) {
                 if (!this.document.system.characterGuide.suggestedPrimaryWeapon && !item.system.secondary)

module/applications/sheets/items/community.mjs

@@ -1,88 +1,13 @@
-import DaggerheartSheet from '../daggerheart-sheet.mjs';
+import DHHeritageSheetV2 from './heritage.mjs';
 
 const { ItemSheetV2 } = foundry.applications.sheets;
-export default class CommunitySheet extends DaggerheartSheet(ItemSheetV2) {
+export default class CommunitySheet extends DHHeritageSheetV2(ItemSheetV2) {
     static DEFAULT_OPTIONS = {
-        tag: 'form',
-        classes: ['daggerheart', 'sheet', 'item', 'dh-style', 'community'],
-        position: { width: 450, height: 700 },
-        actions: {
-            editFeature: this.editFeature,
-            deleteFeature: this.deleteFeature
-        },
-        form: {
-            handler: this.updateForm,
-            submitOnChange: true,
-            closeOnSubmit: false
-        },
-        dragDrop: [{ dragSelector: null, dropSelector: null }]
+        classes: ['community']
     };
 
     static PARTS = {
         header: { template: 'systems/daggerheart/templates/sheets/items/community/header.hbs' },
-        tabs: { template: 'systems/daggerheart/templates/sheets/global/tabs/tab-navigation.hbs' },
-        description: { template: 'systems/daggerheart/templates/sheets/global/tabs/tab-description.hbs' },
-        features: {
-            template: 'systems/daggerheart/templates/sheets/global/tabs/tab-feature-section.hbs',
-            scrollable: ['.features']
-        }
+        ...super.PARTS
     };
-
-    static TABS = {
-        description: {
-            active: true,
-            cssClass: '',
-            group: 'primary',
-            id: 'description',
-            icon: null,
-            label: 'DAGGERHEART.Sheets.Feature.Tabs.Description'
-        },
-        features: {
-            active: false,
-            cssClass: '',
-            group: 'primary',
-            id: 'features',
-            icon: null,
-            label: 'DAGGERHEART.Sheets.Feature.Tabs.Features'
-        }
-    };
-
-    async _prepareContext(_options) {
-        const context = await super._prepareContext(_options);
-        context.document = this.document;
-        context.tabs = super._getTabs(this.constructor.TABS);
-
-        return context;
-    }
-
-    static async updateForm(event, _, formData) {
-        await this.document.update(formData.object);
-        this.render();
-    }
-
-    static async editFeature(_, target) {
-        const feature = await fromUuid(target.dataset.feature);
-        feature.sheet.render(true);
-    }
-
-    static async deleteFeature(event, target) {
-        event.preventDefault();
-        event.stopPropagation();
-        await this.item.update({
-            'system.abilities': this.item.system.abilities.filter(x => x.uuid !== target.dataset.feature)
-        });
-    }
-
-    async _onDrop(event) {
-        const data = TextEditor.getDragEventData(event);
-        const item = await fromUuid(data.uuid);
-        if (item.type === 'feature' && item.system.type === SYSTEM.ITEM.featureTypes.community.id) {
-            await this.document.update({
-                'system.abilities': [
-                    ...this.document.system.abilities,
-                    { img: item.img, name: item.name, uuid: item.uuid }
-                ]
-            });
-        }
-    }
 }

module/applications/sheets/items/heritage.mjs

@@ -0,0 +1,147 @@
+import { actionsTypes } from '../../../data/_module.mjs';
+import DHActionConfig from '../../config/Action.mjs';
+import DHItemMixin from '../item.mjs';
+
+export default function DHHeritageMixin(Base) {
+    return class DHHeritageSheetV2 extends DHItemMixin(Base) {
+        static DEFAULT_OPTIONS = {
+            tag: 'form',
+            position: { width: 450, height: 700 },
+            actions: {
+                addAction: this.addAction,
+                editAction: this.editAction,
+                removeAction: this.removeAction,
+                addEffect: this.addEffect,
+                editEffect: this.editEffect,
+                removeEffect: this.removeEffect
+            },
+            form: {
+                handler: this.updateForm,
+                submitOnChange: true,
+                closeOnSubmit: false
+            }
+        };
+
+        static PARTS = {
+            tabs: { template: 'systems/daggerheart/templates/sheets/global/tabs/tab-navigation.hbs' },
+            description: { template: 'systems/daggerheart/templates/sheets/global/tabs/tab-description.hbs' },
+            actions: {
+                template: 'systems/daggerheart/templates/sheets/global/tabs/tab-actions.hbs',
+                scrollable: ['.actions']
+            },
+            effects: {
+                template: 'systems/daggerheart/templates/sheets/global/tabs/tab-effects.hbs',
+                scrollable: ['.effects']
+            }
+        };
+
+        static TABS = {
+            description: {
+                active: true,
+                cssClass: '',
+                group: 'primary',
+                id: 'description',
+                icon: null,
+                label: 'DAGGERHEART.Sheets.Feature.Tabs.Description'
+            },
+            actions: {
+                active: false,
+                cssClass: '',
+                group: 'primary',
+                id: 'actions',
+                icon: null,
+                label: 'DAGGERHEART.Sheets.Feature.Tabs.Actions'
+            },
+            effects: {
+                active: false,
+                cssClass: '',
+                group: 'primary',
+                id: 'effects',
+                icon: null,
+                label: 'DAGGERHEART.Sheets.Feature.Tabs.Effects'
+            }
+        };
+
+        async _prepareContext(_options) {
+            const context = await super._prepareContext(_options);
+            context.document = this.document;
+            context.tabs = super._getTabs(this.constructor.TABS);
+
+            return context;
+        }
+
+        static async updateForm(event, _, formData) {
+            await this.document.update(formData.object);
+            this.render();
+        }
+
+        async selectActionType() {
+            const content = await foundry.applications.handlebars.renderTemplate(
+                    'systems/daggerheart/templates/views/actionType.hbs',
+                    { types: SYSTEM.ACTIONS.actionTypes }
+                ),
+                title = 'Select Action Type',
+                type = 'form',
+                data = {};
+            return Dialog.prompt({
+                title,
+                label: title,
+                content,
+                type,
+                callback: html => {
+                    const form = html[0].querySelector('form'),
+                        fd = new foundry.applications.ux.FormDataExtended(form);
+                    foundry.utils.mergeObject(data, fd.object, { inplace: true });
+                    return data;
+                },
+                rejectClose: false
+            });
+        }
+
+        static async addAction() {
+            const actionType = await this.selectActionType();
+            const cls = actionsTypes[actionType?.type] ?? actionsTypes.attack,
+                action = new cls(
+                    {
+                        _id: foundry.utils.randomID(),
+                        type: actionType.type,
+                        name: game.i18n.localize(SYSTEM.ACTIONS.actionTypes[actionType.type].name),
+                        ...cls.getSourceConfig(this.document)
+                    },
+                    {
+                        parent: this.document
+                    }
+                );
+            await this.document.update({ 'system.actions': [...this.document.system.actions, action] });
+        }
+
+        static async editAction(_, button) {
+            const action = this.document.system.actions[button.dataset.index];
+            await new DHActionConfig(action).render(true);
+        }
+
+        static async removeAction(event, button) {
+            event.stopPropagation();
+            await this.document.update({
+                'system.actions': this.document.system.actions.filter(
+                    (_, index) => index !== Number.parseInt(button.dataset.index)
+                )
+            });
+        }
+
+        static async addEffect() {
+            await this.document.createEmbeddedDocuments('ActiveEffect', [
+                { name: game.i18n.localize('DAGGERHEART.Feature.NewEffect') }
+            ]);
+        }
+
+        static async editEffect(_, target) {
+            const effect = this.document.effects.get(target.dataset.effect);
+            effect.sheet.render(true);
+        }
+
+        static async removeEffect(_, target) {
+            await this.document.effects.get(target.dataset.effect).delete();
+        }
+    };
+}

module/applications/sheets/items/subclass.mjs

@@ -1,28 +1,24 @@
-import DaggerheartSheet from '../daggerheart-sheet.mjs';
+import { actionsTypes } from '../../../data/_module.mjs';
+import DHActionConfig from '../../config/Action.mjs';
+import DhpApplicationMixin from '../daggerheart-sheet.mjs';
 
 const { ItemSheetV2 } = foundry.applications.sheets;
-const { TextEditor } = foundry.applications.ux;
-const { duplicate, getProperty } = foundry.utils;
-export default class SubclassSheet extends DaggerheartSheet(ItemSheetV2) {
+export default class SubclassSheet extends DhpApplicationMixin(ItemSheetV2) {
     static DEFAULT_OPTIONS = {
         tag: 'form',
         classes: ['daggerheart', 'sheet', 'item', 'dh-style', 'subclass'],
         position: { width: 600 },
         window: { resizable: false },
         actions: {
-            editAbility: this.editAbility,
-            deleteFeatureAbility: this.deleteFeatureAbility
+            addFeature: this.addFeature,
+            editFeature: this.editFeature,
+            deleteFeature: this.deleteFeature
         },
         form: {
             handler: this.updateForm,
             submitOnChange: true,
             closeOnSubmit: false
-        },
-        dragDrop: [
-            { dragSelector: null, dropSelector: '.foundation-tab' },
-            { dragSelector: null, dropSelector: '.specialization-tab' },
-            { dragSelector: null, dropSelector: '.mastery-tab' }
-        ]
+        }
     };
 
     static PARTS = {
@@ -80,41 +76,99 @@ export default class SubclassSheet extends DaggerheartSheet(ItemSheetV2) {
         this.render();
     }
 
-    static async editAbility(_, button) {
-        const feature = await fromUuid(button.dataset.ability);
-        feature.sheet.render(true);
+    static addFeature(_, target) {
+        if (target.dataset.type === 'action') this.addAction(target.dataset.level);
+        else this.addEffect(target.dataset.level);
     }
 
-    static async deleteFeatureAbility(event, button) {
-        event.preventDefault();
-        event.stopPropagation();
-
-        const feature = button.dataset.feature;
-        const newAbilities = this.document.system[`${feature}Feature`].abilities.filter(
-            x => x.uuid !== button.dataset.ability
-        );
-        const path = `system.${feature}Feature.abilities`;
-
-        await this.document.update({ [path]: newAbilities });
+    static async editFeature(_, target) {
+        if (target.dataset.type === 'action') this.editAction(target.dataset.level, target.dataset.feature);
+        else this.editEffect(target.dataset.feature);
     }
 
-    async _onDrop(event) {
-        event.preventDefault();
-        const data = TextEditor.getDragEventData(event);
-        const item = await fromUuid(data.uuid);
-        if (!(item.type === 'feature' && item.system.type === SYSTEM.ITEM.featureTypes.subclass.id)) return;
+    static async deleteFeature(_, target) {
+        if (target.dataset.type === 'action') this.removeAction(target.dataset.level, target.dataset.feature);
+        else this.removeEffect(target.dataset.level, target.dataset.feature);
+    }
 
-        let featureField;
-        if (event.currentTarget.classList.contains('foundation-tab')) featureField = 'foundation';
-        else if (event.currentTarget.classList.contains('specialization-tab')) featureField = 'specialization';
-        else if (event.currentTarget.classList.contains('mastery-tab')) featureField = 'mastery';
-        else return;
+    async #selectActionType() {
+        const content = await foundry.applications.handlebars.renderTemplate(
+                'systems/daggerheart/templates/views/actionType.hbs',
+                { types: SYSTEM.ACTIONS.actionTypes }
+            ),
+            title = 'Select Action Type',
+            type = 'form',
+            data = {};
+        return Dialog.prompt({
+            title,
+            label: title,
+            content,
+            type,
+            callback: html => {
+                const form = html[0].querySelector('form'),
+                    fd = new foundry.applications.ux.FormDataExtended(form);
+                foundry.utils.mergeObject(data, fd.object, { inplace: true });
+                return data;
+            },
+            rejectClose: false
+        });
+    }
 
-        const path = `system.${featureField}Feature.abilities`;
-        const abilities = duplicate(getProperty(this.document, path)) || [];
-        const featureData = { name: item.name, img: item.img, uuid: item.uuid };
-        abilities.push(featureData);
+    async addAction(level) {
+        const actionType = await this.#selectActionType();
+        const cls = actionsTypes[actionType?.type] ?? actionsTypes.attack,
+            action = new cls(
+                {
+                    _id: foundry.utils.randomID(),
+                    systemPath: `${level}.actions`,
+                    type: actionType.type,
+                    name: game.i18n.localize(SYSTEM.ACTIONS.actionTypes[actionType.type].name),
+                    ...cls.getSourceConfig(this.document)
+                },
+                {
+                    parent: this.document
+                }
+            );
+        await this.document.update({ [`system.${level}.actions`]: [...this.document.system[level].actions, action] });
+        await new DHActionConfig(
+            this.document.system[level].actions[this.document.system[level].actions.length - 1]
+        ).render(true);
+    }
 
-        await this.document.update({ [path]: abilities });
+    async addEffect(level) {
+        const embeddedItems = await this.document.createEmbeddedDocuments('ActiveEffect', [
+            { name: game.i18n.localize('DAGGERHEART.Feature.NewEffect') }
+        ]);
+        await this.document.update({
+            [`system.${level}.effects`]: [
+                ...this.document.system[level].effects.map(x => x.uuid),
+                embeddedItems[0].uuid
+            ]
+        });
+    }
+
+    async editAction(level, id) {
+        const action = this.document.system[level].actions.find(x => x._id === id);
+        await new DHActionConfig(action).render(true);
+    }
+
+    async editEffect(id) {
+        const effect = this.document.effects.get(id);
+        effect.sheet.render(true);
+    }
+
+    async removeAction(level, id) {
+        await this.document.update({
+            [`system.${level}.actions`]: this.document.system[level].actions.filter(action => action._id !== id)
+        });
+    }
+
+    async removeEffect(level, id) {
+        await this.document.effects.get(id).delete();
+        await this.document.update({
+            [`system.${level}.effects`]: this.document.system[level].effects
+                .filter(x => x && x.id !== id)
+                .map(effect => effect.uuid)
+        });
     }
 }

module/applications/sheets/items/weapon.mjs

@@ -1,3 +1,5 @@
+import { weaponFeatures } from '../../../config/itemConfig.mjs';
+import { tagifyElement } from '../../../helpers/utils.mjs';
 import DHItemSheetV2 from '../item.mjs';
 
 const { ItemSheetV2 } = foundry.applications.sheets;
@@ -19,4 +21,28 @@ export default class WeaponSheet extends DHItemSheetV2(ItemSheetV2) {
             scrollable: ['.settings']
         }
     };
+
+    async _preparePartContext(partId, context) {
+        super._preparePartContext(partId, context);
+
+        switch (partId) {
+            case 'settings':
+                context.features = this.document.system.features.map(x => x.value);
+                break;
+        }
+
+        return context;
+    }
+
+    _attachPartListeners(partId, htmlElement, options) {
+        super._attachPartListeners(partId, htmlElement, options);
+
+        const featureInput = htmlElement.querySelector('.features-input');
+        tagifyElement(featureInput, weaponFeatures, this.onFeatureSelect.bind(this));
+    }
+
+    async onFeatureSelect(features) {
+        await this.document.update({ 'system.features': features.map(x => ({ value: x.value })) });
+        this.render(true);
+    }
 }