@rpgjs/action-battle 5.0.0-alpha.44 → 5.0.0-beta.10

package/dist/{ai.server.d.ts → client/ai.server.d.ts}

@@ -1,7 +1,75 @@
 import { RpgEvent, RpgPlayer } from '@rpgjs/server';
+import { ActionBattleEnemyAttackProfileMap } from './core/enemy-attack-profiles';
+import { ActionBattleDamageResult } from './core/contracts';
+import { NormalizedActionBattleHitReactionProfile, ActionBattleAnimationOptions } from './types';
 type RpgEventWithBattleAi = RpgEvent & {
-    battleAi: BattleAi;
+    battleAi?: BattleAi;
 };
+export interface BattleAiRewardItem {
+    item?: any;
+    itemId?: string;
+    amount?: number;
+    chance?: number;
+}
+export interface BattleAiRewards {
+    exp?: number;
+    gold?: number;
+    items?: Array<BattleAiRewardItem | string>;
+    showNotification?: boolean;
+}
+export interface BattleAiDefeatReward {
+    readonly awarded: boolean;
+    giveTo(player?: RpgPlayer | null): void;
+}
+export interface BattleAiDefeatedContext {
+    event: RpgEvent;
+    attacker?: RpgPlayer;
+    reward: BattleAiDefeatReward;
+    remove: () => void;
+}
+export type BattleAiDefeatedCallback = (context: BattleAiDefeatedContext) => void;
+export type BattleAiLegacyDefeatedCallback = (event: RpgEvent, attacker?: RpgPlayer) => void;
+export interface BattleAiBaseOptions {
+    enemyType?: EnemyType;
+    attackCooldown?: number;
+    visionRange?: number;
+    attackRange?: number;
+    dodgeChance?: number;
+    dodgeCooldown?: number;
+    fleeThreshold?: number;
+    attackSkill?: any;
+    attackPatterns?: AttackPattern[];
+    attackProfiles?: ActionBattleEnemyAttackProfileMap;
+    patrolWaypoints?: Array<{
+        x: number;
+        y: number;
+    }>;
+    groupBehavior?: boolean;
+    moveToCooldown?: number;
+    retreatCooldown?: number;
+    poise?: number;
+    hitstunMs?: number;
+    invincibilityMs?: number;
+    behavior?: {
+        baseScore?: number;
+        updateInterval?: number;
+        minStateDuration?: number;
+        assaultThreshold?: number;
+        retreatThreshold?: number;
+    };
+    behaviorKey?: string;
+    animations?: ActionBattleAnimationOptions;
+    rewards?: BattleAiRewards;
+    autoAwardRewards?: boolean;
+}
+export interface BattleAiOptions extends BattleAiBaseOptions {
+    /** Callback called when the AI is defeated */
+    onDefeated?: BattleAiDefeatedCallback;
+}
+export interface BattleAiLegacyOptions extends BattleAiBaseOptions {
+    /** @deprecated Use the context callback signature instead. */
+    onDefeated?: BattleAiLegacyDefeatedCallback;
+}
 /**
  * Hit result data returned after applying damage
  *
@@ -221,6 +289,8 @@ export declare class BattleAi {
     private fleeThreshold;
     private attackSkill;
     private attackPatterns;
+    private attackProfiles;
+    private animations?;
     private comboCount;
     private comboMax;
     private chargingAttack;
@@ -234,6 +304,9 @@ export declare class BattleAi {
     private damageCheckInterval;
     private isMovingToTarget;
     private onDefeatedCallback?;
+    private rewards?;
+    private autoAwardRewards;
+    private defeated;
     private lastFacingDirection;
     private behaviorScore;
     private behaviorMode;
@@ -247,6 +320,11 @@ export declare class BattleAi {
     private lastMoveToTime;
     private retreatCooldown;
     private lastRetreatTime;
+    private timers;
+    private behaviorKey?;
+    private poise;
+    private hitstunMs;
+    private invincibilityMs;
     /**
      * Create a new Battle AI Controller
      *
@@ -271,33 +349,8 @@ export declare class BattleAi {
      * });
      * ```
      */
-    constructor(event: RpgEventWithBattleAi, options?: {
-        enemyType?: EnemyType;
-        attackCooldown?: number;
-        visionRange?: number;
-        attackRange?: number;
-        dodgeChance?: number;
-        dodgeCooldown?: number;
-        fleeThreshold?: number;
-        attackSkill?: any;
-        attackPatterns?: AttackPattern[];
-        patrolWaypoints?: Array<{
-            x: number;
-            y: number;
-        }>;
-        groupBehavior?: boolean;
-        moveToCooldown?: number;
-        retreatCooldown?: number;
-        behavior?: {
-            baseScore?: number;
-            updateInterval?: number;
-            minStateDuration?: number;
-            assaultThreshold?: number;
-            retreatThreshold?: number;
-        };
-        /** Callback called when the AI is defeated */
-        onDefeated?: (event: RpgEvent, attacker?: RpgPlayer) => void;
-    });
+    constructor(event: RpgEventWithBattleAi, options?: BattleAiOptions);
+    constructor(event: RpgEventWithBattleAi, options?: BattleAiLegacyOptions);
     /**
      * Apply enemy type-specific behavior modifiers
      *
@@ -354,6 +407,7 @@ export declare class BattleAi {
      * Uses skill if configured, otherwise creates hitbox
      */
     private performMeleeAttack;
+    private executeMeleeAttack;
     /**
      * Perform basic hitbox attack when no skill is set
      */
@@ -421,6 +475,9 @@ export declare class BattleAi {
      * Perform dash attack
      */
     private performDashAttack;
+    private getAttackProfile;
+    private telegraphAttack;
+    private scheduleAttackStartup;
     /**
      * Face the current target with hysteresis to prevent animation flickering
      *
@@ -479,6 +536,9 @@ export declare class BattleAi {
      * The actual damage is applied externally via RPGJS API.
      */
     takeDamage(attacker: RpgPlayer): boolean;
+    handleDamage(attacker: RpgPlayer, damageResult: ActionBattleDamageResult & {
+        reaction?: NormalizedActionBattleHitReactionProfile;
+    }): boolean;
     /**
      * Kill this AI
      *
@@ -491,9 +551,11 @@ export declare class BattleAi {
      */
     private getDistance;
     private updateBehavior;
+    private applyCustomBehavior;
     private handleTacticalMovement;
     private handleAssaultMovement;
     private requestMoveTo;
+    private schedule;
     getHealth(): number;
     getMaxHealth(): number;
     getTarget(): InstanceType<typeof RpgPlayer> | null;

package/dist/client/animations.d.ts

@@ -0,0 +1,16 @@
+import { ActionBattleAnimationContext, ActionBattleAnimationEntity, ActionBattleAnimationKey, ActionBattleAnimationOptions } from './types';
+export declare const DEFAULT_DIE_ANIMATION_DELAY_MS = 500;
+export interface ResolvedActionBattleAnimation {
+    animationName: string;
+    graphic?: string | string[];
+    repeat: number;
+    waitEnd: boolean;
+    delayMs?: number;
+}
+export interface ActionBattleAnimationDefaults {
+    animationName?: string;
+    repeat?: number;
+}
+export declare function resolveActionBattleAnimation(key: ActionBattleAnimationKey, entity: ActionBattleAnimationEntity, animations?: ActionBattleAnimationOptions, context?: ActionBattleAnimationContext, defaults?: ActionBattleAnimationDefaults): ResolvedActionBattleAnimation | null;
+export declare function playActionBattleAnimation(key: ActionBattleAnimationKey, entity: ActionBattleAnimationEntity, animations?: ActionBattleAnimationOptions, context?: ActionBattleAnimationContext, defaults?: ActionBattleAnimationDefaults): ResolvedActionBattleAnimation | null;
+export declare function getActionBattleAnimationRemovalDelay(animation: ResolvedActionBattleAnimation | null): number;

package/dist/{client.d.ts → client/client.d.ts}

@@ -1,4 +1,5 @@
+import { RpgClient } from '@rpgjs/client';
 import { ActionBattleOptions } from './types';
-export declare const createActionBattleClient: (options?: ActionBattleOptions) => any;
-declare const _default: any;
+export declare const createActionBattleClient: (options?: ActionBattleOptions) => RpgClient;
+declare const _default: RpgClient;
 export default _default;

package/dist/{config.d.ts → client/config.d.ts}

@@ -1,3 +1,5 @@
 import { ActionBattleOptions } from './types';
 export declare const DEFAULT_ACTION_BATTLE_OPTIONS: ActionBattleOptions;
 export declare function normalizeActionBattleOptions(options?: ActionBattleOptions): ActionBattleOptions;
+export declare function setActionBattleOptions(options: ActionBattleOptions): void;
+export declare function getActionBattleOptions(): ActionBattleOptions;

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

@@ -0,0 +1,9 @@
+import { ActionBattleAttackHitboxMap, ActionBattleAttackProfile, NormalizedActionBattleAttackProfile } from '../types';
+export declare const DEFAULT_ACTION_BATTLE_ATTACK_PROFILE: NormalizedActionBattleAttackProfile;
+export interface ActionBattleAttackProfileFallbacks {
+    id?: string;
+    lockMovement?: boolean;
+    lockDurationMs?: number;
+    hitboxes?: ActionBattleAttackHitboxMap;
+}
+export declare function normalizeActionBattleAttackProfile(profile?: ActionBattleAttackProfile | undefined, fallbacks?: ActionBattleAttackProfileFallbacks): NormalizedActionBattleAttackProfile;

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

@@ -0,0 +1,20 @@
+import { ActionBattleAttackHitPolicy, ActionBattleOptions, NormalizedActionBattleAttackProfile } from '../types';
+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 createActionBattleAttackId(attackerId: string | number | undefined, profileId: string): string;
+export declare class ActionBattleHitTracker {
+    private readonly hitPolicy;
+    private hitTargets;
+    constructor(hitPolicy: ActionBattleAttackHitPolicy);
+    canHit(target: {
+        id?: string | number;
+    } | undefined): boolean;
+    recordHit(target: {
+        id?: string | number;
+    } | undefined): void;
+    tryHit(target: {
+        id?: string | number;
+    } | undefined): boolean;
+}

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

@@ -0,0 +1,5 @@
+import { ActionBattleOptions } from '../types';
+import { ActionBattleSystems } from './contracts';
+export declare const setActionBattleSystems: (options?: ActionBattleOptions) => void;
+export declare const getActionBattleSystems: () => ActionBattleSystems;
+export declare const createActionBattleSystems: (options?: ActionBattleOptions) => ActionBattleSystems;

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

@@ -0,0 +1,81 @@
+import { RpgPlayer } from '@rpgjs/server';
+import { ActionBattleAiBehavior, ActionBattleAttackContext, ActionBattleCombatSystem, ActionBattleDamageContext, ActionBattleKnockbackContext, ActionBattleKnockbackResult, ActionBattleSystems } from './contracts';
+export declare const DEFAULT_ZELDA_PLAYER_HITBOXES: {
+    up: {
+        offsetX: number;
+        offsetY: number;
+        width: number;
+        height: number;
+    };
+    down: {
+        offsetX: number;
+        offsetY: number;
+        width: number;
+        height: number;
+    };
+    left: {
+        offsetX: number;
+        offsetY: number;
+        width: number;
+        height: number;
+    };
+    right: {
+        offsetX: number;
+        offsetY: number;
+        width: number;
+        height: number;
+    };
+    default: {
+        offsetX: number;
+        offsetY: number;
+        width: number;
+        height: number;
+    };
+};
+export declare const createDefaultPlayerHitboxResolver: (hitboxes?: {
+    up: {
+        offsetX: number;
+        offsetY: number;
+        width: number;
+        height: number;
+    };
+    down: {
+        offsetX: number;
+        offsetY: number;
+        width: number;
+        height: number;
+    };
+    left: {
+        offsetX: number;
+        offsetY: number;
+        width: number;
+        height: number;
+    };
+    right: {
+        offsetX: number;
+        offsetY: number;
+        width: number;
+        height: number;
+    };
+    default: {
+        offsetX: number;
+        offsetY: number;
+        width: number;
+        height: number;
+    };
+}) => (context: ActionBattleAttackContext) => {
+    x: any;
+    y: any;
+    width: number;
+    height: number;
+}[];
+export declare const defaultRpgjsDamageResolver: (context: ActionBattleDamageContext) => {
+    damage: any;
+    defeated: boolean;
+    raw: any;
+};
+export declare const defaultKnockbackResolver: (context: ActionBattleKnockbackContext) => ActionBattleKnockbackResult;
+export declare const defaultCombatSystem: ActionBattleCombatSystem;
+export declare const defaultEnemyBehaviors: Record<string, ActionBattleAiBehavior>;
+export declare const defaultActionBattleSystems: ActionBattleSystems;
+export declare const getEntityWeaponKnockbackForce: (entity: RpgPlayer) => number;

package/dist/client/core/enemy-attack-profiles.d.ts

@@ -0,0 +1,6 @@
+import { ActionBattleAttackProfile, NormalizedActionBattleAttackProfile } from '../types';
+export type ActionBattleEnemyAttackProfileKey = "melee" | "combo" | "charged" | "zone" | "dashAttack";
+export declare const DEFAULT_ACTION_BATTLE_ENEMY_ATTACK_PROFILES: Record<ActionBattleEnemyAttackProfileKey, ActionBattleAttackProfile>;
+export type ActionBattleEnemyAttackProfileMap = Partial<Record<ActionBattleEnemyAttackProfileKey, ActionBattleAttackProfile>>;
+export type NormalizedActionBattleEnemyAttackProfileMap = Record<ActionBattleEnemyAttackProfileKey, NormalizedActionBattleAttackProfile>;
+export declare function normalizeActionBattleEnemyAttackProfiles(overrides?: ActionBattleEnemyAttackProfileMap): NormalizedActionBattleEnemyAttackProfileMap;

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

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

package/dist/client/core/hit-reaction.d.ts

@@ -0,0 +1,5 @@
+import { ActionBattleHitReactionProfile, NormalizedActionBattleHitReactionProfile } from '../types';
+export declare const DEFAULT_ACTION_BATTLE_HIT_REACTION: NormalizedActionBattleHitReactionProfile;
+export declare function normalizeActionBattleHitReaction(reaction: ActionBattleHitReactionProfile | undefined, defaults?: NormalizedActionBattleHitReactionProfile): NormalizedActionBattleHitReactionProfile;
+export declare function isActionBattleEntityInvincible(entity: any, now?: number): boolean;
+export declare function setActionBattleInvincibility(entity: any, durationMs: number, now?: number): void;

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

@@ -0,0 +1,2 @@
+import { ActionBattleCombatSystem, ActionBattleHitContext, ActionBattleHitResult } from './contracts';
+export declare const applyActionBattleHit: (system: ActionBattleCombatSystem, context: ActionBattleHitContext) => ActionBattleHitResult;

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

@@ -0,0 +1,7 @@
+import { RpgEvent } from '@rpgjs/server';
+import { BattleAi, BattleAiOptions } from '../ai.server';
+export interface ActionBattleEnemyPreset extends BattleAiOptions {
+    stats?: (event: RpgEvent) => void;
+}
+export type ActionBattleEnemyPresetMap = Record<string, ActionBattleEnemyPreset>;
+export declare const createActionEnemy: (event: RpgEvent, presetOrOptions: string | BattleAiOptions, presets?: ActionBattleEnemyPresetMap) => BattleAi;

package/dist/client/index.d.ts

@@ -0,0 +1,21 @@
+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 { 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 { 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 { 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 declare function provideActionBattle(options?: ActionBattleOptions): any[];
+declare const _default: {
+    server: import('@rpgjs/server').RpgServer;
+    client: import('@rpgjs/client').RpgClient;
+};
+export default _default;

package/dist/client/index.js

@@ -1,35 +1,28 @@
-import client, { createActionBattleClient } from "./index2.js";
+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 { createModule } from "@rpgjs/common";
-import { AiDebug, AiState, AttackPattern, BattleAi, DEFAULT_KNOCKBACK, EnemyType } from "./index3.js";
-import { ACTION_BATTLE_ACTION_BAR_GUI_ID, DEFAULT_PLAYER_ATTACK_HITBOXES, applyPlayerHitToEvent, createActionBattleServer, getPlayerWeaponKnockbackForce, openActionBattleActionBar, updateActionBattleActionBar } from "./index4.js";
-const server = null;
-const createActionBattleServer2 = null;
+//#region src/index.ts
+var server = null;
+var createActionBattleServer$1 = null;
 function provideActionBattle(options = {}) {
-  return createModule("ActionBattle", [
-    {
-      server: createActionBattleServer2?.(options),
-      client: createActionBattleClient?.(options)
-    }
-  ]);
+	return createModule("ActionBattle", [{
+		server: createActionBattleServer$1?.(options),
+		client: createActionBattleClient?.(options)
+	}]);
 }
-const index = {
-  server,
-  client
-};
-export {
-  ACTION_BATTLE_ACTION_BAR_GUI_ID,
-  AiDebug,
-  AiState,
-  AttackPattern,
-  BattleAi,
-  DEFAULT_KNOCKBACK,
-  DEFAULT_PLAYER_ATTACK_HITBOXES,
-  EnemyType,
-  applyPlayerHitToEvent,
-  createActionBattleServer,
-  index as default,
-  getPlayerWeaponKnockbackForce,
-  openActionBattleActionBar,
-  provideActionBattle,
-  updateActionBattleActionBar
+var src_default = {
+	server,
+	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 };

package/dist/client/index10.js

@@ -0,0 +1,61 @@
+var DEFAULT_ANIMATION_BY_KEY = {
+	attack: "attack",
+	hurt: "hurt",
+	die: "die",
+	castSkill: "skill",
+	castSpell: "skill"
+};
+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
+	};
+	return {
+		hasConfiguredAnimation: false,
+		configured: void 0
+	};
+};
+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;
+}
+//#endregion
+export { getActionBattleAnimationRemovalDelay, playActionBattleAnimation, resolveActionBattleAnimation };

package/dist/client/index11.js

@@ -0,0 +1,55 @@
+import { normalizeActionBattleAttackProfile } from "./index3.js";
+//#region src/core/attack-runtime.ts
+var ACTION_BATTLE_HITBOX_FRAME_MS = 16;
+function getNormalizedActionBattleAttackProfile(options = {}) {
+	const attack = options.attack ?? {};
+	return normalizeActionBattleAttackProfile(attack.profile, {
+		lockMovement: attack.lockMovement,
+		lockDurationMs: attack.lockDurationMs,
+		hitboxes: attack.hitboxes
+	});
+}
+function resolveActionBattleHitboxSpeed(profile, hitboxCount) {
+	const positions = Math.max(1, Math.floor(hitboxCount));
+	const activeFrames = Math.max(1, Math.ceil(profile.activeMs / 16));
+	return Math.max(1, Math.ceil(activeFrames / positions));
+}
+function scheduleActionBattleStartup(profile, callback, scheduler = setTimeout) {
+	if (profile.startupMs <= 0) {
+		callback();
+		return null;
+	}
+	return scheduler(callback, profile.startupMs);
+}
+var attackIdCounter = 0;
+function createActionBattleAttackId(attackerId, profileId) {
+	attackIdCounter++;
+	return `${attackerId ?? "unknown"}:${profileId}:${Date.now()}:${attackIdCounter}`;
+}
+var getTargetKey = (target) => {
+	if (!target || target.id === void 0 || target.id === null) return null;
+	return String(target.id);
+};
+var ActionBattleHitTracker = class {
+	hitPolicy;
+	hitTargets = /* @__PURE__ */ new Set();
+	constructor(hitPolicy) {
+		this.hitPolicy = hitPolicy;
+	}
+	canHit(target) {
+		if (this.hitPolicy === "allowRepeatHits") return true;
+		const key = getTargetKey(target);
+		return !key || !this.hitTargets.has(key);
+	}
+	recordHit(target) {
+		const key = getTargetKey(target);
+		if (key) this.hitTargets.add(key);
+	}
+	tryHit(target) {
+		if (!this.canHit(target)) return false;
+		this.recordHit(target);
+		return true;
+	}
+};
+//#endregion
+export { ACTION_BATTLE_HITBOX_FRAME_MS, ActionBattleHitTracker, createActionBattleAttackId, getNormalizedActionBattleAttackProfile, resolveActionBattleHitboxSpeed, scheduleActionBattleStartup };