@rpgjs/action-battle 5.0.0-beta.3 → 5.0.0-beta.5

package/README.md

@@ -7,6 +7,7 @@ The AI controller manages **behavior only** - all stats (HP, ATK, skills, items,
 ## Features
 
 - **State Machine AI**: Enemies with dynamic behaviors (Idle, Alert, Combat, Flee, Stunned)
+- **Plugin-first architecture**: Replace damage, hitboxes, knockback, hooks, and AI behaviors independently
 - **Multiple Enemy Types**: Aggressive, Defensive, Ranged, Tank, Berserker
 - **Attack Patterns**: Melee, Combo, Charged, Zone, Dash Attack
 - **Skill Support**: AI can use any RPGJS skill
@@ -22,6 +23,90 @@ The AI controller manages **behavior only** - all stats (HP, ATK, skills, items,
 npm install @rpgjs/action-battle
 ```
 
+## Plugin-First Customization
+
+`provideActionBattle()` ships with Zelda-like defaults, but each combat system
+can be replaced without rewriting the module.
+
+```ts
+import { provideActionBattle } from "@rpgjs/action-battle/server";
+
+export default provideActionBattle({
+  attack: {
+    lockMovement: true,
+    lockDurationMs: 280,
+    hitboxes: {
+      right: { offsetX: 18, offsetY: -18, width: 42, height: 36 }
+    }
+  },
+  systems: {
+    combat: {
+      damage({ attacker, target, skill }) {
+        const raw = target.applyDamage(attacker, skill);
+        return {
+          damage: raw.damage,
+          defeated: target.hp <= 0,
+          raw
+        };
+      },
+      knockback({ attacker, target }) {
+        const dx = target.x() - attacker.x();
+        const dy = target.y() - attacker.y();
+        const distance = Math.max(1, Math.sqrt(dx * dx + dy * dy));
+        return {
+          force: 70,
+          duration: 220,
+          direction: { x: dx / distance, y: dy / distance }
+        };
+      },
+      hooks: {
+        beforeHit(context) {
+          // Return false to cancel a hit, or return a modified context.
+          return context;
+        },
+        afterHit(result) {
+          console.log(`Damage: ${result.damage}`);
+        }
+      }
+    },
+    ai: {
+      behaviors: {
+        slime({ hpPercent }) {
+          return {
+            mode: hpPercent !== null && hpPercent < 0.25 ? "retreat" : "assault",
+            attackCooldown: 900
+          };
+        }
+      }
+    }
+  }
+});
+```
+
+The main extension contracts are:
+
+- `ActionBattleCombatSystem`: resolves hitboxes, damage, knockback, and hooks.
+- `ActionBattleAiBehavior`: returns lightweight AI decisions from event state.
+- `ActionBattleHitHooks`: `beforeHit`, `afterDamage`, and `afterHit`.
+
+Use `createActionEnemy()` when you want data-driven enemy presets:
+
+```ts
+import { createActionEnemy, EnemyType } from "@rpgjs/action-battle/server";
+
+const enemyPresets = {
+  slime: {
+    enemyType: EnemyType.Aggressive,
+    behaviorKey: "slime",
+    stats(event) {
+      event.hp = 40;
+    }
+  }
+};
+
+createActionEnemy(this, "slime", enemyPresets);
+```
+
 ## Quick Start
 
 ```typescript
@@ -496,6 +581,36 @@ The module handles player attacks via the `action` input:
 // Knockback force is based on equipped weapon's knockbackForce property
 ```
 
+By default, the player is locked in place for `350ms` when attacking, similar
+to classic A-RPG combat where the attack resolves before movement resumes.
+
+```ts
+provideActionBattle({
+  attack: {
+    lockMovement: true,
+    lockDurationMs: 350,
+    showPreview: true,
+    previewDurationMs: 180,
+    previewColor: 0xfff3b0,
+    previewAccentColor: 0xffffff
+  }
+});
+```
+
+Set `lockMovement` to `false` if your game should allow moving attacks.
+The client also stops predicted movement immediately and shows a short slash
+preview so the action feels responsive even before the server hit resolves. Set
+`showPreview` to `false` if your project uses only spritesheet combat
+animations.
+
+Player attacks are resolved with `createMovingHitbox()` instead of a passive
+contact collision. You can still customize the generated hitboxes with
+`attack.hitboxes` or `attack.resolveHitboxes`.
+
+When the action targets a normal event with no `BattleAi`, the server lets the
+event handle `onAction` and does not create the combat hitbox. Enemy events
+with `BattleAi` still trigger the A-RPG attack.
+
 ## Configurable Combat Animations
 
 By default, player and AI attacks keep using the existing `attack` animation:
@@ -524,6 +639,28 @@ export default provideActionBattle({
 });
 ```
 
+RPGJS Studio stores combat animations as spritesheet media ids. If
+`provideStudioGame()` is installed, `createStudioActionBattleAnimations()` can
+read the project animations attached to the player at runtime. By default, the
+helper plays Studio attack spritesheets with
+`setGraphicAnimation("attack", graphic, 1)`:
+
+```ts
+import { provideActionBattle } from "@rpgjs/action-battle/server";
+import { createStudioActionBattleAnimations } from "@rpgjs/studio/server";
+
+export default provideActionBattle({
+  animations: createStudioActionBattleAnimations()
+});
+```
+
+You can also pass a static Studio animation object to override the media ids
+manually. Animation values may be media ids or media objects returned by the
+Studio game API.
+
+The Studio field `castSpell` is accepted as an alias for action-battle's
+`castSkill` animation key.
+
 For data-driven spritesheets, use resolver functions:
 
 ```ts

package/dist/ai.server.d.ts

@@ -1,7 +1,8 @@
 import { RpgEvent, RpgPlayer } from '@rpgjs/server';
+import { ActionBattleDamageResult } from './core/contracts';
 import { ActionBattleAnimationOptions } from './types';
 type RpgEventWithBattleAi = RpgEvent & {
-    battleAi: BattleAi;
+    battleAi?: BattleAi;
 };
 export interface BattleAiOptions {
     enemyType?: EnemyType;
@@ -27,6 +28,7 @@ export interface BattleAiOptions {
         assaultThreshold?: number;
         retreatThreshold?: number;
     };
+    behaviorKey?: string;
     animations?: ActionBattleAnimationOptions;
     /** Callback called when the AI is defeated */
     onDefeated?: (event: RpgEvent, attacker?: RpgPlayer) => void;
@@ -277,6 +279,8 @@ export declare class BattleAi {
     private lastMoveToTime;
     private retreatCooldown;
     private lastRetreatTime;
+    private timers;
+    private behaviorKey?;
     /**
      * Create a new Battle AI Controller
      *
@@ -483,6 +487,7 @@ export declare class BattleAi {
      * The actual damage is applied externally via RPGJS API.
      */
     takeDamage(attacker: RpgPlayer): boolean;
+    handleDamage(attacker: RpgPlayer, damageResult: ActionBattleDamageResult): boolean;
     /**
      * Kill this AI
      *
@@ -495,9 +500,11 @@ export declare class BattleAi {
      */
     private getDistance;
     private updateBehavior;
+    private applyCustomBehavior;
     private handleTacticalMovement;
     private handleAssaultMovement;
     private requestMoveTo;
+    private schedule;
     getHealth(): number;
     getMaxHealth(): number;
     getTarget(): InstanceType<typeof RpgPlayer> | null;

package/dist/client/index.js

@@ -1,6 +1,10 @@
-import client_default, { createActionBattleClient } from "./index7.js";
-import { AiDebug, AiState, AttackPattern, BattleAi, DEFAULT_KNOCKBACK, EnemyType } from "./index9.js";
-import { ACTION_BATTLE_ACTION_BAR_GUI_ID, DEFAULT_PLAYER_ATTACK_HITBOXES, applyPlayerHitToEvent, createActionBattleServer, getPlayerWeaponKnockbackForce, openActionBattleActionBar, updateActionBattleActionBar } from "./index10.js";
+import client_default, { createActionBattleClient } from "./index9.js";
+import { DEFAULT_ZELDA_PLAYER_HITBOXES, createDefaultPlayerHitboxResolver, defaultCombatSystem, defaultEnemyBehaviors, defaultKnockbackResolver, defaultRpgjsDamageResolver } from "./index10.js";
+import { createActionBattleSystems, getActionBattleSystems } from "./index11.js";
+import { AiDebug, AiState, AttackPattern, BattleAi, DEFAULT_KNOCKBACK, EnemyType } from "./index12.js";
+import { applyActionBattleHit } from "./index13.js";
+import { createActionEnemy } from "./index14.js";
+import { ACTION_BATTLE_ACTION_BAR_GUI_ID, DEFAULT_PLAYER_ATTACK_HITBOXES, applyPlayerHitToEvent, createActionBattleServer, getPlayerWeaponKnockbackForce, openActionBattleActionBar, updateActionBattleActionBar } from "./index15.js";
 import { createModule } from "@rpgjs/common";
 //#region src/index.ts
 var server = null;
@@ -16,4 +20,4 @@ var src_default = {
 	client: client_default
 };
 //#endregion
-export { ACTION_BATTLE_ACTION_BAR_GUI_ID, AiDebug, AiState, AttackPattern, BattleAi, DEFAULT_KNOCKBACK, DEFAULT_PLAYER_ATTACK_HITBOXES, EnemyType, applyPlayerHitToEvent, createActionBattleServer, src_default as default, getPlayerWeaponKnockbackForce, openActionBattleActionBar, provideActionBattle, updateActionBattleActionBar };
+export { ACTION_BATTLE_ACTION_BAR_GUI_ID, AiDebug, AiState, AttackPattern, BattleAi, DEFAULT_KNOCKBACK, DEFAULT_PLAYER_ATTACK_HITBOXES, DEFAULT_ZELDA_PLAYER_HITBOXES, EnemyType, applyActionBattleHit, applyPlayerHitToEvent, createActionBattleServer, createActionBattleSystems, createActionEnemy, createDefaultPlayerHitboxResolver, src_default as default, defaultCombatSystem, defaultEnemyBehaviors, defaultKnockbackResolver, defaultRpgjsDamageResolver, getActionBattleSystems, getPlayerWeaponKnockbackForce, openActionBattleActionBar, provideActionBattle, updateActionBattleActionBar };

package/dist/client/index10.js

@@ -1,19 +1,23 @@
-import { normalizeActionBattleOptions, setActionBattleOptions } from "./index2.js";
-import { manhattanDistance, parseAoeMask } from "./index5.js";
-import { playActionBattleAnimation } from "./index8.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";
-/**
-* 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 = {
+//#region src/core/defaults.ts
+var DEFAULT_CORE_KNOCKBACK = {
+	force: 50,
+	duration: 300
+};
+var CoreAttackPattern = {
+	Melee: "melee",
+	Combo: "combo",
+	Charged: "charged",
+	Zone: "zone",
+	DashAttack: "dashAttack"
+};
+var CoreEnemyType = {
+	Aggressive: "aggressive",
+	Defensive: "defensive",
+	Ranged: "ranged",
+	Tank: "tank",
+	Berserker: "berserker"
+};
+var DEFAULT_ZELDA_PLAYER_HITBOXES = {
 	up: {
 		offsetX: -16,
 		offsetY: -48,
@@ -45,332 +49,95 @@ var DEFAULT_PLAYER_ATTACK_HITBOXES = {
 		height: 32
 	}
 };
-/**
-* 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 knockbackForce = getPlayerWeaponKnockbackForce(player);
-	const defeated = ai.takeDamage(player);
-	const dx = target.x() - player.x();
-	const dy = target.y() - player.y();
-	const distance = Math.sqrt(dx * dx + dy * dy);
-	let hitResult = {
-		damage: 0,
-		knockbackForce,
-		knockbackDuration: DEFAULT_KNOCKBACK.duration,
-		defeated,
-		attacker: player,
-		target
-	};
-	if (hooks?.onBeforeHit) {
-		const modified = hooks.onBeforeHit(hitResult);
-		if (modified) hitResult = modified;
-	}
-	if (!hitResult.defeated && hitResult.knockbackForce > 0 && distance > 0) {
-		const knockbackDirection = {
-			x: dx / distance,
-			y: dy / distance
-		};
-		target.knockback(knockbackDirection, hitResult.knockbackForce, hitResult.knockbackDuration);
-	}
-	if (hooks?.onAfterHit) hooks.onAfterHit(hitResult);
-	return hitResult;
-}
-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 resolveEquippedWeapon = (entity) => {
+	const equipments = entity?.equipments?.() || [];
+	for (const item of equipments) {
+		const itemId = item?.id?.() ?? item?.id;
+		const itemData = entity?.databaseById?.(itemId);
+		if (itemData?._type === "weapon") return itemData;
 	}
+	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;
+var resolveDirection = (attacker, target) => {
+	const dx = target.x() - attacker.x();
+	const dy = target.y() - attacker.y();
+	const distance = Math.sqrt(dx * dx + dy * dy);
+	if (distance <= 0) return void 0;
 	return {
-		range: range ?? 0,
-		aoeMask
+		x: dx / distance,
+		y: dy / distance
 	};
 };
-var normalizeMaskRows = (mask) => {
-	if (!mask) return [];
-	if (Array.isArray(mask)) return mask;
-	return mask.trim().split("\n").map((row) => row.replace(/\r/g, ""));
+var createDefaultPlayerHitboxResolver = (hitboxes = DEFAULT_ZELDA_PLAYER_HITBOXES) => (context) => {
+	const attacker = context.attacker;
+	const config = hitboxes[context.direction ?? (typeof attacker.getDirection === "function" ? attacker.getDirection() : "default")] || hitboxes.default;
+	return [{
+		x: attacker.x() + config.offsetX,
+		y: attacker.y() + config.offsetY,
+		width: config.width,
+		height: config.height
+	}];
 };
-var buildActionBarData = (player, options) => {
+var defaultRpgjsDamageResolver = (context) => {
+	const target = context.target;
+	const raw = target.applyDamage(context.attacker, context.skill);
 	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;
-		})
+		damage: raw?.damage ?? 0,
+		defeated: target.hp <= 0,
+		raw
 	};
 };
-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
-	};
+var defaultKnockbackResolver = (context) => {
+	const weapon = context.weapon ?? resolveEquippedWeapon(context.attacker);
 	return {
-		x: Math.floor((entity.x() + hitbox.w / 2) / tileSize.width),
-		y: Math.floor((entity.y() + hitbox.h / 2) / tileSize.height)
+		force: weapon?.knockbackForce ?? DEFAULT_CORE_KNOCKBACK.force,
+		duration: weapon?.knockbackDuration ?? DEFAULT_CORE_KNOCKBACK.duration,
+		direction: resolveDirection(context.attacker, context.target)
 	};
 };
-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 defaultCombatSystem = {
+	resolveHitboxes: createDefaultPlayerHitboxResolver(),
+	resolveDamage: defaultRpgjsDamageResolver,
+	resolveKnockback: defaultKnockbackResolver
+};
+var defaultEnemyBehaviors = {
+	[CoreEnemyType.Aggressive]: ({ hpPercent }) => ({
+		mode: hpPercent !== null && hpPercent < .15 ? "retreat" : "assault",
+		attackPatterns: [
+			CoreAttackPattern.Melee,
+			CoreAttackPattern.Combo,
+			CoreAttackPattern.DashAttack
+		]
+	}),
+	[CoreEnemyType.Defensive]: ({ hpPercent }) => ({
+		mode: hpPercent !== null && hpPercent < .3 ? "retreat" : "tactical",
+		attackPatterns: [CoreAttackPattern.Melee, CoreAttackPattern.Charged]
+	}),
+	[CoreEnemyType.Ranged]: ({ distance }) => ({
+		mode: distance !== null && distance < 80 ? "retreat" : "tactical",
+		attackPatterns: [CoreAttackPattern.Melee, CoreAttackPattern.Zone]
+	}),
+	[CoreEnemyType.Tank]: () => ({
+		mode: "assault",
+		attackPatterns: [
+			CoreAttackPattern.Melee,
+			CoreAttackPattern.Charged,
+			CoreAttackPattern.Zone
+		]
+	}),
+	[CoreEnemyType.Berserker]: ({ hpPercent }) => ({
+		mode: "assault",
+		attackCooldown: hpPercent === null ? void 0 : Math.max(250, 800 * Math.max(.3, hpPercent)),
+		attackPatterns: [
+			CoreAttackPattern.Melee,
+			CoreAttackPattern.Combo,
+			CoreAttackPattern.DashAttack
+		]
+	})
 };
-var createActionBattleServer = (rawOptions = {}) => {
-	const options = normalizeActionBattleOptions(rawOptions);
-	setActionBattleOptions(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) {
-					playActionBattleAnimation("attack", player, options.animations);
-					const playerX = player.x();
-					const playerY = player.y();
-					const hitboxConfig = DEFAULT_PLAYER_ATTACK_HITBOXES[player.getDirection()] || DEFAULT_PLAYER_ATTACK_HITBOXES.default;
-					const hitboxes = [{
-						x: playerX + hitboxConfig.offsetX,
-						y: playerY + hitboxConfig.offsetY,
-						width: hitboxConfig.width,
-						height: hitboxConfig.height
-					}];
-					player.getCurrentMap()?.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 defaultActionBattleSystems = {
+	combat: defaultCombatSystem,
+	ai: { behaviors: defaultEnemyBehaviors }
 };
-createActionBattleServer();
 //#endregion
-export { ACTION_BATTLE_ACTION_BAR_GUI_ID, DEFAULT_PLAYER_ATTACK_HITBOXES, applyPlayerHitToEvent, createActionBattleServer, getPlayerWeaponKnockbackForce, openActionBattleActionBar, updateActionBattleActionBar };
+export { DEFAULT_ZELDA_PLAYER_HITBOXES, createDefaultPlayerHitboxResolver, defaultActionBattleSystems, defaultCombatSystem, defaultEnemyBehaviors, defaultKnockbackResolver, defaultRpgjsDamageResolver };