@rpgjs/action-battle 5.0.0-beta.10 → 5.0.0-beta.12

package/dist/client/index20.js

@@ -1,504 +1,60 @@
-import "./index2.js";
-import { normalizeActionBattleAttackProfile } from "./index3.js";
-import { normalizeActionBattleOptions, setActionBattleOptions } from "./index4.js";
-import { manhattanDistance, parseAoeMask } from "./index7.js";
-import { playActionBattleAnimation } from "./index10.js";
-import { ActionBattleHitTracker, createActionBattleAttackId, getNormalizedActionBattleAttackProfile, resolveActionBattleHitboxSpeed, scheduleActionBattleStartup } from "./index11.js";
-import { DEFAULT_ZELDA_PLAYER_HITBOXES } from "./index13.js";
-import { getActionBattleSystems, setActionBattleSystems } from "./index14.js";
-import "./index15.js";
-import "./index16.js";
-import { resolveActionBattleWeaponAttackProfile } from "./index17.js";
-import { applyActionBattleHit } from "./index18.js";
-import { Control, defineModule } from "@rpgjs/common";
-//#region src/server.ts
-var RpgEvent = null;
-var DEFAULT_KNOCKBACK = null;
-var ACTION_BATTLE_ACTION_BAR_GUI_ID = "action-battle-action-bar";
-var DEFAULT_ATTACK_LOCK_DURATION_MS = 350;
-/**
-* Default player attack hitboxes offsets for each direction
-* 
-* These hitboxes define the attack areas relative to the player's position
-* for each cardinal direction. They are converted to absolute coordinates
-* when creating the moving hitbox.
-*/
-var DEFAULT_PLAYER_ATTACK_HITBOXES = { ...DEFAULT_ZELDA_PLAYER_HITBOXES };
-var beginPlayerAttackLock = (player, map, durationMs, locks) => {
-	if (durationMs <= 0) return true;
-	const runtimePlayer = player;
-	const now = Date.now();
-	if (typeof runtimePlayer.__actionBattleAttackLockedUntil === "number" && runtimePlayer.__actionBattleAttackLockedUntil > now) return false;
-	const lockId = (runtimePlayer.__actionBattleAttackLockId ?? 0) + 1;
-	runtimePlayer.__actionBattleAttackLockId = lockId;
-	runtimePlayer.__actionBattleAttackLockedUntil = now + durationMs;
-	const previousCanMove = player.canMove;
-	const previousDirectionFixed = player.directionFixed;
-	const previousAnimationFixed = player.animationFixed;
-	if (locks.movement) {
-		player.pendingInputs = [];
-		player.lastProcessedInputTs = 0;
-		map?.stopMovement?.(player);
-		player.canMove = false;
-	}
-	if (locks.direction) player.directionFixed = true;
-	setTimeout(() => {
-		if (runtimePlayer.__actionBattleAttackLockId !== lockId) return;
-		runtimePlayer.__actionBattleAttackLockedUntil = 0;
-		player.canMove = previousCanMove;
-		player.directionFixed = previousDirectionFixed;
-		player.animationFixed = previousAnimationFixed;
-	}, durationMs);
-	return true;
-};
-var isBattleEvent = (event) => !!event.battleAi;
-var rectsOverlap = (a, b) => a.x < b.x + b.width && a.x + a.width > b.x && a.y < b.y + b.height && a.y + a.height > b.y;
-var eventRect = (event) => {
-	const hitbox = typeof event.hitbox === "function" ? event.hitbox() : event.hitbox;
-	return {
-		x: event.x(),
-		y: event.y(),
-		width: hitbox?.w ?? 32,
-		height: hitbox?.h ?? 32
-	};
-};
-var getVisibleActionEvents = (player, map, hitboxes) => {
-	if (!map) return [];
-	const eventsById = /* @__PURE__ */ new Map();
-	const addEvent = (event) => {
-		if (!event) return;
-		if (!(typeof map.isEventVisibleForPlayer === "function" ? map.isEventVisibleForPlayer(event, player) : true)) return;
-		eventsById.set(event.id, event);
-	};
-	const collisions = map.getCollisions?.(player.id);
-	if (Array.isArray(collisions)) collisions.forEach((id) => addEvent(map.getEvent(id)));
-	const direction = typeof player.getDirection === "function" ? player.getDirection() : void 0;
-	const interactionCollisions = map.getInteractionCollisions?.(player.id, direction);
-	if (Array.isArray(interactionCollisions)) interactionCollisions.forEach((id) => addEvent(map.getEvent(id)));
-	for (const event of map.getEvents()) {
-		const rect = eventRect(event);
-		if (hitboxes.some((hitbox) => rectsOverlap(hitbox, rect))) addEvent(event);
-	}
-	return Array.from(eventsById.values());
-};
-var isActionReservedForNormalEvent = (player, map, hitboxes) => {
-	const events = getVisibleActionEvents(player, map, hitboxes);
-	return events.length > 0 && !events.some(isBattleEvent);
-};
-/**
-* Get knockback force from player's equipped weapon
-* 
-* Retrieves the knockbackForce property from the player's equipped weapon.
-* Falls back to DEFAULT_KNOCKBACK.force if no weapon or property is set.
-* 
-* @param player - The player to get weapon knockback from
-* @returns Knockback force value
-* 
-* @example
-* ```ts
-* // Player with weapon having knockbackForce: 80
-* const force = getPlayerWeaponKnockbackForce(player); // 80
-* 
-* // No weapon equipped
-* const force = getPlayerWeaponKnockbackForce(player); // 50 (default)
-* ```
-*/
-function getPlayerWeaponKnockbackForce(player) {
-	try {
-		const equipments = player.equipments?.() || [];
-		for (const item of equipments) {
-			const itemData = player.databaseById?.(item.id());
-			if (itemData?._type === "weapon" && itemData.knockbackForce !== void 0) return itemData.knockbackForce;
-		}
-	} catch {}
-	return DEFAULT_KNOCKBACK.force;
-}
-/**
-* Apply hit from player to target (event with AI)
-* 
-* Handles damage calculation, knockback based on weapon, and visual effects.
-* Can be customized using hooks.
-* 
-* @param player - The attacking player
-* @param target - The event being hit
-* @param hooks - Optional hooks for customizing hit behavior
-* @returns Hit result if AI exists, undefined otherwise
-* 
-* @example
-* ```ts
-* // Basic hit
-* const result = applyPlayerHitToEvent(player, event);
-* 
-* // With custom hooks
-* const result = applyPlayerHitToEvent(player, event, {
-*   onBeforeHit(result) {
-*     result.knockbackForce *= 2; // Double knockback
-*     return result;
-*   },
-*   onAfterHit(result) {
-*     if (result.defeated) {
-*       player.gold += 10;
-*     }
-*   }
-* });
-* ```
-*/
-function applyPlayerHitToEvent(player, target, hooks, metadata) {
-	const ai = target.battleAi;
-	if (!ai) return void 0;
-	const systems = getActionBattleSystems();
-	const result = applyActionBattleHit({
-		...systems.combat,
-		hooks: hooks ? {
-			...systems.combat.hooks,
-			beforeHit(context) {
-				const before = systems.combat.hooks?.beforeHit?.(context);
-				if (before === false) return false;
-				const nextContext = before || context;
-				const legacyResult = toLegacyHitResult(nextContext);
-				const modified = hooks.onBeforeHit?.(legacyResult);
-				if (!modified) return nextContext;
-				return {
-					...nextContext,
-					damage: {
-						damage: modified.damage,
-						defeated: modified.defeated,
-						raw: nextContext.damage?.raw
-					},
-					knockback: {
-						force: modified.knockbackForce,
-						duration: modified.knockbackDuration,
-						direction: nextContext.knockback?.direction
-					}
-				};
-			},
-			afterHit(result) {
-				systems.combat.hooks?.afterHit?.(result);
-				hooks.onAfterHit?.(result);
-			}
-		} : systems.combat.hooks
-	}, {
-		attacker: player,
-		target,
-		metadata,
-		reaction: metadata?.reaction
-	});
-	if (!result.cancelled) ai.handleDamage(player, {
-		damage: result.damage,
-		defeated: result.defeated,
-		raw: result.rawDamage,
-		reaction: result.reaction
-	});
+import { isActionBattleEntityInvincible, setActionBattleInvincibility } from "./index2.js";
+//#region src/core/hit.ts
+var applyActionBattleHit = (system, context) => {
+	let hitContext = { ...context };
+	const before = system.hooks?.beforeHit?.(hitContext);
+	if (before === false) return {
+		damage: 0,
+		knockbackForce: 0,
+		knockbackDuration: 0,
+		defeated: false,
+		attacker: hitContext.attacker,
+		target: hitContext.target,
+		cancelled: true,
+		metadata: hitContext.metadata
+	};
+	if (before) hitContext = before;
+	if (isActionBattleEntityInvincible(hitContext.target)) return {
+		damage: 0,
+		knockbackForce: 0,
+		knockbackDuration: 0,
+		defeated: false,
+		attacker: hitContext.attacker,
+		target: hitContext.target,
+		cancelled: true,
+		metadata: hitContext.metadata,
+		reaction: hitContext.reaction
+	};
+	const damage = hitContext.damage ?? system.resolveDamage({
+		attacker: hitContext.attacker,
+		target: hitContext.target,
+		skill: hitContext.skill,
+		pattern: hitContext.pattern
+	});
+	hitContext.damage = damage;
+	const afterDamage = system.hooks?.afterDamage?.(hitContext);
+	if (afterDamage) hitContext = afterDamage;
+	const knockback = hitContext.knockback ?? system.resolveKnockback({
+		attacker: hitContext.attacker,
+		target: hitContext.target,
+		damage
+	});
+	hitContext.knockback = knockback;
+	if (!damage.defeated && knockback.force > 0 && knockback.direction) hitContext.target.knockback?.(knockback.direction, knockback.force, knockback.duration);
+	if (!damage.defeated && hitContext.reaction?.invincibilityMs) setActionBattleInvincibility(hitContext.target, hitContext.reaction.invincibilityMs);
+	const result = {
+		damage: damage.damage,
+		knockbackForce: knockback.force,
+		knockbackDuration: knockback.duration,
+		defeated: damage.defeated,
+		attacker: hitContext.attacker,
+		target: hitContext.target,
+		rawDamage: damage.raw,
+		reaction: hitContext.reaction,
+		metadata: hitContext.metadata
+	};
+	system.hooks?.afterHit?.(result);
 	return result;
-}
-var toLegacyHitResult = (context) => ({
-	damage: context.damage?.damage ?? 0,
-	knockbackForce: context.knockback?.force ?? getPlayerWeaponKnockbackForce(context.attacker),
-	knockbackDuration: context.knockback?.duration ?? DEFAULT_KNOCKBACK.duration,
-	defeated: context.damage?.defeated ?? false,
-	attacker: context.attacker,
-	target: context.target
-});
-var resolvePlayerAttackHitboxes = (player, directionKey, options, profile) => {
-	const configuredHitboxes = {
-		...DEFAULT_PLAYER_ATTACK_HITBOXES,
-		...options.attack?.hitboxes,
-		...profile.hitboxes
-	};
-	const hitboxConfig = configuredHitboxes[directionKey] || configuredHitboxes.default;
-	const defaultHitboxes = [{
-		x: player.x() + hitboxConfig.offsetX,
-		y: player.y() + hitboxConfig.offsetY,
-		width: hitboxConfig.width,
-		height: hitboxConfig.height
-	}];
-	return options.attack?.resolveHitboxes?.({
-		player,
-		direction: directionKey,
-		defaultHitboxes
-	}) ?? defaultHitboxes;
-};
-var mergeAttackProfileOverrides = (base, override) => ({
-	...base,
-	...override,
-	reaction: {
-		...base.reaction,
-		...override.reaction
-	},
-	hitboxes: {
-		...base.hitboxes,
-		...override.hitboxes
-	}
-});
-var resolvePlayerAttackProfile = (player, options) => {
-	const baseProfile = getNormalizedActionBattleAttackProfile(options);
-	const weaponProfile = resolveActionBattleWeaponAttackProfile(player);
-	if (!weaponProfile) return baseProfile;
-	return normalizeActionBattleAttackProfile(mergeAttackProfileOverrides(baseProfile, weaponProfile), {
-		lockMovement: options.attack?.lockMovement,
-		lockDurationMs: options.attack?.lockDurationMs,
-		hitboxes: options.attack?.hitboxes
-	});
-};
-var resolveSignal = (value) => typeof value === "function" ? value() : value;
-var resolveItemData = (player, itemId) => {
-	try {
-		return player.databaseById?.(itemId);
-	} catch {
-		return null;
-	}
-};
-var resolveSkillData = (player, skillId) => {
-	try {
-		return player.databaseById?.(skillId);
-	} catch {
-		return null;
-	}
-};
-var resolveSkillTargeting = (player, skillId, options) => {
-	const skillsOptions = options.skills;
-	const skillData = resolveSkillData(player, skillId);
-	if (skillsOptions?.getTargeting) return skillsOptions.getTargeting(skillData);
-	const range = skillData?.range ?? skillData?.targeting?.range ?? skillData?.targeting?.distance;
-	const aoeMask = skillData?.aoeMask ?? skillData?.targeting?.aoeMask ?? skillData?.targeting?.mask;
-	if (range === void 0 && aoeMask === void 0) return null;
-	return {
-		range: range ?? 0,
-		aoeMask
-	};
-};
-var normalizeMaskRows = (mask) => {
-	if (!mask) return [];
-	if (Array.isArray(mask)) return mask;
-	return mask.trim().split("\n").map((row) => row.replace(/\r/g, ""));
-};
-var buildActionBarData = (player, options) => {
-	return {
-		items: (player.items?.() || []).map((item) => {
-			const id = item.id?.() ?? item.id;
-			const data = resolveItemData(player, id);
-			const name = resolveSignal(data?.name) ?? resolveSignal(item.name) ?? id;
-			const description = resolveSignal(data?.description) ?? resolveSignal(item.description) ?? "";
-			const icon = resolveSignal(data?.icon) ?? resolveSignal(item.icon);
-			const quantity = resolveSignal(item.quantity) ?? 1;
-			const consumable = resolveSignal(data?.consumable);
-			const itemType = resolveSignal(data?._type);
-			return {
-				id,
-				name,
-				description,
-				icon,
-				quantity,
-				usable: quantity > 0 && consumable !== false && (itemType ? itemType === "item" : true)
-			};
-		}),
-		skills: (player.skills?.() || []).map((skill) => {
-			const id = skill.id?.() ?? skill.id;
-			const data = resolveSkillData(player, id) || skill;
-			const name = resolveSignal(data?.name) ?? resolveSignal(skill.name) ?? id;
-			const description = resolveSignal(data?.description) ?? resolveSignal(skill.description) ?? "";
-			const icon = resolveSignal(data?.icon) ?? resolveSignal(skill.icon);
-			const spCost = resolveSignal(data?.spCost) ?? resolveSignal(skill.spCost) ?? 0;
-			const usable = spCost <= player.sp;
-			const targeting = resolveSkillTargeting(player, id, options);
-			const skillEntry = {
-				id,
-				name,
-				description,
-				icon,
-				spCost,
-				usable,
-				range: targeting?.range ?? 0
-			};
-			if (targeting) {
-				const mask = targeting.aoeMask ?? options.skills?.defaultAoeMask;
-				if (mask) skillEntry.aoeMask = normalizeMaskRows(mask);
-			}
-			return skillEntry;
-		})
-	};
-};
-var ensureActionBarGui = (player, options) => {
-	const gui = player.getGui?.("action-battle-action-bar") || player.gui("action-battle-action-bar");
-	if (!gui.__actionBattleReady) {
-		gui.__actionBattleReady = true;
-		gui.on("useItem", ({ id }) => {
-			try {
-				player.useItem(id);
-			} catch {}
-			gui.update(buildActionBarData(player, options));
-		});
-		gui.on("useSkill", ({ id, target }) => {
-			handleActionBattleSkillUse(player, id, target, options);
-			gui.update(buildActionBarData(player, options));
-		});
-		gui.on("refresh", () => {
-			gui.update(buildActionBarData(player, options));
-		});
-	}
-	return gui;
-};
-var openActionBattleActionBar = (player, rawOptions = {}) => {
-	const options = normalizeActionBattleOptions(rawOptions);
-	ensureActionBarGui(player, options).open(buildActionBarData(player, options));
-};
-var updateActionBattleActionBar = (player, rawOptions = {}) => {
-	const options = normalizeActionBattleOptions(rawOptions);
-	const gui = player.getGui?.(ACTION_BATTLE_ACTION_BAR_GUI_ID);
-	if (gui) gui.update(buildActionBarData(player, options));
-};
-var getTileSize = (map) => ({
-	width: map?.tileWidth ?? 32,
-	height: map?.tileHeight ?? 32
-});
-var getEntityTile = (entity, tileSize) => {
-	const hitbox = entity.hitbox?.() || {
-		w: tileSize.width,
-		h: tileSize.height
-	};
-	return {
-		x: Math.floor((entity.x() + hitbox.w / 2) / tileSize.width),
-		y: Math.floor((entity.y() + hitbox.h / 2) / tileSize.height)
-	};
-};
-var handleActionBattleSkillUse = (player, skillId, target, options) => {
-	const skillData = resolveSkillData(player, skillId);
-	const map = player.getCurrentMap();
-	if (!map) {
-		playActionBattleAnimation("castSkill", player, options.animations, { skill: skillData });
-		player.useSkill(skillId);
-		return;
-	}
-	const targeting = resolveSkillTargeting(player, skillId, options);
-	if (!targeting || !target) {
-		playActionBattleAnimation("castSkill", player, options.animations, { skill: skillData });
-		player.useSkill(skillId);
-		return;
-	}
-	const tileSize = getTileSize(map);
-	const origin = getEntityTile(player, tileSize);
-	const targetTile = {
-		x: target.x,
-		y: target.y
-	};
-	if (manhattanDistance(origin, targetTile) > targeting.range) return;
-	const mask = parseAoeMask(targeting.aoeMask || options.skills?.defaultAoeMask);
-	const affected = /* @__PURE__ */ new Set();
-	mask.cells.forEach((cell) => {
-		const x = targetTile.x + cell.dx;
-		const y = targetTile.y + cell.dy;
-		affected.add(`${x},${y}`);
-	});
-	const targets = [];
-	const affects = options.targeting?.affects || "events";
-	if (affects === "events" || affects === "both") map.getEvents().forEach((event) => {
-		const tile = getEntityTile(event, tileSize);
-		if (affected.has(`${tile.x},${tile.y}`)) targets.push(event);
-	});
-	if (affects === "players" || affects === "both") map.getPlayers().forEach((other) => {
-		if (other.id === player.id) return;
-		const tile = getEntityTile(other, tileSize);
-		if (affected.has(`${tile.x},${tile.y}`)) targets.push(other);
-	});
-	if (!options.targeting?.allowEmptyTarget && targets.length === 0) return;
-	playActionBattleAnimation("castSkill", player, options.animations, {
-		skill: skillData,
-		target: targets[0]
-	});
-	player.useSkill(skillId, targets);
-};
-var createActionBattleServer = (rawOptions = {}) => {
-	const options = normalizeActionBattleOptions(rawOptions);
-	setActionBattleOptions(options);
-	setActionBattleSystems(options);
-	return defineModule({
-		player: {
-			/**
-			* Handle player input for combat actions
-			*
-			* When a player presses the action key, create an attack hitbox
-			* that can damage AI enemies within range and knockback the event.
-			* Knockback force is based on the player's equipped weapon.
-			* Triggers attack animation and visual effects.
-			*
-			* @param player - The player performing the action
-			* @param input - Input data containing pressed keys
-			*/
-			onInput(player, input) {
-				if (input.action == Control.Action) {
-					const map = player.getCurrentMap();
-					const direction = player.getDirection();
-					const attackProfile = resolvePlayerAttackProfile(player, options);
-					const hitboxes = resolvePlayerAttackHitboxes(player, direction, options, attackProfile);
-					if (isActionReservedForNormalEvent(player, map, hitboxes)) return;
-					const lockMovement = attackProfile.movementLock;
-					const lockDirection = attackProfile.directionLock;
-					const lockDurationMs = attackProfile.totalDurationMs ?? DEFAULT_ATTACK_LOCK_DURATION_MS;
-					const actionLocked = (lockMovement || lockDirection) && lockDurationMs > 0;
-					if (actionLocked && !beginPlayerAttackLock(player, map, Math.max(0, lockDurationMs), {
-						movement: lockMovement,
-						direction: lockDirection
-					})) return;
-					playActionBattleAnimation("attack", player, options.animations);
-					if (actionLocked) player.animationFixed = true;
-					const attackId = createActionBattleAttackId(player.id, attackProfile.id);
-					const hitTracker = new ActionBattleHitTracker(attackProfile.hitPolicy);
-					if (options.debug?.attacks) console.log("[ActionBattle] player attack", {
-						attackId,
-						playerId: player.id,
-						profile: attackProfile.id,
-						hitboxes
-					});
-					scheduleActionBattleStartup(attackProfile, () => {
-						map?.createMovingHitbox(hitboxes, { speed: resolveActionBattleHitboxSpeed(attackProfile, hitboxes.length) }).subscribe({ next(hits) {
-							hits.forEach((hit) => {
-								if (hit instanceof RpgEvent) {
-									if (!hitTracker.tryHit(hit)) return;
-									if (applyPlayerHitToEvent(player, hit, void 0, {
-										attackId,
-										attackProfileId: attackProfile.id,
-										reaction: attackProfile.reaction
-									})?.defeated) console.log(`Player ${player.id} defeated AI ${hit.id}`);
-								}
-							});
-						} });
-					});
-				}
-			},
-			onConnected(player) {
-				if (options.ui?.actionBar?.enabled && options.ui?.actionBar?.autoOpen) openActionBattleActionBar(player, options);
-			}
-		},
-		event: {
-			/**
-			* Handle player detection when entering AI vision
-			*
-			* Called when a player enters an AI event's vision range.
-			* The AI will start pursuing and attacking the player.
-			*
-			* @param event - The AI event
-			* @param player - The player entering vision
-			* @param shape - The vision shape
-			*/
-			onDetectInShape(event, player, shape) {
-				event.battleAi?.onDetectInShape(player, shape);
-			},
-			/**
-			* Handle player leaving AI vision
-			*
-			* Called when a player leaves an AI event's vision range.
-			* The AI will stop pursuing the player.
-			*
-			* @param event - The AI event
-			* @param player - The player leaving vision
-			* @param shape - The vision shape
-			*/
-			onDetectOutShape(event, player, shape) {
-				event.battleAi?.onDetectOutShape(player, shape);
-			}
-		}
-	});
 };
-createActionBattleServer();
 //#endregion
-export { ACTION_BATTLE_ACTION_BAR_GUI_ID, DEFAULT_PLAYER_ATTACK_HITBOXES, applyPlayerHitToEvent, createActionBattleServer, getPlayerWeaponKnockbackForce, openActionBattleActionBar, updateActionBattleActionBar };
+export { applyActionBattleHit };

package/dist/client/index21.js

@@ -0,0 +1,69 @@
+//#region src/core/targets.ts
+var RpgEvent = null;
+var RpgPlayer = null;
+var ACTION_BATTLE_PLAYER_FACTION = "players";
+var ACTION_BATTLE_ENEMY_FACTION = "enemies";
+var getBattleAi = (entity) => entity?.battleAi;
+var getActionBattleEntityKind = (entity) => {
+	if (getBattleAi(entity)) return "event";
+	if (entity instanceof RpgEvent) return "event";
+	if (typeof entity?.attachShape === "function") return "event";
+	if (entity instanceof RpgPlayer) return "player";
+	return "player";
+};
+var isActionBattlePlayer = (entity) => getActionBattleEntityKind(entity) === "player";
+var isActionBattleEvent = (entity) => getActionBattleEntityKind(entity) === "event";
+var isActionBattleCombatEntity = (entity) => {
+	if (!entity) return false;
+	if (isActionBattlePlayer(entity)) return true;
+	return !!getBattleAi(entity);
+};
+var getActionBattleFaction = (entity, options = {}) => {
+	const configured = options.getFaction?.(entity);
+	if (configured !== void 0) return configured;
+	const battleAi = getBattleAi(entity);
+	if (battleAi && typeof battleAi.getFaction === "function") {
+		const faction = battleAi.getFaction();
+		if (faction !== void 0) return faction;
+	}
+	const entityFaction = entity.actionBattleFaction ?? entity.faction;
+	if (entityFaction !== void 0) return String(entityFaction);
+	if (isActionBattlePlayer(entity)) return ACTION_BATTLE_PLAYER_FACTION;
+	if (battleAi) return ACTION_BATTLE_ENEMY_FACTION;
+};
+var getActionBattleTargets = (entity, fallback) => {
+	const battleAi = getBattleAi(entity);
+	if (battleAi && typeof battleAi.getTargets === "function") return battleAi.getTargets();
+	return entity.actionBattleTargets ?? fallback;
+};
+var isActionBattleTargetDefeated = (target) => {
+	if (!target) return true;
+	const hp = target.hp;
+	return typeof hp === "number" && hp <= 0;
+};
+var matchesActionBattleTargetSelector = (selector, context) => {
+	if (!selector) return false;
+	if (typeof selector === "function") return selector(context);
+	if (selector === "all") return true;
+	if (selector === "players") return isActionBattlePlayer(context.target);
+	if (selector === "events") return isActionBattleEvent(context.target);
+	if (selector === "hostile") return !!context.attackerFaction && !!context.targetFaction && context.attackerFaction !== context.targetFaction;
+	if (Array.isArray(selector)) return !!context.targetFaction && selector.includes(context.targetFaction);
+	return false;
+};
+var canActionBattleTarget = (attacker, target, selector, options = {}) => {
+	if (attacker === target) return false;
+	if (!isActionBattleCombatEntity(target)) return false;
+	if (isActionBattleTargetDefeated(target)) return false;
+	const context = {
+		attacker,
+		target,
+		attackerFaction: getActionBattleFaction(attacker, options),
+		targetFaction: getActionBattleFaction(target, options)
+	};
+	const allowed = options.canTarget?.(context);
+	if (allowed !== void 0) return allowed;
+	return matchesActionBattleTargetSelector(selector, context);
+};
+//#endregion
+export { ACTION_BATTLE_ENEMY_FACTION, ACTION_BATTLE_PLAYER_FACTION, canActionBattleTarget, getActionBattleFaction, getActionBattleTargets, isActionBattleCombatEntity, isActionBattleEvent, isActionBattlePlayer, isActionBattleTargetDefeated, matchesActionBattleTargetSelector };