Merge branch 'main' into iss4-attach-items

module/documents/activeEffect.mjs

@@ -51,7 +51,11 @@ export default class DhActiveEffect extends ActiveEffect {
     }
 
     static applyField(model, change, field) {
-        change.value = Roll.safeEval(Roll.replaceFormulaData(change.value, change.effect.parent));
+        const isItemTarget = change.value.toLowerCase().startsWith('item.');
+        change.value = isItemTarget ? change.value.slice(5) : change.value;
+        change.value = Roll.safeEval(
+            Roll.replaceFormulaData(change.value, isItemTarget ? change.effect.parent : model)
+        );
         super.applyField(model, change, field);
     }
 

module/documents/actor.mjs

@@ -3,6 +3,7 @@ import { emitAsGM, emitAsOwner, GMUpdateEvent, socketEvent } from '../systemRegi
 import DamageReductionDialog from '../applications/dialogs/damageReductionDialog.mjs';
 import { LevelOptionType } from '../data/levelTier.mjs';
 import DHFeature from '../data/item/feature.mjs';
+import { damageKeyToNumber, getDamageKey } from '../helpers/utils.mjs';
 
 export default class DhpActor extends Actor {
     /**
@@ -455,14 +456,32 @@ export default class DhpActor extends Actor {
         cls.create(msg.toObject());
     }
 
-    async takeDamage(damage, type) {
-        if (Hooks.call(`${CONFIG.DH.id}.preTakeDamage`, this, damage, type) === false) return null;
+    #canReduceDamage(hpDamage, type) {
+        const availableStress = this.system.resources.stress.maxTotal - this.system.resources.stress.value;
+
+        const canUseArmor =
+            this.system.armor &&
+            this.system.armor.system.marks.value < this.system.armorScore &&
+            this.system.armorApplicableDamageTypes[type];
+        const canUseStress = Object.keys(this.system.rules.damageReduction.stressDamageReduction).reduce((acc, x) => {
+            const rule = this.system.rules.damageReduction.stressDamageReduction[x];
+            if (damageKeyToNumber(x) <= hpDamage) return acc || (rule.enabled && availableStress >= rule.cost);
+            return acc;
+        }, false);
+
+        return canUseArmor || canUseStress;
+    }
+
+    async takeDamage(baseDamage, type) {
+        if (Hooks.call(`${CONFIG.DH.id}.preTakeDamage`, this, baseDamage, type) === false) return null;
 
         if (this.type === 'companion') {
             await this.modifyResource([{ value: 1, type: 'stress' }]);
             return;
         }
 
+        const flatReduction = this.system.bonuses.damageReduction[type];
+        const damage = Math.max(baseDamage - (flatReduction ?? 0), 0);
         const hpDamage = this.convertDamageToThreshold(damage);
 
         if (Hooks.call(`${CONFIG.DH.id}.postDamageTreshold`, this, hpDamage, damage, type) === false) return null;
@@ -471,12 +490,12 @@ export default class DhpActor extends Actor {
 
         const updates = [{ value: hpDamage, type: 'hitPoints' }];
 
-        if (
-            this.type === 'character' &&
-            this.system.armor &&
-            this.system.armor.system.marks.value < this.system.armorScore
-        ) {
-            const armorStackResult = await this.owner.query('armorStack', { actorId: this.uuid, damage: hpDamage });
+        if (this.type === 'character' && this.system.armor && this.#canReduceDamage(hpDamage, type)) {
+            const armorStackResult = await this.owner.query('armorStack', {
+                actorId: this.uuid,
+                damage: hpDamage,
+                type: type
+            });
             if (armorStackResult) {
                 const { modifiedDamage, armorSpent, stressSpent } = armorStackResult;
                 updates.find(u => u.type === 'hitPoints').value = modifiedDamage;

module/documents/item.mjs

@@ -90,10 +90,12 @@ export default class DHItem extends foundry.documents.Item {
             ok: {
                 label: title,
                 callback: (event, button, dialog) => {
-                    Object.defineProperty(prevEvent, "shiftKey", {
-                        get() { return event.shiftKey; },
+                    Object.defineProperty(prevEvent, 'shiftKey', {
+                        get() {
+                            return event.shiftKey;
+                        }
                     });
-                    return this.system.actionsList.find(a => a._id === button.form.elements.actionId.value)
+                    return this.system.actionsList.find(a => a._id === button.form.elements.actionId.value);
                 }
             }
         });

module/documents/tooltipManager.mjs

@@ -2,15 +2,33 @@ export default class DhTooltipManager extends foundry.helpers.interaction.Toolti
     async activate(element, options = {}) {
         let html = options.html;
         if (element.dataset.tooltip?.startsWith('#item#')) {
-            const item = await foundry.utils.fromUuid(element.dataset.tooltip.slice(6));
+            const splitValues = element.dataset.tooltip.slice(6).split('#action#');
+            const itemUuid = splitValues[0];
+            const actionId = splitValues.length > 1 ? splitValues[1] : null;
+
+            const baseItem = await foundry.utils.fromUuid(itemUuid);
+            const item = actionId ? baseItem.system.actions.find(x => x.id === actionId) : baseItem;
             if (item) {
+                const type = actionId ? 'action' : item.type;
                 html = await foundry.applications.handlebars.renderTemplate(
-                    `systems/daggerheart/templates/ui/tooltip/${item.type}.hbs`,
-                    item
+                    `systems/daggerheart/templates/ui/tooltip/${type}.hbs`,
+                    {
+                        item: item,
+                        config: CONFIG.DH
+                    }
                 );
+
+                this.tooltip.innerHTML = html;
+                options.direction = this._determineItemTooltipDirection(element);
             }
         }
 
         super.activate(element, { ...options, html: html });
     }
+
+    _determineItemTooltipDirection(element) {
+        const pos = element.getBoundingClientRect();
+        const dirs = this.constructor.TOOLTIP_DIRECTIONS;
+        return dirs[pos.x - this.tooltip.offsetWidth < 0 ? 'DOWN' : 'LEFT'];
+    }
 }