Merged with development

module/data/fields/action/_module.mjs

@@ -6,6 +6,5 @@ export { default as EffectsField } from './effectsField.mjs';
 export { default as SaveField } from './saveField.mjs';
 export { default as BeastformField } from './beastformField.mjs';
 export { default as DamageField } from './damageField.mjs';
-export { default as HealingField } from './healingField.mjs';
 export { default as RollField } from './rollField.mjs';
 export { default as MacroField } from './macroField.mjs';

module/data/fields/action/beastformField.mjs

@@ -1,6 +1,13 @@
+import BeastformDialog from '../../../applications/dialogs/beastformDialog.mjs';
+
 const fields = foundry.data.fields;
 
 export default class BeastformField extends fields.SchemaField {
+    /**
+     * Action Workflow order
+     */
+    static order = 90;
+
     constructor(options = {}, context = {}) {
         const beastformFields = {
             tierAccess: new fields.SchemaField({
@@ -27,4 +34,96 @@ export default class BeastformField extends fields.SchemaField {
         };
         super(beastformFields, options, context);
     }
+
+    /**
+     * Beastform Transformation 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.
+     */
+    static async execute(config) {
+        // Should not be useful anymore here
+        await BeastformField.handleActiveTransformations.call(this);
+
+        const { selected, evolved, hybrid } = await BeastformDialog.configure(config, this.item);
+        if (!selected) return false;
+
+        return await BeastformField.transform.call(this, selected, evolved, hybrid);
+    }
+
+    /**
+     * Update Action Workflow config object.
+     * Must be called within Action context.
+     * @param {object} config    Object that contains workflow datas. Usually made from Action Fields prepareConfig methods.
+     */
+    prepareConfig(config) {
+        if (this.actor.effects.find(x => x.type === 'beastform')) {
+            ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.Notifications.beastformAlreadyApplied'));
+            return false;
+        }
+
+        const settingsTiers = game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.LevelTiers).tiers;
+        const actorLevel = this.actor.system.levelData.level.current;
+        const actorTier =
+            Object.values(settingsTiers).find(
+                tier => actorLevel >= tier.levels.start && actorLevel <= tier.levels.end
+            ) ?? 1;
+
+        config.tierLimit = this.beastform.tierAccess.exact ?? actorTier;
+    }
+
+    /**
+     * TODO by Harry
+     * @param {*} selectedForm
+     * @param {*} evolvedData
+     * @param {*} hybridData
+     * @returns
+     */
+    static async transform(selectedForm, evolvedData, hybridData) {
+        const formData = evolvedData?.form ? evolvedData.form.toObject() : selectedForm.toObject();
+        const beastformEffect = formData.effects.find(x => x.type === 'beastform');
+        if (!beastformEffect) {
+            ui.notifications.error('DAGGERHEART.UI.Notifications.beastformMissingEffect');
+            return false;
+        }
+
+        if (evolvedData?.form) {
+            const evolvedForm = selectedForm.effects.find(x => x.type === 'beastform');
+            if (!evolvedForm) {
+                ui.notifications.error('DAGGERHEART.UI.Notifications.beastformMissingEffect');
+                return false;
+            }
+
+            beastformEffect.changes = [...beastformEffect.changes, ...evolvedForm.changes];
+            formData.system.features = [...formData.system.features, ...selectedForm.system.features.map(x => x.uuid)];
+        }
+
+        if (selectedForm.system.beastformType === CONFIG.DH.ITEM.beastformTypes.hybrid.id) {
+            formData.system.advantageOn = Object.values(hybridData.advantages).reduce((advantages, formCategory) => {
+                Object.keys(formCategory).forEach(advantageKey => {
+                    advantages[advantageKey] = formCategory[advantageKey];
+                });
+                return advantages;
+            }, {});
+            formData.system.features = [
+                ...formData.system.features,
+                ...Object.values(hybridData.features).flatMap(x => Object.keys(x))
+            ];
+        }
+
+        this.actor.createEmbeddedDocuments('Item', [formData]);
+    }
+
+    /**
+     * Remove existing beastform effect and return true if there was one
+     * @returns {boolean}
+     */
+    static async handleActiveTransformations() {
+        const beastformEffects = this.actor.effects.filter(x => x.type === 'beastform');
+        const existingEffects = beastformEffects.length > 0;
+        await this.actor.deleteEmbeddedDocuments(
+            'ActiveEffect',
+            beastformEffects.map(x => x.id)
+        );
+        return existingEffects;
+    }
 }

module/data/fields/action/costField.mjs

@@ -1,6 +1,12 @@
 const fields = foundry.data.fields;
 
 export default class CostField extends fields.ArrayField {
+    /**
+     * Action Workflow order
+     */
+    static order = 150;
+
+    /** @inheritDoc */
     constructor(options = {}, context = {}) {
         const element = new fields.SchemaField({
             key: new fields.StringField({
@@ -8,7 +14,7 @@ export default class CostField extends fields.ArrayField {
                 required: true,
                 initial: 'hope'
             }),
-            keyIsID: new fields.BooleanField(),
+            itemId: new fields.StringField({ nullable: true, initial: null }),
             value: new fields.NumberField({ nullable: true, initial: 1, min: 0 }),
             scalable: new fields.BooleanField({ initial: false }),
             step: new fields.NumberField({ nullable: true, initial: null }),
@@ -20,18 +26,88 @@ export default class CostField extends fields.ArrayField {
         super(element, options, context);
     }
 
-    static prepareConfig(config) {
+    /**
+     * Cost Consumption Action Workflow part.
+     * Consume configured action resources.
+     * Must be called within Action context or similar.
+     * @param {object} config                   Object that contains workflow datas. Usually made from Action Fields prepareConfig methods.
+     * @param {boolean} [successCost=false]     Consume only resources configured as "On Success only" if not already consumed.
+     */
+    static async execute(config, successCost = false) {
+        const actor = this.actor.system.partner ?? this.actor,
+            usefulResources = {
+                ...foundry.utils.deepClone(actor.system.resources),
+                fear: {
+                    value: game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Resources.Fear),
+                    max: game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Homebrew).maxFear,
+                    reversed: false
+                }
+            };
+
+        if (this.parent?.parent) {
+            for (var cost of config.costs) {
+                if (cost.itemId) {
+                    usefulResources[cost.key] = {
+                        value: cost.value,
+                        target: this.parent.parent,
+                        itemId: cost.itemId
+                    };
+                }
+            }
+        }
+
+        const resources = CostField.getRealCosts(config.costs)
+            .filter(
+                c =>
+                    (!successCost && (!c.consumeOnSuccess || config.roll?.success)) ||
+                    (successCost && c.consumeOnSuccess)
+            )
+            .reduce((a, c) => {
+                const resource = usefulResources[c.key];
+                if (resource) {
+                    a.push({
+                        key: c.key,
+                        value: (c.total ?? c.value) * (resource.isReversed ? 1 : -1),
+                        target: resource.target,
+                        itemId: resource.itemId
+                    });
+                    return a;
+                }
+            }, []);
+
+        await actor.modifyResource(resources);
+    }
+
+    /**
+     * Update Action Workflow config object.
+     * Must be called within Action context or similar.
+     * @param {object} config    Object that contains workflow datas. Usually made from Action Fields prepareConfig methods.
+     * @returns {boolean}       Return false if fast-forwarded and no more uses.
+     */
+    prepareConfig(config) {
         const costs = this.cost?.length ? foundry.utils.deepClone(this.cost) : [];
         config.costs = CostField.calcCosts.call(this, costs);
         const hasCost = CostField.hasCost.call(this, config.costs);
-        if (config.isFastForward && !hasCost)
-            return ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.Notifications.insufficientResources'));
-        return hasCost;
+        if (config.dialog.configure === false && !hasCost) {
+            ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.Notifications.insufficientResources'));
+            return hasCost;
+        }
     }
 
+    /**
+     *
+     * Must be called within Action context.
+     * @param {*} costs
+     * @returns
+     */
     static calcCosts(costs) {
         const resources = CostField.getResources.call(this, costs);
-        return costs.map(c => {
+        let filteredCosts = costs;
+        if (this.parent.metadata.isQuantifiable && this.parent.consumeOnUse === false) {
+            filteredCosts = filteredCosts.filter(c => c.key !== 'quantity');
+        }
+
+        return filteredCosts.map(c => {
             c.scale = c.scale ?? 0;
             c.step = c.step ?? 1;
             c.total = c.value + c.scale * c.step;
@@ -40,13 +116,19 @@ export default class CostField extends fields.ArrayField {
                 c.key === 'fear'
                     ? game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Resources.Fear)
                     : resources[c.key].isReversed
-                      ? resources[c.key].max
+                      ? resources[c.key].max - resources[c.key].value
                       : resources[c.key].value;
             if (c.scalable) c.maxStep = Math.floor((c.max - c.value) / c.step);
             return c;
         });
     }
 
+    /**
+     * Check if the current Actor currently has all needed resources.
+     * Must be called within Action context.
+     * @param {*} costs
+     * @returns {boolean}
+     */
     static hasCost(costs) {
         const realCosts = CostField.getRealCosts.call(this, costs),
             hasFearCost = realCosts.findIndex(c => c.key === 'fear');
@@ -73,17 +155,20 @@ export default class CostField extends fields.ArrayField {
         );
     }
 
+    /**
+     * Get all Actor resources + parent Item potential one.
+     * Must be called within Action context.
+     * @param {*} costs
+     * @returns
+     */
     static getResources(costs) {
         const actorResources = foundry.utils.deepClone(this.actor.system.resources);
         if (this.actor.system.partner)
             actorResources.hope = foundry.utils.deepClone(this.actor.system.partner.system.resources.hope);
         const itemResources = {};
         for (let itemResource of costs) {
-            if (itemResource.keyIsID) {
-                itemResources[itemResource.key] = {
-                    value: this.parent.resource.value ?? 0,
-                    max: CostField.formatMax.call(this, this.parent?.resource?.max)
-                };
+            if (itemResource.itemId) {
+                itemResources[itemResource.key] = CostField.getItemIdCostResource.bind(this)(itemResource);
             }
         }
 
@@ -93,6 +178,45 @@ export default class CostField extends fields.ArrayField {
         };
     }
 
+    static getItemIdCostResource(itemResource) {
+        switch (itemResource.key) {
+            case CONFIG.DH.GENERAL.itemAbilityCosts.resource.id:
+                return {
+                    value: this.parent.resource.value ?? 0,
+                    max: CostField.formatMax.call(this, this.parent?.resource?.max)
+                };
+            case CONFIG.DH.GENERAL.itemAbilityCosts.quantity.id:
+                return {
+                    value: this.parent.quantity ?? 0,
+                    max: this.parent.quantity ?? 0
+                };
+            default:
+                return { value: 0, max: 0 };
+        }
+    }
+
+    static getItemIdCostUpdate(r) {
+        switch (r.key) {
+            case CONFIG.DH.GENERAL.itemAbilityCosts.resource.id:
+                return {
+                    path: 'system.resource.value',
+                    value: r.target.system.resource.value + r.value
+                };
+            case CONFIG.DH.GENERAL.itemAbilityCosts.quantity.id:
+                return {
+                    path: 'system.quantity',
+                    value: r.target.system.quantity + r.value
+                };
+            default:
+                return { path: '', value: undefined };
+        }
+    }
+
+    /**
+     *
+     * @param {*} costs
+     * @returns
+     */
     static getRealCosts(costs) {
         const realCosts = costs?.length ? costs.filter(c => c.enabled) : [];
         let mergedCosts = [];
@@ -104,6 +228,12 @@ export default class CostField extends fields.ArrayField {
         return mergedCosts;
     }
 
+    /**
+     * Format scalable max cost, inject Action datas if it's a formula.
+     * Must be called within Action context.
+     * @param {number|string} max   Configured maximum for that resource.
+     * @returns {number}            The max cost value.
+     */
     static formatMax(max) {
         max ??= 0;
         if (isNaN(max)) {

module/data/fields/action/damageField.mjs

@@ -1,8 +1,15 @@
 import FormulaField from '../formulaField.mjs';
+import { setsEqual } from '../../../helpers/utils.mjs';
 
 const fields = foundry.data.fields;
 
 export default class DamageField extends fields.SchemaField {
+    /**
+     * Action Workflow order
+     */
+    static order = 20;
+
+    /** @inheritDoc */
     constructor(options, context = {}) {
         const damageFields = {
             parts: new fields.ArrayField(new fields.EmbeddedDataField(DHDamageData)),
@@ -14,6 +21,152 @@ export default class DamageField extends fields.SchemaField {
         };
         super(damageFields, options, context);
     }
+
+    /**
+     * Roll Damage/Healing 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 {string} [messageId=null]     ChatMessage Id where the clicked button belong.
+     * @param {boolean} [force=false]       If the method should be executed outside of Action workflow, for ChatMessage button for example.
+     */
+    static async execute(config, messageId = null, force = false) {
+        if (!this.hasDamage && !this.hasHealing) return;
+        if (
+            this.hasRoll &&
+            DamageField.getAutomation() === CONFIG.DH.SETTINGS.actionAutomationChoices.never.id &&
+            !force
+        )
+            return;
+
+        let formulas = this.damage.parts.map(p => ({
+            formula: DamageField.getFormulaValue.call(this, p, config).getFormula(this.actor),
+            damageTypes: p.applyTo === 'hitPoints' && !p.type.size ? new Set(['physical']) : p.type,
+            applyTo: p.applyTo
+        }));
+
+        if (!formulas.length) return false;
+
+        formulas = DamageField.formatFormulas.call(this, formulas, config);
+
+        const damageConfig = {
+            ...config,
+            roll: formulas,
+            dialog: {},
+            data: this.getRollData()
+        };
+        delete damageConfig.evaluate;
+
+        if (DamageField.getAutomation() === CONFIG.DH.SETTINGS.actionAutomationChoices.always.id)
+            damageConfig.dialog.configure = false;
+        if (config.hasSave) config.onSave = damageConfig.onSave = this.save.damageMod;
+
+        damageConfig.source.message = config.message?._id ?? messageId;
+        damageConfig.directDamage = !!damageConfig.source?.message;
+
+        // if(damageConfig.source?.message && game.modules.get('dice-so-nice')?.active)
+        //     await game.dice3d.waitFor3DAnimationByMessageID(damageConfig.source.message);
+
+        const damageResult = await CONFIG.Dice.daggerheart.DamageRoll.build(damageConfig);
+        if (!damageResult) return false;
+        config.damage = damageResult.damage;
+        config.message ??= damageConfig.message;
+    }
+
+    /**
+     * Apply Damage/Healing Action Worflow part.
+     * @param {object} config        Object that contains workflow datas. Usually made from Action Fields prepareConfig methods.
+     * @param {*[]} targets     Arrays of targets to bypass pre-selected ones.
+     * @param {boolean} force   If the method should be executed outside of Action workflow, for ChatMessage button for example.
+     */
+    static async applyDamage(config, targets = null, force = false) {
+        targets ??= config.targets.filter(target => target.hit);
+        if (!config.damage || !targets?.length || (!DamageField.getApplyAutomation() && !force)) return;
+        for (let target of targets) {
+            const actor = fromUuidSync(target.actorId);
+            if (!actor) continue;
+            if (!config.hasHealing && config.onSave && target.saved?.success === true) {
+                const mod = CONFIG.DH.ACTIONS.damageOnSave[config.onSave]?.mod ?? 1;
+                Object.entries(config.damage).forEach(([k, v]) => {
+                    v.total = 0;
+                    v.parts.forEach(part => {
+                        part.total = Math.ceil(part.total * mod);
+                        v.total += part.total;
+                    });
+                });
+            }
+
+            if (config.hasHealing) actor.takeHealing(config.damage);
+            else actor.takeDamage(config.damage, config.isDirect);
+        }
+    }
+
+    /**
+     * Return value or valueAlt from damage part
+     * Must be called within Action context or similar.
+     * @param {object} part Damage Part
+     * @param {object} data Action getRollData
+     * @returns Formula value object
+     */
+    static getFormulaValue(part, data) {
+        let formulaValue = part.value;
+
+        if (data.hasRoll && part.resultBased && data.roll.result.duality === -1) return part.valueAlt;
+
+        const isAdversary = this.actor.type === 'adversary';
+        if (isAdversary && this.actor.system.type === CONFIG.DH.ACTOR.adversaryTypes.horde.id) {
+            const hasHordeDamage = this.actor.effects.find(x => x.type === 'horde');
+            if (hasHordeDamage && !hasHordeDamage.disabled) return part.valueAlt;
+        }
+
+        return formulaValue;
+    }
+
+    /**
+     * Prepare formulas for Damage Roll
+     * Must be called within Action context or similar.
+     * @param {object[]} formulas   Array of formatted formulas object
+     * @param {object} data         Action getRollData
+     * @returns
+     */
+    static formatFormulas(formulas, data) {
+        const formattedFormulas = [];
+        formulas.forEach(formula => {
+            if (isNaN(formula.formula))
+                formula.formula = Roll.replaceFormulaData(formula.formula, this.getRollData(data));
+            const same = formattedFormulas.find(
+                f => setsEqual(f.damageTypes, formula.damageTypes) && f.applyTo === formula.applyTo
+            );
+            if (same) same.formula += ` + ${formula.formula}`;
+            else formattedFormulas.push(formula);
+        });
+        return formattedFormulas;
+    }
+
+    /**
+     * 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.damage.gm) ||
+            (!game.user.isGM &&
+                game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Automation).roll.damage.players)
+        );
+    }
+
+    /**
+     * Return the automation setting for applyDamage method for current user role
+     * @returns {boolean} If applyDamage should be triggered automatically
+     */
+    static getApplyAutomation() {
+        return (
+            (game.user.isGM &&
+                game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Automation).roll.damageApply.gm) ||
+            (!game.user.isGM &&
+                game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Automation).roll.damageApply.players)
+        );
+    }
 }
 
 export class DHActionDiceData extends foundry.abstract.DataModel {

module/data/fields/action/effectsField.mjs

@@ -1,6 +1,14 @@
+import { emitAsGM, GMUpdateEvent } from '../../../systemRegistration/socket.mjs';
+
 const fields = foundry.data.fields;
 
 export default class EffectsField extends fields.ArrayField {
+    /**
+     * Action Workflow order
+     */
+    static order = 100;
+
+    /** @inheritDoc */
     constructor(options = {}, context = {}) {
         const element = new fields.SchemaField({
             _id: new fields.DocumentIdField(),
@@ -8,4 +16,85 @@ export default class EffectsField extends fields.ArrayField {
         });
         super(element, options, context);
     }
+
+    /**
+     * Apply Effects 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.hasEffect) 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 (EffectsField.getAutomation() || force) {
+            targets ??= (message.system?.targets ?? config.targets).filter(t => !config.hasRoll || t.hit);
+            await emitAsGM(GMUpdateEvent.UpdateEffect, EffectsField.applyEffects.bind(this), targets, this.uuid);
+            // EffectsField.applyEffects.call(this, config.targets.filter(t => !config.hasRoll || t.hit));
+        }
+    }
+
+    /**
+     * Apply Action Effects to a list of Targets
+     * Must be called within Action context or similar.
+     * @param {object[]} targets Array of formatted targets
+     */
+    static async applyEffects(targets) {
+        if (!this.effects?.length || !targets?.length) return;
+        let effects = this.effects;
+        targets.forEach(async token => {
+            if (this.hasSave && token.saved.success === true) effects = this.effects.filter(e => e.onSave === true);
+            if (!effects.length) return;
+            effects.forEach(async e => {
+                const actor = canvas.tokens.get(token.id)?.actor,
+                    effect = this.item.effects.get(e._id);
+                if (!actor || !effect) return;
+                await EffectsField.applyEffect(effect, actor);
+            });
+        });
+    }
+
+    /**
+     * Apply an Effect to a target or enable it if already on it
+     * @param {object} effect   Effect object containing ActiveEffect UUID
+     * @param {object} actor    Actor Document
+     */
+    static async applyEffect(effect, actor) {
+        const existingEffect = actor.effects.find(e => e.origin === effect.uuid);
+        if (existingEffect) {
+            return effect.update(
+                foundry.utils.mergeObject({
+                    ...effect.constructor.getInitialDuration(),
+                    disabled: false
+                })
+            );
+        }
+
+        // Otherwise, create a new effect on the target
+        const effectData = foundry.utils.mergeObject({
+            ...effect.toObject(),
+            disabled: false,
+            transfer: false,
+            origin: effect.uuid
+        });
+        await ActiveEffect.implementation.create(effectData, { parent: actor });
+    }
+
+    /**
+     * Return the automation setting for execute method for current user role
+     * @returns {boolean} If execute should be triggered automatically
+     */
+    static getAutomation() {
+        return (
+            (game.user.isGM &&
+                game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Automation).roll.effect.gm) ||
+            (!game.user.isGM &&
+                game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Automation).roll.effect.players)
+        );
+    }
 }

module/data/fields/action/healingField.mjs

@@ -1,12 +0,0 @@
-import { DHDamageData } from './damageField.mjs';
-
-const fields = foundry.data.fields;
-
-export default class HealingField extends fields.SchemaField {
-    constructor(options, context = {}) {
-        const healingFields = {
-            parts: new fields.ArrayField(new fields.EmbeddedDataField(DHDamageData))
-        };
-        super(healingFields, options, context);
-    }
-}

module/data/fields/action/macroField.mjs

@@ -1,7 +1,29 @@
 const fields = foundry.data.fields;
 
 export default class MacroField extends fields.DocumentUUIDField {
+    /**
+     * Action Workflow order
+     */
+    static order = 70;
+
+    /** @inheritDoc */
     constructor(context = {}) {
-        super({ type: "Macro" }, context);
+        super({ type: 'Macro' }, context);
+    }
+
+    /**
+     * Macro Action Workflow part.
+     * Must be called within Action context or similar or similar.
+     * @param {object} config    Object that contains workflow datas. Usually made from Action Fields prepareConfig methods. Currently not used.
+     */
+    static async execute(config) {
+        const fixUUID = !this.macro.includes('Macro.') ? `Macro.${this.macro}` : this.macro,
+            macro = await fromUuid(fixUUID);
+        try {
+            if (!macro) throw new Error(`No macro found for the UUID: ${this.macro}.`);
+            macro.execute();
+        } catch (error) {
+            ui.notifications.error(error);
+        }
     }
 }

module/data/fields/action/rangeField.mjs

@@ -1,17 +1,23 @@
 const fields = foundry.data.fields;
 
 export default class RangeField extends fields.StringField {
+    /** @inheritDoc */
     constructor(context = {}) {
         const options = {
             choices: CONFIG.DH.GENERAL.range,
             required: false,
             blank: true,
-            label: "DAGGERHEART.GENERAL.range"
+            label: 'DAGGERHEART.GENERAL.range'
         };
         super(options, context);
     }
 
-    static prepareConfig(config) {
-        return true;
+    /**
+     * Update Action Workflow config object.
+     * NOT YET IMPLEMENTED.
+     * @param {object} config    Object that contains workflow datas. Usually made from Action Fields prepareConfig methods.
+     */
+    prepareConfig(config) {
+        return;
     }
 }

module/data/fields/action/rollField.mjs

@@ -5,7 +5,12 @@ export class DHActionRollData extends foundry.abstract.DataModel {
     static defineSchema() {
         return {
             type: new fields.StringField({ nullable: true, initial: null, choices: CONFIG.DH.GENERAL.rollTypes }),
-            trait: new fields.StringField({ nullable: true, initial: null, choices: CONFIG.DH.ACTOR.abilities, label: "DAGGERHEART.GENERAL.Trait.single" }),
+            trait: new fields.StringField({
+                nullable: true,
+                initial: null,
+                choices: CONFIG.DH.ACTOR.abilities,
+                label: 'DAGGERHEART.GENERAL.Trait.single'
+            }),
             difficulty: new fields.NumberField({ nullable: true, initial: null, integer: true, min: 0 }),
             bonus: new fields.NumberField({ nullable: true, initial: null, integer: true }),
             advState: new fields.StringField({
@@ -71,29 +76,6 @@ export class DHActionRollData extends foundry.abstract.DataModel {
         const modifiers = [];
         if (!this.parent?.actor) return modifiers;
         switch (this.parent.actor.type) {
-            case 'character':
-                const spellcastingTrait =
-                    this.type === 'spellcast'
-                        ? (this.parent.actor?.system?.spellcastModifierTrait?.key ?? 'agility')
-                        : null;
-                const trait =
-                    this.useDefault || !this.trait
-                        ? (spellcastingTrait ?? this.parent.item.system.attack?.roll?.trait ?? 'agility')
-                        : this.trait;
-                if (
-                    this.type === CONFIG.DH.GENERAL.rollTypes.attack.id ||
-                    this.type === CONFIG.DH.GENERAL.rollTypes.trait.id
-                )
-                    modifiers.push({
-                        label: `DAGGERHEART.CONFIG.Traits.${trait}.name`,
-                        value: this.parent.actor.system.traits[trait].value
-                    });
-                else if (this.type === CONFIG.DH.GENERAL.rollTypes.spellcast.id)
-                    modifiers.push({
-                        label: `DAGGERHEART.CONFIG.RollTypes.spellcast.name`,
-                        value: this.parent.actor.system.spellcastModifier
-                    });
-                break;
             case 'companion':
             case 'adversary':
                 if (this.type === CONFIG.DH.GENERAL.rollTypes.attack.id)
@@ -107,10 +89,79 @@ export class DHActionRollData extends foundry.abstract.DataModel {
         }
         return modifiers;
     }
+
+    get rollTrait() {
+        if (this.parent?.actor?.type !== 'character') return null;
+        switch (this.type) {
+            case CONFIG.DH.GENERAL.rollTypes.spellcast.id:
+                return this.parent.actor?.system?.spellcastModifierTrait?.key ?? 'agility';
+            case CONFIG.DH.GENERAL.rollTypes.attack.id:
+            case CONFIG.DH.GENERAL.rollTypes.trait.id:
+                return this.useDefault || !this.trait
+                    ? (this.parent.item.system.attack?.roll?.trait ?? 'agility')
+                    : this.trait;
+            default:
+                return null;
+        }
+    }
 }
 
 export default class RollField extends fields.EmbeddedDataField {
+    /**
+     * Action Workflow order
+     */
+    static order = 10;
+
+    /** @inheritDoc */
     constructor(options, context = {}) {
         super(DHActionRollData, options, context);
     }
+
+    /**
+     * 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.
+     */
+    static async execute(config) {
+        if (!config.hasRoll) return;
+        config = await this.actor.diceRoll(config);
+        if (!config) return false;
+    }
+
+    /**
+     * Update Action Workflow config object.
+     * Must be called within Action context.
+     * @param {object} config    Object that contains workflow datas. Usually made from Action Fields prepareConfig methods.
+     */
+    prepareConfig(config) {
+        if (!config.hasRoll) return;
+
+        config.dialog.configure = RollField.getAutomation() ? !config.dialog.configure : config.dialog.configure;
+
+        const roll = {
+            baseModifiers: this.roll.getModifier(),
+            label: 'Attack',
+            type: this.roll?.type,
+            trait: this.roll?.rollTrait,
+            difficulty: this.roll?.difficulty,
+            formula: this.roll.getFormula(),
+            advantage: CONFIG.DH.ACTIONS.advantageState[this.roll.advState].value
+        };
+        if (this.roll.type === 'diceSet' || !this.hasRoll) roll.lite = true;
+
+        config.roll = roll;
+    }
+
+    /**
+     * Return the automation setting for execute method for current user role
+     * @returns {boolean} If execute should be triggered automatically
+     */
+    static getAutomation() {
+        return (
+            (game.user.isGM &&
+                game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Automation).roll.roll.gm) ||
+            (!game.user.isGM &&
+                game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Automation).roll.roll.players)
+        );
+    }
 }

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));
+        });
+    }
 }

module/data/fields/action/targetField.mjs

@@ -1,6 +1,7 @@
 const fields = foundry.data.fields;
 
 export default class TargetField extends fields.SchemaField {
+    /** @inheritDoc */
     constructor(options = {}, context = {}) {
         const targetFields = {
             type: new fields.StringField({
@@ -13,44 +14,66 @@ export default class TargetField extends fields.SchemaField {
         super(targetFields, options, context);
     }
 
-    static prepareConfig(config) {
-        if (!this.target?.type) return [];
+    /**
+     * Update Action Workflow config object.
+     * Must be called within Action context.
+     * @param {object} config    Object that contains workflow datas. Usually made from Action Fields prepareConfig methods.
+     */
+    prepareConfig(config) {
+        if (!this.target?.type) return (config.targets = []);
         config.hasTarget = true;
         let targets;
+        // If the Action is configured as self-targeted, set targets as the owner.
         if (this.target?.type === CONFIG.DH.GENERAL.targetTypes.self.id)
             targets = [this.actor.token ?? this.actor.prototypeToken];
         else {
             targets = Array.from(game.user.targets);
             if (this.target.type !== CONFIG.DH.GENERAL.targetTypes.any.id) {
-                targets = targets.filter(t => TargetField.isTargetFriendly.call(this, t));
+                targets = targets.filter(target => TargetField.isTargetFriendly(this.actor, target, this.target.type));
                 if (this.target.amount && targets.length > this.target.amount) targets = [];
             }
         }
         config.targets = targets.map(t => TargetField.formatTarget.call(this, t));
         const hasTargets = TargetField.checkTargets.call(this, this.target.amount, config.targets);
-        if (config.isFastForward && !hasTargets)
-            return ui.notifications.warn('Too many targets selected for that actions.');
-        return hasTargets;
+        if (config.dialog.configure === false && !hasTargets) {
+            ui.notifications.warn('Too many targets selected for that actions.');
+            return hasTargets;
+        }
     }
 
+    /**
+     * Check if the number of selected targets respect the amount set in the Action.
+     * NOT YET IMPLEMENTED. Will be with Target Picker.
+     * @param {number} amount   Max amount of targets configured in the action.
+     * @param {*[]} targets     Array of targeted tokens.
+     * @returns {boolean}       If the amount of targeted tokens does not exceed action configured one.
+     */
     static checkTargets(amount, targets) {
         return true;
         // return !amount || (targets.length > amount);
     }
 
-    static isTargetFriendly(target) {
-        const actorDisposition = this.actor.token
-                ? this.actor.token.disposition
-                : this.actor.prototypeToken.disposition,
+    /**
+     * Compare 2 Actors disposition between each other
+     * @param {*} actor         First actor document.
+     * @param {*} target        Second actor document.
+     * @param {string} type     Disposition id to compare (friendly/hostile).
+     * @returns {boolean}       If both actors respect the provided type.
+     */
+    static isTargetFriendly(actor, target, type) {
+        const actorDisposition = actor.token ? actor.token.disposition : actor.prototypeToken.disposition,
             targetDisposition = target.document.disposition;
         return (
-            (this.target.type === CONFIG.DH.GENERAL.targetTypes.friendly.id &&
-                actorDisposition === targetDisposition) ||
-            (this.target.type === CONFIG.DH.GENERAL.targetTypes.hostile.id &&
-                actorDisposition + targetDisposition === 0)
+            (type === CONFIG.DH.GENERAL.targetTypes.friendly.id && actorDisposition === targetDisposition) ||
+            (type === CONFIG.DH.GENERAL.targetTypes.hostile.id && actorDisposition + targetDisposition === 0)
         );
     }
 
+    /**
+     * Format actor to useful datas for Action roll workflow.
+     * @param {*} actor     Actor object to format.
+     * @returns {*}         Formatted Actor.
+     */
     static formatTarget(actor) {
         return {
             id: actor.id,

module/data/fields/action/usesField.mjs

@@ -3,6 +3,12 @@ import FormulaField from '../formulaField.mjs';
 const fields = foundry.data.fields;
 
 export default class UsesField extends fields.SchemaField {
+    /**
+     * Action Workflow order
+     */
+    static order = 160;
+
+    /** @inheritDoc */
     constructor(options = {}, context = {}) {
         const usesFields = {
             value: new fields.NumberField({ nullable: true, initial: null }),
@@ -20,16 +26,45 @@ export default class UsesField extends fields.SchemaField {
         super(usesFields, options, context);
     }
 
-    static prepareConfig(config) {
+    /**
+     * Uses Consumption Action Workflow part.
+     * Increment Action spent uses by 1.
+     * Must be called within Action context or similar or similar.
+     * @param {object} config                   Object that contains workflow datas. Usually made from Action Fields prepareConfig methods.
+     * @param {boolean} [successCost=false]     Consume only resources configured as "On Success only" if not already consumed.
+     */
+    static async execute(config, successCost = false) {
+        if (
+            config.uses?.enabled &&
+            ((!successCost && (!config.uses?.consumeOnSuccess || config.roll?.success)) ||
+                (successCost && config.uses?.consumeOnSuccess))
+        )
+            this.update({ 'uses.value': this.uses.value + 1 });
+    }
+
+    /**
+     * Update Action Workflow config object.
+     * Must be called within Action context.
+     * @param {object} config   Object that contains workflow datas. Usually made from Action Fields prepareConfig methods.
+     * @returns {boolean}       Return false if fast-forwarded and no more uses.
+     */
+    prepareConfig(config) {
         const uses = this.uses?.max ? foundry.utils.deepClone(this.uses) : null;
         if (uses && !uses.value) uses.value = 0;
         config.uses = uses;
         const hasUses = UsesField.hasUses.call(this, config.uses);
-        if (config.isFastForward && !hasUses)
-            return ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.Notifications.actionNoUsesRemaining'));
-        return hasUses;
+        if (config.dialog.configure === false && !hasUses) {
+            ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.Notifications.actionNoUsesRemaining'));
+            return hasUses;
+        }
     }
 
+    /**
+     * Prepare Uses object for Action Workflow
+     * Must be called within Action context.
+     * @param {object} uses
+     * @returns {object}
+     */
     static calcUses(uses) {
         if (!uses) return null;
         return {
@@ -39,6 +74,12 @@ export default class UsesField extends fields.SchemaField {
         };
     }
 
+    /**
+     * Check if the Action still get atleast one unspent uses.
+     * Must be called within Action context.
+     * @param {*} uses
+     * @returns {boolean}
+     */
     static hasUses(uses) {
         if (!uses) return true;
         let max = uses.max ?? 0;