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

package/dist/server.d.ts

@@ -90,11 +90,17 @@ export declare function getPlayerWeaponKnockbackForce(player: RpgPlayer): number
  * });
  * ```
  */
-export declare function applyPlayerHitToEvent(player: RpgPlayer, target: RpgEvent, hooks?: ApplyHitHooks): HitResult | undefined;
+export declare function applyPlayerHitToEvent(player: RpgPlayer, target: RpgEvent, hooks?: ApplyHitHooks, metadata?: Record<string, any>): HitResult | undefined;
 export declare const openActionBattleActionBar: (player: RpgPlayer, rawOptions?: ActionBattleOptions) => void;
 export declare const updateActionBattleActionBar: (player: RpgPlayer, rawOptions?: ActionBattleOptions) => void;
 export declare const createActionBattleServer: (rawOptions?: ActionBattleOptions) => RpgServer;
 declare const _default: RpgServer;
 export default _default;
+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, AttackPattern, BattleAi, 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';

package/dist/ui/state.d.ts

@@ -18,10 +18,10 @@ export interface ActionBattleTargetingState {
     };
     aoeMask: string[] | string;
 }
-export declare const actionBattleUiOptions: import('canvasengine').WritableObjectSignal<import('..').ActionBattleUiOptions>;
-export declare const actionBattleSkillOptions: import('canvasengine').WritableObjectSignal<import('../types').ActionBattleSkillOptions>;
-export declare const actionBattleTargetingState: import('canvasengine').WritableObjectSignal<ActionBattleTargetingState>;
-export declare const actionBattleAttackPreviewState: import('canvasengine').WritableObjectSignal<ActionBattleAttackPreviewState>;
+export declare const actionBattleUiOptions: any;
+export declare const actionBattleSkillOptions: any;
+export declare const actionBattleTargetingState: any;
+export declare const actionBattleAttackPreviewState: any;
 export declare const setActionBattleOptions: (options?: ActionBattleOptions) => void;
 export declare const startTargeting: (skill: ActionBattleActionBarSkill) => void;
 export declare const stopTargeting: () => void;
@@ -31,5 +31,5 @@ export declare const startAttackPreview: (options: {
     durationMs?: number;
     color?: number;
     accentColor?: number;
-}) => number;
+}) => any;
 export declare const stopAttackPreview: (id?: number) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpgjs/action-battle",
-  "version": "5.0.0-beta.5",
+  "version": "5.0.0-beta.7",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
@@ -23,10 +23,10 @@
   "description": "RPGJS is a framework for creating RPG/MMORPG games",
   "peerDependencies": {
     "@canvasengine/presets": "*",
-    "@rpgjs/client": "5.0.0-beta.5",
-    "@rpgjs/common": "5.0.0-beta.5",
-    "@rpgjs/server": "5.0.0-beta.5",
-    "@rpgjs/vite": "5.0.0-beta.5",
+    "@rpgjs/client": "5.0.0-beta.7",
+    "@rpgjs/common": "5.0.0-beta.7",
+    "@rpgjs/server": "5.0.0-beta.7",
+    "@rpgjs/vite": "5.0.0-beta.7",
     "canvasengine": "*"
   },
   "publishConfig": {

package/src/ai.server.spec.ts

@@ -0,0 +1,120 @@
+import { MAXHP } from "@rpgjs/server";
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { BattleAi } from "./ai.server";
+
+const createEvent = () => ({
+  id: "monster-1",
+  hp: 0,
+  param: {
+    [MAXHP]: 10,
+  },
+  attachShape: vi.fn(),
+  flash: vi.fn(),
+  showHit: vi.fn(),
+  setGraphicAnimation: vi.fn(),
+  stopMoveTo: vi.fn(),
+  getCurrentMap: vi.fn(() => ({})),
+  remove: vi.fn(),
+  x: vi.fn(() => 0),
+  y: vi.fn(() => 0),
+  direction: vi.fn(() => "down"),
+});
+
+const createPlayer = () => ({
+  id: "player-1",
+  exp: 0,
+  gold: 0,
+  addItem: vi.fn(() => ({ name: () => "Potion" })),
+  showNotification: vi.fn(),
+  getCurrentMap: vi.fn(() => ({
+    database: () => ({
+      potion: { icon: "potion-icon" },
+    }),
+  })),
+});
+
+describe("BattleAi defeat flow", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+  });
+
+  test("awards the attacker and requests a defeated remove transition", () => {
+    const event = createEvent();
+    const attacker = createPlayer();
+    const ai = new BattleAi(event as any, {
+      animations: {
+        die: {
+          animationName: "die",
+          repeat: 1,
+          delayMs: 700,
+        },
+      },
+      rewards: {
+        exp: 25,
+        gold: 7,
+        items: [{ itemId: "potion", amount: 2, chance: 100 }],
+        showNotification: true,
+      },
+    });
+
+    expect(ai.handleDamage(attacker as any, { damage: 10, defeated: true })).toBe(true);
+
+    expect(attacker.exp).toBe(25);
+    expect(attacker.gold).toBe(7);
+    expect(attacker.addItem).toHaveBeenCalledWith("potion", 2);
+    expect(event.setGraphicAnimation).not.toHaveBeenCalledWith("die", 1);
+    expect(event.remove).toHaveBeenCalledWith({
+      reason: "defeated",
+      data: {
+        animation: expect.objectContaining({
+          animationName: "die",
+          delayMs: 700,
+        }),
+      },
+      transition: {
+        animation: "die",
+        graphic: undefined,
+        duration: 700,
+      },
+      timeoutMs: 700,
+    });
+  });
+
+  test("supports the context onDefeated callback and manual reward control", () => {
+    const event = createEvent();
+    const attacker = createPlayer();
+    const onDefeated = vi.fn(({ reward }) => {
+      expect(reward.awarded).toBe(false);
+      reward.giveTo(attacker as any);
+      expect(reward.awarded).toBe(true);
+    });
+    const ai = new BattleAi(event as any, {
+      autoAwardRewards: false,
+      rewards: {
+        exp: 10,
+      },
+      onDefeated,
+    });
+
+    ai.handleDamage(attacker as any, { damage: 10, defeated: true });
+
+    expect(onDefeated).toHaveBeenCalledWith(
+      expect.objectContaining({
+        event,
+        attacker,
+        reward: expect.any(Object),
+        remove: expect.any(Function),
+      })
+    );
+    expect(attacker.exp).toBe(10);
+    expect(event.remove).toHaveBeenCalledWith({
+      reason: "defeated",
+      data: {
+        animation: null,
+      },
+      transition: undefined,
+      timeoutMs: 0,
+    });
+  });
+});