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

package/src/core/action-use.spec.ts

@@ -0,0 +1,317 @@
+import { afterEach, describe, expect, test, vi } from "vitest";
+import {
+  executeActionBattleUse,
+  handleActionBattleProjectileImpact,
+} from "./action-use";
+import { setActionBattleSystems } from "./context";
+
+const createEntity = (id: string, hp = 100) => ({
+  id,
+  hp,
+  sp: 100,
+  param: { maxhp: hp },
+  x: () => 0,
+  y: () => 0,
+  knockback: vi.fn(),
+  applyStates: vi.fn(),
+  applyDamage: vi.fn(),
+  setGraphicAnimation: vi.fn(),
+  flash: vi.fn(),
+  showHit: vi.fn(),
+});
+
+describe("executeActionBattleUse", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+    setActionBattleSystems({});
+  });
+
+  test("applies the standard skill effect when no onUse hook is defined", () => {
+    const attacker = createEntity("caster");
+    const target = createEntity("target");
+    target.applyDamage.mockReturnValue({ damage: 25 });
+
+    const handled = executeActionBattleUse({
+      attacker: attacker as any,
+      target: target as any,
+      usable: {
+        id: "fire",
+        _type: "skill",
+        spCost: 10,
+        hitRate: 1,
+      },
+      skill: {
+        id: "fire",
+        _type: "skill",
+        spCost: 10,
+        hitRate: 1,
+      },
+    });
+
+    expect(handled).toBe(true);
+    expect(attacker.sp).toBe(90);
+    expect(attacker.applyStates).toHaveBeenCalled();
+    expect(target.applyDamage).toHaveBeenCalledWith(attacker, expect.objectContaining({ id: "fire" }));
+  });
+
+  test("lets onUse compose custom behavior with defaultEffect", () => {
+    const attacker = createEntity("caster");
+    const target = createEntity("target");
+    target.applyDamage.mockReturnValue({ damage: 18 });
+    const onUse = vi.fn((_user, _target, action) => {
+      action.defaultEffect();
+      action.heal(_user, 5);
+    });
+
+    executeActionBattleUse({
+      attacker: attacker as any,
+      target: target as any,
+      usable: {
+        id: "drain",
+        _type: "skill",
+        spCost: 4,
+        hitRate: 1,
+        onUse,
+      },
+      skill: {
+        id: "drain",
+        _type: "skill",
+        spCost: 4,
+        hitRate: 1,
+        onUse,
+      },
+    });
+
+    expect(onUse).toHaveBeenCalledOnce();
+    expect(attacker.sp).toBe(96);
+    expect(target.applyDamage).toHaveBeenCalledOnce();
+  });
+
+  test("applies default effects to action target arrays", () => {
+    const attacker = createEntity("caster");
+    const first = createEntity("first");
+    const second = createEntity("second");
+    first.applyDamage.mockReturnValue({ damage: 11 });
+    second.applyDamage.mockReturnValue({ damage: 12 });
+
+    executeActionBattleUse({
+      attacker: attacker as any,
+      target: [first as any, second as any],
+      usable: {
+        id: "burst",
+        _type: "skill",
+        spCost: 3,
+        hitRate: 1,
+      },
+      skill: {
+        id: "burst",
+        _type: "skill",
+        spCost: 3,
+        hitRate: 1,
+      },
+    });
+
+    expect(first.applyDamage).toHaveBeenCalledOnce();
+    expect(second.applyDamage).toHaveBeenCalledOnce();
+  });
+
+  test("supports full custom heal skills without default damage", () => {
+    const attacker = createEntity("healer");
+    const target = createEntity("ally", 40);
+    target.hp = 10;
+
+    executeActionBattleUse({
+      attacker: attacker as any,
+      target: target as any,
+      usable: {
+        id: "heal",
+        _type: "skill",
+        spCost: 8,
+        hitRate: 1,
+        onUse(_user: any, ally: any, action: any) {
+          action.heal(ally, 20);
+        },
+      },
+      skill: {
+        id: "heal",
+        _type: "skill",
+        spCost: 8,
+        hitRate: 1,
+      },
+    });
+
+    expect(attacker.sp).toBe(92);
+    expect(target.hp).toBe(30);
+    expect(target.applyDamage).not.toHaveBeenCalled();
+  });
+
+  test("applies the standard weapon effect for configured weapons", () => {
+    const attacker = createEntity("monster");
+    const target = createEntity("target");
+    target.applyDamage.mockReturnValue({ damage: 12 });
+
+    const handled = executeActionBattleUse({
+      attacker: attacker as any,
+      target: target as any,
+      usable: {
+        id: "claw",
+        _type: "weapon",
+        action: { mode: "instant", range: 40 },
+      },
+      weapon: {
+        id: "claw",
+        _type: "weapon",
+      },
+    });
+
+    expect(handled).toBe(true);
+    expect(target.applyDamage).toHaveBeenCalledWith(attacker, undefined);
+  });
+
+  test("defers the default effect until projectile impact", () => {
+    const target = createEntity("target");
+    target.applyDamage.mockReturnValue({ damage: 30 });
+    const emitted = [{ id: "bolt-1" }];
+    const attacker = {
+      ...createEntity("caster"),
+      getCurrentMap: () => ({
+        projectiles: {
+          emit: vi.fn(() => emitted),
+        },
+      }),
+    };
+
+    executeActionBattleUse({
+      attacker: attacker as any,
+      target: target as any,
+      usable: {
+        id: "bolt",
+        _type: "skill",
+        spCost: 5,
+        hitRate: 1,
+        action: {
+          mode: "projectile",
+          range: 200,
+          projectile: {
+            type: "bolt",
+            speed: 200,
+            range: 200,
+          },
+        },
+      },
+      skill: {
+        id: "bolt",
+        _type: "skill",
+        spCost: 5,
+        hitRate: 1,
+      },
+    });
+
+    expect(target.applyDamage).not.toHaveBeenCalled();
+
+    handleActionBattleProjectileImpact({
+      attacker: attacker as any,
+      target: target as any,
+      projectile: { id: "bolt-1" },
+      hit: {},
+      map: {},
+    });
+
+    expect(target.applyDamage).toHaveBeenCalledOnce();
+  });
+
+  test("uses the action target policy for projectile collisions", () => {
+    const enemy = createEntity("enemy");
+    (enemy as any).actionBattleFaction = "enemy";
+    const ally = createEntity("ally");
+    (ally as any).actionBattleFaction = "party";
+    const emit = vi.fn(() => [{ id: "heal-bolt-1" }]);
+    const attacker = {
+      ...createEntity("caster"),
+      actionBattleFaction: "party",
+      getCurrentMap: () => ({
+        projectiles: {
+          emit,
+        },
+      }),
+    };
+
+    executeActionBattleUse({
+      attacker: attacker as any,
+      target: ally as any,
+      usable: {
+        id: "heal-bolt",
+        _type: "skill",
+        spCost: 5,
+        hitRate: 1,
+        action: {
+          mode: "projectile",
+          target: "ally",
+          range: 200,
+          projectile: {
+            type: "heal",
+            speed: 200,
+          },
+        },
+      },
+      skill: {
+        id: "heal-bolt",
+        _type: "skill",
+        spCost: 5,
+        hitRate: 1,
+      },
+    });
+
+    const canHit = emit.mock.calls[0][0].canHit;
+    expect(canHit({ target: ally })).toBe(true);
+    expect(canHit({ target: enemy })).toBe(false);
+  });
+
+  test("passes projectile precision options to the generic projectile system", () => {
+    const emit = vi.fn(() => [{ id: "bolt-1" }]);
+    const attacker = {
+      ...createEntity("caster"),
+      getCurrentMap: () => ({
+        projectiles: {
+          emit,
+        },
+      }),
+    };
+    const target = {
+      ...createEntity("target"),
+      x: () => 100,
+      y: () => 0,
+    };
+
+    executeActionBattleUse({
+      attacker: attacker as any,
+      target: target as any,
+      usable: {
+        id: "bolt",
+        _type: "skill",
+        spCost: 0,
+        hitRate: 1,
+        action: {
+          mode: "projectile",
+          projectile: {
+            type: "bolt",
+            speed: 200,
+            range: 200,
+            spreadDegrees: 20,
+          },
+        },
+      },
+      skill: {
+        id: "bolt",
+        _type: "skill",
+        spCost: 0,
+        hitRate: 1,
+      },
+    });
+
+    expect(emit.mock.calls[0][0]).toMatchObject({
+      direction: { x: 1, y: 0 },
+      spreadDegrees: 20,
+    });
+  });
+});

package/src/core/action-use.ts

@@ -0,0 +1,387 @@
+import { MAXHP } from "@rpgjs/server";
+import { getActionBattleOptions } from "../config";
+import { emitActionBattleClientVisual } from "../visual";
+import { applyActionBattleHit } from "./hit";
+import { getActionBattleSystems } from "./context";
+import {
+  canActionBattleTarget,
+  getActionBattleFaction,
+  getActionBattleTargets,
+  isActionBattleCombatEntity,
+  isActionBattleTargetDefeated,
+} from "./targets";
+import type {
+  ActionBattleActionConfig,
+  ActionBattleActionTarget,
+  ActionBattleEntity,
+  ActionBattleTargetOptions,
+  ActionBattleProjectileImpactContext,
+  ActionBattleProjectileOptions,
+  ActionBattleUseContext,
+} from "./contracts";
+import type { NormalizedActionBattleAttackProfile } from "../types";
+
+const projectileHandlers = new Map<
+  string,
+  {
+    action: ActionBattleUseContext;
+    onImpact?: ActionBattleProjectileOptions["onImpact"];
+  }
+>();
+
+const normalizeDirection = (direction: { x: number; y: number }) => {
+  const distance = Math.sqrt(direction.x * direction.x + direction.y * direction.y);
+  if (distance <= 0) return { x: 0, y: 1 };
+  return {
+    x: direction.x / distance,
+    y: direction.y / distance,
+  };
+};
+
+const directionToTarget = (
+  attacker: ActionBattleEntity,
+  target?: ActionBattleEntity | ActionBattleEntity[] | null
+) => {
+  const first = firstTarget(target);
+  if (!first) return undefined;
+  return normalizeDirection({
+    x: (first as any).x() - (attacker as any).x(),
+    y: (first as any).y() - (attacker as any).y(),
+  });
+};
+
+const asArray = <T>(value: T | T[] | null | undefined): T[] => {
+  if (!value) return [];
+  return Array.isArray(value) ? value : [value];
+};
+
+const firstTarget = (
+  target: ActionBattleEntity | ActionBattleEntity[] | null | undefined
+) => asArray(target)[0];
+
+const resolveActionConfig = (usable: any): ActionBattleActionConfig | undefined =>
+  usable?.action ??
+  usable?.actionBattle ??
+  usable?._skillInstance?.action ??
+  usable?._skillInstance?.actionBattle ??
+  usable?._skillData?.action ??
+  usable?._skillData?.actionBattle;
+
+const getUseHookTarget = (usable: any) =>
+  usable?._skillInstance ?? usable?._skillData ?? usable;
+
+const getUseHook = (usable: any) => {
+  const target = getUseHookTarget(usable);
+  return typeof target?.onUse === "function"
+    ? { hook: target.onUse, target }
+    : undefined;
+};
+
+const isSkill = (usable: any, explicitSkill?: any) =>
+  !!explicitSkill || usable?._type === "skill" || usable?.spCost !== undefined;
+
+const consumeSkillUse = (attacker: ActionBattleEntity, skill: any) => {
+  const spCost = typeof skill?.spCost === "number" ? skill.spCost : 0;
+  if (spCost > 0) {
+    if (spCost > ((attacker as any).sp ?? 0)) {
+      throw new Error(`Not enough SP to use ${skill?.id ?? skill?.name ?? "skill"}`);
+    }
+    const halfCost =
+      (attacker as any).hasEffect?.("HALF_SP_COST") ||
+      (attacker as any).hasEffect?.("half_sp_cost");
+    (attacker as any).sp -= spCost / (halfCost ? 2 : 1);
+  }
+
+  const hitRate = typeof skill?.hitRate === "number" ? skill.hitRate : 1;
+  if (Math.random() > hitRate) {
+    throw new Error(`Action battle skill failed: ${skill?.id ?? skill?.name ?? "skill"}`);
+  }
+};
+
+const applyDamageEffect = (
+  attacker: ActionBattleEntity,
+  target: ActionBattleEntity,
+  skill: any,
+  reaction?: NormalizedActionBattleAttackProfile["reaction"],
+  metadata?: Record<string, any>
+) => {
+  const systems = getActionBattleSystems();
+  (attacker as any).applyStates?.(target, skill);
+  const result = applyActionBattleHit(systems.combat, {
+    attacker,
+    target,
+    skill,
+    reaction,
+    metadata,
+  });
+
+  if (!result.cancelled) {
+    emitActionBattleClientVisual({
+      moment: "hurt",
+      entity: attacker,
+      target,
+      attacker,
+      damage: result.damage,
+      result,
+      skill,
+    });
+    (target as any).battleAi?.handleDamage?.(attacker, {
+      damage: result.damage,
+      defeated: result.defeated,
+      raw: result.rawDamage,
+      reaction: result.reaction,
+    });
+  }
+
+  return result;
+};
+
+const buildActionContext = (input: {
+  attacker: ActionBattleEntity;
+  target?: ActionBattleEntity | ActionBattleEntity[] | null;
+  usable: any;
+  skill?: any;
+  weapon?: any;
+  action?: ActionBattleActionConfig;
+  pattern?: string;
+  profile?: NormalizedActionBattleAttackProfile;
+}): ActionBattleUseContext => {
+  const action = {} as ActionBattleUseContext;
+  Object.assign(action, {
+    attacker: input.attacker,
+    user: input.attacker,
+    target: input.target,
+    usable: input.usable,
+    skill: input.skill,
+    weapon: input.weapon,
+    action: input.action,
+    pattern: input.pattern,
+    defaultEffect(target = input.target) {
+      return asArray(target).map((entry) =>
+        applyDamageEffect(
+          input.attacker,
+          entry,
+          input.skill,
+          input.profile?.reaction,
+          {
+            actionId: input.usable?.id,
+            actionType: input.usable?._type,
+            pattern: input.pattern,
+          }
+        )
+      );
+    },
+    damage(target = input.target) {
+      const entry = firstTarget(target);
+      if (!entry) return undefined;
+      return applyDamageEffect(
+        input.attacker,
+        entry,
+        input.skill,
+        input.profile?.reaction,
+        {
+          actionId: input.usable?.id,
+          actionType: input.usable?._type,
+          pattern: input.pattern,
+        }
+      );
+    },
+    heal(
+      target: ActionBattleEntity | ActionBattleEntity[] | null | undefined,
+      amount: number
+    ) {
+      if (!target || !Number.isFinite(amount) || amount <= 0) return 0;
+      return asArray(target).reduce((total, entry) => {
+        const currentHp = Number((entry as any).hp ?? 0);
+        const rawParams =
+          typeof (entry as any).param === "function"
+            ? (entry as any).param()
+            : (entry as any).param;
+        const maxHp = rawParams?.[MAXHP] ?? Number.POSITIVE_INFINITY;
+        const nextHp = Math.min(maxHp, currentHp + amount);
+        (entry as any).hp = nextHp;
+        emitActionBattleClientVisual({
+          moment: "hurt",
+          entity: entry,
+          target: entry,
+          damage: Math.max(0, nextHp - currentHp),
+          skill: input.skill,
+        });
+        return total + nextHp - currentHp;
+      }, 0);
+    },
+    projectile(options: ActionBattleProjectileOptions = { type: "action" }) {
+      const map = (input.attacker as any).getCurrentMap?.();
+      if (!map?.projectiles?.emit) return [];
+
+      const configured = input.action?.projectile ?? {};
+      const projectile = {
+        ...configured,
+        ...options,
+      };
+      const range = projectile.range ?? input.action?.range ?? 160;
+      const speed = projectile.speed ?? 180;
+      const emitted = map.projectiles.emit(
+        {
+          type: projectile.type,
+          origin: projectile.origin,
+          direction:
+            projectile.direction ?? directionToTarget(input.attacker, input.target),
+          spreadDegrees: projectile.spreadDegrees,
+          accuracy: projectile.accuracy,
+          trajectory: projectile.trajectory ?? {
+            type: "linear",
+            speed,
+            range,
+          },
+          collision: projectile.collision,
+          repeat: projectile.repeat,
+          pattern: projectile.pattern,
+          payload: {
+            ...projectile.payload,
+            actionBattle: true,
+            attackerId: input.attacker.id,
+            actionId: input.usable?.id,
+          },
+          params: projectile.params,
+          canHit: ({ target }: { target?: ActionBattleEntity }) => {
+            if (!target) return false;
+            return canActionBattleUseTarget(
+              input.attacker,
+              target,
+              input.action?.target ?? "enemy",
+              getActionBattleOptions().combat?.targets
+            );
+          },
+        },
+        input.attacker as any
+      );
+
+      for (const state of emitted) {
+        projectileHandlers.set(state.id, {
+          action,
+          onImpact: projectile.onImpact,
+        });
+      }
+
+      return emitted;
+    },
+  });
+  return action;
+};
+
+export const getActionBattleActionConfig = (usable: any) =>
+  resolveActionConfig(usable);
+
+export const getActionBattleActionRange = (usable: any): number | undefined =>
+  resolveActionConfig(usable)?.range;
+
+export const canActionBattleUseTarget = (
+  attacker: ActionBattleEntity,
+  target: ActionBattleEntity,
+  actionTarget: ActionBattleActionTarget = "enemy",
+  options: ActionBattleTargetOptions = {}
+): boolean => {
+  if (isActionBattleTargetDefeated(target)) return false;
+
+  if (actionTarget === "self") {
+    return attacker === target;
+  }
+
+  if (actionTarget === "any") {
+    return attacker === target || isActionBattleCombatEntity(target);
+  }
+
+  if (attacker === target || !isActionBattleCombatEntity(target)) {
+    return false;
+  }
+
+  if (actionTarget === "ally") {
+    const attackerFaction = getActionBattleFaction(attacker, options);
+    const targetFaction = getActionBattleFaction(target, options);
+    return !!attackerFaction && attackerFaction === targetFaction;
+  }
+
+  return canActionBattleTarget(
+    attacker,
+    target,
+    getActionBattleTargets(attacker, "hostile"),
+    options
+  );
+};
+
+export const shouldUseActionBattleUsable = (
+  usable: any,
+  explicitSkill?: any
+): boolean => {
+  if (!usable) return false;
+  return (
+    isSkill(usable, explicitSkill) ||
+    !!getUseHook(usable) ||
+    !!resolveActionConfig(usable)
+  );
+};
+
+export const executeActionBattleUse = (input: {
+  attacker: ActionBattleEntity;
+  target?: ActionBattleEntity | ActionBattleEntity[] | null;
+  usable: any;
+  skill?: any;
+  weapon?: any;
+  pattern?: string;
+  profile?: NormalizedActionBattleAttackProfile;
+  playVisual?: boolean;
+}): boolean => {
+  if (!shouldUseActionBattleUsable(input.usable, input.skill)) return false;
+
+  const actionConfig = resolveActionConfig(input.usable);
+  if (isSkill(input.usable, input.skill)) {
+    consumeSkillUse(input.attacker, input.skill ?? input.usable);
+  }
+
+  const action = buildActionContext({
+    ...input,
+    action: actionConfig,
+  });
+  const hook = getUseHook(input.usable);
+
+  if (input.playVisual !== false) {
+    emitActionBattleClientVisual({
+      moment: input.skill ? "castSkill" : "attack",
+      entity: input.attacker,
+      skill: input.skill,
+      target: firstTarget(input.target),
+    });
+  }
+
+  if (hook) {
+    hook.hook.call(hook.target, input.attacker, input.target, action);
+    return true;
+  }
+
+  if (actionConfig?.mode === "projectile") {
+    action.projectile(actionConfig.projectile as ActionBattleProjectileOptions);
+    return true;
+  }
+
+  action.defaultEffect(input.target);
+  return true;
+};
+
+export const handleActionBattleProjectileImpact = (
+  context: ActionBattleProjectileImpactContext
+) => {
+  const handler = projectileHandlers.get(context.projectile.id);
+  if (!handler) return;
+  const target = context.target;
+  handler.action.target = target ?? handler.action.target;
+  if (handler.onImpact) {
+    handler.onImpact(context, handler.action);
+  } else {
+    handler.action.defaultEffect(target ?? undefined);
+  }
+};
+
+export const handleActionBattleProjectileDestroy = (projectileId: string) => {
+  projectileHandlers.delete(projectileId);
+};