@rpgjs/action-battle 5.0.0-beta.1 → 5.0.0-beta.3

package/dist/server/index3.js

@@ -1,1289 +1,64 @@
-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);
-    }
-  }
+//#region src/config.ts
+var DEFAULT_ACTION_BATTLE_OPTIONS = {
+	ui: {
+		actionBar: {
+			enabled: false,
+			autoOpen: false,
+			mode: "both"
+		},
+		targeting: {
+			enabled: true,
+			showGrid: true,
+			colors: {
+				area: 3120887,
+				edge: 1796760,
+				cursor: 16765286
+			}
+		}
+	},
+	skills: { defaultAoeMask: ["#"] },
+	targeting: {
+		affects: "events",
+		allowEmptyTarget: true
+	},
+	animations: {}
 };
-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;
-    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";
-    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;
-    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(
-      "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;
-    }
-    if (this.behaviorEnabled) {
-      this.updateBehavior(currentTime);
-    }
-    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.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;
-        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.requestMoveTo(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.requestMoveTo(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.setGraphicAnimation("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.setGraphicAnimation("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.setGraphicAnimation("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.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
-   */
-  checkDamageTaken() {
-    const currentTime = Date.now();
-    if (currentTime - this.lastHpCheck >= this.damageCheckInterval) {
-      this.recentDamageTaken = 0;
-      this.lastHpCheck = currentTime;
-    }
-  }
-  /**
-   * Start patrol
-   */
-  startPatrol() {
-    if (this.patrolWaypoints.length === 0) return;
-    const waypoint = this.patrolWaypoints[this.currentPatrolIndex];
-    this.requestMoveTo({ x: () => waypoint.x, y: () => waypoint.y });
-  }
-  /**
-   * Update group behavior
-   */
-  updateGroupBehavior() {
-    if (!this.groupBehavior) return;
-    this.groupUpdateInterval++;
-    if (this.groupUpdateInterval >= 20) {
-      this.groupUpdateInterval = 0;
-      this.findNearbyEnemies();
-    }
-    if (this.nearbyEnemies.length > 0 && this.target && this.state === "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.requestMoveTo({ 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(attacker);
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Kill this AI
-   * 
-   * Stops all movements, cleans up resources, calls the onDefeated hook,
-   * and removes the event from the map.
-   */
-  kill(attacker) {
-    if (this.onDefeatedCallback) {
-      this.onDefeatedCallback(this.event, attacker);
-    }
-    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);
-  }
-  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;
-  }
-  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 = [];
-  }
+var currentActionBattleOptions = DEFAULT_ACTION_BATTLE_OPTIONS;
+function normalizeActionBattleOptions(options = {}) {
+	return {
+		ui: {
+			actionBar: {
+				...DEFAULT_ACTION_BATTLE_OPTIONS.ui?.actionBar,
+				...options.ui?.actionBar
+			},
+			targeting: {
+				...DEFAULT_ACTION_BATTLE_OPTIONS.ui?.targeting,
+				...options.ui?.targeting,
+				colors: {
+					...DEFAULT_ACTION_BATTLE_OPTIONS.ui?.targeting?.colors,
+					...options.ui?.targeting?.colors
+				}
+			}
+		},
+		skills: {
+			...DEFAULT_ACTION_BATTLE_OPTIONS.skills,
+			...options.skills
+		},
+		targeting: {
+			...DEFAULT_ACTION_BATTLE_OPTIONS.targeting,
+			...options.targeting
+		},
+		animations: {
+			...DEFAULT_ACTION_BATTLE_OPTIONS.animations,
+			...options.animations
+		}
+	};
 }
-export {
-  AiDebug,
-  AiState,
-  AttackPattern,
-  BattleAi,
-  DEFAULT_KNOCKBACK,
-  EnemyType
-};
+function setActionBattleOptions(options) {
+	currentActionBattleOptions = options;
+}
+function getActionBattleOptions() {
+	return currentActionBattleOptions;
+}
+//#endregion
+export { getActionBattleOptions, normalizeActionBattleOptions, setActionBattleOptions };