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

package/src/server.ts

@@ -6,10 +6,29 @@ import {
   ActionBattleActionBarSkill,
   ActionBattleOptions,
 } from "./types";
-import { normalizeActionBattleOptions } from "./config";
+import { normalizeActionBattleOptions, setActionBattleOptions } from "./config";
 import { manhattanDistance, parseAoeMask } from "./targeting";
+import { playActionBattleAnimation } from "./animations";
+import { getActionBattleSystems, setActionBattleSystems } from "./core/context";
+import { applyActionBattleHit } from "./core/hit";
+import { DEFAULT_ZELDA_PLAYER_HITBOXES } from "./core/defaults";
+import {
+  ActionBattleHitTracker,
+  createActionBattleAttackId,
+  getNormalizedActionBattleAttackProfile,
+  resolveActionBattleHitboxSpeed,
+  scheduleActionBattleStartup,
+} from "./core/attack-runtime";
+import { normalizeActionBattleAttackProfile } from "./core/attack-profile";
+import { resolveActionBattleWeaponAttackProfile } from "./core/equipment";
+import type { ActionBattleHitbox } from "./core/contracts";
+import type {
+  ActionBattleAttackProfile,
+  NormalizedActionBattleAttackProfile,
+} from "./types";
 
 export const ACTION_BATTLE_ACTION_BAR_GUI_ID = "action-battle-action-bar";
+const DEFAULT_ATTACK_LOCK_DURATION_MS = 350;
 
 /**
  * Default player attack hitboxes offsets for each direction
@@ -19,11 +38,127 @@ export const ACTION_BATTLE_ACTION_BAR_GUI_ID = "action-battle-action-bar";
  * when creating the moving hitbox.
  */
 export const DEFAULT_PLAYER_ATTACK_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 }
+  ...DEFAULT_ZELDA_PLAYER_HITBOXES,
+};
+
+const beginPlayerAttackLock = (
+  player: RpgPlayer,
+  map: ReturnType<RpgPlayer["getCurrentMap"]> | undefined,
+  durationMs: number,
+  locks: { movement: boolean; direction: boolean }
+): boolean => {
+  if (durationMs <= 0) return true;
+
+  const runtimePlayer = player as any;
+  const now = Date.now();
+  if (
+    typeof runtimePlayer.__actionBattleAttackLockedUntil === "number" &&
+    runtimePlayer.__actionBattleAttackLockedUntil > now
+  ) {
+    return false;
+  }
+
+  const lockId = (runtimePlayer.__actionBattleAttackLockId ?? 0) + 1;
+  runtimePlayer.__actionBattleAttackLockId = lockId;
+  runtimePlayer.__actionBattleAttackLockedUntil = now + durationMs;
+
+  const previousCanMove = player.canMove;
+  const previousDirectionFixed = player.directionFixed;
+  const previousAnimationFixed = player.animationFixed;
+
+  if (locks.movement) {
+    player.pendingInputs = [];
+    player.lastProcessedInputTs = 0;
+    (map as any)?.stopMovement?.(player);
+    player.canMove = false;
+  }
+  if (locks.direction) {
+    player.directionFixed = true;
+  }
+
+  setTimeout(() => {
+    if (runtimePlayer.__actionBattleAttackLockId !== lockId) return;
+    runtimePlayer.__actionBattleAttackLockedUntil = 0;
+    player.canMove = previousCanMove;
+    player.directionFixed = previousDirectionFixed;
+    player.animationFixed = previousAnimationFixed;
+  }, durationMs);
+
+  return true;
+};
+
+const isBattleEvent = (event: RpgEvent) => !!(event as any).battleAi;
+
+const rectsOverlap = (
+  a: { x: number; y: number; width: number; height: number },
+  b: { x: number; y: number; width: number; height: number }
+) =>
+  a.x < b.x + b.width &&
+  a.x + a.width > b.x &&
+  a.y < b.y + b.height &&
+  a.y + a.height > b.y;
+
+const eventRect = (event: RpgEvent) => {
+  const hitbox =
+    typeof event.hitbox === "function" ? event.hitbox() : (event as any).hitbox;
+  return {
+    x: event.x(),
+    y: event.y(),
+    width: hitbox?.w ?? 32,
+    height: hitbox?.h ?? 32,
+  };
+};
+
+const getVisibleActionEvents = (
+  player: RpgPlayer,
+  map: ReturnType<RpgPlayer["getCurrentMap"]> | undefined,
+  hitboxes: Array<{ x: number; y: number; width: number; height: number }>
+) => {
+  if (!map) return [];
+
+  const eventsById = new Map<string, RpgEvent>();
+  const addEvent = (event: RpgEvent | undefined) => {
+    if (!event) return;
+    const isVisible =
+      typeof (map as any).isEventVisibleForPlayer === "function"
+        ? (map as any).isEventVisibleForPlayer(event, player)
+        : true;
+    if (!isVisible) return;
+    eventsById.set(event.id, event);
+  };
+
+  const collisions = (map as any).getCollisions?.(player.id);
+  if (Array.isArray(collisions)) {
+    collisions.forEach((id: string) => addEvent(map.getEvent(id)));
+  }
+
+  const direction =
+    typeof player.getDirection === "function" ? player.getDirection() : undefined;
+  const interactionCollisions = (map as any).getInteractionCollisions?.(
+    player.id,
+    direction
+  );
+  if (Array.isArray(interactionCollisions)) {
+    interactionCollisions.forEach((id: string) => addEvent(map.getEvent(id)));
+  }
+
+  for (const event of map.getEvents()) {
+    const rect = eventRect(event);
+    if (hitboxes.some((hitbox) => rectsOverlap(hitbox, rect))) {
+      addEvent(event);
+    }
+  }
+
+  return Array.from(eventsById.values());
+};
+
+const isActionReservedForNormalEvent = (
+  player: RpgPlayer,
+  map: ReturnType<RpgPlayer["getCurrentMap"]> | undefined,
+  hitboxes: Array<{ x: number; y: number; width: number; height: number }>
+) => {
+  const events = getVisibleActionEvents(player, map, hitboxes);
+  return events.length > 0 && !events.some(isBattleEvent);
 };
 
 /**
@@ -92,57 +227,141 @@ export function getPlayerWeaponKnockbackForce(player: RpgPlayer): number {
 export function applyPlayerHitToEvent(
   player: RpgPlayer, 
   target: RpgEvent, 
-  hooks?: ApplyHitHooks
+  hooks?: ApplyHitHooks,
+  metadata?: Record<string, any>
 ): HitResult | undefined {
   const ai = (target as any).battleAi as BattleAi;
   if (!ai) return undefined;
 
-  // Get knockback force from player's weapon
-  const knockbackForce = getPlayerWeaponKnockbackForce(player);
-
-  // Apply damage to AI
-  const defeated = ai.takeDamage(player);
-
-  // Calculate knockback direction (away from player)
-  const dx = target.x() - player.x();
-  const dy = target.y() - player.y();
-  const distance = Math.sqrt(dx * dx + dy * dy);
-
-  // Create hit result
-  let hitResult: HitResult = {
-    damage: 0, // Will be set by takeDamage internally
-    knockbackForce,
-    knockbackDuration: DEFAULT_KNOCKBACK.duration,
-    defeated,
-    attacker: player,
-    target
-  };
-
-  // Call onBeforeHit hook
-  if (hooks?.onBeforeHit) {
-    const modified = hooks.onBeforeHit(hitResult);
-    if (modified) {
-      hitResult = modified;
+  const systems = getActionBattleSystems();
+  const result = applyActionBattleHit(
+    {
+      ...systems.combat,
+      hooks: hooks
+        ? {
+            ...systems.combat.hooks,
+            beforeHit(context) {
+              const before = systems.combat.hooks?.beforeHit?.(context);
+              if (before === false) return false;
+              const nextContext = before || context;
+              const legacyResult = toLegacyHitResult(nextContext);
+              const modified = hooks.onBeforeHit?.(legacyResult);
+              if (!modified) return nextContext;
+              return {
+                ...nextContext,
+                damage: {
+                  damage: modified.damage,
+                  defeated: modified.defeated,
+                  raw: nextContext.damage?.raw,
+                },
+                knockback: {
+                  force: modified.knockbackForce,
+                  duration: modified.knockbackDuration,
+                  direction: nextContext.knockback?.direction,
+                },
+              };
+            },
+            afterHit(result) {
+              systems.combat.hooks?.afterHit?.(result);
+              hooks.onAfterHit?.(result as HitResult);
+            },
+          }
+        : systems.combat.hooks,
+    },
+    {
+      attacker: player,
+      target,
+      metadata,
+      reaction: metadata?.reaction,
     }
-  }
-
-  // Apply knockback only if not defeated (entity still exists)
-  if (!hitResult.defeated && hitResult.knockbackForce > 0 && distance > 0) {
-    const knockbackDirection = {
-      x: dx / distance,
-      y: dy / distance
-    };
-    target.knockback(knockbackDirection, hitResult.knockbackForce, hitResult.knockbackDuration);
-  }
+  );
 
-  // Call onAfterHit hook
-  if (hooks?.onAfterHit) {
-    hooks.onAfterHit(hitResult);
+  if (!result.cancelled) {
+    ai.handleDamage(player, {
+      damage: result.damage,
+      defeated: result.defeated,
+      raw: result.rawDamage,
+      reaction: result.reaction,
+    });
   }
 
-  return hitResult;
+  return result as HitResult;
 }
 
+const toLegacyHitResult = (context: any): HitResult => ({
+  damage: context.damage?.damage ?? 0,
+  knockbackForce: context.knockback?.force ?? getPlayerWeaponKnockbackForce(context.attacker),
+  knockbackDuration: context.knockback?.duration ?? DEFAULT_KNOCKBACK.duration,
+  defeated: context.damage?.defeated ?? false,
+  attacker: context.attacker,
+  target: context.target,
+});
+
+const resolvePlayerAttackHitboxes = (
+  player: RpgPlayer,
+  directionKey: string,
+  options: ActionBattleOptions,
+  profile: NormalizedActionBattleAttackProfile
+): ActionBattleHitbox[] => {
+  const configuredHitboxes = {
+    ...DEFAULT_PLAYER_ATTACK_HITBOXES,
+    ...options.attack?.hitboxes,
+    ...profile.hitboxes,
+  };
+  const hitboxConfig =
+    configuredHitboxes[
+      directionKey as keyof typeof DEFAULT_PLAYER_ATTACK_HITBOXES
+    ] || configuredHitboxes.default;
+  const defaultHitboxes = [
+    {
+      x: player.x() + hitboxConfig.offsetX,
+      y: player.y() + hitboxConfig.offsetY,
+      width: hitboxConfig.width,
+      height: hitboxConfig.height,
+    },
+  ];
+  return (
+    options.attack?.resolveHitboxes?.({
+      player,
+      direction: directionKey,
+      defaultHitboxes,
+    }) ?? defaultHitboxes
+  );
+};
+
+const mergeAttackProfileOverrides = (
+  base: NormalizedActionBattleAttackProfile,
+  override: ActionBattleAttackProfile
+): ActionBattleAttackProfile => ({
+  ...base,
+  ...override,
+  reaction: {
+    ...base.reaction,
+    ...override.reaction,
+  },
+  hitboxes: {
+    ...base.hitboxes,
+    ...override.hitboxes,
+  },
+});
+
+const resolvePlayerAttackProfile = (
+  player: RpgPlayer,
+  options: ActionBattleOptions
+): NormalizedActionBattleAttackProfile => {
+  const baseProfile = getNormalizedActionBattleAttackProfile(options);
+  const weaponProfile = resolveActionBattleWeaponAttackProfile(player);
+  if (!weaponProfile) return baseProfile;
+  return normalizeActionBattleAttackProfile(
+    mergeAttackProfileOverrides(baseProfile, weaponProfile),
+    {
+      lockMovement: options.attack?.lockMovement,
+      lockDurationMs: options.attack?.lockDurationMs,
+      hitboxes: options.attack?.hitboxes,
+    }
+  );
+};
+
 const resolveSignal = (value: any) =>
   typeof value === "function" ? value() : value;
 
@@ -270,7 +489,7 @@ const ensureActionBarGui = (
   const gui = existing || player.gui(ACTION_BATTLE_ACTION_BAR_GUI_ID);
   if (!(gui as any).__actionBattleReady) {
     (gui as any).__actionBattleReady = true;
-    gui.on("useItem", ({ id }) => {
+    gui.on("useItem", ({ id }: { id: string }) => {
       try {
         player.useItem(id);
       } catch {
@@ -278,10 +497,13 @@ const ensureActionBarGui = (
       }
       gui.update(buildActionBarData(player, options));
     });
-    gui.on("useSkill", ({ id, target }) => {
-      handleActionBattleSkillUse(player, id, target, options);
-      gui.update(buildActionBarData(player, options));
-    });
+    gui.on(
+      "useSkill",
+      ({ id, target }: { id: string; target?: { x: number; y: number } }) => {
+        handleActionBattleSkillUse(player, id, target, options);
+        gui.update(buildActionBarData(player, options));
+      }
+    );
     gui.on("refresh", () => {
       gui.update(buildActionBarData(player, options));
     });
@@ -330,13 +552,21 @@ const handleActionBattleSkillUse = (
   target: { x: number; y: number } | undefined,
   options: ActionBattleOptions
 ) => {
+  const skillData = resolveSkillData(player, skillId);
+
   const map = player.getCurrentMap();
   if (!map) {
+    playActionBattleAnimation("castSkill", player, options.animations, {
+      skill: skillData,
+    });
     player.useSkill(skillId);
     return;
   }
   const targeting = resolveSkillTargeting(player, skillId, options);
   if (!targeting || !target) {
+    playActionBattleAnimation("castSkill", player, options.animations, {
+      skill: skillData,
+    });
     player.useSkill(skillId);
     return;
   }
@@ -362,7 +592,7 @@ const handleActionBattleSkillUse = (
   const targets: any[] = [];
   const affects = options.targeting?.affects || "events";
   if (affects === "events" || affects === "both") {
-    map.getEvents().forEach((event) => {
+    map.getEvents().forEach((event: RpgEvent) => {
       const tile = getEntityTile(event, tileSize);
       if (affected.has(`${tile.x},${tile.y}`)) {
         targets.push(event);
@@ -370,7 +600,7 @@ const handleActionBattleSkillUse = (
     });
   }
   if (affects === "players" || affects === "both") {
-    map.getPlayers().forEach((other) => {
+    map.getPlayers().forEach((other: RpgPlayer) => {
       if (other.id === player.id) return;
       const tile = getEntityTile(other, tileSize);
       if (affected.has(`${tile.x},${tile.y}`)) {
@@ -383,6 +613,10 @@ const handleActionBattleSkillUse = (
     return;
   }
 
+  playActionBattleAnimation("castSkill", player, options.animations, {
+    skill: skillData,
+    target: targets[0],
+  });
   player.useSkill(skillId, targets as any);
 };
 
@@ -390,6 +624,8 @@ export const createActionBattleServer = (
   rawOptions: ActionBattleOptions = {}
 ) => {
   const options = normalizeActionBattleOptions(rawOptions);
+  setActionBattleOptions(options);
+  setActionBattleSystems(options);
   return defineModule<RpgServer>({
     player: {
       /**
@@ -405,51 +641,90 @@ export const createActionBattleServer = (
        */
       onInput(player: RpgPlayer, input: any) {
         if (input.action == Control.Action) {
-          // Trigger attack animation
-          player.setGraphicAnimation("attack", 1);
-
-          // Get player position
-          const playerX = player.x();
-          const playerY = player.y();
+          const map = player.getCurrentMap();
           const direction = player.getDirection();
+          const attackProfile = resolvePlayerAttackProfile(player, options);
 
           // Convert Direction enum to string key
           const directionKey = direction as string;
 
-          // Get hitbox configuration for the direction
-          const hitboxConfig =
-            DEFAULT_PLAYER_ATTACK_HITBOXES[
-              directionKey as keyof typeof DEFAULT_PLAYER_ATTACK_HITBOXES
-            ] || DEFAULT_PLAYER_ATTACK_HITBOXES.default;
-
-          // Convert relative hitbox to absolute coordinates
-          const hitboxes: Array<{
-            x: number;
-            y: number;
-            width: number;
-            height: number;
-          }> = [
-            {
-              x: playerX + hitboxConfig.offsetX,
-              y: playerY + hitboxConfig.offsetY,
-              width: hitboxConfig.width,
-              height: hitboxConfig.height,
-            },
-          ];
-
-          const map = player.getCurrentMap();
-
-          map?.createMovingHitbox(hitboxes, { speed: 3 }).subscribe({
-            next(hits) {
-              hits.forEach((hit) => {
-                if (hit instanceof RpgEvent) {
-                  const result = applyPlayerHitToEvent(player, hit);
-                  if (result?.defeated) {
-                    console.log(`Player ${player.id} defeated AI ${hit.id}`);
-                  }
-                }
+          const hitboxes = resolvePlayerAttackHitboxes(
+            player,
+            directionKey,
+            options,
+            attackProfile
+          );
+
+          if (isActionReservedForNormalEvent(player, map, hitboxes)) {
+            return;
+          }
+
+          const lockMovement = attackProfile.movementLock;
+          const lockDirection = attackProfile.directionLock;
+          const lockDurationMs =
+            attackProfile.totalDurationMs ?? DEFAULT_ATTACK_LOCK_DURATION_MS;
+          const actionLocked = (lockMovement || lockDirection) && lockDurationMs > 0;
+
+          if (
+            actionLocked &&
+            !beginPlayerAttackLock(player, map, Math.max(0, lockDurationMs), {
+              movement: lockMovement,
+              direction: lockDirection,
+            })
+          ) {
+            return;
+          }
+
+          playActionBattleAnimation("attack", player, options.animations);
+          if (actionLocked) {
+            player.animationFixed = true;
+          }
+          const attackId = createActionBattleAttackId(
+            player.id,
+            attackProfile.id
+          );
+          const hitTracker = new ActionBattleHitTracker(
+            attackProfile.hitPolicy
+          );
+          if (options.debug?.attacks) {
+            console.log("[ActionBattle] player attack", {
+              attackId,
+              playerId: player.id,
+              profile: attackProfile.id,
+              hitboxes,
+            });
+          }
+
+          scheduleActionBattleStartup(attackProfile, () => {
+            map
+              ?.createMovingHitbox(hitboxes, {
+                speed: resolveActionBattleHitboxSpeed(
+                  attackProfile,
+                  hitboxes.length
+                ),
+              })
+              .subscribe({
+                next(hits: any[]) {
+                  hits.forEach((hit: any) => {
+                    if (hit instanceof RpgEvent) {
+                      if (!hitTracker.tryHit(hit)) return;
+                      const result = applyPlayerHitToEvent(
+                        player,
+                        hit,
+                        undefined,
+                        {
+                          attackId,
+                          attackProfileId: attackProfile.id,
+                          reaction: attackProfile.reaction,
+                        }
+                      );
+                      if (result?.defeated) {
+                        console.log(`Player ${player.id} defeated AI ${hit.id}`);
+                      }
+                    }
+                  });
+                },
               });
-            },
           });
         }
       },
@@ -494,3 +769,62 @@ export const createActionBattleServer = (
 };
 
 export default createActionBattleServer();
+
+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,
+  BattleAiDefeatedCallback,
+  BattleAiDefeatedContext,
+  BattleAiDefeatReward,
+  BattleAiLegacyDefeatedCallback,
+  BattleAiLegacyOptions,
+  BattleAiOptions,
+  BattleAiRewardItem,
+  BattleAiRewards,
+  HitResult,
+} from "./ai.server";

package/src/targeting.spec.ts

@@ -0,0 +1,24 @@
+import { describe, expect, test } from "vitest";
+import { manhattanDistance, parseAoeMask } from "./targeting";
+
+describe("targeting helpers", () => {
+  test("parses an ASCII AoE mask around its center", () => {
+    const mask = parseAoeMask([".#.", "###", ".#."]);
+
+    expect(mask.width).toBe(3);
+    expect(mask.height).toBe(3);
+    expect(mask.cells).toEqual(
+      expect.arrayContaining([
+        { dx: 0, dy: -1 },
+        { dx: -1, dy: 0 },
+        { dx: 0, dy: 0 },
+        { dx: 1, dy: 0 },
+        { dx: 0, dy: 1 },
+      ])
+    );
+  });
+
+  test("uses Manhattan distance for tile targeting", () => {
+    expect(manhattanDistance({ x: 2, y: 3 }, { x: 5, y: 1 })).toBe(5);
+  });
+});

package/src/types/canvas-engine.d.ts

@@ -0,0 +1,4 @@
+declare module "*.ce" {
+  const component: any;
+  export default component;
+}