Merged with refactor/84-data-models-structure

module/applications/sheets/activeEffectConfig.mjs

@@ -0,0 +1,62 @@
+export default class DhActiveEffectConfig extends ActiveEffectConfig {
+    static DEFAULT_OPTIONS = {
+        classes: ['daggerheart', 'sheet', 'dh-style']
+    };
+
+    static PARTS = {
+        header: { template: 'systems/daggerheart/templates/sheets/activeEffect/header.hbs' },
+        tabs: { template: 'templates/generic/tab-navigation.hbs' },
+        details: { template: 'systems/daggerheart/templates/sheets/activeEffect/details.hbs', scrollable: [''] },
+        duration: { template: 'systems/daggerheart/templates/sheets/activeEffect/duration.hbs' },
+        changes: {
+            template: 'systems/daggerheart/templates/sheets/activeEffect/changes.hbs',
+            scrollable: ['ol[data-changes]']
+        },
+        footer: { template: 'systems/daggerheart/templates/sheets/global/tabs/tab-form-footer.hbs' }
+    };
+
+    static TABS = {
+        sheet: {
+            tabs: [
+                { id: 'details', icon: 'fa-solid fa-book' },
+                { id: 'duration', icon: 'fa-solid fa-clock' },
+                { id: 'changes', icon: 'fa-solid fa-gears' }
+            ],
+            initial: 'details',
+            labelPrefix: 'EFFECT.TABS'
+        }
+    };
+
+    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/adversary.mjs

@@ -1,219 +1,12 @@
-// import DhpApplicationMixin from '../daggerheart-sheet.mjs';
-
-// export class Teest extends DhpApplicationMixin(ActorSheet) {
-//     static documentType = "adversary";
-
-//     constructor(options){
-//         super(options);
-
-//         this.editMode = false;
-//     }
-
-//     /** @override */
-//     static get defaultOptions() {
-//         return foundry.utils.mergeObject(super.defaultOptions, {
-//             classes: ["daggerheart", "sheet", "adversary"],
-//             width: 600,
-//             height: 'auto',
-//             resizable: false,
-//         });
-//     }
-
-//     async getData() {
-//         const context = super.getData();
-//         context.config = SYSTEM;
-//         context.editMode = this.editMode;
-//         context.title = `${this.actor.name} - ${game.i18n.localize(SYSTEM.ACTOR.adversaryTypes[this.actor.system.type].name)}`;
-
-//         context.data = {
-//             description: this.object.system.description,
-//             motivesAndTactics: this.object.system.motivesAndTactics.join(', '),
-//             tier: this.object.system.tier,
-//             type: game.i18n.localize(SYSTEM.ACTOR.adversaryTypes[this.object.system.type].name),
-//             attack: {
-//                 name: this.object.system.attack.name,
-//                 attackModifier: this.object.system.attackModifier,
-//                 range: this.object.system.attack.range ? game.i18n.localize(SYSTEM.GENERAL.range[this.object.system.attack.range].name) : null,
-//                 damage: {
-//                     value: this.object.system.attack.damage.value,
-//                     type: this.object.system.attack.damage.type,
-//                     typeName: this.object.system.attack.damage.type ? game.i18n.localize(SYSTEM.GENERAL.damageTypes[this.object.system.attack.damage.type].abbreviation).toLowerCase() : null,
-//                 },
-//             },
-//             damageThresholds: this.object.system.damageThresholds,
-//             difficulty: this.object.system.difficulty,
-//             hp: { ...this.object.system.resources.health, lastRowIndex: Math.floor(this.object.system.resources.health.max/5)*5 },
-//             stress: { ...this.object.system.resources.stress, lastRowIndex: Math.floor(this.object.system.resources.stress.max/5)*5  },
-//             moves: this.object.system.moves,
-//         };
-
-//         return context;
-//     }
-
-//     async _handleAction(action, event, button) {
-//         switch(action){
-//             case 'viewMove':
-//                 await this.viewMove(button);
-//                 break;
-//             case 'addMove':
-//                 this.addMove();
-//                 break;
-//             case 'removeMove':
-//                 await this.removeMove(button);
-//                 break;
-//             case 'toggleSlider':
-//                 this.toggleEditMode();
-//                 break;
-//             case 'addMotive':
-//                 await this.addMotive();
-//                 break;
-//             case 'removeMotive':
-//                 await this.removeMotive(button);
-//                 break;
-//             case 'reactionRoll':
-//                 await this.reactionRoll(event);
-//                 break;
-//             case 'attackRoll':
-//                 await this.attackRoll(event);
-//                 break;
-//             case 'addExperience':
-//                 await this.addExperience();
-//                 break;
-//             case 'removeExperience':
-//                 await this.removeExperience(button);
-//                 break;
-//             case 'toggleHP':
-//                 await this.toggleHP(button);
-//                 break;
-//             case 'toggleStress':
-//                 await this.toggleStress(button);
-//                 break;
-//         }
-//     }
-
-//     async viewMove(button){
-//         const move = await fromUuid(button.dataset.move);
-//         move.sheet.render(true);
-//     }
-
-//     async addMove(){
-//         const result = await this.object.createEmbeddedDocuments("Item", [{
-//             name: game.i18n.localize('DAGGERHEART.Sheets.Adversary.NewMove'),
-//             type: 'feature',
-//         }]);
-
-//         await result[0].sheet.render(true);
-//     }
-
-//     async removeMove(button){
-//         await this.object.items.find(x => x.uuid === button.dataset.move).delete();
-//     }
-
-//     toggleEditMode(){
-//         this.editMode = !this.editMode;
-//         this.render();
-//     }
-
-//     async addMotive(){
-//         await this.object.update({ "system.motivesAndTactics": [...this.object.system.motivesAndTactics, ''] });
-//     }
-
-//     async removeMotive(button){
-//         await this.object.update({ "system.motivesAndTactics": this.object.system.motivesAndTactics.filter((_, index) => index !== Number.parseInt(button.dataset.motive) )});
-//     }
-
-//     async reactionRoll(event){
-//         const { roll, diceResults, modifiers } = await this.actor.diceRoll({ title: `${this.actor.name} - Reaction Roll`, value: 0 }, event.shiftKey);
-
-//         const cls = getDocumentClass("ChatMessage");
-//         const msg = new cls({
-//             type: 'adversaryRoll',
-//             system: {
-//                 roll: roll._formula,
-//                 total: roll._total,
-//                 modifiers: modifiers,
-//                 diceResults: diceResults,
-//             },
-//             content: "systems/daggerheart/templates/chat/adversary-roll.hbs",
-//             rolls: [roll]
-//         });
-
-//         cls.create(msg.toObject());
-//     }
-
-//     async attackRoll(event){
-//         const modifier = Number.parseInt(event.currentTarget.dataset.value);
-
-//         const { roll, diceResults, modifiers } = await this.actor.diceRoll({ title: `${this.actor.name} - Attack Roll`, value: modifier }, event.shiftKey);
-
-//         const targets = Array.from(game.user.targets).map(x => ({
-//             id: x.id,
-//             name: x.actor.name,
-//             img: x.actor.img,
-//             difficulty: x.actor.system.difficulty,
-//             evasion: x.actor.system.evasion,
-//         }));
-
-//         const cls = getDocumentClass("ChatMessage");
-//         const msg = new cls({
-//             type: 'adversaryRoll',
-//             system: {
-//                 roll: roll._formula,
-//                 total: roll._total,
-//                 modifiers: modifiers,
-//                 diceResults: diceResults,
-//                 targets: targets,
-//                 damage: { value: event.currentTarget.dataset.damage, type: event.currentTarget.dataset.damageType },
-//             },
-//             content: "systems/daggerheart/templates/chat/adversary-attack-roll.hbs",
-//             rolls: [roll]
-//         });
-
-//         cls.create(msg.toObject());
-//     }
-
-//     async addExperience(){
-//         await this.object.update({ "system.experiences": [...this.object.system.experiences, { name: 'Experience', value: 1 }] });
-//     }
-
-//     async removeExperience(button){
-//         await this.object.update({ "system.experiences": this.object.system.experiences.filter((_, index) => index !== Number.parseInt(button.dataset.experience) )});
-//     }
-
-//     async toggleHP(button){
-//         const index = Number.parseInt(button.dataset.index);
-//         const newHP = index < this.object.system.resources.health.value ? index : index+1;
-//         await this.object.update({ "system.resources.health.value": newHP });
-//     }
-
-//     async toggleStress(button){
-//         const index = Number.parseInt(button.dataset.index);
-//         const newStress = index < this.object.system.resources.stress.value ? index : index+1;
-//         await this.object.update({ "system.resources.stress.value": newStress });
-//     }
-// }
-
 import DaggerheartSheet from './daggerheart-sheet.mjs';
 
 const { ActorSheetV2 } = foundry.applications.sheets;
 export default class AdversarySheet extends DaggerheartSheet(ActorSheetV2) {
-    constructor(options = {}) {
-        super(options);
-
-        this.editMode = false;
-    }
-
     static DEFAULT_OPTIONS = {
         tag: 'form',
-        classes: ['daggerheart', 'sheet', 'adversary'],
-        position: { width: 600 },
+        classes: ['daggerheart', 'sheet', 'actor', 'dh-style', 'adversary'],
+        position: { width: 450, height: 1000 },
         actions: {
-            viewMove: this.viewMove,
-            addMove: this.addMove,
-            removeMove: this.removeMove,
-            toggleSlider: this.toggleEditMode,
-            addMotive: this.addMotive,
-            removeMotive: this.removeMotive,
             reactionRoll: this.reactionRoll,
             attackRoll: this.attackRoll,
             addExperience: this.addExperience,
@@ -229,54 +22,35 @@ export default class AdversarySheet extends DaggerheartSheet(ActorSheetV2) {
     };
 
     static PARTS = {
-        form: {
-            id: 'feature',
-            template: 'systems/daggerheart/templates/sheets/adversary.hbs'
+        header: { template: 'systems/daggerheart/templates/sheets/actors/adversary/header.hbs' },
+        tabs: { template: 'systems/daggerheart/templates/sheets/global/tabs/tab-navigation.hbs' },
+        main: { template: 'systems/daggerheart/templates/sheets/actors/adversary/main.hbs' },
+        information: { template: 'systems/daggerheart/templates/sheets/actors/adversary/information.hbs' }
+    };
+
+    static TABS = {
+        main: {
+            active: true,
+            cssClass: '',
+            group: 'primary',
+            id: 'main',
+            icon: null,
+            label: 'DAGGERHEART.Sheets.Adversary.Tabs.Main'
+        },
+        information: {
+            active: false,
+            cssClass: '',
+            group: 'primary',
+            id: 'information',
+            icon: null,
+            label: 'DAGGERHEART.Sheets.Adversary.Tabs.Information'
         }
     };
 
     async _prepareContext(_options) {
         const context = await super._prepareContext(_options);
         context.document = this.document;
-        context.config = SYSTEM;
-        context.editMode = this.editMode;
-        context.title = `${this.actor.name} - ${game.i18n.localize(SYSTEM.ACTOR.adversaryTypes[this.actor.system.type].name)}`;
-
-        context.data = {
-            description: this.document.system.description,
-            motivesAndTactics: this.document.system.motivesAndTactics.join(', '),
-            tier: this.document.system.tier,
-            type: game.i18n.localize(SYSTEM.ACTOR.adversaryTypes[this.document.system.type].name),
-            attack: {
-                name: this.document.system.attack.name,
-                attackModifier: this.document.system.attackModifier,
-                range: this.document.system.attack.range
-                    ? game.i18n.localize(SYSTEM.GENERAL.range[this.document.system.attack.range].name)
-                    : null,
-                damage: {
-                    value: this.document.system.attack.damage.value,
-                    type: this.document.system.attack.damage.type,
-                    typeName: this.document.system.attack.damage.type
-                        ? game.i18n
-                              .localize(
-                                  SYSTEM.GENERAL.damageTypes[this.document.system.attack.damage.type].abbreviation
-                              )
-                              .toLowerCase()
-                        : null
-                }
-            },
-            damageThresholds: this.document.system.damageThresholds,
-            difficulty: this.document.system.difficulty,
-            hp: {
-                ...this.document.system.resources.health,
-                lastRowIndex: Math.floor(this.document.system.resources.health.max / 5) * 5
-            },
-            stress: {
-                ...this.document.system.resources.stress,
-                lastRowIndex: Math.floor(this.document.system.resources.stress.max / 5) * 5
-            },
-            moves: this.document.system.moves
-        };
+        context.tabs = super._getTabs(this.constructor.TABS);
 
         return context;
     }
@@ -286,43 +60,6 @@ export default class AdversarySheet extends DaggerheartSheet(ActorSheetV2) {
         this.render();
     }
 
-    static async viewMove(_, button) {
-        const move = await fromUuid(button.dataset.move);
-        move.sheet.render(true);
-    }
-
-    static async addMove() {
-        const result = await this.document.createEmbeddedDocuments('Item', [
-            {
-                name: game.i18n.localize('DAGGERHEART.Sheets.Adversary.NewMove'),
-                type: 'feature'
-            }
-        ]);
-
-        await result[0].sheet.render(true);
-    }
-
-    static async removeMove(_, button) {
-        await this.document.items.find(x => x.uuid === button.dataset.move).delete();
-    }
-
-    static toggleEditMode() {
-        this.editMode = !this.editMode;
-        this.render();
-    }
-
-    static async addMotive() {
-        await this.document.update({ 'system.motivesAndTactics': [...this.document.system.motivesAndTactics, ''] });
-    }
-
-    static async removeMotive(button) {
-        await this.document.update({
-            'system.motivesAndTactics': this.document.system.motivesAndTactics.filter(
-                (_, index) => index !== Number.parseInt(button.dataset.motive)
-            )
-        });
-    }
-
     static async reactionRoll(event) {
         const { roll, diceResults, modifiers } = await this.actor.diceRoll(
             { title: `${this.actor.name} - Reaction Roll`, value: 0 },
@@ -349,9 +86,8 @@ export default class AdversarySheet extends DaggerheartSheet(ActorSheetV2) {
         cls.create(msg.toObject());
     }
 
-    static async attackRoll(event, button) {
-        const modifier = Number.parseInt(button.dataset.value);
-
+    static async attackRoll() {
+        const { modifier, damage, name: attackName } = this.actor.system.attack;
         const { roll, dice, advantageState, modifiers } = await this.actor.diceRoll(
             { title: `${this.actor.name} - Attack Roll`, value: modifier },
             event.shiftKey
@@ -362,12 +98,12 @@ export default class AdversarySheet extends DaggerheartSheet(ActorSheetV2) {
             name: x.actor.name,
             img: x.actor.img,
             difficulty: x.actor.system.difficulty,
-            evasion: x.actor.system.evasion.value
+            evasion: x.actor.system.evasion
         }));
 
         const cls = getDocumentClass('ChatMessage');
         const systemData = {
-            title: button.dataset.name,
+            title: attackName,
             origin: this.document.id,
             roll: roll._formula,
             advantageState,
@@ -375,7 +111,7 @@ export default class AdversarySheet extends DaggerheartSheet(ActorSheetV2) {
             modifiers: modifiers,
             dice: dice,
             targets: targets,
-            damage: { value: button.dataset.damage, type: button.dataset.damageType }
+            damage: { value: damage.value, type: damage.type }
         };
         const msg = new cls({
             type: 'adversaryRoll',

module/applications/sheets/character.mjs

@@ -0,0 +1,703 @@
+import { capitalize } from '../../helpers/utils.mjs';
+import DhpDeathMove from '../deathMove.mjs';
+import DhpDowntime from '../downtime.mjs';
+import AncestrySelectionDialog from '../ancestrySelectionDialog.mjs';
+import DaggerheartSheet from './daggerheart-sheet.mjs';
+import { abilities } from '../../config/actorConfig.mjs';
+import DhlevelUp from '../levelup.mjs';
+import DHDualityRoll from '../../data/chat-message/dualityRoll.mjs';
+
+const { ActorSheetV2 } = foundry.applications.sheets;
+const { TextEditor } = foundry.applications.ux;
+export default class CharacterSheet extends DaggerheartSheet(ActorSheetV2) {
+    constructor(options = {}) {
+        super(options);
+    }
+
+    static DEFAULT_OPTIONS = {
+        tag: 'form',
+        classes: ['daggerheart', 'sheet', 'pc'],
+        position: { width: 810, height: 1080 },
+        actions: {
+            attributeRoll: this.rollAttribute,
+            toggleMarks: this.toggleMarks,
+            toggleHP: this.toggleHP,
+            toggleStress: this.toggleStress,
+            toggleHope: this.toggleHope,
+            toggleGold: this.toggleGold,
+            attackRoll: this.attackRoll,
+            useDomainCard: this.useDomainCard,
+            removeCard: this.removeDomainCard,
+            selectClass: this.selectClass,
+            selectSubclass: this.selectSubclass,
+            selectAncestry: this.selectAncestry,
+            selectCommunity: this.selectCommunity,
+            viewObject: this.viewObject,
+            useFeature: this.useFeature,
+            takeShortRest: this.takeShortRest,
+            takeLongRest: this.takeLongRest,
+            deleteItem: this.deleteItem,
+            addScar: this.addScar,
+            deleteScar: this.deleteScar,
+            makeDeathMove: this.makeDeathMove,
+            itemQuantityDecrease: (_, button) => this.setItemQuantity(button, -1),
+            itemQuantityIncrease: (_, button) => this.setItemQuantity(button, 1),
+            useAbility: this.useAbility,
+            useAdvancementCard: this.useAdvancementCard,
+            useAdvancementAbility: this.useAdvancementAbility,
+            toggleEquipItem: this.toggleEquipItem,
+            levelup: this.openLevelUp
+        },
+        window: {
+            minimizable: false,
+            resizable: true
+        },
+        form: {
+            handler: this.updateForm,
+            submitOnChange: true,
+            closeOnSubmit: false
+        },
+        dragDrop: [
+            { dragSelector: null, dropSelector: '.weapon-section' },
+            { dragSelector: null, dropSelector: '.armor-section' },
+            { dragSelector: '.item-list .item', dropSelector: null }
+        ]
+    };
+
+    static PARTS = {
+        form: {
+            id: 'character',
+            template: 'systems/daggerheart/templates/sheets/character/character.hbs'
+        }
+    };
+
+    _getTabs() {
+        const setActive = 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' : '';
+            }
+        };
+
+        const primaryTabs = {
+            features: {
+                active: true,
+                cssClass: '',
+                group: 'primary',
+                id: 'features',
+                icon: null,
+                label: game.i18n.localize('DAGGERHEART.Sheets.PC.Tabs.Features')
+            },
+            loadout: {
+                active: false,
+                cssClass: '',
+                group: 'primary',
+                id: 'loadout',
+                icon: null,
+                label: game.i18n.localize('DAGGERHEART.Sheets.PC.Tabs.Loadout')
+            },
+            inventory: {
+                active: false,
+                cssClass: '',
+                group: 'primary',
+                id: 'inventory',
+                icon: null,
+                label: game.i18n.localize('DAGGERHEART.Sheets.PC.Tabs.Inventory')
+            },
+            story: {
+                active: false,
+                cssClass: '',
+                group: 'primary',
+                id: 'story',
+                icon: null,
+                label: game.i18n.localize('DAGGERHEART.Sheets.PC.Tabs.Story')
+            }
+        };
+        const secondaryTabs = {
+            foundation: {
+                active: true,
+                cssClass: '',
+                group: 'secondary',
+                id: 'foundation',
+                icon: null,
+                label: game.i18n.localize('DAGGERHEART.Sheets.PC.Tabs.Foundation')
+            },
+            loadout: {
+                active: false,
+                cssClass: '',
+                group: 'secondary',
+                id: 'loadout',
+                icon: null,
+                label: game.i18n.localize('DAGGERHEART.Sheets.PC.Tabs.Loadout')
+            },
+            vault: {
+                active: false,
+                cssClass: '',
+                group: 'secondary',
+                id: 'vault',
+                icon: null,
+                label: game.i18n.localize('DAGGERHEART.Sheets.PC.Tabs.Vault')
+            }
+        };
+
+        setActive(primaryTabs);
+        setActive(secondaryTabs);
+
+        return { primary: primaryTabs, secondary: secondaryTabs };
+    }
+
+    _attachPartListeners(partId, htmlElement, options) {
+        super._attachPartListeners(partId, htmlElement, options);
+
+        htmlElement.querySelector('.level-value').addEventListener('change', this.onLevelChange.bind(this));
+    }
+
+    async _prepareContext(_options) {
+        const context = await super._prepareContext(_options);
+        context.document = this.document;
+        context.tabs = this._getTabs();
+
+        context.config = SYSTEM;
+
+        const selectedAttributes = Object.values(this.document.system.traits).map(x => x.base);
+        context.abilityScoreArray = JSON.parse(
+            await game.settings.get(SYSTEM.id, SYSTEM.SETTINGS.gameSettings.General.AbilityArray)
+        ).reduce((acc, x) => {
+            const selectedIndex = selectedAttributes.indexOf(x);
+            if (selectedIndex !== -1) {
+                selectedAttributes.splice(selectedIndex, 1);
+            } else {
+                acc.push({ name: x, value: x });
+            }
+
+            return acc;
+        }, []);
+        if (!context.abilityScoreArray.includes(0)) context.abilityScoreArray.push({ name: 0, value: 0 });
+        context.abilityScoresFinished = context.abilityScoreArray.every(x => x.value === 0);
+
+        context.attributes = Object.keys(this.document.system.traits).reduce((acc, key) => {
+            acc[key] = {
+                ...this.document.system.traits[key],
+                name: game.i18n.localize(SYSTEM.ACTOR.abilities[key].name),
+                verbs: SYSTEM.ACTOR.abilities[key].verbs.map(x => game.i18n.localize(x))
+            };
+
+            return acc;
+        }, {});
+
+        const ancestry = await this.mapFeatureType(
+            this.document.system.ancestry ? [this.document.system.ancestry] : [],
+            SYSTEM.GENERAL.objectTypes
+        );
+        const community = await this.mapFeatureType(
+            this.document.system.community ? [this.document.system.community] : [],
+            SYSTEM.GENERAL.objectTypes
+        );
+        const foundation = {
+            ancestry: ancestry[0],
+            community: community[0],
+            advancement: {}
+        };
+
+        const nrLoadoutCards = this.document.system.domainCards.loadout.length;
+        const loadout = await this.mapFeatureType(this.document.system.domainCards.loadout, SYSTEM.DOMAIN.cardTypes);
+        const vault = await this.mapFeatureType(this.document.system.domainCards.vault, SYSTEM.DOMAIN.cardTypes);
+        context.abilities = {
+            foundation: foundation,
+            loadout: {
+                top: loadout.slice(0, Math.min(2, nrLoadoutCards)),
+                bottom: nrLoadoutCards > 2 ? loadout.slice(2, Math.min(5, nrLoadoutCards)) : [],
+                nrTotal: nrLoadoutCards
+            },
+            vault: vault.map(x => ({
+                ...x,
+                uuid: x.uuid,
+                sendToLoadoutDisabled: this.document.system.domainCards.loadout.length >= 5
+            }))
+        };
+
+        context.inventory = {
+            consumable: {
+                titles: {
+                    name: game.i18n.localize('DAGGERHEART.Sheets.PC.InventoryTab.ConsumableTitle'),
+                    quantity: game.i18n.localize('DAGGERHEART.Sheets.PC.InventoryTab.QuantityTitle')
+                },
+                items: this.document.items.filter(x => x.type === 'consumable')
+            },
+            miscellaneous: {
+                titles: {
+                    name: game.i18n.localize('DAGGERHEART.Sheets.PC.InventoryTab.MiscellaneousTitle'),
+                    quantity: game.i18n.localize('DAGGERHEART.Sheets.PC.InventoryTab.QuantityTitle')
+                },
+                items: this.document.items.filter(x => x.type === 'miscellaneous')
+            },
+            weapons: {
+                titles: {
+                    name: game.i18n.localize('DAGGERHEART.Sheets.PC.InventoryTab.WeaponsTitle'),
+                    quantity: game.i18n.localize('DAGGERHEART.Sheets.PC.InventoryTab.QuantityTitle')
+                },
+                items: this.document.items.filter(x => x.type === 'weapon')
+            },
+            armor: {
+                titles: {
+                    name: game.i18n.localize('DAGGERHEART.Sheets.PC.InventoryTab.ArmorsTitle'),
+                    quantity: game.i18n.localize('DAGGERHEART.Sheets.PC.InventoryTab.QuantityTitle')
+                },
+                items: this.document.items.filter(x => x.type === 'armor')
+            }
+        };
+
+        if (context.inventory.length === 0) {
+            context.inventory = Array(1).fill(Array(5).fill([]));
+        }
+
+        return context;
+    }
+
+    static async updateForm(event, _, formData) {
+        await this.document.update(formData.object);
+        this.render();
+    }
+
+    async mapFeatureType(data, configType) {
+        return await Promise.all(
+            data.map(async x => {
+                const abilities = x.system.abilities
+                    ? await Promise.all(x.system.abilities.map(async x => await fromUuid(x.uuid)))
+                    : [];
+
+                return {
+                    ...x,
+                    uuid: x.uuid,
+                    system: {
+                        ...x.system,
+                        abilities: abilities,
+                        type: game.i18n.localize(configType[x.system.type ?? x.type].label)
+                    }
+                };
+            })
+        );
+    }
+
+    static async rollAttribute(event, button) {
+        const { roll, hope, fear, advantage, disadvantage, modifiers } = await this.document.dualityRoll(
+            { title: game.i18n.localize(abilities[button.dataset.attribute].label), value: button.dataset.value },
+            event.shiftKey
+        );
+
+        const cls = getDocumentClass('ChatMessage');
+
+        const systemContent = new DHDualityRoll({
+            title: game.i18n.format('DAGGERHEART.Chat.DualityRoll.AbilityCheckTitle', {
+                ability: game.i18n.localize(abilities[button.dataset.attribute].label)
+            }),
+            origin: this.document.id,
+            roll: roll._formula,
+            modifiers: modifiers,
+            hope: hope,
+            fear: fear,
+            advantage: advantage,
+            disadvantage: disadvantage
+        });
+
+        await cls.create({
+            type: 'dualityRoll',
+            sound: CONFIG.sounds.dice,
+            system: systemContent,
+            user: game.user.id,
+            content: await foundry.applications.handlebars.renderTemplate(
+                'systems/daggerheart/templates/chat/duality-roll.hbs',
+                systemContent
+            ),
+            rolls: [roll]
+        });
+    }
+
+    static async toggleMarks(_, button) {
+        const markValue = Number.parseInt(button.dataset.value);
+        const newValue = this.document.system.armor.system.marks.value >= markValue ? markValue - 1 : markValue;
+        await this.document.system.armor.update({ 'system.marks.value': newValue });
+    }
+
+    static async toggleHP(_, button) {
+        const healthValue = Number.parseInt(button.dataset.value);
+        const newValue = this.document.system.resources.hitPoints.value >= healthValue ? healthValue - 1 : healthValue;
+        await this.document.update({ 'system.resources.hitPoints.value': newValue });
+    }
+
+    static async toggleStress(_, button) {
+        const healthValue = Number.parseInt(button.dataset.value);
+        const newValue = this.document.system.resources.stress.value >= healthValue ? healthValue - 1 : healthValue;
+        await this.document.update({ 'system.resources.stress.value': newValue });
+    }
+
+    static async toggleHope(_, button) {
+        const hopeValue = Number.parseInt(button.dataset.value);
+        const newValue = this.document.system.resources.hope.value >= hopeValue ? hopeValue - 1 : hopeValue;
+        await this.document.update({ 'system.resources.hope.value': newValue });
+    }
+
+    static async toggleGold(_, button) {
+        const goldValue = Number.parseInt(button.dataset.value);
+        const goldType = button.dataset.type;
+        const newValue = this.document.system.gold[goldType] >= goldValue ? goldValue - 1 : goldValue;
+
+        const update = `system.gold.${goldType}`;
+        await this.document.update({ [update]: newValue });
+    }
+
+    static async attackRoll(event, button) {
+        const weapon = await fromUuid(button.dataset.weapon);
+        const damage = {
+            value: `${this.document.system.proficiency}${weapon.system.damage.value}`,
+            type: weapon.system.damage.type
+        };
+        const modifier = this.document.system.traits[weapon.system.trait].value;
+
+        const { roll, hope, fear, advantage, disadvantage, modifiers } = await this.document.dualityRoll(
+            { title: game.i18n.localize(abilities[weapon.system.trait].label), value: modifier },
+            event.shiftKey
+        );
+
+        const targets = Array.from(game.user.targets).map(x => ({
+            id: x.id,
+            name: x.actor.name,
+            img: x.actor.img,
+            difficulty: x.actor.system.difficulty,
+            evasion: x.actor.system.evasion
+        }));
+
+        const systemData = new DHDualityRoll({
+            title: weapon.name,
+            origin: this.document.id,
+            roll: roll._formula,
+            modifiers: modifiers,
+            hope: hope,
+            fear: fear,
+            advantage: advantage,
+            disadvantage: disadvantage,
+            damage: damage,
+            targets: targets
+        });
+
+        const cls = getDocumentClass('ChatMessage');
+        const msg = new cls({
+            type: 'dualityRoll',
+            sound: CONFIG.sounds.dice,
+            system: systemData,
+            content: await foundry.applications.handlebars.renderTemplate(
+                'systems/daggerheart/templates/chat/attack-roll.hbs',
+                systemData
+            ),
+            rolls: [roll]
+        });
+
+        await cls.create(msg.toObject());
+    }
+
+    static openLevelUp() {
+        if (!this.document.system.class.value || !this.document.system.class.subclass) {
+            ui.notifications.error(game.i18n.localize('DAGGERHEART.Sheets.PC.Errors.missingClassOrSubclass'));
+            return;
+        }
+
+        new DhlevelUp(this.document).render(true);
+    }
+
+    static async useDomainCard(_, button) {
+        const card = this.document.items.find(x => x.uuid === button.dataset.key);
+
+        const cls = getDocumentClass('ChatMessage');
+        const systemData = {
+            title: `${game.i18n.localize('DAGGERHEART.Chat.DomainCard.Title')} - ${capitalize(button.dataset.domain)}`,
+            origin: this.document.id,
+            img: card.img,
+            name: card.name,
+            description: card.system.effect,
+            actions: card.system.actions
+        };
+        const msg = new cls({
+            type: 'abilityUse',
+            user: game.user.id,
+            content: await foundry.applications.handlebars.renderTemplate(
+                'systems/daggerheart/templates/chat/ability-use.hbs',
+                systemData
+            ),
+            system: systemData
+        });
+
+        cls.create(msg.toObject());
+    }
+
+    static async removeDomainCard(_, button) {
+        if (button.dataset.type === 'domainCard') {
+            const card = this.document.items.find(x => x.uuid === button.dataset.key);
+            await card.delete();
+        }
+    }
+
+    static async selectClass() {
+        (await game.packs.get('daggerheart.classes'))?.render(true);
+    }
+
+    static async selectSubclass() {
+        (await game.packs.get('daggerheart.subclasses'))?.render(true);
+    }
+
+    static async selectAncestry() {
+        const dialogClosed = new Promise((resolve, _) => {
+            new AncestrySelectionDialog(resolve).render(true);
+        });
+        const result = await dialogClosed;
+
+        for (var ancestry of this.document.items.filter(x => x => x.type === 'ancestry')) {
+            await ancestry.delete();
+        }
+
+        const createdItems = [];
+        for (var feature of this.document.items.filter(
+            x => x.type === 'feature' && x.system.type === SYSTEM.ITEM.featureTypes.ancestry.id
+        )) {
+            await feature.delete();
+        }
+
+        createdItems.push(result.data);
+
+        await this.document.createEmbeddedDocuments('Item', createdItems);
+    }
+
+    static async selectCommunity() {
+        (await game.packs.get('daggerheart.communities'))?.render(true);
+    }
+
+    static async viewObject(_, button) {
+        const object = await fromUuid(button.dataset.value);
+        if (!object) return;
+
+        const tab = button.dataset.tab;
+        if (tab && object.sheet._tabs) object.sheet._tabs[0].active = tab;
+
+        if (object.sheet.editMode) object.sheet.editMode = false;
+
+        object.sheet.render(true);
+    }
+
+    static async takeShortRest() {
+        await new DhpDowntime(this.document, true).render(true);
+        await this.minimize();
+    }
+
+    static async takeLongRest() {
+        await new DhpDowntime(this.document, false).render(true);
+        await this.minimize();
+    }
+
+    static async addScar() {
+        if (this.document.system.story.scars.length === 5) return;
+
+        await this.document.update({
+            'system.story.scars': [
+                ...this.document.system.story.scars,
+                { name: game.i18n.localize('DAGGERHEART.Sheets.PC.NewScar'), description: '' }
+            ]
+        });
+    }
+
+    static async deleteScar(event, button) {
+        event.stopPropagation();
+        await this.document.update({
+            'system.story.scars': this.document.system.story.scars.filter(
+                (_, index) => index !== Number.parseInt(button.currentTarget.dataset.scar)
+            )
+        });
+    }
+
+    static async makeDeathMove() {
+        if (this.document.system.resources.hitPoints.value === this.document.system.resources.hitPoints.max) {
+            await new DhpDeathMove(this.document).render(true);
+            await this.minimize();
+        }
+    }
+
+    async itemUpdate(event) {
+        const name = event.currentTarget.dataset.item;
+        const item = await fromUuid($(event.currentTarget).closest('[data-item-id]')[0].dataset.itemId);
+        await item.update({ [name]: event.currentTarget.value });
+    }
+
+    async onLevelChange(event) {
+        await this.document.updateLevel(Number(event.currentTarget.value));
+        this.render();
+    }
+
+    static async deleteItem(_, button) {
+        const item = await fromUuid($(button).closest('[data-item-id]')[0].dataset.itemId);
+        await item.delete();
+    }
+
+    static async setItemQuantity(button, value) {
+        const item = await fromUuid($(button).closest('[data-item-id]')[0].dataset.itemId);
+        await item.update({ 'system.quantity': Math.max(item.system.quantity + value, 1) });
+    }
+
+    static async useFeature(_, button) {
+        const item = await fromUuid(button.dataset.id);
+
+        const cls = getDocumentClass('ChatMessage');
+        const systemData = {
+            title: game.i18n.localize('DAGGERHEART.Chat.FeatureTitle'),
+            origin: this.document.id,
+            img: item.img,
+            name: item.name,
+            description: item.system.description,
+            actions: item.system.actions
+        };
+        const msg = new cls({
+            type: 'abilityUse',
+            user: game.user.id,
+            content: await foundry.applications.handlebars.renderTemplate(
+                'systems/daggerheart/templates/chat/ability-use.hbs',
+                systemData
+            ),
+            system: systemData
+        });
+
+        cls.create(msg.toObject());
+    }
+
+    static async useAbility(_, button) {
+        const item = await fromUuid(button.dataset.feature);
+        const type = button.dataset.type;
+
+        const cls = getDocumentClass('ChatMessage');
+        const systemData = {
+            title:
+                type === 'ancestry'
+                    ? game.i18n.localize('DAGGERHEART.Chat.FoundationCard.AncestryTitle')
+                    : type === 'community'
+                      ? game.i18n.localize('DAGGERHEART.Chat.FoundationCard.CommunityTitle')
+                      : game.i18n.localize('DAGGERHEART.Chat.FoundationCard.SubclassFeatureTitle'),
+            origin: this.document.id,
+            img: item.img,
+            name: item.name,
+            description: item.system.description,
+            actions: []
+        };
+        const msg = new cls({
+            type: 'abilityUse',
+            user: game.user.id,
+            system: systemData,
+            content: await foundry.applications.handlebars.renderTemplate(
+                'systems/daggerheart/templates/chat/ability-use.hbs',
+                systemData
+            )
+        });
+
+        cls.create(msg.toObject());
+    }
+
+    static async useAdvancementCard(_, button) {
+        const item =
+            button.dataset.multiclass === 'true'
+                ? this.document.system.multiclass.subclass
+                : this.document.system.class.subclass;
+        const ability = item.system[`${button.dataset.key}Feature`];
+        const title = `${item.name} - ${game.i18n.localize(`DAGGERHEART.Sheets.PC.DomainCard.${capitalize(button.dataset.key)}Title`)}`;
+
+        const cls = getDocumentClass('ChatMessage');
+        const systemData = {
+            title: game.i18n.localize('DAGGERHEART.Chat.FoundationCard.SubclassFeatureTitle'),
+            origin: this.document.id,
+            name: title,
+            img: item.img,
+            description: ability.description
+        };
+        const msg = new cls({
+            type: 'abilityUse',
+            user: game.user.id,
+            system: systemData,
+            content: await foundry.applications.handlebars.renderTemplate(
+                'systems/daggerheart/templates/chat/ability-use.hbs',
+                systemData
+            )
+        });
+
+        cls.create(msg.toObject());
+    }
+
+    static async useAdvancementAbility(_, button) {
+        const item = this.document.items.find(x => x.uuid === button.dataset.id);
+
+        const cls = getDocumentClass('ChatMessage');
+        const systemData = {
+            title: game.i18n.localize('DAGGERHEART.Chat.FoundationCard.SubclassFeatureTitle'),
+            origin: this.document.id,
+            name: item.name,
+            img: item.img,
+            description: item.system.description
+        };
+        const msg = new cls({
+            user: game.user.id,
+            system: systemData,
+            content: await foundry.applications.handlebars.renderTemplate(
+                'systems/daggerheart/templates/chat/ability-use.hbs',
+                systemData
+            )
+        });
+
+        cls.create(msg.toObject());
+    }
+
+    static async toggleEquipItem(_, button) {
+        const item = this.document.items.get(button.id);
+        if (item.system.equipped) {
+            await item.update({ 'system.equipped': false });
+            return;
+        }
+
+        switch (item.type) {
+            case 'armor':
+                const currentArmor = this.document.system.armor;
+                if (currentArmor) {
+                    await currentArmor.update({ 'system.equipped': false });
+                }
+
+                await item.update({ 'system.equipped': true });
+                break;
+            case 'weapon':
+                await this.document.system.constructor.unequipBeforeEquip.bind(this.document.system)(item);
+
+                await item.update({ 'system.equipped': true });
+                break;
+        }
+        this.render();
+    }
+
+    async _onDragStart(_, event) {
+        super._onDragStart(event);
+    }
+
+    async _onDrop(event) {
+        super._onDrop(event);
+        this._onDropItem(event, TextEditor.getDragEventData(event));
+    }
+
+    async _onDropItem(event, data) {
+        const item = await Item.implementation.fromDropData(data);
+        const itemData = item.toObject();
+
+        if (item.type === 'domainCard' && this.document.system.domainCards.loadout.length >= 5) {
+            itemData.system.inVault = true;
+        }
+
+        if (this.document.uuid === item.parent?.uuid) return this._onSortItem(event, itemData);
+        const createdItem = await this._onDropItemCreate(itemData);
+
+        return createdItem;
+    }
+
+    async _onDropItemCreate(itemData, event) {
+        itemData = itemData instanceof Array ? itemData : [itemData];
+        return this.document.createEmbeddedDocuments('Item', itemData);
+    }
+}

module/applications/sheets/environment.mjs

@@ -1,78 +1,60 @@
 import DaggerheartSheet from './daggerheart-sheet.mjs';
 
-const { DocumentSheetV2 } = foundry.applications.api;
-export default class DhpEnvironment extends DaggerheartSheet(DocumentSheetV2) {
-    constructor(options) {
-        super(options);
-
-        this.editMode = false;
-    }
-
+const { ActorSheetV2 } = foundry.applications.sheets;
+export default class DhpEnvironment extends DaggerheartSheet(ActorSheetV2) {
     static DEFAULT_OPTIONS = {
         tag: 'form',
-        classes: ['daggerheart', 'sheet', 'adversary', 'environment'],
+        classes: ['daggerheart', 'sheet', 'actor', 'dh-style', 'environment'],
         position: {
-            width: 600,
-            height: 'auto'
+            width: 450,
+            height: 1000
         },
         actions: {
-            toggleSlider: this.toggleSlider,
-            viewFeature: this.viewFeature,
+            addAdversary: this.addAdversary,
             addFeature: this.addFeature,
-            removeFeature: this.removeFeature,
-            addTone: this.addTone,
-            removeTone: this.removeTone,
-            useFeature: this.useFeature
+            deleteProperty: this.deleteProperty,
+            viewAdversary: this.viewAdversary
         },
         form: {
             handler: this._updateForm,
-            closeOnSubmit: false,
-            submitOnChange: true
-        }
+            submitOnChange: true,
+            closeOnSubmit: false
+        },
+        dragDrop: [{ dragSelector: null, dropSelector: '.adversary-container' }]
     };
 
-    /** @override */
     static PARTS = {
-        form: {
-            id: 'form',
-            template: 'systems/daggerheart/templates/sheets/environment.hbs'
-        }
+        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' }
     };
 
-    /* -------------------------------------------- */
-
-    /** @inheritDoc */
-    get title() {
-        return `${game.i18n.localize('Environment')} - ${this.document.name}`;
-    }
+    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) {
-        return {
-            title: `${this.document.name} - ${game.i18n.localize(SYSTEM.ACTOR.adversaryTypes[this.document.system.type].name)}`,
-            user: this.document,
-            source: this.document.toObject(),
-            fields: this.document.schema.fields,
-            data: {
-                type: game.i18n.localize(SYSTEM.ACTOR.adversaryTypes[this.document.system.type].name),
-                features: this.document.items.reduce((acc, x) => {
-                    if (x.type === 'feature') {
-                        const feature = x.toObject();
-                        acc.push({
-                            ...feature,
-                            system: {
-                                ...feature.system,
-                                actionType: game.i18n.localize(SYSTEM.ITEM.actionTypes[feature.system.actionType].name)
-                            },
-                            uuid: x.uuid
-                        });
-                    }
+        const context = await super._prepareContext(_options);
+        context.document = this.document;
+        context.tabs = super._getTabs(this.constructor.TABS);
 
-                    return acc;
-                }, [])
-            },
-            editMode: this.editMode,
-            config: SYSTEM
-        };
+        return context;
     }
 
     static async _updateForm(event, _, formData) {
@@ -80,60 +62,41 @@ export default class DhpEnvironment extends DaggerheartSheet(DocumentSheetV2) {
         this.render();
     }
 
-    static toggleSlider() {
-        this.editMode = !this.editMode;
+    static async addAdversary() {
+        await this.document.update({
+            [`system.potentialAdversaries.${foundry.utils.randomID()}.label`]: game.i18n.localize(
+                'DAGGERHEART.Sheets.Environment.newAdversary'
+            )
+        });
         this.render();
     }
 
-    static async viewFeature(_, button) {
-        const move = await fromUuid(button.dataset.feature);
-        move.sheet.render(true);
-    }
-
     static async addFeature() {
-        const result = await this.document.createEmbeddedDocuments('Item', [
-            {
-                name: game.i18n.localize('DAGGERHEART.Sheets.Environment.NewFeature'),
-                type: 'feature'
-            }
-        ]);
-
-        await result[0].sheet.render(true);
+        ui.notifications.error('Not Implemented yet. Awaiting datamodel rework');
     }
 
-    static async removeFeature(_, button) {
-        await this.document.items.find(x => x.uuid === button.dataset.feature).delete();
+    static async deleteProperty(_, target) {
+        await this.document.update({ [`${target.dataset.path}.-=${target.id}`]: null });
+        this.render();
     }
 
-    static async addTone() {
-        await this.document.update({ 'system.toneAndFeel': [...this.document.system.toneAndFeel, ''] });
+    static async viewAdversary(_, button) {
+        const adversary = foundry.utils.getProperty(
+            this.document.system.potentialAdversaries,
+            `${button.dataset.potentialAdversary}.adversaries.${button.dataset.adversary}`
+        );
+        adversary.sheet.render(true);
     }
 
-    static async removeTone(button) {
-        await this.document.update({
-            'system.toneAndFeel': this.document.system.toneAndFeel.filter(
-                (_, index) => index !== Number.parseInt(button.dataset.tone)
-            )
-        });
-    }
-
-    static async useFeature(_, button) {
-        const item = this.document.items.find(x => x.uuid === button.dataset.feature);
-
-        const cls = getDocumentClass('ChatMessage');
-        const msg = new cls({
-            user: game.user.id,
-            content: await foundry.applications.handlebars.renderTemplate(
-                'systems/daggerheart/templates/chat/ability-use.hbs',
-                {
-                    title: game.i18n.format('DAGGERHEART.Chat.EnvironmentTitle', {
-                        actionType: button.dataset.actionType
-                    }),
-                    card: { name: item.name, img: item.img, description: item.system.description }
-                }
-            )
-        });
-
-        cls.create(msg.toObject());
+    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
+            });
+        }
     }
 }