Merged with main

module/documents/activeEffect.mjs

@@ -1,16 +1,44 @@
 export default class DhActiveEffect extends ActiveEffect {
     get isSuppressed() {
-        if (['weapon', 'armor'].includes(this.parent.type)) {
+        // If this is a copied effect from an attachment, never suppress it
+        // (These effects have attachmentSource metadata)
+        if (this.flags?.daggerheart?.attachmentSource) {
+            return false;
+        }
+
+        // Then apply the standard suppression rules
+        if (['weapon', 'armor'].includes(this.parent?.type)) {
             return !this.parent.system.equipped;
         }
 
-        if (this.parent.type === 'domainCard') {
+        if (this.parent?.type === 'domainCard') {
             return this.parent.system.inVault;
         }
 
         return super.isSuppressed;
     }
 
+    /**
+     * Check if the parent item is currently attached to another item
+     * @returns {boolean}
+     */
+    get isAttached() {
+        if (!this.parent || !this.parent.parent) return false;
+
+        // Check if this item's UUID is in any actor's armor or weapon attachment lists
+        const actor = this.parent.parent;
+        if (!actor || !actor.items) return false;
+
+        return actor.items.some(item => {
+            return (
+                (item.type === 'armor' || item.type === 'weapon') &&
+                item.system?.attached &&
+                Array.isArray(item.system.attached) &&
+                item.system.attached.includes(this.parent.uuid)
+            );
+        });
+    }
+
     async _preCreate(data, options, user) {
         const update = {};
         if (!data.img) {

module/documents/actor.mjs

@@ -370,7 +370,10 @@ export default class DhpActor extends Actor {
     }
 
     getRollData() {
-        return this.system;
+        const rollData = super.getRollData();
+        rollData.prof = this.system.proficiency?.total ?? 1;
+        rollData.cast = this.system.spellcast?.total ?? 1;
+        return rollData;
     }
 
     formatRollModifier(roll) {
@@ -462,7 +465,7 @@ export default class DhpActor extends Actor {
         const canUseArmor =
             this.system.armor &&
             this.system.armor.system.marks.value < this.system.armorScore &&
-            this.system.armorApplicableDamageTypes[type];
+            type.every(t => this.system.armorApplicableDamageTypes[t] === true);
         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);
@@ -480,11 +483,9 @@ export default class DhpActor extends Actor {
             return;
         }
 
-        const flatReduction = this.system.bonuses.damageReduction[type];
-        const damage = Math.max(baseDamage - (flatReduction ?? 0), 0);
-        const hpDamage = this.convertDamageToThreshold(damage);
+        type = !Array.isArray(type) ? [type] : type;
 
-        if (Hooks.call(`${CONFIG.DH.id}.postDamageTreshold`, this, hpDamage, damage, type) === false) return null;
+        const hpDamage = this.calculateDamage(baseDamage, type);
 
         if (!hpDamage) return;
 
@@ -511,6 +512,38 @@ export default class DhpActor extends Actor {
         if (Hooks.call(`${CONFIG.DH.id}.postTakeDamage`, this, damage, type) === false) return null;
     }
 
+    calculateDamage(baseDamage, type) {
+        if (Hooks.call(`${CONFIG.DH.id}.preCalculateDamage`, this, baseDamage, type) === false) return null;
+
+        /* if(this.system.resistance[type]?.immunity) return 0;
+        if(this.system.resistance[type]?.resistance) baseDamage = Math.ceil(baseDamage / 2); */
+        if (this.canResist(type, 'immunity')) return 0;
+        if (this.canResist(type, 'resistance')) baseDamage = Math.ceil(baseDamage / 2);
+
+        // const flatReduction = this.system.resistance[type].reduction;
+        const flatReduction = this.getDamageTypeReduction(type);
+        const damage = Math.max(baseDamage - (flatReduction ?? 0), 0);
+        const hpDamage = this.convertDamageToThreshold(damage);
+
+        if (Hooks.call(`${CONFIG.DH.id}.postCalculateDamage`, this, baseDamage, type) === false) return null;
+
+        return hpDamage;
+    }
+
+    canResist(type, resistance) {
+        if (!type) return 0;
+        return type.every(t => this.system.resistance[t]?.[resistance] === true);
+    }
+
+    getDamageTypeReduction(type) {
+        if (!type) return 0;
+        const reduction = Object.entries(this.system.resistance).reduce(
+            (a, [index, value]) => (type.includes(index) ? Math.min(value.reduction, a) : a),
+            Infinity
+        );
+        return reduction === Infinity ? 0 : reduction;
+    }
+
     async takeHealing(resources) {
         resources.forEach(r => (r.value *= -1));
         await this.modifyResource(resources);
@@ -577,18 +610,6 @@ export default class DhpActor extends Actor {
                         u.resources,
                         u.target.uuid
                     );
-                    /* if (game.user.isGM) {
-                        await u.target.update(u.resources);
-                    } else {
-                        await game.socket.emit(`system.${CONFIG.DH.id}`, {
-                            action: socketEvent.GMUpdate,
-                            data: {
-                                action: GMUpdateEvent.UpdateDocument,
-                                uuid: u.target.uuid,
-                                update: u.resources
-                            }
-                        });
-                    } */
                 }
             }
         });