Merge branch 'main' into Irk/208-dr-roll-bug

# Conflicts:
#	module/applications/roll.mjs

module/applications/_module.mjs

@@ -12,7 +12,7 @@ export { default as DhpConsumable } from './sheets/items/consumable.mjs';
 export { default as DhpWeapon } from './sheets/items/weapon.mjs';
 export { default as DhpArmor } from './sheets/items/armor.mjs';
 export { default as DhpChatMessage } from './chatMessage.mjs';
-export { default as DhpEnvironment } from './sheets/environment.mjs';
+export { default as DhpEnvironment } from './sheets/actors/environment.mjs';
 export { default as DhActiveEffectConfig } from './sheets/activeEffectConfig.mjs';
 export { default as DhContextMenu } from './contextMenu.mjs';
 

module/applications/npcRollSelectionDialog.mjs

@@ -1,3 +1,5 @@
+/** NOT USED ANYMORE - TO BE DELETED **/
+
 const { HandlebarsApplicationMixin, ApplicationV2 } = foundry.applications.api;
 
 export default class NpcRollSelectionDialog extends HandlebarsApplicationMixin(ApplicationV2) {

module/applications/roll.mjs

@@ -9,6 +9,7 @@ import { setDiceSoNiceForDualityRoll } from '../helpers/utils.mjs';
 */
 
 export class DHRoll extends Roll {
+    baseTerms = [];
     constructor(formula, data, options) {
         super(formula, data, options);
     }
@@ -38,6 +39,7 @@ export class DHRoll extends Roll {
         if (config.dialog.configure !== false) {
             // Open Roll Dialog
             const DialogClass = config.dialog?.class ?? this.DefaultDialog;
+            console.log(roll, config);
             const configDialog = await DialogClass.configure(roll, config, message);
             if (!configDialog) return;
         }
@@ -99,9 +101,27 @@ export class DHRoll extends Roll {
             config.dialog.configure ??= !(config.event.shiftKey || config.event.altKey || config.event.ctrlKey);
     }
 
+    formatModifier(modifier) {
+        const numTerm = modifier < 0 ? '-' : '+';
+        return [
+            new foundry.dice.terms.OperatorTerm({ operator: numTerm }),
+            new foundry.dice.terms.NumericTerm({ number: Math.abs(modifier) })
+        ];
+    }
+
+    getFaces(faces) {
+        return Number(faces.startsWith('d') ? faces.replace('d', '') : faces);
+    }
+
     constructFormula(config) {
-        // const formula = Roll.replaceFormulaData(this.options.roll.formula, config.data);
         this.terms = Roll.parse(this.options.roll.formula, config.data);
+
+        if (this.options.extraFormula) {
+            this.terms.push(
+                new foundry.dice.terms.OperatorTerm({ operator: '+' }),
+                ...this.constructor.parse(this.options.extraFormula, this.options.data)
+            );
+        }
         return (this._formula = this.constructor.getFormula(this.terms));
     }
 }
@@ -115,10 +135,6 @@ export class DualityDie extends foundry.dice.terms.Die {
 export class D20Roll extends DHRoll {
     constructor(formula, data = {}, options = {}) {
         super(formula, data, options);
-        // this.createBaseDice();
-        // this.configureModifiers();
-
-        // this._formula = this.resetFormula();
         this.constructFormula();
     }
 
@@ -141,7 +157,7 @@ export class D20Roll extends DHRoll {
 
     set d20(faces) {
         if (!(this.terms[0] instanceof foundry.dice.terms.Die)) this.createBaseDice();
-        this.terms[0].faces = faces;
+        this.terms[0].faces = this.getFaces(faces);
     }
 
     get dAdvantage() {
@@ -154,11 +170,11 @@ export class D20Roll extends DHRoll {
     }
 
     get hasAdvantage() {
-        return this.options.advantage === this.constructor.ADV_MODE.ADVANTAGE;
+        return this.options.roll.advantage === this.constructor.ADV_MODE.ADVANTAGE;
     }
 
     get hasDisadvantage() {
-        return this.options.advantage === this.constructor.ADV_MODE.DISADVANTAGE;
+        return this.options.roll.advantage === this.constructor.ADV_MODE.DISADVANTAGE;
     }
 
     static applyKeybindings(config) {
@@ -180,18 +196,56 @@ export class D20Roll extends DHRoll {
         config.dialog.configure ??= !Object.values(keys).some(k => k);
 
         // Determine advantage mode
-        const advantage = config.advantage || keys.advantage;
-        const disadvantage = config.disadvantage || keys.disadvantage;
-        if (advantage && !disadvantage) config.advantage = this.ADV_MODE.ADVANTAGE;
-        else if (!advantage && disadvantage) config.advantage = this.ADV_MODE.DISADVANTAGE;
-        else config.advantage = this.ADV_MODE.NORMAL;
+        const advantage = config.roll.advantage === this.ADV_MODE.ADVANTAGE || keys.advantage || config.advantage;
+        const disadvantage =
+            config.roll.advantage === this.ADV_MODE.DISADVANTAGE || keys.disadvantage || config.disadvantage;
+        if (advantage && !disadvantage) config.roll.advantage = this.ADV_MODE.ADVANTAGE;
+        else if (!advantage && disadvantage) config.roll.advantage = this.ADV_MODE.DISADVANTAGE;
+        else config.roll.advantage = this.ADV_MODE.NORMAL;
+    }
+
+    constructFormula(config) {
+        // this.terms = [];
+        this.createBaseDice();
+        this.configureModifiers();
+        this.resetFormula();
+        return this._formula;
     }
 
     createBaseDice() {
-        if (this.terms[0] instanceof foundry.dice.terms.Die) return;
+        if (this.terms[0] instanceof foundry.dice.terms.Die) {
+            this.terms = [this.terms[0]];
+            return;
+        }
         this.terms[0] = new foundry.dice.terms.Die({ faces: 20 });
     }
 
+    configureModifiers() {
+        this.applyAdvantage();
+        this.applyBaseBonus();
+
+        this.options.experiences?.forEach(m => {
+            if (this.options.data.experiences?.[m])
+                this.options.roll.modifiers.push({
+                    label: this.options.data.experiences[m].name,
+                    value: this.options.data.experiences[m].total ?? this.options.data.experiences[m].value
+                });
+        });
+
+        this.options.roll.modifiers?.forEach(m => {
+            this.terms.push(...this.formatModifier(m.value));
+        });
+
+        this.baseTerms = foundry.utils.deepClone(this.terms);
+
+        if (this.options.extraFormula) {
+            this.terms.push(
+                new foundry.dice.terms.OperatorTerm({ operator: '+' }),
+                ...this.constructor.parse(this.options.extraFormula, this.options.data)
+            );
+        }
+    }
+
     applyAdvantage() {
         this.d20.modifiers.findSplice(m => ['kh', 'kl'].includes(m));
         if (!this.hasAdvantage && !this.hasDisadvantage) this.number = 1;
@@ -201,47 +255,26 @@ export class D20Roll extends DHRoll {
         }
     }
 
-    // Trait bonus != Adversary
-    configureModifiers() {
-        this.applyAdvantage();
-        // this.options.roll.modifiers = [];
-        this.applyBaseBonus();
-
-        this.options.experiences?.forEach(m => {
-            if (this.options.data.experiences?.[m])
-                this.options.roll.modifiers.push({
-                    label: this.options.data.experiences[m].name,
-                    value: this.options.data.experiences[m].total ?? this.options.data.experiences[m].value
-                });
-        });
-        this.options.roll.modifiers?.forEach(m => {
-            this.terms.push(...this.formatModifier(m.value));
-        });
-
-        if (this.options.extraFormula) {
-            this.terms.push(
-                new foundry.dice.terms.OperatorTerm({ operator: '+' }),
-                ...this.constructor.parse(this.options.extraFormula, this.getRollData())
-            );
-        }
-        // this.resetFormula();
-    }
-
-    constructFormula(config) {
-        this.terms = [];
-        this.createBaseDice();
-        this.configureModifiers();
-        this.resetFormula();
-        return this._formula;
-    }
-
     applyBaseBonus() {
-        this.options.roll.modifiers = [
-            {
-                label: 'Bonus to Hit',
-                value: Roll.replaceFormulaData('@attackBonus', this.data)
-            }
-        ];
+        this.options.roll.modifiers = [];
+        if (!this.options.roll.bonus) return;
+        this.options.roll.modifiers.push({
+            label: 'Bonus to Hit',
+            value: this.options.roll.bonus
+            // value: Roll.replaceFormulaData('@attackBonus', this.data)
+        });
+    }
+
+    static async buildEvaluate(roll, config = {}, message = {}) {
+        if (config.evaluate !== false) await roll.evaluate();
+        const advantageState =
+            config.roll.advantage == this.ADV_MODE.ADVANTAGE
+                ? true
+                : config.roll.advantage == this.ADV_MODE.DISADVANTAGE
+                  ? false
+                  : null;
+        setDiceSoNiceForDualityRoll(roll, advantageState);
+        this.postEvaluate(roll, config);
     }
 
     static postEvaluate(roll, config = {}) {
@@ -254,23 +287,27 @@ export class D20Roll extends DHRoll {
         } else if (config.roll.difficulty)
             config.roll.success = roll.isCritical || roll.total >= config.roll.difficulty;
         config.roll.advantage = {
-            type: config.advantage,
+            type: config.roll.advantage,
             dice: roll.dAdvantage?.denomination,
             value: roll.dAdvantage?.total
         };
-        config.roll.modifierTotal = config.roll.modifiers.reduce((a, c) => a + Number(c.value), 0);
-    }
-
-    getRollData() {
-        return this.options.data;
-    }
-
-    formatModifier(modifier) {
-        const numTerm = modifier < 0 ? '-' : '+';
-        return [
-            new foundry.dice.terms.OperatorTerm({ operator: numTerm }),
-            new foundry.dice.terms.NumericTerm({ number: Math.abs(modifier) })
-        ];
+        config.roll.extra = roll.dice
+            .filter(d => !roll.baseTerms.includes(d))
+            .map(d => {
+                return {
+                    dice: d.denomination,
+                    value: d.total
+                };
+            });
+        config.roll.modifierTotal = 0;
+        for (let i = 0; i < roll.terms.length; i++) {
+            if (
+                roll.terms[i] instanceof foundry.dice.terms.NumericTerm &&
+                !!roll.terms[i - 1] &&
+                roll.terms[i - 1] instanceof foundry.dice.terms.OperatorTerm
+            )
+                config.roll.modifierTotal += Number(`${roll.terms[i - 1].operator}${roll.terms[i].total}`);
+        }
     }
 
     resetFormula() {
@@ -279,6 +316,8 @@ export class D20Roll extends DHRoll {
 }
 
 export class DualityRoll extends D20Roll {
+    _advantageFaces = 6;
+
     constructor(formula, data = {}, options = {}) {
         super(formula, data, options);
     }
@@ -296,7 +335,7 @@ export class DualityRoll extends D20Roll {
 
     set dHope(faces) {
         if (!(this.dice[0] instanceof CONFIG.Dice.daggerheart.DualityDie)) this.createBaseDice();
-        this.terms[0].faces = faces;
+        this.terms[0].faces = this.getFaces(faces);
         // this.#hopeDice = `d${face}`;
     }
 
@@ -309,7 +348,7 @@ export class DualityRoll extends D20Roll {
 
     set dFear(faces) {
         if (!(this.dice[1] instanceof CONFIG.Dice.daggerheart.DualityDie)) this.createBaseDice();
-        this.dice[1].faces = faces;
+        this.dice[1].faces = this.getFaces(faces);
         // this.#fearDice = `d${face}`;
     }
 
@@ -317,6 +356,14 @@ export class DualityRoll extends D20Roll {
         return this.dice[2];
     }
 
+    get advantageFaces() {
+        return this._advantageFaces;
+    }
+
+    set advantageFaces(faces) {
+        this._advantageFaces = this.getFaces(faces);
+    }
+
     get isCritical() {
         if (!this.dHope._evaluated || !this.dFear._evaluated) return;
         return this.dHope.total === this.dFear.total;
@@ -346,21 +393,23 @@ export class DualityRoll extends D20Roll {
         return game.i18n.localize(label);
     }
 
+    updateFormula() {}
+
     createBaseDice() {
         if (
             this.dice[0] instanceof CONFIG.Dice.daggerheart.DualityDie &&
             this.dice[1] instanceof CONFIG.Dice.daggerheart.DualityDie
-        )
+        ) {
+            this.terms = [this.terms[0], this.terms[1], this.terms[2]];
             return;
-        if (!(this.dice[0] instanceof CONFIG.Dice.daggerheart.DualityDie))
-            this.terms[0] = new CONFIG.Dice.daggerheart.DualityDie();
+        }
+        this.terms[0] = new CONFIG.Dice.daggerheart.DualityDie();
         this.terms[1] = new foundry.dice.terms.OperatorTerm({ operator: '+' });
-        if (!(this.dice[2] instanceof CONFIG.Dice.daggerheart.DualityDie))
-            this.terms[2] = new CONFIG.Dice.daggerheart.DualityDie();
+        this.terms[2] = new CONFIG.Dice.daggerheart.DualityDie();
     }
 
     applyAdvantage() {
-        const dieFaces = 6,
+        const dieFaces = this.advantageFaces,
             bardRallyFaces = this.hasBarRally,
             advDie = new foundry.dice.terms.Die({ faces: dieFaces });
         if (this.hasAdvantage || this.hasDisadvantage || bardRallyFaces)
@@ -381,28 +430,12 @@ export class DualityRoll extends D20Roll {
     }
 
     applyBaseBonus() {
-        if (this.options.roll.trait) {
-            this.options.roll.modifiers = [
-                {
-                    label: `DAGGERHEART.Abilities.${this.options.roll.trait}.name`,
-                    value: Roll.replaceFormulaData(`@traits.${this.options.roll.trait}.total`, this.data)
-                }
-            ];
-        } else {
-            this.options.roll.modifiers = [];
-        }
-    }
-
-    static async buildEvaluate(roll, config = {}, message = {}) {
-        if (config.evaluate !== false) await roll.evaluate();
-        const advantageState =
-            config.advantage == this.ADV_MODE.ADVANTAGE
-                ? true
-                : config.advantage == this.ADV_MODE.DISADVANTAGE
-                  ? false
-                  : null;
-        setDiceSoNiceForDualityRoll(roll, advantageState);
-        this.postEvaluate(roll, config);
+        this.options.roll.modifiers = [];
+        if (!this.options.roll.trait) return;
+        this.options.roll.modifiers.push({
+            label: `DAGGERHEART.Abilities.${this.options.roll.trait}.name`,
+            value: Roll.replaceFormulaData(`@traits.${this.options.roll.trait}.total`, this.data)
+        });
     }
 
     static postEvaluate(roll, config = {}) {

module/applications/rollSelectionDialog.mjs

@@ -1,3 +1,5 @@
+/** NOT USED ANYMORE - TO BE DELETED **/
+
 const { ApplicationV2, HandlebarsApplicationMixin } = foundry.applications.api;
 
 export default class RollSelectionDialog extends HandlebarsApplicationMixin(ApplicationV2) {

module/applications/sheets/actors/adversary.mjs

@@ -87,7 +87,7 @@ export default class AdversarySheet extends DaggerheartSheet(ActorSheetV2) {
             event: event,
             title: `${this.actor.name} - Reaction Roll`,
             roll: {
-                modifier: null,
+                // modifier: null,
                 type: 'reaction'
             },
             chatMessage: {

module/applications/sheets/actors/environment.mjs

@@ -0,0 +1,131 @@
+import DaggerheartSheet from '../daggerheart-sheet.mjs';
+import DHEnvironmentSettings from '../applications/environment-settings.mjs';
+
+const { ActorSheetV2 } = foundry.applications.sheets;
+export default class DhpEnvironment extends DaggerheartSheet(ActorSheetV2) {
+    static DEFAULT_OPTIONS = {
+        tag: 'form',
+        classes: ['daggerheart', 'sheet', 'actor', 'dh-style', 'environment'],
+        position: {
+            width: 500
+        },
+        actions: {
+            addAdversary: this.addAdversary,
+            deleteProperty: this.deleteProperty,
+            viewAdversary: this.viewAdversary,
+            openSettings: this.openSettings,
+            useItem: this.useItem,
+            toChat: this.toChat
+        },
+        form: {
+            handler: this._updateForm,
+            submitOnChange: true,
+            closeOnSubmit: false
+        },
+        dragDrop: [{ dragSelector: '.action-section .inventory-item', dropSelector: null }]
+    };
+
+    static PARTS = {
+        header: { template: 'systems/daggerheart/templates/sheets/actors/environment/header.hbs' },
+        actions: { template: 'systems/daggerheart/templates/sheets/actors/environment/actions.hbs' },
+        potentialAdversaries: {
+            template: 'systems/daggerheart/templates/sheets/actors/environment/potentialAdversaries.hbs'
+        },
+        notes: { template: 'systems/daggerheart/templates/sheets/actors/environment/notes.hbs' }
+    };
+
+    static TABS = {
+        actions: {
+            active: true,
+            cssClass: '',
+            group: 'primary',
+            id: 'actions',
+            icon: null,
+            label: 'DAGGERHEART.General.tabs.actions'
+        },
+        potentialAdversaries: {
+            active: false,
+            cssClass: '',
+            group: 'primary',
+            id: 'potentialAdversaries',
+            icon: null,
+            label: 'DAGGERHEART.General.tabs.potentialAdversaries'
+        },
+        notes: {
+            active: false,
+            cssClass: '',
+            group: 'primary',
+            id: 'notes',
+            icon: null,
+            label: 'DAGGERHEART.Sheets.Adversary.Tabs.notes'
+        }
+    };
+
+    async _prepareContext(_options) {
+        const context = await super._prepareContext(_options);
+        context.document = this.document;
+        context.tabs = super._getTabs(this.constructor.TABS);
+        context.getEffectDetails = this.getEffectDetails.bind(this);
+
+        return context;
+    }
+
+    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 openSettings() {
+        await new DHEnvironmentSettings(this.document).render(true);
+    }
+
+    static async _updateForm(event, _, formData) {
+        await this.document.update(formData.object);
+        this.render();
+    }
+
+    getEffectDetails(id) {
+        return {};
+    }
+
+    static async addAdversary() {
+        await this.document.update({
+            [`system.potentialAdversaries.${foundry.utils.randomID()}.label`]: game.i18n.localize(
+                'DAGGERHEART.Sheets.Environment.newAdversary'
+            )
+        });
+        this.render();
+    }
+
+    static async deleteProperty(_, target) {
+        await this.document.update({ [`${target.dataset.path}.-=${target.id}`]: null });
+        this.render();
+    }
+
+    static async viewAdversary(_, button) {
+        const adversary = await foundry.utils.fromUuid(button.dataset.adversary);
+        adversary.sheet.render(true);
+    }
+
+    static async useItem(event) {
+        const action = this.getAction(event);
+        action.use(event);
+    }
+
+    static async toChat(event) {
+        const item = this.getAction(event);
+        item.toChat(this.document.id);
+    }
+
+    async _onDragStart(event) {
+        const item = event.currentTarget.closest('.inventory-item');
+
+        if (item) {
+            const adversary = game.actors.find(x => x.type === 'adversary' && x.id === item.dataset.itemId);
+            const adversaryData = { type: 'Actor', uuid: adversary.uuid };
+            event.dataTransfer.setData('text/plain', JSON.stringify(adversaryData));
+            event.dataTransfer.setDragImage(item, 60, 0);
+        }
+    }
+}

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

@@ -103,6 +103,7 @@ export default class DHAdversarySettings extends HandlebarsApplicationMixin(Appl
         context.systemFields = this.actor.system.schema.fields;
         context.systemFields.attack.fields = this.actor.system.attack.schema.fields;
         context.isNPC = true;
+        console.log(context)
 
         return context;
     }
@@ -146,7 +147,6 @@ export default class DHAdversarySettings extends HandlebarsApplicationMixin(Appl
                         parent: this.actor
                     }
                 );
-            console.log(action);
             await this.actor.update({ 'system.actions': [...this.actor.system.actions, action] });
             await new DHActionConfig(this.actor.system.actions[this.actor.system.actions.length - 1]).render({
                 force: true

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

@@ -0,0 +1,213 @@
+import DHActionConfig from '../../config/Action.mjs';
+import DHBaseItemSheet from '../api/base-item.mjs';
+import { actionsTypes } from '../../../data/_module.mjs';
+
+const { HandlebarsApplicationMixin, ApplicationV2 } = foundry.applications.api;
+
+export default class DHEnvironmentSettings extends HandlebarsApplicationMixin(ApplicationV2) {
+    constructor(actor) {
+        super({});
+
+        this.actor = actor;
+        this._dragDrop = this._createDragDropHandlers();
+    }
+
+    get title() {
+        return `${game.i18n.localize('DAGGERHEART.Sheets.TABS.settings')}`;
+    }
+
+    static DEFAULT_OPTIONS = {
+        tag: 'form',
+        classes: ['daggerheart', 'dh-style', 'dialog', 'environment-settings'],
+        window: {
+            icon: 'fa-solid fa-wrench',
+            resizable: false
+        },
+        position: { width: 455, height: 'auto' },
+        actions: {
+            addAction: this.#addAction,
+            editAction: this.#editAction,
+            removeAction: this.#removeAction,
+            addCategory: this.#addCategory,
+            deleteProperty: this.#deleteProperty,
+            viewAdversary: this.#viewAdversary,
+            deleteAdversary: this.#deleteAdversary
+        },
+        form: {
+            handler: this.updateForm,
+            submitOnChange: true,
+            closeOnSubmit: false
+        },
+        dragDrop: [{ dragSelector: null, dropSelector: '.category-container' }]
+    };
+
+    static PARTS = {
+        header: {
+            id: 'header',
+            template: 'systems/daggerheart/templates/sheets/applications/environment-settings/header.hbs'
+        },
+        tabs: { template: 'systems/daggerheart/templates/sheets/global/tabs/tab-navigation.hbs' },
+        details: {
+            id: 'details',
+            template: 'systems/daggerheart/templates/sheets/applications/environment-settings/details.hbs'
+        },
+        actions: {
+            id: 'actions',
+            template: 'systems/daggerheart/templates/sheets/applications/environment-settings/actions.hbs'
+        },
+        adversaries: {
+            id: 'adversaries',
+            template: 'systems/daggerheart/templates/sheets/applications/environment-settings/adversaries.hbs'
+        }
+    };
+
+    static TABS = {
+        details: {
+            active: true,
+            cssClass: '',
+            group: 'primary',
+            id: 'details',
+            icon: null,
+            label: 'DAGGERHEART.General.tabs.details'
+        },
+        actions: {
+            active: false,
+            cssClass: '',
+            group: 'primary',
+            id: 'actions',
+            icon: null,
+            label: 'DAGGERHEART.General.tabs.actions'
+        },
+        adversaries: {
+            active: false,
+            cssClass: '',
+            group: 'primary',
+            id: 'adversaries',
+            icon: null,
+            label: 'DAGGERHEART.General.tabs.adversaries'
+        }
+    };
+
+    async _prepareContext(_options) {
+        const context = await super._prepareContext(_options);
+        context.document = this.actor;
+        context.tabs = this._getTabs(this.constructor.TABS);
+        context.systemFields = this.actor.system.schema.fields;
+        context.isNPC = true;
+
+        return context;
+    }
+
+    _attachPartListeners(partId, htmlElement, options) {
+        super._attachPartListeners(partId, htmlElement, options);
+
+        this._dragDrop.forEach(d => d.bind(htmlElement));
+    }
+
+    _createDragDropHandlers() {
+        return this.options.dragDrop.map(d => {
+            d.callbacks = {
+                drop: this._onDrop.bind(this)
+            };
+            return new foundry.applications.ux.DragDrop.implementation(d);
+        });
+    }
+
+    _getTabs(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' : '';
+        }
+
+        return tabs;
+    }
+
+    static async #addAction(_event, _button) {
+        const actionType = await DHBaseItemSheet.selectActionType();
+        if (!actionType) return;
+        try {
+            const cls = actionsTypes[actionType] ?? actionsTypes.attack,
+                action = new cls(
+                    {
+                        _id: foundry.utils.randomID(),
+                        type: actionType,
+                        name: game.i18n.localize(SYSTEM.ACTIONS.actionTypes[actionType].name),
+                        ...cls.getSourceConfig(this.actor)
+                    },
+                    {
+                        parent: this.actor
+                    }
+                );
+            await this.actor.update({ 'system.actions': [...this.actor.system.actions, action] });
+            await new DHActionConfig(this.actor.system.actions[this.actor.system.actions.length - 1]).render({
+                force: true
+            });
+            this.render();
+        } catch (error) {
+            console.log(error);
+        }
+    }
+
+    static async #editAction(event, target) {
+        event.stopPropagation();
+        const actionIndex = target.dataset.index;
+        await new DHActionConfig(this.actor.system.actions[actionIndex]).render({
+            force: true
+        });
+    }
+
+    static async #removeAction(event, target) {
+        event.stopPropagation();
+        const actionIndex = target.dataset.index;
+        await this.actor.update({
+            'system.actions': this.actor.system.actions.filter((_, index) => index !== Number.parseInt(actionIndex))
+        });
+        this.render();
+    }
+
+    static async #addCategory() {
+        await this.actor.update({
+            [`system.potentialAdversaries.${foundry.utils.randomID()}.label`]: game.i18n.localize(
+                'DAGGERHEART.Sheets.Environment.newAdversary'
+            )
+        });
+        this.render();
+    }
+
+    static async #deleteProperty(_, target) {
+        await this.actor.update({ [`${target.dataset.path}.-=${target.id}`]: null });
+        this.render();
+    }
+
+    static async #viewAdversary(_, button) {
+        const adversary = await foundry.utils.fromUuid(button.dataset.adversary);
+        adversary.sheet.render(true);
+    }
+
+    static async #deleteAdversary(event, target) {
+        const adversaryKey = target.dataset.adversary;
+        const path = `system.potentialAdversaries.${target.dataset.potentialAdversary}.adversaries`;
+        const newAdversaries = foundry.utils.getProperty(this.actor, path).filter(x => x.uuid !== adversaryKey);
+        await this.actor.update({ [path]: newAdversaries });
+        this.render();
+    }
+
+    async _onDrop(event) {
+        const data = TextEditor.getDragEventData(event);
+        const item = await fromUuid(data.uuid);
+        if (item.type === 'adversary') {
+            const target = event.target.closest('.category-container');
+            const path = `system.potentialAdversaries.${target.dataset.potentialAdversary}.adversaries`;
+            const current = foundry.utils.getProperty(this.actor, path).map(x => x.uuid);
+            await this.actor.update({
+                [path]: [...current, item.uuid]
+            });
+            this.render();
+        }
+    }
+
+    static async updateForm(event, _, formData) {
+        await this.actor.update(formData.object);
+        this.render();
+    }
+}

module/applications/sheets/daggerheart-sheet.mjs

@@ -60,7 +60,7 @@ export default function DhpApplicationMixin(Base) {
                 //   drop: this._canDragDrop.bind(this)
                 // };
                 d.callbacks = {
-                    // dragstart: this._onDragStart.bind(this),
+                    dragstart: this._onDragStart.bind(this),
                     // dragover: this._onDragOver.bind(this),
                     drop: this._onDrop.bind(this)
                 };
@@ -68,6 +68,7 @@ export default function DhpApplicationMixin(Base) {
             });
         }
 
+        async _onDragStart(event) {}
         _onDrop(event) {}
 
         _getTabs(tabs) {

module/applications/sheets/environment.mjs

@@ -1,107 +0,0 @@
-import DaggerheartSheet from './daggerheart-sheet.mjs';
-
-const { ActorSheetV2 } = foundry.applications.sheets;
-export default class DhpEnvironment extends DaggerheartSheet(ActorSheetV2) {
-    static DEFAULT_OPTIONS = {
-        tag: 'form',
-        classes: ['daggerheart', 'sheet', 'actor', 'dh-style', 'environment'],
-        position: {
-            width: 450,
-            height: 1000
-        },
-        actions: {
-            addAdversary: this.addAdversary,
-            addFeature: this.addFeature,
-            deleteProperty: this.deleteProperty,
-            viewAdversary: this.viewAdversary
-        },
-        form: {
-            handler: this._updateForm,
-            submitOnChange: true,
-            closeOnSubmit: false
-        },
-        dragDrop: [{ dragSelector: null, dropSelector: '.adversary-container' }]
-    };
-
-    static PARTS = {
-        header: { template: 'systems/daggerheart/templates/sheets/actors/environment/header.hbs' },
-        tabs: { template: 'systems/daggerheart/templates/sheets/global/tabs/tab-navigation.hbs' },
-        main: { template: 'systems/daggerheart/templates/sheets/actors/environment/main.hbs' },
-        information: { template: 'systems/daggerheart/templates/sheets/actors/environment/information.hbs' }
-    };
-
-    static TABS = {
-        main: {
-            active: true,
-            cssClass: '',
-            group: 'primary',
-            id: 'main',
-            icon: null,
-            label: 'DAGGERHEART.Sheets.Environment.Tabs.Main'
-        },
-        information: {
-            active: false,
-            cssClass: '',
-            group: 'primary',
-            id: 'information',
-            icon: null,
-            label: 'DAGGERHEART.Sheets.Environment.Tabs.Information'
-        }
-    };
-
-    async _prepareContext(_options) {
-        const context = await super._prepareContext(_options);
-        context.document = this.document;
-        context.tabs = super._getTabs(this.constructor.TABS);
-        context.getEffectDetails = this.getEffectDetails.bind(this);
-
-        return context;
-    }
-
-    static async _updateForm(event, _, formData) {
-        await this.document.update(formData.object);
-        this.render();
-    }
-
-    getEffectDetails(id) {
-        return {};
-    }
-
-    static async addAdversary() {
-        await this.document.update({
-            [`system.potentialAdversaries.${foundry.utils.randomID()}.label`]: game.i18n.localize(
-                'DAGGERHEART.Sheets.Environment.newAdversary'
-            )
-        });
-        this.render();
-    }
-
-    static async addFeature() {
-        ui.notifications.error('Not Implemented yet. Awaiting datamodel rework');
-    }
-
-    static async deleteProperty(_, target) {
-        await this.document.update({ [`${target.dataset.path}.-=${target.id}`]: null });
-        this.render();
-    }
-
-    static async viewAdversary(_, button) {
-        const adversary = foundry.utils.getProperty(
-            this.document.system.potentialAdversaries,
-            `${button.dataset.potentialAdversary}.adversaries.${button.dataset.adversary}`
-        );
-        adversary.sheet.render(true);
-    }
-
-    async _onDrop(event) {
-        const data = TextEditor.getDragEventData(event);
-        const item = await fromUuid(data.uuid);
-        if (item.type === 'adversary') {
-            const target = event.target.closest('.adversary-container');
-            const path = `system.potentialAdversaries.${target.dataset.potentialAdversary}.adversaries.${item.id}`;
-            await this.document.update({
-                [path]: item.uuid
-            });
-        }
-    }
-}