Merge branch 'development' into feature/1383-Companion-Bonus-Levelups

module/documents/_module.mjs

@@ -4,6 +4,7 @@ export { default as DhpCombat } from './combat.mjs';
 export { default as DHCombatant } from './combatant.mjs';
 export { default as DhActiveEffect } from './activeEffect.mjs';
 export { default as DhChatMessage } from './chatMessage.mjs';
+export { default as DhRollTable } from './rollTable.mjs';
 export { default as DhScene } from './scene.mjs';
 export { default as DhToken } from './token.mjs';
 export { default as DhTooltipManager } from './tooltipManager.mjs';

module/documents/actor.mjs

@@ -612,7 +612,7 @@ export default class DhpActor extends Actor {
         if (!updates.length) return;
 
         const hpDamage = updates.find(u => u.key === CONFIG.DH.GENERAL.healingTypes.hitPoints.id);
-        if (hpDamage) {
+        if (hpDamage?.value) {
             hpDamage.value = this.convertDamageToThreshold(hpDamage.value);
             if (
                 this.type === 'character' &&
@@ -854,8 +854,8 @@ export default class DhpActor extends Actor {
 
     async toggleDefeated(defeatedState) {
         const settings = game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Automation).defeated;
-        const { unconscious, defeated, dead } = CONFIG.DH.GENERAL.conditions();
-        const defeatedConditions = new Set([unconscious.id, defeated.id, dead.id]);
+        const { deathMove, unconscious, defeated, dead } = CONFIG.DH.GENERAL.conditions();
+        const defeatedConditions = new Set([deathMove.id, unconscious.id, defeated.id, dead.id]);
         if (!defeatedState) {
             for (let defeatedId of defeatedConditions) {
                 await this.toggleStatusEffect(defeatedId, { overlay: settings.overlay, active: defeatedState });
@@ -869,6 +869,18 @@ export default class DhpActor extends Actor {
         }
     }
 
+    async setDeathMoveDefeated(defeatedIconId) {
+        const settings = game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Automation).defeated;
+        const actorDefault = settings[`${this.type}Default`];
+        if (!settings.enabled || !settings.enabled || !actorDefault || actorDefault === defeatedIconId) return;
+
+        for (let defeatedId of Object.keys(CONFIG.DH.GENERAL.defeatedConditionChoices)) {
+            await this.toggleStatusEffect(defeatedId, { overlay: settings.overlay, active: false });
+        }
+
+        if (defeatedIconId) await this.toggleStatusEffect(defeatedIconId, { overlay: settings.overlay, active: true });
+    }
+
     queueScrollText(scrollingTextData) {
         this.#scrollTextQueue.push(...scrollingTextData.map(data => () => createScrollText(this, data)));
         if (!this.#scrollTextInterval) {

module/documents/chatMessage.mjs

@@ -188,7 +188,7 @@ export default class DhpChatMessage extends foundry.documents.ChatMessage {
             config = foundry.utils.deepClone(this.system);
         config.event = event;
 
-        if (this.system.onSave) {
+        if (config.hasSave) {
             const pendingingSaves = targets.filter(t => t.saved.success === null);
             if (pendingingSaves.length) {
                 const confirm = await foundry.applications.api.DialogV2.confirm({

module/documents/rollTable.mjs

@@ -0,0 +1,122 @@
+export default class DhRollTable extends foundry.documents.RollTable {
+    async roll({ selectedFormula, roll, recursive = true, _depth = 0 } = {}) {
+        // Prevent excessive recursion
+        if (_depth > 5) {
+            throw new Error(`Maximum recursion depth exceeded when attempting to draw from RollTable ${this.id}`);
+        }
+
+        const formula = selectedFormula ?? this.formula;
+
+        // If there is no formula, automatically calculate an even distribution
+        if (!this.formula) {
+            await this.normalize();
+        }
+
+        // Reference the provided roll formula
+        roll = roll instanceof Roll ? roll : Roll.create(formula);
+        let results = [];
+
+        // Ensure that at least one non-drawn result remains
+        const available = this.results.filter(r => !r.drawn);
+        if (!available.length) {
+            ui.notifications.warn(game.i18n.localize('TABLE.NoAvailableResults'));
+            return { roll, results };
+        }
+
+        // Ensure that results are available within the minimum/maximum range
+        const minRoll = (await roll.reroll({ minimize: true })).total;
+        const maxRoll = (await roll.reroll({ maximize: true })).total;
+        const availableRange = available.reduce(
+            (range, result) => {
+                const r = result.range;
+                if (!range[0] || r[0] < range[0]) range[0] = r[0];
+                if (!range[1] || r[1] > range[1]) range[1] = r[1];
+                return range;
+            },
+            [null, null]
+        );
+        if (availableRange[0] > maxRoll || availableRange[1] < minRoll) {
+            ui.notifications.warn('No results can possibly be drawn from this table and formula.');
+            return { roll, results };
+        }
+
+        // Continue rolling until one or more results are recovered
+        let iter = 0;
+        while (!results.length) {
+            if (iter >= 10000) {
+                ui.notifications.error(
+                    `Failed to draw an available entry from Table ${this.name}, maximum iteration reached`
+                );
+                break;
+            }
+            roll = await roll.reroll();
+            results = this.getResultsForRoll(roll.total);
+            iter++;
+        }
+
+        // Draw results recursively from any inner Roll Tables
+        if (recursive) {
+            const inner = [];
+            for (const result of results) {
+                const { type, documentUuid } = result;
+                const documentName = foundry.utils.parseUuid(documentUuid)?.type;
+                if (type === 'document' && documentName === 'RollTable') {
+                    const innerTable = await fromUuid(documentUuid);
+                    if (innerTable) {
+                        const innerRoll = await innerTable.roll({ _depth: _depth + 1 });
+                        inner.push(...innerRoll.results);
+                    }
+                } else inner.push(result);
+            }
+            results = inner;
+        }
+
+        // Return the Roll and the results
+        return { roll, results };
+    }
+
+    async toMessage(results, { roll, messageData = {}, messageOptions = {} } = {}) {
+        messageOptions.rollMode ??= game.settings.get('core', 'rollMode');
+
+        // Construct chat data
+        messageData = foundry.utils.mergeObject(
+            {
+                author: game.user.id,
+                speaker: foundry.documents.ChatMessage.implementation.getSpeaker(),
+                rolls: [],
+                sound: roll ? CONFIG.sounds.dice : null,
+                flags: { 'core.RollTable': this.id }
+            },
+            messageData
+        );
+        if (roll) messageData.rolls.push(roll);
+
+        // Render the chat card which combines the dice roll with the drawn results
+        const detailsPromises = await Promise.allSettled(results.map(r => r.getHTML()));
+        const flavorKey = `TABLE.DrawFlavor${results.length > 1 ? 'Plural' : ''}`;
+        const flavor = game.i18n.format(flavorKey, {
+            number: results.length,
+            name: foundry.utils.escapeHTML(this.name)
+        });
+        messageData.content = await foundry.applications.handlebars.renderTemplate(CONFIG.RollTable.resultTemplate, {
+            description: await TextEditor.implementation.enrichHTML(this.description, {
+                documents: true,
+                secrets: this.isOwner
+            }),
+            flavor: flavor,
+            results: results.map((result, i) => {
+                const r = result.toObject(false);
+                r.details = detailsPromises[i].value ?? '';
+                const useTableIcon =
+                    result.icon === CONFIG.RollTable.resultIcon && this.img !== this.constructor.DEFAULT_ICON;
+                r.icon = useTableIcon ? this.img : result.icon;
+                return r;
+            }),
+            rollHTML: this.displayRoll && roll ? await roll.render() : null,
+            table: this
+        });
+
+        // Create the chat message
+        return foundry.documents.ChatMessage.implementation.create(messageData, messageOptions);
+    }
+}

module/documents/scene.mjs

@@ -51,6 +51,27 @@ 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);