TagTeamDialog somewhat working

module/applications/dialogs/tagTeamDialog.mjs

@@ -1,4 +1,5 @@
 import { ResourceUpdateMap } from '../../data/action/baseAction.mjs';
+import { ChatDamageData } from '../../data/chat-message/chatDamageData.mjs';
 import { MemberData } from '../../data/tagTeamData.mjs';
 import { getCritDamageBonus, shouldUseHopeFearAutomation } from '../../helpers/utils.mjs';
 import { emitGMUpdate, GMUpdateEvent, RefreshType, socketEvent } from '../../systemRegistration/socket.mjs';
@@ -236,7 +237,6 @@ export default class TagTeamDialog extends HandlebarsApplicationMixin(Applicatio
 
         const selectedRoll = Object.values(this.party.system.tagTeam.members).find(member => member.selected);
         const critSelected = !selectedRoll ? undefined : (selectedRoll?.rollData?.options?.roll?.isCritical ?? false);
-        const damage = data.rollData?.options?.damage;
 
         return {
             ...data,
@@ -247,8 +247,8 @@ export default class TagTeamDialog extends HandlebarsApplicationMixin(Applicatio
             hasRolled: Boolean(data.rollData),
             rollOptions,
             damageRollOptions,
-            damage: damage,
+            damage: data.damageRollData,
-            critDamage: await this.getCriticalDamage(damage),
+            critDamage: await this.getCriticalDamage(data.damageRollData),
             useCritDamage: critSelected || (critSelected === undefined && data.rollData?.options?.roll?.isCritical)
         };
     }
@@ -609,47 +609,20 @@ export default class TagTeamDialog extends HandlebarsApplicationMixin(Applicatio
         );
     }
 
-    async getCriticalDamage(damage) {
+    async getCriticalDamage(origDamage) {
-        const newDamage = foundry.utils.deepClone(damage);
+        const newDamage = origDamage ? ChatDamageData.fromJSON(JSON.stringify(origDamage)) : null;
-        for (let key in newDamage) {
+        for (let key in newDamage?.types ?? {}) {
-            var damage = newDamage[key];
+            const damage = newDamage.types[key];
-            damage.formula = '';
+            const criticalDamage = await getCritDamageBonus(damage.roll.formula);
-            damage.total = 0;
+            if (!criticalDamage) continue;
-
+    
-            for (let part of damage.parts) {
+            const criticalTerm = new foundry.dice.terms.NumericTerm({ number: criticalDamage, evaluated: true });
-                const criticalDamage = await getCritDamageBonus(part.formula);
+            criticalTerm.evaluate();
-                if (criticalDamage) {
+            damage.roll = await Roll.fromTerms([
-                    part.modifierTotal += criticalDamage;
+                ...origDamage.types[key].roll.terms,
-                    part.total += criticalDamage;
+                new foundry.dice.terms.OperatorTerm({ operator: '+' }),
-                    part.formula = `${part.dice.map(x => x.formula).join(' + ')} + ${part.modifierTotal}`;
+                criticalTerm
-                    part.roll = new Roll(part.formula);
+            ]);
-                }
-
-                damage.formula = [damage.formula, part.formula].filter(x => x).join(' + ');
-                damage.total += part.total;
-            }
-        }
-
-        return newDamage;
-    }
-
-    async getNonCriticalDamage(config) {
-        const newDamage = foundry.utils.deepClone(config.damage);
-        for (let key in newDamage) {
-            var damage = newDamage[key];
-            damage.formula = '';
-            damage.total = 0;
-
-            for (let part of damage.parts) {
-                const critDamageBonus = await getCritDamageBonus(part.formula);
-                part.modifierTotal -= critDamageBonus;
-                part.total -= critDamageBonus;
-                part.formula = `${part.dice.map(x => x.formula).join(' + ')} + ${part.modifierTotal}`;
-                part.roll = new Roll(part.formula);
-
-                damage.formula = [damage.formula, part.formula].filter(x => x).join(' + ');
-                damage.total += part.total;
-            }
         }
 
         return newDamage;
@@ -685,29 +658,34 @@ export default class TagTeamDialog extends HandlebarsApplicationMixin(Applicatio
             if (!baseMainRoll?.rollData || !baseSecondaryRoll) return null;
 
             const mainRoll = new MemberData(baseMainRoll.toObject());
-            const secondaryRollData = new MemberData(baseSecondaryRoll.toObject()).rollData;
+            mainRoll.damageRollData = baseMainRoll.damageRollData ? 
+                ChatDamageData.fromJSON(JSON.stringify(baseMainRoll.damageRollData)) : null;
+            const secondaryRoll = new MemberData(baseSecondaryRoll.toObject());
+            secondaryRoll.damageRollData = baseSecondaryRoll.damageRollData ? 
+                ChatDamageData.fromJSON(JSON.stringify(baseSecondaryRoll.damageRollData)) : null;
+
             const systemData = mainRoll.rollData.options;
             const isCritical = overrideIsCritical ?? systemData.roll.isCritical;
-            if (isCritical) systemData.damage = await this.getCriticalDamage(systemData.damage);
+            if (isCritical) mainRoll.damageRollData = await this.getCriticalDamage(systemData.damageRollData);
 
-            if (secondaryRollData?.options.hasDamage) {
+            if (secondaryRoll.damageRollData) {
                 const secondaryDamage = (displayVersion ? overrideIsCritical : isCritical)
-                    ? await this.getCriticalDamage(secondaryRollData.options.damage)
+                    ? await this.getCriticalDamage(secondaryRoll.damageRollData)
-                    : secondaryRollData.options.damage;
+                    : secondaryRoll.damageRollData;
-                if (systemData.damage) {
+                if (mainRoll.damageRollData) {
-                    for (const [key, damage] of Object.entries(secondaryDamage ?? {})) {
+                    for (const [key, damage] of Object.entries(secondaryDamage.types ?? {})) {
-                        if (key in systemData.damage) {
+                        if (key in mainRoll.damageRollData.types) {
-                            systemData.damage[key].formula = [systemData.damage[key]?.formula, damage.formula]
+                            mainRoll.damageRollData.types[key].roll = Roll.fromTerms([
-                                .filter(x => x)
+                                ...baseMainRoll.damageRollData.types[key].roll.terms,
-                                .join(' + ');
+                                new foundry.dice.terms.OperatorTerm({ operator: '+' }),
-                            systemData.damage[key].total += damage.total;
+                                ...baseSecondaryRoll.damageRollData.types[key].roll.terms
-                            systemData.damage[key].parts.push(...damage.parts);
+                            ]);
                         } else {
-                            systemData.damage[key] = damage;
+                            mainRoll.damageRollData.types[key] = damage;
                         }
                     }
                 } else {
-                    systemData.damage = secondaryDamage;
+                    mainRoll.damageRollData = secondaryDamage;
                 }
             }
 
@@ -762,13 +740,17 @@ export default class TagTeamDialog extends HandlebarsApplicationMixin(Applicatio
 
         const mainActor = this.party.system.partyMembers.find(x => x.uuid === mainRoll.options.source.actor);
         mainRoll.options.title = game.i18n.localize('DAGGERHEART.APPLICATIONS.TagTeamSelect.chatMessageRollTitle');
+        const systemData = {
+            ...mainRoll.options,
+            damage: joinedRoll.damageRollData
+        };
         const cls = getDocumentClass('ChatMessage'),
             msgData = {
                 type: 'dualityRoll',
                 user: game.user.id,
                 title: game.i18n.localize('DAGGERHEART.APPLICATIONS.TagTeamSelect.title'),
                 speaker: cls.getSpeaker({ actor: mainActor }),
-                system: mainRoll.options,
+                system: systemData,
                 rolls: [JSON.stringify(joinedRoll.roll)],
                 sound: null,
                 flags: { core: { RollTable: true } }

module/data/actor/party.mjs

@@ -3,6 +3,7 @@ import ForeignDocumentUUIDArrayField from '../fields/foreignDocumentUUIDArrayFie
 import TagTeamData from '../tagTeamData.mjs';
 import GroupRollData from '../groupRollData.mjs';
 import { GoldField } from '../fields/actorField.mjs';
+import { ChatDamageData } from '../chat-message/chatDamageData.mjs';
 
 export default class DhParty extends BaseDataActor {
     /** @inheritdoc */
@@ -48,6 +49,15 @@ export default class DhParty extends BaseDataActor {
         }
     }
 
+    prepareDerivedData() {
+        for (const memberKey in this.tagTeam.members) {
+            const member = this.tagTeam.members[memberKey];
+            member.damageRollData = member.rollData?.options.damage ? 
+                ChatDamageData.fromJSON(JSON.stringify(member.rollData.options.damage)) : null;
+            member.damageRollData?.prepareRolls();
+        }
+    }
+
     _onCreate(data, options, userId) {
         super._onCreate(data, options, userId);
 

module/dice/dhRoll.mjs

@@ -1,7 +1,8 @@
 import D20RollDialog from '../applications/dialogs/d20RollDialog.mjs';
 import { triggerChatRollFx } from '../helpers/utils.mjs';
+import BaseRoll from './baseRoll.mjs';
 
-export default class DHRoll extends Roll {
+export default class DHRoll extends BaseRoll {
     baseTerms = [];
     constructor(formula, data = {}, options = {}) {
         super(formula, data, foundry.utils.mergeObject(options, { roll: [] }, { overwrite: false }));

templates/dialogs/tagTeamDialog/parts/tagTeamDamageParts.hbs

@@ -1,25 +1,25 @@
-{{#each damage as |damage key|}}
+{{#each damage.types as |damage key|}}
     <div class="roll-data {{#if isCritical}}critical{{/if}}">
         <div class="duality-label">
             <span>{{localize (concat "DAGGERHEART.CONFIG.HealingType." key ".name")}}:</span>
-            <span>{{damage.total}}</span>
+            <span>{{damage.roll.total}}</span>
         </div>
-        {{#each damage.parts as |part|}}
+        {{#with damage.roll}}
             <div class="roll-dice-container">
-                {{#each part.dice as |dice index|}}
+                {{#each this.dice as |dice index|}}
-                    <a class="roll-dice" data-action="rerollDamageDice" data-member-key="{{../../../key}}" data-damage-key="{{@../../key}}" data-part="{{@../index}}" data-dice="{{index}}">
+                    <a class="roll-dice" data-action="rerollDamageDice" data-member-key="{{../../../key}}" data-damage-key="{{@../../key}}" data-dice="{{index}}">
                         <span class="dice-label">{{dice.total}}</span>
-                        <img src="{{concat "systems/daggerheart/assets/icons/dice/hope/" dice.dice ".svg"}}" />
+                        <img src="{{concat "systems/daggerheart/assets/icons/dice/hope/" dice.denomination ".svg"}}" />
                     </a>
                     {{#unless @last}}
                         <span class="roll-operator">+</span>
                     {{/unless}}
                 {{/each}}
-                {{#if part.modifierTotal}}
+                {{#if this.modifierTotal}}
-                    {{#if part.dice.length}}<span class="roll-operator">{{#if (gte part.modifierTotal 0)}}+{{else}}-{{/if}}</span>{{/if}}
+                    {{#if this.dice.length}}<span class="roll-operator">{{#if (gte this.modifierTotal 0)}}+{{else}}-{{/if}}</span>{{/if}}
-                    <span class="roll-value">{{positive part.modifierTotal}}</span>
+                    <span class="roll-value">{{positive this.modifierTotal}}</span>
                 {{/if}}
             </div>
-        {{/each}}
+        {{/with}}
     </div>
 {{/each}}

templates/dialogs/tagTeamDialog/result.hbs

@@ -6,22 +6,22 @@
                 {{#if hintText}}
                     <div class="hint">{{localize hintText}}</div>
                 {{else}}
-                    {{#if joinedRoll.roll}}
+                    {{#if joinedRoll.rollData}}
                         <div class="result-container">
                             <span class="result-section-label">{{localize "DAGGERHEART.GENERAL.dualityRoll"}}</span>
                             <div class="result-info">
-                                <div class="damage-info">{{joinedRoll.roll.total}}</div>
+                                <div class="damage-info">{{joinedRoll.rollData.total}}</div>
                                 <div>{{localize "DAGGERHEART.GENERAL.withThing" thing=joinedRoll.roll.totalLabel}}</div>
                             </div>
                         </div>
                     {{/if}}
-                    {{#if joinedRoll.rollData.options.hasDamage}}
+                    {{#if joinedRoll.damageRollData}}
                         <div class="result-container">
                             <span class="result-section-label">{{localize "DAGGERHEART.GENERAL.damage"}}</span>
-                            {{#each joinedRoll.rollData.options.damage as |damage key|}}
+                            {{#each joinedRoll.damageRollData.types as |damage key|}}
                                 <div class="result-info">
                                     <div>{{localize (concat "DAGGERHEART.CONFIG.HealingType." key ".name")}}</div>
-                                    <div class="damage-info">{{damage.total}}</div>
+                                    <div class="damage-info">{{damage.roll.total}}</div>
                                 </div>
                             {{/each}}
                         </div>