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

package/dist/client/index26.js

@@ -0,0 +1,1949 @@
+import { isActionBattleEntityInvincible, setActionBattleInvincibility } from "./index2.js";
+import { getActionBattleOptions } from "./index4.js";
+import { ActionBattleHitTracker, runActionBattleActiveHitbox, scheduleActionBattleStartup } from "./index6.js";
+import { applyActionBattleAttackDirection } from "./index7.js";
+import { withActionBattleAnimationUnlocked } from "./index8.js";
+import { getActionBattleAnimationRemovalDelay, resolveActionBattleAnimation } from "./index14.js";
+import { emitActionBattleClientVisual } from "./index15.js";
+import { getActionBattleSystems } from "./index18.js";
+import { normalizeActionBattleEnemyAttackProfiles } from "./index19.js";
+import { canActionBattleTarget, isActionBattlePlayer } from "./index21.js";
+import { executeActionBattleUse, getActionBattleActionRange } from "./index22.js";
+import { resolveActionBattleWeapon } from "./index23.js";
+import { safeActionBattleDash } from "./index24.js";
+import { defineAiBehavior, defineAiTree } from "./index25.js";
+//#region src/ai.server.ts
+var MAXHP = null;
+var resolveMoveCoordinate = (value) => {
+	const raw = typeof value === "function" ? value() : value;
+	return typeof raw === "number" && Number.isFinite(raw) ? raw : void 0;
+};
+var createMoveSignature = (x, y) => `position:${Math.round(x)}:${Math.round(y)}`;
+var normalizeRewardItem = (item) => {
+	if (typeof item === "string") return {
+		itemId: item,
+		amount: 1,
+		chance: 100
+	};
+	return {
+		...item,
+		amount: item.amount ?? 1,
+		chance: item.chance ?? 100
+	};
+};
+var getRewardItemRef = (item) => item.item ?? item.itemId;
+var getPlayerMap = (player) => {
+	return typeof player.getCurrentMap === "function" ? player.getCurrentMap() : void 0;
+};
+var getRewardItemName = (inventoryItem, itemRef) => {
+	if (inventoryItem && typeof inventoryItem.name === "function") return inventoryItem.name();
+	if (inventoryItem?.name) return inventoryItem.name;
+	if (typeof itemRef === "string") return itemRef;
+	if (itemRef?.name) return itemRef.name;
+	if (itemRef?.id) return itemRef.id;
+	return "item";
+};
+var createDefeatReward = (rewards) => {
+	let awarded = false;
+	return {
+		get awarded() {
+			return awarded;
+		},
+		giveTo(player) {
+			if (!player || awarded || !rewards) return;
+			awarded = true;
+			const exp = rewards.exp ?? 0;
+			const gold = rewards.gold ?? 0;
+			if (exp > 0) player.exp += exp;
+			if (gold > 0) player.gold += gold;
+			if (rewards.showNotification && (exp > 0 || gold > 0)) player.showNotification(`You won ${exp} experience and ${gold} gold`);
+			for (const rawItem of rewards.items ?? []) {
+				const item = normalizeRewardItem(rawItem);
+				const itemRef = getRewardItemRef(item);
+				if (!itemRef) continue;
+				if (Math.random() * 100 >= (item.chance ?? 100)) continue;
+				const amount = item.amount ?? 1;
+				const inventoryItem = player.addItem(itemRef, amount);
+				if (rewards.showNotification) {
+					const itemData = typeof itemRef === "string" ? getPlayerMap(player)?.database?.()?.[itemRef] : void 0;
+					player.showNotification(`You won ${amount} ${getRewardItemName(inventoryItem, itemRef)}`, { icon: itemData?.icon });
+				}
+			}
+		}
+	};
+};
+/**
+* AI Debug Logger
+* 
+* Conditional logging utility for AI behavior debugging.
+* Enable by setting `AiDebug.enabled = true` or via environment variable `RPGJS_DEBUG_AI=1`
+* 
+* @example
+* ```ts
+* // Enable debug logging
+* AiDebug.enabled = true;
+* 
+* // Or filter by event ID
+* AiDebug.filterEventId = 'goblin-1';
+* ```
+*/
+var AiDebug = {
+	/** Enable/disable all AI debug logs */
+	enabled: globalThis.process?.env?.RPGJS_DEBUG_AI === "1" || false,
+	/** Filter logs to a specific event ID (null = all events) */
+	filterEventId: null,
+	/** Log categories to enable (empty = all) */
+	categories: [],
+	/**
+	* Log an AI debug message
+	* 
+	* @param category - Log category (e.g., 'state', 'attack', 'movement', 'damage')
+	* @param eventId - Event ID for filtering
+	* @param message - Log message
+	* @param data - Optional additional data
+	*/
+	log(category, eventId, message, data) {}
+};
+/**
+* AI State enumeration
+* 
+* Defines the different states an AI can be in, each with its own behavior.
+*/
+var AiState = /* @__PURE__ */ function(AiState) {
+	AiState["Idle"] = "idle";
+	AiState["Alert"] = "alert";
+	AiState["Combat"] = "combat";
+	AiState["Flee"] = "flee";
+	AiState["Stunned"] = "stunned";
+	return AiState;
+}({});
+/**
+* Enemy Type enumeration
+* 
+* Defines different enemy archetypes with unique behaviors.
+* Stats (HP, ATK, etc.) should be set on the event itself via onInit.
+*/
+var EnemyType = /* @__PURE__ */ function(EnemyType) {
+	EnemyType["Aggressive"] = "aggressive";
+	EnemyType["Defensive"] = "defensive";
+	EnemyType["Ranged"] = "ranged";
+	EnemyType["Tank"] = "tank";
+	EnemyType["Berserker"] = "berserker";
+	return EnemyType;
+}({});
+/**
+* Attack Pattern enumeration
+* 
+* Different attack patterns the AI can use.
+*/
+var AttackPattern = /* @__PURE__ */ function(AttackPattern) {
+	AttackPattern["Melee"] = "melee";
+	AttackPattern["Combo"] = "combo";
+	AttackPattern["Charged"] = "charged";
+	AttackPattern["Zone"] = "zone";
+	AttackPattern["DashAttack"] = "dashAttack";
+	return AttackPattern;
+}({});
+/**
+* Default knockback configuration
+* 
+* Used when no weapon is equipped or weapon doesn't specify knockback.
+*/
+var DEFAULT_KNOCKBACK = {
+	/** Default knockback force */
+	force: 50,
+	/** Default knockback duration in milliseconds */
+	duration: 300
+};
+var mergeBattleAiPresetOptions = (options, seen = /* @__PURE__ */ new Set()) => {
+	if (!options.preset) return options;
+	if (typeof options.preset === "string") {
+		if (seen.has(options.preset)) throw new Error(`Circular action battle AI preset: ${options.preset}`);
+		seen.add(options.preset);
+	}
+	const preset = typeof options.preset === "string" ? getActionBattleSystems().ai.presets[options.preset] : options.preset;
+	if (!preset) throw new Error(`Action battle AI preset not found: ${options.preset}`);
+	const resolvedPreset = mergeBattleAiPresetOptions(preset, seen);
+	const { preset: _preset, ...overrides } = options;
+	return {
+		...resolvedPreset,
+		...overrides,
+		behavior: {
+			...resolvedPreset.behavior,
+			...overrides.behavior
+		},
+		animations: {
+			...resolvedPreset.animations,
+			...overrides.animations
+		},
+		rewards: {
+			...resolvedPreset.rewards,
+			...overrides.rewards
+		}
+	};
+};
+/**
+* Advanced Battle AI Controller for events
+*
+* This class provides intelligent combat behavior control for events.
+* It uses the existing RPGJS API for stats, skills, items, etc.
+* The AI only manages behavior - the event's stats should be configured
+* in onInit using standard RPGJS methods.
+*
+* ## Usage with RPGJS API
+* 
+* Configure the event stats using standard RPGJS methods:
+* - `this.hp = 100` - Set health
+* - `this.learnSkill(FireBall)` - Learn a skill
+* - `this.addItem(Potion, 3)` - Add items
+* - `this.equip(Sword)` - Equip items
+* - `this.setClass(WarriorClass)` - Set class
+* - `this.param[ATK] = 20` - Set parameters
+*
+* @example
+* ```ts
+* function GoblinEnemy() {
+*   return {
+*     name: "Goblin",
+*     onInit() {
+*       this.setGraphic("goblin");
+*       
+*       // Configure stats using RPGJS API
+*       this.hp = 80;
+*       this.param[ATK] = 15;
+*       this.param[PDEF] = 5;
+*       this.learnSkill(Slash);
+*       
+*       // Apply AI behavior
+*       new BattleAi(this, {
+*         enemyType: EnemyType.Aggressive,
+*         attackSkill: Slash
+*       });
+*     }
+*   };
+* }
+* ```
+*/
+var BattleAi = class {
+	event;
+	target = null;
+	lastAttackTime = 0;
+	updateInterval;
+	/**
+	* Log AI debug message for this event
+	*/
+	debugLog(category, message, data) {
+		AiDebug.log(category, this.event.id, message, data);
+	}
+	traceLog(category, message, data) {}
+	lockActionUntil(until, reason, data) {
+		if (until <= this.actionLockedUntil) return;
+		this.actionLockedUntil = until;
+		this.traceLog("state", "action locked", {
+			reason,
+			lockedMs: Math.max(0, until - Date.now()),
+			...data
+		});
+	}
+	lockForAttack(profile, pattern) {
+		this.isMovingToTarget = false;
+		this.event.stopMoveTo();
+		this.lockActionUntil(Date.now() + profile.totalDurationMs, "attack", {
+			pattern,
+			totalDurationMs: profile.totalDurationMs,
+			startupMs: profile.startupMs,
+			activeMs: profile.activeMs,
+			recoveryMs: profile.recoveryMs
+		});
+	}
+	state = AiState.Idle;
+	stateStartTime = 0;
+	stunnedUntil = 0;
+	enemyType;
+	faction;
+	targets = "players";
+	attackCooldown = 1e3;
+	visionRange = 150;
+	attackRange = 60;
+	dodgeChance = .2;
+	dodgeCooldown = 2e3;
+	lastDodgeTime = 0;
+	fleeThreshold = .2;
+	attackSkill;
+	attackPatterns;
+	attackProfiles;
+	animations;
+	comboCount = 0;
+	comboMax = 3;
+	chargingAttack = false;
+	groupBehavior;
+	nearbyEnemies = [];
+	groupUpdateInterval = 0;
+	patrolWaypoints = [];
+	currentPatrolIndex = 0;
+	lastHpCheck = 0;
+	recentDamageTaken = 0;
+	damageCheckInterval = 2e3;
+	isMovingToTarget = false;
+	onDefeatedCallback;
+	rewards;
+	autoAwardRewards = true;
+	defeated = false;
+	lastFacingDirection = null;
+	behaviorScore = 50;
+	behaviorMode = "tactical";
+	behaviorLastUpdate = 0;
+	behaviorUpdateInterval = 400;
+	behaviorAssaultThreshold = 65;
+	behaviorRetreatThreshold = 35;
+	behaviorMinStateDuration = 600;
+	behaviorEnabled = false;
+	moveToCooldown = 400;
+	lastMoveToTime = 0;
+	retreatCooldown = 600;
+	lastRetreatTime = 0;
+	actionLockedUntil = 0;
+	lastActionLockTraceTime = 0;
+	lastMoveToCooldownTraceTime = 0;
+	lastMoveToCooldownTraceSignature = null;
+	lastTargetMovementSkipTraceTime = 0;
+	timers = [];
+	behaviorKey;
+	behaviorTree;
+	aiMemory = {};
+	poise = 0;
+	hitstunMs = 150;
+	invincibilityMs = 250;
+	visionShape;
+	visionSetupRetries = 0;
+	maxVisionSetupRetries = 20;
+	destroyed = false;
+	lastNoTargetTraceTime = 0;
+	constructor(event, options = {}) {
+		options = mergeBattleAiPresetOptions(options);
+		event.battleAi = this;
+		this.event = event;
+		this.enemyType = options.enemyType || EnemyType.Aggressive;
+		this.faction = options.faction;
+		this.targets = options.targets ?? "players";
+		this.behaviorKey = options.behaviorKey ?? this.enemyType;
+		this.applyEnemyTypeBehavior(options);
+		this.attackSkill = options.attackSkill || null;
+		this.animations = {
+			...getActionBattleOptions().animations,
+			...options.animations
+		};
+		this.attackPatterns = options.attackPatterns || [
+			AttackPattern.Melee,
+			AttackPattern.Combo,
+			AttackPattern.DashAttack
+		];
+		this.attackProfiles = normalizeActionBattleEnemyAttackProfiles(options.attackProfiles);
+		this.groupBehavior = options.groupBehavior || false;
+		this.patrolWaypoints = options.patrolWaypoints || [];
+		this.currentPatrolIndex = 0;
+		this.onDefeatedCallback = options.onDefeated;
+		this.rewards = options.rewards;
+		this.autoAwardRewards = options.autoAwardRewards ?? true;
+		if (options.behavior) {
+			this.behaviorEnabled = true;
+			if (options.behavior.baseScore !== void 0) this.behaviorScore = options.behavior.baseScore;
+			if (options.behavior.updateInterval !== void 0) this.behaviorUpdateInterval = options.behavior.updateInterval;
+			if (options.behavior.minStateDuration !== void 0) this.behaviorMinStateDuration = options.behavior.minStateDuration;
+			if (options.behavior.assaultThreshold !== void 0) this.behaviorAssaultThreshold = options.behavior.assaultThreshold;
+			if (options.behavior.retreatThreshold !== void 0) this.behaviorRetreatThreshold = options.behavior.retreatThreshold;
+		}
+		if (options.moveToCooldown !== void 0) this.moveToCooldown = options.moveToCooldown;
+		if (options.retreatCooldown !== void 0) this.retreatCooldown = options.retreatCooldown;
+		if (options.poise !== void 0) this.poise = Math.max(0, options.poise);
+		if (options.hitstunMs !== void 0) this.hitstunMs = Math.max(0, options.hitstunMs);
+		if (options.invincibilityMs !== void 0) this.invincibilityMs = Math.max(0, options.invincibilityMs);
+		if (options.tree || options.behaviorTree) this.behaviorTree = defineAiTree(options.tree ?? options.behaviorTree);
+		else if (options.simpleBehavior) this.behaviorTree = defineAiBehavior(options.simpleBehavior);
+		if (options.attackRange === void 0) {
+			const actionRange = this.getCurrentActionRange();
+			if (actionRange !== void 0) this.attackRange = actionRange;
+		}
+		this.scheduleVisionSetup();
+		this.startAiBehaviorLoop();
+		if (this.patrolWaypoints.length > 0) this.startPatrol();
+		this.debugLog("init", `AI created (type=${this.enemyType}, visionRange=${this.visionRange}, attackRange=${this.attackRange})`);
+	}
+	/**
+	* Apply enemy type-specific behavior modifiers
+	* 
+	* This only affects AI behavior (cooldowns, ranges, dodge).
+	* Stats should be set on the event itself.
+	*/
+	applyEnemyTypeBehavior(options) {
+		switch (this.enemyType) {
+			case EnemyType.Aggressive:
+				this.attackCooldown = options.attackCooldown ?? 600;
+				this.visionRange = options.visionRange ?? 150;
+				this.attackRange = options.attackRange ?? 50;
+				this.dodgeChance = options.dodgeChance ?? .1;
+				this.dodgeCooldown = options.dodgeCooldown ?? 3e3;
+				this.fleeThreshold = options.fleeThreshold ?? .15;
+				break;
+			case EnemyType.Defensive:
+				this.attackCooldown = options.attackCooldown ?? 1500;
+				this.visionRange = options.visionRange ?? 120;
+				this.attackRange = options.attackRange ?? 60;
+				this.dodgeChance = options.dodgeChance ?? .5;
+				this.dodgeCooldown = options.dodgeCooldown ?? 1500;
+				this.fleeThreshold = options.fleeThreshold ?? .3;
+				break;
+			case EnemyType.Ranged:
+				this.attackCooldown = options.attackCooldown ?? 1200;
+				this.visionRange = options.visionRange ?? 200;
+				this.attackRange = options.attackRange ?? 120;
+				this.dodgeChance = options.dodgeChance ?? .4;
+				this.dodgeCooldown = options.dodgeCooldown ?? 2e3;
+				this.fleeThreshold = options.fleeThreshold ?? .25;
+				break;
+			case EnemyType.Tank:
+				this.attackCooldown = options.attackCooldown ?? 2e3;
+				this.visionRange = options.visionRange ?? 100;
+				this.attackRange = options.attackRange ?? 50;
+				this.dodgeChance = 0;
+				this.dodgeCooldown = options.dodgeCooldown ?? 5e3;
+				this.fleeThreshold = options.fleeThreshold ?? .1;
+				break;
+			case EnemyType.Berserker:
+				this.attackCooldown = options.attackCooldown ?? 800;
+				this.visionRange = options.visionRange ?? 180;
+				this.attackRange = options.attackRange ?? 55;
+				this.dodgeChance = options.dodgeChance ?? .15;
+				this.dodgeCooldown = options.dodgeCooldown ?? 2500;
+				this.fleeThreshold = options.fleeThreshold ?? .05;
+				break;
+			default:
+				this.attackCooldown = options.attackCooldown ?? 1e3;
+				this.visionRange = options.visionRange ?? 150;
+				this.attackRange = options.attackRange ?? 60;
+				this.dodgeChance = options.dodgeChance ?? .2;
+				this.dodgeCooldown = options.dodgeCooldown ?? 2e3;
+				this.fleeThreshold = options.fleeThreshold ?? .2;
+		}
+	}
+	/**
+	* Setup vision detection
+	*/
+	setupVision() {
+		if (this.visionShape) return true;
+		const map = this.event.getCurrentMap?.();
+		if (map?.physic?.getEntityByUUID && !map.physic.getEntityByUUID(this.event.id)) {
+			this.traceLog("vision", "physics body not ready", {
+				retries: this.visionSetupRetries,
+				hasMap: !!map
+			});
+			return false;
+		}
+		const diameter = this.visionRange * 2;
+		const shape = this.event.attachShape(`vision_${this.event.id}`, {
+			radius: this.visionRange,
+			width: diameter,
+			height: diameter,
+			angle: 360
+		});
+		if (!shape) {
+			this.traceLog("vision", "attachShape returned no shape", {
+				retries: this.visionSetupRetries,
+				visionRange: this.visionRange
+			});
+			return false;
+		}
+		this.visionShape = shape;
+		this.traceLog("vision", "vision attached", {
+			shapeId: shape?.id,
+			visionRange: this.visionRange
+		});
+		return true;
+	}
+	scheduleVisionSetup() {
+		if (this.destroyed || this.setupVision()) return;
+		if (this.visionSetupRetries >= this.maxVisionSetupRetries) {
+			this.traceLog("vision", "vision setup gave up", { retries: this.visionSetupRetries });
+			return;
+		}
+		this.visionSetupRetries++;
+		this.schedule(() => {
+			if (this.destroyed || !this.event.getCurrentMap()) return;
+			this.scheduleVisionSetup();
+		}, 50);
+	}
+	/**
+	* Start the AI behavior loop
+	*/
+	startAiBehaviorLoop() {
+		const updateInterval = setInterval(() => {
+			if (!this.event.getCurrentMap()) {
+				this.destroy();
+				return;
+			}
+			this.updateAiBehavior();
+		}, 100);
+		this.updateInterval = updateInterval;
+	}
+	/**
+	* Change AI state with validated transitions
+	*/
+	changeState(newState) {
+		if (newState === this.state) return;
+		if (!{
+			[AiState.Idle]: [AiState.Alert, AiState.Combat],
+			[AiState.Alert]: [AiState.Idle, AiState.Combat],
+			[AiState.Combat]: [
+				AiState.Idle,
+				AiState.Flee,
+				AiState.Stunned
+			],
+			[AiState.Flee]: [AiState.Idle, AiState.Combat],
+			[AiState.Stunned]: [AiState.Combat, AiState.Idle]
+		}[this.state].includes(newState)) {
+			this.debugLog("state", `INVALID transition ${this.state} -> ${newState}`);
+			this.traceLog("state", "invalid transition", {
+				from: this.state,
+				to: newState
+			});
+			return;
+		}
+		this.debugLog("state", `STATE change: ${this.state} -> ${newState}`);
+		this.traceLog("state", "state change", {
+			from: this.state,
+			to: newState,
+			targetId: this.target?.id
+		});
+		this.state = newState;
+		this.stateStartTime = Date.now();
+		switch (newState) {
+			case AiState.Idle:
+				if (this.patrolWaypoints.length > 0) this.startPatrol();
+				break;
+			case AiState.Alert:
+				this.event.stopMoveTo();
+				break;
+			case AiState.Combat:
+				this.comboCount = 0;
+				break;
+			case AiState.Flee:
+				if (this.target) this.fleeFromTarget();
+				break;
+			case AiState.Stunned:
+				this.event.stopMoveTo();
+				break;
+		}
+	}
+	/**
+	* Main AI behavior update loop
+	*/
+	updateAiBehavior() {
+		const currentTime = Date.now();
+		if (this.target && this.isTargetDefeated(this.target)) {
+			this.debugLog("combat", `Target ${this.target.id} is defeated, returning to idle`);
+			this.clearTarget();
+			this.changeState(AiState.Idle);
+			this.checkDamageTaken();
+			return;
+		}
+		if (this.groupBehavior) this.updateGroupBehavior();
+		if (this.state === AiState.Stunned) {
+			if (currentTime >= this.stunnedUntil) this.changeState(AiState.Combat);
+			return;
+		}
+		if (currentTime < this.actionLockedUntil) {
+			if (this.target) this.faceTarget();
+			if (currentTime - this.lastActionLockTraceTime > 250) {
+				this.lastActionLockTraceTime = currentTime;
+				this.traceLog("state", "waiting action recovery", {
+					remainingMs: this.actionLockedUntil - currentTime,
+					state: this.state,
+					targetId: this.target?.id
+				});
+			}
+			this.checkDamageTaken();
+			return;
+		}
+		if (this.enemyType === EnemyType.Berserker && this.event.param[MAXHP]) {
+			const hpPercent = this.event.hp / this.event.param[MAXHP];
+			const berserkerModifier = Math.max(.3, hpPercent);
+			this.attackCooldown = 800 * berserkerModifier;
+		}
+		if (this.behaviorEnabled) this.updateBehavior(currentTime);
+		if (!this.target && this.state === AiState.Idle) {
+			const target = this.findNearestTarget();
+			if (target) this.engageTarget(target);
+		}
+		if (this.applyCustomBehavior(currentTime)) {
+			this.checkDamageTaken();
+			return;
+		}
+		switch (this.state) {
+			case AiState.Idle:
+				this.updateIdleBehavior();
+				break;
+			case AiState.Alert:
+				this.updateAlertBehavior();
+				break;
+			case AiState.Combat:
+				this.updateCombatBehavior(currentTime);
+				break;
+			case AiState.Flee:
+				this.updateFleeBehavior();
+				break;
+		}
+		this.checkDamageTaken();
+	}
+	/**
+	* Update idle behavior (patrolling)
+	*/
+	updateIdleBehavior() {
+		const target = this.findNearestTarget();
+		if (target) {
+			this.engageTarget(target);
+			return;
+		}
+		if (this.patrolWaypoints.length > 0) {
+			const waypoint = this.patrolWaypoints[this.currentPatrolIndex];
+			if (this.getDistance(this.event, {
+				x: () => waypoint.x,
+				y: () => waypoint.y
+			}) < 10) {
+				this.currentPatrolIndex = (this.currentPatrolIndex + 1) % this.patrolWaypoints.length;
+				this.startPatrol();
+			}
+		}
+	}
+	/**
+	* Update alert behavior
+	*/
+	updateAlertBehavior() {
+		if (this.target) {
+			this.faceTarget();
+			const distance = this.getDistance(this.event, this.target);
+			this.traceLog("movement", "alert update", {
+				targetId: this.target.id,
+				distance,
+				attackRange: this.attackRange,
+				visionRange: this.visionRange,
+				isMovingToTarget: this.isMovingToTarget
+			});
+			if (distance <= this.attackRange * 1.5) {
+				if (this.isMovingToTarget) {
+					this.isMovingToTarget = false;
+					this.event.stopMoveTo();
+				}
+				this.changeState(AiState.Combat);
+			} else if (distance <= this.visionRange * 1.5) {
+				if (!this.isMovingToTarget) {
+					this.debugLog("movement", `Alert approach (dist=${distance.toFixed(1)}, attackRange=${this.attackRange})`);
+					this.requestTargetMovement();
+				}
+			} else {
+				this.debugLog("combat", `Alert target out of range (dist=${distance.toFixed(1)})`);
+				this.clearTarget();
+				this.changeState(AiState.Idle);
+			}
+		} else this.changeState(AiState.Idle);
+	}
+	/**
+	* Update combat behavior
+	*/
+	updateCombatBehavior(currentTime) {
+		if (!this.target) {
+			this.debugLog("combat", "No target, returning to idle");
+			this.changeState(AiState.Idle);
+			return;
+		}
+		const distance = this.getDistance(this.event, this.target);
+		this.traceLog("combat", "combat update", {
+			targetId: this.target.id,
+			distance,
+			attackRange: this.attackRange,
+			visionRange: this.visionRange,
+			isMovingToTarget: this.isMovingToTarget,
+			behaviorEnabled: this.behaviorEnabled,
+			behaviorMode: this.behaviorMode
+		});
+		if (distance > this.visionRange * 1.5) {
+			this.debugLog("combat", `Target out of range (dist=${distance.toFixed(1)}, maxRange=${(this.visionRange * 1.5).toFixed(1)})`);
+			this.clearTarget();
+			this.changeState(AiState.Idle);
+			return;
+		}
+		if (this.event.param[MAXHP]) {
+			const hpPercent = this.event.hp / this.event.param[MAXHP];
+			if (hpPercent <= this.fleeThreshold) {
+				this.debugLog("combat", `HP low (${(hpPercent * 100).toFixed(0)}%), fleeing`);
+				this.isMovingToTarget = false;
+				this.changeState(AiState.Flee);
+				return;
+			}
+		}
+		if (this.canDodge() && this.shouldDodge()) {
+			this.debugLog("combat", "Attempting dodge");
+			if (this.tryDodge()) {
+				this.isMovingToTarget = false;
+				return;
+			}
+		}
+		if (this.behaviorEnabled) {
+			if (this.behaviorMode === "tactical") this.handleTacticalMovement(distance);
+			else if (this.behaviorMode === "assault") this.handleAssaultMovement(distance);
+			else if (this.behaviorMode === "retreat") {
+				this.isMovingToTarget = false;
+				this.fleeFromTarget();
+				return;
+			}
+		}
+		if (this.behaviorEnabled && this.behaviorMode === "assault") {} else if (this.behaviorEnabled && this.behaviorMode === "tactical") {} else if (this.enemyType === EnemyType.Ranged) {
+			if (distance < this.attackRange * .6) {
+				this.debugLog("movement", `Retreating (dist=${distance.toFixed(1)}, minRange=${(this.attackRange * .6).toFixed(1)})`);
+				this.isMovingToTarget = false;
+				this.retreatFromTarget();
+			} else if (distance > this.attackRange) {
+				if (!this.isMovingToTarget) {
+					this.debugLog("movement", `Moving to target (dist=${distance.toFixed(1)}, attackRange=${this.attackRange})`);
+					this.requestTargetMovement();
+				}
+			} else if (this.isMovingToTarget) {
+				this.debugLog("movement", `In range, stopping (dist=${distance.toFixed(1)})`);
+				this.isMovingToTarget = false;
+				this.event.stopMoveTo();
+			}
+		} else if (distance > this.attackRange) {
+			if (!this.isMovingToTarget) {
+				this.debugLog("movement", `Moving to target (dist=${distance.toFixed(1)}, attackRange=${this.attackRange})`);
+				this.requestTargetMovement();
+			}
+		} else if (this.isMovingToTarget) {
+			this.debugLog("movement", `In range, stopping (dist=${distance.toFixed(1)})`);
+			this.isMovingToTarget = false;
+			this.event.stopMoveTo();
+		}
+		if (distance <= this.attackRange && currentTime - this.lastAttackTime >= this.attackCooldown) {
+			if (!this.chargingAttack) {
+				this.debugLog("attack", `Attacking (dist=${distance.toFixed(1)}, cooldown=${this.attackCooldown}ms)`);
+				this.selectAndPerformAttack();
+				this.lastAttackTime = currentTime;
+			}
+		}
+	}
+	/**
+	* Update flee behavior
+	*/
+	updateFleeBehavior() {
+		if (!this.target) {
+			this.changeState(AiState.Idle);
+			return;
+		}
+		const distance = this.getDistance(this.event, this.target);
+		if (this.event.param[MAXHP]) {
+			if (this.event.hp / this.event.param[MAXHP] > this.fleeThreshold * 1.5 || distance > this.visionRange * 2) {
+				this.changeState(AiState.Combat);
+				return;
+			}
+		}
+		this.fleeFromTarget();
+	}
+	/**
+	* Select and perform an attack pattern
+	*/
+	selectAndPerformAttack() {
+		if (!this.target) return;
+		if (this.comboCount > 0 && this.comboCount < this.comboMax) {
+			this.debugLog("attack", `Continuing combo (${this.comboCount}/${this.comboMax})`);
+			this.performComboAttack();
+			return;
+		}
+		const pattern = this.selectAttackPattern();
+		this.debugLog("attack", `Selected pattern: ${pattern}`);
+		this.performAttackPattern(pattern);
+	}
+	/**
+	* Select attack pattern with weighted probability
+	*/
+	selectAttackPattern() {
+		const weights = {
+			[AttackPattern.Melee]: 40,
+			[AttackPattern.Combo]: 25,
+			[AttackPattern.Charged]: 15,
+			[AttackPattern.Zone]: 10,
+			[AttackPattern.DashAttack]: 10
+		};
+		switch (this.enemyType) {
+			case EnemyType.Aggressive:
+				weights[AttackPattern.Combo] += 20;
+				weights[AttackPattern.DashAttack] += 15;
+				break;
+			case EnemyType.Defensive:
+				weights[AttackPattern.Charged] += 25;
+				break;
+			case EnemyType.Ranged:
+				weights[AttackPattern.Zone] += 20;
+				break;
+			case EnemyType.Tank:
+				weights[AttackPattern.Charged] += 30;
+				weights[AttackPattern.Zone] += 15;
+				break;
+			case EnemyType.Berserker:
+				weights[AttackPattern.Combo] += 35;
+				break;
+		}
+		let total = 0;
+		const available = [];
+		this.attackPatterns.forEach((p) => {
+			const weight = weights[p] || 10;
+			total += weight;
+			available.push({
+				pattern: p,
+				weight
+			});
+		});
+		let random = Math.random() * total;
+		for (const item of available) {
+			random -= item.weight;
+			if (random <= 0) return item.pattern;
+		}
+		return this.attackPatterns[0] || AttackPattern.Melee;
+	}
+	/**
+	* Perform attack pattern
+	*/
+	performAttackPattern(pattern) {
+		switch (pattern) {
+			case AttackPattern.Melee:
+				this.performMeleeAttack();
+				break;
+			case AttackPattern.Combo:
+				this.performComboAttack();
+				break;
+			case AttackPattern.Charged:
+				this.performChargedAttack();
+				break;
+			case AttackPattern.Zone:
+				this.performZoneAttack();
+				break;
+			case AttackPattern.DashAttack:
+				this.performDashAttack();
+				break;
+		}
+	}
+	/**
+	* Perform melee attack
+	* Uses skill if configured, otherwise creates hitbox
+	*/
+	performMeleeAttack() {
+		if (!this.target) return;
+		const profile = this.getAttackProfile(AttackPattern.Melee);
+		this.faceTarget({ force: true });
+		this.lockForAttack(profile, AttackPattern.Melee);
+		this.telegraphAttack(profile);
+		this.playAttackVisual(profile, AttackPattern.Melee);
+		this.scheduleAttackStartup(profile, () => {
+			this.executeMeleeAttack(profile, AttackPattern.Melee);
+		});
+	}
+	executeMeleeAttack(profile, pattern) {
+		if (!this.target || this.isTargetDefeated(this.target)) return;
+		this.debugLog("attack", `Applying ${pattern} hit`);
+		if (this.attackSkill) {
+			const resolvedSkill = this.resolveUsable(this.attackSkill);
+			try {
+				executeActionBattleUse({
+					attacker: this.event,
+					target: this.target,
+					usable: resolvedSkill,
+					skill: resolvedSkill,
+					pattern,
+					profile
+				});
+			} catch (e) {
+				this.performBasicHitbox(profile, pattern);
+			}
+			return;
+		}
+		const weapon = resolveActionBattleWeapon(this.event);
+		if (weapon && executeActionBattleUse({
+			attacker: this.event,
+			target: this.target,
+			usable: weapon,
+			weapon,
+			pattern,
+			profile
+		})) return;
+		this.performBasicHitbox(profile, pattern);
+	}
+	/**
+	* Perform basic hitbox attack when no skill is set
+	*/
+	performBasicHitbox(profile = this.getAttackProfile(AttackPattern.Melee), pattern = AttackPattern.Melee) {
+		if (!this.target || this.isTargetDefeated(this.target)) return;
+		const hitTracker = new ActionBattleHitTracker(profile.hitPolicy);
+		runActionBattleActiveHitbox({
+			...profile,
+			startupMs: 0
+		}, () => this.resolveBasicHitboxes(), (hitboxes) => {
+			this.processHitboxHits(hitboxes, hitTracker, profile, pattern);
+		}, (scheduled, delay) => this.schedule(scheduled, delay));
+	}
+	resolveBasicHitboxes() {
+		if (!this.target || this.isTargetDefeated(this.target)) return [];
+		const eventX = this.event.x();
+		const eventY = this.event.y();
+		const dx = this.target.x() - eventX;
+		const dy = this.target.y() - eventY;
+		const dist = Math.sqrt(dx * dx + dy * dy);
+		if (dist === 0) return [];
+		const dirX = dx / dist;
+		const dirY = dy / dist;
+		return [{
+			x: eventX + dirX * 30,
+			y: eventY + dirY * 30,
+			width: 40,
+			height: 40
+		}];
+	}
+	queryHitboxCandidates(hitboxes) {
+		const map = this.event.getCurrentMap();
+		if (!map || typeof map.queryHitbox !== "function") return [];
+		const candidates = /* @__PURE__ */ new Map();
+		for (const hitbox of hitboxes) for (const hit of map.queryHitbox(hitbox, {
+			excludeIds: [this.event.id],
+			kinds: ["players", "events"]
+		})) if (hit?.id) candidates.set(hit.id, hit);
+		return Array.from(candidates.values());
+	}
+	processHitboxHits(hitboxes, hitTracker, profile, pattern) {
+		for (const hit of this.queryHitboxCandidates(hitboxes)) if (hit !== this.event && this.canTarget(hit) && !this.isTargetDefeated(hit) && hitTracker.tryHit(hit)) this.applyHit(hit, void 0, profile, pattern);
+	}
+	/**
+	* Apply hit to target using RPGJS damage system with knockback
+	* 
+	* Calculates damage using RPGJS formula, applies knockback based on
+	* equipped weapon's knockbackForce property, and triggers visual effects.
+	* Supports hooks for customizing behavior.
+	* 
+	* @param target - The player or entity being hit
+	* @param hooks - Optional hooks for customizing hit behavior
+	* @returns The hit result containing damage and knockback info
+	* 
+	* @example
+	* ```ts
+	* // Basic hit
+	* this.applyHit(player);
+	* 
+	* // With custom hooks
+	* this.applyHit(player, {
+	*   onBeforeHit(result) {
+	*     result.knockbackForce *= 1.5; // Increase knockback
+	*     return result;
+	*   },
+	*   onAfterHit(result) {
+	*     console.log(`Dealt ${result.damage} damage!`);
+	*   }
+	* });
+	* ```
+	*/
+	applyHit(target, hooks, profile = this.getAttackProfile(AttackPattern.Melee), pattern = AttackPattern.Melee) {
+		if (this.isTargetDefeated(target)) return {
+			damage: 0,
+			knockbackForce: 0,
+			knockbackDuration: 0,
+			defeated: true,
+			attacker: this.event,
+			target
+		};
+		if (isActionBattleEntityInvincible(target)) return {
+			damage: 0,
+			knockbackForce: 0,
+			knockbackDuration: 0,
+			defeated: false,
+			attacker: this.event,
+			target
+		};
+		const { damage } = target.applyDamage(this.event);
+		let hitResult = {
+			damage,
+			knockbackForce: this.getWeaponKnockbackForce(),
+			knockbackDuration: DEFAULT_KNOCKBACK.duration,
+			defeated: target.hp <= 0,
+			attacker: this.event,
+			target
+		};
+		if (hooks?.onBeforeHit) {
+			const modified = hooks.onBeforeHit(hitResult);
+			if (modified) hitResult = modified;
+		}
+		withActionBattleAnimationUnlocked(target, () => {
+			emitActionBattleClientVisual({
+				moment: "hurt",
+				entity: this.event,
+				target,
+				attacker: this.event,
+				damage: hitResult.damage,
+				result: hitResult
+			});
+		});
+		setActionBattleInvincibility(target, profile.reaction.invincibilityMs);
+		if (hitResult.knockbackForce > 0) {
+			const dx = target.x() - this.event.x();
+			const dy = target.y() - this.event.y();
+			const distance = Math.sqrt(dx * dx + dy * dy);
+			if (distance > 0) {
+				const knockbackDirection = {
+					x: dx / distance,
+					y: dy / distance
+				};
+				target.knockback(knockbackDirection, hitResult.knockbackForce, hitResult.knockbackDuration);
+			}
+		}
+		if (hooks?.onAfterHit) hooks.onAfterHit(hitResult);
+		const targetAi = target.battleAi;
+		if (targetAi) targetAi.handleDamage(this.event, {
+			damage: hitResult.damage,
+			defeated: hitResult.defeated,
+			raw: void 0,
+			reaction: profile.reaction
+		});
+		return hitResult;
+	}
+	/**
+	* Get knockback force from equipped weapon
+	* 
+	* Retrieves the knockbackForce property from the event's equipped weapon.
+	* Falls back to DEFAULT_KNOCKBACK.force if no weapon or property is set.
+	* 
+	* @returns Knockback force value
+	* 
+	* @example
+	* ```ts
+	* // Weapon with knockbackForce: 80
+	* const force = this.getWeaponKnockbackForce(); // 80
+	* 
+	* // No weapon equipped
+	* const force = this.getWeaponKnockbackForce(); // 50 (default)
+	* ```
+	*/
+	getWeaponKnockbackForce() {
+		try {
+			const equipments = this.event.equipments?.() || [];
+			for (const item of equipments) {
+				const itemData = this.event.databaseById?.(item.id());
+				if (itemData?._type === "weapon" && itemData.knockbackForce !== void 0) return itemData.knockbackForce;
+			}
+		} catch {}
+		return DEFAULT_KNOCKBACK.force;
+	}
+	/**
+	* Perform combo attack
+	*/
+	performComboAttack() {
+		if (!this.target) return;
+		this.comboCount++;
+		const profile = this.getAttackProfile(AttackPattern.Combo);
+		this.faceTarget({ force: true });
+		this.lockForAttack(profile, AttackPattern.Combo);
+		this.telegraphAttack(profile);
+		this.playAttackVisual(profile, AttackPattern.Combo);
+		this.scheduleAttackStartup(profile, () => {
+			this.executeMeleeAttack(profile, AttackPattern.Combo);
+		});
+		if (this.comboCount < this.comboMax) this.schedule(() => {
+			if (this.target && this.state === AiState.Combat) this.performComboAttack();
+			else this.comboCount = 0;
+		}, 300);
+		else this.comboCount = 0;
+	}
+	/**
+	* Perform charged attack
+	*/
+	performChargedAttack() {
+		if (!this.target) return;
+		const profile = this.getAttackProfile(AttackPattern.Charged);
+		this.chargingAttack = true;
+		this.faceTarget({ force: true });
+		this.lockForAttack(profile, AttackPattern.Charged);
+		this.telegraphAttack(profile);
+		this.playAttackVisual(profile, AttackPattern.Charged, { repeat: 2 });
+		this.scheduleAttackStartup(profile, () => {
+			if (!this.target || this.state !== AiState.Combat) {
+				this.chargingAttack = false;
+				return;
+			}
+			this.executeMeleeAttack(profile, AttackPattern.Charged);
+		});
+		this.schedule(() => {
+			this.chargingAttack = false;
+		}, profile.totalDurationMs);
+	}
+	/**
+	* Perform zone attack (360 degrees)
+	*/
+	performZoneAttack() {
+		const profile = this.getAttackProfile(AttackPattern.Zone);
+		this.lockForAttack(profile, AttackPattern.Zone);
+		this.telegraphAttack(profile);
+		this.playAttackVisual(profile, AttackPattern.Zone);
+		const eventX = this.event.x();
+		const eventY = this.event.y();
+		const radius = 50;
+		const hitboxes = [];
+		[
+			0,
+			90,
+			180,
+			270
+		].forEach((angle) => {
+			const rad = angle * Math.PI / 180;
+			hitboxes.push({
+				x: eventX + Math.cos(rad) * radius,
+				y: eventY + Math.sin(rad) * radius,
+				width: 40,
+				height: 40
+			});
+		});
+		this.scheduleAttackStartup(profile, () => {
+			const hitTracker = new ActionBattleHitTracker(profile.hitPolicy);
+			runActionBattleActiveHitbox({
+				...profile,
+				startupMs: 0
+			}, () => hitboxes, (activeHitboxes) => {
+				this.processHitboxHits(activeHitboxes, hitTracker, profile, AttackPattern.Zone);
+			}, (scheduled, delay) => this.schedule(scheduled, delay));
+		});
+	}
+	/**
+	* Perform dash attack
+	*/
+	performDashAttack() {
+		if (!this.target || this.isTargetDefeated(this.target)) return;
+		const profile = this.getAttackProfile(AttackPattern.DashAttack);
+		const dx = this.target.x() - this.event.x();
+		const dy = this.target.y() - this.event.y();
+		const dist = Math.sqrt(dx * dx + dy * dy);
+		if (dist === 0) return;
+		const dirX = dx / dist;
+		const dirY = dy / dist;
+		this.faceTarget({ force: true });
+		this.lockForAttack(profile, AttackPattern.DashAttack);
+		this.telegraphAttack(profile);
+		this.playAttackVisual(profile, AttackPattern.DashAttack);
+		this.scheduleAttackStartup(profile, () => {
+			if (!this.target || this.state !== AiState.Combat) return;
+			safeActionBattleDash(this.event, {
+				x: dirX,
+				y: dirY
+			}, 10, 200);
+			this.schedule(() => {
+				if (!this.target || this.state !== AiState.Combat) return;
+				this.executeMeleeAttack(profile, AttackPattern.DashAttack);
+			}, 200);
+		});
+	}
+	getAttackProfile(pattern) {
+		return this.attackProfiles[pattern] ?? this.attackProfiles.melee;
+	}
+	playAttackVisual(profile, pattern, animationDefaults) {
+		const moment = profile.animationKey === "castSkill" || profile.animationKey === "castSpell" ? "castSkill" : "attack";
+		withActionBattleAnimationUnlocked(this.event, () => {
+			emitActionBattleClientVisual({
+				moment,
+				entity: this.event,
+				target: this.target ?? void 0,
+				pattern,
+				animations: this.animations,
+				animationDefaults
+			});
+		});
+	}
+	telegraphAttack(profile) {
+		if (profile.startupMs <= 0) return;
+		this.event.flash({
+			type: "tint",
+			tint: "white",
+			duration: Math.min(profile.startupMs, 300),
+			cycles: 1
+		});
+	}
+	scheduleAttackStartup(profile, callback) {
+		return scheduleActionBattleStartup(profile, callback, (scheduled, delay) => this.schedule(scheduled, delay));
+	}
+	/**
+	* Face the current target with hysteresis to prevent animation flickering
+	* 
+	* Uses multiple strategies to prevent flickering:
+	* 1. When very close to target (collision), keep current direction
+	* 2. When near diagonal, require significant difference to change
+	* 3. Only change if direction is clearly wrong (opposite)
+	*/
+	faceTarget(options = {}) {
+		if (!this.target) return;
+		const dx = this.target.x() - this.event.x();
+		const dy = this.target.y() - this.event.y();
+		const absX = Math.abs(dx);
+		const absY = Math.abs(dy);
+		const distance = Math.sqrt(dx * dx + dy * dy);
+		if (this.lastFacingDirection && distance < 4) return;
+		let newDirection;
+		if (absX >= absY) newDirection = dx >= 0 ? "right" : "left";
+		else newDirection = dy >= 0 ? "down" : "up";
+		const hysteresisThreshold = .2;
+		const ratio = absX > 0 || absY > 0 ? Math.min(absX, absY) / Math.max(absX, absY) : 0;
+		if (this.lastFacingDirection && ratio > 1 - hysteresisThreshold) {
+			if (!(this.lastFacingDirection === "left" && dx > 20 || this.lastFacingDirection === "right" && dx < -20 || this.lastFacingDirection === "up" && dy > 20 || this.lastFacingDirection === "down" && dy < -20)) return;
+		}
+		this.lastFacingDirection = newDirection;
+		if (options.force) applyActionBattleAttackDirection(this.event, newDirection);
+		else this.event.changeDirection(newDirection);
+	}
+	/**
+	* Try to dodge
+	*/
+	tryDodge() {
+		const currentTime = Date.now();
+		if (currentTime - this.lastDodgeTime < this.dodgeCooldown) {
+			this.debugLog("dodge", `Dodge on cooldown (${this.dodgeCooldown - (currentTime - this.lastDodgeTime)}ms remaining)`);
+			return false;
+		}
+		if (Math.random() > this.dodgeChance) {
+			this.debugLog("dodge", `Dodge roll failed (chance=${(this.dodgeChance * 100).toFixed(0)}%)`);
+			return false;
+		}
+		if (!this.target) return false;
+		const dx = this.target.x() - this.event.x();
+		const dy = this.target.y() - this.event.y();
+		const dist = Math.sqrt(dx * dx + dy * dy);
+		if (dist === 0) return false;
+		const dodgeDirX = -dy / dist;
+		const dodgeDirY = dx / dist;
+		const side = Math.random() > .5 ? 1 : -1;
+		this.debugLog("dodge", `Dodging (dir=${side > 0 ? "right" : "left"})`);
+		if (!safeActionBattleDash(this.event, {
+			x: dodgeDirX * side,
+			y: dodgeDirY * side
+		}, 12, 300)) return false;
+		this.lastDodgeTime = currentTime;
+		if (this.enemyType === EnemyType.Defensive && Math.random() < .5) {
+			this.debugLog("dodge", "Counter-attack after dodge");
+			this.schedule(() => {
+				if (this.target && this.state === AiState.Combat) this.selectAndPerformAttack();
+			}, 400);
+		}
+		return true;
+	}
+	canDodge() {
+		if (this.dodgeChance === 0) return false;
+		return Date.now() - this.lastDodgeTime >= this.dodgeCooldown;
+	}
+	shouldDodge() {
+		if (!this.target) return false;
+		return this.getDistance(this.event, this.target) < this.attackRange * .8;
+	}
+	/**
+	* Flee from target
+	*/
+	fleeFromTarget() {
+		if (!this.target) return;
+		const dx = this.event.x() - this.target.x();
+		const dy = this.event.y() - this.target.y();
+		const dist = Math.sqrt(dx * dx + dy * dy);
+		if (dist === 0) return;
+		const fleeTarget = {
+			x: this.event.x() + dx / dist * 200,
+			y: this.event.y() + dy / dist * 200
+		};
+		this.requestMoveTo(fleeTarget);
+	}
+	/**
+	* Retreat from target (temporary)
+	*/
+	retreatFromTarget() {
+		if (!this.target) return;
+		const currentTime = Date.now();
+		if (currentTime - this.lastRetreatTime < this.retreatCooldown) return;
+		const dx = this.event.x() - this.target.x();
+		const dy = this.event.y() - this.target.y();
+		const dist = Math.sqrt(dx * dx + dy * dy);
+		if (dist === 0) return;
+		if (!safeActionBattleDash(this.event, {
+			x: dx / dist,
+			y: dy / dist
+		}, 8, 200)) return;
+		this.lastRetreatTime = currentTime;
+	}
+	/**
+	* Check damage taken for retreat decision
+	*/
+	checkDamageTaken() {
+		const currentTime = Date.now();
+		if (currentTime - this.lastHpCheck >= this.damageCheckInterval) {
+			this.recentDamageTaken = 0;
+			this.lastHpCheck = currentTime;
+		}
+	}
+	/**
+	* Start patrol
+	*/
+	startPatrol() {
+		if (this.patrolWaypoints.length === 0) return;
+		const waypoint = this.patrolWaypoints[this.currentPatrolIndex];
+		this.requestMoveTo({
+			x: waypoint.x,
+			y: waypoint.y
+		});
+	}
+	/**
+	* Update group behavior
+	*/
+	updateGroupBehavior() {
+		if (!this.groupBehavior) return;
+		this.groupUpdateInterval++;
+		if (this.groupUpdateInterval >= 20) {
+			this.groupUpdateInterval = 0;
+			this.findNearbyEnemies();
+		}
+		if (this.nearbyEnemies.length > 0 && this.target && this.state === AiState.Combat) this.applyFormation();
+	}
+	/**
+	* Find nearby enemies
+	*/
+	findNearbyEnemies() {
+		this.nearbyEnemies = [];
+		const map = this.event.getCurrentMap();
+		if (!map) return;
+		const allEvents = Object.values(map.events());
+		const groupRadius = 150;
+		allEvents.forEach((event) => {
+			if (event === this.event) return;
+			const ai = event.battleAi;
+			if (ai && ai.groupBehavior) {
+				if (this.getDistance(this.event, event) <= groupRadius) this.nearbyEnemies.push(ai);
+			}
+		});
+	}
+	/**
+	* Apply formation around target
+	*/
+	applyFormation() {
+		if (!this.target || this.nearbyEnemies.length === 0) return;
+		const totalEnemies = this.nearbyEnemies.length + 1;
+		const angleStep = 2 * Math.PI / totalEnemies;
+		let ourIndex = 0;
+		for (let i = 0; i < this.nearbyEnemies.length; i++) if (this.nearbyEnemies[i].event.id < this.event.id) ourIndex++;
+		const angle = angleStep * ourIndex;
+		const formationRadius = this.attackRange * 1.2;
+		const formationX = this.target.x() + Math.cos(angle) * formationRadius;
+		const formationY = this.target.y() + Math.sin(angle) * formationRadius;
+		if (Math.sqrt(Math.pow(this.event.x() - formationX, 2) + Math.pow(this.event.y() - formationY, 2)) > 20) this.requestMoveTo({
+			x: formationX,
+			y: formationY
+		});
+	}
+	/**
+	* Handle player entering vision
+	*/
+	onDetectInShape(target, shape) {
+		const canTarget = this.canTarget(target);
+		const defeated = this.isTargetDefeated(target);
+		this.traceLog("vision", "detect in shape", {
+			targetId: target?.id,
+			shapeId: shape?.id,
+			canTarget,
+			defeated,
+			state: this.state,
+			targetHp: target?.hp
+		});
+		if (!canTarget || defeated) return;
+		this.debugLog("vision", `Target ${target.id} entered vision (state=${this.state})`);
+		this.engageTarget(target);
+	}
+	engageTarget(target) {
+		this.traceLog("target", "engage target", {
+			targetId: target.id,
+			previousTargetId: this.target?.id,
+			state: this.state,
+			distance: this.getDistance(this.event, target)
+		});
+		this.target = target;
+		if (this.state === AiState.Idle) this.changeState(AiState.Alert);
+		else if (this.state === AiState.Alert) this.changeState(AiState.Combat);
+	}
+	/**
+	* Handle player leaving vision
+	*/
+	onDetectOutShape(target, shape) {
+		this.debugLog("vision", `Target ${target.id} left vision (wasTarget=${this.target === target})`);
+		this.traceLog("vision", "detect out shape", {
+			targetId: target?.id,
+			shapeId: shape?.id,
+			wasTarget: this.target === target,
+			state: this.state
+		});
+		if (this.target === target) {
+			this.clearTarget();
+			this.changeState(AiState.Idle);
+		}
+	}
+	/**
+	* Handle taking damage (called from server.ts)
+	* 
+	* This triggers state changes like stun and flee check.
+	* The actual damage is applied externally via RPGJS API.
+	*/
+	takeDamage(attacker) {
+		if (this.defeated) return true;
+		const raw = this.event.applyDamage(attacker);
+		return this.handleDamage(attacker, {
+			damage: raw.damage ?? 0,
+			defeated: this.event.hp <= 0,
+			raw
+		});
+	}
+	handleDamage(attacker, damageResult) {
+		if (this.defeated) return true;
+		const damage = Number.isFinite(damageResult.damage) ? damageResult.damage : 0;
+		this.debugLog("damage", `Took ${damage} damage from ${attacker.id} (HP: ${this.event.hp}/${this.event.param[MAXHP] || "?"})`);
+		const canRetaliate = attacker ? this.canTarget(attacker) : false;
+		const attackerDefeated = this.isTargetDefeated(attacker);
+		this.traceLog("damage", "handle damage", {
+			attackerId: attacker?.id,
+			damage,
+			defeated: damageResult.defeated,
+			eventHp: this.event.hp,
+			maxHp: this.event.param[MAXHP],
+			state: this.state,
+			canRetaliate,
+			attackerDefeated,
+			currentTargetId: this.target?.id
+		});
+		withActionBattleAnimationUnlocked(this.event, () => {
+			emitActionBattleClientVisual({
+				moment: "hurt",
+				entity: this.event,
+				target: this.event,
+				attacker,
+				damage,
+				defeated: damageResult.defeated,
+				result: damageResult,
+				animations: this.animations
+			});
+		});
+		this.recentDamageTaken += damage;
+		if (attacker && this.canTarget(attacker) && !this.isTargetDefeated(attacker) && this.state !== AiState.Flee) {
+			this.traceLog("target", "retaliate against attacker", {
+				attackerId: attacker.id,
+				previousTargetId: this.target?.id,
+				state: this.state
+			});
+			this.target = attacker;
+			if (this.state === AiState.Idle || this.state === AiState.Alert) {
+				this.isMovingToTarget = false;
+				this.changeState(AiState.Combat);
+			}
+		}
+		const reaction = damageResult.reaction;
+		const staggerPower = reaction?.staggerPower ?? damage;
+		const hitstunMs = reaction?.hitstunMs ?? this.hitstunMs;
+		const shouldStun = (damage > 0 || (reaction?.staggerPower ?? 0) > 0) && staggerPower >= this.poise && hitstunMs > 0;
+		this.lockActionUntil(Date.now() + Math.max(220, hitstunMs + 120), "damage recovery", {
+			attackerId: attacker?.id,
+			damage,
+			hitstunMs
+		});
+		setActionBattleInvincibility(this.event, reaction?.invincibilityMs ?? this.invincibilityMs);
+		if (shouldStun && this.state !== AiState.Stunned && this.state !== AiState.Flee) {
+			this.debugLog("damage", "Stunned from damage");
+			this.isMovingToTarget = false;
+			this.stunnedUntil = Date.now() + hitstunMs;
+			this.changeState(AiState.Stunned);
+		}
+		if (damageResult.defeated || this.event.hp <= 0) {
+			this.debugLog("damage", "Defeated!");
+			this.kill(attacker);
+			return true;
+		}
+		return false;
+	}
+	/**
+	* Kill this AI
+	* 
+	* Stops all movements, cleans up resources, calls the onDefeated hook,
+	* and removes the event from the map.
+	*/
+	kill(attacker) {
+		if (this.defeated) return;
+		this.defeated = true;
+		const dieAnimation = resolveActionBattleAnimation("die", this.event, this.animations, { attacker });
+		const removeDelay = getActionBattleAnimationRemovalDelay(dieAnimation);
+		const reward = createDefeatReward(this.rewards);
+		let removed = false;
+		const remove = () => {
+			if (removed) return;
+			removed = true;
+			this.event.remove({
+				reason: "defeated",
+				data: { animation: dieAnimation },
+				transition: dieAnimation ? {
+					animation: dieAnimation.animationName,
+					graphic: dieAnimation.graphic,
+					duration: removeDelay
+				} : void 0,
+				timeoutMs: removeDelay
+			});
+		};
+		if (this.autoAwardRewards && attacker && isActionBattlePlayer(attacker)) reward.giveTo(attacker);
+		const context = {
+			event: this.event,
+			attacker,
+			reward,
+			remove
+		};
+		if (this.onDefeatedCallback) if (this.onDefeatedCallback.length >= 2) this.onDefeatedCallback(this.event, attacker);
+		else this.onDefeatedCallback(context);
+		this.destroy();
+		remove();
+	}
+	/**
+	* Get distance between entities
+	*/
+	getDistance(entity1, entity2) {
+		const dx = entity1.x() - entity2.x();
+		const dy = entity1.y() - entity2.y();
+		return Math.sqrt(dx * dx + dy * dy);
+	}
+	resolveUsable(usable) {
+		if (!usable) return usable;
+		const id = typeof usable === "string" ? usable : usable.id;
+		const learned = id ? this.event.getSkill?.(id) : void 0;
+		if (learned) return learned;
+		try {
+			return id ? this.event.databaseById?.(id) ?? usable : usable;
+		} catch {
+			return usable;
+		}
+	}
+	getCurrentActionRange() {
+		const skillRange = this.attackSkill ? getActionBattleActionRange(this.resolveUsable(this.attackSkill)) : void 0;
+		if (skillRange !== void 0) return skillRange;
+		return getActionBattleActionRange(resolveActionBattleWeapon(this.event));
+	}
+	canTarget(target) {
+		return canActionBattleTarget(this.event, target, this.targets, getActionBattleOptions().combat?.targets);
+	}
+	findNearestTarget() {
+		const map = this.event.getCurrentMap();
+		if (!map) {
+			this.traceLog("target", "find nearest skipped: no map");
+			return null;
+		}
+		const candidates = [];
+		map.getPlayers?.().forEach((player) => candidates.push(player));
+		map.getEvents?.().forEach((event) => candidates.push(event));
+		let nearest = null;
+		let nearestDistance = Number.POSITIVE_INFINITY;
+		for (const candidate of candidates) {
+			if (!this.canTarget(candidate)) continue;
+			const distance = this.getDistance(this.event, candidate);
+			if (distance > this.visionRange) continue;
+			if (distance < nearestDistance) {
+				nearest = candidate;
+				nearestDistance = distance;
+			}
+		}
+		const now = Date.now();
+		if (nearest) this.traceLog("target", "nearest target found", {
+			targetId: nearest.id,
+			distance: nearestDistance,
+			visionRange: this.visionRange,
+			candidates: candidates.length
+		});
+		else if (now - this.lastNoTargetTraceTime > 1e3) {
+			this.lastNoTargetTraceTime = now;
+			this.traceLog("target", "no target found", {
+				visionRange: this.visionRange,
+				candidates: candidates.map((candidate) => {
+					const distance = this.getDistance(this.event, candidate);
+					return {
+						id: candidate.id,
+						hp: candidate.hp,
+						canTarget: this.canTarget(candidate),
+						defeated: this.isTargetDefeated(candidate),
+						distance
+					};
+				})
+			});
+		}
+		return nearest;
+	}
+	isTargetDefeated(target) {
+		return !target || target.hp <= 0;
+	}
+	clearTarget() {
+		this.target = null;
+		this.isMovingToTarget = false;
+		this.event.stopMoveTo();
+	}
+	updateBehavior(currentTime) {
+		if (currentTime - this.behaviorLastUpdate < this.behaviorUpdateInterval) return;
+		this.behaviorLastUpdate = currentTime;
+		let score = this.behaviorScore;
+		const maxHp = this.event.param[MAXHP];
+		if (maxHp) {
+			const hpPercent = this.event.hp / maxHp;
+			score += (hpPercent - .5) * 40;
+		}
+		if (this.recentDamageTaken > 0) score -= Math.min(30, this.recentDamageTaken * .5);
+		if (this.target) {
+			const distance = this.getDistance(this.event, this.target);
+			if (distance <= this.attackRange) score += 10;
+			else if (distance > this.visionRange) score -= 10;
+		}
+		if (this.groupBehavior && this.nearbyEnemies.length > 0) score += Math.min(15, this.nearbyEnemies.length * 5);
+		score = Math.max(0, Math.min(100, score));
+		this.behaviorScore = score;
+		const previousMode = this.behaviorMode;
+		if (score >= this.behaviorAssaultThreshold) this.behaviorMode = "assault";
+		else if (score <= this.behaviorRetreatThreshold) this.behaviorMode = "retreat";
+		else this.behaviorMode = "tactical";
+		if (previousMode !== this.behaviorMode) this.debugLog("state", `Behavior mode: ${previousMode} -> ${this.behaviorMode} (score=${score.toFixed(0)})`);
+		if (this.behaviorMode === "retreat" && this.state === AiState.Combat) {
+			if (currentTime - this.stateStartTime >= this.behaviorMinStateDuration) {
+				this.isMovingToTarget = false;
+				this.changeState(AiState.Flee);
+			}
+		} else if (this.behaviorMode === "assault" && this.state === AiState.Flee) {
+			if (currentTime - this.stateStartTime >= this.behaviorMinStateDuration) this.changeState(AiState.Combat);
+		}
+	}
+	applyCustomBehavior(currentTime) {
+		let handled = false;
+		if (this.behaviorTree) {
+			const result = this.behaviorTree.tick(this.createAiTreeContext(currentTime));
+			if (result.decision) handled = this.applyAiDecision(result.decision, currentTime) || handled;
+			if (result.intent) handled = this.executeAiIntents(result.intent, currentTime) || handled;
+			if (result.status === "running") handled = true;
+		}
+		if (!this.behaviorKey) return handled;
+		const behavior = getActionBattleSystems().ai.behaviors[this.behaviorKey];
+		if (!behavior) return handled;
+		const maxHp = this.event.param[MAXHP];
+		const decision = behavior({
+			event: this.event,
+			target: this.target,
+			state: this.state,
+			enemyType: this.enemyType,
+			distance: this.target ? this.getDistance(this.event, this.target) : null,
+			hpPercent: maxHp ? this.event.hp / maxHp : null,
+			now: currentTime
+		});
+		if (!decision) return handled;
+		return this.applyAiDecision(decision, currentTime) || handled;
+	}
+	applyAiDecision(decision, currentTime) {
+		if (!decision) return false;
+		let handled = false;
+		if (decision.attackCooldown !== void 0) this.attackCooldown = decision.attackCooldown;
+		if (decision.moveToCooldown !== void 0) this.moveToCooldown = decision.moveToCooldown;
+		if (decision.attackPatterns?.length) this.attackPatterns = decision.attackPatterns;
+		if (decision.mode) {
+			this.behaviorMode = decision.mode;
+			this.behaviorEnabled = true;
+		}
+		if (decision.intent) handled = this.executeAiIntents(decision.intent, currentTime);
+		return handled;
+	}
+	createAiTreeContext(currentTime) {
+		const maxHp = this.event.param[MAXHP];
+		const distance = this.target ? this.getDistance(this.event, this.target) : null;
+		return {
+			event: this.event,
+			target: this.target,
+			state: this.state,
+			enemyType: this.enemyType,
+			distance,
+			hpPercent: maxHp ? this.event.hp / maxHp : null,
+			now: currentTime,
+			self: {
+				event: this.event,
+				state: this.state,
+				enemyType: this.enemyType,
+				hpPercent: maxHp ? this.event.hp / maxHp : null,
+				attackRange: this.attackRange
+			},
+			targetInfo: this.target && distance !== null ? {
+				entity: this.target,
+				distance,
+				inAttackRange: distance <= this.attackRange,
+				visible: true
+			} : null,
+			memory: this.aiMemory
+		};
+	}
+	executeAiIntents(input, currentTime) {
+		const intents = Array.isArray(input) ? input : [input];
+		let handled = false;
+		for (const intent of intents) handled = this.executeAiIntent(intent, currentTime) || handled;
+		return handled;
+	}
+	executeAiIntent(intent, currentTime) {
+		const consumes = intent.consume !== false;
+		switch (intent.type) {
+			case "setMode":
+				this.behaviorMode = intent.mode;
+				this.behaviorEnabled = true;
+				return consumes;
+			case "idle":
+				this.isMovingToTarget = false;
+				this.event.stopMoveTo();
+				return consumes;
+			case "patrol":
+				this.startPatrol();
+				return consumes;
+			case "faceTarget":
+				this.faceTarget();
+				return consumes;
+			case "moveToTarget":
+				if (!this.target) return false;
+				this.requestTargetMovement();
+				return consumes;
+			case "fleeFromTarget":
+				if (!this.target) return false;
+				this.isMovingToTarget = false;
+				if (this.state === AiState.Combat) this.changeState(AiState.Flee);
+				else this.fleeFromTarget();
+				return consumes;
+			case "keepDistance": return this.executeKeepDistance(intent, consumes);
+			case "useAttack": return this.executeRequestedAttack(intent.pattern, currentTime, consumes);
+			case "useSkill": return this.executeRequestedSkill(intent.skill, currentTime, consumes);
+		}
+	}
+	executeKeepDistance(intent, consumes) {
+		if (!this.target) return false;
+		const tolerance = intent.tolerance ?? Math.max(8, intent.distance * .15);
+		const distance = this.getDistance(this.event, this.target);
+		if (distance < intent.distance - tolerance) {
+			this.isMovingToTarget = false;
+			this.retreatFromTarget();
+			return consumes;
+		}
+		if (distance > intent.distance + tolerance) {
+			this.requestTargetMovement();
+			return consumes;
+		}
+		if (this.isMovingToTarget) {
+			this.isMovingToTarget = false;
+			this.event.stopMoveTo();
+		}
+		return consumes;
+	}
+	executeRequestedAttack(pattern, currentTime, consumes) {
+		if (!this.target || this.isTargetDefeated(this.target) || this.chargingAttack) return false;
+		if (this.getDistance(this.event, this.target) > this.attackRange) return false;
+		if (currentTime - this.lastAttackTime < this.attackCooldown) return false;
+		if (pattern) this.performAttackPattern(pattern);
+		else this.selectAndPerformAttack();
+		this.lastAttackTime = currentTime;
+		return consumes;
+	}
+	executeRequestedSkill(skill, currentTime, consumes) {
+		if (!this.target || this.isTargetDefeated(this.target) || !skill) return false;
+		const distance = this.getDistance(this.event, this.target);
+		const resolvedSkill = this.resolveUsable(skill);
+		const range = getActionBattleActionRange(resolvedSkill) ?? this.attackRange;
+		const cooldownRemaining = this.attackCooldown - (currentTime - this.lastAttackTime);
+		if (distance > range) return false;
+		if (cooldownRemaining > 0) return false;
+		executeActionBattleUse({
+			attacker: this.event,
+			target: this.target,
+			usable: resolvedSkill,
+			skill: resolvedSkill,
+			profile: this.getAttackProfile(AttackPattern.Melee)
+		});
+		this.lastAttackTime = currentTime;
+		return consumes;
+	}
+	handleTacticalMovement(distance) {
+		if (!this.target) return;
+		const minRange = this.attackRange * .7;
+		const maxRange = this.attackRange * 1.2;
+		if (distance < minRange) {
+			this.debugLog("movement", `Tactical retreat (dist=${distance.toFixed(1)}, minRange=${minRange.toFixed(1)})`);
+			this.isMovingToTarget = false;
+			this.retreatFromTarget();
+			return;
+		}
+		if (distance > maxRange) {
+			if (!this.isMovingToTarget) {
+				this.debugLog("movement", `Tactical approach (dist=${distance.toFixed(1)}, maxRange=${maxRange.toFixed(1)})`);
+				this.requestTargetMovement();
+			}
+			return;
+		}
+		if (this.isMovingToTarget) {
+			this.debugLog("movement", `Tactical hold (dist=${distance.toFixed(1)})`);
+			this.isMovingToTarget = false;
+			this.event.stopMoveTo();
+		}
+	}
+	handleAssaultMovement(distance) {
+		if (!this.target) return;
+		if (distance > this.attackRange) {
+			if (!this.isMovingToTarget) {
+				this.debugLog("movement", `Assault approach (dist=${distance.toFixed(1)}, attackRange=${this.attackRange})`);
+				this.requestTargetMovement();
+			}
+			return;
+		}
+		if (this.isMovingToTarget) {
+			this.debugLog("movement", `Assault hold (dist=${distance.toFixed(1)})`);
+			this.isMovingToTarget = false;
+			this.event.stopMoveTo();
+		}
+	}
+	resolveMoveTarget(target) {
+		if (!target) return null;
+		const targetId = target.id !== void 0 && target.id !== null ? String(target.id) : void 0;
+		const x = resolveMoveCoordinate(target.x);
+		const y = resolveMoveCoordinate(target.y);
+		if (targetId) return {
+			kind: "entity",
+			target,
+			id: targetId,
+			x,
+			y,
+			signature: `entity:${targetId}`
+		};
+		if (x === void 0 || y === void 0) return null;
+		return {
+			kind: "position",
+			target: {
+				x,
+				y
+			},
+			x,
+			y,
+			signature: createMoveSignature(x, y)
+		};
+	}
+	requestMoveTo(target) {
+		const currentTime = Date.now();
+		const resolvedTarget = this.resolveMoveTarget(target);
+		if (!resolvedTarget) {
+			this.traceLog("movement", "moveTo skipped: invalid target", { target });
+			return false;
+		}
+		if (currentTime - this.lastMoveToTime < this.moveToCooldown) {
+			if (this.lastMoveToCooldownTraceSignature !== resolvedTarget.signature || currentTime - this.lastMoveToCooldownTraceTime > 1e3) {
+				this.lastMoveToCooldownTraceTime = currentTime;
+				this.lastMoveToCooldownTraceSignature = resolvedTarget.signature;
+				this.traceLog("movement", "moveTo skipped: cooldown", {
+					targetKind: resolvedTarget.kind,
+					targetId: resolvedTarget.kind === "entity" ? resolvedTarget.id : void 0,
+					targetPosition: {
+						x: resolvedTarget.x,
+						y: resolvedTarget.y
+					},
+					elapsed: currentTime - this.lastMoveToTime,
+					moveToCooldown: this.moveToCooldown
+				});
+			}
+			return false;
+		}
+		const map = this.event.getCurrentMap?.();
+		const hasBody = !!map?.physic?.getEntityByUUID?.(this.event.id) || !!map?.getBody?.(this.event.id);
+		this.traceLog("movement", "moveTo requested", {
+			targetKind: resolvedTarget.kind,
+			targetId: resolvedTarget.kind === "entity" ? resolvedTarget.id : void 0,
+			eventPosition: {
+				x: this.event.x?.(),
+				y: this.event.y?.()
+			},
+			targetPosition: {
+				x: resolvedTarget.x,
+				y: resolvedTarget.y
+			},
+			hasMap: !!map,
+			hasMovementBody: hasBody
+		});
+		this.event.moveTo(resolvedTarget.target);
+		this.lastMoveToTime = currentTime;
+		return true;
+	}
+	requestTargetMovement(target = this.target) {
+		if (!target) {
+			this.traceLog("movement", "target movement skipped: no target");
+			return false;
+		}
+		const started = this.requestMoveTo(target);
+		if (started) this.isMovingToTarget = true;
+		else {
+			const now = Date.now();
+			if (now - this.lastTargetMovementSkipTraceTime > 1e3) {
+				this.lastTargetMovementSkipTraceTime = now;
+				this.traceLog("movement", "target movement did not start", {
+					targetId: target.id,
+					isMovingToTarget: this.isMovingToTarget
+				});
+			}
+		}
+		return started;
+	}
+	schedule(callback, delay) {
+		const timer = setTimeout(() => {
+			this.timers = this.timers.filter((entry) => entry !== timer);
+			if (this.destroyed) return;
+			callback();
+		}, delay);
+		this.timers.push(timer);
+		return timer;
+	}
+	getHealth() {
+		return this.event.hp;
+	}
+	getMaxHealth() {
+		return this.event.param[MAXHP];
+	}
+	getTarget() {
+		return this.target;
+	}
+	getState() {
+		return this.state;
+	}
+	getFaction() {
+		return this.faction;
+	}
+	setFaction(faction) {
+		this.faction = faction;
+	}
+	getTargets() {
+		return this.targets;
+	}
+	setTargets(targets) {
+		this.targets = targets;
+		if (this.target && !this.canTarget(this.target)) {
+			this.clearTarget();
+			this.changeState(AiState.Idle);
+		}
+	}
+	getEnemyType() {
+		return this.enemyType;
+	}
+	/**
+	* Clean up
+	*/
+	destroy() {
+		this.destroyed = true;
+		if (this.updateInterval) {
+			clearInterval(this.updateInterval);
+			this.updateInterval = void 0;
+		}
+		this.target = null;
+		this.nearbyEnemies = [];
+		this.timers.forEach((timer) => clearTimeout(timer));
+		this.timers = [];
+	}
+};
+//#endregion
+export { AiDebug, AiState, AttackPattern, BattleAi, DEFAULT_KNOCKBACK, EnemyType };