113 - Character Data Model (#114)

* Improved Character datamodel

* Removed additional unneccessary getters

* Preliminary cleanup in the class sheet

* Cleanup of 'pc' references

* Corrected Duality rolling from Character

* Fix to damage roll

module/applications/_module.mjs

@@ -1,4 +1,4 @@
-export { default as DhpPCSheet } from './sheets/pc.mjs';
+export { default as DhCharacterSheet } from './sheets/character.mjs';
 export { default as DhpAdversarySheet } from './sheets/adversary.mjs';
 export { default as DhpClassSheet } from './sheets/items/class.mjs';
 export { default as DhpSubclass } from './sheets/items/subclass.mjs';

module/applications/levelup.mjs

@@ -149,7 +149,10 @@ export default class DhlevelUp extends HandlebarsApplicationMixin(ApplicationV2)
                 const experienceIncreaseValues = experienceIncreases
                     .filter(exp => exp.data.length > 0)
                     .flatMap(exp =>
-                        exp.data.map(data => this.actor.system.experiences.find(x => x.id === data).description)
+                        exp.data.map(data => {
+                            const experience = Object.keys(this.actor.system.experiences).find(x => x === data);
+                            return this.actor.system.experiences[experience].description;
+                        })
                     );
                 context.experienceIncreases = {
                     values: experienceIncreaseValues,
@@ -201,7 +204,7 @@ export default class DhlevelUp extends HandlebarsApplicationMixin(ApplicationV2)
 
                 const multiclassSubclass = this.actor.system.multiclass?.system?.subclasses?.[0];
                 const possibleSubclasses = [
-                    this.actor.system.subclass,
+                    this.actor.system.class.subclass,
                     ...(multiclassSubclass ? [multiclassSubclass] : [])
                 ];
                 const selectedSubclasses = possibleSubclasses.filter(x => subclassSelections.includes(x.uuid));
@@ -274,8 +277,8 @@ export default class DhlevelUp extends HandlebarsApplicationMixin(ApplicationV2)
 
                 context.achievements = {
                     proficiency: {
-                        old: this.actor.system.proficiency.value,
-                        new: this.actor.system.proficiency.value + achivementProficiency,
+                        old: this.actor.system.proficiency,
+                        new: this.actor.system.proficiency + achivementProficiency,
                         shown: achivementProficiency > 0
                     },
                     damageThresholds: {
@@ -328,10 +331,12 @@ export default class DhlevelUp extends HandlebarsApplicationMixin(ApplicationV2)
                                     break;
                                 case 'experience':
                                     if (!advancement[choiceKey]) advancement[choiceKey] = [];
-                                    const data = checkbox.data.map(
-                                        data =>
-                                            this.actor.system.experiences.find(x => x.id === data)?.description ?? ''
-                                    );
+                                    const data = checkbox.data.map(data => {
+                                        const experience = Object.keys(this.actor.system.experiences).find(
+                                            x => x === data
+                                        );
+                                        return this.actor.system.experiences[experience]?.description ?? '';
+                                    });
                                     advancement[choiceKey].push({ data: data, value: checkbox.value });
                                     break;
                             }
@@ -354,8 +359,8 @@ export default class DhlevelUp extends HandlebarsApplicationMixin(ApplicationV2)
                             new: this.actor.system.resources.stress.max + (advancement.stress ?? 0)
                         },
                         evasion: {
-                            old: this.actor.system.evasion.value,
-                            new: this.actor.system.evasion.value + (advancement.evasion ?? 0)
+                            old: this.actor.system.evasion,
+                            new: this.actor.system.evasion + (advancement.evasion ?? 0)
                         }
                     },
                     traits:
@@ -421,8 +426,9 @@ export default class DhlevelUp extends HandlebarsApplicationMixin(ApplicationV2)
         if (experienceIncreaseTagify) {
             tagifyElement(
                 experienceIncreaseTagify,
-                this.actor.system.experiences.reduce((acc, experience) => {
-                    acc[experience.id] = { label: experience.description };
+                Object.keys(this.actor.system.experiences).reduce((acc, id) => {
+                    const experience = this.actor.system.experiences[id];
+                    acc[id] = { label: experience.description };
 
                     return acc;
                 }, {}),

module/applications/multiclassDialog.mjs

@@ -1,115 +0,0 @@
-const { HandlebarsApplicationMixin, ApplicationV2 } = foundry.applications.api;
-
-export default class DhpMulticlassDialog extends HandlebarsApplicationMixin(ApplicationV2) {
-    constructor(actorName, actorClass, resolve) {
-        super({});
-
-        this.actorName = actorName;
-        this.actorClass = actorClass;
-        this.resolve = resolve;
-
-        this.classChoices = Array.from(
-            game.items.reduce((acc, x) => {
-                if (x.type === 'class' && x.name !== actorClass.name) {
-                    acc.add(x);
-                }
-
-                return acc;
-            }, new Set())
-        );
-        this.subclassChoices = [];
-        this.domainChoices = [];
-
-        this.data = {
-            class: null,
-            subclass: null,
-            domain: null
-        };
-    }
-
-    get title() {
-        return `${this.actorName} - Multiclass`;
-    }
-
-    static DEFAULT_OPTIONS = {
-        classes: ['daggerheart', 'views', 'multiclass'],
-        position: { width: 600, height: 'auto' },
-        actions: {
-            selectClass: this.selectClass,
-            selectSubclass: this.selectSubclass,
-            selectDomain: this.selectDomain,
-            finish: this.finish
-        }
-    };
-
-    static PARTS = {
-        form: {
-            id: 'levelup',
-            template: 'systems/daggerheart/templates/views/multiclass.hbs'
-        }
-    };
-
-    async _prepareContext(_options) {
-        const context = await super._prepareContext(_options);
-        context.classChoices = this.classChoices;
-        context.subclassChoices = this.subclassChoices;
-        context.domainChoices = this.domainChoices;
-        context.disabledFinish = !this.data.class || !this.data.subclass || !this.data.domain;
-        context.data = this.data;
-
-        return context;
-    }
-
-    static async selectClass(_, button) {
-        const oldClass = this.data.class;
-        this.data.class = this.data.class?.uuid === button.dataset.class ? null : await fromUuid(button.dataset.class);
-        if (oldClass !== button.dataset.class) {
-            this.data.subclass = null;
-            this.data.domain = null;
-            this.subclassChoices = this.data.class ? this.data.class.system.subclasses : [];
-            
-            //FIXME
-            this.domainChoices = this.data.class
-                ? this.data.class.system.domains.map(x => {
-                      const config = SYSTEM.DOMAIN.domains[x];
-                      return {
-                          name: game.i18n.localize(config.name),
-                          id: config.id,
-                          img: config.src,
-                          disabled: this.actorClass.system.domains.includes(config.id)
-                      };
-                  })
-                : [];
-        }
-
-        this.render(true);
-    }
-
-    static async selectSubclass(_, button) {
-        this.data.subclass =
-            this.data.subclass?.uuid === button.dataset.subclass
-                ? null
-                : this.subclassChoices.find(x => x.uuid === button.dataset.subclass);
-        this.render(true);
-    }
-
-    static async selectDomain(_, button) {
-        const domain =
-            this.data.domain?.id === button.dataset.domain
-                ? null
-                : this.domainChoices.find(x => x.id === button.dataset.domain);
-        if (domain?.disabled) return;
-
-        this.data.domain = domain;
-        this.render(true);
-    }
-
-    static finish() {
-        this.close({}, this.data);
-    }
-
-    async close(options = {}, data = null) {
-        this.resolve(data);
-        super.close(options);
-    }
-}

module/applications/rollSelectionDialog.mjs

@@ -1,7 +1,7 @@
 const { ApplicationV2, HandlebarsApplicationMixin } = foundry.applications.api;
 
 export default class RollSelectionDialog extends HandlebarsApplicationMixin(ApplicationV2) {
-    constructor(experiences, bonusDamage, hopeResource, resolve, isNpc) {
+    constructor(experiences, hopeResource, resolve) {
         super({}, {});
 
         this.experiences = experiences;
@@ -17,23 +17,13 @@ export default class RollSelectionDialog extends HandlebarsApplicationMixin(Appl
             fear: ['d12'],
             advantage: null,
             disadvantage: null,
-            bonusDamage: bonusDamage.reduce((acc, x) => {
-                if (x.appliesOn === SYSTEM.EFFECTS.applyLocations.attackRoll.id) {
-                    acc.push({
-                        ...x,
-                        hopeUses: 0
-                    });
-                }
-
-                return acc;
-            }, []),
             hopeResource: hopeResource
         };
     }
 
     static DEFAULT_OPTIONS = {
         tag: 'form',
-        id: 'roll-selection', //Having an id causes a new instance to overwrite previous.
+        id: 'roll-selection',
         classes: ['daggerheart', 'views', 'roll-selection'],
         position: {
             width: 400,
@@ -41,8 +31,6 @@ export default class RollSelectionDialog extends HandlebarsApplicationMixin(Appl
         },
         actions: {
             selectExperience: this.selectExperience,
-            decreaseHopeUse: this.decreaseHopeUse,
-            increaseHopeUse: this.increaseHopeUse,
             setAdvantage: this.setAdvantage,
             setDisadvantage: this.setDisadvantage,
             finish: this.finish
@@ -74,27 +62,14 @@ export default class RollSelectionDialog extends HandlebarsApplicationMixin(Appl
         context.fear = this.data.fear;
         context.advantage = this.data.advantage;
         context.disadvantage = this.data.disadvantage;
-        context.experiences = this.experiences.map(x => ({
-            ...x,
-            selected: this.selectedExperiences.find(selected => selected.id === x.id)
-        }));
-        context.bonusDamage = this.data.bonusDamage;
+        context.experiences = Object.keys(this.experiences).map(id => ({ id, ...this.experiences[id] }));
         context.hopeResource = this.data.hopeResource + 1;
-        context.hopeUsed = this.getHopeUsed();
 
         return context;
     }
 
     static updateSelection(event, _, formData) {
-        const { bonusDamage, ...rest } = foundry.utils.expandObject(formData.object);
-
-        for (var index in bonusDamage) {
-            this.data.bonusDamage[index].initiallySelected = bonusDamage[index].initiallySelected;
-            if (bonusDamage[index].hopeUses) {
-                const value = Number.parseInt(bonusDamage[index].hopeUses);
-                if (!Number.isNaN(value)) this.data.bonusDamage[index].hopeUses = value;
-            }
-        }
+        const { ...rest } = foundry.utils.expandObject(formData.object);
 
         this.data = foundry.utils.mergeObject(this.data, rest);
         this.render();
@@ -104,35 +79,12 @@ export default class RollSelectionDialog extends HandlebarsApplicationMixin(Appl
         if (this.selectedExperiences.find(x => x.id === button.dataset.key)) {
             this.selectedExperiences = this.selectedExperiences.filter(x => x.id !== button.dataset.key);
         } else {
-            this.selectedExperiences = [
-                ...this.selectedExperiences,
-                this.experiences.find(x => x.id === button.dataset.key)
-            ];
+            this.selectedExperiences = [...this.selectedExperiences, button.dataset.key];
         }
 
         this.render();
     }
 
-    getHopeUsed() {
-        return this.data.bonusDamage.reduce((acc, x) => acc + x.hopeUses, 0);
-    }
-
-    static decreaseHopeUse(_, button) {
-        const index = Number.parseInt(button.dataset.index);
-        if (this.data.bonusDamage[index].hopeUses - 1 >= 0) {
-            this.data.bonusDamage[index].hopeUses -= 1;
-            this.render(true);
-        }
-    }
-
-    static increaseHopeUse(_, button) {
-        const index = Number.parseInt(button.dataset.index);
-        if (this.data.bonusDamage[index].hopeUses <= this.data.hopeResource + 1) {
-            this.data.bonusDamage[index].hopeUses += 1;
-            this.render(true);
-        }
-    }
-
     static setAdvantage() {
         this.data.advantage = this.data.advantage ? null : 'd6';
         this.data.disadvantage = null;
@@ -149,11 +101,10 @@ export default class RollSelectionDialog extends HandlebarsApplicationMixin(Appl
 
     static async finish() {
         const { diceOptions, ...rest } = this.data;
+
         this.resolve({
             ...rest,
-            experiences: this.selectedExperiences,
-            hopeUsed: this.getHopeUsed(),
-            bonusDamage: this.data.bonusDamage.reduce((acc, x) => acc.concat(` + ${1 + x.hopeUses}${x.value}`), '')
+            experiences: this.selectedExperiences.map(x => ({ id: x, ...this.experiences[x] }))
         });
         this.close();
     }

module/applications/sheets/adversary.mjs

@@ -98,7 +98,7 @@ 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');

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);
+    }
+}