@rpgjs/action-battle 5.0.0-beta.11 → 5.0.0-beta.13

package/dist/server/index2.js

@@ -1,3 +1,12 @@
+var playResolvedAnimation = (entity, animation) => {
+	if (typeof entity.setGraphicAnimation === "function") {
+		if (animation.graphic !== void 0) entity.setGraphicAnimation(animation.animationName, animation.graphic, animation.repeat);
+		else entity.setGraphicAnimation(animation.animationName, animation.repeat);
+		return;
+	}
+	if (typeof entity.setAnimation === "function") if (animation.graphic !== void 0) entity.setAnimation(animation.animationName, animation.graphic, animation.repeat);
+	else entity.setAnimation(animation.animationName, animation.repeat);
+};
 var DEFAULT_ANIMATION_BY_KEY = {
 	attack: "attack",
 	hurt: "hurt",
@@ -48,8 +57,7 @@ function resolveActionBattleAnimation(key, entity, animations, context, defaults
 function playActionBattleAnimation(key, entity, animations, context, defaults = {}) {
 	const animation = resolveActionBattleAnimation(key, entity, animations, context, defaults);
 	if (!animation) return null;
-	if (animation.graphic !== void 0) entity.setGraphicAnimation(animation.animationName, animation.graphic, animation.repeat);
-	else entity.setGraphicAnimation(animation.animationName, animation.repeat);
+	playResolvedAnimation(entity, animation);
 	return animation;
 }
 function getActionBattleAnimationRemovalDelay(animation) {

package/dist/server/index20.js

@@ -0,0 +1,37 @@
+//#region src/targeting.ts
+var normalizeMaskRows = (mask) => {
+	if (!mask) return ["#"];
+	if (Array.isArray(mask)) return mask;
+	return mask.trim().split("\n").map((row) => row.replace(/\r/g, ""));
+};
+var parseAoeMask = (mask) => {
+	const rows = normalizeMaskRows(mask);
+	const height = rows.length;
+	const width = rows.reduce((max, row) => Math.max(max, row.length), 0);
+	const centerX = Math.floor(width / 2);
+	const centerY = Math.floor(height / 2);
+	const cells = [];
+	rows.forEach((row, y) => {
+		for (let x = 0; x < row.length; x++) {
+			const char = row[x];
+			if (char && char !== "." && char !== " ") cells.push({
+				dx: x - centerX,
+				dy: y - centerY
+			});
+		}
+	});
+	if (cells.length === 0) cells.push({
+		dx: 0,
+		dy: 0
+	});
+	return {
+		width,
+		height,
+		centerX,
+		centerY,
+		cells
+	};
+};
+var manhattanDistance = (a, b) => Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
+//#endregion
+export { manhattanDistance, parseAoeMask };

package/dist/server/index21.js

@@ -0,0 +1,588 @@
+import "./index3.js";
+import { normalizeActionBattleAttackProfile } from "./index4.js";
+import { normalizeActionBattleOptions, setActionBattleOptions } from "./index5.js";
+import { emitActionBattleClientVisual } from "./index6.js";
+import { DEFAULT_ZELDA_PLAYER_HITBOXES } from "./index7.js";
+import { getActionBattleSystems, setActionBattleSystems } from "./index8.js";
+import "./index9.js";
+import { ActionBattleHitTracker, createActionBattleAttackId, getNormalizedActionBattleAttackProfile, runActionBattleActiveHitbox } from "./index10.js";
+import { applyActionBattleAttackDirection, resolveActionBattleAttackDirection } from "./index11.js";
+import { applyActionBattleHit } from "./index12.js";
+import { canActionBattleTarget, getActionBattleTargets } from "./index13.js";
+import { canActionBattleUseTarget, executeActionBattleUse, getActionBattleActionConfig, handleActionBattleProjectileDestroy, handleActionBattleProjectileImpact } from "./index14.js";
+import { resolveActionBattleWeapon, resolveActionBattleWeaponAttackProfile } from "./index15.js";
+import { forceActionBattleLocomotionAnimation, withActionBattleAnimationUnlocked } from "./index16.js";
+import { DEFAULT_KNOCKBACK } from "./index19.js";
+import { manhattanDistance, parseAoeMask } from "./index20.js";
+import { RpgEvent } from "@rpgjs/server";
+import { Control, defineModule } from "@rpgjs/common";
+//#region src/server.ts
+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;
+		if (locks.movement && !previousAnimationFixed) forceActionBattleLocomotionAnimation(player, "stand");
+	}, 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 entityRect = (entity) => {
+	const hitbox = typeof entity.hitbox === "function" ? entity.hitbox() : entity.hitbox;
+	return {
+		x: entity.x(),
+		y: entity.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 = entityRect(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) {
+	if (!target.battleAi) return void 0;
+	return applyActionBattleEntityHit(player, target, hooks, metadata);
+}
+function applyActionBattleEntityHit(attacker, target, hooks, metadata) {
+	const ai = target.battleAi;
+	if (target instanceof RpgEvent && !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,
+		target,
+		metadata,
+		reaction: metadata?.reaction
+	});
+	if (!result.cancelled && ai) ai.handleDamage(attacker, {
+		damage: result.damage,
+		defeated: result.defeated,
+		raw: result.rawDamage,
+		reaction: result.reaction
+	});
+	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 getActionBattleHitboxCandidates = (map, hitboxes, options = {}) => {
+	if (!map) return [];
+	if (typeof map.queryHitbox === "function") {
+		const candidates = /* @__PURE__ */ new Map();
+		for (const hitbox of hitboxes) for (const entity of map.queryHitbox(hitbox, options)) if (entity?.id) candidates.set(entity.id, entity);
+		return Array.from(candidates.values());
+	}
+	const candidates = /* @__PURE__ */ new Map();
+	const excluded = new Set(options.excludeIds ?? []);
+	const add = (entity) => {
+		if (!entity?.id) return;
+		if (excluded.has(entity.id)) return;
+		const rect = entityRect(entity);
+		if (hitboxes.some((hitbox) => rectsOverlap(hitbox, rect))) candidates.set(entity.id, entity);
+	};
+	const kinds = new Set(options.kinds ?? ["players", "events"]);
+	if (kinds.has("players")) map.getPlayers?.().forEach(add);
+	if (kinds.has("events")) map.getEvents?.().forEach(add);
+	return Array.from(candidates.values());
+};
+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 resolvePlayerSkillUsable = (player, skillId) => {
+	try {
+		return player.getSkill?.(skillId) ?? resolveSkillData(player, skillId);
+	} catch {
+		return resolveSkillData(player, skillId);
+	}
+};
+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 = resolvePlayerSkillUsable(player, skillId);
+	const actionConfig = getActionBattleActionConfig(skillData);
+	if (actionConfig?.target === "self") {
+		executeActionBattleUse({
+			attacker: player,
+			target: player,
+			usable: skillData,
+			skill: skillData
+		});
+		return;
+	}
+	const map = player.getCurrentMap();
+	if (!map) {
+		emitActionBattleClientVisual({
+			moment: "castSkill",
+			entity: player,
+			skill: skillData
+		});
+		player.useSkill(skillId);
+		return;
+	}
+	const targeting = resolveSkillTargeting(player, skillId, options);
+	if (!targeting || !target) {
+		emitActionBattleClientVisual({
+			moment: "castSkill",
+			entity: player,
+			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 actionTarget = actionConfig?.target ?? "enemy";
+	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}`) && canActionBattleUseTarget(player, event, actionTarget, options.combat?.targets)) 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}`) && canActionBattleUseTarget(player, other, actionTarget, options.combat?.targets)) targets.push(other);
+	});
+	if (!options.targeting?.allowEmptyTarget && targets.length === 0) return;
+	executeActionBattleUse({
+		attacker: player,
+		target: targets,
+		usable: skillData,
+		skill: skillData
+	});
+};
+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 = resolveActionBattleAttackDirection(player, input);
+					applyActionBattleAttackDirection(player, direction);
+					const attackProfile = resolvePlayerAttackProfile(player, options);
+					const directionKey = direction;
+					const resolveActiveHitboxes = () => resolvePlayerAttackHitboxes(player, directionKey, options, attackProfile);
+					if (isActionReservedForNormalEvent(player, map, resolveActiveHitboxes())) 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;
+					withActionBattleAnimationUnlocked(player, () => {
+						emitActionBattleClientVisual({
+							moment: "attack",
+							entity: player
+						});
+					});
+					if (actionLocked) player.animationFixed = true;
+					const attackId = createActionBattleAttackId(player.id, attackProfile.id);
+					const weapon = resolveActionBattleWeapon(player);
+					const hitTracker = new ActionBattleHitTracker(attackProfile.hitPolicy);
+					const targetSelector = getActionBattleTargets(player, "events");
+					const processHits = (hits) => {
+						hits.forEach((hit) => {
+							if (!canActionBattleTarget(player, hit, targetSelector, options.combat?.targets)) return;
+							if (!hitTracker.tryHit(hit)) return;
+							if (weapon && executeActionBattleUse({
+								attacker: player,
+								target: hit,
+								usable: weapon,
+								weapon,
+								profile: attackProfile,
+								playVisual: false
+							})) return;
+							applyActionBattleEntityHit(player, hit, void 0, {
+								attackId,
+								attackProfileId: attackProfile.id,
+								reaction: attackProfile.reaction
+							});
+						});
+					};
+					runActionBattleActiveHitbox(attackProfile, resolveActiveHitboxes, (activeHitboxes) => {
+						processHits(getActionBattleHitboxCandidates(map, activeHitboxes, {
+							excludeIds: [player.id],
+							kinds: ["players", "events"]
+						}));
+					});
+				}
+			},
+			onConnected(player) {
+				const actionBar = options.ui?.actionBar;
+				if (actionBar?.enabled && 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);
+			}
+		},
+		projectiles: {
+			onImpact(context) {
+				handleActionBattleProjectileImpact({
+					attacker: context.projectile?.payload?.attackerId ? context.map?.getObjectById?.(context.projectile.payload.attackerId) : void 0,
+					target: context.target,
+					projectile: context.projectile,
+					hit: context.hit,
+					map: context.map
+				});
+			},
+			onDestroy(context) {
+				handleActionBattleProjectileDestroy(context.projectile?.id);
+			}
+		}
+	});
+};
+var server_default = createActionBattleServer();
+//#endregion
+export { ACTION_BATTLE_ACTION_BAR_GUI_ID, DEFAULT_PLAYER_ATTACK_HITBOXES, applyActionBattleEntityHit, applyPlayerHitToEvent, createActionBattleServer, server_default as default, getPlayerWeaponKnockbackForce, openActionBattleActionBar, updateActionBattleActionBar };