@rpgjs/action-battle 5.0.0-beta.2 → 5.0.0-beta.4

package/src/core/context.ts

@@ -0,0 +1,35 @@
+import type { ActionBattleOptions } from "../types";
+import { defaultActionBattleSystems } from "./defaults";
+import type { ActionBattleSystems } from "./contracts";
+
+const mergeSystems = (options: ActionBattleOptions = {}): ActionBattleSystems => ({
+  combat: {
+    ...defaultActionBattleSystems.combat,
+    resolveDamage:
+      options.systems?.combat?.damage ??
+      defaultActionBattleSystems.combat.resolveDamage,
+    resolveKnockback:
+      options.systems?.combat?.knockback ??
+      defaultActionBattleSystems.combat.resolveKnockback,
+    hooks: {
+      ...defaultActionBattleSystems.combat.hooks,
+      ...options.systems?.combat?.hooks,
+    },
+  },
+  ai: {
+    behaviors: {
+      ...defaultActionBattleSystems.ai.behaviors,
+      ...options.systems?.ai?.behaviors,
+    },
+  },
+});
+
+let currentActionBattleSystems = mergeSystems();
+
+export const setActionBattleSystems = (options: ActionBattleOptions = {}) => {
+  currentActionBattleSystems = mergeSystems(options);
+};
+
+export const getActionBattleSystems = () => currentActionBattleSystems;
+
+export const createActionBattleSystems = mergeSystems;

package/src/core/contracts.ts

@@ -0,0 +1,123 @@
+import type { RpgEvent, RpgPlayer } from "@rpgjs/server";
+import type { AttackPattern, EnemyType, AiState } from "../ai.server";
+
+export type ActionBattleEntity = RpgPlayer | RpgEvent;
+
+export interface ActionBattleHitbox {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+export interface ActionBattleDirection {
+  x: number;
+  y: number;
+}
+
+export interface ActionBattleAttackContext {
+  attacker: ActionBattleEntity;
+  target?: ActionBattleEntity | null;
+  direction?: string;
+  skill?: any;
+  pattern?: AttackPattern | string;
+  map?: any;
+  now: number;
+}
+
+export interface ActionBattleDamageContext {
+  attacker: ActionBattleEntity;
+  target: ActionBattleEntity;
+  skill?: any;
+  pattern?: AttackPattern | string;
+}
+
+export interface ActionBattleDamageResult {
+  damage: number;
+  defeated: boolean;
+  raw?: any;
+}
+
+export interface ActionBattleKnockbackContext {
+  attacker: ActionBattleEntity;
+  target: ActionBattleEntity;
+  damage: ActionBattleDamageResult;
+  weapon?: any;
+}
+
+export interface ActionBattleKnockbackResult {
+  force: number;
+  duration: number;
+  direction?: ActionBattleDirection;
+}
+
+export interface ActionBattleHitContext {
+  attacker: ActionBattleEntity;
+  target: ActionBattleEntity;
+  skill?: any;
+  pattern?: AttackPattern | string;
+  damage?: ActionBattleDamageResult;
+  knockback?: ActionBattleKnockbackResult;
+  cancelled?: boolean;
+  metadata?: Record<string, any>;
+}
+
+export interface ActionBattleHitResult {
+  damage: number;
+  knockbackForce: number;
+  knockbackDuration: number;
+  defeated: boolean;
+  attacker: ActionBattleEntity;
+  target: ActionBattleEntity;
+  rawDamage?: any;
+  cancelled?: boolean;
+  metadata?: Record<string, any>;
+}
+
+export interface ActionBattleHitHooks {
+  beforeHit?: (
+    context: ActionBattleHitContext
+  ) => ActionBattleHitContext | false | void;
+  afterDamage?: (
+    context: ActionBattleHitContext
+  ) => ActionBattleHitContext | void;
+  afterHit?: (result: ActionBattleHitResult) => void;
+}
+
+export interface ActionBattleCombatSystem {
+  resolveHitboxes(context: ActionBattleAttackContext): ActionBattleHitbox[];
+  resolveDamage(context: ActionBattleDamageContext): ActionBattleDamageResult;
+  resolveKnockback(
+    context: ActionBattleKnockbackContext
+  ): ActionBattleKnockbackResult;
+  hooks?: ActionBattleHitHooks;
+}
+
+export interface ActionBattleAiContext {
+  event: RpgEvent;
+  target: RpgPlayer | null;
+  state: AiState;
+  enemyType: EnemyType;
+  distance: number | null;
+  hpPercent: number | null;
+  now: number;
+}
+
+export interface ActionBattleAiDecision {
+  mode?: "assault" | "tactical" | "retreat";
+  attackPatterns?: AttackPattern[];
+  attackCooldown?: number;
+  moveToCooldown?: number;
+  metadata?: Record<string, any>;
+}
+
+export type ActionBattleAiBehavior = (
+  context: ActionBattleAiContext
+) => ActionBattleAiDecision | void;
+
+export interface ActionBattleSystems {
+  combat: ActionBattleCombatSystem;
+  ai: {
+    behaviors: Record<string, ActionBattleAiBehavior>;
+  };
+}

package/src/core/defaults.ts

@@ -0,0 +1,162 @@
+import type { RpgPlayer } from "@rpgjs/server";
+import type {
+  ActionBattleAiBehavior,
+  ActionBattleAttackContext,
+  ActionBattleCombatSystem,
+  ActionBattleDamageContext,
+  ActionBattleKnockbackContext,
+  ActionBattleKnockbackResult,
+  ActionBattleSystems,
+} from "./contracts";
+
+const DEFAULT_CORE_KNOCKBACK = {
+  force: 50,
+  duration: 300,
+};
+
+const CoreAttackPattern = {
+  Melee: "melee",
+  Combo: "combo",
+  Charged: "charged",
+  Zone: "zone",
+  DashAttack: "dashAttack",
+} as const;
+
+const CoreEnemyType = {
+  Aggressive: "aggressive",
+  Defensive: "defensive",
+  Ranged: "ranged",
+  Tank: "tank",
+  Berserker: "berserker",
+} as const;
+
+export const DEFAULT_ZELDA_PLAYER_HITBOXES = {
+  up: { offsetX: -16, offsetY: -48, width: 32, height: 32 },
+  down: { offsetX: -16, offsetY: 16, width: 32, height: 32 },
+  left: { offsetX: -48, offsetY: -16, width: 32, height: 32 },
+  right: { offsetX: 16, offsetY: -16, width: 32, height: 32 },
+  default: { offsetX: 0, offsetY: -32, width: 32, height: 32 },
+};
+
+const resolveEquippedWeapon = (entity: any) => {
+  const equipments = entity?.equipments?.() || [];
+  for (const item of equipments) {
+    const itemId = item?.id?.() ?? item?.id;
+    const itemData = entity?.databaseById?.(itemId);
+    if (itemData?._type === "weapon") return itemData;
+  }
+  return null;
+};
+
+const resolveDirection = (attacker: any, target: any) => {
+  const dx = target.x() - attacker.x();
+  const dy = target.y() - attacker.y();
+  const distance = Math.sqrt(dx * dx + dy * dy);
+  if (distance <= 0) return undefined;
+  return {
+    x: dx / distance,
+    y: dy / distance,
+  };
+};
+
+export const createDefaultPlayerHitboxResolver =
+  (hitboxes = DEFAULT_ZELDA_PLAYER_HITBOXES) =>
+  (context: ActionBattleAttackContext) => {
+    const attacker = context.attacker as any;
+    const direction =
+      context.direction ??
+      (typeof attacker.getDirection === "function"
+        ? attacker.getDirection()
+        : "default");
+    const config =
+      hitboxes[direction as keyof typeof hitboxes] || hitboxes.default;
+    return [
+      {
+        x: attacker.x() + config.offsetX,
+        y: attacker.y() + config.offsetY,
+        width: config.width,
+        height: config.height,
+      },
+    ];
+  };
+
+export const defaultRpgjsDamageResolver = (
+  context: ActionBattleDamageContext
+) => {
+  const target = context.target as any;
+  const raw = target.applyDamage(context.attacker as any, context.skill);
+  return {
+    damage: raw?.damage ?? 0,
+    defeated: target.hp <= 0,
+    raw,
+  };
+};
+
+export const defaultKnockbackResolver = (
+  context: ActionBattleKnockbackContext
+): ActionBattleKnockbackResult => {
+  const weapon = context.weapon ?? resolveEquippedWeapon(context.attacker);
+  return {
+    force: weapon?.knockbackForce ?? DEFAULT_CORE_KNOCKBACK.force,
+    duration: weapon?.knockbackDuration ?? DEFAULT_CORE_KNOCKBACK.duration,
+    direction: resolveDirection(context.attacker as any, context.target as any),
+  };
+};
+
+export const defaultCombatSystem: ActionBattleCombatSystem = {
+  resolveHitboxes: createDefaultPlayerHitboxResolver(),
+  resolveDamage: defaultRpgjsDamageResolver,
+  resolveKnockback: defaultKnockbackResolver,
+};
+
+export const defaultEnemyBehaviors: Record<string, ActionBattleAiBehavior> = {
+  [CoreEnemyType.Aggressive]: ({ hpPercent }) => ({
+    mode: hpPercent !== null && hpPercent < 0.15 ? "retreat" : "assault",
+    attackPatterns: [
+      CoreAttackPattern.Melee as any,
+      CoreAttackPattern.Combo as any,
+      CoreAttackPattern.DashAttack as any,
+    ],
+  }),
+  [CoreEnemyType.Defensive]: ({ hpPercent }) => ({
+    mode: hpPercent !== null && hpPercent < 0.3 ? "retreat" : "tactical",
+    attackPatterns: [CoreAttackPattern.Melee as any, CoreAttackPattern.Charged as any],
+  }),
+  [CoreEnemyType.Ranged]: ({ distance }) => ({
+    mode: distance !== null && distance < 80 ? "retreat" : "tactical",
+    attackPatterns: [CoreAttackPattern.Melee as any, CoreAttackPattern.Zone as any],
+  }),
+  [CoreEnemyType.Tank]: () => ({
+    mode: "assault",
+    attackPatterns: [
+      CoreAttackPattern.Melee as any,
+      CoreAttackPattern.Charged as any,
+      CoreAttackPattern.Zone as any,
+    ],
+  }),
+  [CoreEnemyType.Berserker]: ({ hpPercent }) => ({
+    mode: "assault",
+    attackCooldown:
+      hpPercent === null ? undefined : Math.max(250, 800 * Math.max(0.3, hpPercent)),
+    attackPatterns: [
+      CoreAttackPattern.Melee as any,
+      CoreAttackPattern.Combo as any,
+      CoreAttackPattern.DashAttack as any,
+    ],
+  }),
+};
+
+export const defaultActionBattleSystems: ActionBattleSystems = {
+  combat: defaultCombatSystem,
+  ai: {
+    behaviors: defaultEnemyBehaviors,
+  },
+};
+
+export const getEntityWeaponKnockbackForce = (entity: RpgPlayer): number => {
+  return defaultKnockbackResolver({
+    attacker: entity,
+    target: entity,
+    damage: { damage: 0, defeated: false },
+  }).force;
+};

package/src/core/hit.spec.ts

@@ -0,0 +1,58 @@
+import { describe, expect, test, vi } from "vitest";
+import { applyActionBattleHit } from "./hit";
+import type { ActionBattleCombatSystem } from "./contracts";
+
+const entity = (hp = 100) => ({
+  hp,
+  x: () => 0,
+  y: () => 0,
+  knockback: vi.fn(),
+});
+
+describe("applyActionBattleHit", () => {
+  test("runs beforeHit before resolving damage", () => {
+    const calls: string[] = [];
+    const attacker = entity();
+    const target = entity();
+    const system: ActionBattleCombatSystem = {
+      resolveHitboxes: () => [],
+      resolveDamage: () => {
+        calls.push("damage");
+        return { damage: 12, defeated: false };
+      },
+      resolveKnockback: () => ({ force: 0, duration: 0 }),
+      hooks: {
+        beforeHit() {
+          calls.push("before");
+        },
+        afterHit() {
+          calls.push("after");
+        },
+      },
+    };
+
+    const result = applyActionBattleHit(system, { attacker: attacker as any, target: target as any });
+
+    expect(result.damage).toBe(12);
+    expect(calls).toEqual(["before", "damage", "after"]);
+  });
+
+  test("can cancel a hit before damage is resolved", () => {
+    const resolveDamage = vi.fn();
+    const attacker = entity();
+    const target = entity();
+    const system: ActionBattleCombatSystem = {
+      resolveHitboxes: () => [],
+      resolveDamage,
+      resolveKnockback: () => ({ force: 0, duration: 0 }),
+      hooks: {
+        beforeHit: () => false,
+      },
+    };
+
+    const result = applyActionBattleHit(system, { attacker: attacker as any, target: target as any });
+
+    expect(result.cancelled).toBe(true);
+    expect(resolveDamage).not.toHaveBeenCalled();
+  });
+});

package/src/core/hit.ts

@@ -0,0 +1,66 @@
+import type { ActionBattleCombatSystem, ActionBattleHitContext, ActionBattleHitResult } from "./contracts";
+
+export const applyActionBattleHit = (
+  system: ActionBattleCombatSystem,
+  context: ActionBattleHitContext
+): ActionBattleHitResult => {
+  let hitContext = { ...context };
+  const before = system.hooks?.beforeHit?.(hitContext);
+  if (before === false) {
+    return {
+      damage: 0,
+      knockbackForce: 0,
+      knockbackDuration: 0,
+      defeated: false,
+      attacker: hitContext.attacker,
+      target: hitContext.target,
+      cancelled: true,
+      metadata: hitContext.metadata,
+    };
+  }
+  if (before) hitContext = before;
+
+  const damage =
+    hitContext.damage ??
+    system.resolveDamage({
+      attacker: hitContext.attacker,
+      target: hitContext.target,
+      skill: hitContext.skill,
+      pattern: hitContext.pattern,
+    });
+  hitContext.damage = damage;
+
+  const afterDamage = system.hooks?.afterDamage?.(hitContext);
+  if (afterDamage) hitContext = afterDamage;
+
+  const knockback =
+    hitContext.knockback ??
+    system.resolveKnockback({
+      attacker: hitContext.attacker,
+      target: hitContext.target,
+      damage,
+    });
+  hitContext.knockback = knockback;
+
+  if (!damage.defeated && knockback.force > 0 && knockback.direction) {
+    (hitContext.target as any).knockback?.(
+      knockback.direction,
+      knockback.force,
+      knockback.duration
+    );
+  }
+
+  const result: ActionBattleHitResult = {
+    damage: damage.damage,
+    knockbackForce: knockback.force,
+    knockbackDuration: knockback.duration,
+    defeated: damage.defeated,
+    attacker: hitContext.attacker,
+    target: hitContext.target,
+    rawDamage: damage.raw,
+    metadata: hitContext.metadata,
+  };
+
+  system.hooks?.afterHit?.(result);
+  return result;
+};

package/src/enemies/factory.ts

@@ -0,0 +1,25 @@
+import type { RpgEvent } from "@rpgjs/server";
+import { BattleAi, type BattleAiOptions } from "../ai.server";
+
+export interface ActionBattleEnemyPreset extends BattleAiOptions {
+  stats?: (event: RpgEvent) => void;
+}
+
+export type ActionBattleEnemyPresetMap = Record<string, ActionBattleEnemyPreset>;
+
+export const createActionEnemy = (
+  event: RpgEvent,
+  presetOrOptions: string | BattleAiOptions,
+  presets: ActionBattleEnemyPresetMap = {}
+) => {
+  const options =
+    typeof presetOrOptions === "string"
+      ? presets[presetOrOptions]
+      : presetOrOptions;
+  if (!options) {
+    throw new Error(`Action battle enemy preset not found: ${presetOrOptions}`);
+  }
+  const preset = options as ActionBattleEnemyPreset;
+  preset.stats?.(event);
+  return new BattleAi(event, options);
+};

package/src/index.ts

@@ -21,10 +21,50 @@ export type {
   ActionBattleActionBarSkill,
   ActionBattleSkillTargeting,
   ActionBattleSkillTargetingResolver,
+  ActionBattleAttackOptions,
   ActionBattleUiOptions,
   ActionBattleUiActionBarOptions,
   ActionBattleUiTargetingOptions,
+  ActionBattleCombatOptions,
+  ActionBattleSystemOptions,
+  ActionBattleAiSystemOptions,
 } from "./types";
+export type {
+  ActionBattleAiBehavior,
+  ActionBattleAiContext,
+  ActionBattleAiDecision,
+  ActionBattleAttackContext,
+  ActionBattleCombatSystem,
+  ActionBattleDamageContext,
+  ActionBattleDamageResult,
+  ActionBattleDirection,
+  ActionBattleEntity,
+  ActionBattleHitContext,
+  ActionBattleHitHooks,
+  ActionBattleHitResult,
+  ActionBattleHitbox,
+  ActionBattleKnockbackContext,
+  ActionBattleKnockbackResult,
+  ActionBattleSystems,
+} from "./core/contracts";
+export {
+  DEFAULT_ZELDA_PLAYER_HITBOXES,
+  createDefaultPlayerHitboxResolver,
+  defaultCombatSystem,
+  defaultEnemyBehaviors,
+  defaultKnockbackResolver,
+  defaultRpgjsDamageResolver,
+} from "./core/defaults";
+export {
+  createActionBattleSystems,
+  getActionBattleSystems,
+} from "./core/context";
+export { applyActionBattleHit } from "./core/hit";
+export {
+  createActionEnemy,
+  type ActionBattleEnemyPreset,
+  type ActionBattleEnemyPresetMap,
+} from "./enemies/factory";
 
 // Server exports
 export {