.editorconfig

@@ -1,6 +1,5 @@
 [*]
 indent_size = 4
 indent_style = spaces
-end_of_line = lf
 [*.yml]
 indent_size = 2

.gitattributes

@@ -1,2 +0,0 @@
-* text=auto eol=lf
-*.json text eol=lf

.github/workflows/deploy.yml

@@ -37,7 +37,6 @@ jobs:
         url: https://github.com/${{github.repository}}
         manifest: https://raw.githubusercontent.com/${{github.repository}}/v14/system.json
         download: https://github.com/${{github.repository}}/releases/download/${{github.event.release.tag_name}}/system.zip
-        flags.hotReload: false
 
     # Create a zip file with all files required by the module to add to the release
     - run: zip -r ./system.zip system.json README.md LICENSE build/daggerheart.js build/tagify.css styles/daggerheart.css assets/ templates/ packs/ lang/

.gitignore

@@ -6,4 +6,3 @@ Build
 build
 foundry
 styles/daggerheart.css
-styles/daggerheart.css.map

.prettierrc

@@ -0,0 +1,13 @@
+{
+    "trailingComma": "none",
+    "tabWidth": 4,
+    "useTabs": false,
+    "semi": true,
+    "singleQuote": true,
+    "quoteProps": "consistent",
+    "bracketSpacing": true,
+    "arrowParens": "avoid",
+    "printWidth": 120,
+    "endOfLine": "lf",
+    "bracketSameLine": true
+}

README.md

@@ -66,10 +66,6 @@ You can find the documentation here: https://github.com/Foundryborne/daggerheart
 
 Looking to contribute to the project? Look no further, check out our [contributing guide](CONTRIBUTING.md), and keep the [Code of Conduct](coc.md) in mind when working on things.
 
-## AI Policy
-
-The Foundryborne Daggerheart system does not make use of AI (generative or otherwise) for any area of its implementation. We expect all contributors to follow this same policy when contributing with a pull request; contributions made using AI will be rejected outright.
-
 ## Disclaimer:
 
 **Daggerheart System**

assets/icons/documents/actors/drama-masks.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" style="height: 512px; width: 512px;"><path d="M0 0h512v512H0z" fill="#000" fill-opacity="1"></path><g class="" transform="translate(0,0)" style=""><path d="M418.813 30.625c-21.178 26.27-49.712 50.982-84.125 70.844-36.778 21.225-75.064 33.62-110.313 38.06a310.317 310.317 0 0 0 6.813 18.25c16.01.277 29.366-.434 36.406-1.5l9.47-1.53 8.436-1.28.22 10.186a307.48 307.48 0 0 1-1.095 18.72l56.625 8.843c.86-.095 1.713-.15 2.563-.157 11.188-.114 21.44 7.29 24.468 18.593.657 2.448.922 4.903.845 7.313 5.972-2.075 11.753-4.305 17.28-6.72l9.595-4.188 2.313 10.22a340.211 340.211 0 0 1 7.375 48.062C438.29 247.836 468.438 225.71 493 197.5c-3.22-36.73-16.154-78.04-39.125-117.813a290.509 290.509 0 0 0-2.22-3.78l-27.56 71.374c5.154.762 10.123 3.158 14.092 7.126 9.81 9.807 9.813 25.69 0 35.5-9.812 9.81-25.722 9.807-35.53 0-8.86-8.858-9.69-22.68-2.532-32.5l38.938-100.844a322.02 322.02 0 0 0-20.25-25.937zM51.842 118.72c-8.46 17.373-15.76 36.198-21.187 56.436-14.108 52.617-13.96 103.682-2.812 143.438 13.3-2.605 26.442-3.96 39.312-4.03 1.855-.012 3.688.02 5.53.06 20.857.48 40.98 4.332 59.97 11.5a355.064 355.064 0 0 1-1.656-34.218c0-27.8 3.135-54.377 9-78.937l2.47-10.407 9.655 4.562c29.467 13.98 66.194 23.424 106.28 25.22 5.136-20.05 8.19-39.78 9.408-58.75-35.198 4.83-75.387 2.766-116.407-8.22-38.363-10.272-72.314-26.78-99.562-46.656zm230.594 82.218c-1.535 10.452-3.615 21.03-6.218 31.687a312.754 312.754 0 0 0 46-3.97 24.98 24.98 0 0 1-1.532-21.748l-38.25-5.97zM105 201.375l4.156 18.22-21.594 4.905c8.75 5.174 13.353 15.703 10.594 26-3.32 12.394-16.045 19.758-28.437 16.438-12.394-3.32-19.76-16.075-16.44-28.47a23.235 23.235 0 0 1 3.126-6.874l-21.062 4.78-4.125-18.218 73.78-16.78zm388.594 22.813c-25.53 25.46-55.306 45.445-86.906 60.5.05 2.397.093 4.8.093 7.218 0 9.188-.354 18.232-1.03 27.125 16.635 1.33 32.045-1.7 45.344-9.374 25.925-14.962 40.608-45.694 42.5-85.47zm-338.844 3c-4.03 19.993-6.33 41.31-6.406 63.593l.125-.342c30.568 10.174 62.622 17.572 95.25 21.375l7.5.875.718 7.5 5.687 60.125-18.625 1.75-2.53-26.75a23.117 23.117 0 0 1-14.845.968c-12.393-3.32-19.76-16.042-16.438-28.436.285-1.06.647-2.08 1.063-3.063a496.627 496.627 0 0 1-57.406-14.53c2.69 49.62 16.154 94.04 36.094 126.656 22.366 36.588 52.13 57.78 83.968 57.78 31.838.003 61.602-21.19 83.97-57.78 19.536-31.96 32.846-75.244 35.905-123.656a499.132 499.132 0 0 1-48.25 11.656c1.914 4.57 2.415 9.78 1.033 14.938-3.322 12.394-16.045 19.758-28.438 16.437a23.01 23.01 0 0 1-2.125-.686l-2.5 26.47-18.594-1.752 5.688-60.125.72-7.5 7.498-.875c29.245-3.407 57.995-9.717 85.657-18.312v-1.594c0-21.573-2.27-42.23-6.064-61.75C351.132 242.653 313.092 250 272.312 250c-43.59 0-83.986-8.658-117.562-22.813zm-87.5 105.968c-10.87.102-21.995 1.22-33.375 3.313 12.695 31.62 33.117 53.07 59 60 16.9 4.523 34.896 2.536 52.813-5.25-4.382-13.89-7.874-28.606-10.344-43.97-21.115-9.623-43.934-14.32-68.094-14.094zm137.5 80.22h130.813c-40.082 44.594-92.623 42.844-130.813 0z" fill="#fff" fill-opacity="1"></path></g></svg>

daggerheart.d.ts

@@ -1,11 +1,8 @@
 import '@client/global.mjs';
-import '@common/global.mjs';
-import '@common/primitives/global.mjs';
 import Canvas from '@client/canvas/board.mjs';
 
 // Foundry's use of `Object.assign(globalThis) means many globally available objects are not read as such
 // This declare global hopefully fixes that
-// Note: eslint is not aware of these, whatever is added here should go in the eslint's globals list
 declare global {
     /**
      * A simple event framework used throughout Foundry Virtual Tabletop.
@@ -15,28 +12,9 @@ declare global {
     class Hooks extends foundry.helpers.Hooks {}
     const fromUuid = foundry.utils.fromUuid;
     const fromUuidSync = foundry.utils.fromUuidSync;
-    /**
+
-     * A representation of a color in hexadecimal format.
-     * This class provides methods for transformations and manipulations of colors.
-     */
-    class Color extends foundry.utils.Color {}
     /**
      * The singleton game canvas
      */
     const canvas: Canvas;
-
-    const ActiveEffect: foundry.documents.ActiveEffect;
-    const Actor: foundry.documents.Actor;
-    const BaseScene: foundry.documents.BaseScene;
-    const ChatMessage: foundry.documents.ChatMessage;
-    const Combat: foundry.documents.Combat;
-    const Combatant: foundry.documents.Combatant;
-    const Item: foundry.documents.Item;
-    const Macro: foundry.documents.Macro;
-    const Scene: foundry.documents.Scene;
-    const TokenDocument: foundry.documents.TokenDocument;
-
-    const Collection: foundry.utils.Collection;
-    const FormDataExtended: foundry.applications.ux.FormDataExtended;
-    const TextEditor: foundry.applications.ux.TextEditor;
 }

daggerheart.mjs

@@ -196,11 +196,6 @@ Hooks.once('init', () => {
         makeDefault: true,
         label: sheetLabel('TYPES.Actor.environment')
     });
-    Actors.registerSheet(SYSTEM.id, applications.sheets.actors.NPC, {
-        types: ['npc'],
-        makeDefault: true,
-        label: sheetLabel('TYPES.Actor.npc')
-    });
     Actors.registerSheet(SYSTEM.id, applications.sheets.actors.Party, {
         types: ['party'],
         makeDefault: true,
@@ -446,33 +441,3 @@ Hooks.on('canvasTearDown', canvas => {
 Hooks.on('canvasReady', canas => {
     game.system.registeredTriggers.registerSceneTriggers(canvas.scene);
 });
-
-/** Make the user to select a document type, instead of having a default doc type for them to accidentally keep */
-Hooks.on('renderDialogV2', (_dialog, html) => {
-    if (!html.classList.contains('dialog')) return;
-    const cls = html.classList.contains('item-create')
-        ? documents.DHItem.implementation
-        : html.classList.contains('actor-create')
-            ? documents.DhpActor.implementation
-            : null;
-    if (!cls) return;
-
-    const form = html.querySelector('form');
-    const submit = html.querySelector('button[type=submit]');
-    const select = html.querySelector('select[name=type]');
-    const nameInput = html.querySelector('input[name=name]');
-    if (!form || !select || !submit || !nameInput) return;
-
-    nameInput.placeholder = cls.defaultName({});
-    const emptyOption = document.createElement('option');
-    emptyOption.value = '';
-    emptyOption.selected = true;
-    select.required = true;
-    select.prepend(emptyOption);
-    submit.addEventListener('click', event => {
-        if (!form.reportValidity()) {
-            event.preventDefault();
-            event.stopPropagation();
-        }
-    });
-});

eslint.config.mjs

@@ -1,101 +1,14 @@
 import globals from 'globals';
-import { defineConfig, globalIgnores } from 'eslint/config';
+import { defineConfig } from 'eslint/config';
-import tseslint from 'typescript-eslint';
+import prettier from 'eslint-plugin-prettier';
-import js from '@eslint/js';
-import stylistic from '@stylistic/eslint-plugin';
-
-/** @type {Partial<RulesConfig>} */
-export const stylisticRules = {
-    '@stylistic/indent': [
-        'error',
-        4,
-        {
-            SwitchCase: 1
-        }
-    ],
-    '@stylistic/max-len': ['error', { 
-        code: 120,
-        ignoreComments: true,
-        ignoreStrings: true,
-        ignoreTemplateLiterals: true,
-        ignoreRegExpLiterals: true
-    }],
-    '@stylistic/quotes': ['error', 'single', { allowTemplateLiterals: 'always' }],
-    '@stylistic/arrow-parens': ['error', 'as-needed'],
-    '@stylistic/quote-props': ['error', 'as-needed'],
-    '@stylistic/array-bracket-newline': ['error', 'consistent'],
-    '@stylistic/key-spacing': 'error',
-    '@stylistic/comma-dangle': ['error', 'never'],
-    '@stylistic/space-in-parens': ['error', 'never'],
-    '@stylistic/space-infix-ops': 2,
-    '@stylistic/keyword-spacing': 2,
-    '@stylistic/semi-spacing': 2,
-    '@stylistic/no-multi-spaces': 2,
-    '@stylistic/no-extra-semi': 2,
-    '@stylistic/no-whitespace-before-property': 2,
-    '@stylistic/space-unary-ops': 2
-};
 
 export default defineConfig([
-    globalIgnores(['foundry/**/*', 'build/**/*']),
+    { files: ['**/*.{js,mjs,cjs}'], languageOptions: { globals: globals.browser } },
-    {
+    { plugins: { prettier } },
-        files: ['gulpfile.js', 'postcss.config.js'],
-        languageOptions: { globals: globals.node }
-    },
     {
         files: ['**/*.{js,mjs,cjs}'],
-        plugins: {
-            '@stylistic': stylistic
-        },
-        languageOptions: {
-            globals: {
-                ...globals.browser,
-                CONFIG: 'readonly',
-                CONST: 'readonly',
-                // Global classes
-                Color: 'readonly',
-                Handlebars: 'readonly',
-                Hooks: 'readonly',
-                PIXI: 'readonly',
-                ProseMirror: 'readonly',
-                Roll: 'readonly',
-                // global namespaces
-                canvas: 'readonly',
-                foundry: 'readonly',
-                game: 'readonly',
-                ui: 'readonly',
-                // global functions
-                fromUuid: 'readonly',
-                fromUuidSync: 'readonly',
-                getDocumentClass: 'readonly',
-                _del: 'readonly',
-                _replace: 'readonly',
-                _loc: 'readonly',
-                // Documents
-                ActiveEffect: 'readonly',
-                Actor: 'readonly',
-                BaseScene: 'readonly',
-                ChatMessage: 'readonly',
-                Combat: 'readonly',
-                Combatant: 'readonly',
-                Item: 'readonly',
-                Macro: 'readonly',
-                Scene: 'readonly',
-                TokenDocument: 'readonly',
-                // Other
-                Collection: 'readonly',
-                FormDataExtended: 'readonly',
-                TextEditor: 'readonly'
-            }
-        },
         rules: {
-            'no-undef': 'error',
+            'prettier/prettier': 'error'
-            // 'no-unused-vars': ['error', { argsIgnorePattern: '^_', varsIgnorePattern: '^_' }],
-            ...stylisticRules
         }
-    },
-    {
-        files: ['**/*.ts'],
-        extends: [js.configs.recommended, tseslint.configs.recommended]
     }
 ]);

gulpfile.js

@@ -1,15 +1,9 @@
 // Less configuration
 var gulp = require('gulp');
 var less = require('gulp-less');
-var sourcemaps = require('gulp-sourcemaps');
 
 gulp.task('less', function (cb) {
-    gulp.src('styles/daggerheart.less')
+    gulp.src('styles/daggerheart.less').pipe(less()).on('error', console.error.bind(console)).pipe(gulp.dest('styles'));
-        .pipe(sourcemaps.init())
-        .pipe(less())
-        .on('error', console.error.bind(console))
-        .pipe(sourcemaps.write('.'))
-        .pipe(gulp.dest('styles'));
     cb();
 });
 

jsconfig.json

@@ -1,7 +1,7 @@
 {
     "compilerOptions": {
-        "module": "es2022",
+        "module": "ES6",
-        "target": "es2022",
+        "target": "ES6",
         "paths": {
             "@client/*": ["./foundry/client/*"],
             "@common/*": ["./foundry/common/*"]

lang/en.json

@@ -23,7 +23,6 @@
             "companion": "Companion",
             "adversary": "Adversary",
             "environment": "Environment",
-            "npc": "NPC",
             "party": "Party"
         }
     },
@@ -334,11 +333,6 @@
                 },
                 "newAdversary": "New Adversary"
             },
-            "NPC": {
-                "FIELDS": {
-                    "motives": { "label": "Motives" }
-                }
-            },
             "Party": {
                 "Subtitle": {
                     "character": "{community} {ancestry} | {subclass} {class}",
@@ -412,11 +406,7 @@
                 "giveSpotlight": "Give The Spotlight",
                 "requestingSpotlight": "Requesting The Spotlight",
                 "requestSpotlight": "Request The Spotlight",
-                "openCountdowns": "Countdowns",
+                "openCountdowns": "Countdowns"
-                "adversaryCategories": {
-                    "friendly": "Friendly",
-                    "adversaries": "Adversaries"
-                }
             },
             "CompendiumBrowserSettings": {
                 "title": "Enable Compendiums",
@@ -711,13 +701,19 @@
             },
             "PendingReactionsDialog": {
                 "title": "Pending Reaction Rolls Found",
-                "unfinishedRolls": "Some Tokens have not finished their Reaction Rolls.",
+                "unfinishedRolls": "Some Tokens still need to roll their Reaction Roll.",
-                "warning": "Unfinished reaction rolls will be considered as failed.",
+                "confirmation": "Are you sure you want to continue ?",
-                "confirmation": "Are you sure you want to continue?"
+                "warning": "Undone reaction rolls will be considered as failed"
             },
             "ReactionRoll": {
                 "title": "Reaction Roll: {trait}"
             },
+            "RerollDialog": {
+                "title": "Reroll",
+                "damageTitle": "Reroll Damage",
+                "deselectDiceNotification": "Deselect one of the selected dice first",
+                "acceptCurrentRolls": "Accept Current Rolls"
+            },
             "ResourceDice": {
                 "title": "{name} Resource",
                 "rerollDice": "Reroll Dice"
@@ -778,9 +774,7 @@
                 "title": "Group Roll"
             },
             "TokenConfig": {
-                "actorSizeUsed": "Actor size is set, determining the dimensions",
+                "actorSizeUsed": "Actor size is set, determining the dimensions"
-                "tokenSize": "Token Size",
-                "sizeCategory": "Size Category"
             }
         },
         "CLASS": {
@@ -2567,11 +2561,10 @@
                     "tokenImg": { "label": "Token Image" },
                     "tokenRingImg": { "label": "Subject Texture" },
                     "tokenSize": {
-                        "placeholder": "Token Size",
+                        "placeholder": "Using character dimensions",
-                        "disabledPlaceholder": "Token Size",
+                        "disabledPlaceholder": "Set by character size",
                         "height": { "label": "Height" },
                         "width": { "label": "Width" },
-                        "depth": { "label": "Depth" },
                         "scale": { "label": "Token Scale" }
                     },
                     "evolved": {
@@ -3097,7 +3090,6 @@
                 }
             },
             "ChatLog": {
-                "rerollActionRoll": "Reroll Action",
                 "rerollDamage": "Reroll Damage",
                 "assignTagRoll": "Assign as Tag Roll"
             },

module/applications/characterCreation/characterCreation.mjs

@@ -450,7 +450,7 @@ export default class DhCharacterCreation extends HandlebarsApplicationMixin(Appl
         if (equipment.includes(type))
             presets.filter = {
                 'system.tier': { key: 'system.tier', value: 1 },
-                type: { key: 'type', value: type }
+                'type': { key: 'type', value: type }
             };
 
         ui.compendiumBrowser.open(presets);

module/applications/dialogs/CompendiumBrowserSettings.mjs

@@ -50,7 +50,7 @@ export default class CompendiumBrowserSettings extends HandlebarsApplicationMixi
         const excludedSourceData = this.browserSettings.excludedSources;
         const excludedPackData = this.browserSettings.excludedPacks;
         context.typePackCollections = game.packs.reduce((acc, pack) => {
-            const { type, label, packageType, packageName: basePackageName, name, id } = pack.metadata;
+            const { type, label, packageType, packageName: basePackageName, id } = pack.metadata;
             if (!CompendiumBrowserSettings.#browserPackTypes.includes(type)) return acc;
 
             const isWorldPack = packageType === 'world';
@@ -68,15 +68,13 @@ export default class CompendiumBrowserSettings extends HandlebarsApplicationMixi
             if (!acc[type].sources[packageName])
                 acc[type].sources[packageName] = { label: sourceLabel, checked: sourceChecked, packs: [] };
 
-            const included =
+            const checked = !excludedPackData[id] || !excludedPackData[id].excludedDocumentTypes.includes(type);
-                !excludedPackData[packageName] ||
-                !excludedPackData[packageName][name]?.excludedDocumentTypes.includes(type);
 
             acc[type].sources[packageName].packs.push({
-                name,
+                pack: id,
                 type,
                 label: id === game.system.id ? game.system.title : game.i18n.localize(label),
-                checked: included
+                checked: checked
             });
 
             return acc;
@@ -108,16 +106,16 @@ export default class CompendiumBrowserSettings extends HandlebarsApplicationMixi
     toggleTypedPack(event) {
         event.stopPropagation();
 
-        const { type, source, packName } = event.target.dataset;
+        const { type, pack } = event.target.dataset;
-        const currentlyExcluded = this.browserSettings.excludedPacks[source]?.[packName]
+        const currentlyExcluded = this.browserSettings.excludedPacks[pack]
-            ? this.browserSettings.excludedPacks[source][packName].excludedDocumentTypes.includes(type)
+            ? this.browserSettings.excludedPacks[pack].excludedDocumentTypes.includes(type)
             : false;
 
-        this.browserSettings.excludedPacks[source] ??= {};
+        if (!this.browserSettings.excludedPacks[pack])
-        this.browserSettings.excludedPacks[source][packName] ??= { excludedDocumentTypes: [] };
+            this.browserSettings.excludedPacks[pack] = { excludedDocumentTypes: [] };
-        this.browserSettings.excludedPacks[source][packName].excludedDocumentTypes = currentlyExcluded
+        this.browserSettings.excludedPacks[pack].excludedDocumentTypes = currentlyExcluded
-            ? this.browserSettings.excludedPacks[source][packName].excludedDocumentTypes.filter(x => x !== type)
+            ? this.browserSettings.excludedPacks[pack].excludedDocumentTypes.filter(x => x !== type)
-            : [...(this.browserSettings.excludedPacks[source][packName]?.excludedDocumentTypes ?? []), type];
+            : [...(this.browserSettings.excludedPacks[pack]?.excludedDocumentTypes ?? []), type];
 
         this.render();
     }

module/applications/dialogs/_module.mjs

@@ -10,6 +10,7 @@ export { default as ImageSelectDialog } from './imageSelectDialog.mjs';
 export { default as ItemTransferDialog } from './itemTransfer.mjs';
 export { default as MulticlassChoiceDialog } from './multiclassChoiceDialog.mjs';
 export { default as OwnershipSelection } from './ownershipSelection.mjs';
+export { default as RerollDamageDialog } from './rerollDamageDialog.mjs';
 export { default as ResourceDiceDialog } from './resourceDiceDialog.mjs';
 export { default as ActionSelectionDialog } from './actionSelectionDialog.mjs';
 export { default as TagTeamDialog } from './tagTeamDialog.mjs';

module/applications/dialogs/d20RollDialog.mjs

@@ -175,14 +175,14 @@ export default class D20RollDialog extends HandlebarsApplicationMixin(Applicatio
         this.disadvantage = advantage === -1;
 
         this.config.roll.advantage = this.config.roll.advantage === advantage ? 0 : advantage;
-        if (this.config.roll.advantage === 0) return this.render();
 
-        const defaultFaces =
+        if (this.config.roll.advantage === 1 && this.config.data.rules.roll.defaultAdvantageDice) {
-            this.config.roll.advantage === 1
+            const faces = Number.parseInt(this.config.data.rules.roll.defaultAdvantageDice);
-                ? this.config.data.rules.roll.defaultAdvantageDice
-                : this.config.data.rules.roll.defaultDisadvantageDice;
-        const faces = Number.parseInt(defaultFaces);
             this.roll.advantageFaces = Number.isNaN(faces) ? this.roll.advantageFaces : faces;
+        } else if (this.config.roll.advantage === -1 && this.config.data.rules.roll.defaultDisadvantageDice) {
+            const faces = Number.parseInt(this.config.data.rules.roll.defaultDisadvantageDice);
+            this.roll.advantageFaces = Number.isNaN(faces) ? this.roll.advantageFaces : faces;
+        }
 
         this.render();
     }

module/applications/dialogs/damageReductionDialog.mjs

@@ -138,12 +138,12 @@ export default class DamageReductionDialog extends HandlebarsApplicationMixin(Ap
         const stressReductionStress = this.availableStressReductions
             ? stressReductions.reduce((acc, red) => acc + red.cost, 0)
             : 0;
-        const stress = this.actor.system.resources.stress;
         context.stress =
             selectedStressMarks.length > 0 || this.availableStressReductions
                 ? {
-                    value: stress.value + selectedStressMarks.length + stressReductionStress,
+                      value:
-                    max: stress.max
+                          this.actor.system.resources.stress.value + selectedStressMarks.length + stressReductionStress,
+                      max: this.actor.system.resources.stress.max
                   }
                 : null;
 

module/applications/dialogs/deathMove.mjs

@@ -57,7 +57,6 @@ export default class DhDeathMove extends HandlebarsApplicationMixin(ApplicationV
 
         let returnMessage = game.i18n.localize('DAGGERHEART.UI.Chat.deathMove.avoidScar');
         if (config.roll.fate.value <= this.actor.system.levelData.level.current) {
-            const maxHope = this.actor.system.resources.hope.max + this.actor.system.scars;
             const newScarAmount = this.actor.system.scars + 1;
             await this.actor.update({
                 system: {
@@ -65,7 +64,7 @@ export default class DhDeathMove extends HandlebarsApplicationMixin(ApplicationV
                 }
             });
 
-            if (newScarAmount >= maxHope) {
+            if (newScarAmount >= this.actor.system.resources.hope.max) {
                 await this.actor.setDeathMoveDefeated(CONFIG.DH.GENERAL.defeatedConditionChoices.dead.id);
                 return game.i18n.format('DAGGERHEART.UI.Chat.deathMove.journeysEnd', { scars: newScarAmount });
             }

module/applications/dialogs/groupRollDialog.mjs

@@ -106,12 +106,7 @@ export default class GroupRollDialog extends HandlebarsApplicationMixin(Applicat
         const context = await super._prepareContext(_options);
 
         context.isGM = game.user.isGM;
-        context.isEditable =
+        context.isEditable = this.getIsEditable();
-            game.user.isGM ||
-            this.party.system.partyMembers.some(actor => {
-                const selected = Boolean(this.party.system.groupRoll.participants[actor.id]);
-                return selected && actor.testUserPermission(game.user, CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER);
-            });
         context.fields = this.party.system.schema.fields.groupRoll.fields;
         context.data = this.party.system.groupRoll;
         context.traitOptions = CONFIG.DH.ACTOR.abilities;
@@ -270,6 +265,13 @@ export default class GroupRollDialog extends HandlebarsApplicationMixin(Applicat
         ];
     }
 
+    getIsEditable() {
+        return this.party.system.partyMembers.some(actor => {
+            const selected = Boolean(this.party.system.groupRoll.participants[actor.id]);
+            return selected && actor.testUserPermission(game.user, CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER);
+        });
+    }
+
     groupRollRefresh = ({ refreshType, action, parts }) => {
         if (refreshType !== RefreshType.GroupRoll) return;
 
@@ -356,6 +358,8 @@ export default class GroupRollDialog extends HandlebarsApplicationMixin(Applicat
         });
 
         if (!result) return;
+        // todo: move logic to actor.rollTrait() or actor.diceRoll()
+        if (!game.modules.get('dice-so-nice')?.active) foundry.audio.AudioHelper.play({ src: CONFIG.sounds.dice });
 
         const rollData = result.messageRoll.toJSON();
         delete rollData.options.messageRoll;

module/applications/dialogs/rerollDamageDialog.mjs

@@ -0,0 +1,280 @@
+const { ApplicationV2, HandlebarsApplicationMixin } = foundry.applications.api;
+
+export default class RerollDamageDialog extends HandlebarsApplicationMixin(ApplicationV2) {
+    constructor(message, options = {}) {
+        super(options);
+
+        this.message = message;
+        this.damage = Object.keys(message.system.damage).reduce((acc, typeKey) => {
+            const type = message.system.damage[typeKey];
+            acc[typeKey] = Object.keys(type.parts).reduce((acc, partKey) => {
+                const part = type.parts[partKey];
+                acc[partKey] = Object.keys(part.dice).reduce((acc, diceKey) => {
+                    const dice = part.dice[diceKey];
+                    const activeResults = dice.results.filter(x => x.active);
+                    acc[diceKey] = {
+                        dice: dice.dice,
+                        selectedResults: activeResults.length,
+                        maxSelected: activeResults.length,
+                        results: activeResults.map(x => ({ ...x, selected: true }))
+                    };
+
+                    return acc;
+                }, {});
+
+                return acc;
+            }, {});
+
+            return acc;
+        }, {});
+    }
+
+    static DEFAULT_OPTIONS = {
+        id: 'reroll-dialog',
+        classes: ['daggerheart', 'dialog', 'dh-style', 'views', 'reroll-dialog'],
+        window: {
+            icon: 'fa-solid fa-dice'
+        },
+        actions: {
+            toggleResult: RerollDamageDialog.#toggleResult,
+            selectRoll: RerollDamageDialog.#selectRoll,
+            doReroll: RerollDamageDialog.#doReroll,
+            save: RerollDamageDialog.#save
+        }
+    };
+
+    /** @override */
+    static PARTS = {
+        main: {
+            id: 'main',
+            template: 'systems/daggerheart/templates/dialogs/rerollDialog/damage/main.hbs'
+        },
+        footer: {
+            id: 'footer',
+            template: 'systems/daggerheart/templates/dialogs/rerollDialog/footer.hbs'
+        }
+    };
+
+    get title() {
+        return game.i18n.localize('DAGGERHEART.APPLICATIONS.RerollDialog.damageTitle');
+    }
+
+    _attachPartListeners(partId, htmlElement, options) {
+        super._attachPartListeners(partId, htmlElement, options);
+
+        htmlElement.querySelectorAll('.to-reroll-input').forEach(element => {
+            element.addEventListener('change', this.toggleDice.bind(this));
+        });
+    }
+
+    async _prepareContext(_options) {
+        const context = await super._prepareContext(_options);
+        context.damage = this.damage;
+        context.disabledReroll = !this.getRerollDice().length;
+        context.saveDisabled = !this.isSelectionDone();
+
+        return context;
+    }
+
+    static async #save() {
+        const update = {
+            'system.damage': Object.keys(this.damage).reduce((acc, typeKey) => {
+                const type = this.damage[typeKey];
+                let typeTotal = 0;
+                const messageType = this.message.system.damage[typeKey];
+                const parts = Object.keys(type).map(partKey => {
+                    const part = type[partKey];
+                    const messagePart = messageType.parts[partKey];
+                    let partTotal = messagePart.modifierTotal;
+                    const dice = Object.keys(part).map(diceKey => {
+                        const dice = part[diceKey];
+                        const total = dice.results.reduce((acc, result) => {
+                            if (result.active) acc += result.result;
+                            return acc;
+                        }, 0);
+                        partTotal += total;
+                        const messageDice = messagePart.dice[diceKey];
+                        return {
+                            ...messageDice,
+                            total: total,
+                            results: dice.results.map(x => ({
+                                ...x,
+                                hasRerolls: dice.results.length > 1
+                            }))
+                        };
+                    });
+
+                    typeTotal += partTotal;
+                    return {
+                        ...messagePart,
+                        total: partTotal,
+                        dice: dice
+                    };
+                });
+
+                acc[typeKey] = {
+                    ...messageType,
+                    total: typeTotal,
+                    parts: parts
+                };
+
+                return acc;
+            }, {})
+        };
+
+        await this.message.update(update);
+        await this.close();
+    }
+
+    getRerollDice() {
+        const rerollDice = [];
+        Object.keys(this.damage).forEach(typeKey => {
+            const type = this.damage[typeKey];
+            Object.keys(type).forEach(partKey => {
+                const part = type[partKey];
+                Object.keys(part).forEach(diceKey => {
+                    const dice = part[diceKey];
+                    Object.keys(dice.results).forEach(resultKey => {
+                        const result = dice.results[resultKey];
+                        if (result.toReroll) {
+                            rerollDice.push({
+                                ...result,
+                                dice: dice.dice,
+                                type: typeKey,
+                                part: partKey,
+                                dice: diceKey,
+                                result: resultKey
+                            });
+                        }
+                    });
+                });
+            });
+        });
+
+        return rerollDice;
+    }
+
+    isSelectionDone() {
+        const diceFinishedData = [];
+        Object.keys(this.damage).forEach(typeKey => {
+            const type = this.damage[typeKey];
+            Object.keys(type).forEach(partKey => {
+                const part = type[partKey];
+                Object.keys(part).forEach(diceKey => {
+                    const dice = part[diceKey];
+                    const selected = dice.results.reduce((acc, result) => acc + (result.active ? 1 : 0), 0);
+                    diceFinishedData.push(selected === dice.maxSelected);
+                });
+            });
+        });
+
+        return diceFinishedData.every(x => x);
+    }
+
+    toggleDice(event) {
+        const target = event.target;
+        const { type, part, dice } = target.dataset;
+        const toggleDice = this.damage[type][part][dice];
+
+        const existingDiceRerolls = this.getRerollDice().filter(
+            x => x.type === type && x.part === part && x.dice === dice
+        );
+
+        const allRerolled = existingDiceRerolls.length === toggleDice.results.filter(x => x.active).length;
+
+        toggleDice.toReroll = !allRerolled;
+        toggleDice.results.forEach(result => {
+            if (result.active) {
+                result.toReroll = !allRerolled;
+            }
+        });
+
+        this.render();
+    }
+
+    static #toggleResult(event) {
+        event.stopPropagation();
+
+        const target = event.target.closest('.to-reroll-result');
+        const { type, part, dice, result } = target.dataset;
+        const toggleDice = this.damage[type][part][dice];
+        const toggleResult = toggleDice.results[result];
+        toggleResult.toReroll = !toggleResult.toReroll;
+
+        const existingDiceRerolls = this.getRerollDice().filter(
+            x => x.type === type && x.part === part && x.dice === dice
+        );
+
+        const allToReroll = existingDiceRerolls.length === toggleDice.results.filter(x => x.active).length;
+        toggleDice.toReroll = allToReroll;
+
+        this.render();
+    }
+
+    static async #selectRoll(_, button) {
+        const { type, part, dice, result } = button.dataset;
+
+        const diceVal = this.damage[type][part][dice];
+        const diceResult = diceVal.results[result];
+        if (!diceResult.active && diceVal.results.filter(x => x.active).length === diceVal.maxSelected) {
+            return ui.notifications.warn(
+                game.i18n.localize('DAGGERHEART.APPLICATIONS.RerollDialog.deselectDiceNotification')
+            );
+        }
+
+        if (diceResult.active) {
+            diceVal.toReroll = false;
+            diceResult.toReroll = false;
+        }
+
+        diceVal.selectedResults += diceResult.active ? -1 : 1;
+        diceResult.active = !diceResult.active;
+
+        this.render();
+    }
+
+    static async #doReroll() {
+        const toReroll = this.getRerollDice().map(x => {
+            const { type, part, dice, result } = x;
+            const diceData = this.damage[type][part][dice].results[result];
+            return {
+                ...diceData,
+                dice: this.damage[type][part][dice].dice,
+                typeKey: type,
+                partKey: part,
+                diceKey: dice,
+                resultsIndex: result
+            };
+        });
+
+        const roll = await new Roll(toReroll.map(x => `1${x.dice}`).join(' + ')).evaluate();
+
+        if (game.modules.get('dice-so-nice')?.active) {
+            const diceSoNiceRoll = {
+                _evaluated: true,
+                dice: roll.dice,
+                options: { appearance: {} }
+            };
+
+            await game.dice3d.showForRoll(diceSoNiceRoll, game.user, true);
+        }
+
+        toReroll.forEach((data, index) => {
+            const { typeKey, partKey, diceKey, resultsIndex } = data;
+            const rerolledDice = roll.dice[index];
+
+            const dice = this.damage[typeKey][partKey][diceKey];
+            dice.toReroll = false;
+            dice.results[resultsIndex].active = false;
+            dice.results[resultsIndex].discarded = true;
+            dice.results[resultsIndex].toReroll = false;
+            dice.results.splice(dice.results.length, 0, {
+                ...rerolledDice.results[0],
+                toReroll: false,
+                selected: true
+            });
+        });
+
+        this.render();
+    }
+}

module/applications/dialogs/rerollDialog.mjs

@@ -0,0 +1,279 @@
+const { ApplicationV2, HandlebarsApplicationMixin } = foundry.applications.api;
+
+export default class RerollDialog extends HandlebarsApplicationMixin(ApplicationV2) {
+    constructor(message, options = {}) {
+        super(options);
+
+        this.message = message;
+        this.damage = Object.keys(message.system.damage).reduce((acc, typeKey) => {
+            const type = message.system.damage[typeKey];
+            acc[typeKey] = Object.keys(type.parts).reduce((acc, partKey) => {
+                const part = type.parts[partKey];
+                acc[partKey] = Object.keys(part.dice).reduce((acc, diceKey) => {
+                    const dice = part.dice[diceKey];
+                    const activeResults = dice.results.filter(x => x.active);
+                    acc[diceKey] = {
+                        dice: dice.dice,
+                        selectedResults: activeResults.length,
+                        maxSelected: activeResults.length,
+                        results: activeResults.map(x => ({ ...x, selected: true }))
+                    };
+
+                    return acc;
+                }, {});
+
+                return acc;
+            }, {});
+
+            return acc;
+        }, {});
+    }
+
+    static DEFAULT_OPTIONS = {
+        id: 'reroll-dialog',
+        classes: ['daggerheart', 'dialog', 'dh-style', 'views', 'reroll-dialog'],
+        window: {
+            icon: 'fa-solid fa-dice'
+        },
+        actions: {
+            toggleResult: RerollDialog.#toggleResult,
+            selectRoll: RerollDialog.#selectRoll,
+            doReroll: RerollDialog.#doReroll,
+            save: RerollDialog.#save
+        }
+    };
+
+    /** @override */
+    static PARTS = {
+        main: {
+            id: 'main',
+            template: 'systems/daggerheart/templates/dialogs/rerollDialog/main.hbs'
+        },
+        footer: {
+            id: 'footer',
+            template: 'systems/daggerheart/templates/dialogs/rerollDialog/footer.hbs'
+        }
+    };
+
+    get title() {
+        return game.i18n.localize('DAGGERHEART.APPLICATIONS.RerollDialog.title');
+    }
+
+    _attachPartListeners(partId, htmlElement, options) {
+        super._attachPartListeners(partId, htmlElement, options);
+
+        htmlElement.querySelectorAll('.to-reroll-input').forEach(element => {
+            element.addEventListener('change', this.toggleDice.bind(this));
+        });
+    }
+
+    async _prepareContext(_options) {
+        const context = await super._prepareContext(_options);
+        context.damage = this.damage;
+        context.disabledReroll = !this.getRerollDice().length;
+        context.saveDisabled = !this.isSelectionDone();
+
+        return context;
+    }
+
+    static async #save() {
+        const update = {
+            'system.damage': Object.keys(this.damage).reduce((acc, typeKey) => {
+                const type = this.damage[typeKey];
+                let typeTotal = 0;
+                const messageType = this.message.system.damage[typeKey];
+                const parts = Object.keys(type).map(partKey => {
+                    const part = type[partKey];
+                    const messagePart = messageType.parts[partKey];
+                    let partTotal = messagePart.modifierTotal;
+                    const dice = Object.keys(part).map(diceKey => {
+                        const dice = part[diceKey];
+                        const total = dice.results.reduce((acc, result) => {
+                            if (result.active) acc += result.result;
+                            return acc;
+                        }, 0);
+                        partTotal += total;
+                        const messageDice = messagePart.dice[diceKey];
+                        return {
+                            ...messageDice,
+                            total: total,
+                            results: dice.results.map(x => ({
+                                ...x,
+                                hasRerolls: dice.results.length > 1
+                            }))
+                        };
+                    });
+
+                    typeTotal += partTotal;
+                    return {
+                        ...messagePart,
+                        total: partTotal,
+                        dice: dice
+                    };
+                });
+
+                acc[typeKey] = {
+                    ...messageType,
+                    total: typeTotal,
+                    parts: parts
+                };
+
+                return acc;
+            }, {})
+        };
+        await this.message.update(update);
+        await this.close();
+    }
+
+    getRerollDice() {
+        const rerollDice = [];
+        Object.keys(this.damage).forEach(typeKey => {
+            const type = this.damage[typeKey];
+            Object.keys(type).forEach(partKey => {
+                const part = type[partKey];
+                Object.keys(part).forEach(diceKey => {
+                    const dice = part[diceKey];
+                    Object.keys(dice.results).forEach(resultKey => {
+                        const result = dice.results[resultKey];
+                        if (result.toReroll) {
+                            rerollDice.push({
+                                ...result,
+                                dice: dice.dice,
+                                type: typeKey,
+                                part: partKey,
+                                dice: diceKey,
+                                result: resultKey
+                            });
+                        }
+                    });
+                });
+            });
+        });
+
+        return rerollDice;
+    }
+
+    isSelectionDone() {
+        const diceFinishedData = [];
+        Object.keys(this.damage).forEach(typeKey => {
+            const type = this.damage[typeKey];
+            Object.keys(type).forEach(partKey => {
+                const part = type[partKey];
+                Object.keys(part).forEach(diceKey => {
+                    const dice = part[diceKey];
+                    const selected = dice.results.reduce((acc, result) => acc + (result.active ? 1 : 0), 0);
+                    diceFinishedData.push(selected === dice.maxSelected);
+                });
+            });
+        });
+
+        return diceFinishedData.every(x => x);
+    }
+
+    toggleDice(event) {
+        const target = event.target;
+        const { type, part, dice } = target.dataset;
+        const toggleDice = this.damage[type][part][dice];
+
+        const existingDiceRerolls = this.getRerollDice().filter(
+            x => x.type === type && x.part === part && x.dice === dice
+        );
+
+        const allRerolled = existingDiceRerolls.length === toggleDice.results.filter(x => x.active).length;
+
+        toggleDice.toReroll = !allRerolled;
+        toggleDice.results.forEach(result => {
+            if (result.active) {
+                result.toReroll = !allRerolled;
+            }
+        });
+
+        this.render();
+    }
+
+    static #toggleResult(event) {
+        event.stopPropagation();
+
+        const target = event.target.closest('.to-reroll-result');
+        const { type, part, dice, result } = target.dataset;
+        const toggleDice = this.damage[type][part][dice];
+        const toggleResult = toggleDice.results[result];
+        toggleResult.toReroll = !toggleResult.toReroll;
+
+        const existingDiceRerolls = this.getRerollDice().filter(
+            x => x.type === type && x.part === part && x.dice === dice
+        );
+
+        const allToReroll = existingDiceRerolls.length === toggleDice.results.length;
+        toggleDice.toReroll = allToReroll;
+
+        this.render();
+    }
+
+    static async #selectRoll(_, button) {
+        const { type, part, dice, result } = button.dataset;
+
+        const diceVal = this.damage[type][part][dice];
+        const diceResult = diceVal.results[result];
+        if (!diceResult.active && diceVal.results.filter(x => x.active).length === diceVal.maxSelected) {
+            return ui.notifications.warn(
+                game.i18n.localize('DAGGERHEART.APPLICATIONS.RerollDialog.deselectDiceNotification')
+            );
+        }
+
+        if (diceResult.active) {
+            diceVal.toReroll = false;
+            diceResult.toReroll = false;
+        }
+
+        diceVal.selectedResults += diceResult.active ? -1 : 1;
+        diceResult.active = !diceResult.active;
+
+        this.render();
+    }
+
+    static async #doReroll() {
+        const toReroll = this.getRerollDice().map(x => {
+            const { type, part, dice, result } = x;
+            const diceData = this.damage[type][part][dice].results[result];
+            return {
+                ...diceData,
+                dice: this.damage[type][part][dice].dice,
+                typeKey: type,
+                partKey: part,
+                diceKey: dice,
+                resultsIndex: result
+            };
+        });
+
+        const roll = await new Roll(toReroll.map(x => `1${x.dice}`).join(' + ')).evaluate();
+
+        if (game.modules.get('dice-so-nice')?.active) {
+            const diceSoNiceRoll = {
+                _evaluated: true,
+                dice: roll.dice,
+                options: { appearance: {} }
+            };
+
+            await game.dice3d.showForRoll(diceSoNiceRoll, game.user, true);
+        }
+
+        toReroll.forEach((data, index) => {
+            const { typeKey, partKey, diceKey, resultsIndex } = data;
+            const rerolledDice = roll.dice[index];
+
+            const dice = this.damage[typeKey][partKey][diceKey];
+            dice.toReroll = false;
+            dice.results[resultsIndex].active = false;
+            dice.results[resultsIndex].discarded = true;
+            dice.results[resultsIndex].toReroll = false;
+            dice.results.splice(dice.results.length, 0, {
+                ...rerolledDice.results[0],
+                toReroll: false,
+                selected: true
+            });
+        });
+
+        this.render();
+    }
+}

module/applications/dialogs/resourceDiceDialog.mjs

@@ -1,4 +1,4 @@
-import { itemAbleRollParse, triggerChatRollFx } from '../../helpers/utils.mjs';
+import { itemAbleRollParse } from '../../helpers/utils.mjs';
 
 const { ApplicationV2, HandlebarsApplicationMixin } = foundry.applications.api;
 
@@ -69,7 +69,7 @@ export default class ResourceDiceDialog extends HandlebarsApplicationMixin(Appli
         const max = itemAbleRollParse(this.item.system.resource.max, this.actor, this.item);
         const diceFormula = `${max}${this.item.system.resource.dieFaces}`;
         const roll = await new Roll(diceFormula).evaluate();
-        await triggerChatRollFx([roll]);
+        if (game.modules.get('dice-so-nice')?.active) await game.dice3d.showForRoll(roll, game.user, true);
         this.rollValues = roll.terms[0].results.map(x => ({ value: x.result, used: false }));
         this.resetUsed = true;
 

module/applications/dialogs/tagTeamDialog.mjs

@@ -38,9 +38,6 @@ export default class TagTeamDialog extends HandlebarsApplicationMixin(Applicatio
         tag: 'form',
         classes: ['daggerheart', 'views', 'dh-style', 'dialog', 'tag-team-dialog'],
         position: { width: 550, height: 'auto' },
-        window: {
-            icon: 'fa-solid fa-user-group'
-        },
         actions: {
             toggleSelectMember: TagTeamDialog.#toggleSelectMember,
             startTagTeamRoll: TagTeamDialog.#startTagTeamRoll,
@@ -116,12 +113,7 @@ export default class TagTeamDialog extends HandlebarsApplicationMixin(Applicatio
 
     async _prepareContext(_options) {
         const context = await super._prepareContext(_options);
-        context.isEditable =
+        context.isEditable = this.getIsEditable();
-            game.user.isGM ||
-            this.party.system.partyMembers.some(actor => {
-                const selected = Boolean(this.party.system.tagTeam.members[actor.id]);
-                return selected && actor.testUserPermission(game.user, CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER);
-            });
         context.fields = this.party.system.schema.fields.tagTeam.fields;
         context.data = this.party.system.tagTeam;
         context.rollTypes = CONFIG.DH.GENERAL.tagTeamRollTypes;
@@ -184,56 +176,57 @@ export default class TagTeamDialog extends HandlebarsApplicationMixin(Applicatio
         }
 
         if (Object.keys(this.party.system.tagTeam.members).includes(partId)) {
-            const data = await this.#prepareMemberContext(partId);
+            const data = this.party.system.tagTeam.members[partId];
-            partContext.hasDamage |= Boolean(data?.damage);
-            partContext.members[partId] = data;
-        }
-
-        return partContext;
-    }
-
-    async #prepareMemberContext(partId) {
-        const data = this.party.system.tagTeam.members[partId] ?? {};
             const actor = game.actors.get(partId);
-        if (!actor) console.error(`Failed to get actor ${partId}`);
 
             const rollOptions = [];
             const damageRollOptions = [];
-        for (const item of actor?.items ?? []) {
+            for (const item of actor.items) {
-            if (!item.system.metadata.hasActions) continue;
+                if (item.system.metadata.hasActions) {
                     const actions = [...item.system.actions, ...(item.system.attack ? [item.system.attack] : [])];
                     for (const action of actions) {
                         if (action.hasRoll) {
-                    const collection = action.hasDamage ? damageRollOptions : rollOptions;
+                            const actionItem = {
-                    collection.push({
                                 value: action.uuid,
                                 label: action.name,
                                 group: item.name,
                                 baseAction: action.baseAction
-                    });
+                            };
+
+                            if (action.hasDamage) damageRollOptions.push(actionItem);
+                            else rollOptions.push(actionItem);
+                        }
                     }
                 }
             }
 
             const selectedRoll = Object.values(this.party.system.tagTeam.members).find(member => member.selected);
-        const critSelected = !selectedRoll ? undefined : (selectedRoll?.rollData?.options?.roll?.isCritical ?? false);
+            const critSelected = !selectedRoll
-        const damage = data.rollData?.options?.damage;
+                ? undefined
+                : (selectedRoll?.rollData?.options?.roll?.isCritical ?? false);
 
-        return {
+            const damage = data.rollData?.options?.damage;
+            partContext.hasDamage |= Boolean(damage);
+            const critHitPointsDamage = await this.getCriticalDamage(damage);
+
+            partContext.members[partId] = {
                 ...data,
                 roll: data.roll,
-            isEditable: actor?.testUserPermission(game.user, CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER),
+                isEditable: actor.testUserPermission(game.user, CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER),
                 key: partId,
                 readyToRoll: Boolean(data.rollChoice),
                 hasRolled: Boolean(data.rollData),
                 rollOptions,
                 damageRollOptions,
                 damage: damage,
-            critDamage: await this.getCriticalDamage(damage),
+                critDamage: critHitPointsDamage,
                 useCritDamage: critSelected || (critSelected === undefined && data.rollData?.options?.roll?.isCritical)
             };
         }
 
+        return partContext;
+    }
+
     getUpdatingParts(target) {
         const { initialization, rollSelection, result } = this.constructor.PARTS;
         const isInitialization = this.tabGroups.application === initialization.id;
@@ -277,6 +270,13 @@ export default class TagTeamDialog extends HandlebarsApplicationMixin(Applicatio
         );
     }
 
+    getIsEditable() {
+        return this.party.system.partyMembers.some(actor => {
+            const selected = Boolean(this.party.system.tagTeam.members[actor.id]);
+            return selected && actor.testUserPermission(game.user, CONST.DOCUMENT_OWNERSHIP_LEVELS.OWNER);
+        });
+    }
+
     tagTeamRefresh = ({ refreshType, action, parts }) => {
         if (refreshType !== RefreshType.TagTeamRoll) return;
 
@@ -431,6 +431,8 @@ export default class TagTeamDialog extends HandlebarsApplicationMixin(Applicatio
 
         if (!result) return;
 
+        if (!game.modules.get('dice-so-nice')?.active) foundry.audio.AudioHelper.play({ src: CONFIG.sounds.dice });
+
         const rollData = result.messageRoll.toJSON();
         delete rollData.options.messageRoll;
         this.updatePartyData(
@@ -646,11 +648,10 @@ export default class TagTeamDialog extends HandlebarsApplicationMixin(Applicatio
     }
 
     async getJoinedRoll({ overrideIsCritical, displayVersion } = {}) {
-        try {
         const memberValues = Object.values(this.party.system.tagTeam.members);
         const selectedRoll = memberValues.find(x => x.selected);
-            const baseMainRoll = selectedRoll ?? memberValues[0];
+        let baseMainRoll = selectedRoll ?? memberValues[0];
-            const baseSecondaryRoll = selectedRoll
+        let baseSecondaryRoll = selectedRoll
             ? memberValues.find(x => !x.selected)
             : memberValues.length > 1
               ? memberValues[1]
@@ -669,16 +670,13 @@ export default class TagTeamDialog extends HandlebarsApplicationMixin(Applicatio
                 ? await this.getCriticalDamage(secondaryRollData.options.damage)
                 : secondaryRollData.options.damage;
             if (systemData.damage) {
-                    for (const [key, damage] of Object.entries(secondaryDamage ?? {})) {
+                for (const key in secondaryDamage) {
-                        if (key in systemData.damage) {
+                    const damage = secondaryDamage[key];
-                            systemData.damage[key].formula = [systemData.damage[key]?.formula, damage.formula]
+                    systemData.damage[key].formula = [systemData.damage[key].formula, damage.formula]
                         .filter(x => x)
                         .join(' + ');
                     systemData.damage[key].total += damage.total;
                     systemData.damage[key].parts.push(...damage.parts);
-                        } else {
-                            systemData.damage[key] = damage;
-                        }
                 }
             } else {
                 systemData.damage = secondaryDamage;
@@ -686,10 +684,6 @@ export default class TagTeamDialog extends HandlebarsApplicationMixin(Applicatio
         }
 
         return mainRoll;
-        } catch (err) {
-            console.error(err);
-            return null;
-        }
     }
 
     static async #onCancelRoll(_event, _button, options = { confirm: true }) {

module/applications/hud/tokenHUD.mjs

@@ -124,9 +124,7 @@ export default class DHTokenHUD extends foundry.applications.hud.TokenHUD {
         const animationDuration = 500;
         const scene = game.scenes.get(game.user.viewedScene);
         /* getDependentTokens returns already removed tokens with id = null. Need to filter that until it's potentially fixed from Foundry */
-        const activeTokens = actors.flatMap(member =>
+        const activeTokens = actors.flatMap(member => member.getDependentTokens({ scenes: scene }).filter(x => x._id));
-            member.getDependentTokens({ scenes: scene }).filter(x => x._id && !x._destroyed)
-        );
         const { x: actorX, y: actorY } = this.document;
         if (activeTokens.length > 0) {
             for (let token of activeTokens) {

module/applications/levelup/characterLevelup.mjs

@@ -156,7 +156,6 @@ export default class DhCharacterLevelUp extends LevelUpBase {
                 if (multiclasses?.[0]) {
                     const data = multiclasses[0];
                     const multiclass = data.data.length > 0 ? await foundry.utils.fromUuid(data.data[0]) : {};
-                    const subclasses = (await multiclass?.system?.fetchSubclasses()) ?? [];
 
                     context.multiclass = {
                         ...data,
@@ -176,12 +175,13 @@ export default class DhCharacterLevelUp extends LevelUpBase {
                                         alreadySelected
                                 };
                             }) ?? [],
-                        subclasses: subclasses.map(subclass => ({
+                        subclasses:
+                            multiclass?.system?.subclasses.map(subclass => ({
                                 ...subclass,
                                 uuid: subclass.uuid,
                                 selected: data.secondaryData.subclass === subclass.uuid,
                                 disabled: data.secondaryData.subclass && data.secondaryData.subclass !== subclass.uuid
-                        })),
+                            })) ?? [],
                         compendium: 'classes',
                         limit: 1
                     };

module/applications/levelup/levelup.mjs

@@ -135,6 +135,192 @@ export default class DhlevelUp extends HandlebarsApplicationMixin(ApplicationV2)
                 context.tabs.advancements.progress = { selected: selections, max: currentLevel.maxSelections };
                 context.showTabs = this.tabGroups.primary !== 'summary';
                 break;
+
+                const actorArmor = this.actor.system.armor;
+                const levelKeys = Object.keys(this.levelup.levels);
+                let achivementProficiency = 0;
+                const achievementCards = [];
+                let achievementExperiences = [];
+                for (var levelKey of levelKeys) {
+                    const level = this.levelup.levels[levelKey];
+                    if (Number(levelKey) < this.levelup.startLevel) continue;
+
+                    achivementProficiency += level.achievements.proficiency ?? 0;
+                    const cards = level.achievements.domainCards ? Object.values(level.achievements.domainCards) : null;
+                    if (cards) {
+                        for (var card of cards) {
+                            const itemCard = await foundry.utils.fromUuid(card.uuid);
+                            achievementCards.push(itemCard);
+                        }
+                    }
+
+                    achievementExperiences = level.achievements.experiences
+                        ? Object.values(level.achievements.experiences).reduce((acc, experience) => {
+                              if (experience.name) acc.push(experience);
+                              return acc;
+                          }, [])
+                        : [];
+                }
+
+                context.achievements = {
+                    proficiency: {
+                        old: this.actor.system.proficiency,
+                        new: this.actor.system.proficiency + achivementProficiency,
+                        shown: achivementProficiency > 0
+                    },
+                    damageThresholds: {
+                        major: {
+                            old: this.actor.system.damageThresholds.major,
+                            new: this.actor.system.damageThresholds.major + changedActorLevel - currentActorLevel
+                        },
+                        severe: {
+                            old: this.actor.system.damageThresholds.severe,
+                            new:
+                                this.actor.system.damageThresholds.severe +
+                                (actorArmor
+                                    ? changedActorLevel - currentActorLevel
+                                    : (changedActorLevel - currentActorLevel) * 2)
+                        },
+                        unarmored: !actorArmor
+                    },
+                    domainCards: {
+                        values: achievementCards,
+                        shown: achievementCards.length > 0
+                    },
+                    experiences: {
+                        values: achievementExperiences
+                    }
+                };
+
+                const advancement = {};
+                for (var levelKey of levelKeys) {
+                    const level = this.levelup.levels[levelKey];
+                    if (Number(levelKey) < this.levelup.startLevel) continue;
+
+                    for (var choiceKey of Object.keys(level.choices)) {
+                        const choice = level.choices[choiceKey];
+                        for (var checkbox of Object.values(choice)) {
+                            switch (choiceKey) {
+                                case 'proficiency':
+                                case 'hitPoint':
+                                case 'stress':
+                                case 'evasion':
+                                    advancement[choiceKey] = advancement[choiceKey]
+                                        ? advancement[choiceKey] + Number(checkbox.value)
+                                        : Number(checkbox.value);
+                                    break;
+                                case 'trait':
+                                    if (!advancement[choiceKey]) advancement[choiceKey] = {};
+                                    for (var traitKey of checkbox.data) {
+                                        if (!advancement[choiceKey][traitKey]) advancement[choiceKey][traitKey] = 0;
+                                        advancement[choiceKey][traitKey] += 1;
+                                    }
+                                    break;
+                                case 'domainCard':
+                                    if (!advancement[choiceKey]) advancement[choiceKey] = [];
+                                    if (checkbox.data.length === 1) {
+                                        const choiceItem = await foundry.utils.fromUuid(checkbox.data[0]);
+                                        advancement[choiceKey].push(choiceItem.toObject());
+                                    }
+                                    break;
+                                case 'experience':
+                                    if (!advancement[choiceKey]) advancement[choiceKey] = [];
+                                    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;
+                                case 'subclass':
+                                    if (checkbox.data[0]) {
+                                        const subclassItem = await foundry.utils.fromUuid(checkbox.data[0]);
+                                        if (!advancement[choiceKey]) advancement[choiceKey] = [];
+                                        advancement[choiceKey].push({
+                                            ...subclassItem.toObject(),
+                                            featureLabel: game.i18n.localize(
+                                                subclassFeatureLabels[Number(checkbox.secondaryData.featureState)]
+                                            )
+                                        });
+                                    }
+                                    break;
+                                case 'multiclass':
+                                    const multiclassItem = await foundry.utils.fromUuid(checkbox.data[0]);
+                                    const subclass = multiclassItem
+                                        ? await foundry.utils.fromUuid(checkbox.secondaryData.subclass)
+                                        : null;
+                                    advancement[choiceKey] = multiclassItem
+                                        ? {
+                                              ...multiclassItem.toObject(),
+                                              domain: checkbox.secondaryData.domain
+                                                  ? game.i18n.localize(
+                                                        CONFIG.DH.DOMAIN.allDomains()[checkbox.secondaryData.domain]
+                                                            .label
+                                                    )
+                                                  : null,
+                                              subclass: subclass ? subclass.name : null
+                                          }
+                                        : {};
+                                    break;
+                            }
+                        }
+                    }
+                }
+
+                context.advancements = {
+                    statistics: {
+                        proficiency: {
+                            old: context.achievements.proficiency.new,
+                            new: context.achievements.proficiency.new + (advancement.proficiency ?? 0)
+                        },
+                        hitPoints: {
+                            old: this.actor.system.resources.hitPoints.max,
+                            new: this.actor.system.resources.hitPoints.max + (advancement.hitPoint ?? 0)
+                        },
+                        stress: {
+                            old: this.actor.system.resources.stress.max,
+                            new: this.actor.system.resources.stress.max + (advancement.stress ?? 0)
+                        },
+                        evasion: {
+                            old: this.actor.system.evasion,
+                            new: this.actor.system.evasion + (advancement.evasion ?? 0)
+                        }
+                    },
+                    traits: Object.keys(this.actor.system.traits).reduce((acc, traitKey) => {
+                        if (advancement.trait?.[traitKey]) {
+                            if (!acc) acc = {};
+                            acc[traitKey] = {
+                                label: game.i18n.localize(abilities[traitKey].label),
+                                old: this.actor.system.traits[traitKey].value,
+                                new: this.actor.system.traits[traitKey].value + advancement.trait[traitKey]
+                            };
+                        }
+                        return acc;
+                    }, null),
+                    domainCards: advancement.domainCard ?? [],
+                    experiences:
+                        advancement.experience?.flatMap(x => x.data.map(data => ({ name: data, modifier: x.value }))) ??
+                        [],
+                    multiclass: advancement.multiclass,
+                    subclass: advancement.subclass
+                };
+
+                context.advancements.statistics.proficiency.shown =
+                    context.advancements.statistics.proficiency.new > context.advancements.statistics.proficiency.old;
+                context.advancements.statistics.hitPoints.shown =
+                    context.advancements.statistics.hitPoints.new > context.advancements.statistics.hitPoints.old;
+                context.advancements.statistics.stress.shown =
+                    context.advancements.statistics.stress.new > context.advancements.statistics.stress.old;
+                context.advancements.statistics.evasion.shown =
+                    context.advancements.statistics.evasion.new > context.advancements.statistics.evasion.old;
+                context.advancements.statistics.shown =
+                    context.advancements.statistics.proficiency.shown ||
+                    context.advancements.statistics.hitPoints.shown ||
+                    context.advancements.statistics.stress.shown ||
+                    context.advancements.statistics.evasion.shown;
+
+                break;
         }
 
         return context;
@@ -172,14 +358,14 @@ export default class DhlevelUp extends HandlebarsApplicationMixin(ApplicationV2)
         const experienceIncreaseTagify = htmlElement.querySelector('.levelup-experience-increases');
         if (experienceIncreaseTagify) {
             const allExperiences = {
+                ...this.actor.system.experiences,
                 ...Object.values(this.levelup.levels).reduce((acc, level) => {
                     for (const key of Object.keys(level.achievements.experiences)) {
                         acc[key] = level.achievements.experiences[key];
                     }
 
                     return acc;
-                }, {}),
+                }, {})
-                ...this.actor.system.experiences
             };
             tagifyElement(
                 experienceIncreaseTagify,
@@ -198,7 +384,9 @@ export default class DhlevelUp extends HandlebarsApplicationMixin(ApplicationV2)
         this._dragDrop.forEach(d => d.bind(htmlElement));
     }
 
-    tagifyUpdate = type => async (_, { option, removed }) => {
+    tagifyUpdate =
+        type =>
+        async (_, { option, removed }) => {
             const updatePath = Object.keys(this.levelup.levels[this.levelup.currentLevel].choices).reduce(
                 (acc, choiceKey) => {
                     const choice = this.levelup.levels[this.levelup.currentLevel].choices[choiceKey];

module/applications/settings/homebrewSettings.mjs

@@ -1,5 +1,6 @@
 import { DhHomebrew } from '../../data/settings/_module.mjs';
 import { Resource } from '../../data/settings/Homebrew.mjs';
+import { slugify } from '../../helpers/utils.mjs';
 
 const { HandlebarsApplicationMixin, ApplicationV2 } = foundry.applications.api;
 
@@ -111,7 +112,7 @@ export default class DhHomebrewSettings extends HandlebarsApplicationMixin(Appli
 
         switch (partId) {
             case 'domains':
-                const selectedDomain = this.settings.domains[this.selected.domain] ?? null;
+                const selectedDomain = this.selected.domain ? this.settings.domains[this.selected.domain] : null;
                 const enrichedDescription = selectedDomain
                     ? await foundry.applications.ux.TextEditor.implementation.enrichHTML(selectedDomain.description)
                     : null;
@@ -402,12 +403,12 @@ export default class DhHomebrewSettings extends HandlebarsApplicationMixin(Appli
             const domainName = button.form.elements.domainName.value;
             if (!domainName) return;
 
-            const newSlug = domainName.slugify();
+            const newSlug = slugify(domainName);
             const existingDomains = [
                 ...Object.values(this.settings.domains),
                 ...Object.values(CONFIG.DH.DOMAIN.domains)
             ];
-            if (existingDomains.find(x => x.id === newSlug)) {
+            if (existingDomains.find(x => slugify(game.i18n.localize(x.label)) === newSlug)) {
                 ui.notifications.warn(game.i18n.localize('DAGGERHEART.SETTINGS.Homebrew.domains.duplicateDomain'));
                 return;
             }
@@ -528,7 +529,7 @@ export default class DhHomebrewSettings extends HandlebarsApplicationMixin(Appli
             const identifier = button.form.elements.identifier.value;
             if (!identifier) return;
 
-            const sluggedIdentifier = identifier.slugify();
+            const sluggedIdentifier = slugify(identifier);
 
             await this.settings.updateSource({
                 [`resources.${actorType}.resources.${sluggedIdentifier}`]: Resource.getDefaultResourceData(identifier)

module/applications/sheets-configs/_module.mjs

@@ -2,7 +2,6 @@ export { default as ActionConfig } from './action-config.mjs';
 export { default as ActionSettingsConfig } from './action-settings-config.mjs';
 export { default as CharacterSettings } from './character-settings.mjs';
 export { default as AdversarySettings } from './adversary-settings.mjs';
-export { default as NPCSettings } from './npc-settings.mjs';
 export { default as CompanionSettings } from './companion-settings.mjs';
 export { default as SettingFeatureConfig } from './setting-feature-config.mjs';
 export { default as EnvironmentSettings } from './environment-settings.mjs';

module/applications/sheets-configs/action-base-config.mjs

@@ -204,7 +204,7 @@ export default class DHActionBaseConfig extends DaggerheartSheet(ApplicationV2)
             };
         }
 
-        if (this.action.parent.metadata?.isInventoryItem) {
+        if (this.action.parent.metadata?.isQuantifiable) {
             options.quantity = {
                 label: 'DAGGERHEART.GENERAL.itemQuantity',
                 group: 'Global'

module/applications/sheets-configs/activeEffectConfig.mjs

@@ -41,7 +41,7 @@ export default class DhActiveEffectConfig extends foundry.applications.sheets.Ac
      * @returns {ChangeChoice { value: string, label: string, hint: string, group: string }[]}
      */
     static getChangeChoices() {
-        const ignoredActorKeys = ['config', 'DhEnvironment', 'DhParty', 'DhNPC'];
+        const ignoredActorKeys = ['config', 'DhEnvironment', 'DhParty'];
 
         const getAllLeaves = (root, group, parentPath = '') => {
             const leaves = [];
@@ -175,7 +175,6 @@ export default class DhActiveEffectConfig extends foundry.applications.sheets.Ac
         const partContext = await super._preparePartContext(partId, context);
         switch (partId) {
             case 'details':
-                partContext.isItemEffect = partContext.isItemEffect || this.options.isSetting;
                 const useGeneric = game.settings.get(
                     CONFIG.DH.id,
                     CONFIG.DH.SETTINGS.gameSettings.appearance

module/applications/sheets-configs/npc-settings.mjs

@@ -1,85 +0,0 @@
-import DHBaseActorSettings from '../sheets/api/actor-setting.mjs';
-
-/**@typedef {import('@client/applications/_types.mjs').ApplicationClickAction} ApplicationClickAction */
-
-export default class DHNPCSettings extends DHBaseActorSettings {
-    /**@inheritdoc */
-    static DEFAULT_OPTIONS = {
-        classes: ['npc-settings'],
-        position: { width: 455, height: 'auto' },
-        actions: {},
-        dragDrop: [
-            { dragSelector: null, dropSelector: '.tab.features' },
-            { dragSelector: '.feature-item', dropSelector: null }
-        ]
-    };
-
-    /**@override */
-    static PARTS = {
-        header: {
-            id: 'header',
-            template: 'systems/daggerheart/templates/sheets-settings/npc-settings/header.hbs'
-        },
-        tabs: { template: 'systems/daggerheart/templates/sheets/global/tabs/tab-navigation.hbs' },
-        details: {
-            id: 'details',
-            template: 'systems/daggerheart/templates/sheets-settings/npc-settings/details.hbs'
-        },
-        features: {
-            id: 'features',
-            template: 'systems/daggerheart/templates/sheets-settings/npc-settings/features.hbs'
-        }
-    };
-
-    /** @override */
-    static TABS = {
-        primary: {
-            tabs: [{ id: 'details' }, { id: 'features' }],
-            initial: 'details',
-            labelPrefix: 'DAGGERHEART.GENERAL.Tabs'
-        }
-    };
-
-    async _prepareContext(options) {
-        const context = await super._prepareContext(options);
-
-        const featureForms = ['passive', 'action', 'reaction'];
-        context.features = context.document.system.features.sort((a, b) =>
-            a.system.featureForm !== b.system.featureForm
-                ? featureForms.indexOf(a.system.featureForm) - featureForms.indexOf(b.system.featureForm)
-                : a.sort - b.sort
-        );
-
-        return context;
-    }
-
-    /* -------------------------------------------- */
-
-    async _onDragStart(event) {
-        const featureItem = event.currentTarget.closest('.feature-item');
-
-        if (featureItem) {
-            const feature = this.actor.items.get(featureItem.id);
-            const featureData = { type: 'Item', uuid: feature.uuid, fromInternal: true };
-            event.dataTransfer.setData('text/plain', JSON.stringify(featureData));
-            event.dataTransfer.setDragImage(featureItem.querySelector('img'), 60, 0);
-        }
-    }
-
-    async _onDrop(event) {
-        event.stopPropagation();
-        const data = foundry.applications.ux.TextEditor.implementation.getDragEventData(event);
-
-        const item = await fromUuid(data.uuid);
-        if (item?.type === 'feature') {
-            if (data.fromInternal && item.parent?.uuid === this.actor.uuid) {
-                return;
-            }
-
-            const itemData = item.toObject();
-            delete itemData._id;
-
-            await this.actor.createEmbeddedDocuments('Item', [itemData]);
-        }
-    }
-}

module/applications/sheets/actors/_module.mjs

@@ -2,5 +2,4 @@ export { default as Adversary } from './adversary.mjs';
 export { default as Character } from './character.mjs';
 export { default as Companion } from './companion.mjs';
 export { default as Environment } from './environment.mjs';
-export { default as NPC } from './npc.mjs';
 export { default as Party } from './party.mjs';

module/applications/sheets/actors/adversary.mjs

@@ -31,16 +31,6 @@ export default class AdversarySheet extends DHBaseActorSheet {
                 dragSelector: '[data-item-id][draggable="true"], [data-item-id] [draggable="true"]',
                 dropSelector: null
             }
-        ],
-        contextMenus: [
-            {
-                handler: DHBaseActorSheet.getBaseAttackContextOptions,
-                selector: '[data-item-uuid][data-type="attack"]',
-                options: {
-                    parentClassHooks: false,
-                    fixed: true
-                }
-            }
         ]
     };
 

module/applications/sheets/actors/character.mjs

@@ -57,22 +57,6 @@ export default class CharacterSheet extends DHBaseActorSheet {
             }
         ],
         contextMenus: [
-            {
-                handler: CharacterSheet.#getCreationMainContextOptions,
-                selector: '.character-details [data-action="editDoc"]',
-                options: {
-                    parentClassHooks: false,
-                    fixed: true
-                }
-            },
-            {
-                handler: DHBaseActorSheet.getBaseAttackContextOptions,
-                selector: '[data-item-uuid][data-type="attack"]',
-                options: {
-                    parentClassHooks: false,
-                    fixed: true
-                }
-            },
             {
                 handler: CharacterSheet.#getDomainCardContextOptions,
                 selector: '[data-item-uuid][data-type="domainCard"]',
@@ -192,9 +176,6 @@ export default class CharacterSheet extends DHBaseActorSheet {
         for (const input of form.querySelectorAll('input:not([type=search]), .editor.prosemirror')) {
             input.disabled = disabled;
         }
-        for (const element of form.querySelectorAll('.input[contenteditable]')) {
-            element.classList.toggle('disabled', disabled);
-        }
     }
 
     /** @inheritDoc */
@@ -338,56 +319,6 @@ export default class CharacterSheet extends DHBaseActorSheet {
     /*  Context Menu                                */
     /* -------------------------------------------- */
 
-    static #getCreationMainContextOptions() {
-        /** Returns true if the item is managed by the level up wizard. Such items shouldn't allow things like manual removal */
-        function isItemWizardManaged(item) {
-            const actor = item?.actor;
-            if (!actor) return false;
-
-            // If levelup automation is off in general or for this character, all items are unmanaged
-            // This is disabled until we have proper granted feature removal, for now this feature is to correct errors
-            // const levelupAuto = game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Automation).levelupAuto;
-            // if (!levelupAuto) return false;
-
-            // Core items aren't part of levelup data. TODO: add some way to flag a specific character as no auto leveling
-            const classPair = actor.system.class;
-            const coreItems = [actor.system.ancestry, actor.system.community, classPair?.value, classPair?.subclass];
-            if (coreItems.includes(item)) return true;
-
-            const levelups = Object.values(actor.system.levelData?.levelups) ?? [];
-            const uuid = item.uuid;
-            const sourceUuid = item._stats.compendiumSource; // on older characters this may be missing
-            return levelups.some(data => {
-                if (item.type === 'subclass') {
-                    const selectedSubclasses = data.selections.map(s => s.secondaryData?.subclass).filter(s => !!s);
-                    return sourceUuid
-                        ? selectedSubclasses.includes(sourceUuid)
-                        : selectedSubclasses.length && item.system.isMulticlass;
-                }
-
-                const matchesCard = data.achievements.domainCards.some(i => i.itemUuid === uuid);
-                const matchesSelection = data.selections.some(s => s.itemUuid === uuid);
-                return matchesCard || matchesSelection;
-            });
-        }
-
-        return [
-            {
-                label: 'CONTROLS.CommonDelete',
-                icon: 'fa-solid fa-trash',
-                visible: target => {
-                    const doc = getDocFromElementSync(target);
-                    return doc?.isOwner && !isItemWizardManaged(doc);
-                },
-                onClick: async (event, target) => {
-                    const doc = await getDocFromElement(target);
-                    if (event.shiftKey) return doc.delete();
-                    else return doc.deleteDialog();
-                }
-            }
-        ];
-    }
-
     /**
      * Get the set of ContextMenu options for DomainCards.
      * @returns {import('@client/applications/ux/context-menu.mjs').ContextMenuEntry[]} - The Array of context options passed to the ContextMenu instance
@@ -404,7 +335,7 @@ export default class CharacterSheet extends DHBaseActorSheet {
                     const doc = getDocFromElementSync(target);
                     return doc?.isOwner && doc.system.inVault;
                 },
-                onClick: async (_, target) => {
+                callback: async target => {
                     const doc = await getDocFromElement(target);
                     const actorLoadout = doc.actor.system.loadoutSlot;
                     if (actorLoadout.available) return doc.update({ 'system.inVault': false });
@@ -418,7 +349,7 @@ export default class CharacterSheet extends DHBaseActorSheet {
                     const doc = getDocFromElementSync(target);
                     return doc?.isOwner && doc.system.inVault;
                 },
-                onClick: async (event, target) => {
+                callback: async (target, event) => {
                     const doc = await getDocFromElement(target);
                     const actorLoadout = doc.actor.system.loadoutSlot;
                     if (!actorLoadout.available) {
@@ -457,7 +388,7 @@ export default class CharacterSheet extends DHBaseActorSheet {
                     const doc = getDocFromElementSync(target);
                     return doc?.isOwner && !doc.system.inVault;
                 },
-                onClick: async (_, target) => (await getDocFromElement(target)).update({ 'system.inVault': true })
+                callback: async target => (await getDocFromElement(target)).update({ 'system.inVault': true })
             }
         ].map(option => ({
             ...option,
@@ -483,7 +414,7 @@ export default class CharacterSheet extends DHBaseActorSheet {
                     const doc = getDocFromElementSync(target);
                     return doc.isOwner && doc && !doc.system.equipped;
                 },
-                onClick: (event, target) => CharacterSheet.#toggleEquipItem.call(this, event, target)
+                callback: (target, event) => CharacterSheet.#toggleEquipItem.call(this, event, target)
             },
             {
                 label: 'unequip',
@@ -492,7 +423,7 @@ export default class CharacterSheet extends DHBaseActorSheet {
                     const doc = getDocFromElementSync(target);
                     return doc.isOwner && doc && doc.system.equipped;
                 },
-                onClick: (event, target) => CharacterSheet.#toggleEquipItem.call(this, event, target)
+                callback: (target, event) => CharacterSheet.#toggleEquipItem.call(this, event, target)
             }
         ].map(option => ({
             ...option,
@@ -787,7 +718,7 @@ export default class CharacterSheet extends DHBaseActorSheet {
                     ? {
                           'system.linkedClass.uuid': {
                               key: 'system.linkedClass.uuid',
-                            value: this.document.system.class.value?._stats.compendiumSource
+                              value: this.document.system.class.value._stats.compendiumSource
                           }
                       }
                     : undefined,
@@ -1053,7 +984,7 @@ export default class CharacterSheet extends DHBaseActorSheet {
         game.tooltip.activate(target, {
             html,
             locked: true,
-            cssClass: 'bordered-tooltip dh-style',
+            cssClass: 'bordered-tooltip',
             direction: 'DOWN'
         });
 
@@ -1149,7 +1080,7 @@ export default class CharacterSheet extends DHBaseActorSheet {
         game.tooltip.activate(target, {
             html,
             locked: true,
-            cssClass: 'bordered-tooltip dh-style',
+            cssClass: 'bordered-tooltip',
             direction: 'DOWN',
             noOffset: true
         });

module/applications/sheets/actors/companion.mjs

@@ -11,17 +11,7 @@ export default class DhCompanionSheet extends DHBaseActorSheet {
             toggleStress: DhCompanionSheet.#toggleStress,
             actionRoll: DhCompanionSheet.#actionRoll,
             levelManagement: DhCompanionSheet.#levelManagement
-        },
-        contextMenus: [
-            {
-                handler: DHBaseActorSheet.getBaseAttackContextOptions,
-                selector: '[data-item-uuid][data-type="attack"]',
-                options: {
-                    parentClassHooks: false,
-                    fixed: true
         }
-            }
-        ]
     };
 
     static PARTS = {

module/applications/sheets/actors/npc.mjs

@@ -1,136 +0,0 @@
-import DHBaseActorSheet from '../api/base-actor.mjs';
-
-export default class NPCSheet extends DHBaseActorSheet {
-    /** @inheritDoc */
-    static DEFAULT_OPTIONS = {
-        classes: ['npc'],
-        position: { width: 660, height: 600 },
-        window: { resizable: true },
-        actions: {},
-        window: {
-            resizable: true,
-            controls: [
-                {
-                    icon: 'fa-solid fa-signature',
-                    label: 'DAGGERHEART.UI.Tooltip.configureAttribution',
-                    action: 'editAttribution'
-                }
-            ]
-        },
-        dragDrop: [
-            {
-                dragSelector: '[data-item-id][draggable="true"], [data-item-id] [draggable="true"]',
-                dropSelector: null
-            }
-        ]
-    };
-
-    static PARTS = {
-        header: { template: 'systems/daggerheart/templates/sheets/actors/npc/header.hbs' },
-        tabs: { template: 'systems/daggerheart/templates/sheets/actors/npc/navigation.hbs' },
-        features: {
-            template: 'systems/daggerheart/templates/sheets/actors/npc/features.hbs',
-            scrollable: ['.feature-section']
-        },
-        notes: {
-            template: 'systems/daggerheart/templates/sheets/actors/npc/notes.hbs'
-        }
-    };
-
-    /** @inheritdoc */
-    static TABS = {
-        primary: {
-            tabs: [{ id: 'notes' }, { id: 'features' }],
-            initial: 'notes',
-            labelPrefix: 'DAGGERHEART.GENERAL.Tabs'
-        }
-    };
-
-    /** @inheritdoc */
-    _prepareTabs(group) {
-        const result = super._prepareTabs(group);
-        if (group === 'primary') {
-            result.features.empty = this.document.system.features.length === 0;
-        }
-        return result;
-    }
-
-    /** @inheritdoc */
-    async _preparePartContext(partId, context, options) {
-        context = await super._preparePartContext(partId, context, options);
-        switch (partId) {
-            case 'header':
-                await this._prepareHeaderContext(context, options);
-                break;
-            case 'features':
-                await this._prepareFeaturesContext(context, options);
-                break;
-            case 'notes':
-                await this._prepareNotesContext(context, options);
-                break;
-        }
-
-        return context;
-    }
-
-    /**
-     * Prepare render context for the Header part.
-     * @param {ApplicationRenderContext} context
-     * @param {ApplicationRenderOptions} options
-     * @returns {Promise<void>}
-     * @protected
-     */
-    async _prepareHeaderContext(context, _options) {
-        const { system } = this.document;
-        const { TextEditor } = foundry.applications.ux;
-
-        context.description = await TextEditor.implementation.enrichHTML(system.description, {
-            secrets: this.document.isOwner,
-            relativeTo: this.document
-        });
-    }
-
-    /**
-     * Prepare render context for the Features part.
-     * @param {ApplicationRenderContext} context
-     * @param {ApplicationRenderOptions} options
-     * @returns {Promise<void>}
-     * @protected
-     */
-    async _prepareFeaturesContext(context, _options) {
-        const featureForms = ['passive', 'action', 'reaction'];
-        context.features = this.document.system.features.sort((a, b) =>
-            a.system.featureForm !== b.system.featureForm
-                ? featureForms.indexOf(a.system.featureForm) - featureForms.indexOf(b.system.featureForm)
-                : a.sort - b.sort
-        );
-    }
-
-    /**
-     * Prepare render context for the Biography part.
-     * @param {ApplicationRenderContext} context
-     * @param {ApplicationRenderOptions} options
-     * @returns {Promise<void>}
-     * @protected
-     */
-    async _prepareNotesContext(context, _options) {
-        const { system } = this.document;
-        const { TextEditor } = foundry.applications.ux;
-
-        const paths = {
-            notes: 'notes'
-        };
-
-        for (const [key, path] of Object.entries(paths)) {
-            const value = foundry.utils.getProperty(system, path);
-            context[key] = {
-                field: system.schema.getField(path),
-                value,
-                enriched: await TextEditor.implementation.enrichHTML(value, {
-                    secrets: this.document.isOwner,
-                    relativeTo: this.document
-                })
-            };
-        }
-    }
-}

module/applications/sheets/actors/party.mjs

@@ -26,6 +26,7 @@ export default class Party extends DHBaseActorSheet {
         actions: {
             openDocument: Party.#openDocument,
             deletePartyMember: Party.#deletePartyMember,
+            deleteItem: Party.#deleteItem,
             toggleHope: Party.#toggleHope,
             toggleHitPoints: Party.#toggleHitPoints,
             toggleStress: Party.#toggleStress,
@@ -43,10 +44,12 @@ export default class Party extends DHBaseActorSheet {
     static PARTS = {
         header: { template: 'systems/daggerheart/templates/sheets/actors/party/header.hbs' },
         tabs: { template: 'systems/daggerheart/templates/sheets/global/tabs/tab-navigation.hbs' },
-        partyMembers: {
+        partyMembers: { template: 'systems/daggerheart/templates/sheets/actors/party/party-members.hbs' },
-            template: 'systems/daggerheart/templates/sheets/actors/party/party-members.hbs',
+        /* NOT YET IMPLEMENTED */
-            scrollable: ['']
+        // projects: {
-        },
+        //     template: 'systems/daggerheart/templates/sheets/actors/party/projects.hbs',
+        //     scrollable: ['']
+        // },
         inventory: {
             template: 'systems/daggerheart/templates/sheets/actors/party/inventory.hbs',
             scrollable: ['.tab.inventory .items-section']
@@ -57,13 +60,19 @@ export default class Party extends DHBaseActorSheet {
     /** @inheritdoc */
     static TABS = {
         primary: {
-            tabs: [{ id: 'partyMembers' }, { id: 'inventory' }, { id: 'notes' }],
+            tabs: [
+                { id: 'partyMembers' },
+                /* NOT YET IMPLEMENTED */
+                // { id: 'projects' },
+                { id: 'inventory' },
+                { id: 'notes' }
+            ],
             initial: 'partyMembers',
             labelPrefix: 'DAGGERHEART.GENERAL.Tabs'
         }
     };
 
-    static ALLOWED_ACTOR_TYPES = ['character', 'companion', 'adversary', 'npc'];
+    static ALLOWED_ACTOR_TYPES = ['character', 'companion', 'adversary'];
     static DICE_ROLL_ACTOR_TYPES = ['character'];
 
     async _onRender(context, options) {
@@ -306,7 +315,7 @@ export default class Party extends DHBaseActorSheet {
 
     static async downtimeMoveQuery({ actorId, downtimeType }) {
         const actor = await foundry.utils.fromUuid(actorId);
-        if (!actor || !actor?.isOwner) return;
+        if (!actor || !actor?.isOwner) reject();
         new game.system.api.applications.dialogs.Downtime(actor, downtimeType === 'shortRest').render({
             force: true
         });
@@ -497,4 +506,23 @@ export default class Party extends DHBaseActorSheet {
         const newMembersList = currentMembers.filter(uuid => uuid !== doc.uuid);
         await this.document.update({ 'system.partyMembers': newMembersList });
     }
+
+    static async #deleteItem(event, target) {
+        const doc = await getDocFromElement(target.closest('.inventory-item'));
+        if (!event.shiftKey) {
+            const confirmed = await foundry.applications.api.DialogV2.confirm({
+                window: {
+                    title: game.i18n.format('DAGGERHEART.APPLICATIONS.DeleteConfirmation.title', {
+                        type: game.i18n.localize('TYPES.Actor.party'),
+                        name: doc.name
+                    })
+                },
+                content: game.i18n.format('DAGGERHEART.APPLICATIONS.DeleteConfirmation.text', { name: doc.name })
+            });
+
+            if (!confirmed) return;
+        }
+
+        this.document.deleteEmbeddedDocuments('Item', [doc.id]);
+    }
 }

module/applications/sheets/api/application-mixin.mjs

@@ -89,7 +89,7 @@ export default function DHApplicationMixin(Base) {
             classes: ['daggerheart', 'sheet', 'dh-style'],
             actions: {
                 triggerContextMenu: DHSheetV2.#triggerContextMenu,
-                createDoc: DHSheetV2.#onCreateDoc,
+                createDoc: DHSheetV2.#createDoc,
                 editDoc: DHSheetV2.#editDoc,
                 deleteDoc: DHSheetV2.#deleteDoc,
                 toChat: DHSheetV2.#toChat,
@@ -97,8 +97,8 @@ export default function DHApplicationMixin(Base) {
                 viewItem: DHSheetV2.#viewItem,
                 toggleEffect: DHSheetV2.#toggleEffect,
                 toggleExtended: DHSheetV2.#toggleExtended,
-                addNewItem: DHSheetV2.#onAddNewItem,
+                addNewItem: DHSheetV2.#addNewItem,
-                browseItem: DHSheetV2.#onBrowseItem,
+                browseItem: DHSheetV2.#browseItem,
                 editAttribution: DHSheetV2.#editAttribution
             },
             contextMenus: [
@@ -424,7 +424,7 @@ export default function DHApplicationMixin(Base) {
                         const target = element.closest('[data-item-uuid]');
                         return !target.dataset.disabled && target.dataset.itemType !== 'beastform';
                     },
-                    onClick: async (_, target) => (await getDocFromElement(target)).update({ disabled: true })
+                    callback: async target => (await getDocFromElement(target)).update({ disabled: true })
                 },
                 {
                     label: 'enableEffect',
@@ -433,7 +433,7 @@ export default function DHApplicationMixin(Base) {
                         const target = element.closest('[data-item-uuid]');
                         return target.dataset.disabled && target.dataset.itemType !== 'beastform';
                     },
-                    onClick: async (_, target) => (await getDocFromElement(target)).update({ disabled: false })
+                    callback: async target => (await getDocFromElement(target)).update({ disabled: false })
                 }
             ].map(option => ({
                 ...option,
@@ -478,9 +478,7 @@ export default function DHApplicationMixin(Base) {
                             (doc?.isOwner && (!doc?.hasOwnProperty('systemPath') || doc?.inCollection))
                         );
                     },
-                    onClick: async (_, target) => {
+                    callback: async target => (await getDocFromElement(target)).sheet.render({ force: true })
-                        return (await getDocFromElement(target)).sheet.render({ force: true });
-                    }
                 }
             ];
 
@@ -495,7 +493,7 @@ export default function DHApplicationMixin(Base) {
                             !foundry.utils.isEmpty(doc?.damage?.parts);
                         return doc?.isOwner && hasDamage;
                     },
-                    onClick: async (event, target) => {
+                    callback: async (target, event) => {
                         const doc = await getDocFromElement(target),
                             action = doc?.system?.attack ?? doc;
                         const config = action.prepareConfig(event);
@@ -515,7 +513,7 @@ export default function DHApplicationMixin(Base) {
                         const doc = getDocFromElementSync(target);
                         return doc?.isOwner && !(doc.type === 'domainCard' && doc.system.inVault);
                     },
-                    onClick: async (event, target) => (await getDocFromElement(target)).use(event)
+                    callback: async (target, event) => (await getDocFromElement(target)).use(event)
                 });
             }
 
@@ -523,7 +521,7 @@ export default function DHApplicationMixin(Base) {
                 options.push({
                     label: 'DAGGERHEART.APPLICATIONS.ContextMenu.sendToChat',
                     icon: 'fa-solid fa-message',
-                    onClick: async (_, target) => (await getDocFromElement(target)).toChat(this.document.uuid)
+                    callback: async target => (await getDocFromElement(target)).toChat(this.document.uuid)
                 });
 
             if (deletable)
@@ -535,7 +533,7 @@ export default function DHApplicationMixin(Base) {
                         const doc = getDocFromElementSync(target);
                         return doc?.isOwner !== false && target.dataset.itemType !== 'beastform';
                     },
-                    onClick: async (event, target) => {
+                    callback: async (target, event) => {
                         const doc = await getDocFromElement(target);
                         if (event.shiftKey) return doc.delete();
                         else return doc.deleteDialog();
@@ -641,7 +639,7 @@ export default function DHApplicationMixin(Base) {
         /*  Application Clicks Actions                  */
         /* -------------------------------------------- */
 
-        static async #onAddNewItem(event, target) {
+        static async #addNewItem(event, target) {
             const createChoice = await foundry.applications.api.DialogV2.wait({
                 classes: ['dh-style', 'two-big-buttons'],
                 buttons: [
@@ -660,11 +658,11 @@ export default function DHApplicationMixin(Base) {
 
             if (!createChoice) return;
 
-            if (createChoice === 'browse') return DHSheetV2.#onBrowseItem.call(this, event, target);
+            if (createChoice === 'browse') return DHSheetV2.#browseItem.call(this, event, target);
-            else return DHSheetV2.#onCreateDoc.call(this, event, target);
+            else return DHSheetV2.#createDoc.call(this, event, target);
         }
 
-        static async #onBrowseItem(_event, target) {
+        static async #browseItem(event, target) {
             const type = target.dataset.compendium ?? target.dataset.type;
 
             const presets = {
@@ -715,7 +713,7 @@ export default function DHApplicationMixin(Base) {
          * Create an embedded document.
          * @type {ApplicationClickAction}
          */
-        static async #onCreateDoc(event, target) {
+        static async #createDoc(event, target) {
             const { documentClass, type, inVault, disabled } = target.dataset;
             const parentIsItem = this.document.documentName === 'Item';
             const featureOnCharacter = this.document.parent?.type === 'character' && type === 'feature';
@@ -727,7 +725,7 @@ export default function DHApplicationMixin(Base) {
                       : null
                   : this.document;
 
-            let systemData = {};
+            let systemData = null;
             if (featureOnCharacter) {
                 systemData = {
                     originItemType: this.document.type,
@@ -740,18 +738,15 @@ export default function DHApplicationMixin(Base) {
 
             const data = {
                 name: cls.defaultName({ type, parent }),
-                type,
+                type
-                system: systemData
             };
-            if (disabled) data.disabled = true;
 
-            if (type === 'domainCard') {
+            if (systemData) data.system = systemData;
-                if (parent?.system.domains?.length) data.system.domain = parent.system.domains[0];
+
-                if (inVault) data.system.inVault = true;
+            if (inVault) data['system.inVault'] = true;
-            } else if (type === 'weapon') {
+            if (disabled) data.disabled = true;
-                // Passing an empty system object to weapon causes validation failure due to attack action initialization
+            if (type === 'domainCard' && parent?.system.domains?.length) {
-                // todo: determine why, fix it at its source, then remove this fallback
+                data.system.domain = parent.system.domains[0];
-                delete data.system;
             }
 
             const doc = await cls.create(data, { parent, renderSheet: !event.shiftKey });

module/applications/sheets/api/base-actor.mjs

@@ -166,15 +166,6 @@ export default class DHBaseActorSheet extends DHApplicationMixin(ActorSheetV2) {
         }
     }
 
-    /** Add support for input content editables */
-    _toggleDisabled(disabled) {
-        super._toggleDisabled(disabled);
-        const form = this.form;
-        for (const element of form.querySelectorAll('.input[contenteditable]')) {
-            element.classList.toggle('disabled', disabled);
-        }
-    }
-
     /* -------------------------------------------- */
     /*  Context Menu                                */
     /* -------------------------------------------- */
@@ -189,43 +180,6 @@ export default class DHBaseActorSheet extends DHApplicationMixin(ActorSheetV2) {
         return this._getContextMenuCommonOptions.call(this, { usable: true, toChat: true });
     }
 
-    /**
-     * Get the set of ContextMenu options for the base attack.
-     * @returns {import('@client/applications/ux/context-menu.mjs').ContextMenuEntry[]} - The Array of context options passed to the ContextMenu instance
-     * @this {CharacterSheet}
-     * @protected
-     */
-    static getBaseAttackContextOptions() {
-        /**@type {import('@client/applications/ux/context-menu.mjs').ContextMenuEntry[]} */
-        return [
-            {
-                label: 'DAGGERHEART.CONFIG.RollTypes.attack.name',
-                icon: 'fa-solid fa-burst',
-                onClick: async (event, target) => (await getDocFromElement(target)).use(event)
-            },
-            {
-                label: 'DAGGERHEART.GENERAL.damage',
-                icon: 'fa-solid fa-explosion',
-                onClick: async (event, target) => {
-                    const doc = await getDocFromElement(target),
-                        action = doc?.system?.attack ?? doc;
-                    const config = action.prepareConfig(event);
-                    config.effects = await game.system.api.data.actions.actionsTypes.base.getEffects(
-                        this.document,
-                        doc
-                    );
-                    config.hasRoll = false;
-                    return action && action.workflow.get('damage').execute(config, null, true);
-                }
-            },
-            {
-                label: 'DAGGERHEART.APPLICATIONS.ContextMenu.sendToChat',
-                icon: 'fa-solid fa-message',
-                onClick: async (_, target) => (await getDocFromElement(target)).toChat(this.document.uuid)
-            }
-        ];
-    }
-
     /* -------------------------------------------- */
     /*  Application Listener Actions                */
     /* -------------------------------------------- */
@@ -377,7 +331,7 @@ export default class DHBaseActorSheet extends DHApplicationMixin(ActorSheetV2) {
                 action: 'update',
                 documentName: 'Item',
                 parent: targetActor,
-                updates: [{ _id: existing.id, 'system.quantity': existing.system.quantity + quantity }]
+                updates: [{ '_id': existing.id, 'system.quantity': existing.system.quantity + quantity }]
             });
         } else {
             const itemsToCreate = [];
@@ -410,7 +364,7 @@ export default class DHBaseActorSheet extends DHApplicationMixin(ActorSheetV2) {
                 action: 'update',
                 documentName: 'Item',
                 parent: originActor,
-                updates: [{ _id: item.id, 'system.quantity': item.system.quantity - quantity }]
+                updates: [{ '_id': item.id, 'system.quantity': item.system.quantity - quantity }]
             });
         }
 

module/applications/sheets/api/base-item.mjs

@@ -126,7 +126,7 @@ export default class DHBaseItemSheet extends DHApplicationMixin(ItemSheetV2) {
         options.push({
             name: 'CONTROLS.CommonDelete',
             icon: '<i class="fa-solid fa-trash"></i>',
-            onClick: async (_, target) => {
+            callback: async target => {
                 const feature = await getDocFromElement(target);
                 if (!feature) return;
                 const confirmed = await foundry.applications.api.DialogV2.confirm({

module/applications/sheets/api/item-attachment-sheet.mjs

@@ -29,6 +29,16 @@ export default function ItemAttachmentSheet(Base) {
             }
         };
 
+        async _preparePartContext(partId, context) {
+            await super._preparePartContext(partId, context);
+
+            if (partId === 'attachments') {
+                context.attachedItems = await prepareAttachmentContext(this.document);
+            }
+
+            return context;
+        }
+
         async _onDrop(event) {
             const data = foundry.applications.ux.TextEditor.implementation.getDragEventData(event);
 

module/applications/ui/chatLog.mjs

@@ -50,7 +50,7 @@ export default class DhpChatLog extends foundry.applications.sidebar.tabs.ChatLo
                 const title =
                     (flavor ?? traitValue)
                         ? game.i18n.format('DAGGERHEART.UI.Chat.dualityRoll.abilityCheckTitle', {
-                            ability: game.i18n.localize(CONFIG.DH.ACTOR.abilities[traitValue].label)
+                              ability: game.i18n.localize(SYSTEM.ACTOR.abilities[traitValue].label)
                           })
                         : game.i18n.localize('DAGGERHEART.GENERAL.duality');
 
@@ -103,19 +103,6 @@ export default class DhpChatLog extends foundry.applications.sidebar.tabs.ChatLo
     _getEntryContextOptions() {
         return [
             ...super._getEntryContextOptions(),
-            {
-                label: 'DAGGERHEART.UI.ChatLog.rerollActionRoll',
-                icon: '<i class="fa-solid fa-dice"></i>',
-                visible: li => {
-                    const message = game.messages.get(li.dataset.messageId);
-                    return message.system.hasRoll && (game.user.isGM || message.isAuthor);
-                },
-                callback: async li => {
-                    const message = game.messages.get(li.dataset.messageId);
-                    const reroll = await message.rolls[0].reroll({ liveRoll: true });
-                    message.update({ rolls: [reroll] });
-                }
-            },
             {
                 label: 'DAGGERHEART.UI.ChatLog.rerollDamage',
                 icon: '<i class="fa-solid fa-dice"></i>',
@@ -126,10 +113,9 @@ export default class DhpChatLog extends foundry.applications.sidebar.tabs.ChatLo
                         : false;
                     return (game.user.isGM || message.isAuthor) && hasRolledDamage;
                 },
-                callback: async li => {
+                callback: li => {
                     const message = game.messages.get(li.dataset.messageId);
-                    const update = await message.system.getRerolledDamage();
+                    new game.system.api.applications.dialogs.RerollDamageDialog(message).render({ force: true });
-                    message.update(update);
                 }
             }
         ];

module/applications/ui/combatTracker.mjs

@@ -56,9 +56,7 @@ export default class DhCombatTracker extends foundry.applications.sidebar.tabs.C
     async _prepareTrackerContext(context, options) {
         await super._prepareTrackerContext(context, options);
 
-        const npcs = context.turns?.filter(x => x.isNPC) ?? [];
+        const adversaries = context.turns?.filter(x => x.isNPC) ?? [];
-        const adversaries = npcs.filter(x => x.disposition !== CONST.TOKEN_DISPOSITIONS.FRIENDLY);
-        const friendlies = npcs.filter(x => x.disposition === CONST.TOKEN_DISPOSITIONS.FRIENDLY);
         const characters = context.turns?.filter(x => !x.isNPC) ?? [];
         const spotlightQueueEnabled = game.settings.get(
             CONFIG.DH.id,
@@ -77,56 +75,25 @@ export default class DhCombatTracker extends foundry.applications.sidebar.tabs.C
         Object.assign(context, {
             actionTokens: game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.variantRules).actionTokens,
             adversaries,
-            friendlies,
             allCharacters: characters,
             characters: characters.filter(x => !spotlightQueueEnabled || x.system.spotlight.requestOrderIndex == 0),
             spotlightRequests
         });
     }
 
-    /**
-     * Open the dialog used to edit the name of the currently viewed Combat encounter.
-     * @this {CombatTracker}
-     * @returns {Promise<void>}
-     */
-    static async #onEditName() {
-        const combat = this.viewed;
-        if (!combat || !game.user.isGM) return null;
-        const field = combat.schema.fields.name;
-        const inputHTML = field.toFormGroup({}, { name: 'name', value: combat.name, autofocus: true }).outerHTML;
-        const formData = await foundry.applications.api.DialogV2.input({
-            window: { icon: 'fa-solid fa-tag', title: 'COMBAT.ACTIONS.EditNameTitle' },
-            position: { width: 480 },
-            content: inputHTML
-        });
-        await combat.update({ name: formData.name || '' });
-    }
-
     _getCombatContextOptions() {
         return [
             {
-                label: 'COMBAT.ACTIONS.EditName',
+                label: 'COMBAT.ClearMovementHistories',
-                icon: 'fa-solid fa-tag',
+                icon: '<i class="fa-solid fa-shoe-prints"></i>',
+                visible: () => game.user.isGM && this.viewed?.combatants.size > 0,
+                callback: () => this.viewed.clearMovementHistories()
+            },
+            {
+                label: 'COMBAT.Delete',
+                icon: '<i class="fa-solid fa-trash"></i>',
                 visible: () => game.user.isGM && !!this.viewed,
-                onClick: () => DhCombatTracker.#onEditName.call(this)
+                callback: () => this.viewed.endCombat()
-            },
-            {
-                label: 'COMBAT.ACTIONS.LinkToScene',
-                icon: '<i class="fa-solid fa-link"></i>',
-                visible: () => game.user.isGM && !this.scene,
-                onClick: () => this.viewed.toggleSceneLink()
-            },
-            {
-                label: 'COMBAT.ACTIONS.UnlinkFromScene',
-                icon: '<i class="fa-solid fa-unlink"></i>',
-                visible: () => game.user.isGM && !!this.scene,
-                onClick: () => this.viewed.toggleSceneLink()
-            },
-            {
-                label: 'COMBAT.End',
-                icon: 'fa-solid fa-xmark',
-                visible: () => game.user.isGM && !!this.viewed,
-                onClick: () => this.viewed.endCombat()
             }
         ];
     }
@@ -162,8 +129,7 @@ export default class DhCombatTracker extends foundry.applications.sidebar.tabs.C
             active: index === combat.turn,
             canPing: combatant.sceneId === canvas.scene?.id && game.user.hasPermission('PING_CANVAS'),
             type: combatant.actor?.system?.type,
-            img: await this._getCombatantThumbnail(combatant),
+            img: await this._getCombatantThumbnail(combatant)
-            disposition: combatant.token?.disposition
         };
 
         turn.css = [turn.active ? 'active' : null, hidden ? 'hide' : null, isDefeated ? 'defeated' : null].filterJoin(

module/applications/ui/countdownEdit.mjs

@@ -148,7 +148,7 @@ export default class CountdownEdit extends HandlebarsApplicationMixin(Applicatio
     }
 
     async gmSetSetting(data) {
-        await game.settings.set(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Countdowns, data);
+        await game.settings.set(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Countdowns, data),
             game.socket.emit(`system.${CONFIG.DH.id}`, {
                 action: socketEvent.Refresh,
                 data: { refreshType: RefreshType.Countdown }

module/applications/ui/countdowns.mjs

@@ -21,19 +21,19 @@ export default class DhCountdowns extends HandlebarsApplicationMixin(Application
     static DEFAULT_OPTIONS = {
         id: 'countdowns',
         tag: 'div',
-        classes: ['daggerheart', 'dh-style', 'countdowns'],
+        classes: ['daggerheart', 'dh-style', 'countdowns', 'faded-ui'],
         window: {
             icon: 'fa-solid fa-clock-rotate-left',
-            frame: false,
+            frame: true,
             title: 'DAGGERHEART.UI.Countdowns.title',
             positioned: false,
             resizable: false,
             minimizable: false
         },
         actions: {
-            toggleViewMode: DhCountdowns.#onToggleViewMode,
+            toggleViewMode: DhCountdowns.#toggleViewMode,
-            editCountdowns: DhCountdowns.#onEditCountdowns,
+            editCountdowns: DhCountdowns.#editCountdowns,
-            loopCountdown: DhCountdowns.#onLoopCountdown,
+            loopCountdown: DhCountdowns.#loopCountdown,
             decreaseCountdown: (_, target) => this.editCountdown(false, target),
             increaseCountdown: (_, target) => this.editCountdown(true, target)
         },
@@ -62,6 +62,20 @@ export default class DhCountdowns extends HandlebarsApplicationMixin(Application
         if (iconOnly) frame.classList.add('icon-only');
         else frame.classList.remove('icon-only');
 
+        const header = frame.querySelector('.window-header');
+        header.querySelector('button[data-action="close"]').remove();
+        header.querySelector('button[data-action="toggleControls"]').remove();
+
+        if (game.user.isGM) {
+            const editTooltip = game.i18n.localize('DAGGERHEART.APPLICATIONS.CountdownEdit.editTitle');
+            const editButton = `<a style="margin-right: 8px;" class="header-control" data-tooltip="${editTooltip}" aria-label="${editTooltip}" data-action="editCountdowns"><i class="fa-solid fa-wrench"></i></a>`;
+            header.insertAdjacentHTML('beforeEnd', editButton);
+        }
+
+        const minimizeTooltip = game.i18n.localize('DAGGERHEART.UI.Countdowns.toggleIconMode');
+        const minimizeButton = `<a class="header-control" data-tooltip="${minimizeTooltip}" aria-label="${minimizeTooltip}" data-action="toggleViewMode"><i class="fa-solid fa-down-left-and-up-right-to-center"></i></a>`;
+        header.insertAdjacentHTML('beforeEnd', minimizeButton);
+
         return frame;
     }
 
@@ -147,7 +161,7 @@ export default class DhCountdowns extends HandlebarsApplicationMixin(Application
         return true;
     }
 
-    static async #onToggleViewMode() {
+    static async #toggleViewMode() {
         const currentMode = game.user.getFlag(CONFIG.DH.id, CONFIG.DH.FLAGS.userFlags.countdownMode);
         const appMode = CONFIG.DH.GENERAL.countdownAppMode;
         const newMode = currentMode === appMode.textIcon ? appMode.iconOnly : appMode.textIcon;
@@ -158,16 +172,15 @@ export default class DhCountdowns extends HandlebarsApplicationMixin(Application
         this.render();
     }
 
-    static async #onEditCountdowns() {
+    static async #editCountdowns() {
         new game.system.api.applications.ui.CountdownEdit().render(true);
     }
 
-    static async #onLoopCountdown(_, target) {
+    static async #loopCountdown(_, target) {
         if (!DhCountdowns.canPerformEdit()) return;
 
         const settings = game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Countdowns);
-        const countdownId = target.closest('[data-countdown]').dataset.countdown;
+        const countdown = settings.countdowns[target.id];
-        const countdown = settings.countdowns[countdownId];
 
         let progressMax = countdown.progress.start;
         let message = null;
@@ -186,7 +199,7 @@ export default class DhCountdowns extends HandlebarsApplicationMixin(Application
 
         await waitForDiceSoNice(message);
         await settings.updateSource({
-            [`countdowns.${countdownId}.progress`]: {
+            [`countdowns.${target.id}.progress`]: {
                 current: newMax,
                 start: newMax
             }
@@ -200,19 +213,18 @@ export default class DhCountdowns extends HandlebarsApplicationMixin(Application
         if (!DhCountdowns.canPerformEdit()) return;
 
         const settings = game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Countdowns);
-        const countdownId = target.closest('[data-countdown]').dataset.countdown;
+        const countdown = settings.countdowns[target.id];
-        const countdown = settings.countdowns[countdownId];
         const newCurrent = increase
             ? Math.min(countdown.progress.current + 1, countdown.progress.start)
             : Math.max(countdown.progress.current - 1, 0);
-        await settings.updateSource({ [`countdowns.${countdownId}.progress.current`]: newCurrent });
+        await settings.updateSource({ [`countdowns.${target.id}.progress.current`]: newCurrent });
         await emitGMUpdate(GMUpdateEvent.UpdateCountdowns, DhCountdowns.gmSetSetting.bind(settings), settings, null, {
             refreshType: RefreshType.Countdown
         });
     }
 
     static async gmSetSetting(data) {
-        await game.settings.set(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Countdowns, data);
+        await game.settings.set(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Countdowns, data),
             game.socket.emit(`system.${CONFIG.DH.id}`, {
                 action: socketEvent.Refresh,
                 data: { refreshType: RefreshType.Countdown }

module/applications/ui/itemBrowser.mjs

@@ -1,4 +1,3 @@
-import { getDocFromElement } from '../../helpers/utils.mjs';
 import { RefreshType, socketEvent } from '../../systemRegistration/socket.mjs';
 
 const { HandlebarsApplicationMixin, ApplicationV2 } = foundry.applications.api;
@@ -48,8 +47,7 @@ export class ItemBrowser extends HandlebarsApplicationMixin(ApplicationV2) {
             expandContent: this.expandContent,
             resetFilters: this.resetFilters,
             sortList: this.sortList,
-            openSettings: this.openSettings,
+            openSettings: this.openSettings
-            viewSheet: this.#onViewSheet
         },
         position: {
             left: 100,
@@ -111,8 +109,8 @@ export class ItemBrowser extends HandlebarsApplicationMixin(ApplicationV2) {
             CONFIG.DH.id,
             CONFIG.DH.FLAGS[`${this.compendiumBrowserTypeKey}`].position
         );
+
         options.position = userPresetPosition ?? ItemBrowser.DEFAULT_OPTIONS.position;
-        delete options.position.zIndex;
 
         if (!userPresetPosition) {
             const width = noFolder === true || lite === true ? 600 : 850;
@@ -308,8 +306,7 @@ export class ItemBrowser extends HandlebarsApplicationMixin(ApplicationV2) {
                 {
                     items: this.items,
                     menu: this.selectedMenu,
-                    formatLabel: this.formatLabel,
+                    formatLabel: this.formatLabel
-                    viewSheet: this.items[0] instanceof Actor
                 }
             );
 
@@ -571,11 +568,6 @@ export class ItemBrowser extends HandlebarsApplicationMixin(ApplicationV2) {
         }
     }
 
-    static async #onViewSheet(_, target) {
-        const document = await getDocFromElement(target);
-        document?.sheet?.render(true);
-    }
-
     _createDragProcess() {
         new foundry.applications.ux.DragDrop.implementation({
             dragSelector: '.item-container',
@@ -614,16 +606,7 @@ export class ItemBrowser extends HandlebarsApplicationMixin(ApplicationV2) {
                 items: {
                     folder: 'equipments',
                     render: {
-                        folders: [
+                        noFolder: true
-                            'equipments',
-                            'ancestries',
-                            'classes',
-                            'subclasses',
-                            'domains',
-                            'communities',
-                            'beastforms'
-                            // excluded: features
-                        ]
                     }
                 },
                 compendium: {}

module/canvas/placeables/token.mjs

@@ -249,6 +249,9 @@ export default class DhTokenPlaceable extends foundry.canvas.placeables.Token {
 
     /** @inheritDoc */
     _drawBar(number, bar, data) {
+        const val = Number(data.value);
+        const pct = Math.clamp(val, 0, data.max) / data.max;
+
         // Determine sizing
         const { width, height } = this.document.getSize();
         const s = canvas.dimensions.uiScale;
@@ -256,19 +259,17 @@ export default class DhTokenPlaceable extends foundry.canvas.placeables.Token {
         const bh = 8 * (this.document.height >= 2 ? 1.5 : 1) * s;
 
         // Determine the color to use
-        const Color = foundry.utils.Color;
+        const fillColor =
-        const fillColor = number === 0 ? Color.fromRGB([1, 0, 0]) : Color.fromString('#0032b1');
+            number === 0 ? foundry.utils.Color.fromRGB([1, 0, 0]) : foundry.utils.Color.fromString('#0032b1');
-        const emptyColor = Color.fromRGB([0, 0, 0]);
 
-        // Draw the bar (accounting floating point numbers from bar animations)
+        // Draw the bar
-        const widthUnit = bw / Math.ceil(data.max);
+        const widthUnit = bw / data.max;
         bar.clear().lineStyle(s, 0x000000, 1.0);
-        const sections = [...Array(Math.ceil(data.max)).keys()];
+        const sections = [...Array(data.max).keys()];
-        for (const mark of sections) {
+        for (let mark of sections) {
             const x = mark * widthUnit;
-            const marked = mark < Math.ceil(data.value);
+            const marked = mark + 1 <= data.value;
-            const remainder = mark === Math.ceil(data.value) - 1 ? data.value % 1 : 0;
+            const color = marked ? fillColor : foundry.utils.Color.fromRGB([0, 0, 0]);
-            const color = !marked ? emptyColor : remainder ? emptyColor.mix(fillColor, remainder) : fillColor;
             if (mark === 0 || mark === sections.length - 1) {
                 bar.beginFill(color, marked ? 1.0 : 0.5).drawRect(x, 0, widthUnit, bh, 2 * s); // Would like drawRoundedRect, but it's very troublsome with the corners. Leaving for now.
             } else {

module/config/itemBrowserConfig.mjs

@@ -70,49 +70,6 @@ export const typeConfig = {
             }
         ]
     },
-    environments: {
-        columns: [
-            {
-                key: 'system.tier',
-                label: 'DAGGERHEART.GENERAL.Tiers.singular'
-            },
-            {
-                key: 'system.type',
-                label: 'DAGGERHEART.GENERAL.type',
-                format: type => {
-                    if (!type) return '-';
-
-                    return CONFIG.DH.ACTOR.environmentTypes[type].label;
-                }
-            }
-        ],
-        filters: [
-            {
-                key: 'system.tier',
-                label: 'DAGGERHEART.GENERAL.Tiers.singular',
-                field: 'system.api.models.actors.DhEnvironment.schema.fields.tier'
-            },
-            {
-                key: 'system.type',
-                label: 'DAGGERHEART.GENERAL.type',
-                field: 'system.api.models.actors.DhEnvironment.schema.fields.type'
-            },
-            {
-                key: 'system.difficulty',
-                name: 'difficulty.min',
-                label: 'DAGGERHEART.UI.ItemBrowser.difficultyMin',
-                field: 'system.api.models.actors.DhEnvironment.schema.fields.difficulty',
-                operator: 'gte'
-            },
-            {
-                key: 'system.difficulty',
-                name: 'difficulty.max',
-                label: 'DAGGERHEART.UI.ItemBrowser.difficultyMax',
-                field: 'system.api.models.actors.DhEnvironment.schema.fields.difficulty',
-                operator: 'lte'
-            }
-        ]
-    },
     items: {
         columns: [
             {
@@ -443,13 +400,11 @@ export const typeConfig = {
                     const list = [];
                     for (const item of items.filter(item => item.system.linkedClass)) {
                         const linkedClass = await foundry.utils.fromUuid(item.system.linkedClass);
-                        if (linkedClass) {
                         list.push({
                             value: linkedClass.uuid,
                             label: linkedClass.name
                         });
                     }
-                    }
 
                     return list.reduce((a, c) => {
                         if (!a.find(i => i.value === c.value)) a.push(c);
@@ -604,8 +559,7 @@ export const compendiumConfig = {
         id: 'environments',
         keys: ['environments'],
         label: 'DAGGERHEART.UI.ItemBrowser.folders.environments',
-        type: ['environment'],
+        type: ['environment']
-        listType: 'environments'
     },
     beastforms: {
         id: 'beastforms',

module/data/action/attackAction.mjs

@@ -75,12 +75,7 @@ export default class DHAttackAction extends DHDamageAction {
         const useAltDamage = this.actor?.effects?.find(x => x.type === 'horde')?.active;
         for (const { value, valueAlt, type } of damage.parts) {
             const usedValue = useAltDamage ? valueAlt : value;
-            const damageString = Roll.replaceFormulaData(usedValue.getFormula(), this.actor?.getRollData() ?? {});
+            const str = Roll.replaceFormulaData(usedValue.getFormula(), this.actor?.getRollData() ?? {});
-            const str = damageString
-                ? damageString
-                : game.i18n.format('DAGGERHEART.GENERAL.missingX', {
-                    x: game.i18n.localize('DAGGERHEART.GENERAL.damage')
-                });
 
             const icons = Array.from(type)
                 .map(t => CONFIG.DH.GENERAL.damageTypes[t]?.icon)

module/data/action/baseAction.mjs

@@ -148,14 +148,10 @@ export default class DHBaseAction extends ActionMixin(foundry.abstract.DataModel
               : null;
     }
 
-    /**
+    /** Returns true if the action is usable */
-     * Returns true if the action is usable.
-     * An action is usable on any actor type. For example, an adversary might have a base attack action.
-     */
     get usable() {
         const actor = this.actor;
-        const pack = actor?.pack ? game.packs.get(actor.pack) : null;
+        return this.isOwner && actor?.type === 'character';
-        return !pack?.locked && this.isOwner;
     }
 
     static getRollType(parent) {
@@ -223,7 +219,7 @@ export default class DHBaseAction extends ActionMixin(foundry.abstract.DataModel
      * @returns {object}
      */
     async use(event, configOptions = {}) {
-        if (!this.actor) throw new Error('An Action can\'t be used outside of an Actor context.');
+        if (!this.actor) throw new Error("An Action can't be used outside of an Actor context.");
 
         let config = this.prepareConfig(event, configOptions);
         if (!config) return;

module/data/action/countdownAction.mjs

@@ -36,7 +36,7 @@ export default class DhCountdownAction extends DHBaseAction {
 
     /** @inheritDoc */
     static migrateData(source) {
-        for (const countdown of Object.values(source.countdown)) {
+        for (const countdown of source.countdown) {
             if (countdown.progress.max) {
                 countdown.progress.startFormula = countdown.progress.max;
                 countdown.progress.start = 1;

module/data/activeEffect/beastformEffect.mjs

@@ -35,7 +35,6 @@ export default class BeastformEffect extends BaseEffect {
     static migrateData(source) {
         if (!source.characterTokenData.tokenSize.height) source.characterTokenData.tokenSize.height = 1;
         if (!source.characterTokenData.tokenSize.width) source.characterTokenData.tokenSize.width = 1;
-        if (!source.characterTokenData.tokenSize.depth) source.characterTokenData.tokenSize.depth = 1;
 
         return super.migrateData(source);
     }
@@ -53,8 +52,7 @@ export default class BeastformEffect extends BaseEffect {
         if (this.parent.parent.type === 'character') {
             const baseUpdate = {
                 height: this.characterTokenData.tokenSize.height,
-                width: this.characterTokenData.tokenSize.width,
+                width: this.characterTokenData.tokenSize.width
-                depth: this.characterTokenData.tokenSize.depth
             };
             const update = {
                 ...baseUpdate,
@@ -90,13 +88,13 @@ export default class BeastformEffect extends BaseEffect {
                     ...baseUpdate,
                     x,
                     y,
-                    texture: {
+                    'texture': {
                         enabled: this.characterTokenData.usesDynamicToken,
                         src: token.flags.daggerheart?.beastformTokenImg ?? this.characterTokenData.tokenImg,
                         scaleX: this.characterTokenData.tokenSize.scale,
                         scaleY: this.characterTokenData.tokenSize.scale
                     },
-                    ring: {
+                    'ring': {
                         subject: {
                             texture:
                                 token.flags.daggerheart?.beastformSubjectTexture ?? this.characterTokenData.tokenRingImg

module/data/actor/_module.mjs

@@ -1,17 +1,15 @@
 import DhCharacter from './character.mjs';
 import DhCompanion from './companion.mjs';
 import DhAdversary from './adversary.mjs';
-import DhNPC from './npc.mjs';
 import DhEnvironment from './environment.mjs';
 import DhParty from './party.mjs';
 
-export { DhCharacter, DhCompanion, DhAdversary, DhNPC, DhEnvironment, DhParty };
+export { DhCharacter, DhCompanion, DhAdversary, DhEnvironment, DhParty };
 
 export const config = {
     character: DhCharacter,
     companion: DhCompanion,
     adversary: DhAdversary,
-    npc: DhNPC,
     environment: DhEnvironment,
     party: DhParty
 };

module/data/actor/adversary.mjs

@@ -3,7 +3,8 @@ import { ActionField } from '../fields/actionField.mjs';
 import { commonActorRules } from './base.mjs';
 import DhCreature from './creature.mjs';
 import { bonusField } from '../fields/actorField.mjs';
-import { getTierAdjustedAdversary } from './tierAdjustment.mjs';
+import { calculateExpectedValue, parseTermsFromSimpleFormula } from '../../helpers/utils.mjs';
+import { adversaryExpectedDamage, adversaryScalingData } from '../../config/actorConfig.mjs';
 
 export default class DhpAdversary extends DhCreature {
     static LOCALIZATION_PREFIXES = ['DAGGERHEART.ACTORS.Adversary'];
@@ -205,6 +206,205 @@ export default class DhpAdversary extends DhCreature {
     /** Returns source data for this actor adjusted to a new tier, which can be used to create a new actor. */
     adjustForTier(tier) {
         const source = this.parent.toObject(true);
-        return getTierAdjustedAdversary(source, tier);
+
+        /** @type {(2 | 3 | 4)[]} */
+        const tiers = new Array(Math.abs(tier - this.tier))
+            .fill(0)
+            .map((_, idx) => idx + Math.min(tier, this.tier) + 1);
+        if (tier < this.tier) tiers.reverse();
+        const typeData = adversaryScalingData[source.system.type] ?? adversaryScalingData[source.system.standard];
+        const tierEntries = tiers.map(t => ({ tier: t, ...typeData[t] }));
+
+        // Apply simple tier changes
+        const scale = tier > this.tier ? 1 : -1;
+        for (const entry of tierEntries) {
+            source.system.difficulty += scale * entry.difficulty;
+            source.system.damageThresholds.major += scale * entry.majorThreshold;
+            source.system.damageThresholds.severe += scale * entry.severeThreshold;
+            source.system.resources.hitPoints.max += scale * entry.hp;
+            source.system.resources.stress.max += scale * entry.stress;
+            source.system.attack.roll.bonus += scale * entry.attack;
+        }
+
+        // Get the mean and standard deviation of expected damage in the previous and new tier
+        // The data we have is for attack scaling, but we reuse this for action scaling later
+        const expectedDamageData = adversaryExpectedDamage[source.system.type] ?? adversaryExpectedDamage.basic;
+        const damageMeta = {
+            currentDamageRange: { tier: source.system.tier, ...expectedDamageData[source.system.tier] },
+            newDamageRange: { tier, ...expectedDamageData[tier] },
+            type: 'attack'
+        };
+
+        // Update damage of base attack
+        try {
+            this.#adjustActionDamage(source.system.attack, damageMeta);
+        } catch (err) {
+            ui.notifications.warn('Failed to convert attack damage of adversary');
+            console.error(err);
+        }
+
+        // Update damage of each item action, making sure to also update the description if possible
+        const damageRegex = /@Damage\[([^\[\]]*)\]({[^}]*})?/g;
+        for (const item of source.items) {
+            // Replace damage inlines with new formulas
+            for (const withDescription of [item.system, ...Object.values(item.system.actions)]) {
+                withDescription.description = withDescription.description.replace(damageRegex, (match, inner) => {
+                    const { value: formula } = parseInlineParams(inner);
+                    if (!formula || !type) return match;
+
+                    try {
+                        const adjusted = this.#calculateAdjustedDamage(formula, { ...damageMeta, type: 'action' });
+                        const newFormula = [
+                            adjusted.diceQuantity ? `${adjusted.diceQuantity}d${adjusted.faces}` : null,
+                            adjusted.bonus
+                        ]
+                            .filter(p => !!p)
+                            .join('+');
+                        return match.replace(formula, newFormula);
+                    } catch {
+                        return match;
+                    }
+                });
+            }
+
+            // Update damage in item actions
+            // Parse damage, and convert all formula matches in the descriptions to the new damage
+            for (const action of Object.values(item.system.actions)) {
+                try {
+                    const result = this.#adjustActionDamage(action, { ...damageMeta, type: 'action' });
+                    if (!result) continue;
+
+                    for (const { previousFormula, formula } of Object.values(result)) {
+                        const oldFormulaRegexp = new RegExp(
+                            previousFormula.replace(' ', '').replace('+', '(?:\\s)?\\+(?:\\s)?')
+                        );
+                        item.system.description = item.system.description.replace(oldFormulaRegexp, formula);
+                        action.description = action.description.replace(oldFormulaRegexp, formula);
+                    }
+                } catch (err) {
+                    ui.notifications.warn(`Failed to convert action damage for item ${item.name}`);
+                    console.error(err);
+                }
+            }
+        }
+
+        // Finally set the tier of the source data, now that everything is complete
+        source.system.tier = tier;
+        return source;
+    }
+
+    /**
+     * Converts a damage object to a new damage range
+     * @returns {{ diceQuantity: number; faces: number; bonus: number }} the adjusted result as a combined term
+     * @throws error if the formula is the wrong type
+     */
+    #calculateAdjustedDamage(formula, { currentDamageRange, newDamageRange, type }) {
+        const terms = parseTermsFromSimpleFormula(formula);
+        const flatTerms = terms.filter(t => t.diceQuantity === 0);
+        const diceTerms = terms.filter(t => t.diceQuantity > 0);
+        if (flatTerms.length > 1 || diceTerms.length > 1) {
+            throw new Error('invalid formula for conversion');
+        }
+        const value = {
+            ...(diceTerms[0] ?? { diceQuantity: 0, faces: 1 }),
+            bonus: flatTerms[0]?.bonus ?? 0
+        };
+        const previousExpected = calculateExpectedValue(value);
+        if (previousExpected === 0) return value; // nothing to do
+
+        const dieSizes = [4, 6, 8, 10, 12, 20];
+        const steps = newDamageRange.tier - currentDamageRange.tier;
+        const increasing = steps > 0;
+        const deviation = (previousExpected - currentDamageRange.mean) / currentDamageRange.deviation;
+        const expected = Math.max(1, newDamageRange.mean + newDamageRange.deviation * deviation);
+
+        // If this was just a flat number, convert to the expected damage and exit
+        if (value.diceQuantity === 0) {
+            value.bonus = Math.round(expected);
+            return value;
+        }
+
+        const getExpectedDie = () => calculateExpectedValue({ diceQuantity: 1, faces: value.faces }) || 1;
+        const getBaseAverage = () => calculateExpectedValue({ ...value, bonus: 0 });
+
+        // Check the number of base overages over the expected die. In the end, if the bonus inflates too much, we add a die
+        const baseOverages = Math.floor(value.bonus / getExpectedDie());
+
+        // Prestep. Change number of dice for attacks, bump up/down for actions
+        // We never bump up to d20, though we might bump down from it
+        if (type === 'attack') {
+            const minimum = increasing ? value.diceQuantity : 0;
+            value.diceQuantity = Math.max(minimum, newDamageRange.tier);
+        } else {
+            const currentIdx = dieSizes.indexOf(value.faces);
+            value.faces = dieSizes[Math.clamp(currentIdx + steps, 0, 4)];
+        }
+
+        value.bonus = Math.round(expected - getBaseAverage());
+
+        // Attempt to handle negative values.
+        // If we can do it with only step downs, do so. Otherwise remove tier dice, and try again
+        if (value.bonus < 0) {
+            let stepsRequired = Math.ceil(Math.abs(value.bonus) / value.diceQuantity);
+            const currentIdx = dieSizes.indexOf(value.faces);
+
+            // If step downs alone don't suffice, change the flat modifier, then calculate steps required again
+            // If this isn't sufficient, the result will be slightly off. This is unlikely to happen
+            if (type !== 'attack' && stepsRequired > currentIdx && value.diceQuantity > 0) {
+                value.diceQuantity -= increasing ? 1 : Math.abs(steps);
+                value.bonus = Math.round(expected - getBaseAverage());
+                if (value.bonus >= 0) return value; // complete
+            }
+
+            stepsRequired = Math.ceil(Math.abs(value.bonus) / value.diceQuantity);
+            value.faces = dieSizes[Math.max(0, currentIdx - stepsRequired)];
+            value.bonus = Math.max(0, Math.round(expected - getBaseAverage()));
+        }
+
+        // If value is really high, we add a number of dice based on the number of overages
+        // This attempts to preserve a similar amount of variance when increasing an action
+        const overagesToRemove = Math.floor(value.bonus / getExpectedDie()) - baseOverages;
+        if (type !== 'attack' && increasing && overagesToRemove > 0) {
+            value.diceQuantity += overagesToRemove;
+            value.bonus = Math.round(expected - getBaseAverage());
+        }
+
+        return value;
+    }
+
+    /**
+     * Updates damage to reflect a specific value.
+     * @throws if damage structure is invalid for conversion
+     * @returns the converted formula and value as a simplified term, or null if it doesn't deal HP damage
+     */
+    #adjustActionDamage(action, damageMeta) {
+        if (!action.damage?.parts.hitPoints) return null;
+
+        const result = {};
+        for (const property of ['value', 'valueAlt']) {
+            const data = action.damage.parts.hitPoints[property];
+            const previousFormula = data.custom.enabled
+                ? data.custom.formula
+                : [data.flatMultiplier ? `${data.flatMultiplier}${data.dice}` : 0, data.bonus ?? 0]
+                      .filter(p => !!p)
+                      .join('+');
+            const value = this.#calculateAdjustedDamage(previousFormula, damageMeta);
+            const formula = [value.diceQuantity ? `${value.diceQuantity}d${value.faces}` : null, value.bonus]
+                .filter(p => !!p)
+                .join('+');
+            if (value.diceQuantity) {
+                data.custom.enabled = false;
+                data.bonus = value.bonus;
+                data.dice = `d${value.faces}`;
+                data.flatMultiplier = value.diceQuantity;
+            } else if (!value.diceQuantity) {
+                data.custom.enabled = true;
+                data.custom.formula = formula;
+            }
+
+            result[property] = { previousFormula, formula, value };
+        }
+
+        return result;
     }
 }

module/data/actor/character.mjs

@@ -520,12 +520,12 @@ export default class DhCharacter extends DhCreature {
 
             if (armorSource.type === 'armor') {
                 armorUpdates[armorSource.parent.id].updates.push({
-                    _id: armorSource.id,
+                    '_id': armorSource.id,
                     'system.armor.current': armorSource.system.armor.current + usedArmorChange
                 });
             } else {
                 effectUpdates[armorSource.parent.id].updates.push({
-                    _id: armorSource.id,
+                    '_id': armorSource.id,
                     'system.changes': armorSource.system.changes.map(change => ({
                         ...change,
                         value:
@@ -577,8 +577,6 @@ export default class DhCharacter extends DhCreature {
             communityFeatures = [],
             classFeatures = [],
             subclassFeatures = [],
-            multiclassFeatures = [],
-            multiclassSubclassFeatures = [],
             companionFeatures = [],
             features = [];
 
@@ -588,9 +586,9 @@ export default class DhCharacter extends DhCreature {
             } else if (item.system.originItemType === CONFIG.DH.ITEM.featureTypes.community.id) {
                 communityFeatures.push(item);
             } else if (item.system.originItemType === CONFIG.DH.ITEM.featureTypes.class.id) {
-                (item.system.multiclassOrigin ? multiclassFeatures : classFeatures).push(item);
+                classFeatures.push(item);
             } else if (item.system.originItemType === CONFIG.DH.ITEM.featureTypes.subclass.id) {
-                (item.system.multiclassOrigin ? multiclassSubclassFeatures : subclassFeatures).push(item);
+                subclassFeatures.push(item);
             } else if (item.system.originItemType === CONFIG.DH.ITEM.featureTypes.companion.id) {
                 companionFeatures.push(item);
             } else if (item.type === 'feature' && !item.system.type) {
@@ -619,24 +617,6 @@ export default class DhCharacter extends DhCreature {
                 type: 'subclass',
                 values: subclassFeatures
             },
-            ...(multiclassFeatures.length
-                ? {
-                    multiclassFeatures: {
-                        title: `${game.i18n.localize('DAGGERHEART.GENERAL.multiclass')} - ${this.multiclass.value?.name}`,
-                        type: 'multiclass',
-                        values: multiclassFeatures
-                    }
-                }
-                : {}),
-            ...(multiclassSubclassFeatures.length
-                ? {
-                    multiclassSubclassFeatures: {
-                        title: `${game.i18n.localize('DAGGERHEART.GENERAL.multiclass')} ${game.i18n.localize('TYPES.Item.subclass')} - ${this.multiclass.subclass?.name}`,
-                        type: 'multiclassSubclass',
-                        values: multiclassSubclassFeatures
-                    }
-                }
-                : {}),
             companionFeatures: {
                 title: game.i18n.localize('DAGGERHEART.ACTORS.Character.companionFeatures'),
                 type: 'companion',
@@ -860,13 +840,12 @@ export default class DhCharacter extends DhCreature {
             const newHopeMax = this.resources.hope.max + diff;
             const newHopeValue = Math.min(newHopeMax, this.resources.hope.value);
             if (newHopeValue != this.resources.hope.value) {
-                changes.system = foundry.utils.mergeObject(changes.system ?? {}, {
+                if (!changes.system.resources.hope) changes.system.resources.hope = { value: 0 };
-                    resources: {
+
-                        hope: {
+                changes.system.resources.hope = {
-                            value: (changes.system?.resources?.hope?.value ?? 0) + newHopeMax
+                    ...changes.system.resources.hope,
-                        }
+                    value: changes.system.resources.hope.value + newHopeValue
-                    }
+                };
-                });
             }
         }
 

module/data/actor/npc.mjs

@@ -1,43 +0,0 @@
-import DHNPCSettings from '../../applications/sheets-configs/npc-settings.mjs';
-import BaseDataActor from './base.mjs';
-
-export default class DhpNPC extends BaseDataActor {
-    static LOCALIZATION_PREFIXES = ['DAGGERHEART.ACTORS.NPC'];
-
-    static get metadata() {
-        return foundry.utils.mergeObject(super.metadata, {
-            label: 'TYPES.Actor.npc',
-            type: 'npc',
-            settingSheet: DHNPCSettings,
-            hasResistances: false,
-            hasAttribution: true
-        });
-    }
-
-    static defineSchema() {
-        const fields = foundry.data.fields;
-        return {
-            ...super.defineSchema(),
-            difficulty: new fields.NumberField({
-                nullable: true,
-                initial: null,
-                integer: true,
-                label: 'DAGGERHEART.GENERAL.difficulty'
-            }),
-            description: new fields.HTMLField({ label: 'DAGGERHEART.GENERAL.description' }),
-            motives: new fields.StringField(),
-            notes: new fields.HTMLField()
-        };
-    }
-
-    /**@inheritdoc */
-    static DEFAULT_ICON = 'systems/daggerheart/assets/icons/documents/actors/drama-masks.svg';
-
-    get features() {
-        return this.parent.items.filter(x => x.type === 'feature');
-    }
-
-    isItemValid(source) {
-        return super.isItemValid(source) || source.type === 'feature';
-    }
-}

module/data/actor/tierAdjustment.mjs

@@ -1,219 +0,0 @@
-import { calculateExpectedValue, parseTermsFromSimpleFormula } from '../../helpers/utils.mjs';
-import { adversaryExpectedDamage, adversaryScalingData } from '../../config/actorConfig.mjs';
-import { parseInlineParams } from '../../enrichers/parser.mjs';
-
-export function getTierAdjustedAdversary(source, tier) {
-    const currentTier = source.tier ?? 1;
-
-    /** @type {(2 | 3 | 4)[]} */
-    const tiers = new Array(Math.abs(tier - currentTier))
-        .fill(0)
-        .map((_, idx) => idx + Math.min(tier, currentTier) + 1);
-    if (tier < currentTier) tiers.reverse();
-    const typeData = adversaryScalingData[source.system.type] ?? adversaryScalingData[source.system.standard];
-    const tierEntries = tiers.map(t => ({ tier: t, ...typeData[t] }));
-
-    // Apply simple tier changes
-    const scale = tier > currentTier ? 1 : -1;
-    for (const entry of tierEntries) {
-        source.system.difficulty += scale * entry.difficulty;
-        source.system.damageThresholds.major += scale * entry.majorThreshold;
-        source.system.damageThresholds.severe += scale * entry.severeThreshold;
-        source.system.resources.hitPoints.max += scale * entry.hp;
-        source.system.resources.stress.max += scale * entry.stress;
-        source.system.attack.roll.bonus += scale * entry.attack;
-    }
-
-    // Get the mean and standard deviation of expected damage in the previous and new tier
-    // The data we have is for attack scaling, but we reuse this for action scaling later
-    const expectedDamageData = adversaryExpectedDamage[source.system.type] ?? adversaryExpectedDamage.basic;
-    const damageMeta = {
-        currentDamageRange: { tier: source.system.tier, ...expectedDamageData[source.system.tier] },
-        newDamageRange: { tier, ...expectedDamageData[tier] }
-    };
-
-    // Store initial attack damage for abilities that have you deal a "standard attack"
-    const initialAttack = {
-        type: source.system.attack.damage?.parts.hitPoints?.type?.toSorted(),
-        value: getDamagePartsFormula(source.system.attack.damage?.parts.hitPoints?.value)
-    };
-
-    // Update damage of base attack.
-    try {
-        const damage = source.system.attack.damage;
-        if (!damage?.parts.hitPoints) throw new Error('Unexpected missing attack in adversary');
-
-        for (const property of ['value', 'valueAlt']) {
-            const data = damage.parts.hitPoints[property];
-            const previousFormula = getDamagePartsFormula(data);
-            const { value, formula } = calculateAdjustedDamage(previousFormula, 'attack', damageMeta);
-            applyAdjustedDamage(data, value, formula);
-        }
-    } catch (err) {
-        ui.notifications.warn('Failed to convert attack damage of adversary');
-        console.error(err);
-    }
-
-    // Update damage of each item action, making sure to also update the description if possible
-    const damageRegex = /@Damage\[([^\[\]]*)\]({[^}]*})?/g;
-    for (const item of source.items) {
-        // Replace damage inlines with new formulas. Keep a record for a specific check later
-        const descriptionFormulas = [];
-        for (const withDescription of [item.system, ...Object.values(item.system.actions)]) {
-            withDescription.description = withDescription.description.replace(damageRegex, (match, inner) => {
-                const { value: formula } = parseInlineParams(inner, { first: 'value' });
-                if (!formula) return match;
-
-                try {
-                    const newFormula = calculateAdjustedDamage(formula, 'action', damageMeta)?.formula;
-                    descriptionFormulas.push(formula);
-                    return match.replace(formula, newFormula);
-                } catch {
-                    return match;
-                }
-            });
-        }
-
-        // Update damage in item actions and convert all formula matches in the descriptions to the new damage
-        for (const action of Object.values(item.system.actions)) {
-            if (!action.damage?.parts.hitPoints) continue;
-            try {
-                // Apply conversions and save a record. If it matches attack damage *and* Its not in the description, use attack conversion instead
-                const result = [];
-                for (const property of ['value', 'valueAlt']) {
-                    const { [property]: data, type: damageType } = action.damage.parts.hitPoints;
-                    const previousFormula = getDamagePartsFormula(data);
-                    const isActuallyAttack =
-                        previousFormula === initialAttack.value &&
-                        foundry.utils.equals(damageType.toSorted(), initialAttack.type) &&
-                        !descriptionFormulas.includes(previousFormula);
-                    const type = isActuallyAttack ? 'attack' : 'action';
-                    const { value, formula } = calculateAdjustedDamage(previousFormula, type, damageMeta);
-                    applyAdjustedDamage(data, value, formula);
-                    result.push({ previousFormula, formula });
-                }
-
-                // Override text in the description with those values
-                for (const { previousFormula, formula } of Object.values(result)) {
-                    const oldFormulaRegexp = new RegExp(
-                        previousFormula.replace(' ', '').replace('+', '(?:\\s)?\\+(?:\\s)?')
-                    );
-                    item.system.description = item.system.description.replace(oldFormulaRegexp, formula);
-                    action.description = action.description.replace(oldFormulaRegexp, formula);
-                }
-            } catch (err) {
-                ui.notifications.warn(`Failed to convert action damage for item ${item.name}`);
-                console.error(err);
-            }
-        }
-    }
-
-    // Finally set the tier of the source data, now that everything is complete
-    source.system.tier = tier;
-    return source;
-}
-
-/**
- * Converts a damage object to a new damage range
- * @returns {{ diceQuantity: number; faces: number; bonus: number }} the adjusted result as a combined term
- * @throws error if the formula is the wrong type
- */
-function calculateAdjustedDamage(formula, type, { currentDamageRange, newDamageRange }) {
-    const terms = parseTermsFromSimpleFormula(formula);
-    const flatTerms = terms.filter(t => t.diceQuantity === 0);
-    const diceTerms = terms.filter(t => t.diceQuantity > 0);
-    if (flatTerms.length > 1 || diceTerms.length > 1) {
-        throw new Error('invalid formula for conversion');
-    }
-    const value = {
-        ...(diceTerms[0] ?? { diceQuantity: 0, faces: 1 }),
-        bonus: flatTerms[0]?.bonus ?? 0
-    };
-    const previousExpected = calculateExpectedValue(value);
-    if (previousExpected === 0) return value; // nothing to do
-
-    const dieSizes = [4, 6, 8, 10, 12, 20];
-    const steps = newDamageRange.tier - currentDamageRange.tier;
-    const increasing = steps > 0;
-    const deviation = (previousExpected - currentDamageRange.mean) / currentDamageRange.deviation;
-    const expected = Math.max(1, newDamageRange.mean + newDamageRange.deviation * deviation);
-
-    // If this was just a flat number, convert to the expected damage and exit
-    if (value.diceQuantity === 0) {
-        value.bonus = Math.round(expected);
-        return value;
-    }
-
-    const getExpectedDie = () => calculateExpectedValue({ diceQuantity: 1, faces: value.faces }) || 1;
-    const getBaseAverage = () => calculateExpectedValue({ ...value, bonus: 0 });
-
-    // Check the number of base overages over the expected die. In the end, if the bonus inflates too much, we add a die
-    const baseOverages = Math.floor(value.bonus / getExpectedDie());
-
-    // Prestep. Change number of dice for attacks, bump up/down for actions
-    // We never bump up to d20, though we might bump down from it
-    if (type === 'attack') {
-        const minimum = increasing ? value.diceQuantity : 0;
-        value.diceQuantity = Math.max(minimum, newDamageRange.tier);
-    } else {
-        const currentIdx = dieSizes.indexOf(value.faces);
-        value.faces = dieSizes[Math.clamp(currentIdx + steps, 0, 4)];
-    }
-
-    value.bonus = Math.round(expected - getBaseAverage());
-
-    // Attempt to handle negative values.
-    // If we can do it with only step downs, do so. Otherwise remove tier dice, and try again
-    if (value.bonus < 0) {
-        let stepsRequired = Math.ceil(Math.abs(value.bonus) / value.diceQuantity);
-        const currentIdx = dieSizes.indexOf(value.faces);
-
-        // If step downs alone don't suffice, change the flat modifier, then calculate steps required again
-        // If this isn't sufficient, the result will be slightly off. This is unlikely to happen
-        if (type !== 'attack' && stepsRequired > currentIdx && value.diceQuantity > 0) {
-            value.diceQuantity -= increasing ? 1 : Math.abs(steps);
-            value.bonus = Math.round(expected - getBaseAverage());
-            if (value.bonus >= 0) return value; // complete
-        }
-
-        stepsRequired = Math.ceil(Math.abs(value.bonus) / value.diceQuantity);
-        value.faces = dieSizes[Math.max(0, currentIdx - stepsRequired)];
-        value.bonus = Math.max(0, Math.round(expected - getBaseAverage()));
-    }
-
-    // If value is really high, we add a number of dice based on the number of overages
-    // This attempts to preserve a similar amount of variance when increasing an action
-    const overagesToRemove = Math.floor(value.bonus / getExpectedDie()) - baseOverages;
-    if (type !== 'attack' && increasing && overagesToRemove > 0) {
-        value.diceQuantity += overagesToRemove;
-        value.bonus = Math.round(expected - getBaseAverage());
-    }
-
-    const newFormula = [value.diceQuantity ? `${value.diceQuantity}d${value.faces}` : null, value.bonus]
-        .filter(p => !!p)
-        .join('+');
-    return { value, formula: newFormula };
-}
-
-function getDamagePartsFormula(data) {
-    return data.custom.enabled
-        ? data.custom.formula
-        : [data.flatMultiplier ? `${data.flatMultiplier}${data.dice}` : 0, data.bonus ?? 0].filter(p => !!p).join('+');
-}
-
-/**
- * Updates damage to reflect a specific value.
- * @throws if damage structure is invalid for conversion
- * @returns the converted formula and value as a simplified term, or null if it doesn't deal HP damage
- */
-function applyAdjustedDamage(diceData, value, formula) {
-    if (value.diceQuantity) {
-        diceData.custom.enabled = false;
-        diceData.bonus = value.bonus;
-        diceData.dice = `d${value.faces}`;
-        diceData.flatMultiplier = value.diceQuantity;
-    } else if (!value.diceQuantity) {
-        diceData.custom.enabled = true;
-        diceData.custom.formula = formula;
-    }
-}

module/data/chat-message/actorRoll.mjs

@@ -1,5 +1,3 @@
-import { triggerChatRollFx } from '../../helpers/utils.mjs';
-
 const fields = foundry.data.fields;
 
 const targetsField = () =>
@@ -132,35 +130,6 @@ export default class DHActorRoll extends foundry.abstract.TypeDataModel {
         });
     }
 
-    /* TODO: Change how damage data is stored somehow to enable better rerolling */
-    async getRerolledDamage() {
-        if (!this.damage) return;
-
-        const rerolls = [];
-        const update = { system: { damage: {} } };
-        for (const partKey in this.damage) {
-            const part = this.damage[partKey];
-            const testRoll = Roll.fromData(part.parts[0].roll);
-            const rerolled = await testRoll.reroll();
-            rerolls.push(rerolled);
-
-            if (!update.system.damage[partKey]) update.system.damage[partKey] = { parts: [part.parts[0]] };
-            const partData = update.system.damage[partKey].parts[0];
-            update.system.damage[partKey].total = rerolled.total;
-            partData.modifierTotal = rerolled.terms.reduce((acc, x) => {
-                if (x.isDeterministic && !x.operator) acc += x.total;
-                return acc;
-            }, 0);
-            partData.dice = rerolled.dice.map(d => ({ ...d.toJSON(), dice: d.denomination }));
-            partData.total = rerolled.total;
-            partData.roll = rerolled.toJSON();
-        }
-
-        await triggerChatRollFx(rerolls);
-
-        return update;
-    }
-
     registerTargetHook() {
         if (!this.parent.isAuthor || !this.hasTarget) return;
         if (this.targetMode && this.parent.targetHook !== null) {

module/data/compendiumBrowserSettings.mjs

@@ -11,14 +11,12 @@ export default class CompendiumBrowserSettings extends foundry.abstract.DataMode
                 })
             ),
             excludedPacks: new fields.TypedObjectField(
-                new fields.TypedObjectField(
                 new fields.SchemaField({
                     excludedDocumentTypes: new fields.ArrayField(
                         new fields.StringField({ required: true, choices: CONST.SYSTEM_SPECIFIC_COMPENDIUM_TYPES })
                     )
                 })
             )
-            )
         };
     }
 
@@ -30,7 +28,7 @@ export default class CompendiumBrowserSettings extends foundry.abstract.DataMode
         const excludedSourceData = this.excludedSources[packageName];
         if (excludedSourceData && excludedSourceData.excludedDocumentTypes.includes(pack.metadata.type)) return true;
 
-        const excludedPackData = this.excludedPacks[packageName]?.[pack.metadata.name];
+        const excludedPackData = this.excludedPacks[item.pack];
         if (excludedPackData && excludedPackData.excludedDocumentTypes.includes(pack.metadata.type)) return true;
 
         return false;

module/data/fields/action/costField.mjs

@@ -103,7 +103,7 @@ export default class CostField extends fields.ArrayField {
     static calcCosts(costs) {
         const resources = CostField.getResources.call(this, costs);
         let filteredCosts = costs;
-        if (this.parent?.isInventoryItem && this.parent.consumeOnUse === false) {
+        if (this.parent?.metadata.isQuantifiable && this.parent.consumeOnUse === false) {
             filteredCosts = filteredCosts.filter(c => c.key !== 'quantity');
         }
 

module/data/fields/action/countdownField.mjs

@@ -87,7 +87,7 @@ export default class CountdownField extends fields.ArrayField {
                     CONFIG.DH.id,
                     CONFIG.DH.SETTINGS.gameSettings.Countdowns,
                     countdownSetting.toObject()
-                );
+                ),
                     game.socket.emit(`system.${CONFIG.DH.id}`, {
                         action: socketEvent.Refresh,
                         data: { refreshType: RefreshType.Countdown }

module/data/fields/action/damageField.mjs

@@ -72,6 +72,9 @@ export default class DamageField extends fields.SchemaField {
         damageConfig.source.message = messageId;
         damageConfig.directDamage = !!damageConfig.source?.message;
 
+        // if(damageConfig.source?.message && game.modules.get('dice-so-nice')?.active)
+        //     await game.dice3d.waitFor3DAnimationByMessageID(damageConfig.source.message);
+
         const damageResult = await CONFIG.Dice.daggerheart.DamageRoll.build(damageConfig);
         if (!damageResult) return false;
         if (damageResult.actionChatMessageHandled) config.actionChatMessageHandled = true;

module/data/fields/action/effectsField.mjs

@@ -1,3 +1,5 @@
+import { emitGMUpdate, GMUpdateEvent } from '../../../systemRegistration/socket.mjs';
+
 const fields = foundry.data.fields;
 
 export default class EffectsField extends fields.ArrayField {
@@ -32,7 +34,8 @@ export default class EffectsField extends fields.ArrayField {
         }
         if (EffectsField.getAutomation() || force) {
             targets ??= (message.system?.targets ?? config.targets).filter(t => !config.hasRoll || t.hit);
-            EffectsField.applyEffects.call(this, targets);
+            await emitGMUpdate(GMUpdateEvent.UpdateEffect, EffectsField.applyEffects.bind(this), targets, this.uuid);
+            // EffectsField.applyEffects.call(this, config.targets.filter(t => !config.hasRoll || t.hit));
         }
     }
 
@@ -56,7 +59,7 @@ export default class EffectsField extends fields.ArrayField {
             if (!token) return;
 
             const messageToken = token.document ?? token;
-            const conditionImmunities = messageToken.actor.system.rules?.conditionImmunities ?? {};
+            const conditionImmunities = messageToken.actor.system.rules.conditionImmunities ?? {};
             messageTargets.push({
                 token: messageToken,
                 conditionImmunities: Object.values(conditionImmunities).some(x => x)

module/data/fields/action/summonField.mjs

@@ -1,4 +1,4 @@
-import { itemAbleRollParse, triggerChatRollFx } from '../../../helpers/utils.mjs';
+import { itemAbleRollParse } from '../../../helpers/utils.mjs';
 import FormulaField from '../formulaField.mjs';
 
 const fields = foundry.data.fields;
@@ -40,7 +40,7 @@ export default class DHSummonField extends fields.ArrayField {
             const roll = new Roll(itemAbleRollParse(summon.count, this.actor, this.item));
             await roll.evaluate();
             const count = roll.total;
-            if (!roll.isDeterministic) rolls.push(roll);
+            if (!roll.isDeterministic && game.modules.get('dice-so-nice')?.active) rolls.push(roll);
 
             const actor = await DHSummonField.getWorldActor(await foundry.utils.fromUuid(summon.actorUUID));
             /* Extending summon data in memory so it's available in actionField.toChat. Think it's harmless, but ugly. Could maybe find a better way. */
@@ -56,7 +56,7 @@ export default class DHSummonField extends fields.ArrayField {
             }
         }
 
-        if (rolls.length) await triggerChatRollFx(rolls);
+        if (rolls.length) await Promise.all(rolls.map(roll => game.dice3d.showForRoll(roll, game.user, true)));
 
         this.actor.sheet?.minimize();
         DHSummonField.handleSummon(summonData, this.actor);

module/data/item/ancestry.mjs

@@ -1,6 +1,6 @@
 import BaseDataItem from './base.mjs';
 import ItemLinkFields from '../../data/fields/itemLinkFields.mjs';
-import { fromUuids, getFeaturesHTMLData } from '../../helpers/utils.mjs';
+import { getFeaturesHTMLData } from '../../helpers/utils.mjs';
 
 export default class DHAncestry extends BaseDataItem {
     /** @inheritDoc */
@@ -45,10 +45,6 @@ export default class DHAncestry extends BaseDataItem {
 
     /**@inheritdoc */
     async getDescriptionData() {
-        // Preload all ancestry features for acquisition from the cache
-        // todo: make feature acquisition async and replace feature helpers for methods
-        await fromUuids(this._source.features.map(f => f.item));
-
         const baseDescription = this.description;
         const features = await getFeaturesHTMLData(this.features);
 

module/data/item/armor.mjs

@@ -141,6 +141,16 @@ export default class DHArmor extends AttachableItem {
         }
     }
 
+    _onUpdate(a, b, c) {
+        super._onUpdate(a, b, c);
+
+        if (this.actor?.type === 'character') {
+            for (const party of this.actor.parties) {
+                party.render();
+            }
+        }
+    }
+
     /** @inheritDoc */
     static migrateDocumentData(source) {
         if (!source.system.armor) {

module/data/item/beastform.mjs

@@ -51,8 +51,7 @@ export default class DHBeastform extends BaseDataItem {
                 }),
                 scale: new fields.NumberField({ nullable: false, min: 0.2, max: 3, step: 0.05, initial: 1 }),
                 height: new fields.NumberField({ integer: true, min: 1, initial: null, nullable: true }),
-                width: new fields.NumberField({ integer: true, min: 1, initial: null, nullable: true }),
+                width: new fields.NumberField({ integer: true, min: 1, initial: null, nullable: true })
-                depth: new fields.NumberField({ integer: true, min: 1, initial: null, nullable: true })
             }),
             mainTrait: new fields.StringField({
                 required: true,
@@ -193,8 +192,7 @@ export default class DHBeastform extends BaseDataItem {
                     tokenSize: {
                         scale: this.parent.parent.prototypeToken.texture.scaleX,
                         height: this.parent.parent.prototypeToken.height,
-                        width: this.parent.parent.prototypeToken.width,
+                        width: this.parent.parent.prototypeToken.width
-                        depth: this.parent.parent.prototypeToken.depth
                     }
                 },
                 advantageOn: this.advantageOn,
@@ -213,12 +211,10 @@ export default class DHBeastform extends BaseDataItem {
                 : null;
         const width = autoTokenSize ?? this.tokenSize.width;
         const height = autoTokenSize ?? this.tokenSize.height;
-        const depth = autoTokenSize ?? this.tokenSize.depth;
 
         const prototypeTokenUpdate = {
             height,
             width,
-            depth,
             texture: {
                 src: this.tokenImg,
                 scaleX: this.tokenSize.scale,

module/data/item/class.mjs

@@ -2,7 +2,7 @@ import BaseDataItem from './base.mjs';
 import ForeignDocumentUUIDField from '../fields/foreignDocumentUUIDField.mjs';
 import ForeignDocumentUUIDArrayField from '../fields/foreignDocumentUUIDArrayField.mjs';
 import ItemLinkFields from '../fields/itemLinkFields.mjs';
-import { addLinkedItemsDiff, fromUuids, getFeaturesHTMLData, updateLinkedItemApps } from '../../helpers/utils.mjs';
+import { addLinkedItemsDiff, getFeaturesHTMLData, updateLinkedItemApps } from '../../helpers/utils.mjs';
 
 export default class DHClass extends BaseDataItem {
     /** @inheritDoc */
@@ -73,16 +73,15 @@ export default class DHClass extends BaseDataItem {
         const uuids = [this.parent.uuid, this.parent._stats?.compendiumSource].filter(u => !!u);
         const subclasses = game.items.filter(x => x.type === 'subclass' && uuids.includes(x.system.linkedClass));
         for (const pack of game.packs) {
-            const packIds = [];
             const indexes = await pack.getIndex({ fields: ['system.linkedClass'] });
             for (const index of indexes) {
                 if (index.type !== 'subclass') continue;
                 if (!uuids.includes(index.system?.linkedClass)) continue;
                 if (subclasses.find(x => x.uuid === index.uuid)) continue;
-                packIds.push(index._id);
-            }
 
-            if (packIds.length > 0) subclasses.push(...(await pack.getDocuments({ _id__in: packIds })));
+                const subclass = await foundry.utils.fromUuid(index.uuid);
+                subclasses.push(subclass);
+            }
         }
 
         return subclasses;
@@ -217,10 +216,6 @@ export default class DHClass extends BaseDataItem {
             classItems.push(contentLink.outerHTML);
         }
 
-        // Preload all class features for acquisition from the cache
-        // todo: make feature acquisition async and replace feature helpers for methods
-        await fromUuids(this._source.features.map(f => f.item));
-
         const hopeFeatures = await getFeaturesHTMLData(this.hopeFeatures);
         const classFeatures = await getFeaturesHTMLData(this.classFeatures);
 

module/data/item/community.mjs

@@ -1,4 +1,4 @@
-import { fromUuids, getFeaturesHTMLData } from '../../helpers/utils.mjs';
+import { getFeaturesHTMLData } from '../../helpers/utils.mjs';
 import ForeignDocumentUUIDArrayField from '../fields/foreignDocumentUUIDArrayField.mjs';
 import BaseDataItem from './base.mjs';
 
@@ -27,10 +27,6 @@ export default class DHCommunity extends BaseDataItem {
 
     /**@inheritdoc */
     async getDescriptionData() {
-        // Preload all community features for acquisition from the cache
-        // todo: make feature acquisition async and replace feature helpers for methods
-        await fromUuids(this._source.features);
-
         const baseDescription = this.description;
         const features = await getFeaturesHTMLData(this.features);
 

module/data/item/subclass.mjs

@@ -1,4 +1,5 @@
-import { fromUuids, getFeaturesHTMLData } from '../../helpers/utils.mjs';
+import { getFeaturesHTMLData } from '../../helpers/utils.mjs';
+import ForeignDocumentUUIDField from '../fields/foreignDocumentUUIDField.mjs';
 import ItemLinkFields from '../fields/itemLinkFields.mjs';
 import BaseDataItem from './base.mjs';
 
@@ -55,31 +56,39 @@ export default class DHSubclass extends BaseDataItem {
         if (allowed === false) return;
 
         if (this.actor?.type === 'character') {
-            const { value: actorClass, subclass: existingSubclass } = this.actor.system.class;
+            const dataUuid = data.uuid ?? data._stats.compendiumSource ?? `Item.${data._id}`;
-            const { value: multiclass, subclass: existingMultisubclass } = this.actor.system.multiclass;
+            if (this.actor.system.class.subclass) {
-            if (!actorClass && !multiclass) {
+                if (this.actor.system.multiclass.subclass) {
-                ui.notifications.warn('DAGGERHEART.UI.Notifications.missingClass', { localize: true });
+                    ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.Notifications.subclassesAlreadyPresent'));
                     return false;
-            }
+                } else {
-            if (existingSubclass && existingMultisubclass) {
+                    const multiclass = this.actor.items.find(x => x.type === 'class' && x.system.isMulticlass);
-                ui.notifications.warn('DAGGERHEART.UI.Notifications.subclassesAlreadyPresent', { localize: true });
+                    if (!multiclass) {
-                return false;
+                        ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.Notifications.missingMulticlass'));
-            }
-            if (existingSubclass && !multiclass) {
-                ui.notifications.warn('DAGGERHEART.UI.Notifications.missingMulticlass', { localize: true });
                         return false;
                     }
 
-            const match = [multiclass, actorClass].find(
+                    if (multiclass.system.subclasses.every(x => x.uuid !== dataUuid)) {
-                c => c && (c._stats.compendiumSource ?? c.uuid) === this.linkedClass
+                        ui.notifications.error(
+                            game.i18n.localize('DAGGERHEART.UI.Notifications.subclassNotInMulticlass')
                         );
-            if (!match) {
-                const key = multiclass ? 'subclassNotInMulticlass' : 'subclassNotInClass';
-                ui.notifications.warn(`DAGGERHEART.UI.Notifications.${key}`, { localize: true });
                         return false;
-            } else if (match.system.isMulticlass) {
+                    }
+
                     await this.updateSource({ isMulticlass: true });
                 }
+            } else {
+                const actorClass = this.actor.items.find(x => x.type === 'class' && !x.system.isMulticlass);
+                if (!actorClass) {
+                    ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.Notifications.missingClass'));
+                    return false;
+                }
+
+                if ((await actorClass.system.fetchSubclasses()).every(x => x.uuid !== dataUuid)) {
+                    ui.notifications.error(game.i18n.localize('DAGGERHEART.UI.Notifications.subclassNotInClass'));
+                    return false;
+                }
+            }
         }
     }
 
@@ -90,11 +99,6 @@ export default class DHSubclass extends BaseDataItem {
         const spellcastTrait = this.spellcastingTrait
             ? game.i18n.localize(CONFIG.DH.ACTOR.abilities[this.spellcastingTrait].label)
             : null;
-
-        // Preload all subclass features for acquisition from the cache
-        // todo: make feature acquisition async and replace feature helpers for methods
-        await fromUuids(this._source.features.map(f => f.item));
-
         const foundationFeatures = await getFeaturesHTMLData(this.foundationFeatures);
         const specializationFeatures = await getFeaturesHTMLData(this.specializationFeatures);
         const masteryFeatures = await getFeaturesHTMLData(this.masteryFeatures);

module/dice/d20Roll.mjs

@@ -1,5 +1,4 @@
 import D20RollDialog from '../applications/dialogs/d20RollDialog.mjs';
-import { triggerChatRollFx } from '../helpers/utils.mjs';
 import DHRoll from './dhRoll.mjs';
 
 export default class D20Roll extends DHRoll {
@@ -225,15 +224,4 @@ export default class D20Roll extends DHRoll {
     resetFormula() {
         return (this._formula = this.constructor.getFormula(this.terms));
     }
-
-    async reroll(options) {
-        const result = await super.reroll(options);
-        if (this instanceof game.system.api.dice.DualityRoll) return result;
-
-        if (options?.liveRoll) {
-            await triggerChatRollFx([result]);
-        }
-
-        return result;
-    }
 }

module/dice/damageRoll.mjs

@@ -1,5 +1,5 @@
 import DamageDialog from '../applications/dialogs/damageDialog.mjs';
-import { parseRallyDice, triggerChatRollFx } from '../helpers/utils.mjs';
+import { parseRallyDice } from '../helpers/utils.mjs';
 import DHRoll from './dhRoll.mjs';
 
 export default class DamageRoll extends DHRoll {
@@ -18,12 +18,7 @@ export default class DamageRoll extends DHRoll {
         if (config.evaluate !== false) for (const roll of config.roll) await roll.roll.evaluate();
 
         roll._evaluated = true;
-
+        const parts = config.roll.map(r => this.postEvaluate(r));
-        const parts = [];
-        for (const roll of config.roll) {
-            parts.push(this.postEvaluate(roll));
-            roll.roll = JSON.stringify(roll.roll.toJSON());
-        }
 
         config.damage = this.unifyDamageRoll(parts);
     }
@@ -43,24 +38,25 @@ export default class DamageRoll extends DHRoll {
         const chatMessage = config.source?.message
             ? ui.chat.collection.get(config.source.message)
             : getDocumentClass('ChatMessage').applyMode({}, config.rollMode ?? 'public');
-
-        const diceRolls = [];
         if (game.modules.get('dice-so-nice')?.active) {
-            config.mute = true;
             const pool = foundry.dice.terms.PoolTerm.fromRolls(
                     Object.values(config.damage).flatMap(r => r.parts.map(p => p.roll))
+                ),
+                diceRoll = Roll.fromTerms([pool]);
+            await game.dice3d.showForRoll(
+                diceRoll,
+                game.user,
+                true,
+                chatMessage.whisper?.length > 0 ? chatMessage.whisper : null,
+                chatMessage.blind
             );
-            diceRolls.push(Roll.fromTerms([pool]));
+            config.mute = true;
         }
-
-        await triggerChatRollFx(diceRolls, {
-            whisper: chatMessage.whisper?.length > 0 ? chatMessage.whisper : null,
-            blind: chatMessage.blind
-        });
         await super.buildPost(roll, config, message);
-
         if (config.source?.message) {
             chatMessage.update({ 'system.damage': config.damage });
+
+            if (!game.modules.get('dice-so-nice')?.active) foundry.audio.AudioHelper.play({ src: CONFIG.sounds.dice });
         }
     }
 
@@ -323,10 +319,9 @@ export default class DamageRoll extends DHRoll {
         const newIndex = parsedDiceTerms[dice].results.length;
         await term.reroll(`/r1=${termResult.result}`);
 
-        const diceRolls = [];
         if (game.modules.get('dice-so-nice')?.active) {
             const newResult = parsedDiceTerms[dice].results[newIndex];
-            diceRolls.push({
+            const diceSoNiceRoll = {
                 _evaluated: true,
                 dice: [
                     new foundry.dice.terms.Die({
@@ -337,10 +332,11 @@ export default class DamageRoll extends DHRoll {
                     })
                 ],
                 options: { appearance: {} }
-            });
+            };
+
+            await game.dice3d.showForRoll(diceSoNiceRoll, game.user, true);
         }
 
-        await triggerChatRollFx(diceRolls);
         await parsedRoll.evaluate();
 
         const results = parsedRoll.dice[dice].results.map(result => ({

module/dice/dhRoll.mjs

@@ -1,5 +1,4 @@
 import D20RollDialog from '../applications/dialogs/d20RollDialog.mjs';
-import { triggerChatRollFx } from '../helpers/utils.mjs';
 
 export default class DHRoll extends Roll {
     baseTerms = [];
@@ -37,7 +36,6 @@ export default class DHRoll extends Roll {
     static async buildConfigure(config = {}, message = {}) {
         config.hooks = [...this.getHooks(), ''];
         config.dialog ??= {};
-        config.damageOptions ??= {};
 
         for (const hook of config.hooks) {
             if (Hooks.call(`${CONFIG.DH.id}.preRoll${hook.capitalize()}`, config, message) === false) return null;
@@ -77,7 +75,9 @@ export default class DHRoll extends Roll {
         }
 
         if (config.skips?.createMessage) {
-            await triggerChatRollFx([roll]);
+            if (game.modules.get('dice-so-nice')?.active) {
+                await game.dice3d.showForRoll(roll, game.user, true);
+            }
         } else if (!config.source?.message) {
             config.message = await this.toMessage(roll, config);
         }
@@ -85,7 +85,6 @@ export default class DHRoll extends Roll {
 
     static postEvaluate(roll, config = {}) {
         return {
-            ...roll.options.roll,
             total: roll.total,
             formula: roll.formula,
             dice: roll.dice.map(d => ({

module/dice/die/dualityDie.mjs

@@ -1,4 +1,4 @@
-import { updateResourcesForDualityReroll } from '../helpers.mjs';
+import { ResourceUpdateMap } from '../../data/action/baseAction.mjs';
 
 export default class DualityDie extends foundry.dice.terms.Die {
     constructor(options) {
@@ -12,6 +12,24 @@ export default class DualityDie extends foundry.dice.terms.Die {
         return roll.withHope ? 1 : roll.withFear ? -1 : 0;
     }
 
+    #updateResources(oldDuality, newDuality, actor) {
+        const { hopeFear } = game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Automation);
+        if (game.user.isGM ? !hopeFear.gm : !hopeFear.players) return;
+
+        const updates = [];
+        const hope = (newDuality >= 0 ? 1 : 0) - (oldDuality >= 0 ? 1 : 0);
+        const stress = (newDuality === 0 ? 1 : 0) - (oldDuality === 0 ? 1 : 0);
+        const fear = (newDuality === -1 ? 1 : 0) - (oldDuality === -1 ? 1 : 0);
+
+        if (hope !== 0) updates.push({ key: 'hope', value: hope, total: -1 * hope, enabled: true });
+        if (stress !== 0) updates.push({ key: 'stress', value: -1 * stress, total: stress, enabled: true });
+        if (fear !== 0) updates.push({ key: 'fear', value: fear, total: -1 * fear, enabled: true });
+
+        const resourceUpdates = new ResourceUpdateMap(actor);
+        resourceUpdates.addResources(updates);
+        resourceUpdates.updateResources();
+    }
+
     async reroll(modifier, options) {
         const oldDuality = this.#getDualityState(options.liveRoll.roll);
         await super.reroll(modifier, options);
@@ -39,7 +57,7 @@ export default class DualityDie extends foundry.dice.terms.Die {
             if (options.liveRoll.isReaction) return;
 
             const newDuality = this.#getDualityState(options.liveRoll.roll);
-            updateResourcesForDualityReroll(oldDuality, newDuality, options.liveRoll.actor);
+            this.#updateResources(oldDuality, newDuality, options.liveRoll.actor);
         }
     }
 

module/dice/dualityRoll.mjs

@@ -1,8 +1,6 @@
 import D20RollDialog from '../applications/dialogs/d20RollDialog.mjs';
 import D20Roll from './d20Roll.mjs';
 import { parseRallyDice, setDiceSoNiceForDualityRoll } from '../helpers/utils.mjs';
-import { getDiceSoNicePresets } from '../config/generalConfig.mjs';
-import { updateResourcesForDualityReroll } from './helpers.mjs';
 
 export default class DualityRoll extends D20Roll {
     _advantageNumber = 1;
@@ -132,34 +130,32 @@ export default class DualityRoll extends D20Roll {
     }
 
     createBaseDice() {
+        if (
+            this.dice[0] instanceof game.system.api.dice.diceTypes.HopeDie &&
+            this.dice[1] instanceof game.system.api.dice.diceTypes.FearDie
+        ) {
             this.terms = [this.terms[0], this.terms[1], this.terms[2]];
+            return;
+        }
 
         this.terms[0] = new game.system.api.dice.diceTypes.HopeDie({
-            faces: this.terms[0]?.faces ?? this.data.rules.dualityRoll?.defaultHopeDice ?? 12
+            faces: this.data.rules.dualityRoll?.defaultHopeDice ?? 12
         });
         this.terms[1] = new foundry.dice.terms.OperatorTerm({ operator: '+' });
         this.terms[2] = new game.system.api.dice.diceTypes.FearDie({
-            faces: this.terms[2]?.faces ?? this.data.rules.dualityRoll?.defaultFearDice ?? 12
+            faces: this.data.rules.dualityRoll?.defaultFearDice ?? 12
         });
     }
 
     applyAdvantage() {
-        const advDieClass = this.hasAdvantage
+        if (this.hasAdvantage || this.hasDisadvantage) {
-            ? game.system.api.dice.diceTypes.AdvantageDie
+            const dieFaces = this.advantageFaces,
-            : this.hasDisadvantage
+                advDie = new foundry.dice.terms.Die({ faces: dieFaces, number: this.advantageNumber });
-                ? game.system.api.dice.diceTypes.DisadvantageDie
-                : null;
-        if (advDieClass) {
-            const advDie = new advDieClass({ faces: this.advantageFaces, number: this.advantageNumber });
-            if (this.terms.length < 4) {
             if (this.advantageNumber > 1) advDie.modifiers = ['kh'];
             this.terms.push(
                 new foundry.dice.terms.OperatorTerm({ operator: this.hasDisadvantage ? '-' : '+' }),
                 advDie
             );
-            } else {
-                this.terms[4] = advDie;
-            }
         }
         if (this.rallyFaces)
             this.terms.push(
@@ -384,40 +380,4 @@ export default class DualityRoll extends D20Roll {
             if (currentCombatant?.actorId == config.data.id) ui.combat.setCombatantSpotlight(currentCombatant.id);
         }
     }
-
-    async reroll(options) {
-        const oldDuality = this.withHope ? 1 : this.withFear ? -1 : 0;
-        const rerolled = DualityRoll.fromData((await super.reroll(options)).toJSON());
-
-        if (options?.liveRoll) {
-            if (game.modules.get('dice-so-nice')?.active) {
-                const diceAppearance = await getDiceSoNicePresets(
-                    rerolled,
-                    rerolled.dHope.denomination,
-                    rerolled.dFear.denomination
-                );
-                rerolled.dHope.options.appearance = diceAppearance.hope.appearance;
-                rerolled.dFear.options.appearance = diceAppearance.fear.appearance;
-                if (rerolled.dAdvantage) rerolled.dAdvantage.options.appearance = diceAppearance.advantage.appearance;
-                if (rerolled.dDisadvantage)
-                    rerolled.dDisadvantage.options.appearance = diceAppearance.disadvantage.appearance;
-
-                await game.dice3d.showForRoll(rerolled, game.user, true);
-            } else {
-                foundry.audio.AudioHelper.play({ src: CONFIG.sounds.dice });
-            }
-
-            if (this.options.actionType === 'reaction') return;
-
-            const newDuality = rerolled.withHope ? 1 : rerolled.withFear ? -1 : 0;
-            const actor = await foundry.utils.fromUuid(this.options.source.actor);
-            updateResourcesForDualityReroll(oldDuality, newDuality, actor);
-        }
-
-        return rerolled;
-    }
-
-    fromJSON(json) {
-        return super.fromJSON(json);
-    }
 }

module/dice/helpers.mjs

@@ -1,19 +0,0 @@
-import { ResourceUpdateMap } from '../data/action/baseAction.mjs';
-
-export function updateResourcesForDualityReroll(oldDuality, newDuality, actor) {
-    const { hopeFear } = game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Automation);
-    if (game.user.isGM ? !hopeFear.gm : !hopeFear.players) return;
-
-    const updates = [];
-    const hope = (newDuality >= 0 ? 1 : 0) - (oldDuality >= 0 ? 1 : 0);
-    const stress = (newDuality === 0 ? 1 : 0) - (oldDuality === 0 ? 1 : 0);
-    const fear = (newDuality === -1 ? 1 : 0) - (oldDuality === -1 ? 1 : 0);
-
-    if (hope !== 0) updates.push({ key: 'hope', value: hope, total: -1 * hope, enabled: true });
-    if (stress !== 0) updates.push({ key: 'stress', value: -1 * stress, total: stress, enabled: true });
-    if (fear !== 0) updates.push({ key: 'fear', value: fear, total: -1 * fear, enabled: true });
-
-    const resourceUpdates = new ResourceUpdateMap(actor);
-    resourceUpdates.addResources(updates);
-    resourceUpdates.updateResources();
-}

module/documents/actor.mjs

@@ -65,11 +65,6 @@ export default class DhpActor extends Actor {
         };
     }
 
-    static createDialog(data, createOptions, options, renderOptions) {
-        options.classes = [options.classes ?? [], 'actor-create'].flat(); // handled in hook
-        return super.createDialog(data, createOptions, options, renderOptions);
-    }
-
     /* -------------------------------------------- */
 
     /** @inheritDoc */
@@ -114,33 +109,13 @@ export default class DhpActor extends Actor {
             });
         }
 
-        if (this.type === 'npc') {
-            Object.assign(update, {
-                prototypeToken: {
-                    disposition: CONST.TOKEN_DISPOSITIONS.FRIENDLY
-                }
-            });
-        }
-
         this.updateSource(update);
     }
 
-    /** Perform a render, debounced in order to prevent overloading repeat render requests */
-    renderDebounced = foundry.utils.debounce(options => {
-        return this.render(options);
-    }, 10);
-
-    _onUpdateDescendantDocuments(parent, collection, documents, changes, options, userId) {
-        super._onUpdateDescendantDocuments(parent, collection, documents, changes, options, userId);
-        for (const party of this.parties) {
-            party.renderDebounced({ parts: ['partyMembers'] });
-        }
-    }
-
     _onUpdate(changes, options, userId) {
         super._onUpdate(changes, options, userId);
         for (const party of this.parties) {
-            party.renderDebounced({ parts: ['partyMembers'] });
+            party.render({ parts: ['partyMembers'] });
         }
     }
 
@@ -159,20 +134,17 @@ export default class DhpActor extends Actor {
     _onDelete(options, userId) {
         super._onDelete(options, userId);
         for (const party of this.parties) {
-            party.renderDebounced({ parts: ['partyMembers'] });
+            party.render({ parts: ['partyMembers'] });
         }
     }
 
     async updateLevel(newLevel) {
         if (!['character', 'companion'].includes(this.type) || newLevel === this.system.levelData.level.changed) return;
 
-        const tiers = Object.values(game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.LevelTiers).tiers);
-        const maxLevel = tiers.reduce((acc, tier) => Math.max(acc, tier.levels.end), 0);
-        const multiclassMinLevel = Math.min(
-            maxLevel,
-            ...tiers.filter(t => t.options.multiclass).map(t => t.levels.start)
-        );
         if (newLevel > this.system.levelData.level.current) {
+            const maxLevel = Object.values(
+                game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.LevelTiers).tiers
+            ).reduce((acc, tier) => Math.max(acc, tier.levels.end), 0);
             if (newLevel > maxLevel) {
                 ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.Notifications.tooHighLevel'));
             }
@@ -247,19 +219,18 @@ export default class DhpActor extends Actor {
                     this.system.multiclass.subclass.update({ 'system.featureState': subclassFeatureState.multiclass });
                 }
 
-                // Remove multiclass if we're removing a multiclass feature or if we're below the multiclass minimum level
+                if (multiclass) {
-                // Multclasses cannot be manually removed on the sheet, so this allows recovering in the case of errors
+                    const multiclassItem = this.items.find(x => x.uuid === multiclass.itemUuid);
-                if (multiclass || newLevel < multiclassMinLevel) {
+                    const multiclassFeatures = this.items.filter(
-                    const multiclassItems = this.items.filter(
+                        x => x.system.originItemType === 'class' && x.system.multiclassOrigin
-                        x =>
+                    );
-                            x.uuid === multiclass?.itemUuid ||
+                    const subclassFeatures = this.items.filter(
-                            x.system.isMulticlass ||
+                        x => x.system.originItemType === 'subclass' && x.system.multiclassOrigin
-                            (['class', 'subclass'].includes(x.system.originItemType) && x.system.multiclassOrigin)
                     );
 
                     this.deleteEmbeddedDocuments(
                         'Item',
-                        multiclassItems.map(x => x.id)
+                        [multiclassItem, ...multiclassFeatures, ...subclassFeatures].map(x => x.id)
                     );
 
                     this.update({
@@ -298,7 +269,6 @@ export default class DhpActor extends Actor {
 
     async levelUp(levelupData) {
         const levelupAuto = game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Automation).levelupAuto;
-        const getStatsWithSource = document => ({ ...(document._stats ?? {}), compendiumSource: document.uuid });
 
         const levelups = {};
         for (var levelKey of Object.keys(levelupData)) {
@@ -411,8 +381,8 @@ export default class DhpActor extends Actor {
                     const embeddedItem = await this.createEmbeddedDocuments('Item', [
                         {
                             ...multiclassData,
-                            uuid: multiclassItem.uuid, // todo: replace with setting an id and using keepId
+                            uuid: multiclassItem.uuid,
-                            _stats: getStatsWithSource(multiclassItem),
+                            _stats: multiclassItem._stats,
                             system: {
                                 ...multiclassData.system,
                                 features: multiclassData.system.features.filter(x => x.type !== 'hope'),
@@ -425,8 +395,8 @@ export default class DhpActor extends Actor {
                     await this.createEmbeddedDocuments('Item', [
                         {
                             ...subclassData,
-                            uuid: subclassItem.uuid, // todo: replace with setting an id and using keepId
+                            uuid: subclassItem.uuid,
-                            _stats: getStatsWithSource(subclassItem),
+                            _stats: subclassItem._stats,
                             system: {
                                 ...subclassData.system,
                                 isMulticlass: true
@@ -446,8 +416,8 @@ export default class DhpActor extends Actor {
                     const embeddedItem = await this.createEmbeddedDocuments('Item', [
                         {
                             ...cardData,
-                            uuid: cardItem.uuid, // todo: replace with setting an id and using keepId
+                            uuid: cardItem.uuid,
-                            _stats: getStatsWithSource(cardItem),
+                            _stats: cardItem._stats,
                             system: {
                                 ...cardData.system,
                                 inVault: true
@@ -468,7 +438,8 @@ export default class DhpActor extends Actor {
                     const embeddedItem = await this.createEmbeddedDocuments('Item', [
                         {
                             ...cardData,
-                            _stats: getStatsWithSource(cardItem),
+                            uuid: cardItem.uuid,
+                            _stats: cardItem._stats,
                             system: {
                                 ...cardData.system,
                                 inVault: true

module/documents/chatMessage.mjs

@@ -183,11 +183,7 @@ export default class DhpChatMessage extends foundry.documents.ChatMessage {
             if (pendingingSaves.length) {
                 const confirm = await foundry.applications.api.DialogV2.confirm({
                     window: { title: game.i18n.localize('DAGGERHEART.APPLICATIONS.PendingReactionsDialog.title') },
-                    content: `
+                    content: `<p>${game.i18n.localize('DAGGERHEART.APPLICATIONS.PendingReactionsDialog.unfinishedRolls')}</p><p>${game.i18n.localize('DAGGERHEART.APPLICATIONS.PendingReactionsDialog.confirmation')}</p><p><i>${game.i18n.localize('DAGGERHEART.APPLICATIONS.PendingReactionsDialog.warning')}</i></p>`
-                        <p>${game.i18n.localize('DAGGERHEART.APPLICATIONS.PendingReactionsDialog.unfinishedRolls')}</p>
-                        <p><i>${game.i18n.localize('DAGGERHEART.APPLICATIONS.PendingReactionsDialog.warning')}</i></p>
-                        <p>${game.i18n.localize('DAGGERHEART.APPLICATIONS.PendingReactionsDialog.confirmation')}</p>
-                    `
                 });
                 if (!confirm) return;
             }
@@ -251,24 +247,8 @@ export default class DhpChatMessage extends foundry.documents.ChatMessage {
         const targets = this.filterPermTargets(this.system.hitTargets),
             config = foundry.utils.deepClone(this.system);
         config.event = event;
-
         if (targets.length === 0)
-            return ui.notifications.info(game.i18n.localize('DAGGERHEART.UI.Notifications.noTargetsSelectedOrPerm'));
+            ui.notifications.info(game.i18n.localize('DAGGERHEART.UI.Notifications.noTargetsSelectedOrPerm'));
-        else if (config.hasSave) {
-            const pendingingSaves = targets.filter(t => t.saved.success === null);
-            if (pendingingSaves.length) {
-                const confirm = await foundry.applications.api.DialogV2.confirm({
-                    window: { title: game.i18n.localize('DAGGERHEART.APPLICATIONS.PendingReactionsDialog.title') },
-                    content: `
-                        <p>${game.i18n.localize('DAGGERHEART.APPLICATIONS.PendingReactionsDialog.unfinishedRolls')}</p>
-                        <p><i>${game.i18n.localize('DAGGERHEART.APPLICATIONS.PendingReactionsDialog.warning')}</i></p>
-                        <p>${game.i18n.localize('DAGGERHEART.APPLICATIONS.PendingReactionsDialog.confirmation')}</p>
-                    `
-                });
-                if (!confirm) return;
-            }
-        }
-
         this.consumeOnSuccess();
         this.system.action?.workflow.get('effects')?.execute(config, targets, true);
     }

module/documents/item.mjs

@@ -73,16 +73,13 @@ export default class DHItem extends foundry.documents.Item {
     /** Returns true if the item can be used */
     get usable() {
         const actor = this.actor;
-        const pack = actor?.pack ? game.packs.get(actor.pack) : null;
+        const actionsList = this.system.actionsList;
-        const hasActions = this.system.actionsList?.size || this.system.actionsList?.length;
+        return this.isOwner && actor?.type === 'character' && (actionsList?.size || actionsList?.length);
-        const isValidType = actor?.type === 'character' || this.type === 'feature';
-        return !pack?.locked && this.isOwner && isValidType && hasActions;
     }
 
     /** @inheritdoc */
     static async createDialog(data = {}, createOptions = {}, options = {}) {
         const { folders, types, template, context = {}, ...dialogOptions } = options;
-        dialogOptions.classes = [options.classes ?? [], 'item-create'].flat(); // handled in hook
 
         if (types?.length === 0) {
             throw new Error('The array of sub-types to restrict to must not be empty.');

module/documents/scene.mjs

@@ -20,7 +20,7 @@ export default class DhScene extends Scene {
         const prototype = tokenDoc.actor?.prototypeToken ?? tokenDoc;
         this.#sizeSyncBatch.set(tokenDoc.id, {
             size: tokenSize,
-            prototypeSize: { width: prototype.width, height: prototype.height, depth: prototype.depth },
+            prototypeSize: { width: prototype.width, height: prototype.height },
             position: { x: tokenDoc.x, y: tokenDoc.y, elevation: tokenDoc.elevation }
         });
         this.#processSyncBatch();
@@ -36,13 +36,11 @@ export default class DhScene extends Scene {
                 const tokenSize = tokenSizes[size];
                 const width = size !== CONFIG.DH.ACTOR.tokenSize.custom.id ? tokenSize : prototypeSize.width;
                 const height = size !== CONFIG.DH.ACTOR.tokenSize.custom.id ? tokenSize : prototypeSize.height;
-                const depth = size !== CONFIG.DH.ACTOR.tokenSize.custom.id ? tokenSize : prototypeSize.depth;
                 const updatedPosition = DHToken.getSnappedPositionInSquareGrid(this.grid, position, width, height);
                 return {
                     _id,
                     width,
                     height,
-                    depth,
                     ...updatedPosition
                 };
             });

module/documents/token.mjs

@@ -66,8 +66,7 @@ export default class DHToken extends CONFIG.Token.documentClass {
                 if (tokenSize && actor.system.size !== CONFIG.DH.ACTOR.tokenSize.custom.id) {
                     document.updateSource({
                         width: tokenSize,
-                        height: tokenSize,
+                        height: tokenSize
-                        depth: tokenSize
                     });
                 }
             }
@@ -91,7 +90,7 @@ export default class DHToken extends CONFIG.Token.documentClass {
             ) {
                 const tokenSizes = game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Homebrew).tokenSizes;
                 const tokenSize = tokenSizes[update.system.size];
-                if (tokenSize !== this.width || tokenSize !== this.height || tokenSize !== this.depth) {
+                if (tokenSize !== this.width || tokenSize !== this.height) {
                     this.parent?.syncTokenDimensions(this, update.system.size);
                 }
             }

module/documents/tokenManager.mjs

@@ -15,7 +15,6 @@ export default class DhTokenManager {
             if (tokenSize && actor.system.size !== CONFIG.DH.ACTOR.tokenSize.custom.id) {
                 tokenData.width = tokenSize;
                 tokenData.height = tokenSize;
-                tokenData.depth = tokenSize;
             }
         }
 

module/documents/tooltipManager.mjs

@@ -3,6 +3,7 @@ import { AdversaryBPPerEncounter, BaseBPPerEncounter } from '../config/encounter
 export default class DhTooltipManager extends foundry.helpers.interaction.TooltipManager {
     #wide = false;
     #bordered = false;
+    #active = false;
 
     async activate(element, options = {}) {
         const { TextEditor } = foundry.applications.ux;
@@ -349,9 +350,7 @@ export default class DhTooltipManager extends foundry.helpers.interaction.Toolti
     async getBattlepointHTML(combatId) {
         const combat = game.combats.get(combatId);
         const adversaries =
-            combat.turns
+            combat.turns?.filter(x => x.actor?.isNPC)?.map(x => ({ ...x.actor, type: x.actor.system.type })) ?? [];
-                ?.filter(x => x.actor?.isNPC && x.token.disposition === CONST.TOKEN_DISPOSITIONS.HOSTILE)
-                ?.map(x => ({ ...x.actor, type: x.actor.system.type })) ?? [];
         const characters = combat.turns?.filter(x => !x.isNPC && x.actor) ?? [];
 
         const nrCharacters = characters.length;

module/enrichers/DamageEnricher.mjs

@@ -1,7 +1,7 @@
 import { parseInlineParams } from './parser.mjs';
 
 export default function DhDamageEnricher(match, _options) {
-    const { value, type, inline } = parseInlineParams(match[1], { first: 'value' });
+    const { value, type, inline } = parseInlineParams(match[1]);
     if (!value || !type) return match[0];
     return getDamageMessage(value, type, inline, match[0]);
 }
@@ -59,7 +59,7 @@ export const renderDamageButton = async event => {
             {
                 formula: value,
                 applyTo: CONFIG.DH.GENERAL.healingTypes.hitPoints.id,
-                damageTypes: type
+                type: type
             }
         ]
     };

module/enrichers/parser.mjs

@@ -8,7 +8,7 @@ export function parseInlineParams(paramString, { first } = {}) {
     const parts = paramString.split('|').map(x => x.trim());
     const params = {};
     for (const [idx, param] of parts.entries()) {
-        if (first && idx === 0 && !param.includes(':')) {
+        if (first && idx === 0) {
             params[first] = param;
         } else {
             const parts = param.split(':');

module/helpers/utils.mjs

@@ -449,9 +449,14 @@ export async function createEmbeddedItemsWithEffects(actor, baseData) {
             effects: data.effects?.map(effect => effect.toObject())
         });
     }
+
     await actor.createEmbeddedDocuments('Item', effectData);
 }
 
+export const slugify = name => {
+    return name.toLowerCase().replaceAll(' ', '-').replaceAll('.', '');
+};
+
 export function shuffleArray(array) {
     let currentIndex = array.length;
     while (currentIndex != 0) {
@@ -864,58 +869,3 @@ export function camelize(str) {
         })
         .replace(/\s+/g, '');
 }
-
-/** Bulk load a list of documents using uuids. Returns the documents in the same order */
-export async function fromUuids(uuids) {
-    // Set up base entries. Each step works on a sublist of these objects
-    const entries = uuids.map(uuid => ({
-        uuid,
-        parsed: foundry.utils.parseUuid(uuid),
-        value: foundry.utils.fromUuidSync(uuid)
-    }));
-
-    // Handle missing uuids for embedded documents first
-    // A value may be index data, so we check if its a document
-    const packEmbeddedEntries = entries.filter(
-        e =>
-            !(e.value instanceof Document) &&
-            e.parsed &&
-            e.parsed.collection instanceof foundry.documents.collections.CompendiumCollection &&
-            e.parsed.embedded.length > 0
-    );
-    await Promise.all(
-        packEmbeddedEntries.map(async e => {
-            e.value = await fromUuid(e.uuid);
-            return true;
-        })
-    );
-
-    // Handle missing top level pack stuff, by batching per pack
-    const missingTopLevel = entries.filter(e => !(e.value instanceof Document) && e.value?.pack);
-    for (const packGroup of Object.values(Object.groupBy(missingTopLevel, e => e.value.pack))) {
-        const pack = game.packs.get(packGroup[0].value.pack);
-        if (!pack) continue;
-
-        const ids = packGroup.map(p => p.parsed?.id).filter(id => !!id);
-        const documents = await pack.getDocuments({ _id__in: ids });
-        for (const p of packGroup) {
-            p.value = documents.find(d => d.id === p.parsed.id) ?? p.value;
-        }
-    }
-
-    return entries.map(e => e.value);
-}
-/**
- * Triggers DiceSoNice rolls or dice roll audio for rolls. Not used for duality rolls.
- * @param { Roll[] } rolls
- * @return { void }
- */
-export async function triggerChatRollFx(rolls, options = { whisper: false, blind: false }) {
-    const { whisper, blind } = options;
-    if (game.modules.get('dice-so-nice')?.active) {
-        const rerollPromises = rolls.map(roll => game.dice3d.showForRoll(roll, game.user, true, whisper, blind));
-        await Promise.allSettled(rerollPromises);
-    } else {
-        foundry.audio.AudioHelper.play({ src: CONFIG.sounds.dice });
-    }
-}

package.json

@@ -4,7 +4,6 @@
     "autocompleter": "^9.3.2",
     "gulp": "^5.0.0",
     "gulp-less": "^5.0.0",
-    "gulp-sourcemaps": "^3.0.0",
     "rollup": "^4.40.0"
   },
   "scripts": {
@@ -24,20 +23,18 @@
     "prepare": "husky"
   },
   "devDependencies": {
-    "@eslint/js": "^10.0.1",
     "@foundryvtt/foundryvtt-cli": "^1.0.2",
     "@rollup/plugin-commonjs": "^25.0.7",
     "@rollup/plugin-node-resolve": "^15.2.3",
-    "@stylistic/eslint-plugin": "^5.10.0",
     "concurrently": "^8.2.2",
     "eslint": "^10.2.1",
+    "eslint-plugin-prettier": "^5.5.5",
     "globals": "^17.5.0",
     "husky": "^9.1.7",
     "lint-staged": "^16.4.0",
     "postcss": "^8.4.32",
-    "rollup-plugin-postcss": "^4.0.2",
+    "prettier": "^3.5.3",
-    "typescript": "^6.0.3",
+    "rollup-plugin-postcss": "^4.0.2"
-    "typescript-eslint": "^8.60.1"
   },
   "lint-staged": {
     "**/*": "eslint --fix"

styles/daggerheart.less

@@ -1,11 +1,19 @@
 @import './less/sheets/index.less';
 @import './less/sheets-settings/index.less';
+
 @import './less/dialog/index.less';
-@import './less/hud/index.less';
+
-@import './less/utils/index.less';
+@import './less//hud/index.less';
+
+@import './less/utils/colors.less';
+@import './less/utils/fonts.less';
+
 @import './less/global/index.less';
+
 @import './less/ui/index.less';
+
 @import './less/ux/index.less';
 
 @import '../build/tagify.css';
 
+@import './less/utils/mixin.less';

styles/less/dialog/actions/index.less

@@ -1 +0,0 @@
-@import "./action-list.less";

styles/less/dialog/attribution/index.less

@@ -1 +0,0 @@
-@import "./sheet.less";

styles/less/dialog/beastform/index.less

@@ -1 +0,0 @@
-@import "./sheet.less";

styles/less/dialog/beastform/sheet.less

@@ -43,7 +43,7 @@
         text-align: center;
         font-size: var(--font-size-16);
         margin: 0 4px;
-        border: 1px solid @color-border;
+        border: 1px solid light-dark(@dark-blue, @golden);
         border-radius: 6px;
         color: light-dark(@dark, @beige);
         background-image: url('../assets/parchments/dh-parchment-dark.png');
@@ -58,7 +58,7 @@
             position: relative;
             display: flex;
             justify-content: center;
-            border: 1px solid @color-border;
+            border: 1px solid light-dark(@dark-blue, @golden);
             border-radius: 6px;
             cursor: pointer;
             width: 120px;
@@ -164,7 +164,7 @@
 
                         .hybrid-data {
                             padding: 0 2px;
-                            border: 1px solid @color-border;
+                            border: 1px solid light-dark(@dark-blue, @golden);
                             border-radius: 6px;
                             color: light-dark(@dark, @beige);
                             background-image: url('../assets/parchments/dh-parchment-dark.png');
@@ -191,7 +191,7 @@
                 flex-direction: column;
                 gap: 4px;
                 padding: 0 4px;
-                border: 1px solid @color-border;
+                border: 1px solid light-dark(@dark-blue, @golden);
                 border-radius: 6px;
                 color: light-dark(@dark, @beige);
                 background-image: url('../assets/parchments/dh-parchment-dark.png');
@@ -226,7 +226,7 @@
                 gap: 4px;
 
                 .trait-card {
-                    border: 1px solid @color-border;
+                    border: 1px solid light-dark(@dark-blue, @golden);
                     border-radius: 6px;
                     padding: 2px;
                     opacity: 0.4;

styles/less/dialog/character-creation/index.less

@@ -1,4 +0,0 @@
-@import "./sheet.less";
-@import "./creation-action-footer.less";
-@import "./selections-container.less";
-@import "./tab-navigation.less";

styles/less/dialog/character-creation/selections-container.less

@@ -79,7 +79,7 @@
                 font-weight: bold;
                 padding: 0 2px;
                 background-image: url(../assets/parchments/dh-parchment-light.png);
-                border: 1px solid @color-border;
+                border: 1px solid light-dark(@dark-blue, @golden);
                 border-radius: 6px;
                 color: light-dark(@beige, @dark);
                 opacity: 0.4;
@@ -114,6 +114,9 @@
 
             .card-preview-container {
                 flex: 1;
+            }
+
+            .card-preview-container {
                 border-color: light-dark(@dark-blue, @golden);
             }
 
@@ -203,7 +206,7 @@
                     height: 16px;
                     width: 110px;
                     min-height: unset;
-                    border: 1px solid @color-border;
+                    border: 1px solid light-dark(@dark-blue, @golden);
                     color: light-dark(@beige, @beige);
                     background-color: light-dark(var(--color-warm-3), var(--color-warm-3));
 
@@ -230,7 +233,7 @@
                 .suggested-trait-container {
                     width: 56px;
                     white-space: nowrap;
-                    border: 1px solid @color-border;
+                    border: 1px solid light-dark(@dark-blue, @golden);
                     border-radius: 6px;
                     color: light-dark(@beige, @dark);
                     background-image: url('../assets/parchments/dh-parchment-light.png');
@@ -345,7 +348,7 @@
                         display: flex;
                         justify-content: center;
                         position: relative;
-                        border: 1px solid @color-border;
+                        border: 1px solid light-dark(@dark-blue, @golden);
                         border-radius: 6px;
 
                         .nav-section-text {
@@ -383,7 +386,7 @@
                             width: 56px;
                             text-align: center;
                             line-height: 1;
-                            border: 1px solid @color-border;
+                            border: 1px solid light-dark(@dark-blue, @golden);
                             border-radius: 6px;
                             color: light-dark(@beige, @dark);
                             background-image: url(../assets/parchments/dh-parchment-light.png);
@@ -447,7 +450,7 @@
                 height: 100%;
 
                 .simple-equipment {
-                    border: 1px solid @color-border;
+                    border: 1px solid light-dark(@dark-blue, @golden);
                     border-radius: 8px;
                     position: relative;
                     display: flex;
@@ -466,7 +469,7 @@
                         top: -8px;
                         font-size: var(--font-size-12);
                         white-space: nowrap;
-                        border: 1px solid @color-border;
+                        border: 1px solid light-dark(@dark-blue, @golden);
                         border-radius: 6px;
                         color: @dark;
                         background-image: url('../assets/parchments/dh-parchment-light.png');

styles/less/dialog/character-creation/tab-navigation.less

@@ -7,7 +7,7 @@
             border-top: 0;
 
             a {
-                color: @color-text-emphatic;
+                color: light-dark(@dark-blue, @golden);
 
                 &[disabled] {
                     opacity: 0.4;

styles/less/dialog/character-reset/index.less

@@ -1 +0,0 @@
-@import './sheet.less';

styles/less/dialog/compendiumBrowserPackDialog/index.less

@@ -1 +0,0 @@
-@import './sheet.less';

styles/less/dialog/compendiumBrowserPackDialog/sheet.less

@@ -67,6 +67,7 @@
 
                             i {
                                 font-size: 18px;
+                                // color: light-dark(@dark-blue, @golden);
                             }
                         }
                     }