@rpgjs/action-battle 5.0.0-beta.5 → 5.0.0-beta.7

package/src/core/equipment.ts

@@ -0,0 +1,17 @@
+import type { ActionBattleAttackProfile } from "../types";
+
+const resolveItemId = (item: any) => item?.id?.() ?? item?.id;
+
+export function resolveActionBattleWeaponAttackProfile(
+  entity: any
+): ActionBattleAttackProfile | null {
+  const equipments = entity?.equipments?.() || [];
+  for (const item of equipments) {
+    const itemId = resolveItemId(item);
+    const itemData = entity?.databaseById?.(itemId);
+    if (itemData?._type === "weapon" && itemData.attackProfile) {
+      return itemData.attackProfile;
+    }
+  }
+  return null;
+}

package/src/core/hit-reaction.spec.ts

@@ -0,0 +1,43 @@
+import { afterEach, describe, expect, test, vi } from "vitest";
+import {
+  DEFAULT_ACTION_BATTLE_HIT_REACTION,
+  isActionBattleEntityInvincible,
+  normalizeActionBattleHitReaction,
+  setActionBattleInvincibility,
+} from "./hit-reaction";
+
+describe("hit reaction helpers", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("normalizes hit reaction defaults", () => {
+    expect(normalizeActionBattleHitReaction(undefined)).toEqual(
+      DEFAULT_ACTION_BATTLE_HIT_REACTION
+    );
+  });
+
+  test("normalizes unsafe reaction values", () => {
+    expect(
+      normalizeActionBattleHitReaction({
+        invincibilityMs: -10,
+        hitstunMs: -20,
+        staggerPower: -1,
+      })
+    ).toEqual({
+      invincibilityMs: 0,
+      hitstunMs: 0,
+      staggerPower: 0,
+    });
+  });
+
+  test("tracks invincibility windows on entities", () => {
+    const entity = {};
+    vi.spyOn(Date, "now").mockReturnValue(1000);
+
+    setActionBattleInvincibility(entity, 250);
+
+    expect(isActionBattleEntityInvincible(entity, 1100)).toBe(true);
+    expect(isActionBattleEntityInvincible(entity, 1300)).toBe(false);
+  });
+});

package/src/core/hit-reaction.ts

@@ -0,0 +1,70 @@
+import type {
+  ActionBattleHitReactionProfile,
+  NormalizedActionBattleHitReactionProfile,
+} from "../types";
+
+export const DEFAULT_ACTION_BATTLE_HIT_REACTION: NormalizedActionBattleHitReactionProfile = {
+  invincibilityMs: 250,
+  hitstunMs: 150,
+  staggerPower: 1,
+};
+
+const STATE_KEY = "__actionBattleHitReaction";
+
+interface ActionBattleHitReactionRuntimeState {
+  invincibleUntil: number;
+}
+
+const isFiniteNumber = (value: unknown): value is number =>
+  typeof value === "number" && Number.isFinite(value);
+
+const nonNegativeMs = (value: unknown, fallback: number) =>
+  isFiniteNumber(value) ? Math.max(0, value) : fallback;
+
+const nonNegativeValue = (value: unknown, fallback: number) =>
+  isFiniteNumber(value) ? Math.max(0, value) : fallback;
+
+const getRuntimeState = (entity: any): ActionBattleHitReactionRuntimeState => {
+  if (!entity[STATE_KEY]) {
+    entity[STATE_KEY] = {
+      invincibleUntil: 0,
+    };
+  }
+  return entity[STATE_KEY];
+};
+
+export function normalizeActionBattleHitReaction(
+  reaction: ActionBattleHitReactionProfile | undefined,
+  defaults: NormalizedActionBattleHitReactionProfile =
+    DEFAULT_ACTION_BATTLE_HIT_REACTION
+): NormalizedActionBattleHitReactionProfile {
+  return {
+    invincibilityMs: nonNegativeMs(
+      reaction?.invincibilityMs,
+      defaults.invincibilityMs
+    ),
+    hitstunMs: nonNegativeMs(reaction?.hitstunMs, defaults.hitstunMs),
+    staggerPower: nonNegativeValue(
+      reaction?.staggerPower,
+      defaults.staggerPower
+    ),
+  };
+}
+
+export function isActionBattleEntityInvincible(
+  entity: any,
+  now = Date.now()
+): boolean {
+  if (!entity) return false;
+  return getRuntimeState(entity).invincibleUntil > now;
+}
+
+export function setActionBattleInvincibility(
+  entity: any,
+  durationMs: number,
+  now = Date.now()
+): void {
+  if (!entity || durationMs <= 0) return;
+  const state = getRuntimeState(entity);
+  state.invincibleUntil = Math.max(state.invincibleUntil, now + durationMs);
+}

package/src/core/hit.spec.ts

@@ -1,6 +1,7 @@
-import { describe, expect, test, vi } from "vitest";
+import { afterEach, describe, expect, test, vi } from "vitest";
 import { applyActionBattleHit } from "./hit";
 import type { ActionBattleCombatSystem } from "./contracts";
+import { setActionBattleInvincibility } from "./hit-reaction";
 
 const entity = (hp = 100) => ({
   hp,
@@ -10,6 +11,10 @@ const entity = (hp = 100) => ({
 });
 
 describe("applyActionBattleHit", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
   test("runs beforeHit before resolving damage", () => {
     const calls: string[] = [];
     const attacker = entity();
@@ -55,4 +60,52 @@ describe("applyActionBattleHit", () => {
     expect(result.cancelled).toBe(true);
     expect(resolveDamage).not.toHaveBeenCalled();
   });
+
+  test("cancels a hit when the target is invincible", () => {
+    const resolveDamage = vi.fn();
+    const attacker = entity();
+    const target = entity();
+    setActionBattleInvincibility(target, 500, 1000);
+    vi.spyOn(Date, "now").mockReturnValue(1100);
+    const system: ActionBattleCombatSystem = {
+      resolveHitboxes: () => [],
+      resolveDamage,
+      resolveKnockback: () => ({ force: 0, duration: 0 }),
+    };
+
+    const result = applyActionBattleHit(system, {
+      attacker: attacker as any,
+      target: target as any,
+    });
+
+    expect(result.cancelled).toBe(true);
+    expect(resolveDamage).not.toHaveBeenCalled();
+  });
+
+  test("applies invincibility from hit reaction after damage", () => {
+    vi.spyOn(Date, "now").mockReturnValue(2000);
+    const attacker = entity();
+    const target = entity();
+    const system: ActionBattleCombatSystem = {
+      resolveHitboxes: () => [],
+      resolveDamage: () => ({ damage: 12, defeated: false }),
+      resolveKnockback: () => ({ force: 0, duration: 0 }),
+    };
+
+    const result = applyActionBattleHit(system, {
+      attacker: attacker as any,
+      target: target as any,
+      reaction: {
+        invincibilityMs: 300,
+        hitstunMs: 120,
+        staggerPower: 1,
+      },
+    });
+
+    expect(result.cancelled).toBeUndefined();
+    expect(applyActionBattleHit(system, {
+      attacker: attacker as any,
+      target: target as any,
+    }).cancelled).toBe(true);
+  });
 });

package/src/core/hit.ts

@@ -1,4 +1,8 @@
 import type { ActionBattleCombatSystem, ActionBattleHitContext, ActionBattleHitResult } from "./contracts";
+import {
+  isActionBattleEntityInvincible,
+  setActionBattleInvincibility,
+} from "./hit-reaction";
 
 export const applyActionBattleHit = (
   system: ActionBattleCombatSystem,
@@ -20,6 +24,20 @@ export const applyActionBattleHit = (
   }
   if (before) hitContext = before;
 
+  if (isActionBattleEntityInvincible(hitContext.target)) {
+    return {
+      damage: 0,
+      knockbackForce: 0,
+      knockbackDuration: 0,
+      defeated: false,
+      attacker: hitContext.attacker,
+      target: hitContext.target,
+      cancelled: true,
+      metadata: hitContext.metadata,
+      reaction: hitContext.reaction,
+    };
+  }
+
   const damage =
     hitContext.damage ??
     system.resolveDamage({
@@ -50,6 +68,13 @@ export const applyActionBattleHit = (
     );
   }
 
+  if (!damage.defeated && hitContext.reaction?.invincibilityMs) {
+    setActionBattleInvincibility(
+      hitContext.target,
+      hitContext.reaction.invincibilityMs
+    );
+  }
+
   const result: ActionBattleHitResult = {
     damage: damage.damage,
     knockbackForce: knockback.force,
@@ -58,6 +83,7 @@ export const applyActionBattleHit = (
     attacker: hitContext.attacker,
     target: hitContext.target,
     rawDamage: damage.raw,
+    reaction: hitContext.reaction,
     metadata: hitContext.metadata,
   };
 

package/src/index.ts

@@ -7,7 +7,18 @@ import type { ActionBattleOptions } from "./types";
 export { BattleAi, AiState, EnemyType, AttackPattern, AiDebug, DEFAULT_KNOCKBACK } from "./ai.server";
 
 // Types exports
-export type { HitResult, ApplyHitHooks, BattleAiOptions } from "./ai.server";
+export type {
+  HitResult,
+  ApplyHitHooks,
+  BattleAiOptions,
+  BattleAiDefeatedCallback,
+  BattleAiDefeatedContext,
+  BattleAiDefeatReward,
+  BattleAiLegacyDefeatedCallback,
+  BattleAiLegacyOptions,
+  BattleAiRewardItem,
+  BattleAiRewards,
+} from "./ai.server";
 export type {
   ActionBattleAnimationContext,
   ActionBattleAnimationEntity,
@@ -25,6 +36,15 @@ export type {
   ActionBattleUiOptions,
   ActionBattleUiActionBarOptions,
   ActionBattleUiTargetingOptions,
+  ActionBattleAttackDirection,
+  ActionBattleAttackHitboxConfig,
+  ActionBattleAttackHitboxMap,
+  ActionBattleAttackHitPolicy,
+  ActionBattleAttackProfile,
+  ActionBattleDebugOptions,
+  ActionBattleHitReactionProfile,
+  NormalizedActionBattleHitReactionProfile,
+  NormalizedActionBattleAttackProfile,
   ActionBattleCombatOptions,
   ActionBattleSystemOptions,
   ActionBattleAiSystemOptions,
@@ -47,6 +67,33 @@ export type {
   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,

package/src/server.ts

@@ -12,7 +12,20 @@ import { playActionBattleAnimation } from "./animations";
 import { getActionBattleSystems, setActionBattleSystems } from "./core/context";
 import { applyActionBattleHit } from "./core/hit";
 import { DEFAULT_ZELDA_PLAYER_HITBOXES } from "./core/defaults";
+import {
+  ActionBattleHitTracker,
+  createActionBattleAttackId,
+  getNormalizedActionBattleAttackProfile,
+  resolveActionBattleHitboxSpeed,
+  scheduleActionBattleStartup,
+} from "./core/attack-runtime";
+import { normalizeActionBattleAttackProfile } from "./core/attack-profile";
+import { resolveActionBattleWeaponAttackProfile } from "./core/equipment";
 import type { ActionBattleHitbox } from "./core/contracts";
+import type {
+  ActionBattleAttackProfile,
+  NormalizedActionBattleAttackProfile,
+} from "./types";
 
 export const ACTION_BATTLE_ACTION_BAR_GUI_ID = "action-battle-action-bar";
 const DEFAULT_ATTACK_LOCK_DURATION_MS = 350;
@@ -31,7 +44,8 @@ export const DEFAULT_PLAYER_ATTACK_HITBOXES = {
 const beginPlayerAttackLock = (
   player: RpgPlayer,
   map: ReturnType<RpgPlayer["getCurrentMap"]> | undefined,
-  durationMs: number
+  durationMs: number,
+  locks: { movement: boolean; direction: boolean }
 ): boolean => {
   if (durationMs <= 0) return true;
 
@@ -53,11 +67,15 @@ const beginPlayerAttackLock = (
   const previousDirectionFixed = player.directionFixed;
   const previousAnimationFixed = player.animationFixed;
 
-  player.pendingInputs = [];
-  player.lastProcessedInputTs = 0;
-  (map as any)?.stopMovement?.(player);
-  player.canMove.set(false);
-  player.directionFixed = true;
+  if (locks.movement) {
+    player.pendingInputs = [];
+    player.lastProcessedInputTs = 0;
+    (map as any)?.stopMovement?.(player);
+    player.canMove.set(false);
+  }
+  if (locks.direction) {
+    player.directionFixed = true;
+  }
 
   setTimeout(() => {
     if (runtimePlayer.__actionBattleAttackLockId !== lockId) return;
@@ -115,6 +133,16 @@ const getVisibleActionEvents = (
     collisions.forEach((id: string) => addEvent(map.getEvent(id)));
   }
 
+  const direction =
+    typeof player.getDirection === "function" ? player.getDirection() : undefined;
+  const interactionCollisions = (map as any).getInteractionCollisions?.(
+    player.id,
+    direction
+  );
+  if (Array.isArray(interactionCollisions)) {
+    interactionCollisions.forEach((id: string) => addEvent(map.getEvent(id)));
+  }
+
   for (const event of map.getEvents()) {
     const rect = eventRect(event);
     if (hitboxes.some((hitbox) => rectsOverlap(hitbox, rect))) {
@@ -200,7 +228,8 @@ export function getPlayerWeaponKnockbackForce(player: RpgPlayer): number {
 export function applyPlayerHitToEvent(
   player: RpgPlayer, 
   target: RpgEvent, 
-  hooks?: ApplyHitHooks
+  hooks?: ApplyHitHooks,
+  metadata?: Record<string, any>
 ): HitResult | undefined {
   const ai = (target as any).battleAi as BattleAi;
   if (!ai) return undefined;
@@ -243,6 +272,8 @@ export function applyPlayerHitToEvent(
     {
       attacker: player,
       target,
+      metadata,
+      reaction: metadata?.reaction,
     }
   );
 
@@ -251,6 +282,7 @@ export function applyPlayerHitToEvent(
       damage: result.damage,
       defeated: result.defeated,
       raw: result.rawDamage,
+      reaction: result.reaction,
     });
   }
 
@@ -269,11 +301,13 @@ const toLegacyHitResult = (context: any): HitResult => ({
 const resolvePlayerAttackHitboxes = (
   player: RpgPlayer,
   directionKey: string,
-  options: ActionBattleOptions
+  options: ActionBattleOptions,
+  profile: NormalizedActionBattleAttackProfile
 ): ActionBattleHitbox[] => {
   const configuredHitboxes = {
     ...DEFAULT_PLAYER_ATTACK_HITBOXES,
     ...options.attack?.hitboxes,
+    ...profile.hitboxes,
   };
   const hitboxConfig =
     configuredHitboxes[
@@ -296,6 +330,39 @@ const resolvePlayerAttackHitboxes = (
   );
 };
 
+const mergeAttackProfileOverrides = (
+  base: NormalizedActionBattleAttackProfile,
+  override: ActionBattleAttackProfile
+): ActionBattleAttackProfile => ({
+  ...base,
+  ...override,
+  reaction: {
+    ...base.reaction,
+    ...override.reaction,
+  },
+  hitboxes: {
+    ...base.hitboxes,
+    ...override.hitboxes,
+  },
+});
+
+const resolvePlayerAttackProfile = (
+  player: RpgPlayer,
+  options: ActionBattleOptions
+): NormalizedActionBattleAttackProfile => {
+  const baseProfile = getNormalizedActionBattleAttackProfile(options);
+  const weaponProfile = resolveActionBattleWeaponAttackProfile(player);
+  if (!weaponProfile) return baseProfile;
+  return normalizeActionBattleAttackProfile(
+    mergeAttackProfileOverrides(baseProfile, weaponProfile),
+    {
+      lockMovement: options.attack?.lockMovement,
+      lockDurationMs: options.attack?.lockDurationMs,
+      hitboxes: options.attack?.hitboxes,
+    }
+  );
+};
+
 const resolveSignal = (value: any) =>
   typeof value === "function" ? value() : value;
 
@@ -423,7 +490,7 @@ const ensureActionBarGui = (
   const gui = existing || player.gui(ACTION_BATTLE_ACTION_BAR_GUI_ID);
   if (!(gui as any).__actionBattleReady) {
     (gui as any).__actionBattleReady = true;
-    gui.on("useItem", ({ id }) => {
+    gui.on("useItem", ({ id }: { id: string }) => {
       try {
         player.useItem(id);
       } catch {
@@ -431,10 +498,13 @@ const ensureActionBarGui = (
       }
       gui.update(buildActionBarData(player, options));
     });
-    gui.on("useSkill", ({ id, target }) => {
-      handleActionBattleSkillUse(player, id, target, options);
-      gui.update(buildActionBarData(player, options));
-    });
+    gui.on(
+      "useSkill",
+      ({ id, target }: { id: string; target?: { x: number; y: number } }) => {
+        handleActionBattleSkillUse(player, id, target, options);
+        gui.update(buildActionBarData(player, options));
+      }
+    );
     gui.on("refresh", () => {
       gui.update(buildActionBarData(player, options));
     });
@@ -523,7 +593,7 @@ const handleActionBattleSkillUse = (
   const targets: any[] = [];
   const affects = options.targeting?.affects || "events";
   if (affects === "events" || affects === "both") {
-    map.getEvents().forEach((event) => {
+    map.getEvents().forEach((event: RpgEvent) => {
       const tile = getEntityTile(event, tileSize);
       if (affected.has(`${tile.x},${tile.y}`)) {
         targets.push(event);
@@ -531,7 +601,7 @@ const handleActionBattleSkillUse = (
     });
   }
   if (affects === "players" || affects === "both") {
-    map.getPlayers().forEach((other) => {
+    map.getPlayers().forEach((other: RpgPlayer) => {
       if (other.id === player.id) return;
       const tile = getEntityTile(other, tileSize);
       if (affected.has(`${tile.x},${tile.y}`)) {
@@ -574,6 +644,7 @@ export const createActionBattleServer = (
         if (input.action == Control.Action) {
           const map = player.getCurrentMap();
           const direction = player.getDirection();
+          const attackProfile = resolvePlayerAttackProfile(player, options);
 
           // Convert Direction enum to string key
           const directionKey = direction as string;
@@ -581,42 +652,80 @@ export const createActionBattleServer = (
           const hitboxes = resolvePlayerAttackHitboxes(
             player,
             directionKey,
-            options
+            options,
+            attackProfile
           );
 
           if (isActionReservedForNormalEvent(player, map, hitboxes)) {
             return;
           }
 
-          const lockMovement = options.attack?.lockMovement !== false;
+          const lockMovement = attackProfile.movementLock;
+          const lockDirection = attackProfile.directionLock;
           const lockDurationMs =
-            options.attack?.lockDurationMs ?? DEFAULT_ATTACK_LOCK_DURATION_MS;
-          let movementLocked = false;
+            attackProfile.totalDurationMs ?? DEFAULT_ATTACK_LOCK_DURATION_MS;
+          const actionLocked = (lockMovement || lockDirection) && lockDurationMs > 0;
 
           if (
-            lockMovement &&
-            !beginPlayerAttackLock(player, map, Math.max(0, lockDurationMs))
+            actionLocked &&
+            !beginPlayerAttackLock(player, map, Math.max(0, lockDurationMs), {
+              movement: lockMovement,
+              direction: lockDirection,
+            })
           ) {
             return;
           }
-          movementLocked = lockMovement && lockDurationMs > 0;
 
           playActionBattleAnimation("attack", player, options.animations);
-          if (movementLocked) {
+          if (actionLocked) {
             player.animationFixed = true;
           }
+          const attackId = createActionBattleAttackId(
+            player.id,
+            attackProfile.id
+          );
+          const hitTracker = new ActionBattleHitTracker(
+            attackProfile.hitPolicy
+          );
+          if (options.debug?.attacks) {
+            console.log("[ActionBattle] player attack", {
+              attackId,
+              playerId: player.id,
+              profile: attackProfile.id,
+              hitboxes,
+            });
+          }
 
-          map?.createMovingHitbox(hitboxes, { speed: 3 }).subscribe({
-            next(hits) {
-              hits.forEach((hit) => {
-                if (hit instanceof RpgEvent) {
-                  const result = applyPlayerHitToEvent(player, hit);
-                  if (result?.defeated) {
-                    console.log(`Player ${player.id} defeated AI ${hit.id}`);
-                  }
-                }
+          scheduleActionBattleStartup(attackProfile, () => {
+            map
+              ?.createMovingHitbox(hitboxes, {
+                speed: resolveActionBattleHitboxSpeed(
+                  attackProfile,
+                  hitboxes.length
+                ),
+              })
+              .subscribe({
+                next(hits: any[]) {
+                  hits.forEach((hit: any) => {
+                    if (hit instanceof RpgEvent) {
+                      if (!hitTracker.tryHit(hit)) return;
+                      const result = applyPlayerHitToEvent(
+                        player,
+                        hit,
+                        undefined,
+                        {
+                          attackId,
+                          attackProfileId: attackProfile.id,
+                          reaction: attackProfile.reaction,
+                        }
+                      );
+                      if (result?.defeated) {
+                        console.log(`Player ${player.id} defeated AI ${hit.id}`);
+                      }
+                    }
+                  });
+                },
               });
-            },
           });
         }
       },
@@ -662,6 +771,44 @@ export const createActionBattleServer = (
 
 export default createActionBattleServer();
 
+export {
+  ACTION_BATTLE_HITBOX_FRAME_MS,
+  ActionBattleHitTracker,
+  createActionBattleAttackId,
+  getNormalizedActionBattleAttackProfile,
+  resolveActionBattleHitboxSpeed,
+  scheduleActionBattleStartup,
+} from "./core/attack-runtime";
+export {
+  DEFAULT_ACTION_BATTLE_ATTACK_PROFILE,
+  normalizeActionBattleAttackProfile,
+  type ActionBattleAttackProfileFallbacks,
+} from "./core/attack-profile";
+export type {
+  ActionBattleAttackDirection,
+  ActionBattleAttackHitboxConfig,
+  ActionBattleAttackHitboxMap,
+  ActionBattleAttackHitPolicy,
+  ActionBattleAttackProfile,
+  ActionBattleDebugOptions,
+  ActionBattleHitReactionProfile,
+  NormalizedActionBattleHitReactionProfile,
+  NormalizedActionBattleAttackProfile,
+} from "./types";
+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 {
   AiDebug,
   AiState,
@@ -670,4 +817,15 @@ export {
   DEFAULT_KNOCKBACK,
   EnemyType,
 } from "./ai.server";
-export type { ApplyHitHooks, BattleAiOptions, HitResult } from "./ai.server";
+export type {
+  ApplyHitHooks,
+  BattleAiDefeatedCallback,
+  BattleAiDefeatedContext,
+  BattleAiDefeatReward,
+  BattleAiLegacyDefeatedCallback,
+  BattleAiLegacyOptions,
+  BattleAiOptions,
+  BattleAiRewardItem,
+  BattleAiRewards,
+  HitResult,
+} from "./ai.server";