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

package/src/client.ts

@@ -14,12 +14,14 @@ import {
 import { ActionBattleOptions } from "./types";
 import { normalizeActionBattleOptions } from "./config";
 import { resolveActionBattleAnimation } from "./animations";
+import { getNormalizedActionBattleAttackProfile } from "./core/attack-runtime";
 
 const DEFAULT_ATTACK_LOCK_DURATION_MS = 350;
 
 const beginLocalPlayerAttackLock = (
   engine: RpgClientEngine,
-  durationMs: number
+  durationMs: number,
+  locks: { movement: boolean; direction: boolean }
 ): boolean => {
   if (durationMs <= 0) return true;
 
@@ -44,13 +46,17 @@ const beginLocalPlayerAttackLock = (
   const previousDirectionFixed = player.directionFixed;
   const previousAnimationFixed = player.animationFixed;
 
-  if (typeof engine.interruptCurrentPlayerMovement === "function") {
-    engine.interruptCurrentPlayerMovement(player);
-  } else {
-    (engine.scene as any)?.stopMovement?.(player);
+  if (locks.movement) {
+    if (typeof engine.interruptCurrentPlayerMovement === "function") {
+      engine.interruptCurrentPlayerMovement(player);
+    } else {
+      (engine.scene as any)?.stopMovement?.(player);
+    }
+    player.canMove.set(false);
+  }
+  if (locks.direction) {
+    player.directionFixed = true;
   }
-  player.canMove.set(false);
-  player.directionFixed = true;
   player.animationFixed = true;
 
   setTimeout(() => {
@@ -154,14 +160,17 @@ export const createActionBattleClient = (
         if (input !== "action") return;
         const player = engine.scene?.getCurrentPlayer?.() as any;
         if (!player) return;
+        const attackProfile = getNormalizedActionBattleAttackProfile(normalized);
         const lockDurationMs = Math.max(
           0,
-          normalized.attack?.lockDurationMs ?? DEFAULT_ATTACK_LOCK_DURATION_MS
-        );
-        beginLocalPlayerAttackLock(
-          engine,
-          normalized.attack?.lockMovement === false ? 0 : lockDurationMs
+          attackProfile.totalDurationMs ?? DEFAULT_ATTACK_LOCK_DURATION_MS
         );
+        if (attackProfile.movementLock || attackProfile.directionLock) {
+          beginLocalPlayerAttackLock(engine, lockDurationMs, {
+            movement: attackProfile.movementLock,
+            direction: attackProfile.directionLock,
+          });
+        }
         playLocalPlayerAttackAnimation(player, normalized);
         showLocalAttackPreview(player, normalized);
       },

package/src/config.ts

@@ -1,4 +1,5 @@
 import { ActionBattleOptions } from "./types";
+import { normalizeActionBattleAttackProfile } from "./core/attack-profile";
 
 export const DEFAULT_ACTION_BATTLE_OPTIONS: ActionBattleOptions = {
   ui: {
@@ -41,6 +42,16 @@ let currentActionBattleOptions: ActionBattleOptions =
 export function normalizeActionBattleOptions(
   options: ActionBattleOptions = {}
 ): ActionBattleOptions {
+  const attack = {
+    ...DEFAULT_ACTION_BATTLE_OPTIONS.attack,
+    ...options.attack,
+  };
+  const attackProfile = normalizeActionBattleAttackProfile(attack.profile, {
+    lockMovement: attack.lockMovement,
+    lockDurationMs: attack.lockDurationMs,
+    hitboxes: attack.hitboxes,
+  });
+
   return {
     ui: {
       actionBar: {
@@ -64,9 +75,13 @@ export function normalizeActionBattleOptions(
       ...DEFAULT_ACTION_BATTLE_OPTIONS.targeting,
       ...options.targeting,
     },
+    debug: {
+      ...DEFAULT_ACTION_BATTLE_OPTIONS.debug,
+      ...options.debug,
+    },
     attack: {
-      ...DEFAULT_ACTION_BATTLE_OPTIONS.attack,
-      ...options.attack,
+      ...attack,
+      profile: attackProfile,
     },
     animations: {
       ...DEFAULT_ACTION_BATTLE_OPTIONS.animations,

package/src/core/attack-profile.spec.ts

@@ -0,0 +1,118 @@
+import { describe, expect, test } from "vitest";
+import {
+  DEFAULT_ACTION_BATTLE_ATTACK_PROFILE,
+  normalizeActionBattleAttackProfile,
+} from "./attack-profile";
+import { normalizeActionBattleOptions } from "../config";
+import type { NormalizedActionBattleAttackProfile } from "../types";
+
+describe("normalizeActionBattleAttackProfile", () => {
+  test("creates a default profile compatible with the legacy 350ms attack lock", () => {
+    const profile = normalizeActionBattleAttackProfile();
+
+    expect(profile).toEqual(DEFAULT_ACTION_BATTLE_ATTACK_PROFILE);
+  });
+
+  test("derives recovery from the legacy lock duration when recovery is omitted", () => {
+    const profile = normalizeActionBattleAttackProfile(
+      {
+        startupMs: 80,
+        activeMs: 90,
+      },
+      {
+        lockDurationMs: 400,
+      }
+    );
+
+    expect(profile.recoveryMs).toBe(230);
+    expect(profile.totalDurationMs).toBe(400);
+    expect(profile.cooldownMs).toBe(400);
+  });
+
+  test("keeps explicit timing, movement, hit policy, animation, and hitboxes", () => {
+    const hitboxes = {
+      right: { offsetX: 18, offsetY: -18, width: 42, height: 36 },
+    };
+    const profile = normalizeActionBattleAttackProfile({
+      id: "heavy-sword",
+      startupMs: 140,
+      activeMs: 100,
+      recoveryMs: 260,
+      cooldownMs: 650,
+      movementLock: false,
+      directionLock: false,
+      animationKey: "castSkill",
+      hitPolicy: "allowRepeatHits",
+      hitboxes,
+    });
+
+    expect(profile).toMatchObject({
+      id: "heavy-sword",
+      startupMs: 140,
+      activeMs: 100,
+      recoveryMs: 260,
+      cooldownMs: 650,
+      movementLock: false,
+      directionLock: false,
+      animationKey: "castSkill",
+      hitPolicy: "allowRepeatHits",
+      totalDurationMs: 500,
+    });
+    expect(profile.hitboxes).toBe(hitboxes);
+  });
+
+  test("normalizes unsafe timing values to playable bounds", () => {
+    const profile = normalizeActionBattleAttackProfile({
+      startupMs: -20,
+      activeMs: 0,
+      recoveryMs: -10,
+      cooldownMs: -1,
+    });
+
+    expect(profile.startupMs).toBe(0);
+    expect(profile.activeMs).toBe(1);
+    expect(profile.recoveryMs).toBe(0);
+    expect(profile.cooldownMs).toBe(0);
+    expect(profile.totalDurationMs).toBe(1);
+  });
+
+  test("normalizes attack.profile through action battle options", () => {
+    const options = normalizeActionBattleOptions({
+      attack: {
+        lockMovement: false,
+        lockDurationMs: 300,
+        profile: {
+          id: "quick-slash",
+          startupMs: 60,
+          activeMs: 80,
+        },
+      },
+    });
+    const profile = options.attack
+      ?.profile as NormalizedActionBattleAttackProfile;
+
+    expect(profile).toMatchObject({
+      id: "quick-slash",
+      startupMs: 60,
+      activeMs: 80,
+      recoveryMs: 160,
+      cooldownMs: 300,
+      movementLock: false,
+      totalDurationMs: 300,
+    });
+  });
+
+  test("keeps legacy lockDurationMs when no explicit profile is provided", () => {
+    const options = normalizeActionBattleOptions({
+      attack: {
+        lockDurationMs: 500,
+      },
+    });
+    const profile = options.attack
+      ?.profile as NormalizedActionBattleAttackProfile;
+
+    expect(profile.totalDurationMs).toBe(500);
+    expect(profile.recoveryMs).toBe(380);
+    expect(profile.cooldownMs).toBe(500);
+  });
+});

package/src/core/attack-profile.ts

@@ -0,0 +1,100 @@
+import type {
+  ActionBattleAttackHitboxMap,
+  ActionBattleAttackHitPolicy,
+  ActionBattleAttackProfile,
+  ActionBattleAnimationKey,
+  NormalizedActionBattleAttackProfile,
+} from "../types";
+import {
+  DEFAULT_ACTION_BATTLE_HIT_REACTION,
+  normalizeActionBattleHitReaction,
+} from "./hit-reaction";
+
+export const DEFAULT_ACTION_BATTLE_ATTACK_PROFILE:
+  NormalizedActionBattleAttackProfile = {
+  id: "basic",
+  startupMs: 0,
+  activeMs: 120,
+  recoveryMs: 230,
+  cooldownMs: 350,
+  movementLock: true,
+  directionLock: true,
+  animationKey: "attack",
+  hitPolicy: "oncePerTarget",
+  reaction: DEFAULT_ACTION_BATTLE_HIT_REACTION,
+  totalDurationMs: 350,
+};
+
+export interface ActionBattleAttackProfileFallbacks {
+  id?: string;
+  lockMovement?: boolean;
+  lockDurationMs?: number;
+  hitboxes?: ActionBattleAttackHitboxMap;
+}
+
+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 positiveMs = (value: unknown, fallback: number) =>
+  isFiniteNumber(value) ? Math.max(1, value) : fallback;
+
+const resolveHitPolicy = (
+  value: ActionBattleAttackHitPolicy | undefined
+): ActionBattleAttackHitPolicy =>
+  value === "allowRepeatHits" ? "allowRepeatHits" : "oncePerTarget";
+
+const resolveAnimationKey = (
+  value: ActionBattleAnimationKey | undefined
+): ActionBattleAnimationKey =>
+  value ?? DEFAULT_ACTION_BATTLE_ATTACK_PROFILE.animationKey;
+
+export function normalizeActionBattleAttackProfile(
+  profile: ActionBattleAttackProfile | undefined = {},
+  fallbacks: ActionBattleAttackProfileFallbacks = {}
+): NormalizedActionBattleAttackProfile {
+  const startupMs = nonNegativeMs(
+    profile.startupMs,
+    DEFAULT_ACTION_BATTLE_ATTACK_PROFILE.startupMs
+  );
+  const activeMs = positiveMs(
+    profile.activeMs,
+    DEFAULT_ACTION_BATTLE_ATTACK_PROFILE.activeMs
+  );
+  const legacyDuration = nonNegativeMs(
+    fallbacks.lockDurationMs,
+    DEFAULT_ACTION_BATTLE_ATTACK_PROFILE.totalDurationMs
+  );
+  const fallbackRecoveryMs = Math.max(0, legacyDuration - startupMs - activeMs);
+  const recoveryMs = nonNegativeMs(profile.recoveryMs, fallbackRecoveryMs);
+  const totalDurationMs = startupMs + activeMs + recoveryMs;
+  const cooldownMs = nonNegativeMs(profile.cooldownMs, totalDurationMs);
+  const hitboxes = profile.hitboxes ?? fallbacks.hitboxes;
+
+  const normalized: NormalizedActionBattleAttackProfile = {
+    id: profile.id || fallbacks.id || DEFAULT_ACTION_BATTLE_ATTACK_PROFILE.id,
+    startupMs,
+    activeMs,
+    recoveryMs,
+    cooldownMs,
+    movementLock:
+      profile.movementLock ??
+      fallbacks.lockMovement ??
+      DEFAULT_ACTION_BATTLE_ATTACK_PROFILE.movementLock,
+    directionLock:
+      profile.directionLock ??
+      DEFAULT_ACTION_BATTLE_ATTACK_PROFILE.directionLock,
+    animationKey: resolveAnimationKey(profile.animationKey),
+    hitPolicy: resolveHitPolicy(profile.hitPolicy),
+    reaction: normalizeActionBattleHitReaction(profile.reaction),
+    totalDurationMs,
+  };
+
+  if (hitboxes) {
+    normalized.hitboxes = hitboxes;
+  }
+
+  return normalized;
+}

package/src/core/attack-runtime.spec.ts

@@ -0,0 +1,103 @@
+import { describe, expect, test, vi } from "vitest";
+import {
+  ActionBattleHitTracker,
+  createActionBattleAttackId,
+  getNormalizedActionBattleAttackProfile,
+  resolveActionBattleHitboxSpeed,
+  scheduleActionBattleStartup,
+} from "./attack-runtime";
+
+describe("attack runtime helpers", () => {
+  test("resolves a normalized profile from action battle options", () => {
+    const profile = getNormalizedActionBattleAttackProfile({
+      attack: {
+        lockDurationMs: 420,
+        profile: {
+          startupMs: 100,
+          activeMs: 80,
+        },
+      },
+    });
+
+    expect(profile).toMatchObject({
+      startupMs: 100,
+      activeMs: 80,
+      recoveryMs: 240,
+      totalDurationMs: 420,
+    });
+  });
+
+  test("maps activeMs to moving hitbox speed", () => {
+    const profile = getNormalizedActionBattleAttackProfile({
+      attack: {
+        profile: {
+          activeMs: 96,
+        },
+      },
+    });
+
+    expect(resolveActionBattleHitboxSpeed(profile, 1)).toBe(6);
+    expect(resolveActionBattleHitboxSpeed(profile, 3)).toBe(2);
+  });
+
+  test("runs startup immediately when there is no wind-up", () => {
+    const callback = vi.fn();
+    const scheduler = vi.fn();
+    const profile = getNormalizedActionBattleAttackProfile({
+      attack: {
+        profile: {
+          startupMs: 0,
+        },
+      },
+    });
+
+    const timer = scheduleActionBattleStartup(profile, callback, scheduler);
+
+    expect(timer).toBeNull();
+    expect(callback).toHaveBeenCalledOnce();
+    expect(scheduler).not.toHaveBeenCalled();
+  });
+
+  test("schedules startup when wind-up is configured", () => {
+    const callback = vi.fn();
+    const scheduler = vi.fn(() => "timer-id");
+    const profile = getNormalizedActionBattleAttackProfile({
+      attack: {
+        profile: {
+          startupMs: 120,
+        },
+      },
+    });
+
+    const timer = scheduleActionBattleStartup(profile, callback, scheduler);
+
+    expect(timer).toBe("timer-id");
+    expect(callback).not.toHaveBeenCalled();
+    expect(scheduler).toHaveBeenCalledWith(callback, 120);
+  });
+
+  test("creates stable unique attack ids", () => {
+    const first = createActionBattleAttackId("player-1", "sword");
+    const second = createActionBattleAttackId("player-1", "sword");
+
+    expect(first).toContain("player-1:sword:");
+    expect(second).toContain("player-1:sword:");
+    expect(first).not.toBe(second);
+  });
+
+  test("tracks once-per-target hit policy", () => {
+    const tracker = new ActionBattleHitTracker("oncePerTarget");
+    const target = { id: "enemy-1" };
+
+    expect(tracker.tryHit(target)).toBe(true);
+    expect(tracker.tryHit(target)).toBe(false);
+  });
+
+  test("allows repeated hits when configured", () => {
+    const tracker = new ActionBattleHitTracker("allowRepeatHits");
+    const target = { id: "enemy-1" };
+
+    expect(tracker.tryHit(target)).toBe(true);
+    expect(tracker.tryHit(target)).toBe(true);
+  });
+});

package/src/core/attack-runtime.ts

@@ -0,0 +1,83 @@
+import type {
+  ActionBattleAttackHitPolicy,
+  ActionBattleOptions,
+  NormalizedActionBattleAttackProfile,
+} from "../types";
+import { normalizeActionBattleAttackProfile } from "./attack-profile";
+
+export const ACTION_BATTLE_HITBOX_FRAME_MS = 16;
+
+export function getNormalizedActionBattleAttackProfile(
+  options: ActionBattleOptions = {}
+): NormalizedActionBattleAttackProfile {
+  const attack = options.attack ?? {};
+  return normalizeActionBattleAttackProfile(attack.profile, {
+    lockMovement: attack.lockMovement,
+    lockDurationMs: attack.lockDurationMs,
+    hitboxes: attack.hitboxes,
+  });
+}
+
+export function resolveActionBattleHitboxSpeed(
+  profile: NormalizedActionBattleAttackProfile,
+  hitboxCount: number
+): number {
+  const positions = Math.max(1, Math.floor(hitboxCount));
+  const activeFrames = Math.max(
+    1,
+    Math.ceil(profile.activeMs / ACTION_BATTLE_HITBOX_FRAME_MS)
+  );
+  return Math.max(1, Math.ceil(activeFrames / positions));
+}
+
+export function scheduleActionBattleStartup(
+  profile: NormalizedActionBattleAttackProfile,
+  callback: () => void,
+  scheduler: (callback: () => void, delayMs: number) => unknown = setTimeout
+) {
+  if (profile.startupMs <= 0) {
+    callback();
+    return null;
+  }
+  return scheduler(callback, profile.startupMs);
+}
+
+let attackIdCounter = 0;
+
+export function createActionBattleAttackId(
+  attackerId: string | number | undefined,
+  profileId: string
+): string {
+  attackIdCounter++;
+  return `${attackerId ?? "unknown"}:${profileId}:${Date.now()}:${attackIdCounter}`;
+}
+
+const getTargetKey = (target: { id?: string | number } | undefined) => {
+  if (!target || target.id === undefined || target.id === null) return null;
+  return String(target.id);
+};
+
+export class ActionBattleHitTracker {
+  private hitTargets = new Set<string>();
+
+  constructor(private readonly hitPolicy: ActionBattleAttackHitPolicy) {}
+
+  canHit(target: { id?: string | number } | undefined): boolean {
+    if (this.hitPolicy === "allowRepeatHits") return true;
+    const key = getTargetKey(target);
+    return !key || !this.hitTargets.has(key);
+  }
+
+  recordHit(target: { id?: string | number } | undefined): void {
+    const key = getTargetKey(target);
+    if (key) {
+      this.hitTargets.add(key);
+    }
+  }
+
+  tryHit(target: { id?: string | number } | undefined): boolean {
+    if (!this.canHit(target)) return false;
+    this.recordHit(target);
+    return true;
+  }
+}

package/src/core/contracts.ts

@@ -1,5 +1,6 @@
 import type { RpgEvent, RpgPlayer } from "@rpgjs/server";
 import type { AttackPattern, EnemyType, AiState } from "../ai.server";
+import type { NormalizedActionBattleHitReactionProfile } from "../types";
 
 export type ActionBattleEntity = RpgPlayer | RpgEvent;
 
@@ -58,6 +59,7 @@ export interface ActionBattleHitContext {
   pattern?: AttackPattern | string;
   damage?: ActionBattleDamageResult;
   knockback?: ActionBattleKnockbackResult;
+  reaction?: NormalizedActionBattleHitReactionProfile;
   cancelled?: boolean;
   metadata?: Record<string, any>;
 }
@@ -70,6 +72,7 @@ export interface ActionBattleHitResult {
   attacker: ActionBattleEntity;
   target: ActionBattleEntity;
   rawDamage?: any;
+  reaction?: NormalizedActionBattleHitReactionProfile;
   cancelled?: boolean;
   metadata?: Record<string, any>;
 }

package/src/core/enemy-attack-profiles.spec.ts

@@ -0,0 +1,35 @@
+import { describe, expect, test } from "vitest";
+import {
+  DEFAULT_ACTION_BATTLE_ENEMY_ATTACK_PROFILES,
+  normalizeActionBattleEnemyAttackProfiles,
+} from "./enemy-attack-profiles";
+
+describe("enemy attack profiles", () => {
+  test("normalizes every built-in enemy attack pattern", () => {
+    const profiles = normalizeActionBattleEnemyAttackProfiles();
+
+    expect(Object.keys(profiles).sort()).toEqual(
+      Object.keys(DEFAULT_ACTION_BATTLE_ENEMY_ATTACK_PROFILES).sort()
+    );
+    expect(profiles.charged.startupMs).toBe(800);
+    expect(profiles.zone.reaction.staggerPower).toBe(1.25);
+  });
+
+  test("overrides individual pattern timing", () => {
+    const profiles = normalizeActionBattleEnemyAttackProfiles({
+      melee: {
+        startupMs: 60,
+        activeMs: 40,
+        recoveryMs: 100,
+      },
+    });
+
+    expect(profiles.melee).toMatchObject({
+      startupMs: 60,
+      activeMs: 40,
+      recoveryMs: 100,
+      totalDurationMs: 200,
+    });
+    expect(profiles.charged.startupMs).toBe(800);
+  });
+});

package/src/core/enemy-attack-profiles.ts

@@ -0,0 +1,103 @@
+import type {
+  ActionBattleAttackProfile,
+  NormalizedActionBattleAttackProfile,
+} from "../types";
+import { normalizeActionBattleAttackProfile } from "./attack-profile";
+
+export type ActionBattleEnemyAttackProfileKey =
+  | "melee"
+  | "combo"
+  | "charged"
+  | "zone"
+  | "dashAttack";
+
+export const DEFAULT_ACTION_BATTLE_ENEMY_ATTACK_PROFILES: Record<
+  ActionBattleEnemyAttackProfileKey,
+  ActionBattleAttackProfile
+> = {
+  melee: {
+    id: "enemy-melee",
+    startupMs: 120,
+    activeMs: 100,
+    recoveryMs: 220,
+    cooldownMs: 440,
+    reaction: {
+      invincibilityMs: 250,
+      hitstunMs: 120,
+      staggerPower: 1,
+    },
+  },
+  combo: {
+    id: "enemy-combo",
+    startupMs: 80,
+    activeMs: 80,
+    recoveryMs: 140,
+    cooldownMs: 300,
+    reaction: {
+      invincibilityMs: 180,
+      hitstunMs: 90,
+      staggerPower: 0.75,
+    },
+  },
+  charged: {
+    id: "enemy-charged",
+    startupMs: 800,
+    activeMs: 140,
+    recoveryMs: 320,
+    cooldownMs: 1260,
+    reaction: {
+      invincibilityMs: 350,
+      hitstunMs: 220,
+      staggerPower: 2,
+    },
+  },
+  zone: {
+    id: "enemy-zone",
+    startupMs: 450,
+    activeMs: 180,
+    recoveryMs: 320,
+    cooldownMs: 950,
+    reaction: {
+      invincibilityMs: 300,
+      hitstunMs: 160,
+      staggerPower: 1.25,
+    },
+  },
+  dashAttack: {
+    id: "enemy-dash",
+    startupMs: 180,
+    activeMs: 120,
+    recoveryMs: 260,
+    cooldownMs: 560,
+    reaction: {
+      invincibilityMs: 280,
+      hitstunMs: 150,
+      staggerPower: 1.2,
+    },
+  },
+};
+
+export type ActionBattleEnemyAttackProfileMap = Partial<
+  Record<ActionBattleEnemyAttackProfileKey, ActionBattleAttackProfile>
+>;
+
+export type NormalizedActionBattleEnemyAttackProfileMap = Record<
+  ActionBattleEnemyAttackProfileKey,
+  NormalizedActionBattleAttackProfile
+>;
+
+export function normalizeActionBattleEnemyAttackProfiles(
+  overrides: ActionBattleEnemyAttackProfileMap = {}
+): NormalizedActionBattleEnemyAttackProfileMap {
+  return Object.fromEntries(
+    Object.entries(DEFAULT_ACTION_BATTLE_ENEMY_ATTACK_PROFILES).map(
+      ([key, defaultProfile]) => [
+        key,
+        normalizeActionBattleAttackProfile({
+          ...defaultProfile,
+          ...overrides[key as ActionBattleEnemyAttackProfileKey],
+        }),
+      ]
+    )
+  ) as NormalizedActionBattleEnemyAttackProfileMap;
+}

package/src/core/equipment.spec.ts

@@ -0,0 +1,37 @@
+import { describe, expect, test } from "vitest";
+import { resolveActionBattleWeaponAttackProfile } from "./equipment";
+
+describe("equipment helpers", () => {
+  test("resolves attack profile from equipped weapon data", () => {
+    const attackProfile = {
+      id: "dagger",
+      startupMs: 40,
+      activeMs: 70,
+      recoveryMs: 120,
+    };
+    const entity = {
+      equipments: () => [{ id: () => "dagger" }],
+      databaseById: (id: string) =>
+        id === "dagger"
+          ? {
+              _type: "weapon",
+              attackProfile,
+            }
+          : null,
+    };
+
+    expect(resolveActionBattleWeaponAttackProfile(entity)).toBe(attackProfile);
+  });
+
+  test("ignores non-weapon equipment", () => {
+    const entity = {
+      equipments: () => [{ id: () => "ring" }],
+      databaseById: () => ({
+        _type: "armor",
+        attackProfile: { id: "invalid" },
+      }),
+    };
+
+    expect(resolveActionBattleWeaponAttackProfile(entity)).toBeNull();
+  });
+});