@rpgjs/action-battle 5.0.0-beta.4 → 5.0.0-beta.6

package/dist/server/index7.js

@@ -1,37 +1,25 @@
-//#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
-			});
+import { defaultActionBattleSystems } from "./index6.js";
+//#region src/core/context.ts
+var mergeSystems = (options = {}) => ({
+	combat: {
+		...defaultActionBattleSystems.combat,
+		resolveDamage: options.systems?.combat?.damage ?? defaultActionBattleSystems.combat.resolveDamage,
+		resolveKnockback: options.systems?.combat?.knockback ?? defaultActionBattleSystems.combat.resolveKnockback,
+		hooks: {
+			...defaultActionBattleSystems.combat.hooks,
+			...options.systems?.combat?.hooks
 		}
-	});
-	if (cells.length === 0) cells.push({
-		dx: 0,
-		dy: 0
-	});
-	return {
-		width,
-		height,
-		centerX,
-		centerY,
-		cells
-	};
+	},
+	ai: { behaviors: {
+		...defaultActionBattleSystems.ai.behaviors,
+		...options.systems?.ai?.behaviors
+	} }
+});
+var currentActionBattleSystems = mergeSystems();
+var setActionBattleSystems = (options = {}) => {
+	currentActionBattleSystems = mergeSystems(options);
 };
-var manhattanDistance = (a, b) => Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
+var getActionBattleSystems = () => currentActionBattleSystems;
+var createActionBattleSystems = mergeSystems;
 //#endregion
-export { manhattanDistance, parseAoeMask };
+export { createActionBattleSystems, getActionBattleSystems, setActionBattleSystems };

package/dist/server/index8.js

@@ -1,46 +1,72 @@
-//#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;
-	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);
-	const result = {
-		damage: damage.damage,
-		knockbackForce: knockback.force,
-		knockbackDuration: knockback.duration,
-		defeated: damage.defeated,
-		attacker: hitContext.attacker,
-		target: hitContext.target,
-		rawDamage: damage.raw,
-		metadata: hitContext.metadata
-	};
-	system.hooks?.afterHit?.(result);
-	return result;
+import { normalizeActionBattleAttackProfile } from "./index4.js";
+//#region src/core/enemy-attack-profiles.ts
+var DEFAULT_ACTION_BATTLE_ENEMY_ATTACK_PROFILES = {
+	melee: {
+		id: "enemy-melee",
+		startupMs: 120,
+		activeMs: 100,
+		recoveryMs: 220,
+		cooldownMs: 440,
+		reaction: {
+			invincibilityMs: 250,
+			hitstunMs: 120,
+			staggerPower: 1
+		}
+	},
+	combo: {
+		id: "enemy-combo",
+		startupMs: 80,
+		activeMs: 80,
+		recoveryMs: 140,
+		cooldownMs: 300,
+		reaction: {
+			invincibilityMs: 180,
+			hitstunMs: 90,
+			staggerPower: .75
+		}
+	},
+	charged: {
+		id: "enemy-charged",
+		startupMs: 800,
+		activeMs: 140,
+		recoveryMs: 320,
+		cooldownMs: 1260,
+		reaction: {
+			invincibilityMs: 350,
+			hitstunMs: 220,
+			staggerPower: 2
+		}
+	},
+	zone: {
+		id: "enemy-zone",
+		startupMs: 450,
+		activeMs: 180,
+		recoveryMs: 320,
+		cooldownMs: 950,
+		reaction: {
+			invincibilityMs: 300,
+			hitstunMs: 160,
+			staggerPower: 1.25
+		}
+	},
+	dashAttack: {
+		id: "enemy-dash",
+		startupMs: 180,
+		activeMs: 120,
+		recoveryMs: 260,
+		cooldownMs: 560,
+		reaction: {
+			invincibilityMs: 280,
+			hitstunMs: 150,
+			staggerPower: 1.2
+		}
+	}
 };
+function normalizeActionBattleEnemyAttackProfiles(overrides = {}) {
+	return Object.fromEntries(Object.entries(DEFAULT_ACTION_BATTLE_ENEMY_ATTACK_PROFILES).map(([key, defaultProfile]) => [key, normalizeActionBattleAttackProfile({
+		...defaultProfile,
+		...overrides[key]
+	})]));
+}
 //#endregion
-export { applyActionBattleHit };
+export { DEFAULT_ACTION_BATTLE_ENEMY_ATTACK_PROFILES, normalizeActionBattleEnemyAttackProfiles };

package/dist/server/index9.js

@@ -1,447 +1,54 @@
-import { playActionBattleAnimation } from "./index2.js";
-import { normalizeActionBattleOptions, setActionBattleOptions } from "./index3.js";
-import { DEFAULT_ZELDA_PLAYER_HITBOXES } from "./index4.js";
-import { getActionBattleSystems, setActionBattleSystems } from "./index5.js";
-import { DEFAULT_KNOCKBACK } from "./index6.js";
-import { manhattanDistance, parseAoeMask } from "./index7.js";
-import { applyActionBattleHit } from "./index8.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) => {
-	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 = typeof player.canMove === "function" ? player.canMove() : true;
-	const previousDirectionFixed = player.directionFixed;
-	const previousAnimationFixed = player.animationFixed;
-	player.pendingInputs = [];
-	player.lastProcessedInputTs = 0;
-	map?.stopMovement?.(player);
-	player.canMove.set(false);
-	player.directionFixed = true;
-	setTimeout(() => {
-		if (runtimePlayer.__actionBattleAttackLockId !== lockId) return;
-		runtimePlayer.__actionBattleAttackLockedUntil = 0;
-		player.canMove.set(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)));
-	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) {
-	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
-	});
-	if (!result.cancelled) ai.handleDamage(player, {
-		damage: result.damage,
-		defeated: result.defeated,
-		raw: result.rawDamage
+import { normalizeActionBattleAttackProfile } from "./index4.js";
+//#region src/core/attack-runtime.ts
+var ACTION_BATTLE_HITBOX_FRAME_MS = 16;
+function getNormalizedActionBattleAttackProfile(options = {}) {
+	const attack = options.attack ?? {};
+	return normalizeActionBattleAttackProfile(attack.profile, {
+		lockMovement: attack.lockMovement,
+		lockDurationMs: attack.lockDurationMs,
+		hitboxes: attack.hitboxes
 	});
-	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) => {
-	const configuredHitboxes = {
-		...DEFAULT_PLAYER_ATTACK_HITBOXES,
-		...options.attack?.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 resolveSignal = (value) => typeof value === "function" ? value() : value;
-var resolveItemData = (player, itemId) => {
-	try {
-		return player.databaseById?.(itemId);
-	} catch {
+function resolveActionBattleHitboxSpeed(profile, hitboxCount) {
+	const positions = Math.max(1, Math.floor(hitboxCount));
+	const activeFrames = Math.max(1, Math.ceil(profile.activeMs / 16));
+	return Math.max(1, Math.ceil(activeFrames / positions));
+}
+function scheduleActionBattleStartup(profile, callback, scheduler = setTimeout) {
+	if (profile.startupMs <= 0) {
+		callback();
 		return null;
 	}
-};
-var resolveSkillData = (player, skillId) => {
-	try {
-		return player.databaseById?.(skillId);
-	} catch {
-		return null;
+	return scheduler(callback, profile.startupMs);
+}
+var attackIdCounter = 0;
+function createActionBattleAttackId(attackerId, profileId) {
+	attackIdCounter++;
+	return `${attackerId ?? "unknown"}:${profileId}:${Date.now()}:${attackIdCounter}`;
+}
+var getTargetKey = (target) => {
+	if (!target || target.id === void 0 || target.id === null) return null;
+	return String(target.id);
+};
+var ActionBattleHitTracker = class {
+	hitTargets = /* @__PURE__ */ new Set();
+	constructor(hitPolicy) {
+		this.hitPolicy = hitPolicy;
 	}
-};
-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));
-		});
+	canHit(target) {
+		if (this.hitPolicy === "allowRepeatHits") return true;
+		const key = getTargetKey(target);
+		return !key || !this.hitTargets.has(key);
 	}
-	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;
+	recordHit(target) {
+		const key = getTargetKey(target);
+		if (key) this.hitTargets.add(key);
 	}
-	const targeting = resolveSkillTargeting(player, skillId, options);
-	if (!targeting || !target) {
-		playActionBattleAnimation("castSkill", player, options.animations, { skill: skillData });
-		player.useSkill(skillId);
-		return;
+	tryHit(target) {
+		if (!this.canHit(target)) return false;
+		this.recordHit(target);
+		return true;
 	}
-	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 hitboxes = resolvePlayerAttackHitboxes(player, player.getDirection(), options);
-					if (isActionReservedForNormalEvent(player, map, hitboxes)) return;
-					const lockMovement = options.attack?.lockMovement !== false;
-					const lockDurationMs = options.attack?.lockDurationMs ?? DEFAULT_ATTACK_LOCK_DURATION_MS;
-					let movementLocked = false;
-					if (lockMovement && !beginPlayerAttackLock(player, map, Math.max(0, lockDurationMs))) return;
-					movementLocked = lockMovement && lockDurationMs > 0;
-					playActionBattleAnimation("attack", player, options.animations);
-					if (movementLocked) player.animationFixed = true;
-					map?.createMovingHitbox(hitboxes, { speed: 3 }).subscribe({ next(hits) {
-						hits.forEach((hit) => {
-							if (hit instanceof RpgEvent) {
-								if (applyPlayerHitToEvent(player, hit)?.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 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 { ACTION_BATTLE_HITBOX_FRAME_MS, ActionBattleHitTracker, createActionBattleAttackId, getNormalizedActionBattleAttackProfile, resolveActionBattleHitboxSpeed, scheduleActionBattleStartup };