Merged with development

module/data/fields/action/saveField.mjs

@@ -1,6 +1,14 @@
+import { abilities } from '../../../config/actorConfig.mjs';
+
 const fields = foundry.data.fields;
 
 export default class SaveField extends fields.SchemaField {
+    /**
+     * Action Workflow order
+     */
+    static order = 50;
+
+    /** @inheritDoc */
     constructor(options = {}, context = {}) {
         const saveFields = {
             trait: new fields.StringField({
@@ -16,4 +24,157 @@ export default class SaveField extends fields.SchemaField {
         };
         super(saveFields, options, context);
     }
+
+    /**
+     * Reaction Roll Action Workflow part.
+     * Must be called within Action context or similar.
+     * @param {object} config                    Object that contains workflow datas. Usually made from Action Fields prepareConfig methods.
+     * @param {object[]} [targets=null]     Array of targets to override pre-selected ones.
+     * @param {boolean} [force=false]       If the method should be executed outside of Action workflow, for ChatMessage button for example.
+     */
+    static async execute(config, targets = null, force = false) {
+        if (!config.hasSave) return;
+        let message = config.message ?? ui.chat.collection.get(config.parent?._id);
+
+        if (!message) {
+            const roll = new CONFIG.Dice.daggerheart.DHRoll('');
+            roll._evaluated = true;
+            message = config.message = await CONFIG.Dice.daggerheart.DHRoll.toMessage(roll, config);
+        }
+        if (SaveField.getAutomation() !== CONFIG.DH.SETTINGS.actionAutomationChoices.never.id || force) {
+            targets ??= config.targets.filter(t => !config.hasRoll || t.hit);
+            await SaveField.rollAllSave.call(this, targets, config.event, message);
+        } else return false;
+    }
+
+    /**
+     * Roll a Reaction Roll for all targets. Send a query to the owner if the User is not.
+     * Must be called within Action context.
+     * @param {object[]} targets        Array of formatted targets.
+     * @param {Event} event             Triggering event
+     * @param {ChatMessage} message     The ChatMessage the triggered button comes from.
+     */
+    static async rollAllSave(targets, event, message) {
+        if (!targets) return;
+        return new Promise(resolve => {
+            const aPromise = [];
+            targets.forEach(target => {
+                aPromise.push(
+                    new Promise(async subResolve => {
+                        const actor = fromUuidSync(target.actorId);
+                        if (actor) {
+                            const rollSave =
+                                game.user === actor.owner
+                                    ? SaveField.rollSave.call(this, actor, event)
+                                    : actor.owner.query('reactionRoll', {
+                                          actionId: this.uuid,
+                                          actorId: actor.uuid,
+                                          event,
+                                          message
+                                      });
+                            const result = await rollSave;
+                            await SaveField.updateSaveMessage.call(this, result, message, target.id);
+                            subResolve();
+                        } else subResolve();
+                    })
+                );
+            });
+            Promise.all(aPromise).then(result => resolve());
+        });
+    }
+
+    /**
+     * Roll a Reaction Roll for the specified Actor against the Action difficulty.
+     * Must be called within Action context.
+     * @param {*} actor         Actor document
+     * @param {Event} event     Triggering event
+     * @returns {object}        Actor diceRoll config result.
+     */
+    static async rollSave(actor, event) {
+        if (!actor) return;
+        const title = actor.isNPC
+                ? game.i18n.localize('DAGGERHEART.GENERAL.reactionRoll')
+                : game.i18n.format('DAGGERHEART.UI.Chat.dualityRoll.abilityCheckTitle', {
+                      ability: game.i18n.localize(abilities[this.save.trait]?.label)
+                  }),
+            rollConfig = {
+                event,
+                title,
+                roll: {
+                    trait: this.save.trait,
+                    difficulty: this.save.difficulty ?? this.actor?.baseSaveDifficulty,
+                    type: 'trait'
+                },
+                actionType: 'reaction',
+                hasRoll: true,
+                data: actor.getRollData()
+            };
+        if (SaveField.getAutomation() === CONFIG.DH.SETTINGS.actionAutomationChoices.always.id)
+            rollConfig.dialog = { configure: false };
+        return actor.diceRoll(rollConfig);
+    }
+
+    /**
+     * Update a Roll ChatMessage for a token according to his Reaction Roll result.
+     * @param {object} result        Result from the Reaction Roll
+     * @param {object} message       ChatMessage to update
+     * @param {string} targetId      Token ID
+     */
+    static async updateSaveMessage(result, message, targetId) {
+        if (!result) return;
+        const updateMsg = async function (message, targetId, result) {
+            // setTimeout(async () => {
+            const chatMessage = ui.chat.collection.get(message._id),
+                changes = {
+                    flags: {
+                        [game.system.id]: {
+                            reactionRolls: {
+                                [targetId]: {
+                                    result: result.roll.total,
+                                    success: result.roll.success
+                                }
+                            }
+                        }
+                    }
+                };
+            await chatMessage.update(changes);
+            // }, 100);
+        };
+        if (game.modules.get('dice-so-nice')?.active)
+            game.dice3d
+                .waitFor3DAnimationByMessageID(result.message.id ?? result.message._id)
+                .then(async () => await updateMsg(message, targetId, result));
+        else await updateMsg(message, targetId, result);
+    }
+
+    /**
+     * Return the automation setting for execute method for current user role
+     * @returns {string} Id from settingsConfig.mjs actionAutomationChoices
+     */
+    static getAutomation() {
+        return (
+            (game.user.isGM &&
+                game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Automation).roll.save.gm) ||
+            (!game.user.isGM &&
+                game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Automation).roll.save.players)
+        );
+    }
+
+    /**
+     * Send a query to an Actor owner to roll a Reaction Roll then send back the result.
+     * @param {object} param0
+     * @param {string} param0.actionId         Action ID
+     * @param {string} param0.actorId          Actor ID
+     * @param {Event} param0.event             Triggering event
+     * @param {ChatMessage} param0.message     Chat Message to update
+     * @returns
+     */
+    static rollSaveQuery({ actionId, actorId, event, message }) {
+        return new Promise(async (resolve, reject) => {
+            const actor = await fromUuid(actorId),
+                action = await fromUuid(actionId);
+            if (!actor || !actor?.isOwner) reject();
+            SaveField.rollSave.call(action, actor, event, message).then(result => resolve(result));
+        });
+    }
 }