@rpgjs/action-battle 5.0.0-alpha.28

package/dist/server/index3.js

@@ -0,0 +1,1128 @@
+import { MAXHP, RpgPlayer } from "@rpgjs/server";
+const AiDebug = {
+  /** Enable/disable all AI debug logs */
+  enabled: typeof process !== "undefined" && 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) {
+    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);
+    }
+  }
+};
+var AiState = /* @__PURE__ */ ((AiState2) => {
+  AiState2["Idle"] = "idle";
+  AiState2["Alert"] = "alert";
+  AiState2["Combat"] = "combat";
+  AiState2["Flee"] = "flee";
+  AiState2["Stunned"] = "stunned";
+  return AiState2;
+})(AiState || {});
+var EnemyType = /* @__PURE__ */ ((EnemyType2) => {
+  EnemyType2["Aggressive"] = "aggressive";
+  EnemyType2["Defensive"] = "defensive";
+  EnemyType2["Ranged"] = "ranged";
+  EnemyType2["Tank"] = "tank";
+  EnemyType2["Berserker"] = "berserker";
+  return EnemyType2;
+})(EnemyType || {});
+var AttackPattern = /* @__PURE__ */ ((AttackPattern2) => {
+  AttackPattern2["Melee"] = "melee";
+  AttackPattern2["Combo"] = "combo";
+  AttackPattern2["Charged"] = "charged";
+  AttackPattern2["Zone"] = "zone";
+  AttackPattern2["DashAttack"] = "dashAttack";
+  return AttackPattern2;
+})(AttackPattern || {});
+const DEFAULT_KNOCKBACK = {
+  /** Default knockback force */
+  force: 50,
+  /** Default knockback duration in milliseconds */
+  duration: 300
+};
+class BattleAi {
+  /**
+   * Create a new Battle AI Controller
+   *
+   * The AI controls behavior only. Stats should be set on the event
+   * using standard RPGJS methods (hp, param, learnSkill, etc.)
+   *
+   * @param event - The event to control
+   * @param options - AI behavior configuration
+   *
+   * @example
+   * ```ts
+   * // In your event's onInit
+   * this.hp = 100;
+   * this.param[ATK] = 20;
+   * this.learnSkill(FireBall);
+   * 
+   * new BattleAi(this, {
+   *   enemyType: EnemyType.Ranged,
+   *   attackSkill: FireBall,
+   *   visionRange: 200,
+   *   fleeThreshold: 0.2
+   * });
+   * ```
+   */
+  constructor(event, options = {}) {
+    this.target = null;
+    this.lastAttackTime = 0;
+    this.state = "idle";
+    this.stateStartTime = 0;
+    this.stunnedUntil = 0;
+    this.lastDodgeTime = 0;
+    this.comboCount = 0;
+    this.comboMax = 3;
+    this.chargingAttack = false;
+    this.nearbyEnemies = [];
+    this.groupUpdateInterval = 0;
+    this.patrolWaypoints = [];
+    this.currentPatrolIndex = 0;
+    this.lastHpCheck = 0;
+    this.recentDamageTaken = 0;
+    this.damageCheckInterval = 2e3;
+    this.isMovingToTarget = false;
+    this.lastFacingDirection = null;
+    event.battleAi = this;
+    this.event = event;
+    this.enemyType = options.enemyType || "aggressive";
+    this.applyEnemyTypeBehavior(options);
+    this.attackSkill = options.attackSkill || null;
+    this.attackPatterns = options.attackPatterns || [
+      "melee",
+      "combo",
+      "dashAttack"
+      /* DashAttack */
+    ];
+    this.groupBehavior = options.groupBehavior || false;
+    this.patrolWaypoints = options.patrolWaypoints || [];
+    this.currentPatrolIndex = 0;
+    this.onDefeatedCallback = options.onDefeated;
+    this.setupVision();
+    this.startAiBehaviorLoop();
+    this.changeState(
+      "idle"
+      /* Idle */
+    );
+    this.debugLog("init", `AI created (type=${this.enemyType}, visionRange=${this.visionRange}, attackRange=${this.attackRange})`);
+  }
+  /**
+   * Log AI debug message for this event
+   */
+  debugLog(category, message, data) {
+    AiDebug.log(category, this.event.id, message, data);
+  }
+  /**
+   * 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 "aggressive":
+        this.attackCooldown = options.attackCooldown ?? 600;
+        this.visionRange = options.visionRange ?? 150;
+        this.attackRange = options.attackRange ?? 50;
+        this.dodgeChance = options.dodgeChance ?? 0.1;
+        this.dodgeCooldown = options.dodgeCooldown ?? 3e3;
+        this.fleeThreshold = options.fleeThreshold ?? 0.15;
+        break;
+      case "defensive":
+        this.attackCooldown = options.attackCooldown ?? 1500;
+        this.visionRange = options.visionRange ?? 120;
+        this.attackRange = options.attackRange ?? 60;
+        this.dodgeChance = options.dodgeChance ?? 0.5;
+        this.dodgeCooldown = options.dodgeCooldown ?? 1500;
+        this.fleeThreshold = options.fleeThreshold ?? 0.3;
+        break;
+      case "ranged":
+        this.attackCooldown = options.attackCooldown ?? 1200;
+        this.visionRange = options.visionRange ?? 200;
+        this.attackRange = options.attackRange ?? 120;
+        this.dodgeChance = options.dodgeChance ?? 0.4;
+        this.dodgeCooldown = options.dodgeCooldown ?? 2e3;
+        this.fleeThreshold = options.fleeThreshold ?? 0.25;
+        break;
+      case "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 ?? 0.1;
+        break;
+      case "berserker":
+        this.attackCooldown = options.attackCooldown ?? 800;
+        this.visionRange = options.visionRange ?? 180;
+        this.attackRange = options.attackRange ?? 55;
+        this.dodgeChance = options.dodgeChance ?? 0.15;
+        this.dodgeCooldown = options.dodgeCooldown ?? 2500;
+        this.fleeThreshold = options.fleeThreshold ?? 0.05;
+        break;
+      default:
+        this.attackCooldown = options.attackCooldown ?? 1e3;
+        this.visionRange = options.visionRange ?? 150;
+        this.attackRange = options.attackRange ?? 60;
+        this.dodgeChance = options.dodgeChance ?? 0.2;
+        this.dodgeCooldown = options.dodgeCooldown ?? 2e3;
+        this.fleeThreshold = options.fleeThreshold ?? 0.2;
+    }
+  }
+  /**
+   * Setup vision detection
+   */
+  setupVision() {
+    const diameter = this.visionRange * 2;
+    this.event.attachShape(`vision_${this.event.id}`, {
+      radius: this.visionRange,
+      width: diameter,
+      height: diameter,
+      angle: 360
+    });
+  }
+  /**
+   * 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) {
+    const validTransitions = {
+      [
+        "idle"
+        /* Idle */
+      ]: [
+        "alert",
+        "combat"
+        /* Combat */
+      ],
+      [
+        "alert"
+        /* Alert */
+      ]: [
+        "idle",
+        "combat"
+        /* Combat */
+      ],
+      [
+        "combat"
+        /* Combat */
+      ]: [
+        "idle",
+        "flee",
+        "stunned"
+        /* Stunned */
+      ],
+      [
+        "flee"
+        /* Flee */
+      ]: [
+        "idle",
+        "combat"
+        /* Combat */
+      ],
+      [
+        "stunned"
+        /* Stunned */
+      ]: [
+        "combat",
+        "idle"
+        /* Idle */
+      ]
+    };
+    if (!validTransitions[this.state].includes(newState)) {
+      this.debugLog("state", `INVALID transition ${this.state} -> ${newState}`);
+      return;
+    }
+    this.debugLog("state", `STATE change: ${this.state} -> ${newState}`);
+    this.state = newState;
+    this.stateStartTime = Date.now();
+    switch (newState) {
+      case "idle":
+        if (this.patrolWaypoints.length > 0) {
+          this.startPatrol();
+        }
+        break;
+      case "alert":
+        this.event.stopMoveTo();
+        break;
+      case "combat":
+        this.comboCount = 0;
+        break;
+      case "flee":
+        if (this.target) {
+          this.fleeFromTarget();
+        }
+        break;
+      case "stunned":
+        this.event.stopMoveTo();
+        break;
+    }
+  }
+  /**
+   * Main AI behavior update loop
+   */
+  updateAiBehavior() {
+    const currentTime = Date.now();
+    if (this.groupBehavior) {
+      this.updateGroupBehavior();
+    }
+    if (this.state === "stunned") {
+      if (currentTime >= this.stunnedUntil) {
+        this.changeState(
+          "combat"
+          /* Combat */
+        );
+      }
+      return;
+    }
+    if (this.enemyType === "berserker" && this.event.param[MAXHP]) {
+      const hpPercent = this.event.hp / this.event.param[MAXHP];
+      const berserkerModifier = Math.max(0.3, hpPercent);
+      this.attackCooldown = 800 * berserkerModifier;
+    }
+    switch (this.state) {
+      case "idle":
+        this.updateIdleBehavior();
+        break;
+      case "alert":
+        this.updateAlertBehavior();
+        break;
+      case "combat":
+        this.updateCombatBehavior(currentTime);
+        break;
+      case "flee":
+        this.updateFleeBehavior();
+        break;
+    }
+    this.checkDamageTaken();
+  }
+  /**
+   * Update idle behavior (patrolling)
+   */
+  updateIdleBehavior() {
+    if (this.patrolWaypoints.length > 0) {
+      const waypoint = this.patrolWaypoints[this.currentPatrolIndex];
+      const distance = this.getDistance(this.event, {
+        x: () => waypoint.x,
+        y: () => waypoint.y
+      });
+      if (distance < 10) {
+        this.currentPatrolIndex = (this.currentPatrolIndex + 1) % this.patrolWaypoints.length;
+      }
+    }
+  }
+  /**
+   * Update alert behavior
+   */
+  updateAlertBehavior() {
+    if (this.target) {
+      this.faceTarget();
+      const distance = this.getDistance(this.event, this.target);
+      if (distance <= this.attackRange * 1.5) {
+        this.changeState(
+          "combat"
+          /* Combat */
+        );
+      }
+    } else {
+      this.changeState(
+        "idle"
+        /* Idle */
+      );
+    }
+  }
+  /**
+   * Update combat behavior
+   */
+  updateCombatBehavior(currentTime) {
+    if (!this.target) {
+      this.debugLog("combat", "No target, returning to idle");
+      this.changeState(
+        "idle"
+        /* Idle */
+      );
+      return;
+    }
+    const distance = this.getDistance(this.event, this.target);
+    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.target = null;
+      this.isMovingToTarget = false;
+      this.event.stopMoveTo();
+      this.changeState(
+        "idle"
+        /* 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(
+          "flee"
+          /* Flee */
+        );
+        return;
+      }
+    }
+    if (this.canDodge() && this.shouldDodge()) {
+      this.debugLog("combat", "Attempting dodge");
+      this.isMovingToTarget = false;
+      this.tryDodge();
+      return;
+    }
+    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;
+        this.retreatFromTarget();
+      } 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.event.moveTo(this.target);
+        }
+      } 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.isMovingToTarget = true;
+          this.event.moveTo(this.target);
+        }
+      } 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(
+        "idle"
+        /* Idle */
+      );
+      return;
+    }
+    const distance = this.getDistance(this.event, this.target);
+    if (this.event.param[MAXHP]) {
+      const hpPercent = this.event.hp / this.event.param[MAXHP];
+      if (hpPercent > this.fleeThreshold * 1.5 || distance > this.visionRange * 2) {
+        this.changeState(
+          "combat"
+          /* 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 = {
+      [
+        "melee"
+        /* Melee */
+      ]: 40,
+      [
+        "combo"
+        /* Combo */
+      ]: 25,
+      [
+        "charged"
+        /* Charged */
+      ]: 15,
+      [
+        "zone"
+        /* Zone */
+      ]: 10,
+      [
+        "dashAttack"
+        /* DashAttack */
+      ]: 10
+    };
+    switch (this.enemyType) {
+      case "aggressive":
+        weights[
+          "combo"
+          /* Combo */
+        ] += 20;
+        weights[
+          "dashAttack"
+          /* DashAttack */
+        ] += 15;
+        break;
+      case "defensive":
+        weights[
+          "charged"
+          /* Charged */
+        ] += 25;
+        break;
+      case "ranged":
+        weights[
+          "zone"
+          /* Zone */
+        ] += 20;
+        break;
+      case "tank":
+        weights[
+          "charged"
+          /* Charged */
+        ] += 30;
+        weights[
+          "zone"
+          /* Zone */
+        ] += 15;
+        break;
+      case "berserker":
+        weights[
+          "combo"
+          /* 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] || "melee";
+  }
+  /**
+   * Perform attack pattern
+   */
+  performAttackPattern(pattern) {
+    switch (pattern) {
+      case "melee":
+        this.performMeleeAttack();
+        break;
+      case "combo":
+        this.performComboAttack();
+        break;
+      case "charged":
+        this.performChargedAttack();
+        break;
+      case "zone":
+        this.performZoneAttack();
+        break;
+      case "dashAttack":
+        this.performDashAttack();
+        break;
+    }
+  }
+  /**
+   * Perform melee attack
+   * Uses skill if configured, otherwise creates hitbox
+   */
+  performMeleeAttack() {
+    if (!this.target) return;
+    this.faceTarget();
+    this.event.setAnimation("attack", 1);
+    if (this.attackSkill) {
+      try {
+        this.event.useSkill(this.attackSkill, this.target);
+      } catch (e) {
+        this.performBasicHitbox();
+      }
+    } else {
+      this.performBasicHitbox();
+    }
+  }
+  /**
+   * Perform basic hitbox attack when no skill is set
+   */
+  performBasicHitbox() {
+    if (!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;
+    const hitboxes = [{
+      x: eventX + dirX * 30,
+      y: eventY + dirY * 30,
+      width: 40,
+      height: 40
+    }];
+    const map = this.event.getCurrentMap();
+    map?.createMovingHitbox(hitboxes, { speed: 5 }).subscribe({
+      next: (hits) => {
+        hits.forEach((hit) => {
+          if (hit instanceof RpgPlayer && hit !== this.event) {
+            this.applyHit(hit);
+          }
+        });
+      }
+    });
+  }
+  /**
+   * 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) {
+    const { damage } = target.applyDamage(this.event);
+    const knockbackForce = this.getWeaponKnockbackForce();
+    const knockbackDuration = DEFAULT_KNOCKBACK.duration;
+    let hitResult = {
+      damage,
+      knockbackForce,
+      knockbackDuration,
+      defeated: target.hp <= 0,
+      attacker: this.event,
+      target
+    };
+    if (hooks?.onBeforeHit) {
+      const modified = hooks.onBeforeHit(hitResult);
+      if (modified) {
+        hitResult = modified;
+      }
+    }
+    target.flash({
+      type: "tint",
+      tint: "red",
+      duration: 200,
+      cycles: 1
+    });
+    target.showHit(`-${hitResult.damage}`);
+    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);
+    }
+    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++;
+    this.performMeleeAttack();
+    if (this.comboCount < this.comboMax) {
+      setTimeout(() => {
+        if (this.target && this.state === "combat") {
+          this.performComboAttack();
+        } else {
+          this.comboCount = 0;
+        }
+      }, 300);
+    } else {
+      this.comboCount = 0;
+    }
+  }
+  /**
+   * Perform charged attack
+   */
+  performChargedAttack() {
+    if (!this.target) return;
+    this.chargingAttack = true;
+    this.faceTarget();
+    this.event.setAnimation("attack", 2);
+    setTimeout(() => {
+      if (!this.target || this.state !== "combat") {
+        this.chargingAttack = false;
+        return;
+      }
+      if (this.attackSkill) {
+        try {
+          this.event.useSkill(this.attackSkill, this.target);
+        } catch (e) {
+          this.performBasicHitbox();
+        }
+      } else {
+        this.performBasicHitbox();
+      }
+      this.chargingAttack = false;
+    }, 800);
+  }
+  /**
+   * Perform zone attack (360 degrees)
+   */
+  performZoneAttack() {
+    this.event.setAnimation("attack", 1);
+    const eventX = this.event.x();
+    const eventY = this.event.y();
+    const radius = 50;
+    const hitboxes = [];
+    const angles = [0, 90, 180, 270];
+    angles.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
+      });
+    });
+    const map = this.event.getCurrentMap();
+    map?.createMovingHitbox(hitboxes, { speed: 5 }).subscribe({
+      next: (hits) => {
+        hits.forEach((hit) => {
+          if (hit instanceof RpgPlayer && hit !== this.event) {
+            this.applyHit(hit);
+          }
+        });
+      }
+    });
+  }
+  /**
+   * Perform dash attack
+   */
+  performDashAttack() {
+    if (!this.target) return;
+    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();
+    this.event.dash({ x: dirX, y: dirY }, 10, 200);
+    setTimeout(() => {
+      if (!this.target || this.state !== "combat") return;
+      this.performMeleeAttack();
+    }, 200);
+  }
+  /**
+   * 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() {
+    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);
+    const minDistanceForDirectionChange = 40;
+    if (this.lastFacingDirection && distance < minDistanceForDirectionChange) {
+      return;
+    }
+    let newDirection;
+    if (absX >= absY) {
+      newDirection = dx >= 0 ? "right" : "left";
+    } else {
+      newDirection = dy >= 0 ? "down" : "up";
+    }
+    const hysteresisThreshold = 0.2;
+    const ratio = absX > 0 || absY > 0 ? Math.min(absX, absY) / Math.max(absX, absY) : 0;
+    if (this.lastFacingDirection && ratio > 1 - hysteresisThreshold) {
+      const isOpposite = this.lastFacingDirection === "left" && dx > 20 || this.lastFacingDirection === "right" && dx < -20 || this.lastFacingDirection === "up" && dy > 20 || this.lastFacingDirection === "down" && dy < -20;
+      if (!isOpposite) {
+        return;
+      }
+    }
+    this.lastFacingDirection = newDirection;
+    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;
+    }
+    if (Math.random() > this.dodgeChance) {
+      this.debugLog("dodge", `Dodge roll failed (chance=${(this.dodgeChance * 100).toFixed(0)}%)`);
+      return;
+    }
+    if (!this.target) return;
+    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 dodgeDirX = -dy / dist;
+    const dodgeDirY = dx / dist;
+    const side = Math.random() > 0.5 ? 1 : -1;
+    this.debugLog("dodge", `Dodging (dir=${side > 0 ? "right" : "left"})`);
+    this.event.dash({ x: dodgeDirX * side, y: dodgeDirY * side }, 12, 300);
+    this.lastDodgeTime = currentTime;
+    if (this.enemyType === "defensive" && Math.random() < 0.5) {
+      this.debugLog("dodge", "Counter-attack after dodge");
+      setTimeout(() => {
+        if (this.target && this.state === "combat") {
+          this.selectAndPerformAttack();
+        }
+      }, 400);
+    }
+  }
+  canDodge() {
+    if (this.dodgeChance === 0) return false;
+    return Date.now() - this.lastDodgeTime >= this.dodgeCooldown;
+  }
+  shouldDodge() {
+    if (!this.target) return false;
+    const distance = this.getDistance(this.event, this.target);
+    return distance < this.attackRange * 0.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.event.moveTo(fleeTarget);
+  }
+  /**
+   * Retreat from target (temporary)
+   */
+  retreatFromTarget() {
+    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;
+    this.event.dash({ x: dx / dist, y: dy / dist }, 8, 200);
+  }
+  /**
+   * 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.event.moveTo({ 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 === "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) {
+        const distance = this.getDistance(this.event, event);
+        if (distance <= 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;
+    const distanceToFormation = Math.sqrt(
+      Math.pow(this.event.x() - formationX, 2) + Math.pow(this.event.y() - formationY, 2)
+    );
+    if (distanceToFormation > 20) {
+      this.event.moveTo({ x: () => formationX, y: () => formationY });
+    }
+  }
+  /**
+   * Handle player entering vision
+   */
+  onDetectInShape(player, shape) {
+    this.debugLog("vision", `Player ${player.id} entered vision (state=${this.state})`);
+    this.target = player;
+    if (this.state === "idle") {
+      this.changeState(
+        "alert"
+        /* Alert */
+      );
+    } else if (this.state === "alert") {
+      this.changeState(
+        "combat"
+        /* Combat */
+      );
+    }
+  }
+  /**
+   * Handle player leaving vision
+   */
+  onDetectOutShape(player, shape) {
+    this.debugLog("vision", `Player ${player.id} left vision (wasTarget=${this.target === player})`);
+    if (this.target === player) {
+      this.target = null;
+      this.isMovingToTarget = false;
+      this.event.stopMoveTo();
+      this.changeState(
+        "idle"
+        /* 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) {
+    const { damage } = this.event.applyDamage(attacker);
+    this.debugLog("damage", `Took ${damage} damage from ${attacker.id} (HP: ${this.event.hp}/${this.event.param[MAXHP] || "?"})`);
+    this.event.flash({
+      type: "tint",
+      tint: "red",
+      duration: 200,
+      cycles: 1
+    });
+    this.event.showHit(`-${damage}`);
+    this.recentDamageTaken += damage;
+    if (this.state !== "stunned" && this.state !== "flee") {
+      this.debugLog("damage", "Stunned from damage");
+      this.isMovingToTarget = false;
+      this.stunnedUntil = Date.now() + 150;
+      this.changeState(
+        "stunned"
+        /* Stunned */
+      );
+    }
+    if (this.event.hp <= 0) {
+      this.debugLog("damage", "Defeated!");
+      this.kill();
+      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() {
+    if (this.onDefeatedCallback) {
+      this.onDefeatedCallback(this.event);
+    }
+    this.destroy();
+    this.event.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);
+  }
+  // Public getters
+  getHealth() {
+    return this.event.hp;
+  }
+  getMaxHealth() {
+    return this.event.param[MAXHP];
+  }
+  getTarget() {
+    return this.target;
+  }
+  getState() {
+    return this.state;
+  }
+  getEnemyType() {
+    return this.enemyType;
+  }
+  /**
+   * Clean up
+   */
+  destroy() {
+    if (this.updateInterval) {
+      clearInterval(this.updateInterval);
+      this.updateInterval = void 0;
+    }
+    this.target = null;
+    this.nearbyEnemies = [];
+  }
+}
+export {
+  AiDebug,
+  AiState,
+  AttackPattern,
+  BattleAi,
+  DEFAULT_KNOCKBACK,
+  EnemyType
+};