Le massive export update

module/data/action/_module.mjs

@@ -1,25 +1,20 @@
-import {
-    DHAttackAction,
-    DHBaseAction,
-    DhBeastformAction,
-    DHDamageAction,
-    DHEffectAction,
-    DHHealingAction,
-    DHMacroAction,
-    // DHResourceAction,
-    // DHSpellCastAction,
-    DHSummonAction
-} from './action.mjs';
+export * as ActionDice from './actionDice.mjs';
+import AttackAction from './attackAction.mjs';
+import BaseAction from './baseAction.mjs';
+import BeastformAction from './beastformAction.mjs';
+import DamageAction from './damageAction.mjs';
+import EffectAction from './effectAction.mjs';
+import HealingAction from './healingAction.mjs';
+import MacroAction from './macroAction.mjs';
+import SummonAction from './summonAction.mjs';
 
 export const actionsTypes = {
-    base: DHBaseAction,
-    attack: DHAttackAction,
-    // spellcast: DHSpellCastAction,
-    // resource: DHResourceAction,
-    damage: DHDamageAction,
-    healing: DHHealingAction,
-    summon: DHSummonAction,
-    effect: DHEffectAction,
-    macro: DHMacroAction,
-    beastform: DhBeastformAction
+    base: BaseAction,
+    attack: AttackAction,
+    damage: DamageAction,
+    healing: HealingAction,
+    summon: SummonAction,
+    effect: EffectAction,
+    macro: MacroAction,
+    beastform: BeastformAction
 };

module/data/action/attackAction.mjs

@@ -0,0 +1,34 @@
+import { DHDamageData } from './actionDice.mjs';
+import DHDamageAction from './damageAction.mjs';
+
+export default class DHAttackAction extends DHDamageAction {
+    static extraSchemas = [...super.extraSchemas, ...['roll', 'save']];
+
+    static getRollType(parent) {
+        return parent.type === 'weapon' ? 'weapon' : 'spellcast';
+    }
+
+    get chatTemplate() {
+        return 'systems/daggerheart/templates/ui/chat/duality-roll.hbs';
+    }
+
+    prepareData() {
+        super.prepareData();
+        if (this.damage.includeBase && !!this.item?.system?.damage) {
+            const baseDamage = this.getParentDamage();
+            this.damage.parts.unshift(new DHDamageData(baseDamage));
+        }
+    }
+
+    getParentDamage() {
+        return {
+            value: {
+                multiplier: 'prof',
+                dice: this.item?.system?.damage.dice,
+                bonus: this.item?.system?.damage.bonus ?? 0
+            },
+            type: this.item?.system?.damage.type,
+            base: true
+        };
+    }
+}

module/data/action/baseAction.mjs

@@ -1,7 +1,6 @@
 import { DHActionDiceData, DHActionRollData, DHDamageData, DHDamageField } from './actionDice.mjs';
 import DhpActor from '../../documents/actor.mjs';
 import D20RollDialog from '../../applications/dialogs/d20RollDialog.mjs';
-import BeastformDialog from '../../applications/dialogs/beastformDialog.mjs';
 
 const fields = foundry.data.fields;
 
@@ -21,7 +20,7 @@ const fields = foundry.data.fields;
     - Auto use action   <= Into Roll
 */
 
-export class DHBaseAction extends foundry.abstract.DataModel {
+export default class DHBaseAction extends foundry.abstract.DataModel {
     static extraSchemas = [];
 
     static defineSchema() {
@@ -585,239 +584,3 @@ export class DHBaseAction extends foundry.abstract.DataModel {
         cls.create(msg.toObject());
     }
 }
-
-export class DHDamageAction extends DHBaseAction {
-    static extraSchemas = ['damage', 'target', 'effects'];
-
-    getFormulaValue(part, data) {
-        let formulaValue = part.value;
-        if (this.hasRoll && part.resultBased && data.system.roll.result.duality === -1) return part.valueAlt;
-        return formulaValue;
-    }
-
-    async rollDamage(event, data) {
-        let formula = this.damage.parts.map(p => this.getFormulaValue(p, data).getFormula(this.actor)).join(' + ');
-
-        if (!formula || formula == '') return;
-        let roll = { formula: formula, total: formula },
-            bonusDamage = [];
-
-        if (isNaN(formula)) formula = Roll.replaceFormulaData(formula, this.getRollData(data.system ?? data));
-
-        const config = {
-            title: game.i18n.format('DAGGERHEART.Chat.DamageRoll.Title', { damage: this.name }),
-            roll: { formula },
-            targets: data.system?.targets.filter(t => t.hit) ?? data.targets,
-            hasSave: this.hasSave,
-            isCritical: data.system?.roll?.isCritical ?? false,
-            source: data.system?.source,
-            event
-        };
-        if (this.hasSave) config.onSave = this.save.damageMod;
-        if (data.system) {
-            config.source.message = data._id;
-            config.directDamage = false;
-        }
-
-        roll = CONFIG.Dice.daggerheart.DamageRoll.build(config);
-    }
-}
-
-export class DHAttackAction extends DHDamageAction {
-    static extraSchemas = [...super.extraSchemas, ...['roll', 'save']];
-
-    static getRollType(parent) {
-        return parent.type === 'weapon' ? 'weapon' : 'spellcast';
-    }
-
-    get chatTemplate() {
-        return 'systems/daggerheart/templates/ui/chat/duality-roll.hbs';
-    }
-
-    prepareData() {
-        super.prepareData();
-        if (this.damage.includeBase && !!this.item?.system?.damage) {
-            const baseDamage = this.getParentDamage();
-            this.damage.parts.unshift(new DHDamageData(baseDamage));
-        }
-    }
-
-    getParentDamage() {
-        return {
-            value: {
-                multiplier: 'prof',
-                dice: this.item?.system?.damage.dice,
-                bonus: this.item?.system?.damage.bonus ?? 0
-            },
-            type: this.item?.system?.damage.type,
-            base: true
-        };
-    }
-}
-
-export class DHHealingAction extends DHBaseAction {
-    static extraSchemas = ['target', 'effects', 'healing', 'roll'];
-
-    static getRollType(parent) {
-        return 'spellcast';
-    }
-
-    getFormulaValue(data) {
-        let formulaValue = this.healing.value;
-        if (this.hasRoll && this.healing.resultBased && data.system.roll.result.duality === -1)
-            return this.healing.valueAlt;
-        return formulaValue;
-    }
-
-    async rollHealing(event, data) {
-        let formulaValue = this.getFormulaValue(data),
-            formula = formulaValue.getFormula(this.actor);
-
-        if (!formula || formula == '') return;
-        let roll = { formula: formula, total: formula },
-            bonusDamage = [];
-
-        const config = {
-            title: game.i18n.format('DAGGERHEART.Chat.HealingRoll.Title', {
-                healing: game.i18n.localize(CONFIG.DH.GENERAL.healingTypes[this.healing.type].label)
-            }),
-            roll: { formula },
-            targets: (data.system?.targets ?? data.targets).filter(t => t.hit),
-            messageType: 'healing',
-            type: this.healing.type,
-            event
-        };
-
-        roll = CONFIG.Dice.daggerheart.DamageRoll.build(config);
-    }
-
-    get chatTemplate() {
-        return 'systems/daggerheart/templates/ui/chat/healing-roll.hbs';
-    }
-}
-
-export class DHSummonAction extends DHBaseAction {
-    static defineSchema() {
-        return {
-            ...super.defineSchema(),
-            documentUUID: new fields.DocumentUUIDField({ type: 'Actor' })
-        };
-    }
-
-    async trigger(event, ...args) {
-        if (!this.canSummon || !canvas.scene) return;
-        // const config = await super.use(event, args);
-    }
-
-    get canSummon() {
-        return game.user.can('TOKEN_CREATE');
-    }
-}
-
-export class DHEffectAction extends DHBaseAction {
-    static extraSchemas = ['effects', 'target'];
-
-    async use(event, ...args) {
-        const config = await super.use(event, args);
-        if (['error', 'warning'].includes(config.type)) return;
-        return await this.chatApplyEffects(event, config);
-    }
-
-    async chatApplyEffects(event, data) {
-        const cls = getDocumentClass('ChatMessage'),
-            systemData = {
-                title: game.i18n.format('DAGGERHEART.Chat.ApplyEffect.Title', { name: this.name }),
-                origin: this.actor._id,
-                description: '',
-                targets: data.targets.map(x => ({ id: x.id, name: x.name, img: x.img, hit: true })),
-                action: {
-                    itemId: this.item._id,
-                    actionId: this._id
-                }
-            },
-            msg = new cls({
-                type: 'applyEffect',
-                user: game.user.id,
-                system: systemData,
-                content: await foundry.applications.handlebars.renderTemplate(
-                    'systems/daggerheart/templates/ui/chat/apply-effects.hbs',
-                    systemData
-                )
-            });
-
-        cls.create(msg.toObject());
-    }
-
-    get chatTemplate() {
-        return 'systems/daggerheart/templates/ui/chat/apply-effects.hbs';
-    }
-}
-
-export class DHMacroAction extends DHBaseAction {
-    static defineSchema() {
-        return {
-            ...super.defineSchema(),
-            documentUUID: new fields.DocumentUUIDField({ type: 'Macro' })
-        };
-    }
-
-    async trigger(event, ...args) {
-        // const config = await super.use(event, args);
-        // if (['error', 'warning'].includes(config.type)) return;
-        const fixUUID = !this.documentUUID.includes('Macro.') ? `Macro.${this.documentUUID}` : this.documentUUID,
-            macro = await fromUuid(fixUUID);
-        try {
-            if (!macro) throw new Error(`No macro found for the UUID: ${this.documentUUID}.`);
-            macro.execute();
-        } catch (error) {
-            ui.notifications.error(error);
-        }
-    }
-}
-
-export class DhBeastformAction extends DHBaseAction {
-    static extraSchemas = ['beastform'];
-
-    async use(event, ...args) {
-        const beastformConfig = this.prepareBeastformConfig();
-
-        const abort = await this.handleActiveTransformations();
-        if (abort) return;
-
-        const beastformUuid = await BeastformDialog.configure(beastformConfig);
-        if (!beastformUuid) return;
-
-        await this.transform(beastformUuid);
-    }
-
-    prepareBeastformConfig(config) {
-        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;
-
-        return {
-            tierLimit: this.beastform.tierAccess.exact ?? actorTier
-        };
-    }
-
-    async transform(beastformUuid) {
-        const beastform = await foundry.utils.fromUuid(beastformUuid);
-        this.actor.createEmbeddedDocuments('Item', [beastform.toObject()]);
-    }
-
-    async handleActiveTransformations() {
-        const beastformEffects = this.actor.effects.filter(x => x.type === 'beastform');
-        if (beastformEffects.length > 0) {
-            for (let effect of beastformEffects) {
-                await effect.delete();
-            }
-
-            return true;
-        }
-
-        return false;
-    }
-}

module/data/action/beastformAction.mjs

@@ -0,0 +1,49 @@
+import BeastformDialog from '../../applications/dialogs/beastformDialog.mjs';
+import DHBaseAction from './baseAction.mjs';
+
+export default class DhBeastformAction extends DHBaseAction {
+    static extraSchemas = ['beastform'];
+
+    async use(event, ...args) {
+        const beastformConfig = this.prepareBeastformConfig();
+
+        const abort = await this.handleActiveTransformations();
+        if (abort) return;
+
+        const beastformUuid = await BeastformDialog.configure(beastformConfig);
+        if (!beastformUuid) return;
+
+        await this.transform(beastformUuid);
+    }
+
+    prepareBeastformConfig(config) {
+        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;
+
+        return {
+            tierLimit: this.beastform.tierAccess.exact ?? actorTier
+        };
+    }
+
+    async transform(beastformUuid) {
+        const beastform = await foundry.utils.fromUuid(beastformUuid);
+        this.actor.createEmbeddedDocuments('Item', [beastform.toObject()]);
+    }
+
+    async handleActiveTransformations() {
+        const beastformEffects = this.actor.effects.filter(x => x.type === 'beastform');
+        if (beastformEffects.length > 0) {
+            for (let effect of beastformEffects) {
+                await effect.delete();
+            }
+
+            return true;
+        }
+
+        return false;
+    }
+}

module/data/action/damageAction.mjs

@@ -0,0 +1,38 @@
+import DHBaseAction from './baseAction.mjs';
+
+export default class DHDamageAction extends DHBaseAction {
+    static extraSchemas = ['damage', 'target', 'effects'];
+
+    getFormulaValue(part, data) {
+        let formulaValue = part.value;
+        if (this.hasRoll && part.resultBased && data.system.roll.result.duality === -1) return part.valueAlt;
+        return formulaValue;
+    }
+
+    async rollDamage(event, data) {
+        let formula = this.damage.parts.map(p => this.getFormulaValue(p, data).getFormula(this.actor)).join(' + ');
+
+        if (!formula || formula == '') return;
+        let roll = { formula: formula, total: formula },
+            bonusDamage = [];
+
+        if (isNaN(formula)) formula = Roll.replaceFormulaData(formula, this.getRollData(data.system ?? data));
+
+        const config = {
+            title: game.i18n.format('DAGGERHEART.Chat.DamageRoll.Title', { damage: this.name }),
+            roll: { formula },
+            targets: data.system?.targets.filter(t => t.hit) ?? data.targets,
+            hasSave: this.hasSave,
+            isCritical: data.system?.roll?.isCritical ?? false,
+            source: data.system?.source,
+            event
+        };
+        if (this.hasSave) config.onSave = this.save.damageMod;
+        if (data.system) {
+            config.source.message = data._id;
+            config.directDamage = false;
+        }
+
+        roll = CONFIG.Dice.daggerheart.DamageRoll.build(config);
+    }
+}

module/data/action/effectAction.mjs

@@ -0,0 +1,40 @@
+import DHBaseAction from './baseAction.mjs';
+
+export default class DHEffectAction extends DHBaseAction {
+    static extraSchemas = ['effects', 'target'];
+
+    async use(event, ...args) {
+        const config = await super.use(event, args);
+        if (['error', 'warning'].includes(config.type)) return;
+        return await this.chatApplyEffects(event, config);
+    }
+
+    async chatApplyEffects(event, data) {
+        const cls = getDocumentClass('ChatMessage'),
+            systemData = {
+                title: game.i18n.format('DAGGERHEART.Chat.ApplyEffect.Title', { name: this.name }),
+                origin: this.actor._id,
+                description: '',
+                targets: data.targets.map(x => ({ id: x.id, name: x.name, img: x.img, hit: true })),
+                action: {
+                    itemId: this.item._id,
+                    actionId: this._id
+                }
+            },
+            msg = new cls({
+                type: 'applyEffect',
+                user: game.user.id,
+                system: systemData,
+                content: await foundry.applications.handlebars.renderTemplate(
+                    'systems/daggerheart/templates/ui/chat/apply-effects.hbs',
+                    systemData
+                )
+            });
+
+        cls.create(msg.toObject());
+    }
+
+    get chatTemplate() {
+        return 'systems/daggerheart/templates/ui/chat/apply-effects.hbs';
+    }
+}

module/data/action/healingAction.mjs

@@ -0,0 +1,42 @@
+import DHBaseAction from './baseAction.mjs';
+
+export default class DHHealingAction extends DHBaseAction {
+    static extraSchemas = ['target', 'effects', 'healing', 'roll'];
+
+    static getRollType(parent) {
+        return 'spellcast';
+    }
+
+    getFormulaValue(data) {
+        let formulaValue = this.healing.value;
+        if (this.hasRoll && this.healing.resultBased && data.system.roll.result.duality === -1)
+            return this.healing.valueAlt;
+        return formulaValue;
+    }
+
+    async rollHealing(event, data) {
+        let formulaValue = this.getFormulaValue(data),
+            formula = formulaValue.getFormula(this.actor);
+
+        if (!formula || formula == '') return;
+        let roll = { formula: formula, total: formula },
+            bonusDamage = [];
+
+        const config = {
+            title: game.i18n.format('DAGGERHEART.Chat.HealingRoll.Title', {
+                healing: game.i18n.localize(CONFIG.DH.GENERAL.healingTypes[this.healing.type].label)
+            }),
+            roll: { formula },
+            targets: (data.system?.targets ?? data.targets).filter(t => t.hit),
+            messageType: 'healing',
+            type: this.healing.type,
+            event
+        };
+
+        roll = CONFIG.Dice.daggerheart.DamageRoll.build(config);
+    }
+
+    get chatTemplate() {
+        return 'systems/daggerheart/templates/ui/chat/healing-roll.hbs';
+    }
+}

module/data/action/macroAction.mjs

@@ -0,0 +1,24 @@
+import DHBaseAction from './baseAction.mjs';
+
+export default class DHMacroAction extends DHBaseAction {
+    static defineSchema() {
+        const fields = foundry.data.fields;
+        return {
+            ...super.defineSchema(),
+            documentUUID: new fields.DocumentUUIDField({ type: 'Macro' })
+        };
+    }
+
+    async trigger(event, ...args) {
+        // const config = await super.use(event, args);
+        // if (['error', 'warning'].includes(config.type)) return;
+        const fixUUID = !this.documentUUID.includes('Macro.') ? `Macro.${this.documentUUID}` : this.documentUUID,
+            macro = await fromUuid(fixUUID);
+        try {
+            if (!macro) throw new Error(`No macro found for the UUID: ${this.documentUUID}.`);
+            macro.execute();
+        } catch (error) {
+            ui.notifications.error(error);
+        }
+    }
+}

module/data/action/summonAction.mjs

@@ -0,0 +1,20 @@
+import DHBaseAction from './baseAction.mjs';
+
+export default class DHSummonAction extends DHBaseAction {
+    static defineSchema() {
+        const fields = foundry.data.fields;
+        return {
+            ...super.defineSchema(),
+            documentUUID: new fields.DocumentUUIDField({ type: 'Actor' })
+        };
+    }
+
+    async trigger(event, ...args) {
+        if (!this.canSummon || !canvas.scene) return;
+        // const config = await super.use(event, args);
+    }
+
+    get canSummon() {
+        return game.user.can('TOKEN_CREATE');
+    }
+}