Added so that beastforms can set a scale to handle specific images (#1532 )

Fix bottom gap of item settings and make header rows more rhythmic (#1529 )
[Fix] Daggerheart Menu LightMode (#1534 )
2026-01-15 13:11:08 +01:00 · 2026-01-15 09:45:10 +01:00 · 2026-01-14 20:04:00 -05:00 · 2026-01-15 00:53:33 +01:00 · 2026-01-13 22:36:50 +01:00 · 2026-01-13 21:00:24 +01:00
182 changed files with 6344 additions and 647 deletions
--- a/daggerheart.mjs
+++ b/daggerheart.mjs
@ -16,9 +16,10 @@ import {
    settingsRegistration,
    socketRegistration
 } from './module/systemRegistration/_module.mjs';
-import { placeables } from './module/canvas/_module.mjs';
+import { placeables, DhTokenLayer } from './module/canvas/_module.mjs';
 import './node_modules/@yaireo/tagify/dist/tagify.css';
 import TemplateManager from './module/documents/templateManager.mjs';
+import TokenManager from './module/documents/tokenManager.mjs';

 CONFIG.DH = SYSTEM;
 CONFIG.TextEditor.enrichers.push(...enricherConfig);
@ -51,6 +52,8 @@ CONFIG.ChatMessage.template = 'systems/daggerheart/templates/ui/chat/chat-messag

 CONFIG.Canvas.rulerClass = placeables.DhRuler;
 CONFIG.Canvas.layers.templates.layerClass = placeables.DhTemplateLayer;
+CONFIG.Canvas.layers.tokens.layerClass = DhTokenLayer;
+
 CONFIG.MeasuredTemplate.objectClass = placeables.DhMeasuredTemplate;

 CONFIG.Scene.documentClass = documents.DhScene;
@ -62,6 +65,7 @@ CONFIG.Token.rulerClass = placeables.DhTokenRuler;
 CONFIG.Token.hudClass = applications.hud.DHTokenHUD;

 CONFIG.ui.combat = applications.ui.DhCombatTracker;
+CONFIG.ui.nav = applications.ui.DhSceneNavigation;
 CONFIG.ui.chat = applications.ui.DhChatLog;
 CONFIG.ui.effectsDisplay = applications.ui.DhEffectsDisplay;
 CONFIG.ui.hotbar = applications.ui.DhHotbar;
@ -73,6 +77,7 @@ CONFIG.ui.countdowns = applications.ui.DhCountdowns;
 CONFIG.ux.ContextMenu = applications.ux.DHContextMenu;
 CONFIG.ux.TooltipManager = documents.DhTooltipManager;
 CONFIG.ux.TemplateManager = new TemplateManager();
+CONFIG.ux.TokenManager = new TokenManager();

 Hooks.once('init', () => {
    game.system.api = {
@ -84,6 +89,8 @@ Hooks.once('init', () => {
        fields
    };

+    game.system.registeredTriggers = new RegisteredTriggers();
+
    const { DocumentSheetConfig } = foundry.applications.apps;
    DocumentSheetConfig.unregisterSheet(TokenDocument, 'core', foundry.applications.sheets.TokenConfig);
    DocumentSheetConfig.registerSheet(TokenDocument, SYSTEM.id, applications.sheetConfigs.DhTokenConfig, {
@ -302,7 +309,7 @@ Hooks.on('chatMessage', (_, message) => {
            target,
            difficulty,
            title,
-            label: 'test',
+            label: game.i18n.localize('DAGGERHEART.GENERAL.dualityRoll'),
            actionType: null,
            advantage
        });
@ -316,7 +323,7 @@ const updateActorsRangeDependentEffects = async token => {
        CONFIG.DH.SETTINGS.gameSettings.variantRules
    ).rangeMeasurement;

-    for (let effect of token.actor.allApplicableEffects()) {
+    for (let effect of token.actor?.allApplicableEffects() ?? []) {
        if (!effect.system.rangeDependence?.enabled) continue;
        const { target, range, type } = effect.system.rangeDependence;

@ -330,14 +337,14 @@ const updateActorsRangeDependentEffects = async token => {
                break;
            }

-            const distanceBetween = canvas.grid.measurePath([
-                userTarget.document.movement.destination,
-                token.movement.destination
-            ]).distance;
-            const distance = rangeMeasurement[range];
-
+            // Get required distance and special case 5 feet to test adjacency
+            const required = rangeMeasurement[range];
            const reverse = type === CONFIG.DH.GENERAL.rangeInclusion.outsideRange.id;
-            if (reverse ? distanceBetween <= distance : distanceBetween > distance) {
+            const inRange =
+                required === 5
+                    ? userTarget.isAdjacentWith(token.object)
+                    : userTarget.distanceTo(token.object) <= required;
+            if (reverse ? inRange : !inRange) {
                enabledEffect = false;
                break;
            }
@ -351,16 +358,17 @@ const updateAllRangeDependentEffects = async () => {
    const effectsAutomation = game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Automation).effects;
    if (!effectsAutomation.rangeDependent) return;

-    // Only consider tokens on the active scene
-    const tokens = game.scenes.find(x => x.active).tokens;
+    const tokens = canvas.scene?.tokens;
+    if (!tokens) return;
+
    if (game.user.character) {
        // The character updates their character's token. There can be only one token.
        const characterToken = tokens.find(x => x.actor === game.user.character);
        updateActorsRangeDependentEffects(characterToken);
-    } else if (game.user.isGM) {
+    } else if (game.user.isActiveGM) {
        // The GM is responsible for all other tokens.
        const playerCharacters = game.users.players.filter(x => x.active).map(x => x.character);
-        for (let token of tokens.filter(x => !playerCharacters.includes(x.actor))) {
+        for (const token of tokens.filter(x => !playerCharacters.includes(x.actor))) {
            updateActorsRangeDependentEffects(token);
        }
    }
@ -368,13 +376,62 @@ const updateAllRangeDependentEffects = async () => {

 const debouncedRangeEffectCall = foundry.utils.debounce(updateAllRangeDependentEffects, 50);

-Hooks.on('targetToken', async (user, token, targeted) => {
+Hooks.on('targetToken', () => {
    debouncedRangeEffectCall();
 });

-Hooks.on('moveToken', async (movedToken, data) => {
+Hooks.on('refreshToken', (_, options) => {
+    if (options.refreshPosition) {
        debouncedRangeEffectCall();
+    }
 });

 Hooks.on('renderCompendiumDirectory', (app, html) => applications.ui.ItemBrowser.injectSidebarButton(html));
 Hooks.on('renderDocumentDirectory', (app, html) => applications.ui.ItemBrowser.injectSidebarButton(html));
+
+class RegisteredTriggers extends Map {
+    constructor() {
+        super();
+    }
+
+    async registerTriggers(trigger, actor, triggeringActorType, uuid, commands) {
+        const existingTrigger = this.get(trigger);
+        if (!existingTrigger) this.set(trigger, new Map());
+
+        this.get(trigger).set(uuid, { actor, triggeringActorType, commands });
+    }
+
+    async runTrigger(trigger, currentActor, ...args) {
+        const updates = [];
+        const triggerSettings = game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Automation).triggers;
+        if (!triggerSettings.enabled) return updates;
+
+        const dualityTrigger = this.get(trigger);
+        if (dualityTrigger) {
+            for (let { actor, triggeringActorType, commands } of dualityTrigger.values()) {
+                const triggerData = CONFIG.DH.TRIGGER.triggers[trigger];
+                if (triggerData.usesActor && triggeringActorType !== 'any') {
+                    if (triggeringActorType === 'self' && currentActor?.uuid !== actor) continue;
+                    else if (triggeringActorType === 'other' && currentActor?.uuid === actor) continue;
+                }
+
+                for (let command of commands) {
+                    try {
+                        const result = await command(...args);
+                        if (result?.updates?.length) updates.push(...result.updates);
+                    } catch (_) {
+                        const triggerName = game.i18n.localize(triggerData.label);
+                        ui.notifications.error(
+                            game.i18n.format('DAGGERHEART.CONFIG.Triggers.triggerError', {
+                                trigger: triggerName,
+                                actor: currentActor?.name
+                            })
+                        );
+                    }
+                }
+            }
+        }
+
+        return updates;
+    }
+}
--- a/lang/en.json
+++ b/lang/en.json
@ -69,7 +69,11 @@
                },
                "summon": {
                    "name": "Summon",
-                    "tooltip": "Create tokens in the scene."
+                    "tooltip": "Create tokens in the scene.",
+                    "error": "You do not have permission to summon tokens or there is no active scene.",
+                    "invalidDrop": "You can only drop Actor entities to summon.",
+                    "chatMessageTitle": "Test2",
+                    "chatMessageHeaderTitle": "Summoning"
                }
            },
            "Config": {
@ -90,7 +94,9 @@
                    "customFormula": "Custom Formula",
                    "formula": "Formula"
                },
-                "displayInChat": "Display in chat"
+                "displayInChat": "Display in chat",
+                "deleteTriggerTitle": "Delete Trigger",
+                "deleteTriggerContent": "Are you sure you want to delete the {trigger} trigger?"
            },
            "RollField": {
                "diceRolling": {
@ -120,6 +126,9 @@
                },
                "cost": {
                    "stepTooltip": "+{step} per step"
+                },
+                "summon": {
+                    "dropSummonsHere": "Drop Summons Here"
                }
            }
        },
@ -194,6 +203,8 @@
                    "unequip": "Unequip",
                    "useItem": "Use Item"
                },
+                "defaultHopeDice": "Default Hope Dice",
+                "defaultFearDice": "Default Fear Dice",
                "disadvantageSources": {
                    "label": "Disadvantage Sources",
                    "hint": "Add single words or short text as reminders and hints of what a character has disadvantage on."
@ -226,6 +237,7 @@
                    "confirmText": "Would you like to level up your companion {name} by {levelChange} levels at this time? (You can do it manually later)"
                },
                "viewLevelups": "View Levelups",
+                "viewParty": "View Party",
                "InvalidOldCharacterImportTitle": "Old Character Import",
                "InvalidOldCharacterImportText": "Character data exported prior to system version 1.1 will not generate a complete character. Do you wish to continue?",
                "cancelBeastform": "Cancel Beastform"
@ -326,6 +338,7 @@
                "equip": "Equip",
                "sendToChat": "Send To Chat",
                "toLoadout": "Send to Loadout",
+                "recall": "Recall",
                "toVault": "Send to Vault",
                "unequip": "Unequip",
                "useItem": "Use Item"
@ -1142,7 +1155,8 @@
                "any": "Any",
                "friendly": "Friendly",
                "hostile": "Hostile",
-                "self": "Self"
+                "self": "Self",
+                "other": "Other"
            },
            "TemplateTypes": {
                "circle": "Circle",
@ -1216,6 +1230,29 @@
                    }
                }
            },
+            "Triggers": {
+                "postDamageReduction": {
+                    "label": "After Damage Reduction"
+                },
+                "preDamageReduction": {
+                    "label": "Before Damage Reduction"
+                },
+                "dualityRoll": {
+                    "label": "Duality Roll"
+                },
+                "fearRoll": {
+                    "label": "Fear Roll"
+                },
+                "triggerTexts": {
+                    "strangePatternsContentTitle": "Matched {nr} times.",
+                    "strangePatternsContentSubTitle": "Increase hope and stress to a total of {nr}.",
+                    "ferocityContent": "Spend 2 Hope to gain {bonus} bonus Evasion until after the next attack against you?",
+                    "ferocityEffectDescription": "Your evasion is increased by {bonus}. This bonus lasts until after the next attack made against you."
+                },
+                "triggerType": "Trigger Type",
+                "triggeringActorType": "Triggering Actor Type",
+                "triggerError": "{trigger} trigger failed for {actor}. It's probably configured wrong."
+            },
            "WeaponFeature": {
                "barrier": {
                    "name": "Barrier",
@ -1800,7 +1837,9 @@
                            "label": "Long Rest: Bonus Long Rest Moves",
                            "hint": "The number of extra Long Rest Moves the character can take during a Long Rest."
                        }
-                    }
+                    },
+                    "target": "Target",
+                    "targetSelf": "Self"
                },
                "maxLoadout": {
                    "label": "Max Loadout Cards Bonus"
@ -2051,10 +2090,10 @@
                "partyMembers": "Party Members",
                "projects": "Projects",
                "types": "Types",
-                "itemFeatures": "Item Features",
                "questions": "Questions",
                "configuration": "Configuration",
-                "base": "Base"
+                "base": "Base",
+                "triggers": "Triggers"
            },
            "Tiers": {
                "singular": "Tier",
@ -2175,6 +2214,10 @@
            "stress": "Stress",
            "subclasses": "Subclasses",
            "success": "Success",
+            "summon": {
+                "single": "Summon",
+                "plural": "Summons"
+            },
            "take": "Take",
            "Target": {
                "single": "Target",
@ -2241,7 +2284,8 @@
                        "placeholder": "Using character dimensions",
                        "disabledPlaceholder": "Set by character size",
                        "height": { "label": "Height" },
-                        "width": { "label": "Width" }
+                        "width": { "label": "Width" },
+                        "scale": { "label": "Token Scale" }
                    },
                    "evolved": {
                        "maximumTier": { "label": "Maximum Tier" },
@ -2290,6 +2334,9 @@
            "DomainCard": {
                "type": "Type",
                "recallCost": "Recall Cost",
+                "vaultActive": "Active In Vault",
+                "loadoutIgnore": "Ignores Loadout Limits",
+                "domainTouched": "Domain Touched",
                "foundationTitle": "Foundation",
                "specializationTitle": "Specialization",
                "masteryTitle": "Mastery"
@ -2428,6 +2475,12 @@
                            "hint": "Automatically apply effects. Targets must be selected before the action is made and Reaction Roll Automation must be different than Never. Bypass users permissions."
                        }
                    },
+                    "triggers": {
+                        "enabled": {
+                            "label": "Enabled",
+                            "hint": "Advanced automation such as triggering a popup for a wizard's Strange Patterns"
+                        }
+                    },
                    "summaryMessages": {
                        "label": "Summary Messages"
                    }
@ -2437,6 +2490,9 @@
                },
                "roll": {
                    "title": "Actions"
+                },
+                "trigger": {
+                    "title": "Triggers"
                }
            },
            "Homebrew": {
@ -2564,7 +2620,9 @@
                    }
                },
                "disabledText": "Daggerheart Measurements are disabled in System Settings - Variant Rules",
-                "rangeMeasurement": "Range Measurement"
+                "rangeMeasurement": "Range Measurement",
+                "sceneEnvironments": "Scene Environments",
+                "dragEnvironmentHere": "Drag environments here"
            }
        },
        "UI": {
@ -2777,7 +2835,10 @@
                "gmRequired": "This action requires an online GM",
                "gmOnly": "This can only be accessed by the GM",
                "noActorOwnership": "You do not have permissions for this character",
-                "documentIsMissing": "The {documentType} is missing from the world."
+                "documentIsMissing": "The {documentType} is missing from the world.",
+                "tokenActorMissing": "{name} is missing an Actor",
+                "tokenActorsMissing": "[{names}] missing Actors",
+                "domainTouchRequirement": "This domain card requires {nr} {domain} cards in the loadout to be used"
            },
            "Sidebar": {
                "actorDirectory": {
@ -2822,7 +2883,8 @@
                "deleteItem": "Delete Item",
                "immune": "Immune",
                "middleClick": "[Middle Click] Keep tooltip view",
-                "tokenSize": "The token size used on the canvas"
+                "tokenSize": "The token size used on the canvas",
+                "previewTokenHelp": "Left-click to place, right-click to cancel"
            }
        }
    }
--- a/module/applications/dialogs/beastformDialog.mjs
+++ b/module/applications/dialogs/beastformDialog.mjs
@ -278,19 +278,26 @@ export default class BeastformDialog extends HandlebarsApplicationMixin(Applicat
                'close',
                async () => {
                    const selected = app.selected.toObject();
+                    const evolved = app.evolved.form ? app.evolved.form.toObject() : null;
                    const data = await game.system.api.data.items.DHBeastform.getWildcardImage(
                        app.configData.data.parent,
-                        app.selected
+                        evolved ?? app.selected
                    );
                    if (data) {
                        if (!data.selectedImage) selected = null;
                        else {
-                            if (data.usesDynamicToken) selected.system.tokenRingImg = data.selectedImage;
-                            else selected.system.tokenImg = data.selectedImage;
+                            const imageSource = evolved ?? selected;
+                            if (imageSource.usesDynamicToken) imageSource.system.tokenRingImg = data.selectedImage;
+                            else imageSource.system.tokenImg = data.selectedImage;
                        }
                    }

-                    resolve({ selected: selected, evolved: app.evolved, hybrid: app.hybrid, item: featureItem });
+                    resolve({
+                        selected: selected,
+                        evolved: { ...app.evolved, form: evolved },
+                        hybrid: app.hybrid,
+                        item: featureItem
+                    });
                },
                { once: true }
            );
--- a/module/applications/dialogs/d20RollDialog.mjs
+++ b/module/applications/dialogs/d20RollDialog.mjs
@ -10,6 +10,7 @@ export default class D20RollDialog extends HandlebarsApplicationMixin(Applicatio
        this.config = config;
        this.config.experiences = [];
        this.reactionOverride = config.actionType === 'reaction';
+        this.selectedEffects = this.config.bonusEffects;

        if (config.source?.action) {
            this.item = config.data.parent.items.get(config.source.item) ?? config.data.parent;
@ -35,6 +36,7 @@ export default class D20RollDialog extends HandlebarsApplicationMixin(Applicatio
            selectExperience: this.selectExperience,
            toggleReaction: this.toggleReaction,
            toggleTagTeamRoll: this.toggleTagTeamRoll,
+            toggleSelectedEffect: this.toggleSelectedEffect,
            submitRoll: this.submitRoll
        },
        form: {
@ -76,6 +78,9 @@ export default class D20RollDialog extends HandlebarsApplicationMixin(Applicatio
            icon
        }));

+        context.hasSelectedEffects = Boolean(this.selectedEffects && Object.keys(this.selectedEffects).length);
+        context.selectedEffects = this.selectedEffects;
+
        this.config.costs ??= [];
        if (this.config.costs?.length) {
            const updatedCosts = game.system.api.fields.ActionFields.CostField.calcCosts.call(
@ -104,7 +109,7 @@ export default class D20RollDialog extends HandlebarsApplicationMixin(Applicatio
            context.roll = this.roll;
            context.rollType = this.roll?.constructor.name;
            context.rallyDie = this.roll.rallyChoices;
-            const experiences = this.config.data?.system.experiences || {};
+            const experiences = this.config.data?.system?.experiences || {};
            context.experiences = Object.keys(experiences).map(id => ({
                id,
                ...experiences[id]
@ -208,6 +213,11 @@ export default class D20RollDialog extends HandlebarsApplicationMixin(Applicatio
        this.render();
    }

+    static toggleSelectedEffect(_event, button) {
+        this.selectedEffects[button.dataset.key].selected = !this.selectedEffects[button.dataset.key].selected;
+        this.render();
+    }
+
    static async submitRoll() {
        await this.close({ submitted: true });
    }
--- a/module/applications/dialogs/damageDialog.mjs
+++ b/module/applications/dialogs/damageDialog.mjs
@ -6,6 +6,7 @@ export default class DamageDialog extends HandlebarsApplicationMixin(Application

        this.roll = roll;
        this.config = config;
+        this.selectedEffects = this.config.bonusEffects;
    }

    static DEFAULT_OPTIONS = {
@ -20,6 +21,7 @@ export default class DamageDialog extends HandlebarsApplicationMixin(Application
            icon: 'fa-solid fa-dice'
        },
        actions: {
+            toggleSelectedEffect: this.toggleSelectedEffect,
            submitRoll: this.submitRoll
        },
        form: {
@ -57,6 +59,9 @@ export default class DamageDialog extends HandlebarsApplicationMixin(Application
            icon
        }));
        context.modifiers = this.config.modifiers;
+        context.hasSelectedEffects = Boolean(Object.keys(this.selectedEffects).length);
+        context.selectedEffects = this.selectedEffects;
+
        return context;
    }

@ -69,6 +74,11 @@ export default class DamageDialog extends HandlebarsApplicationMixin(Application
        this.render();
    }

+    static toggleSelectedEffect(_event, button) {
+        this.selectedEffects[button.dataset.key].selected = !this.selectedEffects[button.dataset.key].selected;
+        this.render();
+    }
+
    static async submitRoll() {
        await this.close({ submitted: true });
    }
--- a/module/applications/dialogs/downtime.mjs
+++ b/module/applications/dialogs/downtime.mjs
@ -93,7 +93,9 @@ export default class DhpDowntime extends HandlebarsApplicationMixin(ApplicationV
    }

    getRefreshables() {
-        const actionItems = this.actor.items.filter(x => this.actor.system.isItemAvailable(x)).reduce((acc, x) => {
+        const actionItems = this.actor.items
+            .filter(x => this.actor.system.isItemAvailable(x))
+            .reduce((acc, x) => {
                if (x.system.actions) {
                    const recoverable = x.system.actions.reduce((acc, action) => {
                        if (refreshIsAllowed([this.shortrest ? 'shortRest' : 'longRest'], action.uses.recovery)) {
@ -181,12 +183,18 @@ export default class DhpDowntime extends HandlebarsApplicationMixin(ApplicationV
                .filter(x => category.moves[x].selected)
                .flatMap(key => {
                    const move = category.moves[key];
+                    const needsTarget = move.actions.filter(x => x.target?.type && x.target.type !== 'self').length > 0;
                    return [...Array(move.selected).keys()].map(_ => ({
                        ...move,
-                        movePath: `${categoryKey}.moves.${key}`
+                        movePath: `${categoryKey}.moves.${key}`,
+                        needsTarget: needsTarget
                    }));
                });
        });
+        const characters = game.actors
+            .filter(x => x.type === 'character')
+            .filter(x => x.testUserPermission(game.user, 'LIMITED'))
+            .filter(x => x.uuid !== this.actor.uuid);

        const cls = getDocumentClass('ChatMessage');
        const msg = {
@ -206,7 +214,9 @@ export default class DhpDowntime extends HandlebarsApplicationMixin(ApplicationV
                        `DAGGERHEART.APPLICATIONS.Downtime.${this.shortrest ? 'shortRest' : 'longRest'}.title`
                    ),
                    actor: { name: this.actor.name, img: this.actor.img },
-                    moves: moves
+                    moves: moves,
+                    characters: characters,
+                    selfId: this.actor.uuid
                }
            ),
            flags: {
--- a/module/applications/dialogs/tagTeamDialog.mjs
+++ b/module/applications/dialogs/tagTeamDialog.mjs
@ -77,7 +77,7 @@ export default class TagTeamDialog extends HandlebarsApplicationMixin(Applicatio
            cost: this.data.initiator.cost
        };

-        const selectedMember = Object.values(context.members).find(x => x.selected);
+        const selectedMember = Object.values(context.members).find(x => x.selected && x.roll);
        const selectedIsCritical = selectedMember?.roll?.system?.isCritical;
        context.selectedData = {
            result: selectedMember
--- a/module/applications/hud/tokenHUD.mjs
+++ b/module/applications/hud/tokenHUD.mjs
@ -21,6 +21,8 @@ export default class DHTokenHUD extends foundry.applications.hud.TokenHUD {

    async _prepareContext(options) {
        const context = await super._prepareContext(options);
+        if (!this.actor) return context;
+
        context.partyOnCanvas =
            this.actor.type === 'party' &&
            this.actor.system.partyMembers.some(member => member.getActiveTokens().length > 0);
@ -58,14 +60,33 @@ export default class DHTokenHUD extends foundry.applications.hud.TokenHUD {
    }

    static async #onToggleCombat() {
+        const tokensWithoutActors = canvas.tokens.controlled.filter(t => !t.actor);
+        const warning =
+            tokensWithoutActors.length === 1
+                ? game.i18n.format('DAGGERHEART.UI.Notifications.tokenActorMissing', {
+                      name: tokensWithoutActors[0].name
+                  })
+                : game.i18n.format('DAGGERHEART.UI.Notifications.tokenActorsMissing', {
+                      names: tokensWithoutActors.map(x => x.name).join(', ')
+                  });
+
        const tokens = canvas.tokens.controlled
-            .filter(t => !t.actor || !DHTokenHUD.#nonCombatTypes.includes(t.actor.type))
+            .filter(t => t.actor && !DHTokenHUD.#nonCombatTypes.includes(t.actor.type))
            .map(t => t.document);
-        if (!this.object.controlled) tokens.push(this.document);
+        if (!this.object.controlled && this.document.actor) tokens.push(this.document);

        try {
-            if (this.document.inCombat) await TokenDocument.implementation.deleteCombatants(tokens);
-            else await TokenDocument.implementation.createCombatants(tokens);
+            if (this.document.inCombat) {
+                const tokensInCombat = tokens.filter(t => t.inCombat);
+                await TokenDocument.implementation.deleteCombatants([...tokensInCombat, ...tokensWithoutActors]);
+            } else {
+                if (tokensWithoutActors.length) {
+                    ui.notifications.warn(warning);
+                }
+
+                const tokensOutOfCombat = tokens.filter(t => !t.inCombat);
+                await TokenDocument.implementation.createCombatants(tokensOutOfCombat);
+            }
        } catch (err) {
            ui.notifications.warn(err.message);
        }
--- a/module/applications/scene/sceneConfigSettings.mjs
+++ b/module/applications/scene/sceneConfigSettings.mjs
@ -1,16 +1,25 @@
+import { RefreshType, socketEvent } from '../../systemRegistration/socket.mjs';
+
 export default class DhSceneConfigSettings extends foundry.applications.sheets.SceneConfig {
-    // static DEFAULT_OPTIONS = {
-    //     ...super.DEFAULT_OPTIONS,
-    //     form: {
-    //         handler: this.updateData,
-    //         closeOnSubmit: true
-    //     }
-    // };
+    constructor(options) {
+        super(options);
+
+        Hooks.on(socketEvent.Refresh, ({ refreshType }) => {
+            if (refreshType === RefreshType.Scene) this.render();
+        });
+    }
+
+    static DEFAULT_OPTIONS = {
+        ...super.DEFAULT_OPTIONS,
+        actions: {
+            ...super.DEFAULT_OPTIONS.actions,
+            removeSceneEnvironment: DhSceneConfigSettings.#removeSceneEnvironment
+        }
+    };

    static buildParts() {
        const { footer, tabs, ...parts } = super.PARTS;
        const tmpParts = {
-            // tabs,
            tabs: { template: 'systems/daggerheart/templates/scene/tabs.hbs' },
            ...parts,
            dh: { template: 'systems/daggerheart/templates/scene/dh-config.hbs' },
@ -28,27 +37,47 @@ export default class DhSceneConfigSettings extends foundry.applications.sheets.S

    static TABS = DhSceneConfigSettings.buildTabs();

+    async _preRender(context, options) {
+        await super._preFirstRender(context, options);
+
+        if (!options.internalRefresh)
+            this.daggerheartFlag = new game.system.api.data.scenes.DHScene(this.document.flags.daggerheart);
+    }
+
    _attachPartListeners(partId, htmlElement, options) {
        super._attachPartListeners(partId, htmlElement, options);
+
        switch (partId) {
            case 'dh':
                htmlElement.querySelector('#rangeMeasurementSetting')?.addEventListener('change', async event => {
-                    const flagData = foundry.utils.mergeObject(this.document.flags.daggerheart, {
-                        rangeMeasurement: { setting: event.target.value }
-                    });
-                    this.document.flags.daggerheart = flagData;
-                    this.render();
+                    this.daggerheartFlag.updateSource({ rangeMeasurement: { setting: event.target.value } });
+                    this.render({ internalRefresh: true });
                });
+
+                const dragArea = htmlElement.querySelector('.scene-environments');
+                if (dragArea) dragArea.ondrop = this._onDrop.bind(this);
+
                break;
        }
    }

+    async _onDrop(event) {
+        const data = foundry.applications.ux.TextEditor.implementation.getDragEventData(event);
+        const item = await foundry.utils.fromUuid(data.uuid);
+        if (item instanceof game.system.api.documents.DhpActor && item.type === 'environment') {
+            await this.daggerheartFlag.updateSource({
+                sceneEnvironments: [...this.daggerheartFlag.sceneEnvironments, data.uuid]
+            });
+            this.render({ internalRefresh: true });
+        }
+    }
+
    /** @inheritDoc */
    async _preparePartContext(partId, context, options) {
        context = await super._preparePartContext(partId, context, options);
        switch (partId) {
            case 'dh':
-                context.data = new game.system.api.data.scenes.DHScene(canvas.scene.flags.daggerheart);
+                context.data = this.daggerheartFlag;
                context.variantRules = game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.variantRules);
                break;
        }
@ -56,8 +85,24 @@ export default class DhSceneConfigSettings extends foundry.applications.sheets.S
        return context;
    }

-    // static async updateData(event, _, formData) {
-    //     const data = foundry.utils.expandObject(formData.object);
-    //     this.close(data);
-    // }
+    static async #removeSceneEnvironment(_event, button) {
+        await this.daggerheartFlag.updateSource({
+            sceneEnvironments: this.daggerheartFlag.sceneEnvironments.filter(
+                (_, index) => index !== Number.parseInt(button.dataset.index)
+            )
+        });
+        this.render({ internalRefresh: true });
+    }
+
+    /** @override */
+    async _processSubmitData(event, form, submitData, options) {
+        submitData.flags.daggerheart = this.daggerheartFlag.toObject();
+        for (const key of Object.keys(this.document._source.flags.daggerheart?.sceneEnvironments ?? {})) {
+            if (!submitData.flags.daggerheart.sceneEnvironments[key]) {
+                submitData.flags.daggerheart.sceneEnvironments[`-=${key}`] = null;
+            }
+        }
+
+        super._processSubmitData(event, form, submitData, options);
+    }
 }
--- a/module/applications/sheets-configs/action-base-config.mjs
+++ b/module/applications/sheets-configs/action-base-config.mjs
@ -7,6 +7,7 @@ export default class DHActionBaseConfig extends DaggerheartSheet(ApplicationV2)

        this.action = action;
        this.openSection = null;
+        this.openTrigger = this.action.triggers.length > 0 ? 0 : null;
    }

    get title() {
@ -15,7 +16,7 @@ export default class DHActionBaseConfig extends DaggerheartSheet(ApplicationV2)

    static DEFAULT_OPTIONS = {
        tag: 'form',
-        classes: ['daggerheart', 'dh-style', 'dialog', 'max-800'],
+        classes: ['daggerheart', 'dh-style', 'action-config', 'dialog', 'max-800'],
        window: {
            icon: 'fa-solid fa-wrench',
            resizable: false
@ -29,13 +30,18 @@ export default class DHActionBaseConfig extends DaggerheartSheet(ApplicationV2)
            removeElement: this.removeElement,
            editEffect: this.editEffect,
            addDamage: this.addDamage,
-            removeDamage: this.removeDamage
+            removeDamage: this.removeDamage,
+            editDoc: this.editDoc,
+            addTrigger: this.addTrigger,
+            removeTrigger: this.removeTrigger,
+            expandTrigger: this.expandTrigger
        },
        form: {
            handler: this.updateForm,
            submitOnChange: true,
            closeOnSubmit: false
-        }
+        },
+        dragDrop: [{ dragSelector: null, dropSelector: '#summon-drop-zone', handlers: ['_onDrop'] }]
    };

    static PARTS = {
@ -55,6 +61,10 @@ export default class DHActionBaseConfig extends DaggerheartSheet(ApplicationV2)
        effect: {
            id: 'effect',
            template: 'systems/daggerheart/templates/sheets-settings/action-settings/effect.hbs'
+        },
+        trigger: {
+            id: 'trigger',
+            template: 'systems/daggerheart/templates/sheets-settings/action-settings/trigger.hbs'
        }
    };

@ -82,10 +92,18 @@ export default class DHActionBaseConfig extends DaggerheartSheet(ApplicationV2)
            id: 'effect',
            icon: null,
            label: 'DAGGERHEART.GENERAL.Tabs.effects'
+        },
+        trigger: {
+            active: false,
+            cssClass: '',
+            group: 'primary',
+            id: 'trigger',
+            icon: null,
+            label: 'DAGGERHEART.GENERAL.Tabs.triggers'
        }
    };

-    static CLEAN_ARRAYS = ['damage.parts', 'cost', 'effects'];
+    static CLEAN_ARRAYS = ['damage.parts', 'cost', 'effects', 'summon'];

    _getTabs(tabs) {
        for (const v of Object.values(tabs)) {
@ -96,9 +114,24 @@ export default class DHActionBaseConfig extends DaggerheartSheet(ApplicationV2)
        return tabs;
    }

+    _attachPartListeners(partId, htmlElement, options) {
+        super._attachPartListeners(partId, htmlElement, options);
+
+        htmlElement.querySelectorAll('.summon-count-wrapper input').forEach(element => {
+            element.addEventListener('change', this.updateSummonCount.bind(this));
+        });
+    }
+
    async _prepareContext(_options) {
        const context = await super._prepareContext(_options, 'action');
        context.source = this.action.toObject(true);
+
+        context.summons = [];
+        for (const summon of context.source.summon ?? []) {
+            const actor = await foundry.utils.fromUuid(summon.actorUUID);
+            context.summons.push({ actor, count: summon.count });
+        }
+
        context.openSection = this.openSection;
        context.tabs = this._getTabs(this.constructor.TABS);
        context.config = CONFIG.DH;
@ -111,6 +144,16 @@ export default class DHActionBaseConfig extends DaggerheartSheet(ApplicationV2)
        context.baseSaveDifficulty = this.action.actor?.baseSaveDifficulty;
        context.baseAttackBonus = this.action.actor?.system.attack?.roll.bonus;
        context.hasRoll = this.action.hasRoll;
+        context.triggers = context.source.triggers.map((trigger, index) => {
+            const { hint, returns, usesActor } = CONFIG.DH.TRIGGER.triggers[trigger.trigger];
+            return {
+                ...trigger,
+                hint,
+                returns,
+                usesActor,
+                revealed: this.openTrigger === index
+            };
+        });

        const settingsTiers = game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.LevelTiers).tiers;
        context.tierOptions = [
@ -181,8 +224,9 @@ export default class DHActionBaseConfig extends DaggerheartSheet(ApplicationV2)
    }

    static async updateForm(event, _, formData) {
-        const submitData = this._prepareSubmitData(event, formData),
-            data = foundry.utils.mergeObject(this.action.toObject(), submitData);
+        const submitData = this._prepareSubmitData(event, formData);
+
+        const data = foundry.utils.mergeObject(this.action.toObject(), submitData);
        this.action = await this.action.update(data);

        this.sheetUpdate?.(this.action);
@ -201,12 +245,26 @@ export default class DHActionBaseConfig extends DaggerheartSheet(ApplicationV2)
    static removeElement(event, button) {
        event.stopPropagation();
        const data = this.action.toObject(),
-            key = event.target.closest('[data-key]').dataset.key,
-            index = button.dataset.index;
+            key = event.target.closest('[data-key]').dataset.key;
+
+        // Prefer explicit index, otherwise find by uuid
+        let index = button?.dataset.index;
+        if (index === undefined || index === null || index === '') {
+            const uuid = button?.dataset.uuid ?? button?.dataset.itemUuid;
+            index = data[key].findIndex(e => (e?.actorUUID ?? e?.uuid) === uuid);
+            if (index === -1) return;
+        } else index = Number(index);
+
        data[key].splice(index, 1);
        this.constructor.updateForm.bind(this)(null, null, { object: foundry.utils.flattenObject(data) });
    }

+    static async editDoc(_event, target) {
+        const element = target.closest('[data-item-uuid]');
+        const doc = (await foundry.utils.fromUuid(element.dataset.itemUuid)) ?? null;
+        if (doc) return doc.sheet.render({ force: true });
+    }
+
    static addDamage(_event) {
        if (!this.action.damage.parts) return;
        const data = this.action.toObject(),
@ -224,6 +282,69 @@ export default class DHActionBaseConfig extends DaggerheartSheet(ApplicationV2)
        this.constructor.updateForm.bind(this)(null, null, { object: foundry.utils.flattenObject(data) });
    }

+    static addTrigger() {
+        const data = this.action.toObject();
+        data.triggers.push({
+            trigger: CONFIG.DH.TRIGGER.triggers.dualityRoll.id,
+            triggeringActor: CONFIG.DH.TRIGGER.triggerActorTargetType.any.id
+        });
+        this.constructor.updateForm.bind(this)(null, null, { object: foundry.utils.flattenObject(data) });
+    }
+
+    static async removeTrigger(_event, button) {
+        const trigger = CONFIG.DH.TRIGGER.triggers[this.action.triggers[button.dataset.index].trigger];
+        const confirmed = await foundry.applications.api.DialogV2.confirm({
+            window: {
+                title: game.i18n.localize('DAGGERHEART.ACTIONS.Config.deleteTriggerTitle')
+            },
+            content: game.i18n.format('DAGGERHEART.ACTIONS.Config.deleteTriggerContent', {
+                trigger: game.i18n.localize(trigger.label)
+            })
+        });
+
+        if (!confirmed) return;
+
+        const data = this.action.toObject();
+        data.triggers = data.triggers.filter((_, index) => index !== Number.parseInt(button.dataset.index));
+        this.constructor.updateForm.bind(this)(null, null, { object: foundry.utils.flattenObject(data) });
+    }
+
+    static async expandTrigger(_event, button) {
+        const index = Number.parseInt(button.dataset.index);
+        const toggle = (element, codeMirror) => {
+            codeMirror.classList.toggle('revealed');
+            const button = element.querySelector('a > i');
+            button.classList.toggle('fa-angle-up');
+            button.classList.toggle('fa-angle-down');
+        };
+
+        const fieldset = button.closest('fieldset');
+        const codeMirror = fieldset.querySelector('.code-mirror-wrapper');
+        toggle(fieldset, codeMirror);
+
+        if (this.openTrigger !== null && this.openTrigger !== index) {
+            const previouslyExpanded = fieldset
+                .closest(`section`)
+                .querySelector(`fieldset[data-index="${this.openTrigger}"]`);
+            const codeMirror = previouslyExpanded.querySelector('.code-mirror-wrapper');
+            toggle(previouslyExpanded, codeMirror);
+            this.openTrigger = index;
+        } else if (this.openTrigger === index) {
+            this.openTrigger = null;
+        } else {
+            this.openTrigger = index;
+        }
+    }
+
+    updateSummonCount(event) {
+        event.stopPropagation();
+        const wrapper = event.target.closest('.summon-count-wrapper');
+        const index = wrapper.dataset.index;
+        const data = this.action.toObject();
+        data.summon[index].count = event.target.value;
+        this.constructor.updateForm.bind(this)(null, null, { object: foundry.utils.flattenObject(data) });
+    }
+
    /** Specific implementation in extending classes **/
    static async addEffect(_event) {}
    static removeEffect(_event, _button) {}
@ -233,4 +354,29 @@ export default class DHActionBaseConfig extends DaggerheartSheet(ApplicationV2)
        this.tabGroups.primary = 'base';
        await super.close(options);
    }
+
+    async _onDrop(event) {
+        const data = foundry.applications.ux.TextEditor.getDragEventData(event);
+        const item = await foundry.utils.fromUuid(data.uuid);
+        if (!(item instanceof game.system.api.documents.DhpActor)) {
+            ui.notifications.warn(game.i18n.localize('DAGGERHEART.ACTIONS.TYPES.summon.invalidDrop'));
+            return;
+        }
+
+        const actionData = this.action.toObject();
+        let countvalue = 1;
+        for (const entry of actionData.summon) {
+            if (entry.actorUUID === data.uuid) {
+                entry.count += 1;
+                countvalue = entry.count;
+                await this.constructor.updateForm.bind(this)(null, null, {
+                    object: foundry.utils.flattenObject(actionData)
+                });
+                return;
+            }
+        }
+
+        actionData.summon.push({ actorUUID: data.uuid, count: countvalue });
+        await this.constructor.updateForm.bind(this)(null, null, { object: foundry.utils.flattenObject(actionData) });
+    }
 }
--- a/module/applications/sheets-configs/adversary-settings.mjs
+++ b/module/applications/sheets-configs/adversary-settings.mjs
@ -51,6 +51,19 @@ export default class DHAdversarySettings extends DHBaseActorSettings {
        }
    };

+    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;
+    }
+
    /* -------------------------------------------- */

    /**
--- a/module/applications/sheets-configs/environment-settings.mjs
+++ b/module/applications/sheets-configs/environment-settings.mjs
@ -49,6 +49,19 @@ export default class DHEnvironmentSettings extends DHBaseActorSettings {
        }
    };

+    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;
+    }
+
    /**
     *  Adds a new category entry to the actor.
     * @type {ApplicationClickAction}
--- a/module/applications/sheets/actors/adversary.mjs
+++ b/module/applications/sheets/actors/adversary.mjs
@ -26,7 +26,12 @@ export default class AdversarySheet extends DHBaseActorSheet {
                }
            ]
        },
-        dragDrop: [{ dragSelector: '[data-item-id]', dropSelector: null }]
+        dragDrop: [
+            {
+                dragSelector: '[data-item-id][draggable="true"], [data-item-id] [draggable="true"]',
+                dropSelector: null
+            }
+        ]
    };

    static PARTS = {
@ -88,6 +93,13 @@ export default class AdversarySheet extends DHBaseActorSheet {
        context.resources.stress.emptyPips =
            context.resources.stress.max < maxResource ? maxResource - context.resources.stress.max : 0;

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

@ -164,6 +176,15 @@ export default class AdversarySheet extends DHBaseActorSheet {
        });
    }

+    /** @inheritdoc */
+    async _onDragStart(event) {
+        const inventoryItem = event.currentTarget.closest('.inventory-item');
+        if (inventoryItem) {
+            event.dataTransfer.setDragImage(inventoryItem.querySelector('img'), 60, 0);
+        }
+        super._onDragStart(event);
+    }
+
    /* -------------------------------------------- */
    /*  Application Clicks Actions                  */
    /* -------------------------------------------- */
--- a/module/applications/sheets/actors/character.mjs
+++ b/module/applications/sheets/actors/character.mjs
@ -32,7 +32,8 @@ export default class CharacterSheet extends DHBaseActorSheet {
            handleResourceDice: CharacterSheet.#handleResourceDice,
            advanceResourceDie: CharacterSheet.#advanceResourceDie,
            cancelBeastform: CharacterSheet.#cancelBeastform,
-            useDowntime: this.useDowntime
+            useDowntime: this.useDowntime,
+            viewParty: CharacterSheet.#viewParty
        },
        window: {
            resizable: true,
@ -318,6 +319,45 @@ export default class CharacterSheet extends DHBaseActorSheet {
                    ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.Notifications.loadoutMaxReached'));
                }
            },
+            {
+                name: 'recall',
+                icon: 'fa-solid fa-bolt-lightning',
+                condition: target => {
+                    const doc = getDocFromElementSync(target);
+                    return doc && doc.system.inVault;
+                },
+                callback: async (target, event) => {
+                    const doc = await getDocFromElement(target);
+                    const actorLoadout = doc.actor.system.loadoutSlot;
+                    if (!actorLoadout.available) {
+                        ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.Notifications.loadoutMaxReached'));
+                        return;
+                    }
+                    if (doc.system.recallCost == 0) {
+                        return doc.update({ 'system.inVault': false });
+                    }
+                    const type = 'effect';
+                    const cls = game.system.api.models.actions.actionsTypes[type];
+                    const action = new cls(
+                        {
+                            ...cls.getSourceConfig(doc.system),
+                            type: type,
+                            chatDisplay: false,
+                            cost: [
+                                {
+                                    key: 'stress',
+                                    value: doc.system.recallCost
+                                }
+                            ]
+                        },
+                        { parent: doc.system }
+                    );
+                    const config = await action.use(event);
+                    if (config) {
+                        return doc.update({ 'system.inVault': false });
+                    }
+                }
+            },
            {
                name: 'toVault',
                icon: 'fa-solid fa-arrow-down',
@ -672,8 +712,10 @@ export default class CharacterSheet extends DHBaseActorSheet {
            headerTitle: game.i18n.format('DAGGERHEART.UI.Chat.dualityRoll.abilityCheckTitle', {
                ability: abilityLabel
            }),
+            effects: Array.from(await this.document.allApplicableEffects()),
            roll: {
-                trait: button.dataset.attribute
+                trait: button.dataset.attribute,
+                type: 'trait'
            },
            hasRoll: true,
            actionType: 'action',
@ -683,6 +725,7 @@ export default class CharacterSheet extends DHBaseActorSheet {
            })
        };
        const result = await this.document.diceRoll(config);
+        if (!result) return;

        /* This could be avoided by baking config.costs into config.resourceUpdates. Didn't feel like messing with it at the time */
        const costResources = result.costs
@ -787,7 +830,7 @@ export default class CharacterSheet extends DHBaseActorSheet {
    static async #toggleVault(_event, button) {
        const doc = await getDocFromElement(button);
        const { available } = this.document.system.loadoutSlot;
-        if (doc.system.inVault && !available) {
+        if (doc.system.inVault && !available && !doc.system.loadoutIgnore) {
            return ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.Notifications.loadoutMaxReached'));
        }

@ -858,6 +901,41 @@ export default class CharacterSheet extends DHBaseActorSheet {
        game.system.api.fields.ActionFields.BeastformField.handleActiveTransformations.call(item);
    }

+    static async #viewParty(_, target) {
+        const parties = this.document.parties;
+        if (parties.size <= 1) {
+            parties.first()?.sheet.render({ force: true });
+            return;
+        }
+
+        const buttons = parties.map(p => {
+            const button = document.createElement('button');
+            button.type = 'button';
+            button.classList.add('plain');
+            const img = document.createElement('img');
+            img.src = p.img;
+            button.append(img);
+            const name = document.createElement('span');
+            name.textContent = p.name;
+            button.append(name);
+            button.addEventListener('click', () => {
+                p.sheet?.render({ force: true });
+                game.tooltip.dismissLockedTooltips();
+            });
+            return button;
+        });
+
+        const html = document.createElement('div');
+        html.classList.add('party-list');
+        html.append(...buttons);
+
+        game.tooltip.dismissLockedTooltips();
+        game.tooltip.activate(target, {
+            html,
+            locked: true
+        });
+    }
+
    /**
     *  Open the downtime application.
     * @type {ApplicationClickAction}
--- a/module/applications/sheets/actors/environment.mjs
+++ b/module/applications/sheets/actors/environment.mjs
@ -25,7 +25,12 @@ export default class DhpEnvironment extends DHBaseActorSheet {
            toggleResourceDice: DhpEnvironment.#toggleResourceDice,
            handleResourceDice: DhpEnvironment.#handleResourceDice
        },
-        dragDrop: [{ dragSelector: '.inventory-item', dropSelector: null }]
+        dragDrop: [
+            {
+                dragSelector: '[data-item-id][draggable="true"], [data-item-id] [draggable="true"]',
+                dropSelector: null
+            }
+        ]
    };

    /**@override */
@ -74,6 +79,9 @@ export default class DhpEnvironment extends DHBaseActorSheet {
            case 'header':
                await this._prepareHeaderContext(context, options);

+                break;
+            case 'features':
+                await this._prepareFeaturesContext(context, options);
                break;
            case 'notes':
                await this._prepareNotesContext(context, options);
@ -110,6 +118,22 @@ export default class DhpEnvironment extends DHBaseActorSheet {
        }
    }

+    /**
+     * 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 Header part.
     * @param {ApplicationRenderContext} context
--- a/module/applications/sheets/api/application-mixin.mjs
+++ b/module/applications/sheets/api/application-mixin.mjs
@ -211,7 +211,7 @@ export default function DHApplicationMixin(Base) {
                    const step = event.key === 'ArrowUp' ? 1 : event.key === 'ArrowDown' ? -1 : 0;
                    if (step !== 0) {
                        handleUpdate(step);
-                        deltaInput.dispatchEvent(new Event("change", { bubbles: true }));
+                        deltaInput.dispatchEvent(new Event('change', { bubbles: true }));
                    }
                });

@ -222,7 +222,7 @@ export default function DHApplicationMixin(Base) {
                        if (deltaInput === document.activeElement) {
                            event.preventDefault();
                            handleUpdate(Math.sign(-1 * event.deltaY));
-                            deltaInput.dispatchEvent(new Event("change", { bubbles: true }));
+                            deltaInput.dispatchEvent(new Event('change', { bubbles: true }));
                        }
                    },
                    { passive: false }
@ -236,7 +236,7 @@ export default function DHApplicationMixin(Base) {
            // Handle contenteditable
            for (const input of htmlElement.querySelectorAll('[contenteditable][data-property]')) {
                const property = input.dataset.property;
-                input.addEventListener("blur", () => {
+                input.addEventListener('blur', () => {
                    const selection = document.getSelection();
                    if (input.contains(selection.anchorNode)) {
                        selection.empty();
@ -244,12 +244,12 @@ export default function DHApplicationMixin(Base) {
                    this.document.update({ [property]: input.textContent });
                });

-                input.addEventListener("keydown", event => {
-                    if (event.key === "Enter") input.blur();
+                input.addEventListener('keydown', event => {
+                    if (event.key === 'Enter') input.blur();
                });

                // Chrome sometimes add <br>, which aren't a problem for the value but are for the placeholder
-                input.addEventListener("input", () => input.querySelectorAll("br").forEach((i) => i.remove()));
+                input.addEventListener('input', () => input.querySelectorAll('br').forEach(i => i.remove()));
            }
        }

@ -505,6 +505,7 @@ export default function DHApplicationMixin(Base) {
                        const doc = await getDocFromElement(target),
                            action = doc?.system?.attack ?? doc;
                        const config = action.prepareConfig(event);
+                        config.effects = Array.from(await this.document.allApplicableEffects());
                        config.hasRoll = false;
                        return action && action.workflow.get('damage').execute(config, null, true);
                    }
@ -585,7 +586,9 @@ export default function DHApplicationMixin(Base) {
                if (!doc || !descriptionElement) continue;

                // localize the description (idk if it's still necessary)
-                const description = game.i18n.localize(doc.system?.description ?? doc.description);
+                const description = doc.system?.getEnrichedDescription
+                    ? await doc.system.getEnrichedDescription()
+                    : game.i18n.localize(doc.system?.description ?? doc.description);

                // Enrich the description and attach it;
                const isAction = doc.documentName === 'Action';
@ -736,7 +739,7 @@ export default function DHApplicationMixin(Base) {
            };
            if (inVault) data['system.inVault'] = true;
            if (disabled) data.disabled = true;
-            if (type === "domainCard" && parent?.system.domains?.length) {
+            if (type === 'domainCard' && parent?.system.domains?.length) {
                data.system.domain = parent.system.domains[0];
            }

--- a/module/applications/sheets/api/base-item.mjs
+++ b/module/applications/sheets/api/base-item.mjs
@ -76,16 +76,10 @@ export default class DHBaseItemSheet extends DHApplicationMixin(ItemSheetV2) {
    /**@inheritdoc */
    async _preparePartContext(partId, context, options) {
        await super._preparePartContext(partId, context, options);
-        const { TextEditor } = foundry.applications.ux;

        switch (partId) {
            case 'description':
-                const value = foundry.utils.getProperty(this.document, 'system.description') ?? '';
-                context.enrichedDescription = await TextEditor.enrichHTML(value, {
-                    relativeTo: this.item,
-                    rollData: this.item.getRollData(),
-                    secrets: this.item.isOwner
-                });
+                context.enrichedDescription = await this.document.system.getEnrichedDescription();
                break;
            case 'effects':
                await this._prepareEffectsContext(context, options);
--- a/module/applications/ui/_module.mjs
+++ b/module/applications/ui/_module.mjs
@ -5,4 +5,5 @@ export { default as DhCombatTracker } from './combatTracker.mjs';
 export { default as DhEffectsDisplay } from './effectsDisplay.mjs';
 export { default as DhFearTracker } from './fearTracker.mjs';
 export { default as DhHotbar } from './hotbar.mjs';
+export { default as DhSceneNavigation } from './sceneNavigation.mjs';
 export { ItemBrowser } from './itemBrowser.mjs';
--- a/module/applications/ui/chatLog.mjs
+++ b/module/applications/ui/chatLog.mjs
@ -134,7 +134,9 @@ export default class DhpChatLog extends foundry.applications.sidebar.tabs.ChatLo

    async actionUseButton(event, message) {
        const { moveIndex, actionIndex, movePath } = event.currentTarget.dataset;
-        const parent = await foundry.utils.fromUuid(message.system.actor);
+        const targetUuid = event.currentTarget.closest('.action-use-button-parent').querySelector('select')?.value;
+        const parent = await foundry.utils.fromUuid(targetUuid || message.system.actor);
+
        const actionType = message.system.moves[moveIndex].actions[actionIndex];
        const cls = game.system.api.models.actions.actionsTypes[actionType.type];
        const action = new cls(
@ -146,7 +148,8 @@ export default class DhpChatLog extends foundry.applications.sidebar.tabs.ChatLo
                    type: CONFIG.DH.ITEM.originItemType.restMove,
                    itemPath: movePath,
                    actionIndex: actionIndex
-                }
+                },
+                targetUuid: targetUuid
            },
            { parent: parent.system }
        );
--- a/module/applications/ui/combatTracker.mjs
+++ b/module/applications/ui/combatTracker.mjs
@ -127,7 +127,7 @@ export default class DhCombatTracker extends foundry.applications.sidebar.tabs.C
            resource,
            active: index === combat.turn,
            canPing: combatant.sceneId === canvas.scene?.id && game.user.hasPermission('PING_CANVAS'),
-            type: combatant.actor.system.type,
+            type: combatant.actor?.system?.type,
            img: await this._getCombatantThumbnail(combatant)
        };

@ -165,7 +165,7 @@ export default class DhCombatTracker extends foundry.applications.sidebar.tabs.C

        if (this.viewed.turn !== toggleTurn) {
            const { updateCountdowns } = game.system.api.applications.ui.DhCountdowns;
-            if (combatant.actor.type === 'character') {
+            if (combatant.actor?.type === 'character') {
                await updateCountdowns(
                    CONFIG.DH.GENERAL.countdownProgressionTypes.spotlight.id,
                    CONFIG.DH.GENERAL.countdownProgressionTypes.characterSpotlight.id
--- a/module/applications/ui/itemBrowser.mjs
+++ b/module/applications/ui/itemBrowser.mjs
@ -230,6 +230,14 @@ export class ItemBrowser extends HandlebarsApplicationMixin(ApplicationV2) {
                result.flatMap(r => r),
                'name'
            );
+
+            /* If any noticeable slowdown occurs, consider replacing with enriching description on clicking to expand descriptions */
+            for (const item of this.items) {
+                item.system.enrichedDescription =
+                    (await item.system.getEnrichedDescription?.()) ??
+                    (await foundry.applications.ux.TextEditor.implementation.enrichHTML(item.description));
+            }
+
            this.fieldFilter = this._createFieldFilter();

            if (this.presets?.filter) {
--- a/module/applications/ui/sceneNavigation.mjs
+++ b/module/applications/ui/sceneNavigation.mjs
@ -0,0 +1,89 @@
+import { emitAsGM, GMUpdateEvent } from '../../systemRegistration/socket.mjs';
+
+export default class DhSceneNavigation extends foundry.applications.ui.SceneNavigation {
+    /** @inheritdoc */
+    static DEFAULT_OPTIONS = {
+        ...super.DEFAULT_OPTIONS,
+        classes: ['faded-ui', 'flexcol', 'scene-navigation'],
+        actions: {
+            openSceneEnvironment: DhSceneNavigation.#openSceneEnvironment
+        }
+    };
+
+    /** @inheritdoc */
+    static PARTS = {
+        scenes: {
+            root: true,
+            template: 'systems/daggerheart/templates/ui/sceneNavigation/scene-navigation.hbs'
+        }
+    };
+
+    /** @inheritdoc */
+    async _prepareContext(options) {
+        const context = await super._prepareContext(options);
+
+        const extendScenes = scenes =>
+            scenes.map(x => {
+                const scene = game.scenes.get(x.id);
+                if (!scene.flags.daggerheart) return x;
+
+                const daggerheartInfo = new game.system.api.data.scenes.DHScene(scene.flags.daggerheart);
+                const environments = daggerheartInfo.sceneEnvironments.filter(
+                    x => x && x.testUserPermission(game.user, 'LIMITED')
+                );
+                const hasEnvironments = environments.length > 0 && x.isView;
+                return {
+                    ...x,
+                    hasEnvironments,
+                    environmentImage: hasEnvironments ? environments[0].img : null,
+                    environments: environments
+                };
+            });
+        context.scenes.active = extendScenes(context.scenes.active);
+        context.scenes.inactive = extendScenes(context.scenes.inactive);
+
+        return context;
+    }
+
+    static async #openSceneEnvironment(event, button) {
+        const scene = game.scenes.get(button.dataset.sceneId);
+        const sceneEnvironments = new game.system.api.data.scenes.DHScene(
+            scene.flags.daggerheart
+        ).sceneEnvironments.filter(x => x.testUserPermission(game.user, 'LIMITED'));
+
+        if (sceneEnvironments.length === 1 || event.shiftKey) {
+            sceneEnvironments[0].sheet.render(true);
+        } else {
+            new foundry.applications.ux.ContextMenu.implementation(
+                button,
+                '.scene-environment',
+                sceneEnvironments.map(environment => ({
+                    name: environment.name,
+                    callback: () => {
+                        if (scene.flags.daggerheart.sceneEnvironments[0] !== environment.uuid) {
+                            const newEnvironments = scene.flags.daggerheart.sceneEnvironments;
+                            const newFirst = newEnvironments.splice(
+                                newEnvironments.findIndex(x => x === environment.uuid)
+                            )[0];
+                            newEnvironments.unshift(newFirst);
+                            emitAsGM(
+                                GMUpdateEvent.UpdateDocument,
+                                scene.update.bind(scene),
+                                { 'flags.daggerheart.sceneEnvironments': newEnvironments },
+                                scene.uuid
+                            );
+                        }
+
+                        environment.sheet.render({ force: true });
+                    }
+                })),
+                {
+                    jQuery: false,
+                    fixed: true
+                }
+            );
+
+            CONFIG.ux.ContextMenu.triggerContextMenu(event, '.scene-environment');
+        }
+    }
+}
--- a/module/applications/ux/contextMenu.mjs
+++ b/module/applications/ux/contextMenu.mjs
@ -96,11 +96,11 @@ export default class DHContextMenu extends foundry.applications.ux.ContextMenu {
     * Trigger a context menu event in response to a normal click on a additional options button.
     * @param {PointerEvent} event
     */
-    static triggerContextMenu(event) {
+    static triggerContextMenu(event, altSelector) {
        event.preventDefault();
        event.stopPropagation();
        const { clientX, clientY } = event;
-        const selector = '[data-item-uuid]';
+        const selector = altSelector ?? '[data-item-uuid]';
        const target = event.target.closest(selector) ?? event.currentTarget.closest(selector);
        target?.dispatchEvent(
            new PointerEvent('contextmenu', {
--- a/module/canvas/_module.mjs
+++ b/module/canvas/_module.mjs
@ -1 +1,2 @@
 export * as placeables from './placeables/_module.mjs';
+export { default as DhTokenLayer } from './tokens.mjs';
--- a/module/canvas/placeables/token.mjs
+++ b/module/canvas/placeables/token.mjs
@ -1,4 +1,12 @@
 export default class DhTokenPlaceable extends foundry.canvas.placeables.Token {
+    /** @inheritdoc */
+    async _draw(options) {
+        await super._draw(options);
+
+        if (this.document.flags.daggerheart?.createPlacement)
+            this.previewHelp ||= this.addChild(this.#drawPreviewHelp());
+    }
+
    /** @inheritDoc */
    async _drawEffects() {
        this.effects.renderable = false;
@ -34,6 +42,69 @@ export default class DhTokenPlaceable extends foundry.canvas.placeables.Token {
        this.renderFlags.set({ refreshEffects: true });
    }

+    /**
+     * Returns the distance from this token to another token object.
+     * This value is corrected to handle alternate token sizes and other grid types
+     * according to the diagonal rules.
+     */
+    distanceTo(target) {
+        if (!canvas.ready) return NaN;
+        if (this === target) return 0;
+
+        const originPoint = this.center;
+        const destinationPoint = target.center;
+
+        // Compute for gridless. This version returns circular edge to edge + grid distance,
+        // so that tokens that are touching return 5.
+        if (canvas.grid.type === CONST.GRID_TYPES.GRIDLESS) {
+            const boundsCorrection = canvas.grid.distance / canvas.grid.size;
+            const originRadius = (this.bounds.width * boundsCorrection) / 2;
+            const targetRadius = (target.bounds.width * boundsCorrection) / 2;
+            const distance = canvas.grid.measurePath([originPoint, destinationPoint]).distance;
+            return distance - originRadius - targetRadius + canvas.grid.distance;
+        }
+
+        // Compute what the closest grid space of each token is, then compute that distance
+        const originEdge = this.#getEdgeBoundary(this.bounds, originPoint, destinationPoint);
+        const targetEdge = this.#getEdgeBoundary(target.bounds, originPoint, destinationPoint);
+        const adjustedOriginPoint = canvas.grid.getTopLeftPoint({
+            x: originEdge.x + Math.sign(originPoint.x - originEdge.x),
+            y: originEdge.y + Math.sign(originPoint.y - originEdge.y)
+        });
+        const adjustDestinationPoint = canvas.grid.getTopLeftPoint({
+            x: targetEdge.x + Math.sign(destinationPoint.x - targetEdge.x),
+            y: targetEdge.y + Math.sign(destinationPoint.y - targetEdge.y)
+        });
+        return canvas.grid.measurePath([adjustedOriginPoint, adjustDestinationPoint]).distance;
+    }
+
+    /** Returns the point at which a line starting at origin and ending at destination intersects the edge of the bounds */
+    #getEdgeBoundary(bounds, originPoint, destinationPoint) {
+        const points = [
+            { x: bounds.x, y: bounds.y },
+            { x: bounds.x + bounds.width, y: bounds.y },
+            { x: bounds.x + bounds.width, y: bounds.y + bounds.height },
+            { x: bounds.x, y: bounds.y + bounds.height }
+        ];
+        const pairsToTest = [
+            [points[0], points[1]],
+            [points[1], points[2]],
+            [points[2], points[3]],
+            [points[3], points[0]]
+        ];
+        for (const pair of pairsToTest) {
+            const result = foundry.utils.lineSegmentIntersection(originPoint, destinationPoint, pair[0], pair[1]);
+            if (result) return result;
+        }
+
+        return null;
+    }
+
+    /** Tests if the token is at least adjacent with another, with some leeway for diagonals */
+    isAdjacentWith(token) {
+        return this.distanceTo(token) <= canvas.grid.distance * 1.5;
+    }
+
    /** @inheritDoc */
    _drawBar(number, bar, data) {
        const val = Number(data.value);
@ -69,4 +140,25 @@ export default class DhTokenPlaceable extends foundry.canvas.placeables.Token {
        bar.position.set(0, posY);
        return true;
    }
+
+    /**
+     * Draw a helptext for previews as a text object
+     * @returns {PreciseText}    The Text object for the preview helper
+     */
+    #drawPreviewHelp() {
+        const { uiScale } = canvas.dimensions;
+
+        const textStyle = CONFIG.canvasTextStyle.clone();
+        textStyle.fontSize = 18;
+        textStyle.wordWrapWidth = this.w * 2.5;
+        textStyle.fontStyle = 'italic';
+
+        const helpText = new foundry.canvas.containers.PreciseText(
+            `(${game.i18n.localize('DAGGERHEART.UI.Tooltip.previewTokenHelp')})`,
+            textStyle
+        );
+        helpText.anchor.set(helpText.width / 900, 1);
+        helpText.scale.set(uiScale, uiScale);
+        return helpText;
+    }
 }
--- a/module/canvas/tokens.mjs
+++ b/module/canvas/tokens.mjs
@ -0,0 +1,16 @@
+export default class DhTokenLayer extends foundry.canvas.layers.TokenLayer {
+    async _createPreview(createData, options) {
+        if (options.actor) {
+            const tokenSizes = game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Homebrew).tokenSizes;
+            if (options.actor?.system.metadata.usesSize) {
+                const tokenSize = tokenSizes[options.actor.system.size];
+                if (tokenSize && options.actor.system.size !== CONFIG.DH.ACTOR.tokenSize.custom.id) {
+                    createData.width = tokenSize;
+                    createData.height = tokenSize;
+                }
+            }
+        }
+
+        return super._createPreview(createData, options);
+    }
+}
--- a/module/config/_module.mjs
+++ b/module/config/_module.mjs
@ -10,3 +10,4 @@ export * as itemConfig from './itemConfig.mjs';
 export * as settingsConfig from './settingsConfig.mjs';
 export * as systemConfig from './system.mjs';
 export * as itemBrowserConfig from './itemBrowserConfig.mjs';
+export * as triggerConfig from './triggerConfig.mjs';
--- a/module/config/encounterConfig.mjs
+++ b/module/config/encounterConfig.mjs
@ -9,7 +9,7 @@ export const AdversaryBPPerEncounter = (adversaries, characters) => {
            );
            if (existingEntry) {
                existingEntry.nr += 1;
-            } else {
+            } else if (adversary.type) {
                acc.push({ adversary, nr: 1 });
            }
            return acc;
--- a/module/config/generalConfig.mjs
+++ b/module/config/generalConfig.mjs
@ -232,7 +232,7 @@ export const defaultRestOptions = {
                    actionType: 'action',
                    chatDisplay: false,
                    target: {
-                        type: 'self'
+                        type: 'friendly'
                    },
                    damage: {
                        parts: [
@ -298,7 +298,7 @@ export const defaultRestOptions = {
                    actionType: 'action',
                    chatDisplay: false,
                    target: {
-                        type: 'self'
+                        type: 'friendly'
                    },
                    damage: {
                        parts: [
@ -341,7 +341,7 @@ export const defaultRestOptions = {
                    actionType: 'action',
                    chatDisplay: false,
                    target: {
-                        type: 'self'
+                        type: 'friendly'
                    },
                    damage: {
                        parts: [
@ -407,7 +407,7 @@ export const defaultRestOptions = {
                    actionType: 'action',
                    chatDisplay: false,
                    target: {
-                        type: 'self'
+                        type: 'friendly'
                    },
                    damage: {
                        parts: [
@ -496,6 +496,8 @@ export const diceTypes = {
    d20: 'd20'
 };

+export const dieFaces = [4, 6, 8, 10, 12, 20];
+
 export const multiplierTypes = {
    prof: 'Proficiency',
    cast: 'Spellcast',
--- a/module/config/hooksConfig.mjs
+++ b/module/config/hooksConfig.mjs
@ -1,5 +1,3 @@
-const hooksConfig = {
+export const hooksConfig = {
    effectDisplayToggle: 'DHEffectDisplayToggle'
 };
-
-export default hooksConfig;
--- a/module/config/itemConfig.mjs
+++ b/module/config/itemConfig.mjs
@ -435,7 +435,8 @@ export const armorFeatures = {
                    {
                        key: 'system.resistance.magical.reduction',
                        mode: 2,
-                        value: '@system.armorScore'
+                        value: '@system.armorScore',
+                        priority: 21
                    }
                ]
            }
@ -709,7 +710,8 @@ export const weaponFeatures = {
                            {
                                key: 'system.evasion',
                                mode: 2,
-                                value: '@system.armorScore'
+                                value: '@system.armorScore',
+                                priority: 21
                            }
                        ]
                    }
@ -1324,7 +1326,8 @@ export const weaponFeatures = {
                    {
                        key: 'system.bonuses.damage.primaryWeapon.bonus',
                        mode: 2,
-                        value: '@system.traits.agility.value'
+                        value: '@system.traits.agility.value',
+                        priority: 21
                    }
                ]
            }
@ -1416,9 +1419,9 @@ export const orderedWeaponFeatures = () => {
 };

 export const featureForm = {
-    passive: "DAGGERHEART.CONFIG.FeatureForm.passive",
-    action: "DAGGERHEART.CONFIG.FeatureForm.action",
-    reaction: "DAGGERHEART.CONFIG.FeatureForm.reaction"
+    passive: 'DAGGERHEART.CONFIG.FeatureForm.passive',
+    action: 'DAGGERHEART.CONFIG.FeatureForm.action',
+    reaction: 'DAGGERHEART.CONFIG.FeatureForm.reaction'
 };

 export const featureTypes = {
--- a/module/config/system.mjs
+++ b/module/config/system.mjs
@ -7,7 +7,8 @@ import * as SETTINGS from './settingsConfig.mjs';
 import * as EFFECTS from './effectConfig.mjs';
 import * as ACTIONS from './actionConfig.mjs';
 import * as FLAGS from './flagsConfig.mjs';
-import HOOKS from './hooksConfig.mjs';
+import * as HOOKS from './hooksConfig.mjs';
+import * as TRIGGER from './triggerConfig.mjs';
 import * as ITEMBROWSER from './itemBrowserConfig.mjs';

 export const SYSTEM_ID = 'daggerheart';
@ -24,5 +25,6 @@ export const SYSTEM = {
    ACTIONS,
    FLAGS,
    HOOKS,
+    TRIGGER,
    ITEMBROWSER
 };
--- a/module/config/triggerConfig.mjs
+++ b/module/config/triggerConfig.mjs
@ -0,0 +1,42 @@
+/* hints and returns are intentionally not translated. They are programatical terms and best understood in english */
+export const triggers = {
+    dualityRoll: {
+        id: 'dualityRoll',
+        usesActor: true,
+        args: ['roll', 'actor'],
+        label: 'DAGGERHEART.CONFIG.Triggers.dualityRoll.label',
+        hint: 'this: Action, roll: DhRoll, actor: DhActor',
+        returns: '{ updates: [{ key, value, total }] }'
+    },
+    fearRoll: {
+        id: 'fearRoll',
+        usesActor: true,
+        args: ['roll', 'actor'],
+        label: 'DAGGERHEART.CONFIG.Triggers.fearRoll.label',
+        hint: 'this: Action, roll: DhRoll, actor: DhActor',
+        returns: '{ updates: [{ key, value, total }] }'
+    },
+    postDamageReduction: {
+        id: 'postDamageReduction',
+        usesActor: true,
+        args: ['damageUpdates', 'actor'],
+        label: 'DAGGERHEART.CONFIG.Triggers.postDamageReduction.label',
+        hint: 'damageUpdates: ResourceUpdates, actor: DhActor',
+        returns: '{ updates: [{ originActor: this.actor, updates: [{ key, value, total }] }] }'
+    }
+};
+
+export const triggerActorTargetType = {
+    any: {
+        id: 'any',
+        label: 'DAGGERHEART.CONFIG.TargetTypes.any'
+    },
+    self: {
+        id: 'self',
+        label: 'DAGGERHEART.CONFIG.TargetTypes.self'
+    },
+    other: {
+        id: 'other',
+        label: 'DAGGERHEART.CONFIG.TargetTypes.other'
+    }
+};
--- a/module/data/action/attackAction.mjs
+++ b/module/data/action/attackAction.mjs
@ -36,6 +36,7 @@ export default class DHAttackAction extends DHDamageAction {

    async use(event, options) {
        const result = await super.use(event, options);
+        if (!result.message) return;

        if (result.message.system.action.roll?.type === 'attack') {
            const { updateCountdowns } = game.system.api.applications.ui.DhCountdowns;
--- a/module/data/action/baseAction.mjs
+++ b/module/data/action/baseAction.mjs
@ -2,6 +2,7 @@ import DhpActor from '../../documents/actor.mjs';
 import D20RollDialog from '../../applications/dialogs/d20RollDialog.mjs';
 import { ActionMixin } from '../fields/actionField.mjs';
 import { originItemField } from '../chat-message/actorRoll.mjs';
+import TriggerField from '../fields/triggerField.mjs';

 const fields = foundry.data.fields;

@ -33,7 +34,9 @@ export default class DHBaseAction extends ActionMixin(foundry.abstract.DataModel
                initial: 'action',
                nullable: false,
                required: true
-            })
+            }),
+            targetUuid: new fields.StringField({ initial: undefined }),
+            triggers: new fields.ArrayField(new TriggerField())
        };

        this.extraSchemas.forEach(s => {
@ -163,7 +166,6 @@ export default class DHBaseAction extends ActionMixin(foundry.abstract.DataModel
     */
    getRollData(data = {}) {
        const actorData = this.actor ? this.actor.getRollData(false) : {};
-
        actorData.result = data.roll?.total ?? 1;
        actorData.scale = data.costs?.length // Right now only return the first scalable cost.
            ? (data.costs.find(c => c.scalable)?.total ?? 1)
@ -196,6 +198,8 @@ export default class DHBaseAction extends ActionMixin(foundry.abstract.DataModel
        let config = this.prepareConfig(event);
        if (!config) return;

+        await this.addEffects(config);
+
        if (Hooks.call(`${CONFIG.DH.id}.preUseAction`, this, config) === false) return;

        // Display configuration window if necessary
@ -241,7 +245,8 @@ export default class DHBaseAction extends ActionMixin(foundry.abstract.DataModel
            selectedRollMode: game.settings.get('core', 'rollMode'),
            data: this.getRollData(),
            evaluate: this.hasRoll,
-            resourceUpdates: new ResourceUpdateMap(this.actor)
+            resourceUpdates: new ResourceUpdateMap(this.actor),
+            targetUuid: this.targetUuid
        };

        DHBaseAction.applyKeybindings(config);
@ -261,6 +266,16 @@ export default class DHBaseAction extends ActionMixin(foundry.abstract.DataModel
        return config;
    }

+    /** */
+    async addEffects(config) {
+        let effects = [];
+        if (this.actor) {
+            effects = Array.from(await this.actor.allApplicableEffects());
+        }
+
+        config.effects = effects;
+    }
+
    /**
     * Method used to know if a configuration dialog must be shown or not when there is no roll.
     * @param {*} config    Object that contains workflow datas. Usually made from Action Fields prepareConfig methods.
@ -341,6 +356,10 @@ export class ResourceUpdateMap extends Map {
    }

    addResources(resources) {
+        if (!resources?.length) return;
+        const invalidResources = resources.some(resource => !resource.key);
+        if (invalidResources) return;
+
        for (const resource of resources) {
            if (!resource.key) continue;

--- a/module/data/action/summonAction.mjs
+++ b/module/data/action/summonAction.mjs
@ -1,19 +1,5 @@
 import DHBaseAction from './baseAction.mjs';

 export default class DHSummonAction extends DHBaseAction {
-    static defineSchema() {
-        const fields = foundry.data.fields;
-        return {
-            ...super.defineSchema(),
-            documentUUID: new fields.DocumentUUIDField({ type: 'Actor' })
-        };
-    }
-
-    async trigger(event, ...args) {
-        if (!this.canSummon || !canvas.scene) return;
-    }
-
-    get canSummon() {
-        return game.user.can('TOKEN_CREATE');
-    }
+    static extraSchemas = [...super.extraSchemas, 'summon'];
 }
--- a/module/data/activeEffect/baseEffect.mjs
+++ b/module/data/activeEffect/baseEffect.mjs
@ -1,3 +1,17 @@
+/** -- Changes Type Priorities --
+ *  - Base Number -
+ *  Custom: 0
+ *  Multiply: 10
+ *  Add: 20
+ *  Downgrade: 30
+ *  Upgrade: 40
+ *  Override: 50
+ *
+ *  - Changes Value Priorities -
+ *  Standard: +0
+ *  "Anything that uses another data model value as its value": +1 - Effects that increase traits have to be calculated first at Base priority. (EX: Raise evasion by half your agility)
+ */
+
 export default class BaseEffect extends foundry.abstract.TypeDataModel {
    static defineSchema() {
        const fields = foundry.data.fields;
--- a/module/data/activeEffect/beastformEffect.mjs
+++ b/module/data/activeEffect/beastformEffect.mjs
@ -19,6 +19,7 @@ export default class BeastformEffect extends BaseEffect {
                    base64: false
                }),
                tokenSize: new fields.SchemaField({
+                    scale: new fields.NumberField({ nullable: false, initial: 1 }),
                    height: new fields.NumberField({ integer: false, nullable: true }),
                    width: new fields.NumberField({ integer: false, nullable: true })
                })
@ -55,7 +56,9 @@ export default class BeastformEffect extends BaseEffect {
            const update = {
                ...baseUpdate,
                texture: {
-                    src: this.characterTokenData.tokenImg
+                    src: this.characterTokenData.tokenImg,
+                    scaleX: this.characterTokenData.tokenSize.scale,
+                    scaleY: this.characterTokenData.tokenSize.scale
                },
                ring: {
                    enabled: this.characterTokenData.usesDynamicToken,
@ -66,19 +69,29 @@ export default class BeastformEffect extends BaseEffect {
            };

            const updateToken = token => {
-                const { x, y } = game.system.api.documents.DhToken.getSnappedPositionInSquareGrid(
+                let x = null,
+                    y = null;
+                if (token.object?.scene?.grid) {
+                    const positionData = game.system.api.documents.DhToken.getSnappedPositionInSquareGrid(
                        token.object.scene.grid,
                        { x: token.x, y: token.y, elevation: token.elevation },
                        baseUpdate.width,
                        baseUpdate.height
                    );
+
+                    x = positionData.x;
+                    y = positionData.y;
+                }
+
                return {
                    ...baseUpdate,
                    x,
                    y,
                    'texture': {
                        enabled: this.characterTokenData.usesDynamicToken,
-                        src: token.flags.daggerheart?.beastformTokenImg ?? this.characterTokenData.tokenImg
+                        src: token.flags.daggerheart?.beastformTokenImg ?? this.characterTokenData.tokenImg,
+                        scaleX: this.characterTokenData.tokenSize.scale,
+                        scaleY: this.characterTokenData.tokenSize.scale
                    },
                    'ring': {
                        subject: {
--- a/module/data/actor/adversary.mjs
+++ b/module/data/actor/adversary.mjs
@ -1,6 +1,6 @@
 import DHAdversarySettings from '../../applications/sheets-configs/adversary-settings.mjs';
 import { ActionField } from '../fields/actionField.mjs';
-import BaseDataActor from './base.mjs';
+import BaseDataActor, { commonActorRules } from './base.mjs';
 import { resourceField, bonusField } from '../fields/actorField.mjs';

 export default class DhpAdversary extends BaseDataActor {
@ -56,25 +56,11 @@ export default class DhpAdversary extends BaseDataActor {
                })
            }),
            resources: new fields.SchemaField({
-                hitPoints: resourceField(
-                    0,
-                    0,
-                    'DAGGERHEART.GENERAL.HitPoints.plural',
-                    true
-                ),
-                stress: resourceField(
-                    0,
-                    0,
-                    'DAGGERHEART.GENERAL.stress',
-                    true
-                )
+                hitPoints: resourceField(0, 0, 'DAGGERHEART.GENERAL.HitPoints.plural', true),
+                stress: resourceField(0, 0, 'DAGGERHEART.GENERAL.stress', true)
            }),
            rules: new fields.SchemaField({
-                conditionImmunities: new fields.SchemaField({
-                    hidden: new fields.BooleanField({ initial: false }),
-                    restrained: new fields.BooleanField({ initial: false }),
-                    vulnerable: new fields.BooleanField({ initial: false })
-                })
+                ...commonActorRules()
            }),
            attack: new ActionField({
                initial: {
--- a/module/data/actor/base.mjs
+++ b/module/data/actor/base.mjs
@ -2,21 +2,23 @@ import DHBaseActorSettings from '../../applications/sheets/api/actor-setting.mjs
 import DHItem from '../../documents/item.mjs';
 import { getScrollTextData } from '../../helpers/utils.mjs';

+const fields = foundry.data.fields;
+
 const resistanceField = (resistanceLabel, immunityLabel, reductionLabel) =>
-    new foundry.data.fields.SchemaField({
-        resistance: new foundry.data.fields.BooleanField({
+    new fields.SchemaField({
+        resistance: new fields.BooleanField({
            initial: false,
            label: `${resistanceLabel}.label`,
            hint: `${resistanceLabel}.hint`,
            isAttributeChoice: true
        }),
-        immunity: new foundry.data.fields.BooleanField({
+        immunity: new fields.BooleanField({
            initial: false,
            label: `${immunityLabel}.label`,
            hint: `${immunityLabel}.hint`,
            isAttributeChoice: true
        }),
-        reduction: new foundry.data.fields.NumberField({
+        reduction: new fields.NumberField({
            integer: true,
            initial: 0,
            label: `${reductionLabel}.label`,
@ -24,6 +26,25 @@ const resistanceField = (resistanceLabel, immunityLabel, reductionLabel) =>
        })
    });

+/* Common rules applying to Characters and Adversaries */
+export const commonActorRules = (extendedData = { damageReduction: {} }) => ({
+    conditionImmunities: new fields.SchemaField({
+        hidden: new fields.BooleanField({ initial: false }),
+        restrained: new fields.BooleanField({ initial: false }),
+        vulnerable: new fields.BooleanField({ initial: false })
+    }),
+    damageReduction: new fields.SchemaField({
+        thresholdImmunities: new fields.SchemaField({
+            minor: new fields.BooleanField({ initial: false })
+        }),
+        reduceSeverity: new fields.SchemaField({
+            magical: new fields.NumberField({ initial: 0, min: 0 }),
+            physical: new fields.NumberField({ initial: 0, min: 0 })
+        }),
+        ...extendedData.damageReduction
+    })
+});
+
 /**
 * Describes metadata about the actor data model type
 * @typedef {Object} ActorDataModelMetadata
@ -54,7 +75,6 @@ export default class BaseDataActor extends foundry.abstract.TypeDataModel {

    /** @inheritDoc */
    static defineSchema() {
-        const fields = foundry.data.fields;
        const schema = {};

        if (this.metadata.hasAttribution) {
--- a/module/data/actor/character.mjs
+++ b/module/data/actor/character.mjs
@ -1,7 +1,7 @@
 import { burden } from '../../config/generalConfig.mjs';
 import ForeignDocumentUUIDField from '../fields/foreignDocumentUUIDField.mjs';
 import DhLevelData from '../levelData.mjs';
-import BaseDataActor from './base.mjs';
+import BaseDataActor, { commonActorRules } from './base.mjs';
 import { attributeField, resourceField, stressDamageReductionRule, bonusField } from '../fields/actorField.mjs';
 import { ActionField } from '../fields/actionField.mjs';
 import DHCharacterSettings from '../../applications/sheets-configs/character-settings.mjs';
@ -217,7 +217,10 @@ export default class DhCharacter extends BaseDataActor {
            }),
            companion: new ForeignDocumentUUIDField({ type: 'Actor', nullable: true, initial: null }),
            rules: new fields.SchemaField({
-                damageReduction: new fields.SchemaField({
+                ...commonActorRules({
+                    damageReduction: {
+                        magical: new fields.BooleanField({ initial: false }),
+                        physical: new fields.BooleanField({ initial: false }),
                        maxArmorMarked: new fields.SchemaField({
                            value: new fields.NumberField({
                                required: true,
@ -234,7 +237,9 @@ export default class DhCharacter extends BaseDataActor {
                            })
                        }),
                        stressDamageReduction: new fields.SchemaField({
-                        severe: stressDamageReductionRule('DAGGERHEART.GENERAL.Rules.damageReduction.stress.severe'),
+                            severe: stressDamageReductionRule(
+                                'DAGGERHEART.GENERAL.Rules.damageReduction.stress.severe'
+                            ),
                            major: stressDamageReductionRule('DAGGERHEART.GENERAL.Rules.damageReduction.stress.major'),
                            minor: stressDamageReductionRule('DAGGERHEART.GENERAL.Rules.damageReduction.stress.minor'),
                            any: stressDamageReductionRule('DAGGERHEART.GENERAL.Rules.damageReduction.stress.any')
@ -245,16 +250,8 @@ export default class DhCharacter extends BaseDataActor {
                            label: 'DAGGERHEART.GENERAL.Rules.damageReduction.increasePerArmorMark.label',
                            hint: 'DAGGERHEART.GENERAL.Rules.damageReduction.increasePerArmorMark.hint'
                        }),
-                    magical: new fields.BooleanField({ initial: false }),
-                    physical: new fields.BooleanField({ initial: false }),
-                    thresholdImmunities: new fields.SchemaField({
-                        minor: new fields.BooleanField({ initial: false })
-                    }),
-                    reduceSeverity: new fields.SchemaField({
-                        magical: new fields.NumberField({ initial: 0, min: 0 }),
-                        physical: new fields.NumberField({ initial: 0, min: 0 })
-                    }),
                        disabledArmor: new fields.BooleanField({ intial: false })
+                    }
                }),
                attack: new fields.SchemaField({
                    damage: new fields.SchemaField({
@ -283,10 +280,23 @@ export default class DhCharacter extends BaseDataActor {
                        })
                    })
                }),
-                conditionImmunities: new fields.SchemaField({
-                    hidden: new fields.BooleanField({ initial: false }),
-                    restrained: new fields.BooleanField({ initial: false }),
-                    vulnerable: new fields.BooleanField({ initial: false })
+                dualityRoll: new fields.SchemaField({
+                    defaultHopeDice: new fields.NumberField({
+                        nullable: false,
+                        required: true,
+                        integer: true,
+                        choices: CONFIG.DH.GENERAL.dieFaces,
+                        initial: 12,
+                        label: 'DAGGERHEART.ACTORS.Character.defaultHopeDice'
+                    }),
+                    defaultFearDice: new fields.NumberField({
+                        nullable: false,
+                        required: true,
+                        integer: true,
+                        choices: CONFIG.DH.GENERAL.dieFaces,
+                        initial: 12,
+                        label: 'DAGGERHEART.ACTORS.Character.defaultFearDice'
+                    })
                }),
                runeWard: new fields.BooleanField({ initial: false }),
                burden: new fields.SchemaField({
@ -453,8 +463,7 @@ export default class DhCharacter extends BaseDataActor {

        if (
            item.system.identifier === CONFIG.DH.ITEM.featureSubTypes.foundation ||
-            (item.system.identifier === CONFIG.DH.ITEM.featureSubTypes.specialization &&
-                subclassState >= 2) ||
+            (item.system.identifier === CONFIG.DH.ITEM.featureSubTypes.specialization && subclassState >= 2) ||
            (item.system.identifier === CONFIG.DH.ITEM.featureSubTypes.mastery && subclassState >= 3)
        ) {
            return true;
--- a/module/data/actor/environment.mjs
+++ b/module/data/actor/environment.mjs
@ -1,8 +1,11 @@
 import BaseDataActor from './base.mjs';
 import ForeignDocumentUUIDArrayField from '../fields/foreignDocumentUUIDArrayField.mjs';
 import DHEnvironmentSettings from '../../applications/sheets-configs/environment-settings.mjs';
+import { RefreshType, socketEvent } from '../../systemRegistration/socket.mjs';

 export default class DhEnvironment extends BaseDataActor {
+    scenes = new Set();
+
    /**@override */
    static LOCALIZATION_PREFIXES = ['DAGGERHEART.ACTORS.Environment'];

@ -53,6 +56,31 @@ export default class DhEnvironment extends BaseDataActor {
    }

    isItemValid(source) {
-        return source.type === "feature";
+        return source.type === 'feature';
+    }
+
+    _onUpdate(changes, options, userId) {
+        super._onUpdate(changes, options, userId);
+        for (const scene of this.scenes) {
+            scene.render();
+        }
+    }
+
+    _onDelete(options, userId) {
+        super._onDelete(options, userId);
+        for (const scene of this.scenes) {
+            if (game.user.isActiveGM) {
+                const newSceneEnvironments = scene.flags.daggerheart.sceneEnvironments.filter(
+                    x => x !== this.parent.uuid
+                );
+                scene.update({ 'flags.daggerheart.sceneEnvironments': newSceneEnvironments }).then(() => {
+                    Hooks.callAll(socketEvent.Refresh, { refreshType: RefreshType.Scene });
+                    game.socket.emit(`system.${CONFIG.DH.id}`, {
+                        action: socketEvent.Refresh,
+                        data: { refreshType: RefreshType.TagTeamRoll }
+                    });
+                });
+            }
+        }
    }
 }
--- a/module/data/combat.mjs
+++ b/module/data/combat.mjs
@ -15,8 +15,9 @@ export default class DhCombat extends foundry.abstract.TypeDataModel {
    get extendedBattleToggles() {
        const modifiers = CONFIG.DH.ENCOUNTER.BPModifiers;
        const adversaries =
-            this.parent.turns?.filter(x => x.isNPC)?.map(x => ({ ...x.actor, type: x.actor.system.type })) ?? [];
-        const characters = this.parent.turns?.filter(x => !x.isNPC) ?? [];
+            this.parent.turns?.filter(x => x.actor && x.isNPC)?.map(x => ({ ...x.actor, type: x.actor.system.type })) ??
+            [];
+        const characters = this.parent.turns?.filter(x => x.actor && !x.isNPC) ?? [];

        const activeAutomatic = Object.keys(modifiers).reduce((acc, categoryKey) => {
            const category = modifiers[categoryKey];
--- a/module/data/fields/_module.mjs
+++ b/module/data/fields/_module.mjs
@ -2,5 +2,6 @@ export { ActionCollection } from './actionField.mjs';
 export { default as FormulaField } from './formulaField.mjs';
 export { default as ForeignDocumentUUIDField } from './foreignDocumentUUIDField.mjs';
 export { default as ForeignDocumentUUIDArrayField } from './foreignDocumentUUIDArrayField.mjs';
+export { default as TriggerField } from './triggerField.mjs';
 export { default as MappingField } from './mappingField.mjs';
 export * as ActionFields from './action/_module.mjs';
--- a/module/data/fields/action/_module.mjs
+++ b/module/data/fields/action/_module.mjs
@ -9,3 +9,4 @@ export { default as BeastformField } from './beastformField.mjs';
 export { default as DamageField } from './damageField.mjs';
 export { default as RollField } from './rollField.mjs';
 export { default as MacroField } from './macroField.mjs';
+export { default as SummonField } from './summonField.mjs';
--- a/module/data/fields/action/beastformField.mjs
+++ b/module/data/fields/action/beastformField.mjs
@ -76,7 +76,7 @@ export default class BeastformField extends fields.SchemaField {
     * @returns
     */
    static async transform(selectedForm, evolvedData, hybridData) {
-        const formData = evolvedData?.form ? evolvedData.form.toObject() : selectedForm;
+        const formData = evolvedData?.form ?? selectedForm;
        const beastformEffect = formData.effects.find(x => x.type === 'beastform');
        if (!beastformEffect) {
            ui.notifications.error('DAGGERHEART.UI.Notifications.beastformMissingEffect');
--- a/module/data/fields/action/rollField.mjs
+++ b/module/data/fields/action/rollField.mjs
@ -87,7 +87,7 @@ export class DHActionRollData extends foundry.abstract.DataModel {
                if (this.type === CONFIG.DH.GENERAL.rollTypes.attack.id)
                    modifiers.push({
                        label: 'Bonus to Hit',
-                        value: this.bonus ?? this.parent.actor.system.attack.roll.bonus
+                        value: this.bonus ?? this.parent.actor.system.attack.roll.bonus ?? 0
                    });
                break;
            default:
--- a/module/data/fields/action/summonField.mjs
+++ b/module/data/fields/action/summonField.mjs
@ -0,0 +1,89 @@
+import FormulaField from '../formulaField.mjs';
+
+const fields = foundry.data.fields;
+
+export default class DHSummonField extends fields.ArrayField {
+    /**
+     * Action Workflow order
+     */
+    static order = 120;
+
+    constructor(options = {}, context = {}) {
+        const summonFields = new fields.SchemaField({
+            actorUUID: new fields.DocumentUUIDField({
+                type: 'Actor',
+                required: true
+            }),
+            count: new FormulaField({
+                required: true,
+                default: '1'
+            })
+        });
+        super(summonFields, options, context);
+    }
+
+    static async execute() {
+        if (!canvas.scene) {
+            ui.notifications.warn(game.i18n.localize('DAGGERHEART.ACTIONS.TYPES.summon.error'));
+            return;
+        }
+
+        if (this.summon.length === 0) {
+            ui.notifications.warn('No actors configured for this Summon action.');
+            return;
+        }
+
+        const rolls = [];
+        const summonData = [];
+        for (const summon of this.summon) {
+            let count = summon.count;
+            const roll = new Roll(summon.count);
+            if (!roll.isDeterministic) {
+                await roll.evaluate();
+                if (game.modules.get('dice-so-nice')?.active) rolls.push(roll);
+                count = roll.total;
+            }
+
+            const actor = 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. */
+            summon.rolledCount = count;
+            summon.actor = actor.toObject();
+
+            summonData.push({ actor, count: count });
+        }
+
+        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);
+    }
+
+    /* Check for any available instances of the actor present in the world if we're missing artwork in the compendium */
+    static getWorldActor(baseActor) {
+        const dataType = game.system.api.data.actors[`Dh${baseActor.type.capitalize()}`];
+        if (baseActor.inCompendium && dataType && baseActor.img === dataType.DEFAULT_ICON) {
+            const worldActorCopy = game.actors.find(x => x.name === baseActor.name);
+            return worldActorCopy ?? baseActor;
+        }
+
+        return baseActor;
+    }
+
+    static async handleSummon(summonData, actionActor, summonIndex = 0) {
+        const summon = summonData[summonIndex];
+        const result = await CONFIG.ux.TokenManager.createPreviewAsync(summon.actor, {
+            name: `${summon.actor.prototypeToken.name}${summon.count > 1 ? ` (${summon.count}x)` : ''}`
+        });
+
+        if (!result) return actionActor.sheet?.maximize();
+        summon.actor = result.actor;
+
+        summon.count--;
+        if (summon.count <= 0) {
+            summonIndex++;
+            if (summonIndex === summonData.length) return actionActor.sheet?.maximize();
+        }
+
+        DHSummonField.handleSummon(summonData, actionActor, summonIndex);
+    }
+}
--- a/module/data/fields/action/targetField.mjs
+++ b/module/data/fields/action/targetField.mjs
@ -25,9 +25,12 @@ export default class TargetField extends fields.SchemaField {
        config.hasTarget = true;
        let targets;
        // If the Action is configured as self-targeted, set targets as the owner. Probably better way than to fallback to getDependentTokens
-        if (this.target?.type === CONFIG.DH.GENERAL.targetTypes.self.id)
+        if (this.target?.type === CONFIG.DH.GENERAL.targetTypes.self.id) {
            targets = [this.actor.token ?? this.actor.prototypeToken];
-        else {
+        } else if (config.targetUuid) {
+            const actor = fromUuidSync(config.targetUuid);
+            targets = [actor.token ?? actor.prototypeToken];
+        } else {
            targets = Array.from(game.user.targets);
            if (this.target.type !== CONFIG.DH.GENERAL.targetTypes.any.id) {
                targets = targets.filter(target => TargetField.isTargetFriendly(this.actor, target, this.target.type));
--- a/module/data/fields/actionField.mjs
+++ b/module/data/fields/actionField.mjs
@ -267,17 +267,23 @@ export function ActionMixin(Base) {
                action: {
                    name: this.name,
                    img: this.baseAction ? this.parent.parent.img : this.img,
-                    tags: this.tags ? this.tags : ['Spell', 'Arcana', 'Lv 10']
+                    tags: this.tags ? this.tags : ['Spell', 'Arcana', 'Lv 10'],
+                    summon: this.summon
                },
                itemOrigin: this.item,
                description: this.description || (this.item instanceof Item ? this.item.system.description : '')
            };
+
+            const speaker = cls.getSpeaker();
            const msg = {
                type: 'abilityUse',
                user: game.user.id,
                actor: { name: this.actor.name, img: this.actor.img },
                author: this.author,
-                speaker: cls.getSpeaker(),
+                speaker: {
+                    speaker,
+                    actor: speaker.actor ?? this.actor
+                },
                title: game.i18n.localize('DAGGERHEART.UI.Chat.action.title'),
                system: systemData,
                content: await foundry.applications.handlebars.renderTemplate(
--- a/module/data/fields/triggerField.mjs
+++ b/module/data/fields/triggerField.mjs
@ -0,0 +1,24 @@
+export default class TriggerField extends foundry.data.fields.SchemaField {
+    constructor(context) {
+        super(
+            {
+                trigger: new foundry.data.fields.StringField({
+                    nullable: false,
+                    blank: false,
+                    initial: CONFIG.DH.TRIGGER.triggers.dualityRoll.id,
+                    choices: CONFIG.DH.TRIGGER.triggers,
+                    label: 'DAGGERHEART.CONFIG.Triggers.triggerType'
+                }),
+                triggeringActorType: new foundry.data.fields.StringField({
+                    nullable: false,
+                    blank: false,
+                    initial: CONFIG.DH.TRIGGER.triggerActorTargetType.any.id,
+                    choices: CONFIG.DH.TRIGGER.triggerActorTargetType,
+                    label: 'DAGGERHEART.CONFIG.Triggers.triggeringActorType'
+                }),
+                command: new foundry.data.fields.JavaScriptField({ async: true })
+            },
+            context
+        );
+    }
+}
--- a/module/data/item/armor.mjs
+++ b/module/data/item/armor.mjs
@ -54,6 +54,21 @@ export default class DHArmor extends AttachableItem {
        );
    }

+    /**@inheritdoc */
+    async getDescriptionData() {
+        const baseDescription = this.description;
+        const allFeatures = CONFIG.DH.ITEM.allArmorFeatures();
+        const features = this.armorFeatures.map(x => allFeatures[x.value]);
+        if (!features.length) return { prefix: null, value: baseDescription, suffix: null };
+
+        const prefix = await foundry.applications.handlebars.renderTemplate(
+            'systems/daggerheart/templates/sheets/items/armor/description.hbs',
+            { features }
+        );
+
+        return { prefix, value: baseDescription, suffix: null };
+    }
+
    /**@inheritdoc */
    async _preUpdate(changes, options, user) {
        const allowed = await super._preUpdate(changes, options, user);
--- a/module/data/item/base.mjs
+++ b/module/data/item/base.mjs
@ -8,7 +8,7 @@
 * @property {boolean} isInventoryItem- Indicates whether items of this type is a Inventory Item
 */

-import { addLinkedItemsDiff, createScrollText, getScrollTextData, updateLinkedItemApps } from '../../helpers/utils.mjs';
+import { addLinkedItemsDiff, getScrollTextData, updateLinkedItemApps } from '../../helpers/utils.mjs';
 import { ActionsField } from '../fields/actionField.mjs';
 import FormulaField from '../fields/formulaField.mjs';

@ -124,6 +124,33 @@ export default class BaseDataItem extends foundry.abstract.TypeDataModel {
        return [source, page ? `pg ${page}.` : null].filter(x => x).join('. ');
    }

+    /**
+     * Augments the description for the item with type specific info to display. Implemented in applicable item subtypes.
+     * @param {object} [options] - Options that modify the styling of the rendered template. { headerStyle: undefined|'none'|'large' }
+     * @returns {string}
+     */
+    async getDescriptionData(_options) {
+        return { prefix: null, value: this.description, suffix: null };
+    }
+
+    /**
+     * Gets the enriched and augmented description for the item.
+     * @param {object} [options] - Options that modify the styling of the rendered template. { headerStyle: undefined|'none'|'large' }
+     * @returns {string}
+     */
+    async getEnrichedDescription() {
+        if (!this.metadata.hasDescription) return '';
+
+        const { prefix, value, suffix } = await this.getDescriptionData();
+        const fullDescription = [prefix, value, suffix].filter(p => !!p).join('\n<hr>\n');
+
+        return await foundry.applications.ux.TextEditor.implementation.enrichHTML(fullDescription, {
+            relativeTo: this,
+            rollData: this.getRollData(),
+            secrets: this.isOwner
+        });
+    }
+
    /**
     * Obtain a data object used to evaluate any dice rolls associated with this Item Type
     * @param {object} [options] - Options which modify the getRollData method.
@ -135,6 +162,30 @@ export default class BaseDataItem extends foundry.abstract.TypeDataModel {
        return data;
    }

+    prepareBaseData() {
+        super.prepareBaseData();
+
+        for (const action of this.actions ?? []) {
+            if (!action.actor) continue;
+
+            const actionsToRegister = [];
+            for (let i = 0; i < action.triggers.length; i++) {
+                const trigger = action.triggers[i];
+                const { args } = CONFIG.DH.TRIGGER.triggers[trigger.trigger];
+                const fn = new foundry.utils.AsyncFunction(...args, `{${trigger.command}\n}`);
+                actionsToRegister.push(fn.bind(action));
+                if (i === action.triggers.length - 1)
+                    game.system.registeredTriggers.registerTriggers(
+                        trigger.trigger,
+                        action.actor?.uuid,
+                        trigger.triggeringActorType,
+                        this.parent.uuid,
+                        actionsToRegister
+                    );
+            }
+        }
+    }
+
    async _preCreate(data, options, user) {
        // Skip if no initial action is required or actions already exist
        if (this.metadata.hasInitialAction && foundry.utils.isEmpty(this.actions)) {
--- a/module/data/item/beastform.mjs
+++ b/module/data/item/beastform.mjs
@ -49,6 +49,7 @@ export default class DHBeastform extends BaseDataItem {
                    choices: CONFIG.DH.ACTOR.tokenSize,
                    initial: CONFIG.DH.ACTOR.tokenSize.custom.id
                }),
+                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 })
            }),
@ -184,6 +185,7 @@ export default class DHBeastform extends BaseDataItem {
                    tokenImg: this.parent.parent.prototypeToken.texture.src,
                    tokenRingImg: this.parent.parent.prototypeToken.ring.subject.texture,
                    tokenSize: {
+                        scale: this.parent.parent.prototypeToken.texture.scaleX,
                        height: this.parent.parent.prototypeToken.height,
                        width: this.parent.parent.prototypeToken.width
                    }
@ -209,7 +211,9 @@ export default class DHBeastform extends BaseDataItem {
            height,
            width,
            texture: {
-                src: this.tokenImg
+                src: this.tokenImg,
+                scaleX: this.tokenSize.scale,
+                scaleY: this.tokenSize.scale
            },
            ring: {
                subject: {
@ -218,12 +222,20 @@ export default class DHBeastform extends BaseDataItem {
            }
        };
        const tokenUpdate = token => {
-            const { x, y } = game.system.api.documents.DhToken.getSnappedPositionInSquareGrid(
+            let x = null,
+                y = null;
+            if (token.object?.scene?.grid) {
+                const positionData = game.system.api.documents.DhToken.getSnappedPositionInSquareGrid(
                    token.object.scene.grid,
                    { x: token.x, y: token.y, elevation: token.elevation },
                    width ?? token.width,
                    height ?? token.height
                );
+
+                x = positionData.x;
+                y = positionData.y;
+            }
+
            return {
                ...prototypeTokenUpdate,
                x,
--- a/module/data/item/domainCard.mjs
+++ b/module/data/item/domainCard.mjs
@ -29,7 +29,21 @@ export default class DHDomainCard extends BaseDataItem {
                required: true,
                initial: CONFIG.DH.DOMAIN.cardTypes.ability.id
            }),
-            inVault: new fields.BooleanField({ initial: false })
+            inVault: new fields.BooleanField({ initial: false }),
+            vaultActive: new fields.BooleanField({
+                required: true,
+                nullable: false,
+                initial: false
+            }),
+            loadoutIgnore: new fields.BooleanField({
+                required: true,
+                nullable: false,
+                initial: false
+            }),
+            domainTouched: new fields.NumberField({
+                nullable: true,
+                initial: null
+            })
        };
    }

@ -38,6 +52,19 @@ export default class DHDomainCard extends BaseDataItem {
        return game.i18n.localize(allDomainData[this.domain].label);
    }

+    get isVaultSupressed() {
+        return this.inVault && !this.vaultActive;
+    }
+
+    get isDomainTouchedSuppressed() {
+        if (!this.parent.system.domainTouched || this.parent.parent?.type !== 'character') return false;
+
+        const matchingDomainCards = this.parent.parent.items.filter(
+            item => !item.system.inVault && item.system.domain === this.parent.system.domain
+        ).length;
+        return matchingDomainCards < this.parent.system.domainTouched;
+    }
+
    /* -------------------------------------------- */

    /**@override */
--- a/module/data/item/weapon.mjs
+++ b/module/data/item/weapon.mjs
@ -110,6 +110,21 @@ export default class DHWeapon extends AttachableItem {
        );
    }

+    /**@inheritdoc */
+    async getDescriptionData() {
+        const baseDescription = this.description;
+        const allFeatures = CONFIG.DH.ITEM.allWeaponFeatures();
+        const features = this.weaponFeatures.map(x => allFeatures[x.value]);
+        if (!features.length) return { prefix: null, value: baseDescription, suffix: null };
+
+        const prefix = await foundry.applications.handlebars.renderTemplate(
+            'systems/daggerheart/templates/sheets/items/weapon/description.hbs',
+            { features }
+        );
+
+        return { prefix, value: baseDescription, suffix: null };
+    }
+
    prepareDerivedData() {
        this.attack.roll.trait = this.rules.attack.roll.trait ?? this.attack.roll.trait;
    }
--- a/module/data/scene/scene.mjs
+++ b/module/data/scene/scene.mjs
@ -1,3 +1,8 @@
+import ForeignDocumentUUIDArrayField from '../fields/foreignDocumentUUIDArrayField.mjs';
+
+/*  Foundry does not add any system data for subtyped Scenes. The data model is therefore used by instantiating a new instance of it for sceneConfigSettings.mjs.
+    Needed dataprep and lifetime hooks are handled in documents/scene.
+*/
 export default class DHScene extends foundry.abstract.DataModel {
    static defineSchema() {
        const fields = foundry.data.fields;
@ -13,7 +18,8 @@ export default class DHScene extends foundry.abstract.DataModel {
                veryClose: new fields.NumberField({ integer: true, label: 'DAGGERHEART.CONFIG.Range.veryClose.name' }),
                close: new fields.NumberField({ integer: true, label: 'DAGGERHEART.CONFIG.Range.close.name' }),
                far: new fields.NumberField({ integer: true, label: 'DAGGERHEART.CONFIG.Range.far.name' })
-            })
+            }),
+            sceneEnvironments: new ForeignDocumentUUIDArrayField({ type: 'Actor', prune: true })
        };
    }
 }
--- a/module/data/settings/Automation.mjs
+++ b/module/data/settings/Automation.mjs
@ -173,6 +173,13 @@ export default class DhAutomation extends foundry.abstract.DataModel {
                        label: 'DAGGERHEART.GENERAL.player.plurial'
                    })
                })
+            }),
+            triggers: new fields.SchemaField({
+                enabled: new fields.BooleanField({
+                    nullable: false,
+                    initial: true,
+                    label: 'DAGGERHEART.SETTINGS.Automation.FIELDS.triggers.enabled.label'
+                })
            })
        };
    }
--- a/module/dice/d20Roll.mjs
+++ b/module/dice/d20Roll.mjs
@ -35,7 +35,9 @@ export default class D20Roll extends DHRoll {

    get isCritical() {
        if (!this.d20._evaluated) return;
-        return this.d20.total >= this.data.system.criticalThreshold;
+
+        const criticalThreshold = this.options.actionType === 'reaction' ? 20 : this.data.system.criticalThreshold;
+        return this.d20.total >= criticalThreshold;
    }

    get hasAdvantage() {
@ -127,15 +129,55 @@ export default class D20Roll extends DHRoll {
        const modifiers = foundry.utils.deepClone(this.options.roll.baseModifiers) ?? [];

        modifiers.push(
-            ...this.getBonus(`roll.${this.options.actionType}`, `${this.options.actionType?.capitalize()} Bonus`)
-        );
-        modifiers.push(
-            ...this.getBonus(`roll.${this.options.roll.type}`, `${this.options.roll.type?.capitalize()} Bonus`)
+            ...this.getBonus(
+                `system.bonuses.roll.${this.options.actionType}`,
+                `${this.options.actionType?.capitalize()} Bonus`
+            )
        );

+        if (this.options.roll.type !== CONFIG.DH.GENERAL.rollTypes.attack.id) {
+            modifiers.push(
+                ...this.getBonus(
+                    `system.bonuses.roll.${this.options.roll.type}`,
+                    `${this.options.roll.type?.capitalize()} Bonus`
+                )
+            );
+        }
+
+        if (
+            this.options.roll.type === CONFIG.DH.GENERAL.rollTypes.attack.id ||
+            (this.options.roll.type === CONFIG.DH.GENERAL.rollTypes.spellcast.id && this.options.hasDamage)
+        ) {
+            modifiers.push(
+                ...this.getBonus(`system.bonuses.roll.attack`, `${this.options.roll.type?.capitalize()} Bonus`)
+            );
+        }
+
        return modifiers;
    }

+    getActionChangeKeys() {
+        const changeKeys = new Set([`system.bonuses.roll.${this.options.actionType}`]);
+
+        if (this.options.roll.type !== CONFIG.DH.GENERAL.rollTypes.attack.id) {
+            changeKeys.add(`system.bonuses.roll.${this.options.roll.type}`);
+        }
+
+        if (
+            this.options.roll.type === CONFIG.DH.GENERAL.rollTypes.attack.id ||
+            (this.options.roll.type === CONFIG.DH.GENERAL.rollTypes.spellcast.id && this.options.hasDamage)
+        ) {
+            changeKeys.add(`system.bonuses.roll.attack`);
+        }
+
+        if (this.options.roll.trait && this.data.traits?.[this.options.roll.trait]) {
+            if (this.options.roll.type !== CONFIG.DH.GENERAL.rollTypes.spellcast.id)
+                changeKeys.add('system.bonuses.roll.trait');
+        }
+
+        return changeKeys;
+    }
+
    static postEvaluate(roll, config = {}) {
        const data = super.postEvaluate(roll, config);
        data.type = config.actionType;
--- a/module/dice/damageRoll.mjs
+++ b/module/dice/damageRoll.mjs
@ -93,7 +93,6 @@ export default class DamageRoll extends DHRoll {
            type = this.options.messageType ?? (this.options.hasHealing ? 'healing' : 'damage'),
            options = part ?? this.options;

-        modifiers.push(...this.getBonus(`${type}`, `${type.capitalize()} Bonus`));
        if (!this.options.hasHealing) {
            options.damageTypes?.forEach(t => {
                modifiers.push(...this.getBonus(`${type}.${t}`, `${t.capitalize()} ${type.capitalize()} Bonus`));
@ -108,6 +107,31 @@ export default class DamageRoll extends DHRoll {
        return modifiers;
    }

+    getActionChangeKeys() {
+        const type = this.options.messageType ?? (this.options.hasHealing ? 'healing' : 'damage');
+        const changeKeys = [];
+
+        for (const roll of this.options.roll) {
+            for (const damageType of roll.damageTypes?.values?.() ?? []) {
+                changeKeys.push(`system.bonuses.${type}.${damageType}`);
+            }
+        }
+
+        const item = this.data.parent?.items?.get(this.options.source.item);
+        if (item) {
+            switch (item.type) {
+                case 'weapon':
+                    if (!this.options.hasHealing)
+                        ['primaryWeapon', 'secondaryWeapon'].forEach(w =>
+                            changeKeys.push(`system.bonuses.damage.${w}`)
+                        );
+                    break;
+            }
+        }
+
+        return changeKeys;
+    }
+
    constructFormula(config) {
        this.options.roll.forEach((part, index) => {
            part.roll = new Roll(Roll.replaceFormulaData(part.formula, config.data));
--- a/module/dice/dhRoll.mjs
+++ b/module/dice/dhRoll.mjs
@ -4,6 +4,7 @@ export default class DHRoll extends Roll {
    baseTerms = [];
    constructor(formula, data = {}, options = {}) {
        super(formula, data, options);
+        options.bonusEffects = this.bonusEffectBuilder();
        if (!this.data || !Object.keys(this.data).length) this.data = options.data;
    }

@ -164,12 +165,18 @@ export default class DHRoll extends Roll {
                new foundry.dice.terms.OperatorTerm({ operator: '+' }),
                ...this.constructor.parse(modifier.join(' + '), this.options.data)
            ];
-        } else {
+        } else if (Number.isNumeric(modifier)) {
            const numTerm = modifier < 0 ? '-' : '+';
            return [
                new foundry.dice.terms.OperatorTerm({ operator: numTerm }),
                new foundry.dice.terms.NumericTerm({ number: Math.abs(modifier) })
            ];
+        } else {
+            const numTerm = modifier < 0 ? '-' : '+';
+            return [
+                new foundry.dice.terms.OperatorTerm({ operator: numTerm }),
+                ...this.constructor.parse(modifier, this.options.data)
+            ];
        }
    }

@ -185,18 +192,20 @@ export default class DHRoll extends Roll {
    }

    getBonus(path, label) {
-        const bonus = foundry.utils.getProperty(this.data.bonuses, path),
-            modifiers = [];
-        if (bonus?.bonus)
-            modifiers.push({
-                label: label,
-                value: bonus?.bonus
-            });
-        if (bonus?.dice?.length)
-            modifiers.push({
-                label: label,
-                value: bonus?.dice
-            });
+        const modifiers = [];
+        for (const effect of Object.values(this.options.bonusEffects)) {
+            if (!effect.selected) continue;
+            for (const change of effect.changes) {
+                if (!change.key.includes(path)) continue;
+                const changeValue = game.system.api.documents.DhActiveEffect.getChangeValue(
+                    this.data,
+                    change,
+                    effect.origEffect
+                );
+                modifiers.push({ label: label, value: changeValue });
+            }
+        }
+
        return modifiers;
    }

@ -235,4 +244,28 @@ export default class DHRoll extends Roll {
    static temporaryModifierBuilder(config) {
        return {};
    }
+
+    bonusEffectBuilder() {
+        const changeKeys = this.getActionChangeKeys();
+        return (
+            this.options.effects?.reduce((acc, effect) => {
+                if (effect.changes.some(x => changeKeys.some(key => x.key.includes(key)))) {
+                    acc[effect.id] = {
+                        id: effect.id,
+                        name: effect.name,
+                        description: effect.description,
+                        changes: effect.changes,
+                        origEffect: effect,
+                        selected: !effect.disabled
+                    };
+                }
+
+                return acc;
+            }, {}) ?? []
+        );
+    }
+
+    getActionChangeKeys() {
+        return [];
+    }
 }
--- a/module/dice/dualityRoll.mjs
+++ b/module/dice/dualityRoll.mjs
@ -130,9 +130,14 @@ export default class DualityRoll extends D20Roll {
            this.terms = [this.terms[0], this.terms[1], this.terms[2]];
            return;
        }
-        this.terms[0] = new foundry.dice.terms.Die({ faces: 12 });
+
+        this.terms[0] = new foundry.dice.terms.Die({
+            faces: this.data.rules.dualityRoll?.defaultHopeDice ?? 12
+        });
        this.terms[1] = new foundry.dice.terms.OperatorTerm({ operator: '+' });
-        this.terms[2] = new foundry.dice.terms.Die({ faces: 12 });
+        this.terms[2] = new foundry.dice.terms.Die({
+            faces: this.data.rules.dualityRoll?.defaultFearDice ?? 12
+        });
    }

    applyAdvantage() {
@ -173,6 +178,34 @@ export default class DualityRoll extends D20Roll {
        return modifiers;
    }

+    getActionChangeKeys() {
+        const changeKeys = new Set([`system.bonuses.roll.${this.options.actionType}`]);
+
+        if (this.options.roll.type !== CONFIG.DH.GENERAL.rollTypes.attack.id) {
+            changeKeys.add(`system.bonuses.roll.${this.options.roll.type}`);
+        }
+
+        if (
+            this.options.roll.type === CONFIG.DH.GENERAL.rollTypes.attack.id ||
+            (this.options.roll.type === CONFIG.DH.GENERAL.rollTypes.spellcast.id && this.options.hasDamage)
+        ) {
+            changeKeys.add(`system.bonuses.roll.attack`);
+        }
+
+        if (this.options.roll.trait && this.data.traits?.[this.options.roll.trait]) {
+            if (this.options.roll.type !== CONFIG.DH.GENERAL.rollTypes.spellcast.id)
+                changeKeys.add('system.bonuses.roll.trait');
+        }
+
+        const weapons = ['primaryWeapon', 'secondaryWeapon'];
+        weapons.forEach(w => {
+            if (this.options.source.item && this.options.source.item === this.data[w]?.id)
+                changeKeys.add(`system.bonuses.roll.${w}`);
+        });
+
+        return changeKeys;
+    }
+
    static async buildEvaluate(roll, config = {}, message = {}) {
        await super.buildEvaluate(roll, config, message);

@ -224,6 +257,32 @@ export default class DualityRoll extends D20Roll {
        await super.buildPost(roll, config, message);

        await DualityRoll.dualityUpdate(config);
+        await DualityRoll.handleTriggers(roll, config);
+    }
+
+    static async handleTriggers(roll, config) {
+        if (!config.source?.actor) return;
+
+        const updates = [];
+        const dualityUpdates = await game.system.registeredTriggers.runTrigger(
+            CONFIG.DH.TRIGGER.triggers.dualityRoll.id,
+            roll.data?.parent,
+            roll,
+            roll.data?.parent
+        );
+        if (dualityUpdates?.length) updates.push(...dualityUpdates);
+
+        if (config.roll.result.duality === -1) {
+            const fearUpdates = await game.system.registeredTriggers.runTrigger(
+                CONFIG.DH.TRIGGER.triggers.fearRoll.id,
+                roll.data?.parent,
+                roll,
+                roll.data?.parent
+            );
+            if (fearUpdates?.length) updates.push(...fearUpdates);
+        }
+
+        config.resourceUpdates.addResources(updates);
    }

    static async addDualityResourceUpdates(config) {
@ -298,7 +357,7 @@ export default class DualityRoll extends D20Roll {

        if (looseSpotlight && game.combat?.active) {
            const currentCombatant = game.combat.combatants.get(game.combat.current?.combatantId);
-            if (currentCombatant?.actorId == actor.id) ui.combat.setCombatantSpotlight(currentCombatant.id);
+            if (currentCombatant?.actorId == config.data.id) ui.combat.setCombatantSpotlight(currentCombatant.id);
        }
    }

--- a/module/documents/_module.mjs
+++ b/module/documents/_module.mjs
@ -8,3 +8,4 @@ export { default as DhScene } from './scene.mjs';
 export { default as DhToken } from './token.mjs';
 export { default as DhTooltipManager } from './tooltipManager.mjs';
 export { default as DhTemplateManager } from './templateManager.mjs';
+export { default as DhTokenManager } from './tokenManager.mjs';
--- a/module/documents/activeEffect.mjs
+++ b/module/documents/activeEffect.mjs
@ -20,7 +20,10 @@ export default class DhActiveEffect extends foundry.documents.ActiveEffect {
        }

        if (this.parent?.type === 'domainCard') {
-            return this.parent.system.inVault;
+            const isVaultSupressed = this.parent.system.isVaultSupressed;
+            const domainTouchedSupressed = this.parent.system.isDomainTouchedSuppressed;
+
+            return isVaultSupressed || domainTouchedSupressed;
        }

        return super.isSuppressed;
@ -106,23 +109,29 @@ export default class DhActiveEffect extends foundry.documents.ActiveEffect {

    /**@inheritdoc*/
    static applyField(model, change, field) {
-        const isOriginTarget = change.value.toLowerCase().includes('origin.@');
+        change.value = DhActiveEffect.getChangeValue(model, change, change.effect);
+        super.applyField(model, change, field);
+    }
+
+    /** */
+    static getChangeValue(model, change, effect) {
+        let value = change.value;
+        const isOriginTarget = value.toLowerCase().includes('origin.@');
        let parseModel = model;
-        if (isOriginTarget && change.effect.origin) {
-            change.value = change.value.replaceAll(/origin\.@/gi, '@');
+        if (isOriginTarget && effect.origin) {
+            value = change.value.replaceAll(/origin\.@/gi, '@');
            try {
-                const effect = foundry.utils.fromUuidSync(change.effect.origin);
+                const originEffect = foundry.utils.fromUuidSync(effect.origin);
                const doc =
-                    effect.parent?.parent instanceof game.system.api.documents.DhpActor
-                        ? effect.parent
-                        : effect.parent.parent;
+                    originEffect.parent?.parent instanceof game.system.api.documents.DhpActor
+                        ? originEffect.parent
+                        : originEffect.parent.parent;
                if (doc) parseModel = doc;
            } catch (_) {}
        }

-        const evalValue = this.effectSafeEval(itemAbleRollParse(change.value, parseModel, change.effect.parent));
-        change.value = evalValue ?? change.value;
-        super.applyField(model, change, field);
+        const evalValue = this.effectSafeEval(itemAbleRollParse(value, parseModel, effect.parent));
+        return evalValue ?? value;
    }

    /**
--- a/module/documents/actor.mjs
+++ b/module/documents/actor.mjs
@ -1,7 +1,7 @@
 import { emitAsGM, GMUpdateEvent } from '../systemRegistration/socket.mjs';
 import { LevelOptionType } from '../data/levelTier.mjs';
 import DHFeature from '../data/item/feature.mjs';
-import { createScrollText, damageKeyToNumber } from '../helpers/utils.mjs';
+import { createScrollText, damageKeyToNumber, getDamageKey } from '../helpers/utils.mjs';
 import DhCompanionLevelUp from '../applications/levelup/companionLevelup.mjs';
 import { ResourceUpdateMap } from '../data/action/baseAction.mjs';

@ -543,6 +543,7 @@ export default class DhpActor extends Actor {
        /* system gets repeated infinately which causes issues when trying to use the data for document creation */
        delete rollData.system;

+        rollData.id = this.id;
        rollData.name = this.name;
        rollData.system = this.system.getRollData();
        rollData.prof = this.system.proficiency ?? 1;
@ -630,6 +631,32 @@ export default class DhpActor extends Actor {
                    }
                }
            }
+            if (this.type === 'adversary') {
+                const reducedSeverity = hpDamage.damageTypes.reduce((value, curr) => {
+                    return Math.max(this.system.rules.damageReduction.reduceSeverity[curr], value);
+                }, 0);
+                hpDamage.value = Math.max(hpDamage.value - reducedSeverity, 0);
+
+                if (
+                    hpDamage.value &&
+                    this.system.rules.damageReduction.thresholdImmunities[getDamageKey(hpDamage.value)]
+                ) {
+                    hpDamage.value -= 1;
+                }
+            }
+        }
+
+        const results = await game.system.registeredTriggers.runTrigger(
+            CONFIG.DH.TRIGGER.triggers.postDamageReduction.id,
+            this,
+            updates,
+            this
+        );
+
+        if (results?.length) {
+            const resourceMap = new ResourceUpdateMap(results[0].originActor);
+            for (var result of results) resourceMap.addResources(result.updates);
+            resourceMap.updateResources();
        }

        updates.forEach(
--- a/module/documents/chatMessage.mjs
+++ b/module/documents/chatMessage.mjs
@ -157,7 +157,10 @@ export default class DhpChatMessage extends foundry.documents.ChatMessage {
        event.stopPropagation();
        const config = foundry.utils.deepClone(this.system);
        config.event = event;
-        await this.system.action?.workflow.get('damage')?.execute(config, this._id, true);
+        if (this.system.action) {
+            await this.system.action.addEffects(config);
+            await this.system.action.workflow.get('damage')?.execute(config, this._id, true);
+        }

        Hooks.callAll(socketEvent.Refresh, { refreshType: RefreshType.TagTeamRoll });
        await game.socket.emit(`system.${CONFIG.DH.id}`, {
--- a/module/documents/item.mjs
+++ b/module/documents/item.mjs
@ -31,7 +31,7 @@ export default class DHItem extends foundry.documents.Item {
    static async createDocuments(sources, operation) {
        // Ensure that items being created are valid to the actor its being added to
        const actor = operation.parent;
-        sources = actor?.system?.isItemValid ? sources.filter((s) => actor.system.isItemValid(s)) : sources;
+        sources = actor?.system?.isItemValid ? sources.filter(s => actor.system.isItemValid(s)) : sources;
        return super.createDocuments(sources, operation);
    }

@ -146,6 +146,16 @@ export default class DHItem extends foundry.documents.Item {
    /* -------------------------------------------- */

    async use(event) {
+        /* DomainCard check. Can be expanded or made neater */
+        if (this.system.isDomainTouchedSuppressed) {
+            return ui.notifications.warn(
+                game.i18n.format('DAGGERHEART.UI.Notifications.domainTouchRequirement', {
+                    nr: this.domainTouched,
+                    domain: game.i18n.localize(CONFIG.DH.DOMAIN.allDomains()[this.domain].label)
+                })
+            );
+        }
+
        const actions = new Set(this.system.actionsList);
        if (actions?.size) {
            let action = actions.first();
--- a/module/documents/scene.mjs
+++ b/module/documents/scene.mjs
@ -37,4 +37,30 @@ export default class DhScene extends Scene {
        this.#sizeSyncBatch.clear();
        this.updateEmbeddedDocuments('Token', entries, { animation: { movementSpeed: 1.5 } });
    }, 0);
+
+    prepareBaseData() {
+        super.prepareBaseData();
+
+        if (this instanceof game.system.api.documents.DhScene) {
+            const system = new game.system.api.data.scenes.DHScene(this.flags.daggerheart);
+
+            // Register this scene to all environements
+            for (const environment of system.sceneEnvironments) {
+                environment.system.scenes?.add(this);
+            }
+        }
+    }
+
+    _onDelete(options, userId) {
+        super._onDelete(options, userId);
+
+        if (this instanceof game.system.api.documents.DhScene) {
+            const system = new game.system.api.data.scenes.DHScene(this.flags.daggerheart);
+
+            // Clear this scene from all environments that aren't deleted
+            for (const environment of system.sceneEnvironments) {
+                environment?.system?.scenes?.delete(this);
+            }
+        }
+    }
 }
--- a/module/documents/token.mjs
+++ b/module/documents/token.mjs
@ -83,7 +83,7 @@ export default class DHToken extends CONFIG.Token.documentClass {
        if (combat?.system?.battleToggles?.length) {
            await combat.toggleModifierEffects(
                true,
-                tokens.map(x => x.actor)
+                tokens.filter(x => x.actor).map(x => x.actor)
            );
        }
        super.createCombatants(tokens, combat ?? {});
@ -95,7 +95,7 @@ export default class DHToken extends CONFIG.Token.documentClass {
        if (combat?.system?.battleToggles?.length) {
            await combat.toggleModifierEffects(
                false,
-                tokens.map(x => x.actor)
+                tokens.filter(x => x.actor).map(x => x.actor)
            );
        }
        super.deleteCombatants(tokens, combat ?? {});
--- a/module/documents/tokenManager.mjs
+++ b/module/documents/tokenManager.mjs
@ -0,0 +1,104 @@
+/**
+ * A singleton class that handles preview tokens.
+ */
+
+export default class DhTokenManager {
+    #activePreview;
+    #actor;
+    #resolve;
+
+    /**
+     * Create a template preview, deactivating any existing ones.
+     * @param {object} data
+     */
+    async createPreview(actor, tokenData) {
+        this.#actor = actor;
+        const token = await canvas.tokens._createPreview(
+            {
+                ...actor.prototypeToken,
+                displayName: 50,
+                ...tokenData
+            },
+            { renderSheet: false, actor }
+        );
+
+        this.#activePreview = {
+            document: token.document,
+            object: token,
+            origin: { x: token.document.x, y: token.document.y }
+        };
+
+        this.#activePreview.events = {
+            contextmenu: this.#cancelTemplate.bind(this),
+            mousedown: this.#confirmTemplate.bind(this),
+            mousemove: this.#onDragMouseMove.bind(this)
+        };
+
+        canvas.stage.on('mousemove', this.#activePreview.events.mousemove);
+        canvas.stage.on('mousedown', this.#activePreview.events.mousedown);
+        canvas.app.view.addEventListener('contextmenu', this.#activePreview.events.contextmenu);
+    }
+
+    /* Currently intended for using as a preview of where to create a token. (note the flag) */
+    async createPreviewAsync(actor, tokenData = {}) {
+        return new Promise(resolve => {
+            this.#resolve = resolve;
+            this.createPreview(actor, { ...tokenData, flags: { daggerheart: { createPlacement: true } } });
+        });
+    }
+
+    /**
+     * Handles the movement of the token preview on mousedrag.
+     * @param {mousemove Event} event
+     */
+    #onDragMouseMove(event) {
+        event.stopPropagation();
+        const { moveTime, object } = this.#activePreview;
+        const update = {};
+
+        const now = Date.now();
+        if (now - (moveTime || 0) <= 16) return;
+        this.#activePreview.moveTime = now;
+
+        let cursor = event.getLocalPosition(canvas.templates);
+
+        Object.assign(update, canvas.grid.getTopLeftPoint(cursor));
+
+        object.document.updateSource(update);
+        object.renderFlags.set({ refresh: true });
+    }
+
+    /**
+     * Cancels the preview token on right-click.
+     * @param {contextmenu Event} event
+     */
+    #cancelTemplate(_event, resolved) {
+        const { mousemove, mousedown, contextmenu } = this.#activePreview.events;
+        this.#activePreview.object.destroy();
+
+        canvas.stage.off('mousemove', mousemove);
+        canvas.stage.off('mousedown', mousedown);
+        canvas.app.view.removeEventListener('contextmenu', contextmenu);
+        if (this.#resolve && !resolved) this.#resolve(false);
+    }
+
+    /**
+     * Creates a real Actor and token at the preview location and cancels the preview.
+     * @param {click Event} event
+     */
+    async #confirmTemplate(event) {
+        event.stopPropagation();
+        this.#cancelTemplate(event, true);
+
+        const actor = this.#actor.inCompendium
+            ? await game.system.api.documents.DhpActor.create(this.#actor.toObject())
+            : this.#actor;
+        const tokenData = await actor.getTokenDocument();
+        const result = await canvas.scene.createEmbeddedDocuments('Token', [
+            { ...tokenData, x: this.#activePreview.document.x, y: this.#activePreview.document.y }
+        ]);
+
+        this.#activePreview = undefined;
+        if (this.#resolve && result.length) this.#resolve(result[0]);
+    }
+}
--- a/module/documents/tooltipManager.mjs
+++ b/module/documents/tooltipManager.mjs
@ -67,7 +67,7 @@ export default class DhTooltipManager extends foundry.helpers.interaction.Toolti
            if (item) {
                const isAction = item instanceof game.system.api.models.actions.actionsTypes.base;
                const isEffect = item instanceof ActiveEffect;
-                await this.enrichText(item, isAction || isEffect);
+                await this.enrichText(item);

                const type = isAction ? 'action' : isEffect ? 'effect' : item.type;
                html = await foundry.applications.handlebars.renderTemplate(
@ -202,10 +202,20 @@ export default class DhTooltipManager extends foundry.helpers.interaction.Toolti
        }
    }

-    async enrichText(item, flatStructure) {
+    async enrichText(item) {
        const { TextEditor } = foundry.applications.ux;
+
+        if (item.system?.metadata?.hasDescription) {
+            const enrichedValue =
+                (await item.system?.getEnrichedDescription?.()) ??
+                (await TextEditor.enrichHTML(item.system.description));
+            foundry.utils.setProperty(item, 'system.enrichedDescription', enrichedValue);
+        } else if (item.description) {
+            const enrichedValue = await TextEditor.enrichHTML(item.description);
+            foundry.utils.setProperty(item, 'enrichedDescription', enrichedValue);
+        }
+
        const enrichPaths = [
-            { path: flatStructure ? '' : 'system', name: 'description' },
            { path: 'system', name: 'features' },
            { path: 'system', name: 'actions' },
            { path: 'system', name: 'customActions' }
@ -220,12 +230,15 @@ export default class DhTooltipManager extends foundry.helpers.interaction.Toolti
                for (const [index, itemValue] of pathValue.entries()) {
                    const itemIsAction = itemValue instanceof game.system.api.models.actions.actionsTypes.base;
                    const value = itemIsAction || !itemValue?.item ? itemValue : itemValue.item;
-                    const enrichedValue = await TextEditor.enrichHTML(value.system?.description ?? value.description);
+                    const enrichedValue =
+                        (await value.system?.getEnrichedDescription?.()) ??
+                        (await TextEditor.enrichHTML(value.system?.description ?? value.description));
                    if (itemIsAction) value.enrichedDescription = enrichedValue;
                    else foundry.utils.setProperty(item, `${basePath}.${index}.enrichedDescription`, enrichedValue);
                }
            } else {
-                const enrichedValue = await TextEditor.enrichHTML(pathValue);
+                const enrichedValue =
+                    (await item.system?.getEnrichedDescription?.()) ?? (await TextEditor.enrichHTML(pathValue));
                foundry.utils.setProperty(
                    item,
                    `${data.path ? `${data.path}.` : ''}enriched${data.name.capitalize()}`,
@ -262,7 +275,7 @@ export default class DhTooltipManager extends foundry.helpers.interaction.Toolti
        const combat = game.combats.get(combatId);
        const adversaries =
            combat.turns?.filter(x => x.actor?.isNPC)?.map(x => ({ ...x.actor, type: x.actor.system.type })) ?? [];
-        const characters = combat.turns?.filter(x => !x.isNPC) ?? [];
+        const characters = combat.turns?.filter(x => !x.isNPC && x.actor) ?? [];

        const nrCharacters = characters.length;
        const currentBP = AdversaryBPPerEncounter(adversaries, characters);
@ -272,7 +285,7 @@ export default class DhTooltipManager extends foundry.helpers.interaction.Toolti
        );

        const categories = combat.combatants.reduce((acc, combatant) => {
-            if (combatant.actor.type === 'adversary') {
+            if (combatant.actor?.type === 'adversary') {
                const keyData = Object.keys(acc).reduce((identifiers, categoryKey) => {
                    if (identifiers) return identifiers;
                    const category = acc[categoryKey];
@ -352,7 +365,7 @@ export default class DhTooltipManager extends foundry.helpers.interaction.Toolti

        await combat.toggleModifierEffects(
            event.target.checked,
-            combat.combatants.filter(x => x.actor.type === 'adversary').map(x => x.actor),
+            combat.combatants.filter(x => x.actor?.type === 'adversary').map(x => x.actor),
            category,
            grouping
        );
--- a/module/enrichers/DualityRollEnricher.mjs
+++ b/module/enrichers/DualityRollEnricher.mjs
@ -86,9 +86,9 @@ export const enrichedDualityRoll = async (
    const config = {
        event: event ?? {},
        title: title,
+        headerTitle: label,
        roll: {
            trait: traitValue && target ? traitValue : null,
-            label: label,
            difficulty: difficulty,
            advantage,
            type: reaction ? 'reaction' : null
@ -101,7 +101,7 @@ export const enrichedDualityRoll = async (
        await target.diceRoll(config);
    } else {
        // For no target, call DualityRoll directly with basic data
-        config.data = { experiences: {}, traits: {} };
+        config.data = { experiences: {}, traits: {}, rules: {} };
        config.source = { actor: null };
        await CONFIG.Dice.daggerheart.DualityRoll.build(config);
    }
--- a/module/helpers/utils.mjs
+++ b/module/helpers/utils.mjs
@ -119,7 +119,7 @@ export const tagifyElement = (element, baseOptions, onChange, tagifyOptions = {}
                            spellcheck='false'
                            tabIndex="${this.settings.a11y.focusableTags ? 0 : -1}"
                            class="${this.settings.classNames.tag} ${tagData.class ? tagData.class : ''}"
-                            data-tooltip="${tagData.description || tagData.name}"
+                            data-tooltip="${tagData.description ? htmlToText(tagData.description) : tagData.name}"
                            ${this.getAttributes(tagData)}> 
                    <x class="${this.settings.classNames.tagX}" role='button' aria-label='remove tag'></x>
                    <div>
@ -474,3 +474,10 @@ export async function getCritDamageBonus(formula) {
    const critRoll = new Roll(formula);
    return critRoll.dice.reduce((acc, dice) => acc + dice.faces * dice.number, 0);
 }
+
+export function htmlToText(html) {
+    var tempDivElement = document.createElement('div');
+    tempDivElement.innerHTML = html;
+
+    return tempDivElement.textContent || tempDivElement.innerText || '';
+}
--- a/module/systemRegistration/handlebars.mjs
+++ b/module/systemRegistration/handlebars.mjs
@ -32,6 +32,7 @@ export const preloadHandlebarsTemplates = async function () {
        'systems/daggerheart/templates/actionTypes/effect.hbs',
        'systems/daggerheart/templates/actionTypes/beastform.hbs',
        'systems/daggerheart/templates/actionTypes/countdown.hbs',
+        'systems/daggerheart/templates/actionTypes/summon.hbs',
        'systems/daggerheart/templates/settings/components/settings-item-line.hbs',
        'systems/daggerheart/templates/ui/tooltip/parts/tooltipChips.hbs',
        'systems/daggerheart/templates/ui/tooltip/parts/tooltipTags.hbs',
--- a/module/systemRegistration/socket.mjs
+++ b/module/systemRegistration/socket.mjs
@ -37,7 +37,8 @@ export const GMUpdateEvent = {
 export const RefreshType = {
    Countdown: 'DhCoundownRefresh',
    TagTeamRoll: 'DhTagTeamRollRefresh',
-    EffectsDisplay: 'DhEffectsDisplayRefresh'
+    EffectsDisplay: 'DhEffectsDisplayRefresh',
+    Scene: 'DhSceneRefresh'
 };

 export const registerSocketHooks = () => {
--- a/src/packs/adversaries/adversary_Arch_Necromancer_WPEOIGfclNJxWb87.json
+++ b/src/packs/adversaries/adversary_Arch_Necromancer_WPEOIGfclNJxWb87.json
@ -533,33 +533,31 @@
        "description": "<p><strong>Spend a Fear</strong> to summon a @UUID[Compendium.daggerheart.adversaries.Actor.YhJrP7rTBiRdX5Fp]{Zombie Legion}, which appears at Close range and immediately takes the spotlight.</p>",
        "resource": null,
        "actions": {
-          "gZg3AkzCYUTExjE6": {
-            "type": "effect",
-            "_id": "gZg3AkzCYUTExjE6",
+          "qSuWxC8xQOhnbBx9": {
+            "type": "summon",
+            "_id": "qSuWxC8xQOhnbBx9",
            "systemPath": "actions",
+            "baseAction": false,
            "description": "",
            "chatDisplay": true,
+            "originItem": {
+              "type": "itemCollection"
+            },
            "actionType": "action",
-            "cost": [
-              {
-                "scalable": false,
-                "key": "fear",
-                "value": 1,
-                "step": null
-              }
-            ],
+            "cost": [],
            "uses": {
              "value": null,
              "max": "",
-              "recovery": null
-            },
-            "effects": [],
-            "target": {
-              "type": "any",
-              "amount": null
+              "recovery": null,
+              "consumeOnSuccess": false
            },
+            "summon": [
+              {
+                "actorUUID": "Compendium.daggerheart.adversaries.Actor.YhJrP7rTBiRdX5Fp",
+                "count": "1"
+              }
+            ],
            "name": "Spend Fear",
-            "img": "icons/magic/death/undead-zombie-grave-green.webp",
            "range": ""
          }
        },
--- a/src/packs/adversaries/adversary_Demon_of_Avarice_pnyjIGxxvurcWmTv.json
+++ b/src/packs/adversaries/adversary_Demon_of_Avarice_pnyjIGxxvurcWmTv.json
@ -284,7 +284,7 @@
              "key": "system.bonuses.roll.attack.bonus",
              "mode": 2,
              "value": "ITEM.@system.resource.value",
-              "priority": null
+              "priority": 21
            }
          ],
          "disabled": false,
--- a/src/packs/adversaries/adversary_Demon_of_Despair_kE4dfhqmIQpNd44e.json
+++ b/src/packs/adversaries/adversary_Demon_of_Despair_kE4dfhqmIQpNd44e.json
@ -312,7 +312,14 @@
              "range": "melee"
            }
          },
-          "changes": [],
+          "changes": [
+            {
+              "key": "system.rules.dualityRoll.defaultHopeDice",
+              "mode": 5,
+              "value": "d8",
+              "priority": null
+            }
+          ],
          "disabled": false,
          "duration": {
            "startTime": null,
--- a/src/packs/adversaries/adversary_Demon_of_Wrath_5lphJAgzoqZI3VoG.json
+++ b/src/packs/adversaries/adversary_Demon_of_Wrath_5lphJAgzoqZI3VoG.json
@ -256,34 +256,45 @@
        "description": "<p><strong>Spend a Fear</strong> to boil the blood of all PCs within Far range. They use a d20 as their Fear Die until the end of the scene.</p><p>@Template[type:emanation|range:f]</p>",
        "resource": null,
        "actions": {
-          "V142qYppCGJn8OiN": {
+          "jKvzbQT0vp66DDOH": {
            "type": "effect",
-            "_id": "V142qYppCGJn8OiN",
+            "_id": "jKvzbQT0vp66DDOH",
            "systemPath": "actions",
+            "baseAction": false,
            "description": "",
            "chatDisplay": true,
+            "originItem": {
+              "type": "itemCollection"
+            },
            "actionType": "action",
            "cost": [
              {
                "scalable": false,
                "key": "fear",
                "value": 1,
-                "step": null
+                "itemId": null,
+                "step": null,
+                "consumeOnSuccess": false
              }
            ],
            "uses": {
              "value": null,
              "max": "",
-              "recovery": null
+              "recovery": null,
+              "consumeOnSuccess": false
            },
-            "effects": [],
+            "effects": [
+              {
+                "_id": "gFeHLGgeRoDdd3VG",
+                "onSave": false
+              }
+            ],
            "target": {
-              "type": "self",
+              "type": "hostile",
              "amount": null
            },
            "name": "Spend Fear",
-            "img": "icons/skills/melee/maneuver-greatsword-yellow.webp",
-            "range": ""
+            "range": "far"
          }
        },
        "originItemType": null,
@ -292,7 +303,51 @@
      },
      "_id": "a33PW8UkziliowlR",
      "img": "icons/skills/melee/maneuver-greatsword-yellow.webp",
-      "effects": [],
+      "effects": [
+        {
+          "name": "Battle Lust",
+          "img": "icons/skills/melee/maneuver-greatsword-yellow.webp",
+          "origin": "Compendium.daggerheart.adversaries.Actor.5lphJAgzoqZI3VoG.Item.a33PW8UkziliowlR",
+          "transfer": false,
+          "_id": "gFeHLGgeRoDdd3VG",
+          "type": "base",
+          "system": {
+            "rangeDependence": {
+              "enabled": false,
+              "type": "withinRange",
+              "target": "hostile",
+              "range": "melee"
+            }
+          },
+          "changes": [
+            {
+              "key": "system.rules.dualityRoll.defaultFearDice",
+              "mode": 5,
+              "value": "d20",
+              "priority": null
+            }
+          ],
+          "disabled": false,
+          "duration": {
+            "startTime": null,
+            "combat": null,
+            "seconds": null,
+            "rounds": null,
+            "turns": null,
+            "startRound": null,
+            "startTurn": null
+          },
+          "description": "<p>You use a d20 as your Fear Die until the end of the scene.</p>",
+          "tint": "#ffffff",
+          "statuses": [],
+          "sort": 0,
+          "flags": {},
+          "_stats": {
+            "compendiumSource": null
+          },
+          "_key": "!actors.items.effects!5lphJAgzoqZI3VoG.a33PW8UkziliowlR.gFeHLGgeRoDdd3VG"
+        }
+      ],
      "folder": null,
      "sort": 0,
      "ownership": {
@ -457,11 +512,12 @@
            "img": "icons/creatures/unholy/demon-fire-horned-clawed.webp",
            "range": ""
          },
-          "7G6uWlFEeOLsJIWY": {
-            "type": "effect",
-            "_id": "7G6uWlFEeOLsJIWY",
+          "FlE6i0tbKEguF9wz": {
+            "type": "summon",
+            "_id": "FlE6i0tbKEguF9wz",
            "systemPath": "actions",
-            "description": "<p>Summon [[/r 1d4]]@UUID[Compendium.daggerheart.adversaries.Actor.3tqCjDwJAQ7JKqMb]{Minor Demons}, who appear at Close range.</p>",
+            "baseAction": false,
+            "description": "",
            "chatDisplay": true,
            "originItem": {
              "type": "itemCollection"
@ -474,13 +530,13 @@
              "recovery": null,
              "consumeOnSuccess": false
            },
-            "effects": [],
-            "target": {
-              "type": "any",
-              "amount": null
-            },
+            "summon": [
+              {
+                "actorUUID": "Compendium.daggerheart.adversaries.Actor.3tqCjDwJAQ7JKqMb",
+                "count": "1d4"
+              }
+            ],
            "name": "Summon",
-            "img": "icons/creatures/unholy/demon-fire-horned-clawed.webp",
            "range": ""
          }
        },
--- a/src/packs/adversaries/adversary_Dryad_wR7cFKrHvRzbzhBT.json
+++ b/src/packs/adversaries/adversary_Dryad_wR7cFKrHvRzbzhBT.json
@ -363,33 +363,31 @@
        "description": "<p><strong>Spend a Fear</strong> to grow three @UUID[Compendium.daggerheart.adversaries.Actor.o63nS0k3wHu6EgKP]{Treant Sapling Minions}, who appear at Close range and immediately take the spotlight.</p>",
        "resource": null,
        "actions": {
-          "84Q2b0zIY9c7Yhho": {
-            "type": "effect",
-            "_id": "84Q2b0zIY9c7Yhho",
+          "R84DdS0OIx2cUt1w": {
+            "type": "summon",
+            "_id": "R84DdS0OIx2cUt1w",
            "systemPath": "actions",
+            "baseAction": false,
            "description": "",
            "chatDisplay": true,
+            "originItem": {
+              "type": "itemCollection"
+            },
            "actionType": "action",
-            "cost": [
-              {
-                "scalable": false,
-                "key": "fear",
-                "value": 1,
-                "step": null
-              }
-            ],
+            "cost": [],
            "uses": {
              "value": null,
              "max": "",
-              "recovery": null
-            },
-            "effects": [],
-            "target": {
-              "type": "self",
-              "amount": null
+              "recovery": null,
+              "consumeOnSuccess": false
            },
+            "summon": [
+              {
+                "actorUUID": "Compendium.daggerheart.adversaries.Actor.o63nS0k3wHu6EgKP",
+                "count": "3"
+              }
+            ],
            "name": "Spend Fear",
-            "img": "icons/magic/unholy/orb-hands-pink.webp",
            "range": ""
          }
        },
--- a/src/packs/adversaries/adversary_Green_Ooze_SHXedd9zZPVfUgUa.json
+++ b/src/packs/adversaries/adversary_Green_Ooze_SHXedd9zZPVfUgUa.json
@ -510,34 +510,41 @@
        "description": "<p>When the @Lookup[@name] has 3 or more HP marked, you can <strong>spend a Fear</strong> to split them into two @UUID[Compendium.daggerheart.adversaries.Actor.aLkLFuVoKz2NLoBK]{Tiny Green Oozes} (with no marked HP or Stress). Immediately spotlight both of them.</p>",
        "resource": null,
        "actions": {
-          "s5mLw6DRGd76MLcC": {
-            "type": "effect",
-            "_id": "s5mLw6DRGd76MLcC",
+          "J8U7dw3cDSsEirr5": {
+            "type": "summon",
+            "_id": "J8U7dw3cDSsEirr5",
            "systemPath": "actions",
+            "baseAction": false,
            "description": "",
            "chatDisplay": true,
+            "originItem": {
+              "type": "itemCollection"
+            },
            "actionType": "action",
            "cost": [
              {
                "scalable": false,
                "key": "fear",
                "value": 1,
-                "step": null
+                "itemId": null,
+                "step": null,
+                "consumeOnSuccess": false
              }
            ],
            "uses": {
              "value": null,
              "max": "",
-              "recovery": null
-            },
-            "effects": [],
-            "target": {
-              "type": "self",
-              "amount": null
+              "recovery": null,
+              "consumeOnSuccess": false
            },
+            "summon": [
+              {
+                "actorUUID": "Compendium.daggerheart.adversaries.Actor.aLkLFuVoKz2NLoBK",
+                "count": "2"
+              }
+            ],
            "name": "Spend Fear",
-            "img": "icons/creatures/slimes/slime-movement-pseudopods-green.webp",
-            "range": ""
+            "range": "self"
          }
        },
        "originItemType": null,
--- a/src/packs/adversaries/adversary_Head_Vampire_i2UNbRvgyoSs07M6.json
+++ b/src/packs/adversaries/adversary_Head_Vampire_i2UNbRvgyoSs07M6.json
@ -474,33 +474,31 @@
        "description": "<p><strong>Spend 2 Fear</strong> to summon [[/r 1d4]] @UUID[Compendium.daggerheart.adversaries.Actor.WWyUp6Mxl1S3KYUG]{Vampires}, who appear at Far range and immediately take the spotlight.</p>",
        "resource": null,
        "actions": {
-          "5Q6RMUTiauKw0tDj": {
-            "type": "effect",
-            "_id": "5Q6RMUTiauKw0tDj",
+          "jGFOnU6PNdWU6iF4": {
+            "type": "summon",
+            "_id": "jGFOnU6PNdWU6iF4",
            "systemPath": "actions",
+            "baseAction": false,
            "description": "",
            "chatDisplay": true,
+            "originItem": {
+              "type": "itemCollection"
+            },
            "actionType": "action",
-            "cost": [
-              {
-                "scalable": false,
-                "key": "fear",
-                "value": 2,
-                "step": null
-              }
-            ],
+            "cost": [],
            "uses": {
              "value": null,
              "max": "",
-              "recovery": null
+              "recovery": null,
+              "consumeOnSuccess": false
            },
-            "effects": [],
-            "target": {
-              "type": "any",
-              "amount": null
-            },
-            "name": "Summon Vampires",
-            "img": "icons/creatures/mammals/bat-giant-tattered-purple.webp",
+            "summon": [
+              {
+                "actorUUID": "Compendium.daggerheart.adversaries.Actor.WWyUp6Mxl1S3KYUG",
+                "count": "1d4"
+              }
+            ],
+            "name": "Spend Fear",
            "range": ""
          }
        },
--- a/src/packs/adversaries/adversary_Huge_Green_Ooze_6hbqmxDXFOzZJDk4.json
+++ b/src/packs/adversaries/adversary_Huge_Green_Ooze_6hbqmxDXFOzZJDk4.json
@ -479,33 +479,31 @@
        "description": "<p>When the @Lookup[@name] has 4 or more HP marked, you can <strong>spend a Fear</strong> to split them into two @UUID[Compendium.daggerheart.adversaries.Actor.SHXedd9zZPVfUgUa]{Green Oozes}(with no marked HP or Stress). Immediately spotlight both of them.</p>",
        "resource": null,
        "actions": {
-          "iQsYAqpUFvJslRDr": {
-            "type": "effect",
-            "_id": "iQsYAqpUFvJslRDr",
+          "aeRdkiRsDNagTKhp": {
+            "type": "summon",
+            "_id": "aeRdkiRsDNagTKhp",
            "systemPath": "actions",
+            "baseAction": false,
            "description": "",
            "chatDisplay": true,
+            "originItem": {
+              "type": "itemCollection"
+            },
            "actionType": "action",
-            "cost": [
-              {
-                "scalable": false,
-                "key": "fear",
-                "value": 1,
-                "step": null
-              }
-            ],
+            "cost": [],
            "uses": {
              "value": null,
              "max": "",
-              "recovery": null
-            },
-            "effects": [],
-            "target": {
-              "type": "any",
-              "amount": null
+              "recovery": null,
+              "consumeOnSuccess": false
            },
+            "summon": [
+              {
+                "actorUUID": "Compendium.daggerheart.adversaries.Actor.SHXedd9zZPVfUgUa",
+                "count": "2"
+              }
+            ],
            "name": "Spend Fear",
-            "img": "icons/creatures/slimes/slime-movement-pseudopods-green.webp",
            "range": ""
          }
        },
--- a/src/packs/adversaries/adversary_Jagged_Knife_Lieutenant_aTljstqteGoLpCBq.json
+++ b/src/packs/adversaries/adversary_Jagged_Knife_Lieutenant_aTljstqteGoLpCBq.json
@ -287,7 +287,35 @@
      "system": {
        "description": "<p>Summon three @Compendium[daggerheart.adversaries.Actor.C0OMQqV7pN6t7ouR], who appear at Far range.</p>",
        "resource": null,
-        "actions": {},
+        "actions": {
+          "MCTBsw9lusUdubj0": {
+            "type": "summon",
+            "_id": "MCTBsw9lusUdubj0",
+            "systemPath": "actions",
+            "baseAction": false,
+            "description": "",
+            "chatDisplay": true,
+            "originItem": {
+              "type": "itemCollection"
+            },
+            "actionType": "action",
+            "cost": [],
+            "uses": {
+              "value": null,
+              "max": "",
+              "recovery": null,
+              "consumeOnSuccess": false
+            },
+            "summon": [
+              {
+                "actorUUID": "Compendium.daggerheart.adversaries.Actor.C0OMQqV7pN6t7ouR",
+                "count": "3"
+              }
+            ],
+            "name": "Summon",
+            "range": ""
+          }
+        },
        "originItemType": null,
        "subType": null,
        "originId": null,
--- a/src/packs/adversaries/adversary_Petty_Noble_wycLpvebWdUqRhpP.json
+++ b/src/packs/adversaries/adversary_Petty_Noble_wycLpvebWdUqRhpP.json
@ -258,57 +258,40 @@
        "description": "<p>Once per scene, <strong>mark a Stress</strong> to summon <strong>1d4</strong> @UUID[Compendium.daggerheart.adversaries.Actor.B4LZcGuBAHzyVdzy]{Bladed Guards}, who appear at Far range to enforce the @Lookup[@name]’s will.</p>",
        "resource": null,
        "actions": {
-          "cUKwhq1imsTVru8D": {
-            "type": "attack",
-            "_id": "cUKwhq1imsTVru8D",
+          "tioTtYfIGFIXRITN": {
+            "type": "summon",
+            "_id": "tioTtYfIGFIXRITN",
            "systemPath": "actions",
-            "description": "<p>Once per scene, <strong>mark a Stress</strong> to summon <strong>1d4</strong> @UUID[Compendium.daggerheart.adversaries.Actor.B4LZcGuBAHzyVdzy]{Bladed Guards}, who appear at Far range to enforce the Noble’s will.</p>",
+            "baseAction": false,
+            "description": "",
            "chatDisplay": true,
+            "originItem": {
+              "type": "itemCollection"
+            },
            "actionType": "action",
            "cost": [
              {
                "scalable": false,
                "key": "stress",
                "value": 1,
-                "step": null
+                "itemId": null,
+                "step": null,
+                "consumeOnSuccess": false
              }
            ],
            "uses": {
              "value": null,
-              "max": "",
-              "recovery": null
-            },
-            "damage": {
-              "parts": [],
-              "includeBase": false
-            },
-            "target": {
-              "type": "any",
-              "amount": null
-            },
-            "effects": [],
-            "roll": {
-              "type": "diceSet",
-              "trait": null,
-              "difficulty": null,
-              "bonus": null,
-              "advState": "neutral",
-              "diceRolling": {
-                "multiplier": "prof",
-                "flatMultiplier": 1,
-                "dice": "d4",
-                "compare": null,
-                "treshold": null
-              },
-              "useDefault": false
-            },
-            "save": {
-              "trait": null,
-              "difficulty": null,
-              "damageMod": "none"
+              "max": "1",
+              "recovery": "scene",
+              "consumeOnSuccess": false
            },
+            "summon": [
+              {
+                "actorUUID": "Compendium.daggerheart.adversaries.Actor.B4LZcGuBAHzyVdzy",
+                "count": "1d4"
+              }
+            ],
            "name": "Summon Guards",
-            "img": "icons/environment/people/infantry-armored.webp",
            "range": ""
          }
        },
--- a/src/packs/adversaries/adversary_Pirate_Captain_OROJbjsqagVh7ECV.json
+++ b/src/packs/adversaries/adversary_Pirate_Captain_OROJbjsqagVh7ECV.json
@ -313,36 +313,43 @@
      "_id": "WGEGO0DSOs5cF0EL",
      "img": "icons/environment/people/charge.webp",
      "system": {
-        "description": "<p>Once per scene, <strong>mark a Stress</strong> to summon a Pirate Raiders Horde, which appears at Far range.</p>",
+        "description": "<p>Once per scene, <strong>mark a Stress</strong> to summon a @UUID[Compendium.daggerheart.adversaries.Actor.5YgEajn0wa4i85kC]{Pirate Raider Horde}, which appears at Far range.</p>",
        "resource": null,
        "actions": {
-          "NlgIp0KrmZoS27Xy": {
-            "type": "effect",
-            "_id": "NlgIp0KrmZoS27Xy",
+          "nuYk5WeLLpIKa69q": {
+            "type": "summon",
+            "_id": "nuYk5WeLLpIKa69q",
            "systemPath": "actions",
+            "baseAction": false,
            "description": "",
            "chatDisplay": true,
+            "originItem": {
+              "type": "itemCollection"
+            },
            "actionType": "action",
            "cost": [
              {
                "scalable": false,
                "key": "stress",
                "value": 1,
-                "step": null
+                "itemId": null,
+                "step": null,
+                "consumeOnSuccess": false
              }
            ],
            "uses": {
              "value": null,
              "max": "",
-              "recovery": null
-            },
-            "effects": [],
-            "target": {
-              "type": "any",
-              "amount": null
+              "recovery": null,
+              "consumeOnSuccess": false
            },
+            "summon": [
+              {
+                "actorUUID": "Compendium.daggerheart.adversaries.Actor.5YgEajn0wa4i85kC",
+                "count": "1"
+              }
+            ],
            "name": "Mark Stress",
-            "img": "icons/environment/people/charge.webp",
            "range": ""
          }
        },
--- a/src/packs/adversaries/adversary_Red_Ooze_9rVlbJVrDNn1x7PS.json
+++ b/src/packs/adversaries/adversary_Red_Ooze_9rVlbJVrDNn1x7PS.json
@ -454,33 +454,40 @@
        "description": "<p>When the @Lookup[@name] has 3 or more HP marked, you can <strong>spend a Fear</strong> to split them into two @UUID[Compendium.daggerheart.adversaries.Actor.1fkLQXVtmILqfJ44]{Tiny Red Oozes} (with no marked HP or Stress). Immediately spotlight both of them.</p>",
        "resource": null,
        "actions": {
-          "dw6Juw8mriH7sg0e": {
-            "type": "effect",
-            "_id": "dw6Juw8mriH7sg0e",
+          "BMEr77hDxaQyYBna": {
+            "type": "summon",
+            "_id": "BMEr77hDxaQyYBna",
            "systemPath": "actions",
+            "baseAction": false,
            "description": "",
            "chatDisplay": true,
+            "originItem": {
+              "type": "itemCollection"
+            },
            "actionType": "action",
            "cost": [
              {
                "scalable": false,
                "key": "fear",
                "value": 1,
-                "step": null
+                "itemId": null,
+                "step": null,
+                "consumeOnSuccess": false
              }
            ],
            "uses": {
              "value": null,
              "max": "",
-              "recovery": null
-            },
-            "effects": [],
-            "target": {
-              "type": "any",
-              "amount": null
+              "recovery": null,
+              "consumeOnSuccess": false
            },
+            "summon": [
+              {
+                "actorUUID": "Compendium.daggerheart.adversaries.Actor.1fkLQXVtmILqfJ44",
+                "count": "2"
+              }
+            ],
            "name": "Spend Fear",
-            "img": "icons/creatures/slimes/slime-movement-splashing-red.webp",
            "range": ""
          }
        },
--- a/src/packs/adversaries/adversary_Secret_Keeper_sLAccjvCWfeedbpI.json
+++ b/src/packs/adversaries/adversary_Secret_Keeper_sLAccjvCWfeedbpI.json
@ -416,28 +416,6 @@
        "description": "<p><em>Countdown (6)</em>. When the @Lookup[@name] is in the spotlight for the first time, activate the countdown. When they mark HP, tick down this countdown by the number of HP marked. When it triggers, summon a @UUID[Compendium.daggerheart.adversaries.Actor.3tqCjDwJAQ7JKqMb]{Minor Demon} who appears at Close range.</p>",
        "resource": null,
        "actions": {
-          "0rixG6jLRynAYNqA": {
-            "type": "effect",
-            "_id": "0rixG6jLRynAYNqA",
-            "systemPath": "actions",
-            "description": "<p>Summon a @UUID[Compendium.daggerheart.adversaries.Actor.3tqCjDwJAQ7JKqMb]{Minor Demon} who appears at Close range.</p>",
-            "chatDisplay": true,
-            "actionType": "action",
-            "cost": [],
-            "uses": {
-              "value": null,
-              "max": "",
-              "recovery": null
-            },
-            "effects": [],
-            "target": {
-              "type": "any",
-              "amount": null
-            },
-            "name": "Summon",
-            "img": "icons/magic/unholy/silhouette-light-fire-blue.webp",
-            "range": "close"
-          },
          "ZVXHY2fpomoKV7jG": {
            "type": "countdown",
            "_id": "ZVXHY2fpomoKV7jG",
@ -474,6 +452,33 @@
            "name": "Start Countdown",
            "img": "icons/magic/unholy/silhouette-light-fire-blue.webp",
            "range": ""
+          },
+          "YReYG6DrWp4QGSij": {
+            "type": "summon",
+            "_id": "YReYG6DrWp4QGSij",
+            "systemPath": "actions",
+            "baseAction": false,
+            "description": "",
+            "chatDisplay": true,
+            "originItem": {
+              "type": "itemCollection"
+            },
+            "actionType": "action",
+            "cost": [],
+            "uses": {
+              "value": null,
+              "max": "",
+              "recovery": null,
+              "consumeOnSuccess": false
+            },
+            "summon": [
+              {
+                "actorUUID": "Compendium.daggerheart.adversaries.Actor.3tqCjDwJAQ7JKqMb",
+                "count": "1"
+              }
+            ],
+            "name": "Summon",
+            "range": ""
          }
        },
        "originItemType": null,
@ -502,33 +507,31 @@
        "description": "<p>Once per scene, when the @Lookup[@name] marks 2 or more HP, you can <strong>mark a Stress</strong> to summon a @UUID[Compendium.daggerheart.adversaries.Actor.NoRZ1PqB8N5wcIw0]{Demonic Hound Pack}, which appears at Close range and is immediately spotlighted.</p>",
        "resource": null,
        "actions": {
-          "JBuQUJhif2A7IlJd": {
-            "type": "effect",
-            "_id": "JBuQUJhif2A7IlJd",
+          "tfmY6HYkkY27NBaF": {
+            "type": "summon",
+            "_id": "tfmY6HYkkY27NBaF",
            "systemPath": "actions",
+            "baseAction": false,
            "description": "",
            "chatDisplay": true,
+            "originItem": {
+              "type": "itemCollection"
+            },
            "actionType": "action",
-            "cost": [
-              {
-                "scalable": false,
-                "key": "stress",
-                "value": 1,
-                "step": null
-              }
-            ],
+            "cost": [],
            "uses": {
              "value": null,
-              "max": "1",
-              "recovery": "scene"
-            },
-            "effects": [],
-            "target": {
-              "type": "self",
-              "amount": null
+              "max": "",
+              "recovery": null,
+              "consumeOnSuccess": false
            },
+            "summon": [
+              {
+                "actorUUID": "Compendium.daggerheart.adversaries.Actor.NoRZ1PqB8N5wcIw0",
+                "count": "1"
+              }
+            ],
            "name": "Mark Stress",
-            "img": "icons/creatures/unholy/demon-fire-horned-clawed.webp",
            "range": ""
          }
        },
--- a/src/packs/adversaries/adversary_Tangle_Bramble_XcAGOSmtCFLT1unN.json
+++ b/src/packs/adversaries/adversary_Tangle_Bramble_XcAGOSmtCFLT1unN.json
@ -340,7 +340,35 @@
      "system": {
        "description": "<p>When an attack from the @Lookup[@name] causes a target to mark HP and there are three or more @Lookup[@name] Minions within Close range, you can combine the Minions into a @UUID[Compendium.daggerheart.adversaries.Actor.PKSXFuaIHUCoH63A]{Tangle Bramble Swarm Horde}. The Horde’s HP is equal to the number of Minions combined.</p>",
        "resource": null,
-        "actions": {},
+        "actions": {
+          "g1OQ5xlMHFWsoktd": {
+            "type": "summon",
+            "_id": "g1OQ5xlMHFWsoktd",
+            "systemPath": "actions",
+            "baseAction": false,
+            "description": "",
+            "chatDisplay": true,
+            "originItem": {
+              "type": "itemCollection"
+            },
+            "actionType": "action",
+            "cost": [],
+            "uses": {
+              "value": null,
+              "max": "",
+              "recovery": null,
+              "consumeOnSuccess": false
+            },
+            "summon": [
+              {
+                "actorUUID": "Compendium.daggerheart.adversaries.Actor.PKSXFuaIHUCoH63A",
+                "count": "1"
+              }
+            ],
+            "name": "Summon",
+            "range": ""
+          }
+        },
        "originItemType": null,
        "subType": null,
        "originId": null,
--- a/src/packs/ancestries/feature_Shell_A6a87OWA3tx16g9V.json
+++ b/src/packs/ancestries/feature_Shell_A6a87OWA3tx16g9V.json
@ -36,13 +36,13 @@
          "key": "system.damageThresholds.major",
          "mode": 2,
          "value": "@prof",
-          "priority": null
+          "priority": 21
        },
        {
          "key": "system.damageThresholds.severe",
          "mode": 2,
          "value": "@prof",
-          "priority": null
+          "priority": 21
        }
      ],
      "disabled": false,
--- a/src/packs/beastforms/feature_Armored_Shell_nDQZdIF2epKlhauX.json
+++ b/src/packs/beastforms/feature_Armored_Shell_nDQZdIF2epKlhauX.json
@ -100,7 +100,7 @@
          "key": "system.resistance.physical.reduction",
          "mode": 2,
          "value": "@system.armorScore",
-          "priority": null
+          "priority": 21
        }
      ],
      "disabled": false,
--- a/src/packs/classes/feature_Strange_Patterns_6YsfFjmCGuFYVhT4.json
+++ b/src/packs/classes/feature_Strange_Patterns_6YsfFjmCGuFYVhT4.json
@ -80,7 +80,14 @@
        },
        "name": "Clear Stress",
        "img": "icons/magic/symbols/rune-sigil-black-pink.webp",
-        "range": ""
+        "range": "",
+        "triggers": [
+          {
+            "trigger": "dualityRoll",
+            "triggeringActorType": "self",
+            "command": "/* Ignore if it's a TagTeam roll */\nconst tagTeam = game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.TagTeamRoll);\nif (tagTeam.members[actor.id]) return;\n\n/* Check if there's a Strange Pattern match */\nconst dice = [roll.dFear.total, roll.dHope.total];\nconst resource = this.parent.resource?.diceStates ? Object.values(this.parent.resource.diceStates).map(x => x.value)[0] : null;\nconst nrMatches = dice.filter(x => x === resource).length;\n\nif (!nrMatches) return;\n\n/* Create a dialog to choose Hope or Stress - or to cancel*/\nconst content = `\n  <div><div>${game.i18n.format('DAGGERHEART.CONFIG.Triggers.triggerTexts.strangePatternsContentTitle', { nr: nrMatches })}</div>\n  <div>${game.i18n.format('DAGGERHEART.CONFIG.Triggers.triggerTexts.strangePatternsContentSubTitle', { nr: nrMatches })}</div>\n      <div class=\"flexrow\" style=\"gap: 8px;\">\n        <button type=\"button\" id=\"hopeButton\">\n          <i class=\"fa-solid fa-hands-holding\"></i>\n          <label>0</label>\n        </button>\n        <button type=\"button\" id=\"stressButton\">\n          <i class=\"fa-solid fa-bolt-lightning\"></i>\n          <label>0</label>\n        </button>\n      </div>\n</div>`;\n\nconst result = await foundry.applications.api.DialogV2.input({\n  classes: ['dh-style', 'two-big-buttons'],\n  window: { title: this.item.name },\n  content: content,\n  render: (_, dialog) => {\n      const hopeButton = dialog.element.querySelector('#hopeButton');\n      const stressButton = dialog.element.querySelector('#stressButton');\ndialog.element.querySelector('button[type=\"submit\"]').disabled = true;\n    \n      const updateFunc = (event, selector, adding, clamp) => {\n        const button = event.target.closest(`#${selector}Button`);\n        const parent = event.target.closest('.flexrow');\n        const hope = Number.parseInt(parent.querySelector('#hopeButton label').innerHTML);\n        const stress = Number.parseInt(parent.querySelector('#stressButton label').innerHTML);\n        const currentTotal = (Number.isNumeric(hope) ? hope : 0) + (Number.isNumeric(stress) ? stress : 0);\n        if (adding && currentTotal === nrMatches) return;\n        \n        const current = Number.parseInt(button.querySelector('label').innerHTML);\n        if (!adding && current === 0) return;\n        \n        const value = Number.isNumeric(current) ? adding ? current+1 : current-1 : 1;\n        if (!dialog.data) dialog.data = {};\n        dialog.data[selector] = clamp(value);\n        button.querySelector('label').innerHTML = dialog.data[selector];\n\n        event.target.closest('.dialog-form').querySelector('button[type=\"submit\"]').disabled = !adding || currentTotal < (nrMatches-1);\n        \n      };\n      hopeButton.addEventListener('click', event => updateFunc(event, 'hope', true, x => Math.min(x, nrMatches)));\n      hopeButton.addEventListener('contextmenu', event => updateFunc(event, 'hope', false, x => Math.max(x, 0)));\n      stressButton.addEventListener('click', event => updateFunc(event, 'stress', true, x => Math.min(x, nrMatches)));\n      stressButton.addEventListener('contextmenu', event => updateFunc(event, 'stress', false, x => Math.max(x, 0)));\n  },\n  ok: { callback: (_event, _result, dialog) => {\n    const hope = dialog.data.hope ?? 0;\n    const stress = dialog.data.stress ?? 0;\n    if (!hope && !stress) return;\n\n    /* Return resource update according to choices */\n    const hopeUpdate = hope ? { key: 'hope', value: hope, total: -hope, enabled: true } : null;\n    const stressUpdate = stress ? { key: 'stress', value: -stress, total: stress, enabled: true } : null;\n    return { updates: [hopeUpdate, stressUpdate].filter(x => x) };\n  }}\n});\n\nreturn result;"
+          }
+        ]
      }
    },
    "originItemType": null,
--- a/src/packs/domains/domainCard_Arcana_Touched_5PvMQKCjrgSxzstn.json
+++ b/src/packs/domains/domainCard_Arcana_Touched_5PvMQKCjrgSxzstn.json
@ -54,7 +54,8 @@
      "source": "Daggerheart SRD",
      "page": 120,
      "artist": ""
-    }
+    },
+    "domainTouched": 4
  },
  "flags": {},
  "_id": "5PvMQKCjrgSxzstn",
--- a/src/packs/domains/domainCard_Blade_Touched_Gb5bqpFSBiuBxUix.json
+++ b/src/packs/domains/domainCard_Blade_Touched_Gb5bqpFSBiuBxUix.json
@ -13,7 +13,8 @@
      "source": "Daggerheart SRD",
      "page": 121,
      "artist": ""
-    }
+    },
+    "domainTouched": 4
  },
  "flags": {},
  "_id": "Gb5bqpFSBiuBxUix",
--- a/src/packs/domains/domainCard_Body_Basher_aQz8jKkCd8M9aKMA.json
+++ b/src/packs/domains/domainCard_Body_Basher_aQz8jKkCd8M9aKMA.json
@ -38,13 +38,13 @@
          "key": "system.bonuses.damage.primaryWeapon.bonus",
          "mode": 2,
          "value": "@system.traits.strength.value",
-          "priority": null
+          "priority": 21
        },
        {
          "key": "system.bonuses.damage.secondaryWeapon.bonus",
          "mode": 2,
          "value": "@system.traits.strength.value",
-          "priority": null
+          "priority": 21
        }
      ],
      "disabled": false,
@ -57,7 +57,7 @@
        "startRound": null,
        "startTurn": null
      },
-      "description": "<p><span style=\"color:rgb(239, 230, 216);font-family:Montserrat, sans-serif;font-size:14px;font-style:normal;font-variant-ligatures:normal;font-variant-caps:normal;font-weight:400;letter-spacing:normal;orphans:2;text-align:start;text-indent:0px;text-transform:none;widows:2;word-spacing:0px;-webkit-text-stroke-width:0px;white-space:normal;background-color:rgba(24, 22, 46, 0.376);text-decoration-thickness:initial;text-decoration-style:initial;text-decoration-color:initial;display:inline !important;float:none\">On a successful attack using a weapon with a </span><span class=\"tooltip-convert\" style=\"box-sizing:border-box;scrollbar-width:thin;scrollbar-color:rgb(93, 20, 43) rgba(0, 0, 0, 0);color:rgb(239, 230, 216);font-family:Montserrat, sans-serif;font-size:14px;font-style:normal;font-variant-ligatures:normal;font-variant-caps:normal;font-weight:400;letter-spacing:normal;orphans:2;text-align:start;text-indent:0px;text-transform:none;widows:2;word-spacing:0px;-webkit-text-stroke-width:0px;white-space:normal;background-color:rgba(24, 22, 46, 0.376);text-decoration-thickness:initial;text-decoration-style:initial;text-decoration-color:initial\">Melee</span><span style=\"color:rgb(239, 230, 216);font-family:Montserrat, sans-serif;font-size:14px;font-style:normal;font-variant-ligatures:normal;font-variant-caps:normal;font-weight:400;letter-spacing:normal;orphans:2;text-align:start;text-indent:0px;text-transform:none;widows:2;word-spacing:0px;-webkit-text-stroke-width:0px;white-space:normal;background-color:rgba(24, 22, 46, 0.376);text-decoration-thickness:initial;text-decoration-style:initial;text-decoration-color:initial;display:inline !important;float:none\"> range, gain a bonus to your damage roll equal to your </span><span class=\"tooltip-convert\" style=\"box-sizing:border-box;scrollbar-width:thin;scrollbar-color:rgb(93, 20, 43) rgba(0, 0, 0, 0);color:rgb(239, 230, 216);font-family:Montserrat, sans-serif;font-size:14px;font-style:normal;font-variant-ligatures:normal;font-variant-caps:normal;font-weight:400;letter-spacing:normal;orphans:2;text-align:start;text-indent:0px;text-transform:none;widows:2;word-spacing:0px;-webkit-text-stroke-width:0px;white-space:normal;background-color:rgba(24, 22, 46, 0.376);text-decoration-thickness:initial;text-decoration-style:initial;text-decoration-color:initial\">Strength</span><span style=\"color:rgb(239, 230, 216);font-family:Montserrat, sans-serif;font-size:14px;font-style:normal;font-variant-ligatures:normal;font-variant-caps:normal;font-weight:400;letter-spacing:normal;orphans:2;text-align:start;text-indent:0px;text-transform:none;widows:2;word-spacing:0px;-webkit-text-stroke-width:0px;white-space:normal;background-color:rgba(24, 22, 46, 0.376);text-decoration-thickness:initial;text-decoration-style:initial;text-decoration-color:initial;display:inline !important;float:none\">.</p>",
+      "description": "<p><span style=\"color:rgb(239, 230, 216);font-family:Montserrat, sans-serif;font-size:14px;font-style:normal;font-variant-ligatures:normal;font-variant-caps:normal;font-weight:400;letter-spacing:normal;orphans:2;text-align:start;text-indent:0px;text-transform:none;widows:2;word-spacing:0px;-webkit-text-stroke-width:0px;white-space:normal;background-color:rgba(24, 22, 46, 0.376);text-decoration-thickness:initial;text-decoration-style:initial;text-decoration-color:initial;display:inline !important;float:none\">On a successful attack using a weapon with a </span><span class=\"tooltip-convert\" style=\"box-sizing:border-box;scrollbar-width:thin;scrollbar-color:rgb(93, 20, 43) rgba(0, 0, 0, 0);color:rgb(239, 230, 216);font-family:Montserrat, sans-serif;font-size:14px;font-style:normal;font-variant-ligatures:normal;font-variant-caps:normal;font-weight:400;letter-spacing:normal;orphans:2;text-align:start;text-indent:0px;text-transform:none;widows:2;word-spacing:0px;-webkit-text-stroke-width:0px;white-space:normal;background-color:rgba(24, 22, 46, 0.376);text-decoration-thickness:initial;text-decoration-style:initial;text-decoration-color:initial\">Melee</span><span style=\"color:rgb(239, 230, 216);font-family:Montserrat, sans-serif;font-size:14px;font-style:normal;font-variant-ligatures:normal;font-variant-caps:normal;font-weight:400;letter-spacing:normal;orphans:2;text-align:start;text-indent:0px;text-transform:none;widows:2;word-spacing:0px;-webkit-text-stroke-width:0px;white-space:normal;background-color:rgba(24, 22, 46, 0.376);text-decoration-thickness:initial;text-decoration-style:initial;text-decoration-color:initial;display:inline !important;float:none\"> range, gain a bonus to your damage roll equal to your </span><span class=\"tooltip-convert\" style=\"box-sizing:border-box;scrollbar-width:thin;scrollbar-color:rgb(93, 20, 43) rgba(0, 0, 0, 0);color:rgb(239, 230, 216);font-family:Montserrat, sans-serif;font-size:14px;font-style:normal;font-variant-ligatures:normal;font-variant-caps:normal;font-weight:400;letter-spacing:normal;orphans:2;text-align:start;text-indent:0px;text-transform:none;widows:2;word-spacing:0px;-webkit-text-stroke-width:0px;white-space:normal;background-color:rgba(24, 22, 46, 0.376);text-decoration-thickness:initial;text-decoration-style:initial;text-decoration-color:initial\">Strength</span><span style=\"color:rgb(239, 230, 216);font-family:Montserrat, sans-serif;font-size:14px;font-style:normal;font-variant-ligatures:normal;font-variant-caps:normal;font-weight:400;letter-spacing:normal;orphans:2;text-align:start;text-indent:0px;text-transform:none;widows:2;word-spacing:0px;-webkit-text-stroke-width:0px;white-space:normal;background-color:rgba(24, 22, 46, 0.376);text-decoration-thickness:initial;text-decoration-style:initial;text-decoration-color:initial;display:inline !important;float:none\">.</span></p>",
      "origin": null,
      "tint": "#ffffff",
      "transfer": true,
--- a/src/packs/domains/domainCard_Bone_Touched_ON5bvnoQBy0SYc9Y.json
+++ b/src/packs/domains/domainCard_Bone_Touched_ON5bvnoQBy0SYc9Y.json
@ -46,7 +46,8 @@
      "source": "Daggerheart SRD",
      "page": 123,
      "artist": ""
-    }
+    },
+    "domainTouched": 4
  },
  "flags": {},
  "_id": "ON5bvnoQBy0SYc9Y",
--- a/src/packs/domains/domainCard_Codex_Touched_7Pu83ABdMukTxu3e.json
+++ b/src/packs/domains/domainCard_Codex_Touched_7Pu83ABdMukTxu3e.json
@ -71,7 +71,8 @@
      "source": "Daggerheart SRD",
      "page": 125,
      "artist": ""
-    }
+    },
+    "domainTouched": 4
  },
  "flags": {},
  "_id": "7Pu83ABdMukTxu3e",
--- a/src/packs/domains/domainCard_Cruel_Precision_bap1eCWryPNowbyo.json
+++ b/src/packs/domains/domainCard_Cruel_Precision_bap1eCWryPNowbyo.json
@ -37,13 +37,13 @@
          "key": "system.bonuses.damage.primaryWeapon.bonus",
          "mode": 2,
          "value": "@system.traits.agility.value",
-          "priority": null
+          "priority": 21
        },
        {
          "key": "system.bonuses.damage.secondaryWeapon.bonus",
          "mode": 2,
          "value": "@system.traits.agility.value",
-          "priority": null
+          "priority": 21
        }
      ],
      "disabled": true,
--- a/src/packs/domains/domainCard_Ferocity_jSQsSP61CX4MhSN7.json
+++ b/src/packs/domains/domainCard_Ferocity_jSQsSP61CX4MhSN7.json
@ -17,7 +17,16 @@
        "description": "<p class=\"Body-Foundation\">When you cause an adversary to mark 1 or more Hit Points, you can <strong>spend 2 Hope</strong> to increase your Evasion by the number of Hit Points they marked. This bonus lasts until after the next attack made against you.</p>",
        "chatDisplay": true,
        "actionType": "action",
-        "cost": [],
+        "cost": [
+          {
+            "scalable": false,
+            "key": "hope",
+            "value": 2,
+            "itemId": null,
+            "step": null,
+            "consumeOnSuccess": false
+          }
+        ],
        "uses": {
          "value": null,
          "max": "",
@ -30,8 +39,15 @@
          "amount": null
        },
        "name": "Spend Hope",
-        "img": "icons/skills/melee/maneuver-daggers-paired-orange.webp",
-        "range": ""
+        "img": "icons/skills/melee/maneuver-sword-katana-yellow.webp",
+        "range": "",
+        "triggers": [
+          {
+            "trigger": "postDamageReduction",
+            "triggeringActorType": "other",
+            "command": "/* Check if sufficient hope */\nif (this.actor.system.resources.hope.value < 2) return;\n\n/* Check if hit point damage was dealt */\nconst hpDamage = damageUpdates.find(u => u.key === CONFIG.DH.GENERAL.healingTypes.hitPoints.id);\nif (hpDamage.value < 0) return;\n\n/* Dialog to give player choice */\nconst confirmed = await foundry.applications.api.DialogV2.confirm({\n    window: { title: this.item?.name ?? '' },\n    content: game.i18n.format('DAGGERHEART.CONFIG.Triggers.triggerTexts.ferocityContent', { bonus: hpDamage.value }),\n});\n\nif (!confirmed) return;\n\n/* Create the effect */\nthis.actor.createEmbeddedDocuments('ActiveEffect', [{\n  name: this.item.name,\n  img: 'icons/skills/melee/maneuver-sword-katana-yellow.webp',\n  description: game.i18n.format('DAGGERHEART.CONFIG.Triggers.triggerTexts.ferocityEffectDescription', { bonus: hpDamage.value }),\n  changes: [{ key: 'system.evasion', mode: 2, value: hpDamage.value }]\n}]);\n\n/* Update hope */\nreturn { updates: [{ \n  originActor: this.actor, \n  updates: [{\n    key: CONFIG.DH.GENERAL.healingTypes.hope.id,\n    value: -2,\n    total: 2\n  }] \n}]}"
+          }
+        ]
      }
    },
    "attribution": {
--- a/src/packs/domains/domainCard_Get_Back_Up_BFWN2cObMdlk9uVz.json
+++ b/src/packs/domains/domainCard_Get_Back_Up_BFWN2cObMdlk9uVz.json
@ -18,7 +18,7 @@
  },
  "flags": {},
  "_id": "BFWN2cObMdlk9uVz",
-  "sort": 3400000,
+  "sort": 3500000,
  "effects": [
    {
      "name": "Get Back Up",
--- a/Show more
+++ b/Show more
Author	SHA1	Message	Date
WBHarry	9393bab6cf	Added so that beastforms can set a scale to handle specific images (#1532 )	2026-01-15 09:45:10 +01:00
Carlos Fernandez	b92a474069	Fix bottom gap of item settings and make header rows more rhythmic (#1529 )	2026-01-14 20:04:00 -05:00
WBHarry	4aa414be00	[Fix] Daggerheart Menu LightMode (#1534 ) * Fixed so the menu and menuIcon coloration correctly changes with mode change * . * . * .	2026-01-15 00:53:33 +01:00
WBHarry	5b61340fee	Fixed /dr without target failing resource update	2026-01-13 22:36:50 +01:00
WBHarry	acafd2c8b9	Added fallback for defaultHopeDice and defaultFearDice	2026-01-13 21:00:24 +01:00
WBHarry	9473250f0c	Fixed critical threshold applying to reactions	2026-01-13 20:47:43 +01:00
WBHarry	c958acabe6	[Fix] Release Fixes (#1530 ) * Various fixes * . * . * .	2026-01-13 19:12:50 +01:00
WBHarry	3c9ef75645	[Feature] ActiveEffect Default Hope/Fear dice (#1522 ) * Added ActiveEffect rules for default hope and fear dice * . * Raised system version	2026-01-13 10:58:03 +01:00
WBHarry	d282a81594	[Feature] Summon Action Implementation (#1514 ) * Schema definition for DHSummonAction * Will reimplement * HBS idea formed. Need to recheck drag drop implementation * Tried to refine drag drop * drag drop implemented (css tbd) * phase 1 complete * tbd work on summon action type * Improved Schema and now it works * . * Dialog created. Tokens not dragged(tbd). * Bare minimum implementation * Finalized functionality * Cleanup * . * Added optional summon render to chat message * Updated SRD * bugfix: fix title lines not rendering in chat messages * Added summon actions to the easily doable environments in the SRD * Update module/data/fields/action/summonField.mjs Co-authored-by: Carlos Fernandez <CarlosFdez@users.noreply.github.com> --------- Co-authored-by: Nikhil Nagarajan <potter.nikhil@gmail.com> Co-authored-by: Murilo Brito <dev.murilobrito@gmail.com> Co-authored-by: Carlos Fernandez <CarlosFdez@users.noreply.github.com>	2026-01-13 10:36:29 +01:00
WBHarry	d823501d91	[Feature] Advanced Effect Settings (#1523 ) * Added VaultActive and LoadoutIgnore * Added DomainTouched support * Naming change * . * Improved labels	2026-01-13 10:32:16 +01:00
WBHarry	27b7758f7d	[Feature] Roll Effect Toggles (#1510 ) * Initial * . * . * Update module/dice/dhRoll.mjs Co-authored-by: Carlos Fernandez <CarlosFdez@users.noreply.github.com> --------- Co-authored-by: Carlos Fernandez <CarlosFdez@users.noreply.github.com>	2026-01-13 01:15:00 +01:00
WBHarry	883aaeec02	[Feature] Armor/Weapon Features In Description (#1521 ) * ItemFeatures are now prepended to the description * . * Better separation of concerns * . * .	2026-01-12 14:16:19 +01:00
WBHarry	8de12551ad	[Feature] Scene Environments (#1499 ) * Initial * Remade to array structure * Fixed context menu for multiples * . * Cleanup * . * Fixed so that users can access sceneEnvironments if they have permissions * Update module/documents/scene.mjs Co-authored-by: Carlos Fernandez <CarlosFdez@users.noreply.github.com> * . --------- Co-authored-by: Carlos Fernandez <CarlosFdez@users.noreply.github.com>	2026-01-12 00:26:27 +01:00
WBHarry	454507ba7b	[Feature] Trigger System (#1500 ) * Initial * . * Added StrangePattern trigger * Set command codeblock to expandable * Added automation setting * Added ferocity trigger * Improved StrangePatterns trigger to handle multiple matches	2026-01-11 11:51:05 +01:00
WBHarry	0b343c9f52	Fixed a lot of cases where we expected a combatant to have an attached actor (#1520 )	2026-01-10 00:21:44 +01:00
Carlos Fernandez	e6973fabd0	Add view party button to character sheet (#1508 )	2026-01-09 17:41:35 +01:00
WBHarry	4e18ed8270	Fixed so that chatMessages always get actor data available (#1519 )	2026-01-09 17:35:00 +01:00
Nikhil Nagarajan	e7cf6594b6	[PR] Rolltables Compendium Added (#1516 ) * Initial Setup * Updated Consumables RollTable * Placed the rolltable compendium in the SRD folder * updated Journal with fixed links * Re-added descriptions in rolltable --------- Co-authored-by: WBHarry <williambjrklund@gmail.com>	2026-01-09 17:34:11 +01:00
WBHarry	bbe8fb953e	Fixed so that tagify tooltip descriptions cannot end up with raw HTML that breaks it (#1504 )	2026-01-09 15:57:57 +01:00
Nikhil Nagarajan	6cebccd958	Template removed from Stardrop JSON (#1513 )	2026-01-09 15:56:48 +01:00
Chris Ryan	248f7b41e7	Safety check for experiences (#1515 ) Co-authored-by: Chris Ryan <chrisr@blackhole>	2026-01-09 15:55:16 +01:00
WBHarry	c6bdc846ab	[Fix] SRD Effect Priorities (#1505 ) * Increased priority on effects in srd domain cards that depend on character data * Increased priority on effects in srd classes/subclasses that depend on character data * Increased priority on effects in srd ancestries that depend on character data * Increased priority on effects in srd beastforms that depend on character data * Increased priority on effects in remaining SRD items that depend on character data * Adversaries * Raised system version	2026-01-09 15:50:56 +01:00
Carlos Fernandez	6deadea437	Fix detection of range dependencies (#1497 )	2026-01-08 19:52:25 -05:00
WBHarry	9564edb244	.	2026-01-05 13:45:03 +01:00
WBHarry	bca7e0d3c9	[Fix] Beastforms Getting Stuck (#1495 ) * Fixed beastforms getting stuck * Raised version	2025-12-31 04:52:19 +01:00
Nick Salyzyn	3b7b6258a1	[PR] Adding the ability to target downtime actions. (#1475 ) * Adding the ability to target downtime actions. * No longer using an arbitrary 100 healing. Changing the action's parent	2025-12-29 21:55:13 +01:00
WBHarry	e8c541c002	Added damage reduction rules (#1491 )	2025-12-29 14:00:40 +01:00
WBHarry	f6bd1430e3	Fixed drag/drop of features for environments (#1488 )	2025-12-29 13:02:22 +01:00
WBHarry	c070c6cc2d	[Fix] Evolved Beastform Wildcard (#1486 ) * Fixed so picking an evolved beastform will properly handle wildcard images * .	2025-12-29 04:44:49 +01:00
WBHarry	d0e55aeb8d	Resource Generation Fix	2025-12-28 21:16:24 +01:00
Carlos Fernandez	f11b018bd7	Support drag/drop resorting of adversary features (#1469 )	2025-12-28 19:07:12 +01:00
Nick Salyzyn	c83fe25a47	Using the same drag-drop approach in environments and adversaries as in the character sheet (#1481 )	2025-12-28 18:50:26 +01:00
Nick Salyzyn	3405b53900	[PR] Adding recall functionality to the loadout tab (#1482 ) * Adding a Recall button that doesn't yet show a popup * Adding an action with a cost dialog for stress - if there is a stress cost	2025-12-28 18:31:48 +01:00
Nick Salyzyn	5f001a9f83	Adding scrollable to various tabs in the homebrew settings (#1483 )	2025-12-28 17:26:39 +01:00