Restructured all the files

module/documents/_module.mjs

@@ -2,3 +2,6 @@ export { default as DhpActor } from './actor.mjs';
 export { default as DHItem } from './item.mjs';
 export { default as DhpCombat } from './combat.mjs';
 export { default as DhActiveEffect } from './activeEffect.mjs';
+export { default as DhChatMessage } from './chatMessage.mjs';
+export * as DhRoll from './roll.mjs';
+export { default as DhTooltipManager } from './tooltipManager.mjs';

module/documents/activeEffect.mjs

@@ -44,7 +44,7 @@ export default class DhActiveEffect extends ActiveEffect {
             user: game.user.id,
             system: systemData,
             content: await foundry.applications.handlebars.renderTemplate(
-                'systems/daggerheart/templates/chat/ability-use.hbs',
+                'systems/daggerheart/templates/ui/chat/ability-use.hbs',
                 systemData
             )
         });

module/documents/actor.mjs

@@ -1,6 +1,6 @@
-import DamageSelectionDialog from '../applications/damageSelectionDialog.mjs';
-import { GMUpdateEvent, socketEvent } from '../helpers/socket.mjs';
-import DamageReductionDialog from '../applications/damageReductionDialog.mjs';
+import DamageSelectionDialog from '../applications/dialogs/damageSelectionDialog.mjs';
+import { GMUpdateEvent, socketEvent } from '../systemRegistration/socket.mjs';
+import DamageReductionDialog from '../applications/dialogs/damageReductionDialog.mjs';
 import { LevelOptionType } from '../data/levelTier.mjs';
 import DHFeature from '../data/item/feature.mjs';
 
@@ -24,7 +24,7 @@ export default class DhpActor extends Actor {
 
         if (newLevel > this.system.levelData.level.current) {
             const maxLevel = Object.values(
-                game.settings.get(SYSTEM.id, SYSTEM.SETTINGS.gameSettings.LevelTiers).tiers
+                game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.LevelTiers).tiers
             ).reduce((acc, tier) => Math.max(acc, tier.levels.end), 0);
             if (newLevel > maxLevel) {
                 ui.notifications.warn(game.i18n.localize('DAGGERHEART.Sheets.PC.Errors.tooHighLevel'));
@@ -375,7 +375,7 @@ export default class DhpActor extends Actor {
             bonusDamage = result.bonusDamage;
             rollString = result.rollString;
 
-            const automateHope = await game.settings.get(SYSTEM.id, SYSTEM.SETTINGS.gameSettings.Automation.Hope);
+            const automateHope = await game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Automation.Hope);
             if (automateHope && result.hopeUsed) {
                 await this.update({
                     'system.resources.hope.value': this.system.resources.hope.value - result.hopeUsed
@@ -421,7 +421,7 @@ export default class DhpActor extends Actor {
             sound: CONFIG.sounds.dice,
             system: systemData,
             content: await foundry.applications.handlebars.renderTemplate(
-                'systems/daggerheart/templates/chat/damage-roll.hbs',
+                'systems/daggerheart/templates/ui/chat/damage-roll.hbs',
                 systemData
             ),
             rolls: [roll]
@@ -488,7 +488,7 @@ export default class DhpActor extends Actor {
             switch (r.type) {
                 case 'fear':
                     ui.resources.updateFear(
-                        game.settings.get(SYSTEM.id, SYSTEM.SETTINGS.gameSettings.Resources.Fear) + r.value
+                        game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Resources.Fear) + r.value
                     );
                     break;
                 case 'armorStack':
@@ -513,7 +513,7 @@ export default class DhpActor extends Actor {
                 if (game.user.isGM) {
                     await u.target.update(u.resources);
                 } else {
-                    await game.socket.emit(`system.${SYSTEM.id}`, {
+                    await game.socket.emit(`system.${CONFIG.DH.id}`, {
                         action: socketEvent.GMUpdate,
                         data: {
                             action: GMUpdateEvent.UpdateDocument,

module/documents/chatMessage.mjs

@@ -0,0 +1,40 @@
+export default class DhpChatMessage extends foundry.documents.ChatMessage {
+    async renderHTML() {
+        if (this.system.messageTemplate)
+            this.content = await foundry.applications.handlebars.renderTemplate(
+                this.system.messageTemplate,
+                this.system
+            );
+
+        /* We can change to fully implementing the renderHTML function if needed, instead of augmenting it. */
+        const html = await super.renderHTML();
+        this.applyPermission(html);
+
+        if (this.type === 'dualityRoll') {
+            html.classList.add('duality');
+            switch (this.system.roll.result.duality) {
+                case 1:
+                    html.classList.add('hope');
+                    break;
+                case -1:
+                    html.classList.add('fear');
+                    break;
+                default:
+                    html.classList.add('critical');
+                    break;
+            }
+        }
+
+        return html;
+    }
+
+    applyPermission(html) {
+        const elements = html.querySelectorAll('[data-perm-id]');
+        elements.forEach(e => {
+            const uuid = e.dataset.permId,
+                document = fromUuidSync(uuid);
+            e.setAttribute('data-view-perm', document.testUserPermission(game.user, 'OBSERVER'));
+            e.setAttribute('data-use-perm', document.testUserPermission(game.user, 'OWNER'));
+        });
+    }
+}

module/documents/item.mjs

@@ -79,7 +79,7 @@ export default class DHItem extends foundry.documents.Item {
 
     async selectActionDialog() {
         const content = await foundry.applications.handlebars.renderTemplate(
-                'systems/daggerheart/templates/views/actionSelect.hbs',
+                'systems/daggerheart/templates/dialogs/actionSelect.hbs',
                 { actions: this.system.actions }
             ),
             title = 'Select Action';
@@ -131,7 +131,7 @@ export default class DHItem extends foundry.documents.Item {
             user: game.user.id,
             system: systemData,
             content: await foundry.applications.handlebars.renderTemplate(
-                'systems/daggerheart/templates/chat/ability-use.hbs',
+                'systems/daggerheart/templates/ui/chat/ability-use.hbs',
                 systemData
             )
         });

module/documents/roll.mjs

@@ -0,0 +1,493 @@
+import D20RollDialog from '../applications/dialogs/d20RollDialog.mjs';
+import DamageDialog from '../applications/dialogs/damageDialog.mjs';
+import { setDiceSoNiceForDualityRoll } from '../helpers/utils.mjs';
+
+/*
+    - Damage & other resources roll
+    - Close dialog => don't roll
+*/
+
+export class DHRoll extends Roll {
+    baseTerms = [];
+    constructor(formula, data, options) {
+        super(formula, data, options);
+    }
+
+    static messageType = 'adversaryRoll';
+
+    static DefaultDialog = D20RollDialog;
+
+    static async build(config = {}, message = {}) {
+        const roll = await this.buildConfigure(config, message);
+        if (!roll) return;
+        await this.buildEvaluate(roll, config, (message = {}));
+        await this.buildPost(roll, config, (message = {}));
+        return config;
+    }
+
+    static async buildConfigure(config = {}, message = {}) {
+        config.hooks = [...(config.hooks ?? []), ''];
+        config.dialog ??= {};
+        for (const hook of config.hooks) {
+            if (Hooks.call(`${CONFIG.DH.id}.preRoll${hook.capitalize()}`, config, message) === false) return null;
+        }
+
+        this.applyKeybindings(config);
+
+        let roll = new this(config.roll.formula, config.data, config);
+        if (config.dialog.configure !== false) {
+            // Open Roll Dialog
+            const DialogClass = config.dialog?.class ?? this.DefaultDialog;
+            const configDialog = await DialogClass.configure(roll, config, message);
+            if (!configDialog) return;
+        }
+
+        for (const hook of config.hooks) {
+            if (
+                Hooks.call(`${CONFIG.DH.id}.post${hook.capitalize()}RollConfiguration`, roll, config, message) === false
+            )
+                return [];
+        }
+        return roll;
+    }
+
+    static async buildEvaluate(roll, config = {}, message = {}) {
+        if (config.evaluate !== false) await roll.evaluate();
+        this.postEvaluate(roll, config);
+    }
+
+    static async buildPost(roll, config, message) {
+        for (const hook of config.hooks) {
+            if (Hooks.call(`${CONFIG.DH.id}.postRoll${hook.capitalize()}`, config, message) === false) return null;
+        }
+
+        // Create Chat Message
+        if (config.source?.message) {
+        } else {
+            const messageData = {};
+            config.message = await this.toMessage(roll, config);
+        }
+    }
+
+    static postEvaluate(roll, config = {}) {
+        if (!config.roll) config.roll = {};
+        config.roll.total = roll.total;
+        config.roll.formula = roll.formula;
+        config.roll.dice = [];
+        roll.dice.forEach(d => {
+            config.roll.dice.push({
+                dice: d.denomination,
+                total: d.total,
+                formula: d.formula,
+                results: d.results
+            });
+        });
+    }
+
+    static async toMessage(roll, config) {
+        const cls = getDocumentClass('ChatMessage'),
+            msg = {
+                type: this.messageType,
+                user: game.user.id,
+                sound: config.mute ? null : CONFIG.sounds.dice,
+                system: config,
+                rolls: [roll]
+            };
+        return await cls.create(msg);
+    }
+
+    static applyKeybindings(config) {
+        if (config.event)
+            config.dialog.configure ??= !(config.event.shiftKey || config.event.altKey || config.event.ctrlKey);
+    }
+
+    formatModifier(modifier) {
+        const numTerm = modifier < 0 ? '-' : '+';
+        return [
+            new foundry.dice.terms.OperatorTerm({ operator: numTerm }),
+            new foundry.dice.terms.NumericTerm({ number: Math.abs(modifier) })
+        ];
+    }
+
+    getFaces(faces) {
+        return Number(faces.startsWith('d') ? faces.replace('d', '') : faces);
+    }
+
+    constructFormula(config) {
+        this.terms = Roll.parse(this.options.roll.formula, config.data);
+
+        if (this.options.extraFormula) {
+            this.terms.push(
+                new foundry.dice.terms.OperatorTerm({ operator: '+' }),
+                ...this.constructor.parse(this.options.extraFormula, this.options.data)
+            );
+        }
+        return (this._formula = this.constructor.getFormula(this.terms));
+    }
+
+    static calculateTotalModifiers(roll) {
+        let modifierTotal = 0;
+        for (let i = 0; i < roll.terms.length; i++) {
+            if (
+                roll.terms[i] instanceof foundry.dice.terms.NumericTerm &&
+                !!roll.terms[i - 1] &&
+                roll.terms[i - 1] instanceof foundry.dice.terms.OperatorTerm
+            )
+                modifierTotal += Number(`${roll.terms[i - 1].operator}${roll.terms[i].total}`);
+        }
+        return modifierTotal;
+    }
+}
+
+export class DualityDie extends foundry.dice.terms.Die {
+    constructor({ number = 1, faces = 12, ...args } = {}) {
+        super({ number, faces, ...args });
+    }
+}
+
+export class D20Roll extends DHRoll {
+    constructor(formula, data = {}, options = {}) {
+        super(formula, data, options);
+        this.constructFormula();
+    }
+
+    static ADV_MODE = {
+        NORMAL: 0,
+        ADVANTAGE: 1,
+        DISADVANTAGE: -1
+    };
+
+    static messageType = 'adversaryRoll';
+
+    static CRITICAL_TRESHOLD = 20;
+
+    static DefaultDialog = D20RollDialog;
+
+    get d20() {
+        if (!(this.terms[0] instanceof foundry.dice.terms.Die)) this.createBaseDice();
+        return this.terms[0];
+    }
+
+    set d20(faces) {
+        if (!(this.terms[0] instanceof foundry.dice.terms.Die)) this.createBaseDice();
+        this.terms[0].faces = this.getFaces(faces);
+    }
+
+    get dAdvantage() {
+        return this.dice[2];
+    }
+
+    get isCritical() {
+        if (!this.d20._evaluated) return;
+        return this.d20.total >= this.constructor.CRITICAL_TRESHOLD;
+    }
+
+    get hasAdvantage() {
+        return this.options.roll.advantage === this.constructor.ADV_MODE.ADVANTAGE;
+    }
+
+    get hasDisadvantage() {
+        return this.options.roll.advantage === this.constructor.ADV_MODE.DISADVANTAGE;
+    }
+
+    static applyKeybindings(config) {
+        let keys = {
+            normal: true,
+            advantage: false,
+            disadvantage: false
+        };
+
+        if (config.event) {
+            keys = {
+                normal: config.event.shiftKey || config.event.altKey || config.event.ctrlKey,
+                advantage: config.event.altKey,
+                disadvantage: config.event.ctrlKey
+            };
+        }
+
+        // Should the roll configuration dialog be displayed?
+        config.dialog.configure ??= !Object.values(keys).some(k => k);
+
+        // Determine advantage mode
+        const advantage = config.roll.advantage === this.ADV_MODE.ADVANTAGE || keys.advantage || config.advantage;
+        const disadvantage =
+            config.roll.advantage === this.ADV_MODE.DISADVANTAGE || keys.disadvantage || config.disadvantage;
+        if (advantage && !disadvantage) config.roll.advantage = this.ADV_MODE.ADVANTAGE;
+        else if (!advantage && disadvantage) config.roll.advantage = this.ADV_MODE.DISADVANTAGE;
+        else config.roll.advantage = this.ADV_MODE.NORMAL;
+    }
+
+    constructFormula(config) {
+        // this.terms = [];
+        this.createBaseDice();
+        this.configureModifiers();
+        this.resetFormula();
+        return this._formula;
+    }
+
+    createBaseDice() {
+        if (this.terms[0] instanceof foundry.dice.terms.Die) {
+            this.terms = [this.terms[0]];
+            return;
+        }
+        this.terms[0] = new foundry.dice.terms.Die({ faces: 20 });
+    }
+
+    configureModifiers() {
+        this.applyAdvantage();
+        this.applyBaseBonus();
+
+        this.options.experiences?.forEach(m => {
+            if (this.options.data.experiences?.[m])
+                this.options.roll.modifiers.push({
+                    label: this.options.data.experiences[m].name,
+                    value: this.options.data.experiences[m].total ?? this.options.data.experiences[m].value
+                });
+        });
+
+        this.options.roll.modifiers?.forEach(m => {
+            this.terms.push(...this.formatModifier(m.value));
+        });
+
+        this.baseTerms = foundry.utils.deepClone(this.terms);
+
+        if (this.options.extraFormula) {
+            this.terms.push(
+                new foundry.dice.terms.OperatorTerm({ operator: '+' }),
+                ...this.constructor.parse(this.options.extraFormula, this.options.data)
+            );
+        }
+    }
+
+    applyAdvantage() {
+        this.d20.modifiers.findSplice(m => ['kh', 'kl'].includes(m));
+        if (!this.hasAdvantage && !this.hasDisadvantage) this.number = 1;
+        else {
+            this.d20.number = 2;
+            this.d20.modifiers.push(this.hasAdvantage ? 'kh' : 'kl');
+        }
+    }
+
+    applyBaseBonus() {
+        this.options.roll.modifiers = [];
+        if (!this.options.roll.bonus) return;
+        this.options.roll.modifiers.push({
+            label: 'Bonus to Hit',
+            value: this.options.roll.bonus
+            // value: Roll.replaceFormulaData('@attackBonus', this.data)
+        });
+    }
+
+    static async buildEvaluate(roll, config = {}, message = {}) {
+        if (config.evaluate !== false) await roll.evaluate();
+        const advantageState =
+            config.roll.advantage == this.ADV_MODE.ADVANTAGE
+                ? true
+                : config.roll.advantage == this.ADV_MODE.DISADVANTAGE
+                  ? false
+                  : null;
+        setDiceSoNiceForDualityRoll(roll, advantageState);
+        this.postEvaluate(roll, config);
+    }
+
+    static postEvaluate(roll, config = {}) {
+        super.postEvaluate(roll, config);
+        if (config.targets?.length) {
+            config.targets.forEach(target => {
+                const difficulty = config.roll.difficulty ?? target.difficulty ?? target.evasion;
+                target.hit = this.isCritical || roll.total >= difficulty;
+            });
+        } else if (config.roll.difficulty)
+            config.roll.success = roll.isCritical || roll.total >= config.roll.difficulty;
+        config.roll.advantage = {
+            type: config.roll.advantage,
+            dice: roll.dAdvantage?.denomination,
+            value: roll.dAdvantage?.total
+        };
+        config.roll.isCritical = roll.isCritical;
+        config.roll.extra = roll.dice
+            .filter(d => !roll.baseTerms.includes(d))
+            .map(d => {
+                return {
+                    dice: d.denomination,
+                    value: d.total
+                };
+            });
+        config.roll.modifierTotal = this.calculateTotalModifiers(roll);
+    }
+
+    resetFormula() {
+        return (this._formula = this.constructor.getFormula(this.terms));
+    }
+}
+
+export class DualityRoll extends D20Roll {
+    _advantageFaces = 6;
+
+    constructor(formula, data = {}, options = {}) {
+        super(formula, data, options);
+    }
+
+    static messageType = 'dualityRoll';
+
+    static DefaultDialog = D20RollDialog;
+
+    get dHope() {
+        // if ( !(this.terms[0] instanceof foundry.dice.terms.Die) ) return;
+        if (!(this.dice[0] instanceof CONFIG.Dice.daggerheart.DualityDie)) this.createBaseDice();
+        return this.dice[0];
+        // return this.#hopeDice;
+    }
+
+    set dHope(faces) {
+        if (!(this.dice[0] instanceof CONFIG.Dice.daggerheart.DualityDie)) this.createBaseDice();
+        this.terms[0].faces = this.getFaces(faces);
+        // this.#hopeDice = `d${face}`;
+    }
+
+    get dFear() {
+        // if ( !(this.terms[1] instanceof foundry.dice.terms.Die) ) return;
+        if (!(this.dice[1] instanceof CONFIG.Dice.daggerheart.DualityDie)) this.createBaseDice();
+        return this.dice[1];
+        // return this.#fearDice;
+    }
+
+    set dFear(faces) {
+        if (!(this.dice[1] instanceof CONFIG.Dice.daggerheart.DualityDie)) this.createBaseDice();
+        this.dice[1].faces = this.getFaces(faces);
+        // this.#fearDice = `d${face}`;
+    }
+
+    get dAdvantage() {
+        return this.dice[2];
+    }
+
+    get advantageFaces() {
+        return this._advantageFaces;
+    }
+
+    set advantageFaces(faces) {
+        this._advantageFaces = this.getFaces(faces);
+    }
+
+    get isCritical() {
+        if (!this.dHope._evaluated || !this.dFear._evaluated) return;
+        return this.dHope.total === this.dFear.total;
+    }
+
+    get withHope() {
+        if (!this._evaluated) return;
+        return this.dHope.total > this.dFear.total;
+    }
+
+    get withFear() {
+        if (!this._evaluated) return;
+        return this.dHope.total < this.dFear.total;
+    }
+
+    get hasBarRally() {
+        return null;
+    }
+
+    get totalLabel() {
+        const label = this.withHope
+            ? 'DAGGERHEART.General.Hope'
+            : this.withFear
+              ? 'DAGGERHEART.General.Fear'
+              : 'DAGGERHEART.General.CriticalSuccess';
+
+        return game.i18n.localize(label);
+    }
+
+    updateFormula() {}
+
+    createBaseDice() {
+        if (
+            this.dice[0] instanceof CONFIG.Dice.daggerheart.DualityDie &&
+            this.dice[1] instanceof CONFIG.Dice.daggerheart.DualityDie
+        ) {
+            this.terms = [this.terms[0], this.terms[1], this.terms[2]];
+            return;
+        }
+        this.terms[0] = new CONFIG.Dice.daggerheart.DualityDie();
+        this.terms[1] = new foundry.dice.terms.OperatorTerm({ operator: '+' });
+        this.terms[2] = new CONFIG.Dice.daggerheart.DualityDie();
+    }
+
+    applyAdvantage() {
+        const dieFaces = this.advantageFaces,
+            bardRallyFaces = this.hasBarRally,
+            advDie = new foundry.dice.terms.Die({ faces: dieFaces });
+        if (this.hasAdvantage || this.hasDisadvantage || bardRallyFaces)
+            this.terms.push(new foundry.dice.terms.OperatorTerm({ operator: this.hasDisadvantage ? '-' : '+' }));
+        if (bardRallyFaces) {
+            const rallyDie = new foundry.dice.terms.Die({ faces: bardRallyFaces });
+            if (this.hasAdvantage) {
+                this.terms.push(
+                    new foundry.dice.terms.PoolTerm({
+                        terms: [advDie.formula, rallyDie.formula],
+                        modifiers: ['kh']
+                    })
+                );
+            } else if (this.hasDisadvantage) {
+                this.terms.push(advDie, new foundry.dice.terms.OperatorTerm({ operator: '+' }), rallyDie);
+            }
+        } else if (this.hasAdvantage || this.hasDisadvantage) this.terms.push(advDie);
+    }
+
+    applyBaseBonus() {
+        this.options.roll.modifiers = [];
+        if (!this.options.roll.trait) return;
+        this.options.roll.modifiers.push({
+            label: `DAGGERHEART.Abilities.${this.options.roll.trait}.name`,
+            value: Roll.replaceFormulaData(`@traits.${this.options.roll.trait}.total`, this.data)
+        });
+    }
+
+    static postEvaluate(roll, config = {}) {
+        super.postEvaluate(roll, config);
+        config.roll.hope = {
+            dice: roll.dHope.denomination,
+            value: roll.dHope.total
+        };
+        config.roll.fear = {
+            dice: roll.dFear.denomination,
+            value: roll.dFear.total
+        };
+        config.roll.result = {
+            duality: roll.withHope ? 1 : roll.withFear ? -1 : 0,
+            total: roll.dHope.total + roll.dFear.total,
+            label: roll.totalLabel
+        };
+    }
+}
+
+export class DamageRoll extends DHRoll {
+    constructor(formula, data = {}, options = {}) {
+        super(formula, data, options);
+    }
+
+    static messageType = 'damageRoll';
+
+    static DefaultDialog = DamageDialog;
+
+    static async postEvaluate(roll, config = {}) {
+        super.postEvaluate(roll, config);
+        config.roll.type = config.type;
+        config.roll.modifierTotal = this.calculateTotalModifiers(roll);
+        if (config.source?.message) {
+            const chatMessage = ui.chat.collection.get(config.source.message);
+            chatMessage.update({ 'system.damage': config });
+        }
+    }
+
+    constructFormula(config) {
+        super.constructFormula(config);
+        if (config.isCritical) {
+            const tmpRoll = new Roll(this._formula)._evaluateSync({ maximize: true }),
+                criticalBonus = tmpRoll.total - this.constructor.calculateTotalModifiers(tmpRoll);
+            this.terms.push(...this.formatModifier(criticalBonus));
+        }
+        return (this._formula = this.constructor.getFormula(this.terms));
+    }
+}

module/documents/tooltipManager.mjs

@@ -0,0 +1,16 @@
+export default class DhTooltipManager extends foundry.helpers.interaction.TooltipManager.implementation {
+    async activate(element, options = {}) {
+        let html = options.html;
+        if (element.dataset.tooltip.startsWith('#item#')) {
+            const item = await foundry.utils.fromUuid(element.dataset.tooltip.slice(6));
+            if (item) {
+                html = await foundry.applications.handlebars.renderTemplate(
+                    `systems/daggerheart/templates/ui/tooltip/${item.type}.hbs`,
+                    item
+                );
+            }
+        }
+
+        super.activate(element, { ...options, html: html });
+    }
+}