Merge branch 'development' into feature-rollTableSheet

module/data/actor/character.mjs

@@ -549,7 +549,18 @@ export default class DhCharacter extends BaseDataActor {
     }
 
     get deathMoveViable() {
-        return this.resources.hitPoints.max > 0 && this.resources.hitPoints.value >= this.resources.hitPoints.max;
+        const { characterDefault } = game.settings.get(
+            CONFIG.DH.id,
+            CONFIG.DH.SETTINGS.gameSettings.Automation
+        ).defeated;
+        const deathMoveOutcomeStatuses = Object.keys(CONFIG.DH.GENERAL.defeatedConditionChoices).filter(
+            key => key !== characterDefault
+        );
+        const deathMoveNotResolved = this.parent.statuses.every(status => !deathMoveOutcomeStatuses.includes(status));
+
+        const allHitPointsMarked =
+            this.resources.hitPoints.max > 0 && this.resources.hitPoints.value >= this.resources.hitPoints.max;
+        return deathMoveNotResolved && allHitPointsMarked;
     }
 
     get armorApplicableDamageTypes() {

module/data/registeredTriggers.mjs

@@ -20,6 +20,7 @@ export default class RegisteredTriggers extends Map {
     }
 
     registerItemTriggers(item, registerOverride) {
+        if (!item.actor || !item._stats.createdTime) return;
         for (const action of item.system.actions ?? []) {
             if (!action.actor) continue;
 
@@ -71,10 +72,21 @@ 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);
@@ -83,14 +95,17 @@ 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) {
-        /* 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);
-        //     }
-        // }
+        this.registerSceneEnvironmentTriggers(scene.flags.daggerheart);
 
         for (const actor of scene.tokens.filter(x => x.actor).map(x => x.actor)) {
             if (actor.prototypeToken.actorLink) continue;
@@ -107,13 +122,11 @@ export default class RegisteredTriggers extends Map {
         if (!triggerSettings.enabled) return updates;
 
         const dualityTrigger = this.get(trigger);
-        if (dualityTrigger) {
-            const tokenBoundActors = ['adversary', 'environment'];
-            const triggerActors = ['character', ...tokenBoundActors];
+        if (dualityTrigger?.size) {
+            const triggerActors = ['character', 'adversary', 'environment'];
             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/data/settings/Automation.mjs

@@ -58,7 +58,7 @@ export default class DhAutomation extends foundry.abstract.DataModel {
             defeated: new fields.SchemaField({
                 enabled: new fields.BooleanField({
                     required: true,
-                    initial: false,
+                    initial: true,
                     label: 'DAGGERHEART.SETTINGS.Automation.FIELDS.defeated.enabled.label'
                 }),
                 overlay: new fields.BooleanField({
@@ -69,7 +69,7 @@ export default class DhAutomation extends foundry.abstract.DataModel {
                 characterDefault: new fields.StringField({
                     required: true,
                     choices: CONFIG.DH.GENERAL.defeatedConditionChoices,
-                    initial: CONFIG.DH.GENERAL.defeatedConditionChoices.unconscious.id,
+                    initial: CONFIG.DH.GENERAL.defeatedConditionChoices.deathMove.id,
                     label: 'DAGGERHEART.SETTINGS.Automation.FIELDS.defeated.characterDefault.label'
                 }),
                 adversaryDefault: new fields.StringField({
@@ -84,23 +84,29 @@ export default class DhAutomation extends foundry.abstract.DataModel {
                     initial: CONFIG.DH.GENERAL.defeatedConditionChoices.defeated.id,
                     label: 'DAGGERHEART.SETTINGS.Automation.FIELDS.defeated.companionDefault.label'
                 }),
+                deathMoveIcon: new fields.FilePathField({
+                    initial: 'icons/magic/life/heart-cross-purple-orange.webp',
+                    categories: ['IMAGE'],
+                    base64: false,
+                    label: 'DAGGERHEART.SETTINGS.Automation.FIELDS.defeated.deathMove.label'
+                }),
                 deadIcon: new fields.FilePathField({
                     initial: 'icons/magic/death/grave-tombstone-glow-teal.webp',
                     categories: ['IMAGE'],
                     base64: false,
-                    label: 'Dead'
+                    label: 'DAGGERHEART.SETTINGS.Automation.FIELDS.defeated.dead.label'
                 }),
                 defeatedIcon: new fields.FilePathField({
                     initial: 'icons/magic/control/fear-fright-mask-orange.webp',
                     categories: ['IMAGE'],
                     base64: false,
-                    label: 'Defeated'
+                    label: 'DAGGERHEART.SETTINGS.Automation.FIELDS.defeated.defeated.label'
                 }),
                 unconsciousIcon: new fields.FilePathField({
                     initial: 'icons/magic/control/sleep-bubble-purple.webp',
                     categories: ['IMAGE'],
                     base64: false,
-                    label: 'Unconcious'
+                    label: 'DAGGERHEART.SETTINGS.Automation.FIELDS.defeated.unconscious.label'
                 })
             }),
             roll: new fields.SchemaField({