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

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @rpgjs/action-battle
 
+## 5.0.0-beta.12
+
+### Patch Changes
+
+- Prepare beta.12 with action battle AI, area queries, client visuals, event component resolvers, projectile handling, and related Vite/runtime updates.
+- Updated dependencies
+  - @rpgjs/client@5.0.0-beta.12
+  - @rpgjs/common@5.0.0-beta.12
+  - @rpgjs/server@5.0.0-beta.12
+  - @rpgjs/vite@5.0.0-beta.12
+
 ## 5.0.0-beta.11
 
 ### Patch Changes

package/dist/client/ai.server.d.ts

@@ -1,6 +1,7 @@
 import { RpgEvent, RpgPlayer } from '@rpgjs/server';
 import { ActionBattleEnemyAttackProfileMap } from './core/enemy-attack-profiles';
-import { ActionBattleDamageResult } from './core/contracts';
+import { ActionBattleAiSimpleBehavior, ActionBattleAiTreeInput } from './core/ai-behavior-tree';
+import { ActionBattleAiPreset, ActionBattleDamageResult, ActionBattleEntity, ActionBattleTargetSelector } from './core/contracts';
 import { NormalizedActionBattleHitReactionProfile, ActionBattleAnimationOptions } from './types';
 type RpgEventWithBattleAi = RpgEvent & {
     battleAi?: BattleAi;
@@ -23,13 +24,16 @@ export interface BattleAiDefeatReward {
 }
 export interface BattleAiDefeatedContext {
     event: RpgEvent;
-    attacker?: RpgPlayer;
+    attacker?: ActionBattleEntity;
     reward: BattleAiDefeatReward;
     remove: () => void;
 }
 export type BattleAiDefeatedCallback = (context: BattleAiDefeatedContext) => void;
-export type BattleAiLegacyDefeatedCallback = (event: RpgEvent, attacker?: RpgPlayer) => void;
+export type BattleAiLegacyDefeatedCallback = (event: RpgEvent, attacker?: ActionBattleEntity) => void;
 export interface BattleAiBaseOptions {
+    preset?: string | ActionBattleAiPreset;
+    faction?: string;
+    targets?: ActionBattleTargetSelector;
     enemyType?: EnemyType;
     attackCooldown?: number;
     visionRange?: number;
@@ -58,6 +62,9 @@ export interface BattleAiBaseOptions {
         retreatThreshold?: number;
     };
     behaviorKey?: string;
+    tree?: ActionBattleAiTreeInput;
+    behaviorTree?: ActionBattleAiTreeInput;
+    simpleBehavior?: ActionBattleAiSimpleBehavior;
     animations?: ActionBattleAnimationOptions;
     rewards?: BattleAiRewards;
     autoAwardRewards?: boolean;
@@ -280,6 +287,8 @@ export declare class BattleAi {
     private stateStartTime;
     private stunnedUntil;
     private enemyType;
+    private faction?;
+    private targets;
     private attackCooldown;
     private visionRange;
     private attackRange;
@@ -322,9 +331,15 @@ export declare class BattleAi {
     private lastRetreatTime;
     private timers;
     private behaviorKey?;
+    private behaviorTree?;
+    private aiMemory;
     private poise;
     private hitstunMs;
     private invincibilityMs;
+    private visionShape?;
+    private visionSetupRetries;
+    private maxVisionSetupRetries;
+    private destroyed;
     /**
      * Create a new Battle AI Controller
      *
@@ -362,6 +377,7 @@ export declare class BattleAi {
      * Setup vision detection
      */
     private setupVision;
+    private scheduleVisionSetup;
     /**
      * Start the AI behavior loop
      */
@@ -412,6 +428,9 @@ export declare class BattleAi {
      * Perform basic hitbox attack when no skill is set
      */
     private performBasicHitbox;
+    private resolveBasicHitboxes;
+    private queryHitboxCandidates;
+    private processHitboxHits;
     /**
      * Apply hit to target using RPGJS damage system with knockback
      *
@@ -524,19 +543,20 @@ export declare class BattleAi {
     /**
      * Handle player entering vision
      */
-    onDetectInShape(player: InstanceType<typeof RpgPlayer>, shape: any): void;
+    onDetectInShape(target: ActionBattleEntity, shape: any): void;
+    private engageTarget;
     /**
      * Handle player leaving vision
      */
-    onDetectOutShape(player: InstanceType<typeof RpgPlayer>, shape: any): void;
+    onDetectOutShape(target: ActionBattleEntity, shape: any): void;
     /**
      * 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: RpgPlayer): boolean;
-    handleDamage(attacker: RpgPlayer, damageResult: ActionBattleDamageResult & {
+    takeDamage(attacker: ActionBattleEntity): boolean;
+    handleDamage(attacker: ActionBattleEntity, damageResult: ActionBattleDamageResult & {
         reaction?: NormalizedActionBattleHitReactionProfile;
     }): boolean;
     /**
@@ -550,16 +570,33 @@ export declare class BattleAi {
      * Get distance between entities
      */
     private getDistance;
+    private resolveUsable;
+    private getCurrentActionRange;
+    private canTarget;
+    private findNearestTarget;
+    private isTargetDefeated;
+    private clearTarget;
     private updateBehavior;
     private applyCustomBehavior;
+    private applyAiDecision;
+    private createAiTreeContext;
+    private executeAiIntents;
+    private executeAiIntent;
+    private executeKeepDistance;
+    private executeRequestedAttack;
+    private executeRequestedSkill;
     private handleTacticalMovement;
     private handleAssaultMovement;
     private requestMoveTo;
     private schedule;
     getHealth(): number;
     getMaxHealth(): number;
-    getTarget(): InstanceType<typeof RpgPlayer> | null;
+    getTarget(): ActionBattleEntity | null;
     getState(): AiState;
+    getFaction(): string | undefined;
+    setFaction(faction: string | undefined): void;
+    getTargets(): ActionBattleTargetSelector;
+    setTargets(targets: ActionBattleTargetSelector): void;
     getEnemyType(): EnemyType;
     /**
      * Clean up

package/dist/client/attack-input.d.ts

@@ -0,0 +1,3 @@
+export type ActionBattleResolvedDirection = "up" | "down" | "left" | "right";
+export declare const resolveActionBattleAttackDirection: (entity: any, input?: any) => ActionBattleResolvedDirection;
+export declare const applyActionBattleAttackDirection: (entity: any, direction: ActionBattleResolvedDirection) => void;

package/dist/client/core/action-use.d.ts

@@ -0,0 +1,18 @@
+import { ActionBattleActionConfig, ActionBattleActionTarget, ActionBattleEntity, ActionBattleTargetOptions, ActionBattleProjectileImpactContext } from './contracts';
+import { NormalizedActionBattleAttackProfile } from '../types';
+export declare const getActionBattleActionConfig: (usable: any) => ActionBattleActionConfig | undefined;
+export declare const getActionBattleActionRange: (usable: any) => number | undefined;
+export declare const canActionBattleUseTarget: (attacker: ActionBattleEntity, target: ActionBattleEntity, actionTarget?: ActionBattleActionTarget, options?: ActionBattleTargetOptions) => boolean;
+export declare const shouldUseActionBattleUsable: (usable: any, explicitSkill?: any) => boolean;
+export declare const executeActionBattleUse: (input: {
+    attacker: ActionBattleEntity;
+    target?: ActionBattleEntity | ActionBattleEntity[] | null;
+    usable: any;
+    skill?: any;
+    weapon?: any;
+    pattern?: string;
+    profile?: NormalizedActionBattleAttackProfile;
+    playVisual?: boolean;
+}) => boolean;
+export declare const handleActionBattleProjectileImpact: (context: ActionBattleProjectileImpactContext) => void;
+export declare const handleActionBattleProjectileDestroy: (projectileId: string) => void;

package/dist/client/core/ai-behavior-tree.d.ts

@@ -0,0 +1,99 @@
+import { RpgEvent, RpgPlayer } from '@rpgjs/server';
+import { AiState, AttackPattern, EnemyType } from '../ai.server';
+import { ActionBattleAiContext, ActionBattleAiDecision } from './contracts';
+export type ActionBattleAiTreeStatus = "success" | "failure" | "running";
+export type ActionBattleAiMemory = Record<string, any>;
+export interface ActionBattleAiIntentBase {
+    consume?: boolean;
+    metadata?: Record<string, any>;
+}
+export type ActionBattleAiIntent = (ActionBattleAiIntentBase & {
+    type: "idle";
+}) | (ActionBattleAiIntentBase & {
+    type: "patrol";
+}) | (ActionBattleAiIntentBase & {
+    type: "faceTarget";
+}) | (ActionBattleAiIntentBase & {
+    type: "moveToTarget";
+}) | (ActionBattleAiIntentBase & {
+    type: "fleeFromTarget";
+}) | (ActionBattleAiIntentBase & {
+    type: "keepDistance";
+    distance: number;
+    tolerance?: number;
+}) | (ActionBattleAiIntentBase & {
+    type: "useAttack";
+    pattern?: AttackPattern | string;
+}) | (ActionBattleAiIntentBase & {
+    type: "useSkill";
+    skill: any;
+}) | (ActionBattleAiIntentBase & {
+    type: "setMode";
+    mode: NonNullable<ActionBattleAiDecision["mode"]>;
+});
+export interface ActionBattleAiSnapshotSelf {
+    event: RpgEvent;
+    state: AiState;
+    enemyType: EnemyType;
+    hpPercent: number | null;
+    attackRange: number;
+}
+export interface ActionBattleAiSnapshotTarget {
+    entity: RpgPlayer;
+    distance: number;
+    inAttackRange: boolean;
+    visible: boolean;
+}
+export interface ActionBattleAiTreeContext extends ActionBattleAiContext {
+    self: ActionBattleAiSnapshotSelf;
+    targetInfo: ActionBattleAiSnapshotTarget | null;
+    memory: ActionBattleAiMemory;
+}
+export interface ActionBattleAiTreeResult {
+    status: ActionBattleAiTreeStatus;
+    decision?: ActionBattleAiDecision;
+    intent?: ActionBattleAiIntent | ActionBattleAiIntent[];
+}
+export interface ActionBattleAiTreeNode {
+    tick(context: ActionBattleAiTreeContext): ActionBattleAiTreeResult;
+}
+export type ActionBattleAiTreeInput = ActionBattleAiTreeNode | ((context: ActionBattleAiTreeContext) => ActionBattleAiTreeResult | void);
+export type ActionBattleAiCondition = (context: ActionBattleAiTreeContext) => boolean;
+export type ActionBattleAiIntentInput = ActionBattleAiIntent | ActionBattleAiIntent[] | ActionBattleAiTreeNode | ((context: ActionBattleAiTreeContext) => ActionBattleAiIntent | ActionBattleAiIntent[]);
+export interface ActionBattleAiRule {
+    condition: ActionBattleAiCondition;
+    then: ActionBattleAiIntentInput;
+}
+export interface ActionBattleAiSimpleBehavior {
+    when?: ActionBattleAiRule[];
+    otherwise?: ActionBattleAiIntentInput;
+}
+export declare const defineAiTree: (input: ActionBattleAiTreeInput) => ActionBattleAiTreeNode;
+export declare const selector: (children: ActionBattleAiTreeInput[]) => ActionBattleAiTreeNode;
+export declare const sequence: (children: ActionBattleAiTreeInput[]) => ActionBattleAiTreeNode;
+export declare const condition: (predicate: ActionBattleAiCondition) => ActionBattleAiTreeNode;
+export declare const action: (input: ActionBattleAiIntentInput, status?: ActionBattleAiTreeStatus) => ActionBattleAiTreeNode;
+export declare const decision: (resolve: ActionBattleAiDecision | ((context: ActionBattleAiTreeContext) => ActionBattleAiDecision)) => ActionBattleAiTreeNode;
+export declare const rule: (predicate: ActionBattleAiCondition, then: ActionBattleAiIntentInput) => ActionBattleAiRule;
+export declare const defineAiBehavior: (behavior: ActionBattleAiSimpleBehavior) => ActionBattleAiTreeNode;
+export declare const hpBelow: (ratio: number) => ActionBattleAiCondition;
+export declare const targetVisible: () => ActionBattleAiCondition;
+export declare const targetInRange: (range?: number) => ActionBattleAiCondition;
+export declare const distanceLessThan: (distance: number) => ActionBattleAiCondition;
+export declare const inState: (state: AiState) => ActionBattleAiCondition;
+export declare const isEnemyType: (enemyType: EnemyType) => ActionBattleAiCondition;
+export declare const idle: () => ActionBattleAiIntent;
+export declare const patrol: () => ActionBattleAiIntent;
+export declare const faceTarget: () => ActionBattleAiIntent;
+export declare const chase: () => ActionBattleAiIntent;
+export declare const moveToTarget: () => ActionBattleAiIntent;
+export declare const flee: () => ActionBattleAiIntent;
+export declare const fleeFromTarget: () => ActionBattleAiIntent;
+export declare const keepDistance: (distance: number, tolerance?: number) => ActionBattleAiIntent;
+export declare const useAttack: (pattern?: AttackPattern | string) => ActionBattleAiIntent;
+export declare const useSkill: (skill: any) => ActionBattleAiIntent;
+export declare const setMode: (mode: NonNullable<ActionBattleAiDecision["mode"]>) => ActionBattleAiIntent;
+export declare const ifHpBelow: (ratio: number, then: ActionBattleAiIntentInput) => ActionBattleAiRule;
+export declare const ifTargetVisible: (then: ActionBattleAiIntentInput) => ActionBattleAiRule;
+export declare const ifTargetInRange: (then: ActionBattleAiIntentInput, range?: number) => ActionBattleAiRule;
+export declare const ifDistanceLessThan: (distance: number, then: ActionBattleAiIntentInput) => ActionBattleAiRule;

package/dist/client/core/attack-runtime.d.ts

@@ -1,8 +1,10 @@
 import { ActionBattleAttackHitPolicy, ActionBattleOptions, NormalizedActionBattleAttackProfile } from '../types';
+import { ActionBattleHitbox } from './contracts';
 export declare const ACTION_BATTLE_HITBOX_FRAME_MS = 16;
 export declare function getNormalizedActionBattleAttackProfile(options?: ActionBattleOptions): NormalizedActionBattleAttackProfile;
 export declare function resolveActionBattleHitboxSpeed(profile: NormalizedActionBattleAttackProfile, hitboxCount: number): number;
 export declare function scheduleActionBattleStartup(profile: NormalizedActionBattleAttackProfile, callback: () => void, scheduler?: (callback: () => void, delayMs: number) => unknown): unknown;
+export declare function runActionBattleActiveHitbox(profile: NormalizedActionBattleAttackProfile, resolveHitboxes: () => ActionBattleHitbox[], onHitboxes: (hitboxes: ActionBattleHitbox[]) => void, scheduler?: (callback: () => void, delayMs: number) => unknown): unknown;
 export declare function createActionBattleAttackId(attackerId: string | number | undefined, profileId: string): string;
 export declare class ActionBattleHitTracker {
     private readonly hitPolicy;

package/dist/client/core/defaults.d.ts

@@ -1,5 +1,5 @@
 import { RpgPlayer } from '@rpgjs/server';
-import { ActionBattleAiBehavior, ActionBattleAttackContext, ActionBattleCombatSystem, ActionBattleDamageContext, ActionBattleKnockbackContext, ActionBattleKnockbackResult, ActionBattleSystems } from './contracts';
+import { ActionBattleAiBehavior, ActionBattleAiPreset, ActionBattleAttackContext, ActionBattleCombatSystem, ActionBattleDamageContext, ActionBattleKnockbackContext, ActionBattleKnockbackResult, ActionBattleSystems } from './contracts';
 export declare const DEFAULT_ZELDA_PLAYER_HITBOXES: {
     up: {
         offsetX: number;
@@ -77,5 +77,6 @@ export declare const defaultRpgjsDamageResolver: (context: ActionBattleDamageCon
 export declare const defaultKnockbackResolver: (context: ActionBattleKnockbackContext) => ActionBattleKnockbackResult;
 export declare const defaultCombatSystem: ActionBattleCombatSystem;
 export declare const defaultEnemyBehaviors: Record<string, ActionBattleAiBehavior>;
+export declare const defaultEnemyPresets: Record<string, ActionBattleAiPreset>;
 export declare const defaultActionBattleSystems: ActionBattleSystems;
 export declare const getEntityWeaponKnockbackForce: (entity: RpgPlayer) => number;

package/dist/client/core/equipment.d.ts

@@ -1,2 +1,3 @@
 import { ActionBattleAttackProfile } from '../types';
+export declare function resolveActionBattleWeapon(entity: any): any | null;
 export declare function resolveActionBattleWeaponAttackProfile(entity: any): ActionBattleAttackProfile | null;

package/dist/client/core/targets.d.ts

@@ -0,0 +1,15 @@
+import { ActionBattleEntity, ActionBattleTargetContext, ActionBattleTargetOptions, ActionBattleTargetSelector } from './contracts';
+export declare const ACTION_BATTLE_PLAYER_FACTION = "players";
+export declare const ACTION_BATTLE_ENEMY_FACTION = "enemies";
+type EntityKind = "player" | "event";
+export declare const getActionBattleEntityKind: (entity: ActionBattleEntity) => EntityKind;
+export declare const isActionBattlePlayer: (entity: ActionBattleEntity) => boolean;
+export declare const isActionBattleEvent: (entity: ActionBattleEntity) => boolean;
+export declare const isActionBattleCombatEntity: (entity: ActionBattleEntity | undefined | null) => entity is ActionBattleEntity;
+export declare const getActionBattleFaction: (entity: ActionBattleEntity, options?: ActionBattleTargetOptions) => string | undefined;
+export declare const getActionBattleTargets: (entity: ActionBattleEntity, fallback: ActionBattleTargetSelector) => ActionBattleTargetSelector;
+export declare const isActionBattleTargetDefeated: (target: ActionBattleEntity | null | undefined) => boolean;
+export declare const matchesActionBattleTargetSelector: (selector: ActionBattleTargetSelector | undefined, context: ActionBattleTargetContext) => boolean;
+export declare const canActionBattleTarget: (attacker: ActionBattleEntity, target: ActionBattleEntity, selector: ActionBattleTargetSelector | undefined, options?: ActionBattleTargetOptions) => boolean;
+export declare const getActionBattleEntitiesInRange: (attacker: ActionBattleEntity, radius: number, selector: ActionBattleTargetSelector | undefined, options?: ActionBattleTargetOptions) => ActionBattleEntity[];
+export {};

package/dist/client/enemies/factory.d.ts

@@ -4,4 +4,6 @@ export interface ActionBattleEnemyPreset extends BattleAiOptions {
     stats?: (event: RpgEvent) => void;
 }
 export type ActionBattleEnemyPresetMap = Record<string, ActionBattleEnemyPreset>;
+export declare const defineActionBattleEnemy: <T extends ActionBattleEnemyPreset>(preset: T) => T;
+export declare const defineActionBattleAiPreset: <T extends BattleAiOptions>(preset: T) => T;
 export declare const createActionEnemy: (event: RpgEvent, presetOrOptions: string | BattleAiOptions, presets?: ActionBattleEnemyPresetMap) => BattleAi;

package/dist/client/index.d.ts

@@ -1,18 +1,23 @@
 import { ActionBattleOptions } from './types';
 export { BattleAi, AiState, EnemyType, AttackPattern, AiDebug, DEFAULT_KNOCKBACK } from './ai.server';
 export type { HitResult, ApplyHitHooks, BattleAiOptions, BattleAiDefeatedCallback, BattleAiDefeatedContext, BattleAiDefeatReward, BattleAiLegacyDefeatedCallback, BattleAiLegacyOptions, BattleAiRewardItem, BattleAiRewards, } from './ai.server';
-export type { ActionBattleAnimationContext, ActionBattleAnimationEntity, ActionBattleAnimationKey, ActionBattleAnimationOptions, ActionBattleAnimationResolver, ActionBattleAnimationResult, ActionBattleOptions, ActionBattleActionBarData, ActionBattleActionBarItem, ActionBattleActionBarSkill, ActionBattleSkillTargeting, ActionBattleSkillTargetingResolver, ActionBattleAttackOptions, ActionBattleUiOptions, ActionBattleUiActionBarOptions, ActionBattleUiTargetingOptions, ActionBattleAttackDirection, ActionBattleAttackHitboxConfig, ActionBattleAttackHitboxMap, ActionBattleAttackHitPolicy, ActionBattleAttackProfile, ActionBattleDebugOptions, ActionBattleHitReactionProfile, NormalizedActionBattleHitReactionProfile, NormalizedActionBattleAttackProfile, ActionBattleCombatOptions, ActionBattleSystemOptions, ActionBattleAiSystemOptions, } from './types';
-export type { ActionBattleAiBehavior, ActionBattleAiContext, ActionBattleAiDecision, ActionBattleAttackContext, ActionBattleCombatSystem, ActionBattleDamageContext, ActionBattleDamageResult, ActionBattleDirection, ActionBattleEntity, ActionBattleHitContext, ActionBattleHitHooks, ActionBattleHitResult, ActionBattleHitbox, ActionBattleKnockbackContext, ActionBattleKnockbackResult, ActionBattleSystems, } from './core/contracts';
+export type { ActionBattleAnimationContext, ActionBattleAnimationEntity, ActionBattleAnimationKey, ActionBattleAnimationOptions, ActionBattleAnimationResolver, ActionBattleAnimationResult, ActionBattleAiOptions, ActionBattleOptions, ActionBattleActionBarData, ActionBattleActionBarItem, ActionBattleActionBarSkill, ActionBattleSkillTargeting, ActionBattleSkillTargetingResolver, ActionBattleAttackOptions, ActionBattleUiOptions, ActionBattleUiActionBarOptions, ActionBattleUiAttackPreviewOptions, ActionBattleUiGuiEntry, ActionBattleUiTargetingOptions, ActionBattleAttackDirection, ActionBattleAttackHitboxConfig, ActionBattleAttackHitboxMap, ActionBattleAttackHitPolicy, ActionBattleAttackProfile, ActionBattleHitReactionProfile, NormalizedActionBattleHitReactionProfile, NormalizedActionBattleAttackProfile, ActionBattleCombatOptions, ActionBattleSystemOptions, ActionBattleAiSystemOptions, ActionBattleVisualComposer, ActionBattleVisualContext, ActionBattleVisualHelpers, ActionBattleVisualInput, ActionBattleVisualMoment, ActionBattleVisualPart, ActionBattleVisualPreset, } from './types';
+export type { ActionBattleAiBehavior, ActionBattleAiContext, ActionBattleAiDecision, ActionBattleAiPreset, ActionBattleAttackContext, ActionBattleCombatSystem, ActionBattleDamageContext, ActionBattleDamageResult, ActionBattleDirection, ActionBattleEntity, ActionBattleActionConfig, ActionBattleActionMode, ActionBattleActionTarget, ActionBattleTargetContext, ActionBattleTargetOptions, ActionBattleTargetSelector, ActionBattleProjectileImpactContext, ActionBattleProjectileOptions, ActionBattleUsable, ActionBattleUseContext, ActionBattleHitContext, ActionBattleHitHooks, ActionBattleHitResult, ActionBattleHitbox, ActionBattleKnockbackContext, ActionBattleKnockbackResult, ActionBattleSystems, } from './core/contracts';
+export { action, chase, condition, decision, defineAiBehavior, defineAiTree, distanceLessThan, faceTarget, flee, fleeFromTarget, hpBelow, idle, ifDistanceLessThan, ifHpBelow, ifTargetInRange, ifTargetVisible, inState, isEnemyType, keepDistance, moveToTarget, patrol, rule, selector, sequence, setMode, targetInRange, targetVisible, useAttack, useSkill, type ActionBattleAiCondition, type ActionBattleAiIntent, type ActionBattleAiIntentInput, type ActionBattleAiMemory, type ActionBattleAiRule, type ActionBattleAiSimpleBehavior, type ActionBattleAiSnapshotSelf, type ActionBattleAiSnapshotTarget, type ActionBattleAiTreeContext, type ActionBattleAiTreeInput, type ActionBattleAiTreeNode, type ActionBattleAiTreeResult, type ActionBattleAiTreeStatus, } from './core/ai-behavior-tree';
 export { DEFAULT_ACTION_BATTLE_ATTACK_PROFILE, normalizeActionBattleAttackProfile, type ActionBattleAttackProfileFallbacks, } from './core/attack-profile';
-export { ACTION_BATTLE_HITBOX_FRAME_MS, ActionBattleHitTracker, createActionBattleAttackId, getNormalizedActionBattleAttackProfile, resolveActionBattleHitboxSpeed, scheduleActionBattleStartup, } from './core/attack-runtime';
+export { ACTION_BATTLE_HITBOX_FRAME_MS, ActionBattleHitTracker, createActionBattleAttackId, getNormalizedActionBattleAttackProfile, resolveActionBattleHitboxSpeed, runActionBattleActiveHitbox, scheduleActionBattleStartup, } from './core/attack-runtime';
+export { canActionBattleUseTarget, executeActionBattleUse, getActionBattleActionConfig, getActionBattleActionRange, handleActionBattleProjectileDestroy, handleActionBattleProjectileImpact, shouldUseActionBattleUsable, } from './core/action-use';
 export { DEFAULT_ACTION_BATTLE_HIT_REACTION, isActionBattleEntityInvincible, normalizeActionBattleHitReaction, setActionBattleInvincibility, } from './core/hit-reaction';
 export { DEFAULT_ACTION_BATTLE_ENEMY_ATTACK_PROFILES, normalizeActionBattleEnemyAttackProfiles, type ActionBattleEnemyAttackProfileKey, type ActionBattleEnemyAttackProfileMap, type NormalizedActionBattleEnemyAttackProfileMap, } from './core/enemy-attack-profiles';
-export { resolveActionBattleWeaponAttackProfile } from './core/equipment';
-export { DEFAULT_ZELDA_PLAYER_HITBOXES, createDefaultPlayerHitboxResolver, defaultCombatSystem, defaultEnemyBehaviors, defaultKnockbackResolver, defaultRpgjsDamageResolver, } from './core/defaults';
+export { resolveActionBattleWeapon, resolveActionBattleWeaponAttackProfile, } from './core/equipment';
+export { DEFAULT_ZELDA_PLAYER_HITBOXES, createDefaultPlayerHitboxResolver, defaultCombatSystem, defaultEnemyBehaviors, defaultEnemyPresets, defaultKnockbackResolver, defaultRpgjsDamageResolver, } from './core/defaults';
+export { ACTION_BATTLE_ENEMY_FACTION, ACTION_BATTLE_PLAYER_FACTION, canActionBattleTarget, getActionBattleFaction, getActionBattleTargets, isActionBattleCombatEntity, isActionBattleEvent, isActionBattlePlayer, matchesActionBattleTargetSelector, } from './core/targets';
 export { createActionBattleSystems, getActionBattleSystems, } from './core/context';
 export { applyActionBattleHit } from './core/hit';
-export { createActionEnemy, type ActionBattleEnemyPreset, type ActionBattleEnemyPresetMap, } from './enemies/factory';
-export { DEFAULT_PLAYER_ATTACK_HITBOXES, getPlayerWeaponKnockbackForce, applyPlayerHitToEvent, ACTION_BATTLE_ACTION_BAR_GUI_ID, openActionBattleActionBar, updateActionBattleActionBar, createActionBattleServer, } from './server';
+export { ACTION_BATTLE_CLIENT_VISUAL_ID, ACTION_BATTLE_HIT_FX_COMPONENT_ID, createActionBattleClientVisuals, createActionBattleVisual, createClassicActionBattleVisual, createFxActionBattleVisual, emitActionBattleClientVisual, playActionBattleVisual, setActionBattlePreviewStarter, } from './visual';
+export { ActionBattleUi, createActionBattleUi, resolveActionBattleUi, type ResolvedActionBattleUi, } from './ui';
+export { createActionEnemy, defineActionBattleAiPreset, defineActionBattleEnemy, type ActionBattleEnemyPreset, type ActionBattleEnemyPresetMap, } from './enemies/factory';
+export { DEFAULT_PLAYER_ATTACK_HITBOXES, getPlayerWeaponKnockbackForce, applyActionBattleEntityHit, applyPlayerHitToEvent, ACTION_BATTLE_ACTION_BAR_GUI_ID, openActionBattleActionBar, updateActionBattleActionBar, createActionBattleServer, } from './server';
 export declare function provideActionBattle(options?: ActionBattleOptions): any[];
 declare const _default: {
     server: import('@rpgjs/server').RpgServer;

package/dist/client/index.js

@@ -1,15 +1,20 @@
 import { DEFAULT_ACTION_BATTLE_HIT_REACTION, isActionBattleEntityInvincible, normalizeActionBattleHitReaction, setActionBattleInvincibility } from "./index2.js";
 import { DEFAULT_ACTION_BATTLE_ATTACK_PROFILE, normalizeActionBattleAttackProfile } from "./index3.js";
-import { ACTION_BATTLE_HITBOX_FRAME_MS, ActionBattleHitTracker, createActionBattleAttackId, getNormalizedActionBattleAttackProfile, resolveActionBattleHitboxSpeed, scheduleActionBattleStartup } from "./index11.js";
-import client_default, { createActionBattleClient } from "./index12.js";
-import { DEFAULT_ZELDA_PLAYER_HITBOXES, createDefaultPlayerHitboxResolver, defaultCombatSystem, defaultEnemyBehaviors, defaultKnockbackResolver, defaultRpgjsDamageResolver } from "./index13.js";
-import { createActionBattleSystems, getActionBattleSystems } from "./index14.js";
-import { DEFAULT_ACTION_BATTLE_ENEMY_ATTACK_PROFILES, normalizeActionBattleEnemyAttackProfiles } from "./index15.js";
-import { AiDebug, AiState, AttackPattern, BattleAi, DEFAULT_KNOCKBACK, EnemyType } from "./index16.js";
-import { resolveActionBattleWeaponAttackProfile } from "./index17.js";
-import { applyActionBattleHit } from "./index18.js";
-import { createActionEnemy } from "./index19.js";
-import { ACTION_BATTLE_ACTION_BAR_GUI_ID, DEFAULT_PLAYER_ATTACK_HITBOXES, applyPlayerHitToEvent, createActionBattleServer, getPlayerWeaponKnockbackForce, openActionBattleActionBar, updateActionBattleActionBar } from "./index20.js";
+import { ACTION_BATTLE_HITBOX_FRAME_MS, ActionBattleHitTracker, createActionBattleAttackId, getNormalizedActionBattleAttackProfile, resolveActionBattleHitboxSpeed, runActionBattleActiveHitbox, scheduleActionBattleStartup } from "./index6.js";
+import { ActionBattleUi, createActionBattleUi, resolveActionBattleUi } from "./index13.js";
+import { ACTION_BATTLE_CLIENT_VISUAL_ID, ACTION_BATTLE_HIT_FX_COMPONENT_ID, createActionBattleClientVisuals, createActionBattleVisual, createClassicActionBattleVisual, createFxActionBattleVisual, emitActionBattleClientVisual, playActionBattleVisual, setActionBattlePreviewStarter } from "./index15.js";
+import client_default, { createActionBattleClient } from "./index16.js";
+import { DEFAULT_ZELDA_PLAYER_HITBOXES, createDefaultPlayerHitboxResolver, defaultCombatSystem, defaultEnemyBehaviors, defaultEnemyPresets, defaultKnockbackResolver, defaultRpgjsDamageResolver } from "./index17.js";
+import { createActionBattleSystems, getActionBattleSystems } from "./index18.js";
+import { DEFAULT_ACTION_BATTLE_ENEMY_ATTACK_PROFILES, normalizeActionBattleEnemyAttackProfiles } from "./index19.js";
+import { applyActionBattleHit } from "./index20.js";
+import { ACTION_BATTLE_ENEMY_FACTION, ACTION_BATTLE_PLAYER_FACTION, canActionBattleTarget, getActionBattleFaction, getActionBattleTargets, isActionBattleCombatEntity, isActionBattleEvent, isActionBattlePlayer, matchesActionBattleTargetSelector } from "./index21.js";
+import { canActionBattleUseTarget, executeActionBattleUse, getActionBattleActionConfig, getActionBattleActionRange, handleActionBattleProjectileDestroy, handleActionBattleProjectileImpact, shouldUseActionBattleUsable } from "./index22.js";
+import { resolveActionBattleWeapon, resolveActionBattleWeaponAttackProfile } from "./index23.js";
+import { action, chase, condition, decision, defineAiBehavior, defineAiTree, distanceLessThan, faceTarget, flee, fleeFromTarget, hpBelow, idle, ifDistanceLessThan, ifHpBelow, ifTargetInRange, ifTargetVisible, inState, isEnemyType, keepDistance, moveToTarget, patrol, rule, selector, sequence, setMode, targetInRange, targetVisible, useAttack, useSkill } from "./index25.js";
+import { AiDebug, AiState, AttackPattern, BattleAi, DEFAULT_KNOCKBACK, EnemyType } from "./index26.js";
+import { createActionEnemy, defineActionBattleAiPreset, defineActionBattleEnemy } from "./index27.js";
+import { ACTION_BATTLE_ACTION_BAR_GUI_ID, DEFAULT_PLAYER_ATTACK_HITBOXES, applyActionBattleEntityHit, applyPlayerHitToEvent, createActionBattleServer, getPlayerWeaponKnockbackForce, openActionBattleActionBar, updateActionBattleActionBar } from "./index28.js";
 import { createModule } from "@rpgjs/common";
 //#region src/index.ts
 var server = null;
@@ -25,4 +30,4 @@ var src_default = {
 	client: client_default
 };
 //#endregion
-export { ACTION_BATTLE_ACTION_BAR_GUI_ID, ACTION_BATTLE_HITBOX_FRAME_MS, ActionBattleHitTracker, AiDebug, AiState, AttackPattern, BattleAi, DEFAULT_ACTION_BATTLE_ATTACK_PROFILE, DEFAULT_ACTION_BATTLE_ENEMY_ATTACK_PROFILES, DEFAULT_ACTION_BATTLE_HIT_REACTION, DEFAULT_KNOCKBACK, DEFAULT_PLAYER_ATTACK_HITBOXES, DEFAULT_ZELDA_PLAYER_HITBOXES, EnemyType, applyActionBattleHit, applyPlayerHitToEvent, createActionBattleAttackId, createActionBattleServer, createActionBattleSystems, createActionEnemy, createDefaultPlayerHitboxResolver, src_default as default, defaultCombatSystem, defaultEnemyBehaviors, defaultKnockbackResolver, defaultRpgjsDamageResolver, getActionBattleSystems, getNormalizedActionBattleAttackProfile, getPlayerWeaponKnockbackForce, isActionBattleEntityInvincible, normalizeActionBattleAttackProfile, normalizeActionBattleEnemyAttackProfiles, normalizeActionBattleHitReaction, openActionBattleActionBar, provideActionBattle, resolveActionBattleHitboxSpeed, resolveActionBattleWeaponAttackProfile, scheduleActionBattleStartup, setActionBattleInvincibility, updateActionBattleActionBar };
+export { ACTION_BATTLE_ACTION_BAR_GUI_ID, ACTION_BATTLE_CLIENT_VISUAL_ID, ACTION_BATTLE_ENEMY_FACTION, ACTION_BATTLE_HITBOX_FRAME_MS, ACTION_BATTLE_HIT_FX_COMPONENT_ID, ACTION_BATTLE_PLAYER_FACTION, ActionBattleHitTracker, ActionBattleUi, AiDebug, AiState, AttackPattern, BattleAi, DEFAULT_ACTION_BATTLE_ATTACK_PROFILE, DEFAULT_ACTION_BATTLE_ENEMY_ATTACK_PROFILES, DEFAULT_ACTION_BATTLE_HIT_REACTION, DEFAULT_KNOCKBACK, DEFAULT_PLAYER_ATTACK_HITBOXES, DEFAULT_ZELDA_PLAYER_HITBOXES, EnemyType, action, applyActionBattleEntityHit, applyActionBattleHit, applyPlayerHitToEvent, canActionBattleTarget, canActionBattleUseTarget, chase, condition, createActionBattleAttackId, createActionBattleClientVisuals, createActionBattleServer, createActionBattleSystems, createActionBattleUi, createActionBattleVisual, createActionEnemy, createClassicActionBattleVisual, createDefaultPlayerHitboxResolver, createFxActionBattleVisual, decision, src_default as default, defaultCombatSystem, defaultEnemyBehaviors, defaultEnemyPresets, defaultKnockbackResolver, defaultRpgjsDamageResolver, defineActionBattleAiPreset, defineActionBattleEnemy, defineAiBehavior, defineAiTree, distanceLessThan, emitActionBattleClientVisual, executeActionBattleUse, faceTarget, flee, fleeFromTarget, getActionBattleActionConfig, getActionBattleActionRange, getActionBattleFaction, getActionBattleSystems, getActionBattleTargets, getNormalizedActionBattleAttackProfile, getPlayerWeaponKnockbackForce, handleActionBattleProjectileDestroy, handleActionBattleProjectileImpact, hpBelow, idle, ifDistanceLessThan, ifHpBelow, ifTargetInRange, ifTargetVisible, inState, isActionBattleCombatEntity, isActionBattleEntityInvincible, isActionBattleEvent, isActionBattlePlayer, isEnemyType, keepDistance, matchesActionBattleTargetSelector, moveToTarget, normalizeActionBattleAttackProfile, normalizeActionBattleEnemyAttackProfiles, normalizeActionBattleHitReaction, openActionBattleActionBar, patrol, playActionBattleVisual, provideActionBattle, resolveActionBattleHitboxSpeed, resolveActionBattleUi, resolveActionBattleWeapon, resolveActionBattleWeaponAttackProfile, rule, runActionBattleActiveHitbox, scheduleActionBattleStartup, selector, sequence, setActionBattleInvincibility, setActionBattlePreviewStarter, setMode, shouldUseActionBattleUsable, targetInRange, targetVisible, updateActionBattleActionBar, useAttack, useSkill };

package/dist/client/index10.js

@@ -1,61 +1,37 @@
-var DEFAULT_ANIMATION_BY_KEY = {
-	attack: "attack",
-	hurt: "hurt",
-	die: "die",
-	castSkill: "skill",
-	castSpell: "skill"
+//#region src/targeting.ts
+var normalizeMaskRows = (mask) => {
+	if (!mask) return ["#"];
+	if (Array.isArray(mask)) return mask;
+	return mask.trim().split("\n").map((row) => row.replace(/\r/g, ""));
 };
-var getConfiguredAnimation = (key, animations) => {
-	if (!animations) return {
-		hasConfiguredAnimation: false,
-		configured: void 0
-	};
-	const hasConfiguredAnimation = Object.prototype.hasOwnProperty.call(animations, key);
-	if (hasConfiguredAnimation) return {
-		hasConfiguredAnimation,
-		configured: animations[key]
-	};
-	if (key === "castSkill") return {
-		hasConfiguredAnimation: Object.prototype.hasOwnProperty.call(animations, "castSpell"),
-		configured: animations.castSpell
-	};
+var parseAoeMask = (mask) => {
+	const rows = normalizeMaskRows(mask);
+	const height = rows.length;
+	const width = rows.reduce((max, row) => Math.max(max, row.length), 0);
+	const centerX = Math.floor(width / 2);
+	const centerY = Math.floor(height / 2);
+	const cells = [];
+	rows.forEach((row, y) => {
+		for (let x = 0; x < row.length; x++) {
+			const char = row[x];
+			if (char && char !== "." && char !== " ") cells.push({
+				dx: x - centerX,
+				dy: y - centerY
+			});
+		}
+	});
+	if (cells.length === 0) cells.push({
+		dx: 0,
+		dy: 0
+	});
 	return {
-		hasConfiguredAnimation: false,
-		configured: void 0
+		width,
+		height,
+		centerX,
+		centerY,
+		cells
 	};
 };
-function resolveActionBattleAnimation(key, entity, animations, context, defaults = {}) {
-	const defaultAnimationName = defaults.animationName ?? DEFAULT_ANIMATION_BY_KEY[key];
-	const defaultRepeat = defaults.repeat ?? 1;
-	const { hasConfiguredAnimation, configured: configuredAnimation } = getConfiguredAnimation(key, animations);
-	if (!hasConfiguredAnimation && key !== "attack") return null;
-	const configured = hasConfiguredAnimation ? configuredAnimation : defaultAnimationName;
-	const result = typeof configured === "function" ? configured(entity, context) : configured;
-	if (result == null) return null;
-	if (typeof result === "string") return {
-		animationName: result,
-		repeat: defaultRepeat,
-		waitEnd: false
-	};
-	return {
-		animationName: result.animationName ?? defaultAnimationName,
-		graphic: result.graphic,
-		repeat: result.repeat ?? defaultRepeat,
-		waitEnd: result.waitEnd ?? false,
-		delayMs: result.delayMs
-	};
-}
-function playActionBattleAnimation(key, entity, animations, context, defaults = {}) {
-	const animation = resolveActionBattleAnimation(key, entity, animations, context, defaults);
-	if (!animation) return null;
-	if (animation.graphic !== void 0) entity.setGraphicAnimation(animation.animationName, animation.graphic, animation.repeat);
-	else entity.setGraphicAnimation(animation.animationName, animation.repeat);
-	return animation;
-}
-function getActionBattleAnimationRemovalDelay(animation) {
-	if (!animation) return 0;
-	if (animation.delayMs !== void 0) return animation.delayMs;
-	return animation.waitEnd ? 500 : 0;
-}
+var manhattanDistance = (a, b) => Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
 //#endregion
-export { getActionBattleAnimationRemovalDelay, playActionBattleAnimation, resolveActionBattleAnimation };
+export { manhattanDistance, parseAoeMask };