Added transform action to handle phased adversaries

module/applications/sheets-configs/action-base-config.mjs

@@ -28,6 +28,7 @@ export default class DHActionBaseConfig extends DaggerheartSheet(ApplicationV2)
             removeEffect: this.removeEffect,
             addElement: this.addElement,
             removeElement: this.removeElement,
+            removeTransformActor: this.removeTransformActor,
             editEffect: this.editEffect,
             addDamage: this.addDamage,
             removeDamage: this.removeDamage,
@@ -41,7 +42,7 @@ export default class DHActionBaseConfig extends DaggerheartSheet(ApplicationV2)
             submitOnChange: true,
             closeOnSubmit: false
         },
-        dragDrop: [{ dragSelector: null, dropSelector: '#summon-drop-zone', handlers: ['_onDrop'] }]
+        dragDrop: [{ dragSelector: null, dropSelector: '[data-is-drop-zone]', handlers: ['_onDrop'] }]
     };
 
     static PARTS = {
@@ -133,6 +134,12 @@ export default class DHActionBaseConfig extends DaggerheartSheet(ApplicationV2)
             context.summons.push({ actor, count: summon.count });
         }
 
+        if (context.source.transform) {
+            context.transform = {
+                actor: await foundry.utils.fromUuid(context.source.transform.actorUUID)
+            };
+        }
+
         context.openSection = this.openSection;
         context.tabs = this._getTabs(this.constructor.TABS);
         context.config = CONFIG.DH;
@@ -266,6 +273,12 @@ export default class DHActionBaseConfig extends DaggerheartSheet(ApplicationV2)
         if (doc) return doc.sheet.render({ force: true });
     }
 
+    static async removeTransformActor() {
+        const data = this.action.toObject();
+        data.transform.actorUUID = null;
+        this.constructor.updateForm.bind(this)(null, null, { object: foundry.utils.flattenObject(data) });
+    }
+
     static addDamage(_event) {
         if (!this.action.damage.parts) return;
         const data = this.action.toObject(),
@@ -364,6 +377,18 @@ export default class DHActionBaseConfig extends DaggerheartSheet(ApplicationV2)
             return;
         }
 
+        const dropZone = event.target.closest('[data-is-drop-zone]');
+        if (!dropZone) return;
+
+        switch (dropZone.id) {
+            case 'summon-drop-zone':
+                return this.onSummonDrop(data);
+            case 'transform-drop-zone':
+                return this.onTransformDrop(data);
+        }
+    }
+
+    async onSummonDrop(data) {
         const actionData = this.action.toObject();
         let countvalue = 1;
         for (const entry of actionData.summon) {
@@ -380,4 +405,10 @@ export default class DHActionBaseConfig extends DaggerheartSheet(ApplicationV2)
         actionData.summon.push({ actorUUID: data.uuid, count: countvalue });
         await this.constructor.updateForm.bind(this)(null, null, { object: foundry.utils.flattenObject(actionData) });
     }
+
+    async onTransformDrop(data) {
+        const actionData = this.action.toObject();
+        actionData.transform.actorUUID = data.uuid;
+        await this.constructor.updateForm.bind(this)(null, null, { object: foundry.utils.flattenObject(actionData) });
+    }
 }

module/config/actionConfig.mjs

@@ -35,6 +35,12 @@ export const actionTypes = {
         icon: 'fa-ghost',
         tooltip: 'DAGGERHEART.ACTIONS.TYPES.summon.tooltip'
     },
+    transform: {
+        id: 'transform',
+        name: 'DAGGERHEART.ACTIONS.TYPES.transform.name',
+        icon: 'fa-dragon',
+        tooltip: 'DAGGERHEART.ACTIONS.TYPES.transform.tooltip'
+    },
     effect: {
         id: 'effect',
         name: 'DAGGERHEART.ACTIONS.TYPES.effect.name',

module/data/action/_module.mjs

@@ -7,6 +7,7 @@ import EffectAction from './effectAction.mjs';
 import HealingAction from './healingAction.mjs';
 import MacroAction from './macroAction.mjs';
 import SummonAction from './summonAction.mjs';
+import TransformAction from './transformAction.mjs';
 
 export const actionsTypes = {
     base: BaseAction,
@@ -17,5 +18,6 @@ export const actionsTypes = {
     summon: SummonAction,
     effect: EffectAction,
     macro: MacroAction,
-    beastform: BeastformAction
+    beastform: BeastformAction,
+    transform: TransformAction
 };

module/data/action/transformAction.mjs

@@ -0,0 +1,5 @@
+import DHBaseAction from './baseAction.mjs';
+
+export default class DHTransformAction extends DHBaseAction {
+    static extraSchemas = [...super.extraSchemas, 'transform'];
+}

module/data/fields/action/_module.mjs

@@ -10,3 +10,4 @@ export { default as DamageField } from './damageField.mjs';
 export { default as RollField } from './rollField.mjs';
 export { default as MacroField } from './macroField.mjs';
 export { default as SummonField } from './summonField.mjs';
+export { default as TransformField } from './transformField.mjs';

module/data/fields/action/transformField.mjs

@@ -0,0 +1,47 @@
+const fields = foundry.data.fields;
+
+export default class DHSummonField extends fields.SchemaField {
+    /**
+     * Action Workflow order
+     */
+    static order = 130;
+
+    constructor(options = {}, context = {}) {
+        const transformFields = {
+            actorUUID: new fields.DocumentUUIDField({
+                type: 'Actor',
+                required: true
+            })
+        };
+        super(transformFields, options, context);
+    }
+
+    static async execute() {
+        if (!canvas.scene)
+            return ui.notifications.warn(game.i18n.localize('DAGGERHEART.ACTIONS.TYPES.transform.canvasError'));
+
+        if (!this.actor.token)
+            return ui.notifications.warn(game.i18n.localize('DAGGERHEART.ACTIONS.TYPES.transform.prototypeError'));
+
+        const actor = await DHSummonField.getWorldActor(await foundry.utils.fromUuid(this.transform.actorUUID));
+
+        await this.actor.token.update(
+            { ...actor.prototypeToken.toJSON(), actorId: actor.id },
+            { diff: false, recursive: false, noHook: true }
+        );
+        this.actor.sheet.close();
+        actor.sheet.render({ force: true });
+    }
+
+    /* Check for any available instances of the actor present in the world, or create a world actor based on compendium */
+    static async getWorldActor(baseActor) {
+        const dataType = game.system.api.data.actors[`Dh${baseActor.type.capitalize()}`];
+        if (baseActor.inCompendium && dataType && baseActor.img === dataType.DEFAULT_ICON) {
+            const worldActorCopy = game.actors.find(x => x.name === baseActor.name);
+            if (worldActorCopy) return worldActorCopy;
+        }
+
+        const worldActor = await game.system.api.documents.DhpActor.create(baseActor.toObject());
+        return worldActor;
+    }
+}

module/systemRegistration/handlebars.mjs

@@ -33,6 +33,7 @@ export const preloadHandlebarsTemplates = async function () {
         'systems/daggerheart/templates/actionTypes/beastform.hbs',
         'systems/daggerheart/templates/actionTypes/countdown.hbs',
         'systems/daggerheart/templates/actionTypes/summon.hbs',
+        'systems/daggerheart/templates/actionTypes/transform.hbs',
         'systems/daggerheart/templates/settings/components/settings-item-line.hbs',
         'systems/daggerheart/templates/ui/tooltip/parts/tooltipChips.hbs',
         'systems/daggerheart/templates/ui/tooltip/parts/tooltipTags.hbs',