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

package/src/ai.server.spec.ts

@@ -1,6 +1,9 @@
 import { MAXHP } from "@rpgjs/server";
 import { afterEach, describe, expect, test, vi } from "vitest";
-import { BattleAi } from "./ai.server";
+import { AttackPattern, BattleAi } from "./ai.server";
+import { chase, idle, ifTargetVisible } from "./core/ai-behavior-tree";
+import { setActionBattleSystems } from "./core/context";
+import { ACTION_BATTLE_CLIENT_VISUAL_ID } from "./visual";
 
 const createEvent = () => ({
   id: "monster-1",
@@ -13,11 +16,13 @@ const createEvent = () => ({
   showHit: vi.fn(),
   setGraphicAnimation: vi.fn(),
   stopMoveTo: vi.fn(),
+  moveTo: vi.fn(),
   getCurrentMap: vi.fn(() => ({})),
   remove: vi.fn(),
   x: vi.fn(() => 0),
   y: vi.fn(() => 0),
   direction: vi.fn(() => "down"),
+  changeDirection: vi.fn(),
 });
 
 const createPlayer = () => ({
@@ -37,6 +42,7 @@ describe("BattleAi defeat flow", () => {
   afterEach(() => {
     vi.useRealTimers();
     vi.restoreAllMocks();
+    setActionBattleSystems({});
   });
 
   test("awards the attacker and requests a defeated remove transition", () => {
@@ -118,3 +124,376 @@ describe("BattleAi defeat flow", () => {
     });
   });
 });
+
+describe("BattleAi vision setup", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+    setActionBattleSystems({});
+  });
+
+  test("retries vision attachment when the physics body is not ready yet", () => {
+    vi.useFakeTimers();
+    const event = createEvent();
+    const visionShape = { id: "vision_monster-1" };
+    event.attachShape.mockReturnValueOnce(undefined).mockReturnValueOnce(visionShape);
+
+    const ai = new BattleAi(event as any);
+
+    expect(event.attachShape).toHaveBeenCalledTimes(1);
+
+    vi.advanceTimersByTime(60);
+
+    expect(event.attachShape).toHaveBeenCalledTimes(2);
+    expect(event.attachShape).toHaveBeenLastCalledWith("vision_monster-1", {
+      radius: 150,
+      width: 300,
+      height: 300,
+      angle: 360,
+    });
+
+    ai.destroy();
+  });
+});
+
+describe("BattleAi behavior tree", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+    setActionBattleSystems({});
+  });
+
+  test("executes simplified behavior intents", () => {
+    vi.useFakeTimers();
+    const event = createEvent();
+    event.attachShape.mockReturnValue({ id: "vision_monster-1" });
+    const player = {
+      ...createPlayer(),
+      x: vi.fn(() => 20),
+      y: vi.fn(() => 0),
+    };
+    const ai = new BattleAi(event as any, {
+      simpleBehavior: {
+        when: [ifTargetVisible(chase())],
+      },
+    });
+
+    ai.onDetectInShape(player as any, {});
+    vi.advanceTimersByTime(100);
+
+    expect(event.moveTo).toHaveBeenCalledWith(player);
+    ai.destroy();
+  });
+
+  test("composes named AI presets with local overrides", () => {
+    vi.useFakeTimers();
+    const event = createEvent();
+    event.attachShape.mockReturnValue({ id: "vision_monster-1" });
+    setActionBattleSystems({
+      ai: {
+        presets: {
+          slime: {
+            preset: "aggressive",
+            visionRange: 220,
+            simpleBehavior: {
+              otherwise: chase(),
+            },
+          },
+        },
+      },
+    });
+
+    const ai = new BattleAi(event as any, {
+      preset: "slime",
+      attackRange: 70,
+    });
+
+    expect(event.attachShape).toHaveBeenCalledWith("vision_monster-1", {
+      radius: 220,
+      width: 440,
+      height: 440,
+      angle: 360,
+    });
+    ai.destroy();
+  });
+
+  test("local behavior tree overrides preset simple behavior", () => {
+    vi.useFakeTimers();
+    const event = createEvent();
+    event.attachShape.mockReturnValue({ id: "vision_monster-1" });
+    const player = {
+      ...createPlayer(),
+      hp: 10,
+      x: vi.fn(() => 20),
+      y: vi.fn(() => 0),
+    };
+    setActionBattleSystems({
+      ai: {
+        presets: {
+          ranged: {
+            simpleBehavior: {
+              otherwise: chase(),
+            },
+          },
+        },
+      },
+    });
+
+    const ai = new BattleAi(event as any, {
+      preset: "ranged",
+      behaviorTree: () => ({ status: "success", intent: idle() }),
+    });
+
+    ai.onDetectInShape(player as any, {});
+    vi.advanceTimersByTime(100);
+
+    expect(event.moveTo).not.toHaveBeenCalled();
+    expect(event.stopMoveTo).toHaveBeenCalled();
+    ai.destroy();
+  });
+
+  test("does not target an already defeated player", () => {
+    const event = createEvent();
+    event.attachShape.mockReturnValue({ id: "vision_monster-1" });
+    const ai = new BattleAi(event as any);
+    const player = {
+      ...createPlayer(),
+      hp: 0,
+      x: vi.fn(() => 20),
+      y: vi.fn(() => 0),
+    };
+
+    ai.onDetectInShape(player as any, {});
+
+    expect(ai.getTarget()).toBeNull();
+    ai.destroy();
+  });
+
+  test("approaches a visible target while alert but not yet in combat range", () => {
+    vi.useFakeTimers();
+    const event = createEvent();
+    event.attachShape.mockReturnValue({ id: "vision_monster-1" });
+    const player = {
+      ...createPlayer(),
+      hp: 10,
+      x: vi.fn(() => 120),
+      y: vi.fn(() => 0),
+    };
+    const ai = new BattleAi(event as any, {
+      attackRange: 50,
+      visionRange: 150,
+    });
+
+    ai.onDetectInShape(player as any, {});
+    vi.advanceTimersByTime(100);
+
+    expect(event.moveTo).toHaveBeenCalledWith(player);
+    ai.destroy();
+  });
+
+  test("normalizes position move targets before calling RPGJS moveTo", () => {
+    vi.useFakeTimers();
+    const event = createEvent();
+    event.attachShape.mockReturnValue({ id: "vision_monster-1" });
+
+    const ai = new BattleAi(event as any, {
+      patrolWaypoints: [{ x: 32, y: 48 }],
+      moveToCooldown: 0,
+    });
+
+    expect(event.moveTo).toHaveBeenCalledWith({ x: 32, y: 48 });
+    ai.destroy();
+  });
+
+  test("targets its attacker after taking non-lethal damage", () => {
+    vi.useFakeTimers();
+    const event = createEvent();
+    event.hp = 9;
+    event.attachShape.mockReturnValue({ id: "vision_monster-1" });
+    const player = {
+      ...createPlayer(),
+      hp: 10,
+      x: vi.fn(() => 120),
+      y: vi.fn(() => 0),
+    };
+    const ai = new BattleAi(event as any, {
+      attackRange: 50,
+      visionRange: 150,
+    });
+
+    ai.handleDamage(player as any, { damage: 1, defeated: false });
+
+    expect(ai.getTarget()).toBe(player);
+    ai.destroy();
+  });
+
+  test("waits for damage recovery before chasing its attacker", () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(1000);
+    const event = createEvent();
+    event.hp = 9;
+    event.attachShape.mockReturnValue({ id: "vision_monster-1" });
+    const player = {
+      ...createPlayer(),
+      hp: 10,
+      x: vi.fn(() => 120),
+      y: vi.fn(() => 0),
+    };
+    const ai = new BattleAi(event as any, {
+      attackRange: 50,
+      visionRange: 150,
+      hitstunMs: 100,
+      moveToCooldown: 0,
+    });
+
+    ai.handleDamage(player as any, { damage: 1, defeated: false });
+    vi.advanceTimersByTime(200);
+    expect(event.moveTo).not.toHaveBeenCalledWith(player);
+
+    vi.advanceTimersByTime(100);
+    expect(event.moveTo).toHaveBeenCalledWith(player);
+    ai.destroy();
+  });
+
+  test("chases its attacker after hitstun ends", () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(1000);
+    const event = createEvent();
+    event.hp = 9;
+    event.attachShape.mockReturnValue({ id: "vision_monster-1" });
+    const player = {
+      ...createPlayer(),
+      hp: 10,
+      x: vi.fn(() => 120),
+      y: vi.fn(() => 0),
+    };
+    const ai = new BattleAi(event as any, {
+      attackRange: 50,
+      visionRange: 150,
+      hitstunMs: 100,
+      moveToCooldown: 0,
+    });
+
+    ai.handleDamage(player as any, { damage: 1, defeated: false });
+    vi.advanceTimersByTime(300);
+
+    expect(event.moveTo).toHaveBeenCalledWith(player);
+    ai.destroy();
+  });
+
+  test("behavior tree idle fallback does not block target acquisition", () => {
+    vi.useFakeTimers();
+    const event = createEvent();
+    const player = {
+      ...createPlayer(),
+      hp: 10,
+      x: vi.fn(() => 30),
+      y: vi.fn(() => 0),
+    };
+    const map = {
+      getPlayers: vi.fn(() => [player]),
+      getEvents: vi.fn(() => [event]),
+    };
+    event.getCurrentMap.mockReturnValue(map);
+    event.attachShape.mockReturnValue({ id: "vision_monster-1" });
+
+    const ai = new BattleAi(event as any, {
+      simpleBehavior: {
+        otherwise: idle(),
+      },
+    });
+
+    vi.advanceTimersByTime(100);
+
+    expect(ai.getTarget()).toBe(player);
+    ai.destroy();
+  });
+
+  test("clears its target when the player is defeated", () => {
+    vi.useFakeTimers();
+    const event = createEvent();
+    event.attachShape.mockReturnValue({ id: "vision_monster-1" });
+    const player = {
+      ...createPlayer(),
+      hp: 10,
+      x: vi.fn(() => 20),
+      y: vi.fn(() => 0),
+    };
+    const ai = new BattleAi(event as any);
+
+    ai.onDetectInShape(player as any, {});
+    expect(ai.getTarget()).toBe(player);
+
+    player.hp = 0;
+    vi.advanceTimersByTime(100);
+
+    expect(ai.getTarget()).toBeNull();
+    expect(event.stopMoveTo).toHaveBeenCalled();
+    ai.destroy();
+  });
+
+  test("can target hostile BattleAi events by faction", () => {
+    vi.useFakeTimers();
+    const event = createEvent();
+    const hostile = {
+      ...createEvent(),
+      id: "bandit-1",
+      hp: 10,
+      x: vi.fn(() => 30),
+      y: vi.fn(() => 0),
+      battleAi: {
+        getFaction: () => "bandits",
+        getTargets: () => "players",
+      },
+    };
+    const map = {
+      getPlayers: vi.fn(() => []),
+      getEvents: vi.fn(() => [event, hostile]),
+    };
+    event.getCurrentMap.mockReturnValue(map);
+    event.attachShape.mockReturnValue({ id: "vision_monster-1" });
+
+    const ai = new BattleAi(event as any, {
+      faction: "guards",
+      targets: ["bandits"],
+    });
+
+    vi.advanceTimersByTime(100);
+
+    expect(ai.getTarget()).toBe(hostile);
+    ai.destroy();
+  });
+
+  test("dash attacks emit an attack visual before the dash hit", () => {
+    vi.useFakeTimers();
+    const clientVisual = vi.fn();
+    const event = createEvent();
+    event.getCurrentMap.mockReturnValue({ clientVisual });
+    event.attachShape.mockReturnValue({ id: "vision_monster-1" });
+    const player = {
+      ...createPlayer(),
+      hp: 10,
+      x: vi.fn(() => 20),
+      y: vi.fn(() => 0),
+    };
+    const ai = new BattleAi(event as any, {
+      attackPatterns: [AttackPattern.DashAttack],
+      attackRange: 50,
+      moveToCooldown: 0,
+    });
+
+    ai.onDetectInShape(player as any, {});
+    (ai as any).performDashAttack();
+
+    expect(clientVisual).toHaveBeenCalledWith(
+      ACTION_BATTLE_CLIENT_VISUAL_ID,
+      expect.objectContaining({
+        moment: "attack",
+        objectId: "monster-1",
+        targetId: "player-1",
+        pattern: AttackPattern.DashAttack,
+      })
+    );
+    ai.destroy();
+  });
+});