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

package/dist/server/index14.js

@@ -1,503 +1,225 @@
-import { playActionBattleAnimation } from "./index2.js";
-import "./index3.js";
-import { normalizeActionBattleAttackProfile } from "./index4.js";
-import { normalizeActionBattleOptions, setActionBattleOptions } from "./index5.js";
-import { DEFAULT_ZELDA_PLAYER_HITBOXES } from "./index6.js";
-import { getActionBattleSystems, setActionBattleSystems } from "./index7.js";
-import "./index8.js";
-import { ActionBattleHitTracker, createActionBattleAttackId, getNormalizedActionBattleAttackProfile, resolveActionBattleHitboxSpeed, scheduleActionBattleStartup } from "./index9.js";
-import { DEFAULT_KNOCKBACK } from "./index10.js";
-import { manhattanDistance, parseAoeMask } from "./index11.js";
+import { getActionBattleOptions } from "./index5.js";
+import { emitActionBattleClientVisual } from "./index6.js";
+import { getActionBattleSystems } from "./index8.js";
 import { applyActionBattleHit } from "./index12.js";
-import { resolveActionBattleWeaponAttackProfile } from "./index13.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;
-	}, 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;
+import { canActionBattleTarget, getActionBattleFaction, getActionBattleTargets, isActionBattleCombatEntity, isActionBattleTargetDefeated } from "./index13.js";
+import { MAXHP } from "@rpgjs/server";
+//#region src/core/action-use.ts
+var projectileHandlers = /* @__PURE__ */ new Map();
+var normalizeDirection = (direction) => {
+	const distance = Math.sqrt(direction.x * direction.x + direction.y * direction.y);
+	if (distance <= 0) return {
+		x: 0,
+		y: 1
+	};
 	return {
-		x: event.x(),
-		y: event.y(),
-		width: hitbox?.w ?? 32,
-		height: hitbox?.h ?? 32
+		x: direction.x / distance,
+		y: direction.y / distance
 	};
 };
-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 directionToTarget = (attacker, target) => {
+	const first = firstTarget(target);
+	if (!first) return void 0;
+	return normalizeDirection({
+		x: first.x() - attacker.x(),
+		y: first.y() - attacker.y()
+	});
 };
-var isActionReservedForNormalEvent = (player, map, hitboxes) => {
-	const events = getVisibleActionEvents(player, map, hitboxes);
-	return events.length > 0 && !events.some(isBattleEvent);
+var asArray = (value) => {
+	if (!value) return [];
+	return Array.isArray(value) ? value : [value];
+};
+var firstTarget = (target) => asArray(target)[0];
+var resolveActionConfig = (usable) => usable?.action ?? usable?.actionBattle ?? usable?._skillInstance?.action ?? usable?._skillInstance?.actionBattle ?? usable?._skillData?.action ?? usable?._skillData?.actionBattle;
+var getUseHookTarget = (usable) => usable?._skillInstance ?? usable?._skillData ?? usable;
+var getUseHook = (usable) => {
+	const target = getUseHookTarget(usable);
+	return typeof target?.onUse === "function" ? {
+		hook: target.onUse,
+		target
+	} : void 0;
+};
+var isSkill = (usable, explicitSkill) => !!explicitSkill || usable?._type === "skill" || usable?.spCost !== void 0;
+var consumeSkillUse = (attacker, skill) => {
+	const spCost = typeof skill?.spCost === "number" ? skill.spCost : 0;
+	if (spCost > 0) {
+		if (spCost > (attacker.sp ?? 0)) throw new Error(`Not enough SP to use ${skill?.id ?? skill?.name ?? "skill"}`);
+		const halfCost = attacker.hasEffect?.("HALF_SP_COST") || attacker.hasEffect?.("half_sp_cost");
+		attacker.sp -= spCost / (halfCost ? 2 : 1);
+	}
+	const hitRate = typeof skill?.hitRate === "number" ? skill.hitRate : 1;
+	if (Math.random() > hitRate) throw new Error(`Action battle skill failed: ${skill?.id ?? skill?.name ?? "skill"}`);
 };
-/**
-* 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;
+var applyDamageEffect = (attacker, target, skill, reaction, metadata) => {
 	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,
+	attacker.applyStates?.(target, skill);
+	const result = applyActionBattleHit(systems.combat, {
+		attacker,
 		target,
-		metadata,
-		reaction: metadata?.reaction
-	});
-	if (!result.cancelled) ai.handleDamage(player, {
-		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 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
+		skill,
+		reaction,
+		metadata
 	});
-};
-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));
+	if (!result.cancelled) {
+		emitActionBattleClientVisual({
+			moment: "hit",
+			entity: attacker,
+			target,
+			damage: result.damage,
+			result,
+			skill
 		});
-		gui.on("refresh", () => {
-			gui.update(buildActionBarData(player, options));
+		target.battleAi?.handleDamage?.(attacker, {
+			damage: result.damage,
+			defeated: result.defeated,
+			raw: result.rawDamage,
+			reaction: result.reaction
 		});
 	}
-	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)
-	};
+	return result;
 };
-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);
+var buildActionContext = (input) => {
+	const action = {};
+	Object.assign(action, {
+		attacker: input.attacker,
+		user: input.attacker,
+		target: input.target,
+		usable: input.usable,
+		skill: input.skill,
+		weapon: input.weapon,
+		action: input.action,
+		pattern: input.pattern,
+		defaultEffect(target = input.target) {
+			return asArray(target).map((entry) => applyDamageEffect(input.attacker, entry, input.skill, input.profile?.reaction, {
+				actionId: input.usable?.id,
+				actionType: input.usable?._type,
+				pattern: input.pattern
+			}));
+		},
+		damage(target = input.target) {
+			const entry = firstTarget(target);
+			if (!entry) return void 0;
+			return applyDamageEffect(input.attacker, entry, input.skill, input.profile?.reaction, {
+				actionId: input.usable?.id,
+				actionType: input.usable?._type,
+				pattern: input.pattern
+			});
+		},
+		heal(target, amount) {
+			if (!target || !Number.isFinite(amount) || amount <= 0) return 0;
+			return asArray(target).reduce((total, entry) => {
+				const currentHp = Number(entry.hp ?? 0);
+				const maxHp = (typeof entry.param === "function" ? entry.param() : entry.param)?.[MAXHP] ?? Number.POSITIVE_INFINITY;
+				const nextHp = Math.min(maxHp, currentHp + amount);
+				entry.hp = nextHp;
+				emitActionBattleClientVisual({
+					moment: "hurt",
+					entity: entry,
+					target: entry,
+					damage: Math.max(0, nextHp - currentHp),
+					skill: input.skill
+				});
+				return total + nextHp - currentHp;
+			}, 0);
+		},
+		projectile(options = { type: "action" }) {
+			const map = input.attacker.getCurrentMap?.();
+			if (!map?.projectiles?.emit) return [];
+			const projectile = {
+				...input.action?.projectile ?? {},
+				...options
+			};
+			const range = projectile.range ?? input.action?.range ?? 160;
+			const speed = projectile.speed ?? 180;
+			const emitted = map.projectiles.emit({
+				type: projectile.type,
+				origin: projectile.origin,
+				direction: projectile.direction ?? directionToTarget(input.attacker, input.target),
+				spreadDegrees: projectile.spreadDegrees,
+				accuracy: projectile.accuracy,
+				trajectory: projectile.trajectory ?? {
+					type: "linear",
+					speed,
+					range
+				},
+				collision: projectile.collision,
+				repeat: projectile.repeat,
+				pattern: projectile.pattern,
+				payload: {
+					...projectile.payload,
+					actionBattle: true,
+					attackerId: input.attacker.id,
+					actionId: input.usable?.id
+				},
+				params: projectile.params,
+				canHit: ({ target }) => {
+					if (!target) return false;
+					return canActionBattleUseTarget(input.attacker, target, input.action?.target ?? "enemy", getActionBattleOptions().combat?.targets);
+				}
+			}, input.attacker);
+			for (const state of emitted) projectileHandlers.set(state.id, {
+				action,
+				onImpact: projectile.onImpact
+			});
+			return emitted;
+		}
 	});
-	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);
+	return action;
+};
+var getActionBattleActionConfig = (usable) => resolveActionConfig(usable);
+var getActionBattleActionRange = (usable) => resolveActionConfig(usable)?.range;
+var canActionBattleUseTarget = (attacker, target, actionTarget = "enemy", options = {}) => {
+	if (isActionBattleTargetDefeated(target)) return false;
+	if (actionTarget === "self") return attacker === target;
+	if (actionTarget === "any") return attacker === target || isActionBattleCombatEntity(target);
+	if (attacker === target || !isActionBattleCombatEntity(target)) return false;
+	if (actionTarget === "ally") {
+		const attackerFaction = getActionBattleFaction(attacker, options);
+		const targetFaction = getActionBattleFaction(target, options);
+		return !!attackerFaction && attackerFaction === targetFaction;
+	}
+	return canActionBattleTarget(attacker, target, getActionBattleTargets(attacker, "hostile"), options);
+};
+var shouldUseActionBattleUsable = (usable, explicitSkill) => {
+	if (!usable) return false;
+	return isSkill(usable, explicitSkill) || !!getUseHook(usable) || !!resolveActionConfig(usable);
+};
+var executeActionBattleUse = (input) => {
+	if (!shouldUseActionBattleUsable(input.usable, input.skill)) return false;
+	const actionConfig = resolveActionConfig(input.usable);
+	if (isSkill(input.usable, input.skill)) consumeSkillUse(input.attacker, input.skill ?? input.usable);
+	const action = buildActionContext({
+		...input,
+		action: actionConfig
 	});
-	if (!options.targeting?.allowEmptyTarget && targets.length === 0) return;
-	playActionBattleAnimation("castSkill", player, options.animations, {
-		skill: skillData,
-		target: targets[0]
+	const hook = getUseHook(input.usable);
+	if (input.playVisual !== false) emitActionBattleClientVisual({
+		moment: input.skill ? "castSkill" : "attack",
+		entity: input.attacker,
+		skill: input.skill,
+		target: firstTarget(input.target)
 	});
-	player.useSkill(skillId, targets);
+	if (hook) {
+		hook.hook.call(hook.target, input.attacker, input.target, action);
+		return true;
+	}
+	if (actionConfig?.mode === "projectile") {
+		action.projectile(actionConfig.projectile);
+		return true;
+	}
+	action.defaultEffect(input.target);
+	return true;
 };
-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);
-			}
-		}
-	});
+var handleActionBattleProjectileImpact = (context) => {
+	const handler = projectileHandlers.get(context.projectile.id);
+	if (!handler) return;
+	const target = context.target;
+	handler.action.target = target ?? handler.action.target;
+	if (handler.onImpact) handler.onImpact(context, handler.action);
+	else handler.action.defaultEffect(target ?? void 0);
+};
+var handleActionBattleProjectileDestroy = (projectileId) => {
+	projectileHandlers.delete(projectileId);
 };
-var server_default = createActionBattleServer();
 //#endregion
-export { ACTION_BATTLE_ACTION_BAR_GUI_ID, DEFAULT_PLAYER_ATTACK_HITBOXES, applyPlayerHitToEvent, createActionBattleServer, server_default as default, getPlayerWeaponKnockbackForce, openActionBattleActionBar, updateActionBattleActionBar };
+export { canActionBattleUseTarget, executeActionBattleUse, getActionBattleActionConfig, getActionBattleActionRange, handleActionBattleProjectileDestroy, handleActionBattleProjectileImpact, shouldUseActionBattleUsable };