Partial Fate Roll creation and Fate Roll Enricher (/fr)

module/dice/_module.mjs

@@ -3,3 +3,4 @@ export { default as D20Roll } from './d20Roll.mjs';
 export { default as DamageRoll } from './damageRoll.mjs';
 export { default as DHRoll } from './dhRoll.mjs';
 export { default as DualityRoll } from './dualityRoll.mjs';
+export { default as FateRoll } from './fateRoll.mjs';

module/dice/fateRoll.mjs

@@ -0,0 +1,127 @@
+import D20RollDialog from '../applications/dialogs/d20RollDialog.mjs';
+import D20Roll from './d20Roll.mjs';
+import { setDiceSoNiceForFateRoll } from '../helpers/utils.mjs';
+
+export default class FateRoll extends D20Roll {
+     constructor(formula, data = {}, options = {}) {
+        super(formula, data, options);
+    }
+
+    static messageType = 'fateRoll';
+
+    static DefaultDialog = D20RollDialog;
+
+    get title() {
+        return game.i18n.localize(
+            `DAGGERHEART.GENERAL.fateRoll`
+        );
+    }
+
+    get dHope() {
+        // if ( !(this.terms[0] instanceof foundry.dice.terms.Die) ) return;
+        if (!(this.dice[0] instanceof foundry.dice.terms.Die)) this.createBaseDice();
+        return this.dice[0];
+        // return this.#hopeDice;
+    }
+
+    set dHope(faces) {
+        if (!(this.dice[0] instanceof foundry.dice.terms.Die)) this.createBaseDice();
+        this.terms[0].faces = this.getFaces(faces);
+        // this.#hopeDice = `d${face}`;
+    }
+
+    get isCritical() {
+        return false;
+    }
+
+    static getHooks(hooks) {
+        return [...(hooks ?? []), 'Fate'];
+    }
+
+    /** @inheritDoc */
+    static fromData(data) {
+        data.terms[0].class = foundry.dice.terms.Die.name;
+        return super.fromData(data);
+    }
+
+    createBaseDice() {
+        if (this.dice[0] instanceof foundry.dice.terms.Die) {
+            this.terms = [this.terms[0]];
+            return;
+        }
+        this.terms[0] = new foundry.dice.terms.Die({ faces: 12 });
+    }
+
+    static async buildEvaluate(roll, config = {}, message = {}) {
+        await super.buildEvaluate(roll, config, message);
+
+        await setDiceSoNiceForFateRoll(
+            roll,
+            config.roll.hope.dice
+        );
+    }
+
+    static postEvaluate(roll, config = {}) {
+        const data = super.postEvaluate(roll, config);
+
+        data.hope = {
+            dice: roll.dHope.denomination,
+            value: roll.dHope.total,
+            rerolled: {
+                any: roll.dHope.results.some(x => x.rerolled),
+                rerolls: roll.dHope.results.filter(x => x.rerolled)
+            }
+        };
+
+        return data;
+    }
+
+    // static async reroll(rollString, target, message) {
+    //     let parsedRoll = game.system.api.dice.DualityRoll.fromData({ ...rollString, evaluated: false });
+    //     const term = parsedRoll.terms[target.dataset.dieIndex];
+    //     await term.reroll(`/r1=${term.total}`);
+    //     if (game.modules.get('dice-so-nice')?.active) {
+    //         const diceSoNiceRoll = {
+    //             _evaluated: true,
+    //             dice: [
+    //                 new foundry.dice.terms.Die({
+    //                     ...term,
+    //                     faces: term._faces,
+    //                     results: term.results.filter(x => !x.rerolled)
+    //                 })
+    //             ],
+    //             options: { appearance: {} }
+    //         };
+
+    //         const diceSoNicePresets = await getDiceSoNicePresets(`d${term._faces}`, `d${term._faces}`);
+    //         const type = target.dataset.type;
+    //         if (diceSoNicePresets[type]) {
+    //             diceSoNiceRoll.dice[0].options = diceSoNicePresets[type];
+    //         }
+
+    //         await game.dice3d.showForRoll(diceSoNiceRoll, game.user, true);
+    //     }
+
+    //     await parsedRoll.evaluate();
+
+    //     const newRoll = game.system.api.dice.DualityRoll.postEvaluate(parsedRoll, {
+    //         targets: message.system.targets,
+    //         roll: {
+    //             advantage: message.system.roll.advantage?.type,
+    //             difficulty: message.system.roll.difficulty ? Number(message.system.roll.difficulty) : null
+    //         }
+    //     });
+    //     newRoll.extra = newRoll.extra.slice(2);
+
+    //     const tagTeamSettings = game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.TagTeamRoll);
+    //     Hooks.call(`${CONFIG.DH.id}.postRollDuality`, {
+    //         source: { actor: message.system.source.actor ?? '' },
+    //         targets: message.system.targets,
+    //         tagTeamSelected: Object.values(tagTeamSettings.members).some(x => x.messageId === message._id),
+    //         roll: newRoll,
+    //         rerolledRoll:
+    //             newRoll.result.duality !== message.system.roll.result.duality ? message.system.roll : undefined
+    //     });
+    //     return { newRoll, parsedRoll };
+    // }
+}