daggerheart.mjs

@@ -298,15 +298,13 @@ Hooks.on('chatMessage', (_, message) => {
               ? CONFIG.DH.ACTIONS.advantageState.disadvantage.value
               : undefined;
         const difficulty = rollCommand.difficulty;
-        const grantResources = Boolean(rollCommand.grantResources);
 
         const target = getCommandTarget({ allowNull: true });
-        const title =
-            (flavor ?? traitValue)
-                ? game.i18n.format('DAGGERHEART.UI.Chat.dualityRoll.abilityCheckTitle', {
-                      ability: game.i18n.localize(SYSTEM.ACTOR.abilities[traitValue].label)
-                  })
-                : game.i18n.localize('DAGGERHEART.GENERAL.duality');
+        const title = flavor ??
+            traitValue ? game.i18n.format('DAGGERHEART.UI.Chat.dualityRoll.abilityCheckTitle', {
+                  ability: game.i18n.localize(SYSTEM.ACTOR.abilities[traitValue].label)
+              })
+            : game.i18n.localize('DAGGERHEART.GENERAL.duality');
 
         enrichedDualityRoll({
             reaction,
@@ -316,8 +314,7 @@ Hooks.on('chatMessage', (_, message) => {
             title,
             label: game.i18n.localize('DAGGERHEART.GENERAL.dualityRoll'),
             actionType: null,
-            advantage,
-            grantResources
+            advantage
         });
         return false;
     }

module/applications/dialogs/deathMove.mjs

@@ -85,7 +85,6 @@ export default class DhDeathMove extends HandlebarsApplicationMixin(ApplicationV
             label: game.i18n.localize('DAGGERHEART.GENERAL.dualityDice'),
             actionType: null,
             advantage: null,
-            grantResources: false,
             customConfig: { skips: { resources: true, reaction: true } }
         });
 

module/data/registeredTriggers.mjs

@@ -72,21 +72,10 @@ export default class RegisteredTriggers extends Map {
         }
     }
 
-    unregisterSceneEnvironmentTriggers(flagSystemData) {
-        const sceneData = new game.system.api.data.scenes.DHScene(flagSystemData);
-        for (const environment of sceneData.sceneEnvironments) {
-            if (environment.pack) continue;
-            this.unregisterItemTriggers(environment.system.features);
-        }
-    }
-
     unregisterSceneTriggers(scene) {
-        this.unregisterSceneEnvironmentTriggers(scene.flags.daggerheart);
-
         for (const triggerKey of Object.keys(CONFIG.DH.TRIGGER.triggers)) {
             const existingTrigger = this.get(triggerKey);
             if (!existingTrigger) continue;
-
             const filtered = new Map();
             for (const [uuid, data] of existingTrigger.entries()) {
                 if (!uuid.startsWith(scene.uuid)) filtered.set(uuid, data);
@@ -95,17 +84,14 @@ export default class RegisteredTriggers extends Map {
         }
     }
 
-    registerSceneEnvironmentTriggers(flagSystemData) {
-        const sceneData = new game.system.api.data.scenes.DHScene(flagSystemData);
-        for (const environment of sceneData.sceneEnvironments) {
-            for (const feature of environment.system.features) {
-                if (feature) this.registerItemTriggers(feature, true);
-            }
-        }
-    }
-
     registerSceneTriggers(scene) {
-        this.registerSceneEnvironmentTriggers(scene.flags.daggerheart);
+        /* TODO: Finish sceneEnvironment registration and unreg */
+        // const systemData = new game.system.api.data.scenes.DHScene(scene.flags.daggerheart);
+        // for (const environment of systemData.sceneEnvironments) {
+        //     for (const feature of environment.system.features) {
+        //         if(feature) this.registerItemTriggers(feature, true);
+        //     }
+        // }
 
         for (const actor of scene.tokens.filter(x => x.actor).map(x => x.actor)) {
             if (actor.prototypeToken.actorLink) continue;
@@ -122,11 +108,13 @@ export default class RegisteredTriggers extends Map {
         if (!triggerSettings.enabled) return updates;
 
         const dualityTrigger = this.get(trigger);
-        if (dualityTrigger?.size) {
-            const triggerActors = ['character', 'adversary', 'environment'];
+        if (dualityTrigger) {
+            const tokenBoundActors = ['adversary', 'environment'];
+            const triggerActors = ['character', ...tokenBoundActors];
             for (let [itemUuid, { actor: actorUuid, triggeringActorType, commands }] of dualityTrigger.entries()) {
                 const actor = await foundry.utils.fromUuid(actorUuid);
                 if (!actor || !triggerActors.includes(actor.type)) continue;
+                if (tokenBoundActors.includes(actor.type) && !actor.getActiveTokens().length) continue;
 
                 const triggerData = CONFIG.DH.TRIGGER.triggers[trigger];
                 if (triggerData.usesActor && triggeringActorType !== 'any') {

module/dice/dualityRoll.mjs

@@ -274,7 +274,7 @@ export default class DualityRoll extends D20Roll {
     }
 
     static async handleTriggers(roll, config) {
-        if (!config.source?.actor || config.skips?.triggers) return;
+        if (!config.source?.actor) return;
 
         const updates = [];
         const dualityUpdates = await game.system.registeredTriggers.runTrigger(

module/documents/scene.mjs

@@ -51,27 +51,6 @@ export default class DhScene extends Scene {
         }
     }
 
-    async _preUpdate(changes, options, user) {
-        const allowed = await super._preUpdate(changes, options, user);
-        if (allowed === false) return false;
-
-        if (changes.flags?.daggerheart) {
-            if (this._source.flags.daggerheart) {
-                const unregisterTriggerData = this._source.flags.daggerheart.sceneEnvironments.reduce(
-                    (acc, env) => {
-                        if (!changes.flags.daggerheart.sceneEnvironments.includes(env)) acc.sceneEnvironments.push(env);
-
-                        return acc;
-                    },
-                    { ...this._source.flags.daggerheart, sceneEnvironments: [] }
-                );
-                game.system.registeredTriggers.unregisterSceneEnvironmentTriggers(unregisterTriggerData);
-            }
-
-            game.system.registeredTriggers.registerSceneEnvironmentTriggers(changes.flags.daggerheart);
-        }
-    }
-
     _onDelete(options, userId) {
         super._onDelete(options, userId);
 

module/enrichers/DualityRollEnricher.mjs

@@ -47,7 +47,6 @@ function getDualityMessage(roll, flavor) {
             ${roll?.trait && abilities[roll.trait] ? `data-trait="${roll.trait}"` : ''}
             ${roll?.advantage ? 'data-advantage="true"' : ''}
             ${roll?.disadvantage ? 'data-disadvantage="true"' : ''}
-            ${roll?.grantResources ? 'data-grant-resources="true"' : ''}
         >
             ${roll?.reaction ? '<i class="fa-solid fa-reply"></i>' : '<i class="fa-solid fa-circle-half-stroke"></i>'}
             ${label}
@@ -64,8 +63,7 @@ export const renderDualityButton = async event => {
         traitValue = button.dataset.trait?.toLowerCase(),
         target = getCommandTarget({ allowNull: true }),
         difficulty = button.dataset.difficulty,
-        advantage = button.dataset.advantage ? Number(button.dataset.advantage) : undefined,
-        grantResources = Boolean(button.dataset?.grantResources);
+        advantage = button.dataset.advantage ? Number(button.dataset.advantage) : undefined;
 
     await enrichedDualityRoll(
         {
@@ -75,15 +73,14 @@ export const renderDualityButton = async event => {
             difficulty,
             title: button.dataset.title,
             label: button.dataset.label,
-            advantage,
-            grantResources
+            advantage
         },
         event
     );
 };
 
 export const enrichedDualityRoll = async (
-    { reaction, traitValue, target, difficulty, title, label, advantage, grantResources, customConfig },
+    { reaction, traitValue, target, difficulty, title, label, advantage, customConfig },
     event
 ) => {
     const config = {
@@ -96,18 +93,13 @@ export const enrichedDualityRoll = async (
             advantage,
             type: reaction ? 'reaction' : null
         },
-        skips: {
-            resources: !grantResources,
-            triggers: !grantResources
-        },
         type: 'trait',
         hasRoll: true,
         ...(customConfig ?? {})
     };
 
     if (target) {
-        const result = await target.diceRoll(config);
-        result.resourceUpdates.updateResources();
+        await target.diceRoll(config);
     } else {
         // For no target, call DualityRoll directly with basic data
         config.data = { experiences: {}, traits: {}, rules: {} };