140/141 - Class/Subclass Actions/Effects (#142)

* Added Actions and effects

* Added class hopeFeatures and classFeatures

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/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/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/data/action/action.mjs

@@ -55,6 +55,7 @@ export class DHBaseAction extends foundry.abstract.DataModel {
     static defineSchema() {
         return {
             _id: new fields.DocumentIdField(),
+            systemPath: new fields.StringField({ required: true, initial: 'actions' }),
             type: new fields.StringField({ initial: undefined, readonly: true, required: true }),
             name: new fields.StringField({ initial: undefined }),
             img: new fields.FilePathField({ initial: undefined, categories: ['IMAGE'], base64: false }),
@@ -93,7 +94,7 @@ export class DHBaseAction extends foundry.abstract.DataModel {
     prepareData() {}
 
     get index() {
-        return this.parent.actions.indexOf(this);
+        return foundry.utils.getProperty(this.parent, this.systemPath).indexOf(this);
     }
 
     get item() {
@@ -203,7 +204,7 @@ export class DHAttackAction extends DHBaseAction {
     static getRollType() {
         return 'weapon';
     }
- 
+
     get chatTitle() {
         return game.i18n.format('DAGGERHEART.Chat.AttackRoll.Title', {
             attack: this.item.name

module/data/item/class.mjs

@@ -1,5 +1,6 @@
 import BaseDataItem from './base.mjs';
 import ForeignDocumentUUIDField from '../fields/foreignDocumentUUIDField.mjs';
+import ActionField from '../fields/actionField.mjs';
 
 export default class DHClass extends BaseDataItem {
     /** @inheritDoc */
@@ -19,7 +20,8 @@ export default class DHClass extends BaseDataItem {
             domains: new fields.ArrayField(new fields.StringField(), { max: 2 }),
             classItems: new fields.ArrayField(new ForeignDocumentUUIDField({ type: 'Item' })),
             evasion: new fields.NumberField({ initial: 0, integer: true }),
-            features: new fields.ArrayField(new ForeignDocumentUUIDField({ type: 'Item' })),
+            hopeFeatures: new foundry.data.fields.ArrayField(new ActionField()),
+            classFeatures: new foundry.data.fields.ArrayField(new ActionField()),
             subclasses: new fields.ArrayField(
                 new ForeignDocumentUUIDField({ type: 'Item', required: false, nullable: true, initial: undefined })
             ),
@@ -51,6 +53,10 @@ export default class DHClass extends BaseDataItem {
         };
     }
 
+    get hopeFeature() {
+        return this.hopeFeatures.length > 0 ? this.hopeFeatures[0] : null;
+    }
+
     async _preCreate(data, options, user) {
         const allowed = await super._preCreate(data, options, user);
         if (allowed === false) return;

module/data/item/subclass.mjs

@@ -1,6 +1,15 @@
+import ActionField from '../fields/actionField.mjs';
 import ForeignDocumentUUIDField from '../fields/foreignDocumentUUIDField.mjs';
 import BaseDataItem from './base.mjs';
 
+const featureSchema = () => {
+    return new foundry.data.fields.SchemaField({
+        name: new foundry.data.fields.StringField({ required: true }),
+        effects: new foundry.data.fields.ArrayField(new ForeignDocumentUUIDField({ type: 'ActiveEffect' })),
+        actions: new foundry.data.fields.ArrayField(new ActionField())
+    });
+};
+
 export default class DHSubclass extends BaseDataItem {
     /** @inheritDoc */
     static get metadata() {
@@ -22,9 +31,9 @@ export default class DHSubclass extends BaseDataItem {
                 nullable: true,
                 initial: null
             }),
-            foundationFeature: new ForeignDocumentUUIDField({ type: 'Item' }),
-            specializationFeature: new ForeignDocumentUUIDField({ type: 'Item' }),
-            masteryFeature: new ForeignDocumentUUIDField({ type: 'Item' }),
+            foundationFeature: featureSchema(),
+            specializationFeature: featureSchema(),
+            masteryFeature: featureSchema(),
             featureState: new fields.NumberField({ required: true, initial: 1, min: 1 }),
             isMulticlass: new fields.BooleanField({ initial: false })
         };