@rpgjs/action-battle 5.0.0-beta.12 → 5.0.0-beta.14

package/src/core/action-use.ts

@@ -117,9 +117,10 @@ const applyDamageEffect = (
 
   if (!result.cancelled) {
     emitActionBattleClientVisual({
-      moment: "hit",
+      moment: "hurt",
       entity: attacker,
       target,
+      attacker,
       damage: result.damage,
       result,
       skill,

package/src/core/defaults.ts

@@ -85,9 +85,24 @@ export const defaultRpgjsDamageResolver = (
   context: ActionBattleDamageContext
 ) => {
   const target = context.target as any;
+  const previousHp =
+    typeof target.hp === "number" && Number.isFinite(target.hp)
+      ? target.hp
+      : undefined;
   const raw = target.applyDamage(context.attacker as any, context.skill);
+  const resolvedDamage = Number(raw?.damage ?? 0);
+  if (!Number.isFinite(resolvedDamage)) {
+    if (previousHp !== undefined) {
+      target.hp = previousHp;
+    }
+    return {
+      damage: 0,
+      defeated: false,
+      raw,
+    };
+  }
   return {
-    damage: raw?.damage ?? 0,
+    damage: resolvedDamage,
     defeated: target.hp <= 0,
     raw,
   };

package/src/core/hit.spec.ts

@@ -1,5 +1,6 @@
 import { afterEach, describe, expect, test, vi } from "vitest";
 import { applyActionBattleHit } from "./hit";
+import { defaultRpgjsDamageResolver } from "./defaults";
 import type { ActionBattleCombatSystem } from "./contracts";
 import { setActionBattleInvincibility } from "./hit-reaction";
 
@@ -108,4 +109,24 @@ describe("applyActionBattleHit", () => {
       target: target as any,
     }).cancelled).toBe(true);
   });
+
+  test("normalizes invalid RPGJS damage without poisoning target hp", () => {
+    const attacker = entity();
+    const target = {
+      ...entity(100),
+      applyDamage() {
+        this.hp = Number.NaN;
+        return { damage: Number.NaN };
+      },
+    };
+
+    const result = defaultRpgjsDamageResolver({
+      attacker: attacker as any,
+      target: target as any,
+    });
+
+    expect(result.damage).toBe(0);
+    expect(result.defeated).toBe(false);
+    expect(target.hp).toBe(100);
+  });
 });

package/src/core/targets.spec.ts

@@ -52,6 +52,18 @@ describe("action battle targets", () => {
     expect(canActionBattleTarget(attacker, target, "players")).toBe(false);
   });
 
+  test("classifies runtime players with shape helpers as players", () => {
+    const attacker = battleEvent("enemy-1", "enemies");
+    const target = {
+      ...player("player-1"),
+      attachShape() {},
+      isEvent: () => false,
+    };
+
+    expect(getActionBattleEntityKind(target as any)).toBe("player");
+    expect(canActionBattleTarget(attacker, target as any, "players")).toBe(true);
+  });
+
   test("supports player targets explicitly", () => {
     const attacker = player("player-1");
     const target = player("player-2");

package/src/core/targets.ts

@@ -17,9 +17,12 @@ export const getActionBattleEntityKind = (
   entity: ActionBattleEntity
 ): EntityKind => {
   if (getBattleAi(entity)) return "event";
+  if (typeof (entity as any)?.isEvent === "function") {
+    return (entity as any).isEvent() ? "event" : "player";
+  }
   if ((entity as any) instanceof RpgEvent) return "event";
-  if (typeof (entity as any)?.attachShape === "function") return "event";
   if ((entity as any) instanceof RpgPlayer) return "player";
+  if (typeof (entity as any)?.attachShape === "function") return "event";
   return "player";
 };
 

package/src/visual.ts

@@ -112,7 +112,7 @@ const callGraphic = (
   if (!entity || keyOrOptions == null) return;
 
   if (typeof keyOrOptions === "string") {
-    playActionBattleAnimation(
+    const animation = playActionBattleAnimation(
       keyOrOptions as ActionBattleAnimationKey,
       entity,
       context?.animations ?? getActionBattleOptions().animations,