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

package/src/animations.ts

@@ -0,0 +1,110 @@
+import type {
+  ActionBattleAnimationContext,
+  ActionBattleAnimationEntity,
+  ActionBattleAnimationKey,
+  ActionBattleAnimationOptions,
+} from "./types";
+
+export const DEFAULT_DIE_ANIMATION_DELAY_MS = 500;
+
+export interface ResolvedActionBattleAnimation {
+  animationName: string;
+  graphic?: string | string[];
+  repeat: number;
+  waitEnd: boolean;
+  delayMs?: number;
+}
+
+export interface ActionBattleAnimationDefaults {
+  animationName?: string;
+  repeat?: number;
+}
+
+const DEFAULT_ANIMATION_BY_KEY: Record<ActionBattleAnimationKey, string> = {
+  attack: "attack",
+  hurt: "hurt",
+  die: "die",
+  castSkill: "skill",
+};
+
+export function resolveActionBattleAnimation(
+  key: ActionBattleAnimationKey,
+  entity: ActionBattleAnimationEntity,
+  animations?: ActionBattleAnimationOptions,
+  context?: ActionBattleAnimationContext,
+  defaults: ActionBattleAnimationDefaults = {}
+): ResolvedActionBattleAnimation | null {
+  const defaultAnimationName =
+    defaults.animationName ?? DEFAULT_ANIMATION_BY_KEY[key];
+  const defaultRepeat = defaults.repeat ?? 1;
+  const hasConfiguredAnimation = animations
+    ? Object.prototype.hasOwnProperty.call(animations, key)
+    : false;
+  if (!hasConfiguredAnimation && key !== "attack") {
+    return null;
+  }
+
+  const configured = hasConfiguredAnimation
+    ? animations?.[key]
+    : defaultAnimationName;
+  const result =
+    typeof configured === "function"
+      ? configured(entity, context)
+      : configured;
+
+  if (result == null) return null;
+
+  if (typeof result === "string") {
+    return {
+      animationName: result,
+      repeat: defaultRepeat,
+      waitEnd: false,
+    };
+  }
+
+  const animationName = result.animationName ?? defaultAnimationName;
+  return {
+    animationName,
+    graphic: result.graphic,
+    repeat: result.repeat ?? defaultRepeat,
+    waitEnd: result.waitEnd ?? false,
+    delayMs: result.delayMs,
+  };
+}
+
+export function playActionBattleAnimation(
+  key: ActionBattleAnimationKey,
+  entity: ActionBattleAnimationEntity,
+  animations?: ActionBattleAnimationOptions,
+  context?: ActionBattleAnimationContext,
+  defaults: ActionBattleAnimationDefaults = {}
+): ResolvedActionBattleAnimation | null {
+  const animation = resolveActionBattleAnimation(
+    key,
+    entity,
+    animations,
+    context,
+    defaults
+  );
+  if (!animation) return null;
+
+  if (animation.graphic !== undefined) {
+    entity.setGraphicAnimation(
+      animation.animationName,
+      animation.graphic,
+      animation.repeat
+    );
+  } else {
+    entity.setGraphicAnimation(animation.animationName, animation.repeat);
+  }
+
+  return animation;
+}
+
+export function getActionBattleAnimationRemovalDelay(
+  animation: ResolvedActionBattleAnimation | null
+): number {
+  if (!animation) return 0;
+  if (animation.delayMs !== undefined) return animation.delayMs;
+  return animation.waitEnd ? DEFAULT_DIE_ANIMATION_DELAY_MS : 0;
+}

package/src/config.ts

@@ -24,8 +24,12 @@ export const DEFAULT_ACTION_BATTLE_OPTIONS: ActionBattleOptions = {
     affects: "events",
     allowEmptyTarget: true,
   },
+  animations: {},
 };
 
+let currentActionBattleOptions: ActionBattleOptions =
+  DEFAULT_ACTION_BATTLE_OPTIONS;
+
 export function normalizeActionBattleOptions(
   options: ActionBattleOptions = {}
 ): ActionBattleOptions {
@@ -52,5 +56,17 @@ export function normalizeActionBattleOptions(
       ...DEFAULT_ACTION_BATTLE_OPTIONS.targeting,
       ...options.targeting,
     },
+    animations: {
+      ...DEFAULT_ACTION_BATTLE_OPTIONS.animations,
+      ...options.animations,
+    },
   };
 }
+
+export function setActionBattleOptions(options: ActionBattleOptions) {
+  currentActionBattleOptions = options;
+}
+
+export function getActionBattleOptions(): ActionBattleOptions {
+  return currentActionBattleOptions;
+}

package/src/index.ts

@@ -7,8 +7,14 @@ import type { ActionBattleOptions } from "./types";
 export { BattleAi, AiState, EnemyType, AttackPattern, AiDebug, DEFAULT_KNOCKBACK } from "./ai.server";
 
 // Types exports
-export type { HitResult, ApplyHitHooks } from "./ai.server";
+export type { HitResult, ApplyHitHooks, BattleAiOptions } from "./ai.server";
 export type {
+  ActionBattleAnimationContext,
+  ActionBattleAnimationEntity,
+  ActionBattleAnimationKey,
+  ActionBattleAnimationOptions,
+  ActionBattleAnimationResolver,
+  ActionBattleAnimationResult,
   ActionBattleOptions,
   ActionBattleActionBarData,
   ActionBattleActionBarItem,

package/src/server.ts

@@ -6,8 +6,9 @@ import {
   ActionBattleActionBarSkill,
   ActionBattleOptions,
 } from "./types";
-import { normalizeActionBattleOptions } from "./config";
+import { normalizeActionBattleOptions, setActionBattleOptions } from "./config";
 import { manhattanDistance, parseAoeMask } from "./targeting";
+import { playActionBattleAnimation } from "./animations";
 
 export const ACTION_BATTLE_ACTION_BAR_GUI_ID = "action-battle-action-bar";
 
@@ -330,13 +331,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;
   }
@@ -383,6 +392,10 @@ const handleActionBattleSkillUse = (
     return;
   }
 
+  playActionBattleAnimation("castSkill", player, options.animations, {
+    skill: skillData,
+    target: targets[0],
+  });
   player.useSkill(skillId, targets as any);
 };
 
@@ -390,6 +403,7 @@ export const createActionBattleServer = (
   rawOptions: ActionBattleOptions = {}
 ) => {
   const options = normalizeActionBattleOptions(rawOptions);
+  setActionBattleOptions(options);
   return defineModule<RpgServer>({
     player: {
       /**
@@ -405,8 +419,7 @@ export const createActionBattleServer = (
        */
       onInput(player: RpgPlayer, input: any) {
         if (input.action == Control.Action) {
-          // Trigger attack animation
-          player.setGraphicAnimation("attack", 1);
+          playActionBattleAnimation("attack", player, options.animations);
 
           // Get player position
           const playerX = player.x();

package/src/types.ts

@@ -4,6 +4,52 @@ export type ActionBattleActionBarMode = "items" | "skills" | "both";
 
 export type ActionBattleTargetingAffects = "events" | "players" | "both";
 
+export type ActionBattleAnimationKey =
+  | "attack"
+  | "hurt"
+  | "die"
+  | "castSkill";
+
+export type ActionBattleAnimationResult =
+  | string
+  | {
+      animationName?: string;
+      graphic?: string | string[];
+      repeat?: number;
+      waitEnd?: boolean;
+      delayMs?: number;
+    }
+  | null
+  | undefined;
+
+export type ActionBattleAnimationEntity = {
+  setGraphicAnimation(animationName: string, repeat: number): void;
+  setGraphicAnimation(
+    animationName: string,
+    graphic: string | string[],
+    repeat: number
+  ): void;
+  [key: string]: any;
+};
+
+export interface ActionBattleAnimationContext {
+  skill?: any;
+  attacker?: ActionBattleAnimationEntity;
+  target?: ActionBattleAnimationEntity;
+}
+
+export type ActionBattleAnimationResolver = (
+  entity: ActionBattleAnimationEntity,
+  context?: ActionBattleAnimationContext
+) => ActionBattleAnimationResult;
+
+export type ActionBattleAnimationOptions = Partial<
+  Record<
+    ActionBattleAnimationKey,
+    ActionBattleAnimationResult | ActionBattleAnimationResolver
+  >
+>;
+
 export interface ActionBattleSkillTargeting {
   range: number;
   aoeMask?: ActionBattleAoeMask;
@@ -49,6 +95,7 @@ export interface ActionBattleOptions {
   ui?: ActionBattleUiOptions;
   skills?: ActionBattleSkillOptions;
   targeting?: ActionBattleTargetingOptions;
+  animations?: ActionBattleAnimationOptions;
 }
 
 export interface ActionBattleActionBarItem {