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

package/src/ai.server.ts

@@ -60,6 +60,31 @@ type RpgEventWithBattleAi = RpgEvent & {
   battleAi?: BattleAi;
 };
 
+type ResolvedMoveTarget =
+  | {
+      kind: "entity";
+      target: ActionBattleEntity;
+      id?: string;
+      x?: number;
+      y?: number;
+      signature: string;
+    }
+  | {
+      kind: "position";
+      target: { x: number; y: number };
+      x: number;
+      y: number;
+      signature: string;
+    };
+
+const resolveMoveCoordinate = (value: unknown): number | undefined => {
+  const raw = typeof value === "function" ? (value as () => unknown)() : value;
+  return typeof raw === "number" && Number.isFinite(raw) ? raw : undefined;
+};
+
+const createMoveSignature = (x: number, y: number): string =>
+  `position:${Math.round(x)}:${Math.round(y)}`;
+
 export interface BattleAiRewardItem {
   item?: any;
   itemId?: string;
@@ -334,16 +359,10 @@ export const AiDebug = {
    * @param data - Optional additional data
    */
   log(category: string, eventId: string | undefined, message: string, data?: any): void {
-    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 !== undefined) {
-      console.log(prefix, message, data);
-    } else {
-      console.log(prefix, message);
-    }
+    void category;
+    void eventId;
+    void message;
+    void data;
   }
 };
 
@@ -497,6 +516,37 @@ export class BattleAi {
     AiDebug.log(category, this.event.id, message, data);
   }
 
+  private traceLog(category: string, message: string, data?: any): void {
+    void category;
+    void message;
+    void data;
+  }
+
+  private lockActionUntil(until: number, reason: string, data?: any): void {
+    if (until <= this.actionLockedUntil) return;
+    this.actionLockedUntil = until;
+    this.traceLog("state", "action locked", {
+      reason,
+      lockedMs: Math.max(0, until - Date.now()),
+      ...data,
+    });
+  }
+
+  private lockForAttack(
+    profile: NormalizedActionBattleAttackProfile,
+    pattern: AttackPattern
+  ): void {
+    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 machine
   private state: AiState = AiState.Idle;
   private stateStartTime: number = 0;
@@ -570,6 +620,11 @@ export class BattleAi {
   private lastMoveToTime: number = 0;
   private retreatCooldown: number = 600;
   private lastRetreatTime: number = 0;
+  private actionLockedUntil: number = 0;
+  private lastActionLockTraceTime: number = 0;
+  private lastMoveToCooldownTraceTime: number = 0;
+  private lastMoveToCooldownTraceSignature: string | null = null;
+  private lastTargetMovementSkipTraceTime: number = 0;
   private timers: ReturnType<typeof setTimeout>[] = [];
   private behaviorKey?: string;
   private behaviorTree?: ActionBattleAiTreeNode;
@@ -581,6 +636,7 @@ export class BattleAi {
   private visionSetupRetries: number = 0;
   private maxVisionSetupRetries: number = 20;
   private destroyed: boolean = false;
+  private lastNoTargetTraceTime: number = 0;
 
   /**
    * Create a new Battle AI Controller
@@ -790,6 +846,10 @@ export class BattleAi {
       map?.physic?.getEntityByUUID &&
       !map.physic.getEntityByUUID(this.event.id)
     ) {
+      this.traceLog("vision", "physics body not ready", {
+        retries: this.visionSetupRetries,
+        hasMap: !!map,
+      });
       return false;
     }
 
@@ -800,14 +860,29 @@ export class BattleAi {
       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 as any)?.id,
+      visionRange: this.visionRange,
+    });
     return true;
   }
 
   private 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(() => {
@@ -848,10 +923,19 @@ export class BattleAi {
 
     if (!validTransitions[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();
 
@@ -905,6 +989,20 @@ export class BattleAi {
       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;
+    }
+
     // Berserker: faster attacks when HP is low
     if (this.enemyType === EnemyType.Berserker && this.event.param[MAXHP]) {
       const hpPercent = this.event.hp / this.event.param[MAXHP];
@@ -982,8 +1080,28 @@ export class BattleAi {
       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);
@@ -1001,6 +1119,15 @@ export class BattleAi {
     }
 
     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,
+    });
 
     // Check if target is still in range
     if (distance > this.visionRange * 1.5) {
@@ -1055,8 +1182,7 @@ export class BattleAi {
       } 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) {
@@ -1069,8 +1195,7 @@ export class BattleAi {
       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) {
@@ -1217,15 +1342,9 @@ export class BattleAi {
     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);
@@ -1439,12 +1558,12 @@ export class BattleAi {
     // Visual feedback
     withActionBattleAnimationUnlocked(target, () => {
       emitActionBattleClientVisual({
-        moment: "hit",
+        moment: "hurt",
         entity: this.event,
         target,
+        attacker: this.event,
         damage: hitResult.damage,
         result: hitResult,
-        animations: this.animations,
       });
     });
     setActionBattleInvincibility(
@@ -1526,15 +1645,9 @@ export class BattleAi {
     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);
     });
@@ -1561,16 +1674,9 @@ export class BattleAi {
 
     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) {
@@ -1589,15 +1695,9 @@ export class BattleAi {
    */
   private 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 ?? undefined,
-        animations: this.animations,
-      });
-    });
+    this.playAttackVisual(profile, AttackPattern.Zone);
 
     const eventX = this.event.x();
     const eventY = this.event.y();
@@ -1651,7 +1751,9 @@ export class BattleAi {
     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;
@@ -1671,6 +1773,28 @@ export class BattleAi {
     ] ?? this.attackProfiles.melee;
   }
 
+  private playAttackVisual(
+    profile: NormalizedActionBattleAttackProfile,
+    pattern: AttackPattern,
+    animationDefaults?: { animationName?: string; repeat?: number }
+  ): void {
+    const moment =
+      profile.animationKey === "castSkill" || profile.animationKey === "castSpell"
+        ? "castSkill"
+        : "attack";
+
+    withActionBattleAnimationUnlocked(this.event, () => {
+      emitActionBattleClientVisual({
+        moment,
+        entity: this.event,
+        target: this.target ?? undefined,
+        pattern,
+        animations: this.animations,
+        animationDefaults,
+      });
+    });
+  }
+
   private telegraphAttack(profile: NormalizedActionBattleAttackProfile) {
     if (profile.startupMs <= 0) return;
     this.event.flash({
@@ -1820,8 +1944,8 @@ export class BattleAi {
     if (dist === 0) return;
 
     const fleeTarget = {
-      x: () => this.event.x() + (dx / dist) * 200,
-      y: () => this.event.y() + (dy / dist) * 200
+      x: this.event.x() + (dx / dist) * 200,
+      y: this.event.y() + (dy / dist) * 200
     };
 
     this.requestMoveTo(fleeTarget as any);
@@ -1868,7 +1992,7 @@ export class BattleAi {
     if (this.patrolWaypoints.length === 0) return;
 
     const waypoint = this.patrolWaypoints[this.currentPatrolIndex];
-    this.requestMoveTo({ x: () => waypoint.x, y: () => waypoint.y } as any);
+    this.requestMoveTo({ x: waypoint.x, y: waypoint.y } as any);
   }
 
   /**
@@ -1940,7 +2064,7 @@ export class BattleAi {
     );
 
     if (distanceToFormation > 20) {
-      this.requestMoveTo({ x: () => formationX, y: () => formationY } as any);
+      this.requestMoveTo({ x: formationX, y: formationY } as any);
     }
   }
 
@@ -1948,12 +2072,28 @@ export class BattleAi {
    * Handle player entering vision
    */
   onDetectInShape(target: ActionBattleEntity, shape: any) {
-    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 as any)?.hp,
+    });
+    if (!canTarget || defeated) return;
     this.debugLog('vision', `Target ${target.id} entered vision (state=${this.state})`);
     this.engageTarget(target);
   }
 
   private engageTarget(target: ActionBattleEntity) {
+    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) {
@@ -1968,6 +2108,12 @@ export class BattleAi {
    */
   onDetectOutShape(target: ActionBattleEntity, shape: any) {
     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);
@@ -1998,8 +2144,21 @@ export class BattleAi {
     }
   ): boolean {
     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,
+    });
 
     // Visual feedback
     withActionBattleAnimationUnlocked(this.event, () => {
@@ -2018,10 +2177,36 @@ export class BattleAi {
     // Track damage
     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
@@ -2157,7 +2342,10 @@ export class BattleAi {
 
   private findNearestTarget(): ActionBattleEntity | null {
     const map = this.event.getCurrentMap();
-    if (!map) return null;
+    if (!map) {
+      this.traceLog("target", "find nearest skipped: no map");
+      return null;
+    }
 
     const candidates: ActionBattleEntity[] = [];
     map.getPlayers?.().forEach((player: RpgPlayer) => candidates.push(player));
@@ -2175,6 +2363,31 @@ export class BattleAi {
       }
     }
 
+    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 > 1000) {
+      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 as any).hp,
+            canTarget: this.canTarget(candidate),
+            defeated: this.isTargetDefeated(candidate),
+            distance,
+          };
+        }),
+      });
+    }
+
     return nearest;
   }
 
@@ -2370,8 +2583,7 @@ export class BattleAi {
         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;
@@ -2404,8 +2616,7 @@ export class BattleAi {
       return consumes;
     }
     if (distance > intent.distance + tolerance) {
-      this.isMovingToTarget = true;
-      this.requestMoveTo(this.target);
+      this.requestTargetMovement();
       return consumes;
     }
     if (this.isMovingToTarget) {
@@ -2473,8 +2684,7 @@ export class BattleAi {
     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;
     }
@@ -2491,8 +2701,7 @@ export class BattleAi {
     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;
     }
@@ -2504,16 +2713,114 @@ export class BattleAi {
     }
   }
 
+  private resolveMoveTarget(target: any): ResolvedMoveTarget | null {
+    if (!target) return null;
+
+    const targetId =
+      target.id !== undefined && target.id !== null ? String(target.id) : undefined;
+    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 === undefined || y === undefined) {
+      return null;
+    }
+
+    return {
+      kind: "position",
+      target: { x, y },
+      x,
+      y,
+      signature: createMoveSignature(x, y),
+    };
+  }
+
   private requestMoveTo(target: any): boolean {
     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 > 1000
+      ) {
+        this.lastMoveToCooldownTraceTime = currentTime;
+        this.lastMoveToCooldownTraceSignature = resolvedTarget.signature;
+        this.traceLog("movement", "moveTo skipped: cooldown", {
+          targetKind: resolvedTarget.kind,
+          targetId:
+            resolvedTarget.kind === "entity" ? resolvedTarget.id : undefined,
+          targetPosition: {
+            x: resolvedTarget.x,
+            y: resolvedTarget.y,
+          },
+          elapsed: currentTime - this.lastMoveToTime,
+          moveToCooldown: this.moveToCooldown,
+        });
+      }
       return false;
     }
-    this.event.moveTo(target as any);
+    const map = this.event.getCurrentMap?.() as any;
+    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 : undefined,
+      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 as any);
     this.lastMoveToTime = currentTime;
     return true;
   }
 
+  private requestTargetMovement(target: ActionBattleEntity | null = this.target): boolean {
+    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 > 1000) {
+        this.lastTargetMovementSkipTraceTime = now;
+        this.traceLog("movement", "target movement did not start", {
+          targetId: target.id,
+          isMovingToTarget: this.isMovingToTarget,
+        });
+      }
+    }
+    return started;
+  }
+
   private schedule(callback: () => void, delay: number) {
     const timer = setTimeout(() => {
       this.timers = this.timers.filter((entry) => entry !== timer);