Standarize the combat turn taking across combat hud and tracker

Author: Azurelol

module/checks/common-events.mjs

@@ -261,6 +261,59 @@ function skill(actor, item) {
 	Hooks.call(FUHooks.SKILL_EVENT, event);
 }
 
+/**
+ * @description Dispatched when an actor performs a skill without am accuracy check.
+ * @typedef ItemEvent
+ * @property {ItemReference} item
+ * @property {FUActor} actor
+ * @property {String} type The item type
+ * @property {Token} token
+ * @property {EventTarget[]} targets
+ */
+
+/**
+ * @description Dispatches an event to signal the usage of a consumable
+ * @param {FUActor} actor
+ * @param {FUItem} item
+ */
+function item(actor, item) {
+	/** @type ConsumableDataModel  **/
+	const consumable = item.system;
+	const targets = Targeting.getSerializedTargetData();
+	const eventTargets = getEventTargets(targets);
+
+	/** @type ItemEvent  **/
+	const event = {
+		item: toItemReference(item),
+		actor: actor,
+		type: consumable.subtype.value,
+		token: actor.resolveToken(),
+		targets: eventTargets,
+	};
+	Hooks.call(FUHooks.ITEM_EVENT, event);
+}
+
+/**
+ * @description Dispatched when an actor performs a study check
+ * @typedef StudyEvent
+ * @property {FUActor} actor
+ * @property {Token} token
+ * @property {EventTarget[]} targets
+ */
+
+function study(actor, targets) {
+	const targetData = Targeting.serializeTargetData(targets);
+	const eventTargets = getEventTargets(targetData);
+
+	/** @type ItemEvent  **/
+	const event = {
+		actor: actor,
+		token: actor.resolveToken(),
+		targets: eventTargets,
+	};
+	Hooks.call(FUHooks.STUDY_EVENT, event);
+}
+
 /**
  * @param {TargetData[]} targets
  * @returns {EventTarget[]}
@@ -301,4 +354,6 @@ export const CommonEvents = Object.freeze({
 	loss,
 	spell,
 	skill,
+	item,
+	study,
 });

module/checks/common-sections.mjs

@@ -151,7 +151,7 @@ const opportunity = (sections, opportunity, order) => {
  * @param accuracyData
  * @param {TemplateDamageData} damageData
  */
-const targeted = (sections, actor, item, targets, flags, accuracyData, damageData) => {
+const targeted = (sections, actor, item, targets, flags, accuracyData = undefined, damageData = undefined) => {
 	const isTargeted = targets?.length > 0 || !Targeting.STRICT_TARGETING;
 	if (isTargeted) {
 		sections.push(async function () {
@@ -234,7 +234,7 @@ async function showFloatyText(targetData, localizedText) {
  * @param {Object} flags
  * @param {ResourceExpense} expense
  */
-const spendResource = (sections, actor, item, targets, flags, expense) => {
+const spendResource = (sections, actor, item, targets, flags, expense = undefined) => {
 	// Resolve the expense if not explicit
 	if (expense === undefined) {
 		// If using the newer cost data model

module/documents/actors/actor.mjs

@@ -1,6 +1,6 @@
 import { FUItem } from '../items/item.mjs';
 import { FUHooks } from '../../hooks.mjs';
-import { Effects, toggleStatusEffect } from '../../pipelines/effects.mjs';
+import { Effects, prepareActiveEffectCategories, toggleStatusEffect } from '../../pipelines/effects.mjs';
 import { SYSTEM } from '../../helpers/config.mjs';
 import { Flags } from '../../helpers/flags.mjs';
 
@@ -33,6 +33,7 @@ import { Flags } from '../../helpers/flags.mjs';
  * @description Extend the base Actor document by defining a custom roll data structure
  * @extends {Actor}
  * @property {CharacterDataModel | NpcDataModel} system
+ * @property {EffectCategories} effectCategories
  * @remarks {@link https://foundryvtt.com/api/classes/client.Actor.html}
  * @inheritDoc
  */
@@ -310,6 +311,18 @@ export class FUActor extends Actor {
 		return effects;
 	}
 
+	/**
+	 * @returns {EffectCategories}
+	 * @remarks Used by modules mostly
+	 */
+	get effectCategories() {
+		const effects = Array.from(this.allApplicableEffects());
+		this.temporaryEffects.forEach((effect) => {
+			if (effects.indexOf(effect) < 0) effects.push(effect);
+		});
+		return prepareActiveEffectCategories(effects);
+	}
+
 	applyActiveEffects() {
 		if (this.system.prepareEmbeddedData instanceof Function) {
 			this.system.prepareEmbeddedData();

module/documents/items/consumable/consumable-data-model.mjs

@@ -1,12 +1,18 @@
 import { CheckHooks } from '../../../checks/check-hooks.mjs';
 import { FU } from '../../../helpers/config.mjs';
 import { CommonSections } from '../../../checks/common-sections.mjs';
+import { CheckConfiguration } from '../../../checks/check-configuration.mjs';
+import { CommonEvents } from '../../../checks/common-events.mjs';
 
 Hooks.on(CheckHooks.renderCheck, (sections, check, actor, item, flags) => {
 	if (item?.system instanceof ConsumableDataModel) {
 		CommonSections.tags(sections, [{ tag: FU.consumableType[item.system.subtype.value] }, { tag: 'FU.InventoryAbbr', value: item.system.ipCost.value, flip: true }]);
 		CommonSections.description(sections, item.system.description, item.system.summary.value);
+		const targets = CheckConfiguration.inspect(check).getTargetsOrDefault();
+		CommonSections.targeted(sections, actor, item, targets, flags);
 		CommonSections.spendResource(sections, actor, item, [], flags);
+
+		CommonEvents.item(actor, item);
 	}
 });
 

module/helpers/checks.mjs

@@ -152,6 +152,7 @@ import { Flags } from './flags.mjs';
 import { ChecksV2 } from '../checks/checks-v2.mjs';
 import { CheckHooks } from '../checks/check-hooks.mjs';
 import { CheckConfiguration } from '../checks/check-configuration.mjs';
+import { CommonEvents } from '../checks/common-events.mjs';
 
 /**
  *
@@ -946,6 +947,8 @@ export async function promptOpenCheck(actor, title, action) {
 					try {
 						const studyRollHandler = new StudyRollHandler(actor, checkResult.result);
 						await studyRollHandler.handleStudyRoll();
+						const targets = CheckConfiguration.inspect(checkResult).getTargetsOrDefault();
+						CommonEvents.study(actor, targets);
 						return { rollResult: checkResult.result, message: null };
 					} catch (error) {
 						console.error('Error processing study roll:', error);

module/helpers/study-roll.mjs

@@ -26,7 +26,6 @@ export class StudyRollHandler {
 			}
 		}
 
-		// Iterate over each targeted actor
 		for (const actor of targets) {
 			await this.handleStudyRollCallback(actor);
 		}
@@ -87,7 +86,7 @@ export class StudyRollHandler {
 		);
 
 		// Render the dialog
-		dialog.render(true);
+		await dialog.render(true);
 	}
 
 	/**

module/helpers/targeting.mjs

@@ -1,6 +1,5 @@
 import { ChooseWeaponDialog } from '../documents/items/skill/choose-weapon-dialog.mjs';
 import { Flags } from './flags.mjs';
-import { SYSTEM } from './config.mjs';
 import { getTargeted } from './target-handler.mjs';
 
 /**
@@ -125,7 +124,7 @@ function deserializeTargetData(targetData) {
  * @param {jQuery} jQuery
  */
 function onRenderChatMessage(document, jQuery) {
-	if (!document.getFlag(SYSTEM, Flags.ChatMessage.Targets)) {
+	if (!document.getFlag(Flags.Scope, Flags.ChatMessage.Targets)) {
 		return;
 	}
 

module/hooks.mjs

@@ -100,4 +100,16 @@ export const FUHooks = {
 	 * @remarks Uses {@link StatusEvent}. It happens AFTER the status effect has been applied.
 	 */
 	STATUS_EVENT: 'projectfu.events.status',
+	/**
+	 * @description Dispatched after an actor uses a consumable
+	 * @example callback(event)
+	 * @remarks Uses {@link ItemEvent}
+	 */
+	ITEM_EVENT: 'projectfu.events.item',
+	/**
+	 * @description Dispatched after an actor performs a study check
+	 * @example callback(event)
+	 * @remarks Uses {@link StudyEvent}
+	 */
+	STUDY_EVENT: 'projectfu.events.study',
 };

module/pipelines/effects.mjs

@@ -112,6 +112,13 @@ export async function onManageActiveEffect(event, owner) {
 	}
 }
 
+/**
+ * @typedef EffectCategories
+ * @property temporary
+ * @property passive
+ * @property inactive
+ */
+
 /**
  * Prepare the data structure for Active Effects which are currently applied to an Actor or Item.
  * @param {ActiveEffect[]} effects    The array of Active Effect instances to prepare sheet data for

module/sheets/actor-standard-sheet.mjs

@@ -1,4 +1,4 @@
-import { isActiveEffectForStatusEffectId, onManageActiveEffect, prepareActiveEffectCategories, toggleStatusEffect } from '../pipelines/effects.mjs';
+import { isActiveEffectForStatusEffectId, onManageActiveEffect, toggleStatusEffect } from '../pipelines/effects.mjs';
 import { createChatMessage, promptCheck, promptOpenCheck } from '../helpers/checks.mjs';
 import { ItemCustomizer } from '../helpers/item-customizer.mjs';
 import { ActionHandler } from '../helpers/action-handler.mjs';
@@ -127,11 +127,7 @@ export class FUStandardActorSheet extends ActorSheet {
 		context.rollData = context.actor.getRollData();
 
 		// Prepare active effects
-		const effects = Array.from(this.actor.allApplicableEffects());
-		this.actor.temporaryEffects.forEach((effect) => {
-			if (effects.indexOf(effect) < 0) effects.push(effect);
-		});
-		context.effects = prepareActiveEffectCategories(effects);
+		context.effects = this.actor.effectCategories;
 
 		// Combine all effects into a single array
 		context.allEffects = [...context.effects.temporary.effects, ...context.effects.passive.effects, ...context.effects.inactive.effects];

module/ui/combat-hud.mjs

@@ -153,13 +153,11 @@ export class CombatHUD extends Application {
 		data.cssClasses = this.options.classes.join(' ');
 		data.cssId = this.options.id;
 		data.isCompact = game.settings.get(SYSTEM, SETTINGS.optionCombatHudCompact);
-		data.isGM = game.user.isGM;
 
 		const opacity = game.settings.get(SYSTEM, SETTINGS.optionCombatHudOpacity) / 100;
 		data.additionalStyle = this._getAdditionalStyle(opacity);
 
 		const ordering = game.settings.get(SYSTEM, SETTINGS.optionCombatHudActorOrdering);
-
 		data.npcs = [];
 		data.characters = [];
 
@@ -185,14 +183,9 @@ export class CombatHUD extends Application {
 
 		const NPCTurnsLeftMode = game.settings.get(SYSTEM, SETTINGS.optionCombatHudShowNPCTurnsLeftMode);
 
-		const currentTurn = game.combat.getCurrentTurn();
-		const turnsLeft = ui.combat.countTurnsLeft(game.combat);
-		// const round = game.combat.round;
-
 		/** @type FUCombat **/
 		const combat = game.combat;
-		data.turnStarted = combat.isTurnStarted;
-		data.hasCombatStarted = game.combat.started;
+		combat.populateData(data);
 
 		for (const combatant of game.combat.combatants) {
 			if (!combatant.actor || !combatant.token) continue;
@@ -202,7 +195,10 @@ export class CombatHUD extends Application {
 				id: combatant.id,
 				name: combatant.name,
 				actor: combatant.actor,
+				isOwner: combatant.isOwner,
+				totalTurns: combatant.totalTurns,
 				token: combatant.token,
+				faction: combatant.faction,
 				effects: activeEffects,
 				// token._source should contain the most current version of the token's texture.
 				img: game.settings.get(SYSTEM, SETTINGS.optionCombatHudPortrait) === 'token' ? combatant.token._source.texture.src : combatant.actor.img,
@@ -247,7 +243,6 @@ export class CombatHUD extends Application {
 
 				// Ensure shouldEffectsMarquee is false if effectsMarqueeDuration is over 9000
 				actorData.shouldEffectsMarquee = actorData.effects.length > maxEffectsBeforeMarquee && effectsMarqueeDuration < 9000;
-
 				actorData.effectsMarqueeDuration = effectsMarqueeDuration;
 
 				const marqueeDirection = game.settings.get(SYSTEM, SETTINGS.optionCombatHudEffectsMarqueeMode);
@@ -271,29 +266,19 @@ export class CombatHUD extends Application {
 				});
 			}
 
-			actorData.isOwner = combatant.isOwner;
 			actorData.order = order;
 
-			actorData.totalTurns = combatant.totalTurns;
 			if (NPCTurnsLeftMode === 'never') {
 				actorData.totalTurns = 1;
 			} else if (NPCTurnsLeftMode === 'only-studied' && !this._isNPCStudied(combatant.token)) {
 				actorData.totalTurns = 1;
 			}
 
-			actorData.turnsLeft = turnsLeft[combatant.id] ?? 0;
-
 			if (combatant.token.disposition === foundry.CONST.TOKEN_DISPOSITIONS.FRIENDLY) {
-				actorData.isCurrentTurn = currentTurn === 'friendly';
 				data.characters.push(actorData);
 			} else {
-				actorData.isCurrentTurn = currentTurn === 'hostile';
 				data.npcs.push(actorData);
 			}
-
-			// Decides whether combatant can (start turn | take turn)
-			actorData.isCurrentCombatant = combat.isCurrentCombatant(combatant);
-			actorData.hasTurns = turnsLeft[combatant.id] && actorData.isCurrentTurn;
 		}
 
 		data.characters.sort((a, b) => a.order - b.order);
@@ -361,6 +346,7 @@ export class CombatHUD extends Application {
 
 		html.find('a[data-action=start-turn]').click((event) => ui.combat.handleStartTurn(event));
 		html.find('a[data-action=end-turn]').click((event) => ui.combat.handleEndTurn(event));
+		html.find('a[data-action=take-turn-out-of-turn]').click((event) => ui.combat.handleTakeTurnOutOfTurn(event));
 	}
 
 	_doHudDragStart(event) {
@@ -861,6 +847,8 @@ export class CombatHUD extends Application {
 				activeEffect.parent.parent?.documentName === 'Actor' &&
 				foundry.utils.hasProperty(changes, 'transfer') &&
 				game.combat?.combatants.some((c) => c.actor.uuid === activeEffect.parent.parent.uuid)
+			!(activeEffect.target && game.combat?.combatants.some((c) => c.actor.uuid === activeEffect.target.uuid)) &&
+				game.combat?.combatants.some((c) => c.actor.uuid === activeEffect.parent.parent.uuid)
 			)
 		) {
 			return;