Fix conflict

module/applications/characterCreation/characterCreation.mjs

@@ -1,5 +1,6 @@
 import { abilities } from '../../config/actorConfig.mjs';
 import { burden } from '../../config/generalConfig.mjs';
+import { createEmbeddedItemWithEffects } from '../../helpers/utils.mjs';
 
 const { HandlebarsApplicationMixin, ApplicationV2 } = foundry.applications.api;
 
@@ -550,34 +551,46 @@ export default class DhCharacterCreation extends HandlebarsApplicationMixin(Appl
             }
         };
 
-        await this.character.createEmbeddedDocuments('Item', [ancestry]);
-        await this.character.createEmbeddedDocuments('Item', [this.setup.community]);
-        await this.character.createEmbeddedDocuments('Item', [this.setup.class]);
-        await this.character.createEmbeddedDocuments('Item', [this.setup.subclass]);
-        await this.character.createEmbeddedDocuments('Item', Object.values(this.setup.domainCards));
-
-        if (this.equipment.armor.uuid)
-            await this.character.createEmbeddedDocuments('Item', [
-                { ...this.equipment.armor, system: { ...this.equipment.armor.system, equipped: true } }
-            ]);
-        if (this.equipment.primaryWeapon.uuid)
-            await this.character.createEmbeddedDocuments('Item', [
-                { ...this.equipment.primaryWeapon, system: { ...this.equipment.primaryWeapon.system, equipped: true } }
-            ]);
-        if (this.equipment.secondaryWeapon.uuid)
-            await this.character.createEmbeddedDocuments('Item', [
-                {
-                    ...this.equipment.secondaryWeapon,
-                    system: { ...this.equipment.secondaryWeapon.system, equipped: true }
-                }
-            ]);
-        if (this.equipment.inventory.choiceA.uuid)
-            await this.character.createEmbeddedDocuments('Item', [this.equipment.inventory.choiceA]);
-        if (this.equipment.inventory.choiceB.uuid)
-            await this.character.createEmbeddedDocuments('Item', [this.equipment.inventory.choiceB]);
+        await createEmbeddedItemWithEffects(this.character, ancestry);
+        await createEmbeddedItemWithEffects(this.character, this.setup.community);
+        await createEmbeddedItemWithEffects(this.character, this.setup.class);
+        await createEmbeddedItemWithEffects(this.character, this.setup.subclass);
         await this.character.createEmbeddedDocuments(
             'Item',
-            this.setup.class.system.inventory.take.filter(x => x)
+            Object.values(this.setup.domainCards).map(x => ({
+                ...x,
+                effects: x.effects?.map(effect => effect.toObject())
+            }))
+        );
+
+        if (this.equipment.armor.uuid)
+            await createEmbeddedItemWithEffects(this.character, this.equipment.armor, {
+                ...this.equipment.armor,
+                system: { ...this.equipment.armor.system, equipped: true }
+            });
+        if (this.equipment.primaryWeapon.uuid)
+            await createEmbeddedItemWithEffects(this.character, this.equipment.primaryWeapon, {
+                ...this.equipment.primaryWeapon,
+                system: { ...this.equipment.primaryWeapon.system, equipped: true }
+            });
+        if (this.equipment.secondaryWeapon.uuid)
+            await createEmbeddedItemWithEffects(this.character, this.equipment.secondaryWeapon, {
+                ...this.equipment.secondaryWeapon,
+                system: { ...this.equipment.secondaryWeapon.system, equipped: true }
+            });
+        if (this.equipment.inventory.choiceA.uuid)
+            await createEmbeddedItemWithEffects(this.character, this.equipment.inventory.choiceA);
+        if (this.equipment.inventory.choiceB.uuid)
+            await createEmbeddedItemWithEffects(this.character, this.equipment.inventory.choiceB);
+
+        await this.character.createEmbeddedDocuments(
+            'Item',
+            this.setup.class.system.inventory.take
+                .filter(x => x)
+                .map(x => ({
+                    ...x,
+                    effects: x.effects?.map(effect => effect.toObject())
+                }))
         );
 
         await this.character.update({

module/applications/dialogs/damageReductionDialog.mjs

@@ -10,14 +10,18 @@ export default class DamageReductionDialog extends HandlebarsApplicationMixin(Ap
         this.reject = reject;
         this.actor = actor;
         this.damage = damage;
+        this.rulesDefault = game.settings.get(
+            CONFIG.DH.id,
+            CONFIG.DH.SETTINGS.gameSettings.Automation
+        ).damageReductionRulesDefault;
+
+        this.rulesOn = [CONFIG.DH.GENERAL.ruleChoice.on.id, CONFIG.DH.GENERAL.ruleChoice.onWithToggle.id].includes(
+            this.rulesDefault
+        );
 
         const canApplyArmor = damageType.every(t => actor.system.armorApplicableDamageTypes[t] === true);
-        const maxArmorMarks = canApplyArmor
-            ? Math.min(
-                  actor.system.armorScore - actor.system.armor.system.marks.value,
-                  actor.system.rules.damageReduction.maxArmorMarked.value
-              )
-            : 0;
+        const availableArmor = actor.system.armorScore - actor.system.armor.system.marks.value;
+        const maxArmorMarks = canApplyArmor ? availableArmor : 0;
 
         const armor = [...Array(maxArmorMarks).keys()].reduce((acc, _) => {
             acc[foundry.utils.randomID()] = { selected: false };
@@ -42,6 +46,7 @@ export default class DamageReductionDialog extends HandlebarsApplicationMixin(Ap
                     acc[damage] = {
                         cost: dr.cost,
                         selected: false,
+                        any: key === 'any',
                         from: getDamageLabel(damage),
                         to: getDamageLabel(damage - 1)
                     };
@@ -51,16 +56,28 @@ export default class DamageReductionDialog extends HandlebarsApplicationMixin(Ap
             },
             null
         );
+
+        this.thresholdImmunities = Object.keys(actor.system.rules.damageReduction.thresholdImmunities).reduce(
+            (acc, key) => {
+                if (actor.system.rules.damageReduction.thresholdImmunities[key])
+                    acc[damageKeyToNumber(key)] = game.i18n.format(`DAGGERHEART.GENERAL.DamageThresholds.with`, {
+                        threshold: game.i18n.localize(`DAGGERHEART.GENERAL.DamageThresholds.${key}`)
+                    });
+                return acc;
+            },
+            {}
+        );
     }
 
     static DEFAULT_OPTIONS = {
         tag: 'form',
         classes: ['daggerheart', 'views', 'damage-reduction'],
         position: {
-            width: 240,
+            width: 280,
             height: 'auto'
         },
         actions: {
+            toggleRules: this.toggleRules,
             setMarks: this.setMarks,
             useStressReduction: this.useStressReduction,
             takeDamage: this.takeDamage
@@ -89,6 +106,12 @@ export default class DamageReductionDialog extends HandlebarsApplicationMixin(Ap
 
     async _prepareContext(_options) {
         const context = await super._prepareContext(_options);
+        context.rulesOn = this.rulesOn;
+        context.rulesToggleable = [
+            CONFIG.DH.GENERAL.ruleChoice.onWithToggle.id,
+            CONFIG.DH.GENERAL.ruleChoice.offWithToggle.id
+        ].includes(this.rulesDefault);
+        context.thresholdImmunities = this.thresholdImmunities;
 
         const { selectedArmorMarks, selectedStressMarks, stressReductions, currentMarks, currentDamage } =
             this.getDamageInfo();
@@ -110,12 +133,22 @@ export default class DamageReductionDialog extends HandlebarsApplicationMixin(Ap
                   }
                 : null;
 
-        context.marks = this.marks;
+        const maxArmor = this.actor.system.rules.damageReduction.maxArmorMarked.value;
+        context.marks = {
+            armor: Object.keys(this.marks.armor).reduce((acc, key, index) => {
+                const mark = this.marks.armor[key];
+                if (!this.rulesOn || index + 1 <= maxArmor) acc[key] = mark;
+
+                return acc;
+            }, {}),
+            stress: this.marks.stress
+        };
         context.availableStressReductions = this.availableStressReductions;
 
         context.damage = getDamageLabel(this.damage);
         context.reducedDamage = currentDamage !== this.damage ? getDamageLabel(currentDamage) : null;
         context.currentDamage = context.reducedDamage ?? context.damage;
+        context.currentDamageNr = currentDamage;
 
         return context;
     }
@@ -136,22 +169,48 @@ export default class DamageReductionDialog extends HandlebarsApplicationMixin(Ap
 
         const armorMarkReduction =
             selectedArmorMarks.length * this.actor.system.rules.damageReduction.increasePerArmorMark;
-        const currentDamage = this.damage - armorMarkReduction - selectedStressMarks.length - stressReductions.length;
+        let currentDamage = Math.max(
+            this.damage - armorMarkReduction - selectedStressMarks.length - stressReductions.length,
+            0
+        );
+
+        if (this.thresholdImmunities[currentDamage]) currentDamage = 0;
 
         return { selectedArmorMarks, selectedStressMarks, stressReductions, currentMarks, currentDamage };
     };
 
+    static toggleRules() {
+        this.rulesOn = !this.rulesOn;
+
+        const maxArmor = this.actor.system.rules.damageReduction.maxArmorMarked.value;
+        this.marks = {
+            armor: Object.keys(this.marks.armor).reduce((acc, key, index) => {
+                const mark = this.marks.armor[key];
+                const keepSelectValue = !this.rulesOn || index + 1 <= maxArmor;
+                acc[key] = { ...mark, selected: keepSelectValue ? mark.selected : false };
+
+                return acc;
+            }, {}),
+            stress: this.marks.stress
+        };
+
+        this.render();
+    }
+
     static setMarks(_, target) {
         const currentMark = this.marks[target.dataset.type][target.dataset.key];
         const { selectedStressMarks, stressReductions, currentMarks, currentDamage } = this.getDamageInfo();
+
         if (!currentMark.selected && currentDamage === 0) {
             ui.notifications.info(game.i18n.localize('DAGGERHEART.UI.Notifications.damageAlreadyNone'));
             return;
         }
 
-        if (!currentMark.selected && currentMarks === this.actor.system.armorScore) {
-            ui.notifications.info(game.i18n.localize('DAGGERHEART.UI.Notifications.noAvailableArmorMarks'));
-            return;
+        if (this.rulesOn) {
+            if (!currentMark.selected && currentMarks === this.actor.system.armorScore) {
+                ui.notifications.info(game.i18n.localize('DAGGERHEART.UI.Notifications.noAvailableArmorMarks'));
+                return;
+            }
         }
 
         if (currentMark.selected) {

module/applications/dialogs/downtime.mjs

@@ -24,6 +24,8 @@ export default class DhpDowntime extends HandlebarsApplicationMixin(ApplicationV
                     actor.system.bonuses.rest[`${shortrest ? 'short' : 'long'}Rest`].longMoves
             }
         };
+
+        this.refreshables = this.getRefreshables();
     }
 
     get title() {
@@ -81,11 +83,56 @@ export default class DhpDowntime extends HandlebarsApplicationMixin(ApplicationV
         context.shortRestMoves = this.nrChoices.shortRest.max > 0 ? this.moveData.shortRest : null;
         context.longRestMoves = this.nrChoices.longRest.max > 0 ? this.moveData.longRest : null;
 
+        context.refreshables = this.refreshables;
+
         context.disabledDowntime = shortRestMovesSelected === 0 && longRestMovesSelected === 0;
 
         return context;
     }
 
+    getRefreshables() {
+        const actionItems = this.actor.items.reduce((acc, x) => {
+            if (x.system.actions) {
+                const recoverable = x.system.actions.reduce((acc, action) => {
+                    if (action.uses.recovery && (action.uses.recovery === 'shortRest') === this.shortrest) {
+                        acc.push({
+                            title: x.name,
+                            name: action.name,
+                            uuid: action.uuid
+                        });
+                    }
+
+                    return acc;
+                }, []);
+
+                if (recoverable) {
+                    acc.push(...recoverable);
+                }
+            }
+
+            return acc;
+        }, []);
+        const resourceItems = this.actor.items.reduce((acc, x) => {
+            if (
+                x.system.resource &&
+                x.system.resource.type &&
+                (x.system.resource.recovery === 'shortRest') === this.shortrest
+            ) {
+                acc.push({
+                    title: game.i18n.localize(`TYPES.Item.${x.type}`),
+                    name: x.name,
+                    uuid: x.uuid
+                });
+            }
+
+            return acc;
+        }, []);
+        return {
+            actionItems,
+            resourceItems
+        };
+    }
+
     static selectMove(_, target) {
         const { category, move } = target.dataset;
 
@@ -172,11 +219,24 @@ export default class DhpDowntime extends HandlebarsApplicationMixin(ApplicationV
             }
         }
 
-        // We can close the window when all moves are taken
+        // We can close the window and refresh resources when all moves are taken
         if (
             this.nrChoices.shortRest.taken >= this.nrChoices.shortRest.max &&
             this.nrChoices.longRest.taken >= this.nrChoices.longRest.max
         ) {
+            for (var data of this.refreshables.actionItems) {
+                const action = await foundry.utils.fromUuid(data.uuid);
+                await action.parent.parent.update({ [`system.actions.${action.id}.uses.value`]: action.uses.max ?? 1 });
+            }
+
+            for (var data of this.refreshables.resourceItems) {
+                const feature = await foundry.utils.fromUuid(data.uuid);
+                const increasing =
+                    feature.system.resource.progression === CONFIG.DH.ITEM.itemResourceProgression.increasing.id;
+                const resetValue = increasing ? 0 : (feature.system.resource.max ?? 0);
+                await feature.update({ 'system.resource.value': resetValue });
+            }
+
             this.close();
         } else {
             this.render();

module/applications/sheets/api/application-mixin.mjs

@@ -130,7 +130,7 @@ export default function DHApplicationMixin(Base) {
                 docs.push(doc);
             }
 
-            docs.filter(doc => doc).map(doc => (doc.apps[this.id] = this));
+            docs.filter(doc => doc).forEach(doc => (doc.apps[this.id] = this));
 
             if (!!this.options.contextMenus.length) this._createContextMenus();
         }

module/applications/sheets/items/class.mjs

@@ -80,10 +80,17 @@ export default class ClassSheet extends DHBaseItemSheet {
             'inventory.choiceB'
         ];
 
-        paths.forEach(path => {
-            const docs = [].concat(foundry.utils.getProperty(this.document, `system.${path}`) ?? []);
-            docs.forEach(doc => (doc.apps[this.id] = this));
-        });
+        for (let path of paths) {
+            const docDatas = [].concat(foundry.utils.getProperty(this.document, `system.${path}`) ?? []);
+
+            const docs = [];
+            for (var docData of docDatas) {
+                const doc = await foundry.utils.fromUuid(docData.uuid);
+                docs.push(doc);
+            }
+
+            docs.filter(doc => doc).forEach(doc => (doc.apps[this.id] = this));
+        }
     }
 
     /**@inheritdoc */