[Rework] ChatMessage Damage (#2079)

* Initial rework

* Removed unneeded method

* Removed outcommented code

* Added migration

* Fixed DamageActions

* Semi-corrected reroll of one of multiple results on a die

* Code improvement

* Added aseDie.rerollResult method to specifically reroll a specific result die in a grouping

* TagTeamDialog somewhat working

* Added migration for TagTeamData

* Fix for mean tagTeamDialog.finish

* .

* Improved migration

* Internalised ChatDamageData.prepareRolls to its own constructor

* Moved DamageTypes to roll.options

* TagTeamDialog fixes to accomodate new flat damage.types structure

* Changed so all default rolls become BaseRolls to access convenience functions and getters

* .

* Fixed so that party.tagTeam now uses a declared damageRollData(ChatDamageData) field. rollData.options.damage is retired.

* Critical damage fixes

* Corrected TagTeamDialog rerender logic when selecting a roll

* Fixed so that DamageTypes are retained and joined together throughout TagTeamDialog

* Removed some remaining types.<>.roll references

* [Rework] Damage and Damage Resource split (#2094)

* Changed the label of ActionSheet damage.resources to Mark Resources

* Fix assigning includeBase

* Localize add resource

* Maybe simplify API

* Fix onRollSimple

* Handle erroring action update differently

---------

Co-authored-by: Carlos Fernandez <cfern1990@gmail.com>

module/data/chat-message/actorRoll.mjs

@@ -1,4 +1,5 @@
 import { triggerChatRollFx } from '../../helpers/utils.mjs';
+import { ChatDamageData } from './chatDamageData.mjs';
 
 const fields = foundry.data.fields;
 
@@ -49,7 +50,7 @@ export default class DHActorRoll extends foundry.abstract.TypeDataModel {
                 originItem: originItemField(),
                 action: new fields.StringField()
             }),
-            damage: new fields.ObjectField(),
+            damage: new fields.EmbeddedDataField(ChatDamageData),
             damageOptions: new fields.ObjectField(),
             costs: new fields.ArrayField(new fields.ObjectField()),
             successConsumed: new fields.BooleanField({ initial: false })
@@ -132,28 +133,21 @@ export default class DHActorRoll extends foundry.abstract.TypeDataModel {
         });
     }
 
-    /* TODO: Change how damage data is stored somehow to enable better rerolling */
     async getRerolledDamage() {
-        if (!this.damage) return;
+        if (!this.damage.active) return;
 
         const rerolls = [];
-        const update = { system: { damage: {} } };
-        for (const partKey in this.damage) {
-            const part = this.damage[partKey];
-            const testRoll = Roll.fromData(part.parts[0].roll);
-            const rerolled = await testRoll.reroll();
-            rerolls.push(rerolled);
+        const update = { system: { damage: { main: null, resources: _replace({}) } } };
+        if (this.damage.main) {
+            const reroll = await this.damage.main.reroll();
+            rerolls.push(reroll);
+            update.system.damage.main = reroll.toJSON();
+        }
 
-            if (!update.system.damage[partKey]) update.system.damage[partKey] = { parts: [part.parts[0]] };
-            const partData = update.system.damage[partKey].parts[0];
-            update.system.damage[partKey].total = rerolled.total;
-            partData.modifierTotal = rerolled.terms.reduce((acc, x) => {
-                if (x.isDeterministic && !x.operator) acc += x.total;
-                return acc;
-            }, 0);
-            partData.dice = rerolled.dice.map(d => ({ ...d.toJSON(), dice: d.denomination }));
-            partData.total = rerolled.total;
-            partData.roll = rerolled.toJSON();
+        for (const key of Object.keys(this.damage.resources)) {
+            const reroll = await this.damage.resources[key].reroll();
+            rerolls.push(reroll);
+            update.system.damage.resources[key] = reroll.toJSON();
         }
 
         await triggerChatRollFx(rerolls);
@@ -198,6 +192,43 @@ export default class DHActorRoll extends foundry.abstract.TypeDataModel {
         this.isGM = game.user.isGM; //temp
     }
 
+    static migrateData(source) {
+        const { main, resources, ...flatDamageKeys } = source.damage ?? {};
+        if (source.damage && !main && !resources) {
+            source.damage.main = null;
+            source.damage.resources = {};
+
+            const getRoll = key => {
+                const damageData = source.damage[key];
+                const oldRoll = damageData.parts[0]?.roll;
+                return oldRoll ? JSON.stringify({
+                    ...oldRoll,
+                    class: 'BaseRoll',
+                    options: {
+                        ...oldRoll.options,
+                        damageTypes: damageData.parts[0].damageTypes ?? []
+                    }
+                }) : null;
+            };
+
+            for (const key of Object.keys(flatDamageKeys)) {
+                if (key === 'hitPoints' && source.hasDamage && !source.hasHealing) {
+                    source.damage.main = getRoll('hitPoints');
+                } 
+                else {
+                    source.damage.resources[key] = getRoll(key);
+                }
+            }
+        }
+
+        for (const key of Object.keys(flatDamageKeys)) {
+            delete source.damage[key];
+        }
+        
+        return source;
+    }
+
+
     getTargetList() {
         const targets =
                 this.targetMode && this.parent.isAuthor

module/data/chat-message/chatDamageData.mjs

@@ -0,0 +1,58 @@
+import { triggerChatRollFx } from '../../helpers/utils.mjs';
+
+export class ChatDamageData extends foundry.abstract.DataModel {
+    constructor(data = {}, options = {}) {
+        super(data, options);
+        
+        this._prepareRolls();
+    }
+
+    static defineSchema() {
+        const fields = foundry.data.fields;
+        
+        return {
+            main: new fields.JSONField({ nullable: true, validate: ChatDamageData.#validateRoll}),
+            resources: new fields.TypedObjectField(new fields.JSONField({validate: ChatDamageData.#validateRoll}))
+        };
+    }
+
+    get active() {
+        return !!this.main || Boolean(Object.keys(this.resources).length);
+    }
+
+    static #validateRoll(rollJSON) {
+        if (rollJSON) {
+            const roll = JSON.parse(rollJSON);
+            if (!roll.evaluated) throw new Error('Roll objects added to ChatMessage documents must be evaluated');
+        }
+    }
+
+    _prepareRolls() {
+        this.main &&= Roll.fromData(this.main);
+        for (const key of Object.keys(this.resources)) {
+            this.resources[key] = Roll.fromData(this.resources[key]);
+        }
+    }
+
+    async rerollDamageDie(isResource, damageType, dice, resultIndex) {
+        const reroll = isResource ? this.resources[damageType] : this.main;
+        const rerollDice = reroll.dice[dice];
+        await rerollDice.rerollResult(resultIndex);
+        await reroll._evaluate();
+    
+        const rerolledResult = rerollDice.results[rerollDice.results.length - 1];
+        if (rerolledResult) {
+            const fakeRoll = {
+                _evaluated: true,
+                dice: [new foundry.dice.terms.Die({
+                    ...rerollDice,
+                    results: [rerolledResult],
+                    total: rerolledResult.value,
+                    faces: rerollDice.faces
+                })],
+                options: { appearance: {} }
+            };
+            await triggerChatRollFx([fakeRoll]);
+        }
+    }
+}