@rpgjs/action-battle 5.0.0-alpha.30 → 5.0.0-alpha.32

package/README.md

@@ -601,7 +601,7 @@ import {
 
 // Custom attack with hooks
 function customAttack(player: RpgPlayer) {
-  player.setAnimation('attack', 1);
+  player.setGraphicAnimation('attack', 1);
   
   const direction = player.getDirection();
   const hitboxConfig = DEFAULT_PLAYER_ATTACK_HITBOXES[direction] || DEFAULT_PLAYER_ATTACK_HITBOXES.default;

package/dist/ai.server.d.ts

@@ -235,6 +235,18 @@ export declare class BattleAi {
     private isMovingToTarget;
     private onDefeatedCallback?;
     private lastFacingDirection;
+    private behaviorScore;
+    private behaviorMode;
+    private behaviorLastUpdate;
+    private behaviorUpdateInterval;
+    private behaviorAssaultThreshold;
+    private behaviorRetreatThreshold;
+    private behaviorMinStateDuration;
+    private behaviorEnabled;
+    private moveToCooldown;
+    private lastMoveToTime;
+    private retreatCooldown;
+    private lastRetreatTime;
     /**
      * Create a new Battle AI Controller
      *
@@ -274,6 +286,15 @@ export declare class BattleAi {
             y: number;
         }>;
         groupBehavior?: boolean;
+        moveToCooldown?: number;
+        retreatCooldown?: number;
+        behavior?: {
+            baseScore?: number;
+            updateInterval?: number;
+            minStateDuration?: number;
+            assaultThreshold?: number;
+            retreatThreshold?: number;
+        };
         /** Callback called when the AI is defeated */
         onDefeated?: (event: RpgEvent) => void;
     });
@@ -469,6 +490,10 @@ export declare class BattleAi {
      * Get distance between entities
      */
     private getDistance;
+    private updateBehavior;
+    private handleTacticalMovement;
+    private handleAssaultMovement;
+    private requestMoveTo;
     getHealth(): number;
     getMaxHealth(): number;
     getTarget(): InstanceType<typeof RpgPlayer> | null;

package/dist/client/index3.js

@@ -101,6 +101,18 @@ class BattleAi {
     this.damageCheckInterval = 2e3;
     this.isMovingToTarget = false;
     this.lastFacingDirection = null;
+    this.behaviorScore = 50;
+    this.behaviorMode = "tactical";
+    this.behaviorLastUpdate = 0;
+    this.behaviorUpdateInterval = 400;
+    this.behaviorAssaultThreshold = 65;
+    this.behaviorRetreatThreshold = 35;
+    this.behaviorMinStateDuration = 600;
+    this.behaviorEnabled = false;
+    this.moveToCooldown = 400;
+    this.lastMoveToTime = 0;
+    this.retreatCooldown = 600;
+    this.lastRetreatTime = 0;
     event.battleAi = this;
     this.event = event;
     this.enemyType = options.enemyType || "aggressive";
@@ -116,6 +128,30 @@ class BattleAi {
     this.patrolWaypoints = options.patrolWaypoints || [];
     this.currentPatrolIndex = 0;
     this.onDefeatedCallback = options.onDefeated;
+    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;
+    }
     this.setupVision();
     this.startAiBehaviorLoop();
     this.changeState(
@@ -310,6 +346,9 @@ class BattleAi {
       const berserkerModifier = Math.max(0.3, hpPercent);
       this.attackCooldown = 800 * berserkerModifier;
     }
+    if (this.behaviorEnabled) {
+      this.updateBehavior(currentTime);
+    }
     switch (this.state) {
       case "idle":
         this.updateIdleBehavior();
@@ -403,7 +442,20 @@ class BattleAi {
       this.tryDodge();
       return;
     }
-    if (this.enemyType === "ranged") {
+    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 === "ranged") {
       if (distance < this.attackRange * 0.6) {
         this.debugLog("movement", `Retreating (dist=${distance.toFixed(1)}, minRange=${(this.attackRange * 0.6).toFixed(1)})`);
         this.isMovingToTarget = false;
@@ -412,7 +464,7 @@ class BattleAi {
         if (!this.isMovingToTarget) {
           this.debugLog("movement", `Moving to target (dist=${distance.toFixed(1)}, attackRange=${this.attackRange})`);
           this.isMovingToTarget = true;
-          this.event.moveTo(this.target);
+          this.requestMoveTo(this.target);
         }
       } else {
         if (this.isMovingToTarget) {
@@ -426,7 +478,7 @@ class BattleAi {
         if (!this.isMovingToTarget) {
           this.debugLog("movement", `Moving to target (dist=${distance.toFixed(1)}, attackRange=${this.attackRange})`);
           this.isMovingToTarget = true;
-          this.event.moveTo(this.target);
+          this.requestMoveTo(this.target);
         }
       } else {
         if (this.isMovingToTarget) {
@@ -591,7 +643,7 @@ class BattleAi {
   performMeleeAttack() {
     if (!this.target) return;
     this.faceTarget();
-    this.event.setAnimation("attack", 1);
+    this.event.setGraphicAnimation("attack", 1);
     if (this.attackSkill) {
       try {
         this.event.useSkill(this.attackSkill, this.target);
@@ -758,7 +810,7 @@ class BattleAi {
     if (!this.target) return;
     this.chargingAttack = true;
     this.faceTarget();
-    this.event.setAnimation("attack", 2);
+    this.event.setGraphicAnimation("attack", 2);
     setTimeout(() => {
       if (!this.target || this.state !== "combat") {
         this.chargingAttack = false;
@@ -780,7 +832,7 @@ class BattleAi {
    * Perform zone attack (360 degrees)
    */
   performZoneAttack() {
-    this.event.setAnimation("attack", 1);
+    this.event.setGraphicAnimation("attack", 1);
     const eventX = this.event.x();
     const eventY = this.event.y();
     const radius = 50;
@@ -915,18 +967,23 @@ class BattleAi {
       x: () => this.event.x() + dx / dist * 200,
       y: () => this.event.y() + dy / dist * 200
     };
-    this.event.moveTo(fleeTarget);
+    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;
     this.event.dash({ x: dx / dist, y: dy / dist }, 8, 200);
+    this.lastRetreatTime = currentTime;
   }
   /**
    * Check damage taken for retreat decision
@@ -944,7 +1001,7 @@ class BattleAi {
   startPatrol() {
     if (this.patrolWaypoints.length === 0) return;
     const waypoint = this.patrolWaypoints[this.currentPatrolIndex];
-    this.event.moveTo({ x: () => waypoint.x, y: () => waypoint.y });
+    this.requestMoveTo({ x: () => waypoint.x, y: () => waypoint.y });
   }
   /**
    * Update group behavior
@@ -1001,7 +1058,7 @@ class BattleAi {
       Math.pow(this.event.x() - formationX, 2) + Math.pow(this.event.y() - formationY, 2)
     );
     if (distanceToFormation > 20) {
-      this.event.moveTo({ x: () => formationX, y: () => formationY });
+      this.requestMoveTo({ x: () => formationX, y: () => formationY });
     }
   }
   /**
@@ -1091,6 +1148,110 @@ class BattleAi {
     const dy = entity1.y() - entity2.y();
     return Math.sqrt(dx * dx + dy * dy);
   }
+  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 - 0.5) * 40;
+    }
+    if (this.recentDamageTaken > 0) {
+      score -= Math.min(30, this.recentDamageTaken * 0.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 === "combat") {
+      if (currentTime - this.stateStartTime >= this.behaviorMinStateDuration) {
+        this.isMovingToTarget = false;
+        this.changeState(
+          "flee"
+          /* Flee */
+        );
+      }
+    } else if (this.behaviorMode === "assault" && this.state === "flee") {
+      if (currentTime - this.stateStartTime >= this.behaviorMinStateDuration) {
+        this.changeState(
+          "combat"
+          /* Combat */
+        );
+      }
+    }
+  }
+  handleTacticalMovement(distance) {
+    if (!this.target) return;
+    const minRange = this.attackRange * 0.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.isMovingToTarget = true;
+        this.requestMoveTo(this.target);
+      }
+      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.isMovingToTarget = true;
+        this.requestMoveTo(this.target);
+      }
+      return;
+    }
+    if (this.isMovingToTarget) {
+      this.debugLog("movement", `Assault hold (dist=${distance.toFixed(1)})`);
+      this.isMovingToTarget = false;
+      this.event.stopMoveTo();
+    }
+  }
+  requestMoveTo(target) {
+    const currentTime = Date.now();
+    if (currentTime - this.lastMoveToTime < this.moveToCooldown) {
+      return false;
+    }
+    this.event.moveTo(target);
+    this.lastMoveToTime = currentTime;
+    return true;
+  }
   // Public getters
   getHealth() {
     return this.event.hp;

package/dist/client/index4.js

@@ -1,4 +1,4 @@
-import { defineModule } from "@rpgjs/common";
+import { defineModule, Control } from "@rpgjs/common";
 const RpgEvent = null;
 const DEFAULT_KNOCKBACK = null;
 const DEFAULT_PLAYER_ATTACK_HITBOXES = {
@@ -70,8 +70,8 @@ defineModule({
      * @param input - Input data containing pressed keys
      */
     onInput(player, input) {
-      if (input.action) {
-        player.setAnimation("attack", 1);
+      if (input.action == Control.Action) {
+        player.setGraphicAnimation("attack", 1);
         const playerX = player.x();
         const playerY = player.y();
         const direction = player.getDirection();

package/dist/server/index2.js

@@ -1,5 +1,5 @@
 import { RpgEvent } from "@rpgjs/server";
-import { defineModule } from "@rpgjs/common";
+import { defineModule, Control } from "@rpgjs/common";
 import { DEFAULT_KNOCKBACK } from "./index3.js";
 const DEFAULT_PLAYER_ATTACK_HITBOXES = {
   up: { offsetX: -16, offsetY: -48, width: 32, height: 32 },
@@ -70,8 +70,8 @@ const server = defineModule({
      * @param input - Input data containing pressed keys
      */
     onInput(player, input) {
-      if (input.action) {
-        player.setAnimation("attack", 1);
+      if (input.action == Control.Action) {
+        player.setGraphicAnimation("attack", 1);
         const playerX = player.x();
         const playerY = player.y();
         const direction = player.getDirection();

package/dist/server/index3.js

@@ -100,6 +100,18 @@ class BattleAi {
     this.damageCheckInterval = 2e3;
     this.isMovingToTarget = false;
     this.lastFacingDirection = null;
+    this.behaviorScore = 50;
+    this.behaviorMode = "tactical";
+    this.behaviorLastUpdate = 0;
+    this.behaviorUpdateInterval = 400;
+    this.behaviorAssaultThreshold = 65;
+    this.behaviorRetreatThreshold = 35;
+    this.behaviorMinStateDuration = 600;
+    this.behaviorEnabled = false;
+    this.moveToCooldown = 400;
+    this.lastMoveToTime = 0;
+    this.retreatCooldown = 600;
+    this.lastRetreatTime = 0;
     event.battleAi = this;
     this.event = event;
     this.enemyType = options.enemyType || "aggressive";
@@ -115,6 +127,30 @@ class BattleAi {
     this.patrolWaypoints = options.patrolWaypoints || [];
     this.currentPatrolIndex = 0;
     this.onDefeatedCallback = options.onDefeated;
+    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;
+    }
     this.setupVision();
     this.startAiBehaviorLoop();
     this.changeState(
@@ -309,6 +345,9 @@ class BattleAi {
       const berserkerModifier = Math.max(0.3, hpPercent);
       this.attackCooldown = 800 * berserkerModifier;
     }
+    if (this.behaviorEnabled) {
+      this.updateBehavior(currentTime);
+    }
     switch (this.state) {
       case "idle":
         this.updateIdleBehavior();
@@ -402,7 +441,20 @@ class BattleAi {
       this.tryDodge();
       return;
     }
-    if (this.enemyType === "ranged") {
+    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 === "ranged") {
       if (distance < this.attackRange * 0.6) {
         this.debugLog("movement", `Retreating (dist=${distance.toFixed(1)}, minRange=${(this.attackRange * 0.6).toFixed(1)})`);
         this.isMovingToTarget = false;
@@ -411,7 +463,7 @@ class BattleAi {
         if (!this.isMovingToTarget) {
           this.debugLog("movement", `Moving to target (dist=${distance.toFixed(1)}, attackRange=${this.attackRange})`);
           this.isMovingToTarget = true;
-          this.event.moveTo(this.target);
+          this.requestMoveTo(this.target);
         }
       } else {
         if (this.isMovingToTarget) {
@@ -425,7 +477,7 @@ class BattleAi {
         if (!this.isMovingToTarget) {
           this.debugLog("movement", `Moving to target (dist=${distance.toFixed(1)}, attackRange=${this.attackRange})`);
           this.isMovingToTarget = true;
-          this.event.moveTo(this.target);
+          this.requestMoveTo(this.target);
         }
       } else {
         if (this.isMovingToTarget) {
@@ -590,7 +642,7 @@ class BattleAi {
   performMeleeAttack() {
     if (!this.target) return;
     this.faceTarget();
-    this.event.setAnimation("attack", 1);
+    this.event.setGraphicAnimation("attack", 1);
     if (this.attackSkill) {
       try {
         this.event.useSkill(this.attackSkill, this.target);
@@ -757,7 +809,7 @@ class BattleAi {
     if (!this.target) return;
     this.chargingAttack = true;
     this.faceTarget();
-    this.event.setAnimation("attack", 2);
+    this.event.setGraphicAnimation("attack", 2);
     setTimeout(() => {
       if (!this.target || this.state !== "combat") {
         this.chargingAttack = false;
@@ -779,7 +831,7 @@ class BattleAi {
    * Perform zone attack (360 degrees)
    */
   performZoneAttack() {
-    this.event.setAnimation("attack", 1);
+    this.event.setGraphicAnimation("attack", 1);
     const eventX = this.event.x();
     const eventY = this.event.y();
     const radius = 50;
@@ -914,18 +966,23 @@ class BattleAi {
       x: () => this.event.x() + dx / dist * 200,
       y: () => this.event.y() + dy / dist * 200
     };
-    this.event.moveTo(fleeTarget);
+    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;
     this.event.dash({ x: dx / dist, y: dy / dist }, 8, 200);
+    this.lastRetreatTime = currentTime;
   }
   /**
    * Check damage taken for retreat decision
@@ -943,7 +1000,7 @@ class BattleAi {
   startPatrol() {
     if (this.patrolWaypoints.length === 0) return;
     const waypoint = this.patrolWaypoints[this.currentPatrolIndex];
-    this.event.moveTo({ x: () => waypoint.x, y: () => waypoint.y });
+    this.requestMoveTo({ x: () => waypoint.x, y: () => waypoint.y });
   }
   /**
    * Update group behavior
@@ -1000,7 +1057,7 @@ class BattleAi {
       Math.pow(this.event.x() - formationX, 2) + Math.pow(this.event.y() - formationY, 2)
     );
     if (distanceToFormation > 20) {
-      this.event.moveTo({ x: () => formationX, y: () => formationY });
+      this.requestMoveTo({ x: () => formationX, y: () => formationY });
     }
   }
   /**
@@ -1090,6 +1147,110 @@ class BattleAi {
     const dy = entity1.y() - entity2.y();
     return Math.sqrt(dx * dx + dy * dy);
   }
+  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 - 0.5) * 40;
+    }
+    if (this.recentDamageTaken > 0) {
+      score -= Math.min(30, this.recentDamageTaken * 0.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 === "combat") {
+      if (currentTime - this.stateStartTime >= this.behaviorMinStateDuration) {
+        this.isMovingToTarget = false;
+        this.changeState(
+          "flee"
+          /* Flee */
+        );
+      }
+    } else if (this.behaviorMode === "assault" && this.state === "flee") {
+      if (currentTime - this.stateStartTime >= this.behaviorMinStateDuration) {
+        this.changeState(
+          "combat"
+          /* Combat */
+        );
+      }
+    }
+  }
+  handleTacticalMovement(distance) {
+    if (!this.target) return;
+    const minRange = this.attackRange * 0.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.isMovingToTarget = true;
+        this.requestMoveTo(this.target);
+      }
+      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.isMovingToTarget = true;
+        this.requestMoveTo(this.target);
+      }
+      return;
+    }
+    if (this.isMovingToTarget) {
+      this.debugLog("movement", `Assault hold (dist=${distance.toFixed(1)})`);
+      this.isMovingToTarget = false;
+      this.event.stopMoveTo();
+    }
+  }
+  requestMoveTo(target) {
+    const currentTime = Date.now();
+    if (currentTime - this.lastMoveToTime < this.moveToCooldown) {
+      return false;
+    }
+    this.event.moveTo(target);
+    this.lastMoveToTime = currentTime;
+    return true;
+  }
   // Public getters
   getHealth() {
     return this.event.hp;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpgjs/action-battle",
-  "version": "5.0.0-alpha.30",
+  "version": "5.0.0-alpha.32",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
@@ -23,10 +23,10 @@
   "description": "RPGJS is a framework for creating RPG/MMORPG games",
   "peerDependencies": {
     "@canvasengine/presets": "*",
-    "@rpgjs/client": "5.0.0-alpha.30",
-    "@rpgjs/common": "5.0.0-alpha.30",
-    "@rpgjs/server": "5.0.0-alpha.30",
-    "@rpgjs/vite": "5.0.0-alpha.30",
+    "@rpgjs/client": "5.0.0-alpha.32",
+    "@rpgjs/common": "5.0.0-alpha.32",
+    "@rpgjs/server": "5.0.0-alpha.32",
+    "@rpgjs/vite": "5.0.0-alpha.32",
     "canvasengine": "*"
   },
   "publishConfig": {

package/src/ai.server.ts

@@ -285,6 +285,21 @@ export class BattleAi {
   // Direction hysteresis to prevent animation flickering
   private lastFacingDirection: string | null = null;
 
+  // Behavior gauge (0-100)
+  private behaviorScore: number = 50;
+  private behaviorMode: 'assault' | 'tactical' | 'retreat' = 'tactical';
+  private behaviorLastUpdate: number = 0;
+  private behaviorUpdateInterval: number = 400;
+  private behaviorAssaultThreshold: number = 65;
+  private behaviorRetreatThreshold: number = 35;
+  private behaviorMinStateDuration: number = 600;
+  private behaviorEnabled: boolean = false;
+
+  // Movement throttling
+  private moveToCooldown: number = 400;
+  private lastMoveToTime: number = 0;
+  private retreatCooldown: number = 600;
+  private lastRetreatTime: number = 0;
 
   /**
    * Create a new Battle AI Controller
@@ -324,6 +339,15 @@ export class BattleAi {
       attackPatterns?: AttackPattern[];
       patrolWaypoints?: Array<{ x: number; y: number }>;
       groupBehavior?: boolean;
+      moveToCooldown?: number;
+      retreatCooldown?: number;
+      behavior?: {
+        baseScore?: number;
+        updateInterval?: number;
+        minStateDuration?: number;
+        assaultThreshold?: number;
+        retreatThreshold?: number;
+      };
       /** Callback called when the AI is defeated */
       onDefeated?: (event: RpgEvent) => void;
     } = {}
@@ -355,6 +379,33 @@ export class BattleAi {
     // Initialize defeat callback
     this.onDefeatedCallback = options.onDefeated;
 
+    // Behavior gauge settings
+    if (options.behavior) {
+      this.behaviorEnabled = true;
+      if (options.behavior.baseScore !== undefined) {
+        this.behaviorScore = options.behavior.baseScore;
+      }
+      if (options.behavior.updateInterval !== undefined) {
+        this.behaviorUpdateInterval = options.behavior.updateInterval;
+      }
+      if (options.behavior.minStateDuration !== undefined) {
+        this.behaviorMinStateDuration = options.behavior.minStateDuration;
+      }
+      if (options.behavior.assaultThreshold !== undefined) {
+        this.behaviorAssaultThreshold = options.behavior.assaultThreshold;
+      }
+      if (options.behavior.retreatThreshold !== undefined) {
+        this.behaviorRetreatThreshold = options.behavior.retreatThreshold;
+      }
+    }
+
+    if (options.moveToCooldown !== undefined) {
+      this.moveToCooldown = options.moveToCooldown;
+    }
+    if (options.retreatCooldown !== undefined) {
+      this.retreatCooldown = options.retreatCooldown;
+    }
+
     // Setup AI systems
     this.setupVision();
     this.startAiBehaviorLoop();
@@ -531,6 +582,11 @@ export class BattleAi {
       this.attackCooldown = 800 * berserkerModifier;
     }
 
+    // Update behavior gauge and state decision
+    if (this.behaviorEnabled) {
+      this.updateBehavior(currentTime);
+    }
+
     // State-specific behavior
     switch (this.state) {
       case AiState.Idle:
@@ -625,8 +681,24 @@ export class BattleAi {
       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;
+      }
+    }
+
     // Movement based on enemy type
-    if (this.enemyType === EnemyType.Ranged) {
+    if (this.behaviorEnabled && this.behaviorMode === 'assault') {
+      // Assault mode already handled movement
+    } else if (this.behaviorEnabled && this.behaviorMode === 'tactical') {
+      // Tactical mode already handled movement
+    } else if (this.enemyType === EnemyType.Ranged) {
       if (distance < this.attackRange * 0.6) {
         this.debugLog('movement', `Retreating (dist=${distance.toFixed(1)}, minRange=${(this.attackRange * 0.6).toFixed(1)})`);
         this.isMovingToTarget = false;
@@ -635,7 +707,7 @@ export class BattleAi {
         if (!this.isMovingToTarget) {
           this.debugLog('movement', `Moving to target (dist=${distance.toFixed(1)}, attackRange=${this.attackRange})`);
           this.isMovingToTarget = true;
-          this.event.moveTo(this.target);
+          this.requestMoveTo(this.target);
         }
       } else {
         if (this.isMovingToTarget) {
@@ -649,7 +721,7 @@ export class BattleAi {
         if (!this.isMovingToTarget) {
           this.debugLog('movement', `Moving to target (dist=${distance.toFixed(1)}, attackRange=${this.attackRange})`);
           this.isMovingToTarget = true;
-          this.event.moveTo(this.target);
+          this.requestMoveTo(this.target);
         }
       } else {
         if (this.isMovingToTarget) {
@@ -795,7 +867,7 @@ export class BattleAi {
     if (!this.target) return;
 
     this.faceTarget();
-    this.event.setAnimation('attack', 1);
+    this.event.setGraphicAnimation('attack', 1);
 
     // Use skill if available
     if (this.attackSkill) {
@@ -994,7 +1066,7 @@ export class BattleAi {
 
     this.chargingAttack = true;
     this.faceTarget();
-    this.event.setAnimation('attack', 2);
+    this.event.setGraphicAnimation('attack', 2);
 
     setTimeout(() => {
       if (!this.target || this.state !== AiState.Combat) {
@@ -1021,7 +1093,7 @@ export class BattleAi {
    * Perform zone attack (360 degrees)
    */
   private performZoneAttack() {
-    this.event.setAnimation('attack', 1);
+    this.event.setGraphicAnimation('attack', 1);
 
     const eventX = this.event.x();
     const eventY = this.event.y();
@@ -1202,7 +1274,7 @@ export class BattleAi {
       y: () => this.event.y() + (dy / dist) * 200
     };
 
-    this.event.moveTo(fleeTarget as any);
+    this.requestMoveTo(fleeTarget as any);
   }
 
   /**
@@ -1210,6 +1282,10 @@ export class BattleAi {
    */
   private 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();
@@ -1218,6 +1294,7 @@ export class BattleAi {
     if (dist === 0) return;
 
     this.event.dash({ x: dx / dist, y: dy / dist }, 8, 200);
+    this.lastRetreatTime = currentTime;
   }
 
   /**
@@ -1239,7 +1316,7 @@ export class BattleAi {
     if (this.patrolWaypoints.length === 0) return;
 
     const waypoint = this.patrolWaypoints[this.currentPatrolIndex];
-    this.event.moveTo({ x: () => waypoint.x, y: () => waypoint.y } as any);
+    this.requestMoveTo({ x: () => waypoint.x, y: () => waypoint.y } as any);
   }
 
   /**
@@ -1311,7 +1388,7 @@ export class BattleAi {
     );
 
     if (distanceToFormation > 20) {
-      this.event.moveTo({ x: () => formationX, y: () => formationY } as any);
+      this.requestMoveTo({ x: () => formationX, y: () => formationY } as any);
     }
   }
 
@@ -1409,6 +1486,120 @@ export class BattleAi {
     return Math.sqrt(dx * dx + dy * dy);
   }
 
+  private updateBehavior(currentTime: number) {
+    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 - 0.5) * 40;
+    }
+
+    if (this.recentDamageTaken > 0) {
+      score -= Math.min(30, this.recentDamageTaken * 0.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);
+      }
+    }
+  }
+
+  private handleTacticalMovement(distance: number) {
+    if (!this.target) return;
+    const minRange = this.attackRange * 0.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.isMovingToTarget = true;
+        this.requestMoveTo(this.target);
+      }
+      return;
+    }
+
+    if (this.isMovingToTarget) {
+      this.debugLog('movement', `Tactical hold (dist=${distance.toFixed(1)})`);
+      this.isMovingToTarget = false;
+      this.event.stopMoveTo();
+    }
+  }
+
+  private handleAssaultMovement(distance: number) {
+    if (!this.target) return;
+    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);
+      }
+      return;
+    }
+
+    if (this.isMovingToTarget) {
+      this.debugLog('movement', `Assault hold (dist=${distance.toFixed(1)})`);
+      this.isMovingToTarget = false;
+      this.event.stopMoveTo();
+    }
+  }
+
+  private requestMoveTo(target: any): boolean {
+    const currentTime = Date.now();
+    if (currentTime - this.lastMoveToTime < this.moveToCooldown) {
+      return false;
+    }
+    this.event.moveTo(target as any);
+    this.lastMoveToTime = currentTime;
+    return true;
+  }
+
   // Public getters
   getHealth(): number { return this.event.hp; }
   getMaxHealth(): number { return this.event.param[MAXHP]; }

package/src/server.ts

@@ -1,5 +1,5 @@
 import { RpgEvent, RpgPlayer, type RpgServer } from "@rpgjs/server";
-import { defineModule } from "@rpgjs/common";
+import { Control, defineModule } from "@rpgjs/common";
 import { BattleAi, HitResult, ApplyHitHooks, DEFAULT_KNOCKBACK } from "./ai.server";
 
 /**
@@ -148,9 +148,9 @@ export default defineModule<RpgServer>({
      * @param input - Input data containing pressed keys
      */
     onInput(player: RpgPlayer, input: any) {
-      if (input.action) {
+      if (input.action == Control.Action) {
         // Trigger attack animation
-        player.setAnimation('attack', 1);
+        player.setGraphicAnimation('attack', 1);
 
         // Get player position
         const playerX = player.x();