Roll All Save button + Merge Attack & Roll Chat message

module/data/action/action.mjs

@@ -308,14 +308,14 @@ export class DHBaseAction extends foundry.abstract.DataModel {
     prepareTarget() {
         let targets;
         if (this.target?.type === SYSTEM.ACTIONS.targetTypes.self.id)
-            targets = this.formatTarget(this.actor.token ?? this.actor.prototypeToken);
+            targets = this.constructor.formatTarget(this.actor.token ?? this.actor.prototypeToken);
         targets = Array.from(game.user.targets);
         // foundry.CONST.TOKEN_DISPOSITIONS.FRIENDLY
         if (this.target?.type && this.target.type !== SYSTEM.ACTIONS.targetTypes.any.id) {
             targets = targets.filter(t => this.isTargetFriendly(t));
             if (this.target.amount && targets.length > this.target.amount) targets = [];
         }
-        targets = targets.map(t => this.formatTarget(t));
+        targets = targets.map(t => this.constructor.formatTarget(t));
         return targets;
 
     }
@@ -387,7 +387,12 @@ export class DHBaseAction extends foundry.abstract.DataModel {
     }
 
     hasCost(costs) {
-        const realCosts = this.getRealCosts(costs);
+        const realCosts = this.getRealCosts(costs),
+            hasFearCost = realCosts.findIndex(c => c.type === 'fear');
+        if(hasFearCost > -1) {
+            const fearCost = realCosts.splice(hasFearCost, 1);
+            if(!game.user.isGM || fearCost[0].total > game.settings.get(SYSTEM.id, SYSTEM.SETTINGS.gameSettings.Resources.Fear)) return false;
+        }
         return realCosts.reduce((a, c) => a && this.actor.system.resources[c.type]?.value >= (c.total ?? c.value), true);
     }
     /* COST */
@@ -419,7 +424,7 @@ export class DHBaseAction extends foundry.abstract.DataModel {
         );
     }
 
-    formatTarget(actor) {
+    static formatTarget(actor) {
         return {
             id: actor.id,
             actorId: actor.actor.uuid,
@@ -436,10 +441,11 @@ export class DHBaseAction extends foundry.abstract.DataModel {
     /* RANGE */
 
     /* EFFECTS */
-    async applyEffects(event, data, force = false) {
-        if (!this.effects?.length || !data.system.targets.length) return;
+    async applyEffects(event, data, targets) {
+        targets ??= data.system.targets;
+        if (!this.effects?.length || !targets.length) return;
         let effects = this.effects;
-        data.system.targets.forEach(async token => {
+        targets.forEach(async token => {
             if (!token.hit && !force) return;
             if(this.hasSave && token.saved.success === true) {
                 effects = this.effects.filter(e => e.onSave === true)
@@ -480,7 +486,7 @@ export class DHBaseAction extends foundry.abstract.DataModel {
     /* SAVE */
     async rollSave(target, event, message) {
         if(!target?.actor) return;
-        target.actor.diceRoll({
+        return target.actor.diceRoll({
             event,
             title: 'Roll Save',
             roll: {
@@ -516,13 +522,6 @@ export class DHBaseAction extends foundry.abstract.DataModel {
 export class DHDamageAction extends DHBaseAction {
     static extraSchemas = ['damage', 'target', 'effects'];
 
-    /* async use(event, ...args) {
-        const config = await super.use(event, args);
-        if (!config || ['error', 'warning'].includes(config.type)) return;
-        if (!this.directDamage) return;
-        return await this.rollDamage(event, config);
-    } */
-
     getFormulaValue(part, data) {
         let formulaValue = part.value;
         if(this.hasRoll && part.resultBased && data.system.roll.result.duality === -1) return part.valueAlt;

module/data/chat-message/adversaryRoll.mjs

@@ -1,7 +1,9 @@
+import { DHBaseAction } from "../action/action.mjs";
+
+const fields = foundry.data.fields;
+
 export default class DHAdversaryRoll extends foundry.abstract.TypeDataModel {
     static defineSchema() {
-        const fields = foundry.data.fields;
-
         return {
             title: new fields.StringField(),
             roll: new fields.DataField(),
@@ -20,6 +22,7 @@ export default class DHAdversaryRoll extends foundry.abstract.TypeDataModel {
                     })
                 })
             ),
+            targetSelection: new fields.BooleanField({ initial: true }),
             hasDamage: new fields.BooleanField({ initial: false }),
             hasHealing: new fields.BooleanField({ initial: false }),
             hasEffect: new fields.BooleanField({ initial: false }),
@@ -28,11 +31,17 @@ export default class DHAdversaryRoll extends foundry.abstract.TypeDataModel {
                 actor: new fields.StringField(),
                 item: new fields.StringField(),
                 action: new fields.StringField()
-            })
+            }),
+            damage: new fields.ObjectField()
         };
     }
 
     get messageTemplate() {
         return 'systems/daggerheart/templates/chat/adversary-roll.hbs';
     }
+
+    prepareDerivedData() {
+        this.hasHitTarget = this.targets.filter(t => t.hit === true).length > 0;
+        this.currentTargets = this.targetSelection !== true ? Array.from(game.user.targets).map(t => DHBaseAction.formatTarget(t)) : this.targets;
+    }
 }

module/data/chat-message/damageRoll.mjs

@@ -19,6 +19,7 @@ export default class DHDamageRoll extends foundry.abstract.TypeDataModel {
                     })
                 })
             ),
+            targetSelection: new fields.BooleanField({ initial: true }),
             hasSave: new fields.BooleanField({ initial: false }),
             onSave: new fields.StringField(),
             source: new fields.SchemaField({
@@ -34,4 +35,9 @@ export default class DHDamageRoll extends foundry.abstract.TypeDataModel {
     get messageTemplate() {
         return `systems/daggerheart/templates/chat/${this.messageType}-roll.hbs`;
     }
+
+    prepareDerivedData() {
+        this.hasHitTarget = this.targets.filter(t => t.hit === true).length > 0;
+        this.currentTargets = this.targetSelection !== true ? Array.from(game.user.targets).map(t => DHBaseAction.formatTarget(t)) : this.targets;
+    }
 }

module/data/chat-message/dualityRoll.mjs

@@ -1,44 +1,6 @@
-const fields = foundry.data.fields;
-
-export default class DHDualityRoll extends foundry.abstract.TypeDataModel {
-    static dualityResult = {
-        hope: 1,
-        fear: 2,
-        critical: 3
-    };
-
-    static defineSchema() {
-        return {
-            title: new fields.StringField(),
-            roll: new fields.DataField({}),
-            targets: new fields.ArrayField(
-                new fields.SchemaField({
-                    id: new fields.StringField({}),
-                    actorId: new fields.StringField({}),
-                    name: new fields.StringField({}),
-                    img: new fields.StringField({}),
-                    difficulty: new fields.NumberField({ integer: true, nullable: true }),
-                    evasion: new fields.NumberField({ integer: true }),
-                    hit: new fields.BooleanField({ initial: false }),
-                    saved: new fields.SchemaField({
-                        result: new fields.NumberField(),
-                        success: new fields.BooleanField({ nullable: true, initial: null })
-                    })
-                })
-            ),
-            costs: new fields.ArrayField(new fields.ObjectField()),
-            hasDamage: new fields.BooleanField({ initial: false }),
-            hasHealing: new fields.BooleanField({ initial: false }),
-            hasEffect: new fields.BooleanField({ initial: false }),
-            hasSave: new fields.BooleanField({ initial: false }),
-            source: new fields.SchemaField({
-                actor: new fields.StringField(),
-                item: new fields.StringField(),
-                action: new fields.StringField()
-            })
-        };
-    }
+import DHAdversaryRoll from "./adversaryRoll.mjs";
 
+export default class DHDualityRoll extends DHAdversaryRoll {
     get messageTemplate() {
         return 'systems/daggerheart/templates/chat/duality-roll.hbs';
     }