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

package/dist/server/index13.js

@@ -5,9 +5,10 @@ var ACTION_BATTLE_ENEMY_FACTION = "enemies";
 var getBattleAi = (entity) => entity?.battleAi;
 var getActionBattleEntityKind = (entity) => {
 	if (getBattleAi(entity)) return "event";
+	if (typeof entity?.isEvent === "function") return entity.isEvent() ? "event" : "player";
 	if (entity instanceof RpgEvent) return "event";
-	if (typeof entity?.attachShape === "function") return "event";
 	if (entity instanceof RpgPlayer) return "player";
+	if (typeof entity?.attachShape === "function") return "event";
 	return "player";
 };
 var isActionBattlePlayer = (entity) => getActionBattleEntityKind(entity) === "player";

package/dist/server/index14.js

@@ -62,9 +62,10 @@ var applyDamageEffect = (attacker, target, skill, reaction, metadata) => {
 	});
 	if (!result.cancelled) {
 		emitActionBattleClientVisual({
-			moment: "hit",
+			moment: "hurt",
 			entity: attacker,
 			target,
+			attacker,
 			damage: result.damage,
 			result,
 			skill

package/dist/server/index19.js

@@ -14,6 +14,11 @@ import { safeActionBattleDash } from "./index17.js";
 import { defineAiBehavior, defineAiTree } from "./index18.js";
 import { MAXHP } from "@rpgjs/server";
 //#region src/ai.server.ts
+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,
@@ -97,14 +102,7 @@ var AiDebug = {
 	* @param message - Log message
 	* @param data - Optional additional data
 	*/
-	log(category, eventId, message, data) {
-		if (!this.enabled) return;
-		if (this.filterEventId && eventId !== this.filterEventId) return;
-		if (this.categories.length > 0 && !this.categories.includes(category)) return;
-		const prefix = `[AI:${category}]${eventId ? ` [${eventId.substring(0, 8)}]` : ""}`;
-		if (data !== void 0) console.log(prefix, message, data);
-		else console.log(prefix, message);
-	}
+	log(category, eventId, message, data) {}
 };
 /**
 * AI State enumeration
@@ -237,6 +235,27 @@ var BattleAi = class {
 	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;
@@ -283,6 +302,11 @@ var BattleAi = class {
 	lastMoveToTime = 0;
 	retreatCooldown = 600;
 	lastRetreatTime = 0;
+	actionLockedUntil = 0;
+	lastActionLockTraceTime = 0;
+	lastMoveToCooldownTraceTime = 0;
+	lastMoveToCooldownTraceSignature = null;
+	lastTargetMovementSkipTraceTime = 0;
 	timers = [];
 	behaviorKey;
 	behaviorTree;
@@ -294,6 +318,7 @@ var BattleAi = class {
 	visionSetupRetries = 0;
 	maxVisionSetupRetries = 20;
 	destroyed = false;
+	lastNoTargetTraceTime = 0;
 	constructor(event, options = {}) {
 		options = mergeBattleAiPresetOptions(options);
 		event.battleAi = this;
@@ -407,7 +432,13 @@ var BattleAi = class {
 	setupVision() {
 		if (this.visionShape) return true;
 		const map = this.event.getCurrentMap?.();
-		if (map?.physic?.getEntityByUUID && !map.physic.getEntityByUUID(this.event.id)) return false;
+		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,
@@ -415,13 +446,26 @@ var BattleAi = class {
 			height: diameter,
 			angle: 360
 		});
-		if (!shape) return false;
+		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) 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;
@@ -458,9 +502,18 @@ var BattleAi = class {
 			[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) {
@@ -498,6 +551,19 @@ var BattleAi = class {
 			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);
@@ -554,7 +620,30 @@ var BattleAi = class {
 	updateAlertBehavior() {
 		if (this.target) {
 			this.faceTarget();
-			if (this.getDistance(this.event, this.target) <= this.attackRange * 1.5) this.changeState(AiState.Combat);
+			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);
 	}
 	/**
@@ -567,6 +656,15 @@ var BattleAi = class {
 			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();
@@ -606,8 +704,7 @@ var BattleAi = class {
 			} else if (distance > this.attackRange) {
 				if (!this.isMovingToTarget) {
 					this.debugLog("movement", `Moving to target (dist=${distance.toFixed(1)}, attackRange=${this.attackRange})`);
-					this.isMovingToTarget = true;
-					this.requestMoveTo(this.target);
+					this.requestTargetMovement();
 				}
 			} else if (this.isMovingToTarget) {
 				this.debugLog("movement", `In range, stopping (dist=${distance.toFixed(1)})`);
@@ -617,8 +714,7 @@ var BattleAi = class {
 		} else if (distance > this.attackRange) {
 			if (!this.isMovingToTarget) {
 				this.debugLog("movement", `Moving to target (dist=${distance.toFixed(1)}, attackRange=${this.attackRange})`);
-				this.isMovingToTarget = true;
-				this.requestMoveTo(this.target);
+				this.requestTargetMovement();
 			}
 		} else if (this.isMovingToTarget) {
 			this.debugLog("movement", `In range, stopping (dist=${distance.toFixed(1)})`);
@@ -741,15 +837,9 @@ var BattleAi = class {
 		if (!this.target) return;
 		const profile = this.getAttackProfile(AttackPattern.Melee);
 		this.faceTarget({ force: true });
+		this.lockForAttack(profile, AttackPattern.Melee);
 		this.telegraphAttack(profile);
-		withActionBattleAnimationUnlocked(this.event, () => {
-			emitActionBattleClientVisual({
-				moment: "attack",
-				entity: this.event,
-				target: this.target,
-				animations: this.animations
-			});
-		});
+		this.playAttackVisual(profile, AttackPattern.Melee);
 		this.scheduleAttackStartup(profile, () => {
 			this.executeMeleeAttack(profile, AttackPattern.Melee);
 		});
@@ -887,12 +977,12 @@ var BattleAi = class {
 		}
 		withActionBattleAnimationUnlocked(target, () => {
 			emitActionBattleClientVisual({
-				moment: "hit",
+				moment: "hurt",
 				entity: this.event,
 				target,
+				attacker: this.event,
 				damage: hitResult.damage,
-				result: hitResult,
-				animations: this.animations
+				result: hitResult
 			});
 		});
 		setActionBattleInvincibility(target, profile.reaction.invincibilityMs);
@@ -953,15 +1043,9 @@ var BattleAi = class {
 		this.comboCount++;
 		const profile = this.getAttackProfile(AttackPattern.Combo);
 		this.faceTarget({ force: true });
+		this.lockForAttack(profile, AttackPattern.Combo);
 		this.telegraphAttack(profile);
-		withActionBattleAnimationUnlocked(this.event, () => {
-			emitActionBattleClientVisual({
-				moment: "attack",
-				entity: this.event,
-				target: this.target,
-				animations: this.animations
-			});
-		});
+		this.playAttackVisual(profile, AttackPattern.Combo);
 		this.scheduleAttackStartup(profile, () => {
 			this.executeMeleeAttack(profile, AttackPattern.Combo);
 		});
@@ -979,16 +1063,9 @@ var BattleAi = class {
 		const profile = this.getAttackProfile(AttackPattern.Charged);
 		this.chargingAttack = true;
 		this.faceTarget({ force: true });
+		this.lockForAttack(profile, AttackPattern.Charged);
 		this.telegraphAttack(profile);
-		withActionBattleAnimationUnlocked(this.event, () => {
-			emitActionBattleClientVisual({
-				moment: "attack",
-				entity: this.event,
-				target: this.target,
-				animations: this.animations,
-				animationDefaults: { repeat: 2 }
-			});
-		});
+		this.playAttackVisual(profile, AttackPattern.Charged, { repeat: 2 });
 		this.scheduleAttackStartup(profile, () => {
 			if (!this.target || this.state !== AiState.Combat) {
 				this.chargingAttack = false;
@@ -1005,15 +1082,9 @@ var BattleAi = class {
 	*/
 	performZoneAttack() {
 		const profile = this.getAttackProfile(AttackPattern.Zone);
+		this.lockForAttack(profile, AttackPattern.Zone);
 		this.telegraphAttack(profile);
-		withActionBattleAnimationUnlocked(this.event, () => {
-			emitActionBattleClientVisual({
-				moment: "attack",
-				entity: this.event,
-				target: this.target ?? void 0,
-				animations: this.animations
-			});
-		});
+		this.playAttackVisual(profile, AttackPattern.Zone);
 		const eventX = this.event.x();
 		const eventY = this.event.y();
 		const radius = 50;
@@ -1055,7 +1126,9 @@ var BattleAi = class {
 		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, {
@@ -1071,6 +1144,19 @@ var BattleAi = class {
 	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({
@@ -1163,10 +1249,11 @@ var BattleAi = class {
 		const dy = this.event.y() - this.target.y();
 		const dist = Math.sqrt(dx * dx + dy * dy);
 		if (dist === 0) return;
-		this.requestMoveTo({
-			x: () => this.event.x() + dx / dist * 200,
-			y: () => this.event.y() + dy / dist * 200
-		});
+		const fleeTarget = {
+			x: this.event.x() + dx / dist * 200,
+			y: this.event.y() + dy / dist * 200
+		};
+		this.requestMoveTo(fleeTarget);
 	}
 	/**
 	* Retreat from target (temporary)
@@ -1202,8 +1289,8 @@ var BattleAi = class {
 		if (this.patrolWaypoints.length === 0) return;
 		const waypoint = this.patrolWaypoints[this.currentPatrolIndex];
 		this.requestMoveTo({
-			x: () => waypoint.x,
-			y: () => waypoint.y
+			x: waypoint.x,
+			y: waypoint.y
 		});
 	}
 	/**
@@ -1249,19 +1336,35 @@ var BattleAi = class {
 		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
+			x: formationX,
+			y: formationY
 		});
 	}
 	/**
 	* Handle player entering vision
 	*/
 	onDetectInShape(target, shape) {
-		if (!this.canTarget(target) || this.isTargetDefeated(target)) return;
+		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);
@@ -1271,6 +1374,12 @@ var BattleAi = class {
 	*/
 	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);
@@ -1293,8 +1402,21 @@ var BattleAi = class {
 	}
 	handleDamage(attacker, damageResult) {
 		if (this.defeated) return true;
-		const damage = damageResult.damage;
+		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",
@@ -1308,10 +1430,27 @@ var BattleAi = class {
 			});
 		});
 		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 = staggerPower >= this.poise && hitstunMs > 0;
+		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");
@@ -1394,7 +1533,10 @@ var BattleAi = class {
 	}
 	findNearestTarget() {
 		const map = this.event.getCurrentMap();
-		if (!map) return null;
+		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));
@@ -1409,6 +1551,29 @@ var BattleAi = class {
 				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) {
@@ -1540,8 +1705,7 @@ var BattleAi = class {
 				return consumes;
 			case "moveToTarget":
 				if (!this.target) return false;
-				this.isMovingToTarget = true;
-				this.requestMoveTo(this.target);
+				this.requestTargetMovement();
 				return consumes;
 			case "fleeFromTarget":
 				if (!this.target) return false;
@@ -1564,8 +1728,7 @@ var BattleAi = class {
 			return consumes;
 		}
 		if (distance > intent.distance + tolerance) {
-			this.isMovingToTarget = true;
-			this.requestMoveTo(this.target);
+			this.requestTargetMovement();
 			return consumes;
 		}
 		if (this.isMovingToTarget) {
@@ -1614,8 +1777,7 @@ var BattleAi = class {
 		if (distance > maxRange) {
 			if (!this.isMovingToTarget) {
 				this.debugLog("movement", `Tactical approach (dist=${distance.toFixed(1)}, maxRange=${maxRange.toFixed(1)})`);
-				this.isMovingToTarget = true;
-				this.requestMoveTo(this.target);
+				this.requestTargetMovement();
 			}
 			return;
 		}
@@ -1630,8 +1792,7 @@ var BattleAi = class {
 		if (distance > this.attackRange) {
 			if (!this.isMovingToTarget) {
 				this.debugLog("movement", `Assault approach (dist=${distance.toFixed(1)}, attackRange=${this.attackRange})`);
-				this.isMovingToTarget = true;
-				this.requestMoveTo(this.target);
+				this.requestTargetMovement();
 			}
 			return;
 		}
@@ -1641,13 +1802,94 @@ var BattleAi = class {
 			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();
-		if (currentTime - this.lastMoveToTime < this.moveToCooldown) return false;
-		this.event.moveTo(target);
+		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);

package/dist/server/index7.js

@@ -80,9 +80,19 @@ var createDefaultPlayerHitboxResolver = (hitboxes = DEFAULT_ZELDA_PLAYER_HITBOXE
 };
 var defaultRpgjsDamageResolver = (context) => {
 	const target = context.target;
+	const previousHp = typeof target.hp === "number" && Number.isFinite(target.hp) ? target.hp : void 0;
 	const raw = target.applyDamage(context.attacker, context.skill);
+	const resolvedDamage = Number(raw?.damage ?? 0);
+	if (!Number.isFinite(resolvedDamage)) {
+		if (previousHp !== void 0) target.hp = previousHp;
+		return {
+			damage: 0,
+			defeated: false,
+			raw
+		};
+	}
 	return {
-		damage: raw?.damage ?? 0,
+		damage: resolvedDamage,
 		defeated: target.hp <= 0,
 		raw
 	};