Fix for mean tagTeamDialog.finish

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,23 @@ 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');
+        
+        /* This could assumably be done better. For some reason rolls don't get correctly done through rollData.toJSON */
+        const systemData = {
+            ...mainRoll.options,
+            damage: joinedRoll.damageRollData.toJSON()
+        };
+        for (const type of Object.keys(joinedRoll.damageRollData.types)) {
+            systemData.damage.types[type].roll = joinedRoll.damageRollData.types[type].roll.toJSON();
+        }
+
         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 }));

module/systemRegistration/migration-handlers/2_6_0.mjs

@@ -0,0 +1,20 @@
+import { MigrationHandlerBase } from './base.mjs';
+
+export class Migration_2_6_0 extends MigrationHandlerBase {
+    version = '2.6.0';
+
+    /** @inheritdoc */
+    async updateActorSource(actor) {
+        if (actor.type === 'party') {
+            return {
+                _id: actor._id,
+                system: {
+                    tagTeam: {
+                        initiator: null,
+                        members: _replace({})
+                    }
+                }
+            };
+        }
+    }
+}

module/systemRegistration/migration-handlers/base.mjs

@@ -1,8 +1,9 @@
 /** 
  * @import DHItem from "../../documents/item.mjs";
+* @import DhActor from "../../documents/actor.mjs";
  */
-
 /** 
+
  * The base class of an async migration. 
  * These are generally run between versions for things that require compendiums or must be done in post.
  * The migrate() functions calls the various updateXSource() functions.
@@ -22,6 +23,16 @@ export class MigrationHandlerBase {
         return null;
     }
 
+    /**
+     * Update a world actor
+     * @param {DhActor} actor 
+     * @returns {Promise<object>}
+     * @protected
+     */
+    async updateActorSource(actor) {
+        return null;
+    }
+
     async migrate() {
         // todo: handle more than just migrating effects. Right now this can only migrate effects
         // NOTE: the preload is hardcoded, we should not hardcode it
@@ -60,10 +71,39 @@ export class MigrationHandlerBase {
             }
         };
 
-        for (const actor of game.actors) {
+        const updateActor = async actor => {
+            const actorUpdate = await this.updateActorSource(actor);
+            if (actorUpdate) {
+                batch.push({
+                    action: 'update',
+                    documentName: 'Actor',
+                    updates: [actorUpdate]
+                });
+            }
+
+            const aeUpdates = [];
             for (const item of actor.items) {
                 await updateItem(item);
             }
+            
+            for (const effect of actor.effects) {
+                const changes = await this.updateActiveEffectSource(effect.toObject(), { parent: actor });
+                if (changes) aeUpdates.push(changes);
+            }
+            if (aeUpdates.length) {
+                batch.push({
+                    action: 'update',
+                    documentName: 'ActiveEffect',
+                    updates: aeUpdates,
+                    parent: actor
+                });
+            }
+        }
+
+
+        for (const actor of game.actors) {
+            await updateActor(actor);
+  
             progress.advance();
         }
         for (const item of game.items) {

module/systemRegistration/migrations.mjs

@@ -1,5 +1,6 @@
 import { defaultRestOptions } from '../config/generalConfig.mjs';
 import { Migration_2_5_2 } from './migration-handlers/2_5_2.mjs';
+import { Migration_2_6_0 } from './migration-handlers/2_6_0.mjs';
 
 export async function runMigrations() {
     let lastMigrationVersion = game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.LastMigrationVersion);
@@ -329,7 +330,8 @@ export async function runMigrations() {
     /* -------------------------------------------- */
 
     const migrations = [
-        new Migration_2_5_2()
+        new Migration_2_5_2(),
+        new Migration_2_6_0()
     ].filter(m => m.version && foundry.utils.isNewerVersion(m.version, lastMigrationVersion));
 
     for (const handler of migrations) {

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>