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

package/src/server.ts

@@ -8,7 +8,15 @@ import {
 } from "./types";
 import { normalizeActionBattleOptions, setActionBattleOptions } from "./config";
 import { manhattanDistance, parseAoeMask } from "./targeting";
-import { playActionBattleAnimation } from "./animations";
+import { emitActionBattleClientVisual } from "./visual";
+import {
+  applyActionBattleAttackDirection,
+  resolveActionBattleAttackDirection,
+} from "./attack-input";
+import {
+  forceActionBattleLocomotionAnimation,
+  withActionBattleAnimationUnlocked,
+} from "./locomotion";
 import { getActionBattleSystems, setActionBattleSystems } from "./core/context";
 import { applyActionBattleHit } from "./core/hit";
 import { DEFAULT_ZELDA_PLAYER_HITBOXES } from "./core/defaults";
@@ -16,12 +24,25 @@ import {
   ActionBattleHitTracker,
   createActionBattleAttackId,
   getNormalizedActionBattleAttackProfile,
-  resolveActionBattleHitboxSpeed,
-  scheduleActionBattleStartup,
+  runActionBattleActiveHitbox,
 } from "./core/attack-runtime";
+import {
+  canActionBattleUseTarget,
+  executeActionBattleUse,
+  getActionBattleActionConfig,
+  handleActionBattleProjectileDestroy,
+  handleActionBattleProjectileImpact,
+} from "./core/action-use";
 import { normalizeActionBattleAttackProfile } from "./core/attack-profile";
-import { resolveActionBattleWeaponAttackProfile } from "./core/equipment";
+import {
+  resolveActionBattleWeapon,
+  resolveActionBattleWeaponAttackProfile,
+} from "./core/equipment";
 import type { ActionBattleHitbox } from "./core/contracts";
+import {
+  canActionBattleTarget,
+  getActionBattleTargets,
+} from "./core/targets";
 import type {
   ActionBattleAttackProfile,
   NormalizedActionBattleAttackProfile,
@@ -82,6 +103,9 @@ const beginPlayerAttackLock = (
     player.canMove = previousCanMove;
     player.directionFixed = previousDirectionFixed;
     player.animationFixed = previousAnimationFixed;
+    if (locks.movement && !previousAnimationFixed) {
+      forceActionBattleLocomotionAnimation(player, "stand");
+    }
   }, durationMs);
 
   return true;
@@ -98,12 +122,12 @@ const rectsOverlap = (
   a.y < b.y + b.height &&
   a.y + a.height > b.y;
 
-const eventRect = (event: RpgEvent) => {
+const entityRect = (entity: RpgPlayer | RpgEvent | any) => {
   const hitbox =
-    typeof event.hitbox === "function" ? event.hitbox() : (event as any).hitbox;
+    typeof entity.hitbox === "function" ? entity.hitbox() : entity.hitbox;
   return {
-    x: event.x(),
-    y: event.y(),
+    x: entity.x(),
+    y: entity.y(),
     width: hitbox?.w ?? 32,
     height: hitbox?.h ?? 32,
   };
@@ -143,7 +167,7 @@ const getVisibleActionEvents = (
   }
 
   for (const event of map.getEvents()) {
-    const rect = eventRect(event);
+    const rect = entityRect(event);
     if (hitboxes.some((hitbox) => rectsOverlap(hitbox, rect))) {
       addEvent(event);
     }
@@ -229,9 +253,19 @@ export function applyPlayerHitToEvent(
   target: RpgEvent, 
   hooks?: ApplyHitHooks,
   metadata?: Record<string, any>
+): HitResult | undefined {
+  if (!(target as any).battleAi) return undefined;
+  return applyActionBattleEntityHit(player, target, hooks, metadata);
+}
+
+export function applyActionBattleEntityHit(
+  attacker: RpgPlayer | RpgEvent,
+  target: RpgPlayer | RpgEvent,
+  hooks?: ApplyHitHooks,
+  metadata?: Record<string, any>
 ): HitResult | undefined {
   const ai = (target as any).battleAi as BattleAi;
-  if (!ai) return undefined;
+  if (target instanceof RpgEvent && !ai) return undefined;
 
   const systems = getActionBattleSystems();
   const result = applyActionBattleHit(
@@ -269,15 +303,15 @@ export function applyPlayerHitToEvent(
         : systems.combat.hooks,
     },
     {
-      attacker: player,
+      attacker,
       target,
       metadata,
       reaction: metadata?.reaction,
     }
   );
 
-  if (!result.cancelled) {
-    ai.handleDamage(player, {
+  if (!result.cancelled && ai) {
+    ai.handleDamage(attacker, {
       damage: result.damage,
       defeated: result.defeated,
       raw: result.rawDamage,
@@ -329,6 +363,39 @@ const resolvePlayerAttackHitboxes = (
   );
 };
 
+const getActionBattleHitboxCandidates = (
+  map: ReturnType<RpgPlayer["getCurrentMap"]> | undefined,
+  hitboxes: ActionBattleHitbox[],
+  options: { excludeIds?: string[]; kinds?: Array<"players" | "events"> } = {}
+) => {
+  if (!map) return [];
+  if (typeof (map as any).queryHitbox === "function") {
+    const candidates = new Map<string, RpgPlayer | RpgEvent>();
+    for (const hitbox of hitboxes) {
+      for (const entity of (map as any).queryHitbox(hitbox, options)) {
+        if (entity?.id) candidates.set(entity.id, entity);
+      }
+    }
+    return Array.from(candidates.values());
+  }
+
+  const candidates = new Map<string, RpgPlayer | RpgEvent>();
+  const excluded = new Set(options.excludeIds ?? []);
+  const add = (entity: RpgPlayer | RpgEvent | undefined) => {
+    if (!entity?.id) return;
+    if (excluded.has(entity.id)) return;
+    const rect = entityRect(entity);
+    if (hitboxes.some((hitbox) => rectsOverlap(hitbox, rect))) {
+      candidates.set(entity.id, entity);
+    }
+  };
+
+  const kinds = new Set(options.kinds ?? ["players", "events"]);
+  if (kinds.has("players")) map.getPlayers?.().forEach(add);
+  if (kinds.has("events")) map.getEvents?.().forEach(add);
+  return Array.from(candidates.values());
+};
+
 const mergeAttackProfileOverrides = (
   base: NormalizedActionBattleAttackProfile,
   override: ActionBattleAttackProfile
@@ -381,6 +448,16 @@ const resolveSkillData = (player: RpgPlayer, skillId: string) => {
   }
 };
 
+const resolvePlayerSkillUsable = (player: RpgPlayer, skillId: string) => {
+  try {
+    return (
+      (player as any).getSkill?.(skillId) ?? resolveSkillData(player, skillId)
+    );
+  } catch {
+    return resolveSkillData(player, skillId);
+  }
+};
+
 const resolveSkillTargeting = (
   player: RpgPlayer,
   skillId: string,
@@ -552,11 +629,24 @@ const handleActionBattleSkillUse = (
   target: { x: number; y: number } | undefined,
   options: ActionBattleOptions
 ) => {
-  const skillData = resolveSkillData(player, skillId);
+  const skillData = resolvePlayerSkillUsable(player, skillId);
+  const actionConfig = getActionBattleActionConfig(skillData);
+
+  if (actionConfig?.target === "self") {
+    executeActionBattleUse({
+      attacker: player,
+      target: player,
+      usable: skillData,
+      skill: skillData,
+    });
+    return;
+  }
 
   const map = player.getCurrentMap();
   if (!map) {
-    playActionBattleAnimation("castSkill", player, options.animations, {
+    emitActionBattleClientVisual({
+      moment: "castSkill",
+      entity: player,
       skill: skillData,
     });
     player.useSkill(skillId);
@@ -564,7 +654,9 @@ const handleActionBattleSkillUse = (
   }
   const targeting = resolveSkillTargeting(player, skillId, options);
   if (!targeting || !target) {
-    playActionBattleAnimation("castSkill", player, options.animations, {
+    emitActionBattleClientVisual({
+      moment: "castSkill",
+      entity: player,
       skill: skillData,
     });
     player.useSkill(skillId);
@@ -590,11 +682,20 @@ const handleActionBattleSkillUse = (
   });
 
   const targets: any[] = [];
+  const actionTarget = actionConfig?.target ?? "enemy";
   const affects = options.targeting?.affects || "events";
   if (affects === "events" || affects === "both") {
     map.getEvents().forEach((event: RpgEvent) => {
       const tile = getEntityTile(event, tileSize);
-      if (affected.has(`${tile.x},${tile.y}`)) {
+      if (
+        affected.has(`${tile.x},${tile.y}`) &&
+        canActionBattleUseTarget(
+          player,
+          event,
+          actionTarget,
+          options.combat?.targets
+        )
+      ) {
         targets.push(event);
       }
     });
@@ -603,7 +704,15 @@ const handleActionBattleSkillUse = (
     map.getPlayers().forEach((other: RpgPlayer) => {
       if (other.id === player.id) return;
       const tile = getEntityTile(other, tileSize);
-      if (affected.has(`${tile.x},${tile.y}`)) {
+      if (
+        affected.has(`${tile.x},${tile.y}`) &&
+        canActionBattleUseTarget(
+          player,
+          other,
+          actionTarget,
+          options.combat?.targets
+        )
+      ) {
         targets.push(other);
       }
     });
@@ -613,11 +722,12 @@ const handleActionBattleSkillUse = (
     return;
   }
 
-  playActionBattleAnimation("castSkill", player, options.animations, {
+  executeActionBattleUse({
+    attacker: player,
+    target: targets,
+    usable: skillData,
     skill: skillData,
-    target: targets[0],
   });
-  player.useSkill(skillId, targets as any);
 };
 
 export const createActionBattleServer = (
@@ -642,20 +752,22 @@ export const createActionBattleServer = (
       onInput(player: RpgPlayer, input: any) {
         if (input.action == Control.Action) {
           const map = player.getCurrentMap();
-          const direction = player.getDirection();
+          const direction = resolveActionBattleAttackDirection(player, input);
+          applyActionBattleAttackDirection(player, direction);
           const attackProfile = resolvePlayerAttackProfile(player, options);
 
           // Convert Direction enum to string key
           const directionKey = direction as string;
 
-          const hitboxes = resolvePlayerAttackHitboxes(
+          const resolveActiveHitboxes = () => resolvePlayerAttackHitboxes(
             player,
             directionKey,
             options,
             attackProfile
           );
+          const initialHitboxes = resolveActiveHitboxes();
 
-          if (isActionReservedForNormalEvent(player, map, hitboxes)) {
+          if (isActionReservedForNormalEvent(player, map, initialHitboxes)) {
             return;
           }
 
@@ -675,7 +787,12 @@ export const createActionBattleServer = (
             return;
           }
 
-          playActionBattleAnimation("attack", player, options.animations);
+          withActionBattleAnimationUnlocked(player, () => {
+            emitActionBattleClientVisual({
+              moment: "attack",
+              entity: player,
+            });
+          });
           if (actionLocked) {
             player.animationFixed = true;
           }
@@ -683,53 +800,60 @@ export const createActionBattleServer = (
             player.id,
             attackProfile.id
           );
+          const weapon = resolveActionBattleWeapon(player);
           const hitTracker = new ActionBattleHitTracker(
             attackProfile.hitPolicy
           );
-          if (options.debug?.attacks) {
-            console.log("[ActionBattle] player attack", {
-              attackId,
-              playerId: player.id,
-              profile: attackProfile.id,
-              hitboxes,
+          const targetSelector = getActionBattleTargets(player, "events");
+
+          const processHits = (hits: any[]) => {
+            hits.forEach((hit: any) => {
+              if (
+                !canActionBattleTarget(
+                  player,
+                  hit,
+                  targetSelector,
+                  options.combat?.targets
+                )
+              ) {
+                return;
+              }
+              if (!hitTracker.tryHit(hit)) return;
+              const handledByWeapon =
+                weapon &&
+                executeActionBattleUse({
+                  attacker: player,
+                  target: hit,
+                  usable: weapon,
+                  weapon,
+                  profile: attackProfile,
+                  playVisual: false,
+                });
+              if (handledByWeapon) return;
+              applyActionBattleEntityHit(player, hit, undefined, {
+                attackId,
+                attackProfileId: attackProfile.id,
+                reaction: attackProfile.reaction,
+              });
             });
-          }
-
-          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}`);
-                      }
-                    }
-                  });
-                },
+          };
+
+          runActionBattleActiveHitbox(
+            attackProfile,
+            resolveActiveHitboxes,
+            (activeHitboxes) => {
+              const candidates = getActionBattleHitboxCandidates(map, activeHitboxes, {
+                excludeIds: [player.id],
+                kinds: ["players", "events"],
               });
-          });
+              processHits(candidates);
+            }
+          );
         }
       },
       onConnected(player: RpgPlayer) {
-        if (options.ui?.actionBar?.enabled && options.ui?.actionBar?.autoOpen) {
+        const actionBar = options.ui?.actionBar as any;
+        if (actionBar?.enabled && actionBar?.autoOpen) {
           openActionBattleActionBar(player, options);
         }
       },
@@ -765,6 +889,23 @@ export const createActionBattleServer = (
         ai?.onDetectOutShape(player, shape);
       },
     },
+    projectiles: {
+      onImpact(context: any) {
+        handleActionBattleProjectileImpact({
+          attacker:
+            context.projectile?.payload?.attackerId
+              ? context.map?.getObjectById?.(context.projectile.payload.attackerId)
+              : undefined,
+          target: context.target,
+          projectile: context.projectile,
+          hit: context.hit,
+          map: context.map,
+        } as any);
+      },
+      onDestroy(context: any) {
+        handleActionBattleProjectileDestroy(context.projectile?.id);
+      },
+    },
   });
 };
 
@@ -776,6 +917,7 @@ export {
   createActionBattleAttackId,
   getNormalizedActionBattleAttackProfile,
   resolveActionBattleHitboxSpeed,
+  runActionBattleActiveHitbox,
   scheduleActionBattleStartup,
 } from "./core/attack-runtime";
 export {
@@ -789,11 +931,31 @@ export type {
   ActionBattleAttackHitboxMap,
   ActionBattleAttackHitPolicy,
   ActionBattleAttackProfile,
-  ActionBattleDebugOptions,
   ActionBattleHitReactionProfile,
   NormalizedActionBattleHitReactionProfile,
   NormalizedActionBattleAttackProfile,
 } from "./types";
+export type {
+  ActionBattleActionConfig,
+  ActionBattleActionMode,
+  ActionBattleActionTarget,
+  ActionBattleProjectileImpactContext,
+  ActionBattleProjectileOptions,
+  ActionBattleTargetContext,
+  ActionBattleTargetOptions,
+  ActionBattleTargetSelector,
+  ActionBattleUsable,
+  ActionBattleUseContext,
+} from "./core/contracts";
+export {
+  canActionBattleUseTarget,
+  executeActionBattleUse,
+  getActionBattleActionConfig,
+  getActionBattleActionRange,
+  handleActionBattleProjectileDestroy,
+  handleActionBattleProjectileImpact,
+  shouldUseActionBattleUsable,
+} from "./core/action-use";
 export {
   DEFAULT_ACTION_BATTLE_HIT_REACTION,
   isActionBattleEntityInvincible,
@@ -807,7 +969,21 @@ export {
   type ActionBattleEnemyAttackProfileMap,
   type NormalizedActionBattleEnemyAttackProfileMap,
 } from "./core/enemy-attack-profiles";
-export { resolveActionBattleWeaponAttackProfile } from "./core/equipment";
+export {
+  resolveActionBattleWeapon,
+  resolveActionBattleWeaponAttackProfile,
+} from "./core/equipment";
+export {
+  ACTION_BATTLE_ENEMY_FACTION,
+  ACTION_BATTLE_PLAYER_FACTION,
+  canActionBattleTarget,
+  getActionBattleFaction,
+  getActionBattleTargets,
+  isActionBattleCombatEntity,
+  isActionBattleEvent,
+  isActionBattlePlayer,
+  matchesActionBattleTargetSelector,
+} from "./core/targets";
 export {
   AiDebug,
   AiState,

package/src/types.ts

@@ -1,5 +1,7 @@
 import type {
   ActionBattleAiBehavior,
+  ActionBattleAiPreset,
+  ActionBattleTargetOptions,
   ActionBattleCombatSystem,
   ActionBattleHitHooks,
   ActionBattleHitbox,
@@ -31,12 +33,8 @@ export type ActionBattleAnimationResult =
   | undefined;
 
 export type ActionBattleAnimationEntity = {
-  setGraphicAnimation(animationName: string, repeat: number): void;
-  setGraphicAnimation(
-    animationName: string,
-    graphic: string | string[],
-    repeat: number
-  ): void;
+  setGraphicAnimation?: (...args: any[]) => unknown;
+  setAnimation?: (...args: any[]) => unknown;
   [key: string]: any;
 };
 
@@ -67,28 +65,6 @@ export type ActionBattleSkillTargetingResolver = (
   skill: any
 ) => ActionBattleSkillTargeting | null | undefined;
 
-export interface ActionBattleUiActionBarOptions {
-  enabled?: boolean;
-  autoOpen?: boolean;
-  mode?: ActionBattleActionBarMode;
-}
-
-export interface ActionBattleUiTargetingOptions {
-  enabled?: boolean;
-  showGrid?: boolean;
-  tileSize?: { width: number; height: number };
-  colors?: {
-    area?: number;
-    edge?: number;
-    cursor?: number;
-  };
-}
-
-export interface ActionBattleUiOptions {
-  actionBar?: ActionBattleUiActionBarOptions;
-  targeting?: ActionBattleUiTargetingOptions;
-}
-
 export type ActionBattleAttackDirection =
   | "up"
   | "down"
@@ -145,6 +121,7 @@ export interface NormalizedActionBattleAttackProfile
 }
 
 export interface ActionBattleSkillOptions {
+  targeting?: ActionBattleSkillTargetingResolver;
   getTargeting?: ActionBattleSkillTargetingResolver;
   defaultAoeMask?: ActionBattleAoeMask;
 }
@@ -154,10 +131,6 @@ export interface ActionBattleTargetingOptions {
   allowEmptyTarget?: boolean;
 }
 
-export interface ActionBattleDebugOptions {
-  attacks?: boolean;
-}
-
 export interface ActionBattleAttackOptions {
   profile?: ActionBattleAttackProfile;
   lockMovement?: boolean;
@@ -175,26 +148,123 @@ export interface ActionBattleAttackOptions {
 }
 
 export interface ActionBattleCombatOptions {
+  attack?: ActionBattleAttackOptions;
   damage?: ActionBattleCombatSystem["resolveDamage"];
   knockback?: ActionBattleCombatSystem["resolveKnockback"];
   hooks?: ActionBattleHitHooks;
+  targets?: ActionBattleTargetOptions;
 }
 
-export interface ActionBattleAiSystemOptions {
+export interface ActionBattleAiOptions {
   behaviors?: Record<string, ActionBattleAiBehavior>;
+  presets?: Record<string, ActionBattleAiPreset>;
 }
 
+export type ActionBattleAiSystemOptions = ActionBattleAiOptions;
+
 export interface ActionBattleSystemOptions {
   combat?: ActionBattleCombatOptions;
-  ai?: ActionBattleAiSystemOptions;
+  ai?: ActionBattleAiOptions;
+}
+
+export type ActionBattleVisualMoment =
+  | "attack"
+  | "castSkill"
+  | "hit"
+  | "hurt"
+  | "defeat"
+  | "preview";
+
+export interface ActionBattleVisualContext {
+  moment: ActionBattleVisualMoment;
+  entity?: any;
+  target?: any;
+  attacker?: any;
+  damage?: number;
+  defeated?: boolean;
+  result?: any;
+  skill?: any;
+  pattern?: string;
+  animations?: ActionBattleAnimationOptions;
+  animationDefaults?: {
+    animationName?: string;
+    repeat?: number;
+  };
+}
+
+export interface ActionBattleVisualHelpers {
+  graphic(entity: any, keyOrOptions: ActionBattleAnimationKey | ActionBattleAnimationResult): void;
+  flash(entity: any, options?: Record<string, any>): void;
+  damageText(entity: any, damageOrText?: number | string): void;
+  component(entity: any, id: string, params?: Record<string, any>): void;
+  preview(entity: any, options?: Record<string, any>): void;
+}
+
+export type ActionBattleVisualPart = (
+  context: ActionBattleVisualContext,
+  helpers: ActionBattleVisualHelpers
+) => void;
+
+export type ActionBattleVisualComposer = (
+  context: ActionBattleVisualContext
+) => void;
+
+export type ActionBattleVisualPreset = "classic" | "fx" | "none";
+
+export type ActionBattleVisualInput =
+  | ActionBattleVisualPreset
+  | ActionBattleVisualComposer
+  | Partial<Record<ActionBattleVisualMoment, ActionBattleVisualPart>>;
+
+export interface ActionBattleUiActionBarOptions {
+  enabled?: boolean;
+  autoOpen?: boolean;
+  mode?: ActionBattleActionBarMode;
+  component?: any;
+}
+
+export interface ActionBattleUiTargetingOptions {
+  enabled?: boolean;
+  component?: any;
+  showGrid?: boolean;
+  tileSize?: { width: number; height: number };
+  colors?: {
+    area?: number;
+    edge?: number;
+    cursor?: number;
+  };
+}
+
+export interface ActionBattleUiAttackPreviewOptions {
+  enabled?: boolean;
+  component?: any;
+}
+
+export interface ActionBattleUiGuiEntry {
+  id: string;
+  component: any;
+  dependencies?: Function;
+}
+
+export interface ActionBattleUiOptions {
+  actionBar?: boolean | ActionBattleUiActionBarOptions;
+  targeting?: boolean | ActionBattleUiTargetingOptions;
+  attackPreview?: boolean | ActionBattleUiAttackPreviewOptions;
+  gui?: ActionBattleUiGuiEntry[];
+  spriteComponents?: {
+    front?: any[];
+    back?: any[];
+  } | any[];
 }
 
 export interface ActionBattleOptions {
+  combat?: ActionBattleCombatOptions;
+  visual?: ActionBattleVisualInput;
   ui?: ActionBattleUiOptions;
+  ai?: ActionBattleAiOptions;
   skills?: ActionBattleSkillOptions;
   targeting?: ActionBattleTargetingOptions;
   attack?: ActionBattleAttackOptions;
-  debug?: ActionBattleDebugOptions;
   animations?: ActionBattleAnimationOptions;
   systems?: ActionBattleSystemOptions;
 }