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

package/dist/client/index8.js

@@ -1,69 +1,61 @@
-const DEFAULT_ACTION_BATTLE_OPTIONS = {
-  ui: {
-    actionBar: {
-      enabled: false,
-      autoOpen: false,
-      mode: "both"
-    },
-    targeting: {
-      enabled: true,
-      showGrid: true,
-      colors: {
-        area: 3120887,
-        edge: 1796760,
-        cursor: 16765286
-      }
-    }
-  },
-  skills: {
-    defaultAoeMask: ["#"]
-  },
-  targeting: {
-    affects: "events",
-    allowEmptyTarget: true
-  },
-  animations: {}
+var DEFAULT_ANIMATION_BY_KEY = {
+	attack: "attack",
+	hurt: "hurt",
+	die: "die",
+	castSkill: "skill",
+	castSpell: "skill"
 };
-let currentActionBattleOptions = DEFAULT_ACTION_BATTLE_OPTIONS;
-function normalizeActionBattleOptions(options = {}) {
-  return {
-    ui: {
-      actionBar: {
-        ...DEFAULT_ACTION_BATTLE_OPTIONS.ui?.actionBar,
-        ...options.ui?.actionBar
-      },
-      targeting: {
-        ...DEFAULT_ACTION_BATTLE_OPTIONS.ui?.targeting,
-        ...options.ui?.targeting,
-        colors: {
-          ...DEFAULT_ACTION_BATTLE_OPTIONS.ui?.targeting?.colors,
-          ...options.ui?.targeting?.colors
-        }
-      }
-    },
-    skills: {
-      ...DEFAULT_ACTION_BATTLE_OPTIONS.skills,
-      ...options.skills
-    },
-    targeting: {
-      ...DEFAULT_ACTION_BATTLE_OPTIONS.targeting,
-      ...options.targeting
-    },
-    animations: {
-      ...DEFAULT_ACTION_BATTLE_OPTIONS.animations,
-      ...options.animations
-    }
-  };
+var getConfiguredAnimation = (key, animations) => {
+	if (!animations) return {
+		hasConfiguredAnimation: false,
+		configured: void 0
+	};
+	const hasConfiguredAnimation = Object.prototype.hasOwnProperty.call(animations, key);
+	if (hasConfiguredAnimation) return {
+		hasConfiguredAnimation,
+		configured: animations[key]
+	};
+	if (key === "castSkill") return {
+		hasConfiguredAnimation: Object.prototype.hasOwnProperty.call(animations, "castSpell"),
+		configured: animations.castSpell
+	};
+	return {
+		hasConfiguredAnimation: false,
+		configured: void 0
+	};
+};
+function resolveActionBattleAnimation(key, entity, animations, context, defaults = {}) {
+	const defaultAnimationName = defaults.animationName ?? DEFAULT_ANIMATION_BY_KEY[key];
+	const defaultRepeat = defaults.repeat ?? 1;
+	const { hasConfiguredAnimation, configured: configuredAnimation } = getConfiguredAnimation(key, animations);
+	if (!hasConfiguredAnimation && key !== "attack") return null;
+	const configured = hasConfiguredAnimation ? configuredAnimation : 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
+	};
+	return {
+		animationName: result.animationName ?? defaultAnimationName,
+		graphic: result.graphic,
+		repeat: result.repeat ?? defaultRepeat,
+		waitEnd: result.waitEnd ?? false,
+		delayMs: result.delayMs
+	};
 }
-function setActionBattleOptions(options) {
-  currentActionBattleOptions = options;
+function playActionBattleAnimation(key, entity, animations, context, defaults = {}) {
+	const animation = resolveActionBattleAnimation(key, entity, animations, context, defaults);
+	if (!animation) return null;
+	if (animation.graphic !== void 0) entity.setGraphicAnimation(animation.animationName, animation.graphic, animation.repeat);
+	else entity.setGraphicAnimation(animation.animationName, animation.repeat);
+	return animation;
 }
-function getActionBattleOptions() {
-  return currentActionBattleOptions;
+function getActionBattleAnimationRemovalDelay(animation) {
+	if (!animation) return 0;
+	if (animation.delayMs !== void 0) return animation.delayMs;
+	return animation.waitEnd ? 500 : 0;
 }
-export {
-  DEFAULT_ACTION_BATTLE_OPTIONS,
-  getActionBattleOptions,
-  normalizeActionBattleOptions,
-  setActionBattleOptions
-};
+//#endregion
+export { getActionBattleAnimationRemovalDelay, playActionBattleAnimation, resolveActionBattleAnimation };

package/dist/client/index9.js

@@ -1,64 +1,99 @@
-const DEFAULT_DIE_ANIMATION_DELAY_MS = 500;
-const DEFAULT_ANIMATION_BY_KEY = {
-  attack: "attack",
-  hurt: "hurt",
-  die: "die",
-  castSkill: "skill"
+import { normalizeActionBattleOptions } from "./index2.js";
+import { setActionBattleOptions, startAttackPreview, stopAttackPreview } from "./index3.js";
+import component from "./index4.js";
+import component$1 from "./index6.js";
+import component$2 from "./index7.js";
+import { resolveActionBattleAnimation } from "./index8.js";
+import { PrebuiltComponentAnimations, RpgClientEngine, RpgGui, inject } from "@rpgjs/client";
+import { defineModule } from "@rpgjs/common";
+//#region src/client.ts
+var DEFAULT_ATTACK_LOCK_DURATION_MS = 350;
+var beginLocalPlayerAttackLock = (engine, durationMs) => {
+	if (durationMs <= 0) return true;
+	const player = engine.scene?.getCurrentPlayer?.();
+	if (!player) return true;
+	const runtimePlayer = player;
+	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 = typeof player.canMove === "function" ? player.canMove() : true;
+	const previousDirectionFixed = player.directionFixed;
+	const previousAnimationFixed = player.animationFixed;
+	if (typeof engine.interruptCurrentPlayerMovement === "function") engine.interruptCurrentPlayerMovement(player);
+	else engine.scene?.stopMovement?.(player);
+	player.canMove.set(false);
+	player.directionFixed = true;
+	player.animationFixed = true;
+	setTimeout(() => {
+		if (runtimePlayer.__actionBattleAttackLockId !== lockId) return;
+		runtimePlayer.__actionBattleAttackLockedUntil = 0;
+		player.canMove.set(previousCanMove);
+		player.directionFixed = previousDirectionFixed;
+		player.animationFixed = previousAnimationFixed;
+	}, durationMs);
+	return true;
 };
-function resolveActionBattleAnimation(key, entity, animations, context, defaults = {}) {
-  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
-  };
-}
-function playActionBattleAnimation(key, entity, animations, context, defaults = {}) {
-  const animation = resolveActionBattleAnimation(
-    key,
-    entity,
-    animations,
-    context,
-    defaults
-  );
-  if (!animation) return null;
-  if (animation.graphic !== void 0) {
-    entity.setGraphicAnimation(
-      animation.animationName,
-      animation.graphic,
-      animation.repeat
-    );
-  } else {
-    entity.setGraphicAnimation(animation.animationName, animation.repeat);
-  }
-  return animation;
-}
-function getActionBattleAnimationRemovalDelay(animation) {
-  if (!animation) return 0;
-  if (animation.delayMs !== void 0) return animation.delayMs;
-  return animation.waitEnd ? DEFAULT_DIE_ANIMATION_DELAY_MS : 0;
-}
-export {
-  DEFAULT_DIE_ANIMATION_DELAY_MS,
-  getActionBattleAnimationRemovalDelay,
-  playActionBattleAnimation,
-  resolveActionBattleAnimation
+var resolveLocalPlayerDirection = (player) => {
+	if (typeof player.getDirection === "function") return player.getDirection();
+	if (typeof player.direction === "function") return player.direction();
+	return player.direction ?? "down";
 };
+var playLocalPlayerAttackAnimation = (player, options) => {
+	if (!player || typeof player.setAnimation !== "function") return;
+	const animation = resolveActionBattleAnimation("attack", player, options.animations);
+	if (!animation) return;
+	if (animation.graphic !== void 0) {
+		player.setAnimation(animation.animationName, animation.graphic, animation.repeat);
+		return;
+	}
+	player.setAnimation(animation.animationName, animation.repeat);
+};
+var showLocalAttackPreview = (player, options) => {
+	if (!player || options.attack?.showPreview === false) return;
+	const durationMs = Math.max(1, options.attack?.previewDurationMs ?? 180);
+	const previewId = startAttackPreview({
+		direction: resolveLocalPlayerDirection(player),
+		durationMs,
+		color: options.attack?.previewColor,
+		accentColor: options.attack?.previewAccentColor
+	});
+	setTimeout(() => stopAttackPreview(previewId), durationMs);
+};
+var createActionBattleClient = (options = {}) => {
+	const normalized = normalizeActionBattleOptions(options);
+	setActionBattleOptions(normalized);
+	const actionBarEnabled = normalized.ui?.actionBar?.enabled;
+	const componentsInFront = [...normalized.ui?.targeting?.enabled ? [component$1] : [], component$2];
+	const hitComponent = PrebuiltComponentAnimations?.Hit;
+	return defineModule({
+		componentAnimations: hitComponent ? [{
+			id: "hit",
+			component: hitComponent
+		}] : [],
+		gui: actionBarEnabled ? [{
+			id: "action-battle-action-bar",
+			component,
+			dependencies: () => {
+				return [inject(RpgClientEngine).scene.currentPlayer];
+			}
+		}] : [],
+		sprite: { componentsInFront },
+		sceneMap: { onAfterLoading() {
+			if (actionBarEnabled && normalized.ui?.actionBar?.autoOpen) inject(RpgGui).display("action-battle-action-bar");
+		} },
+		engine: { onInput(engine, { input }) {
+			if (input !== "action") return;
+			const player = engine.scene?.getCurrentPlayer?.();
+			if (!player) return;
+			const lockDurationMs = Math.max(0, normalized.attack?.lockDurationMs ?? DEFAULT_ATTACK_LOCK_DURATION_MS);
+			beginLocalPlayerAttackLock(engine, normalized.attack?.lockMovement === false ? 0 : lockDurationMs);
+			playLocalPlayerAttackAnimation(player, normalized);
+			showLocalAttackPreview(player, normalized);
+		} }
+	});
+};
+var client_default = createActionBattleClient();
+//#endregion
+export { createActionBattleClient, client_default as default };

package/dist/client.d.ts

@@ -1,4 +1,5 @@
+import { RpgClient } from '@rpgjs/client';
 import { ActionBattleOptions } from './types';
-export declare const createActionBattleClient: (options?: ActionBattleOptions) => any;
-declare const _default: any;
+export declare const createActionBattleClient: (options?: ActionBattleOptions) => RpgClient;
+declare const _default: RpgClient;
 export default _default;

package/dist/core/context.d.ts

@@ -0,0 +1,5 @@
+import { ActionBattleOptions } from '../types';
+import { ActionBattleSystems } from './contracts';
+export declare const setActionBattleSystems: (options?: ActionBattleOptions) => void;
+export declare const getActionBattleSystems: () => ActionBattleSystems;
+export declare const createActionBattleSystems: (options?: ActionBattleOptions) => ActionBattleSystems;

package/dist/core/defaults.d.ts

@@ -0,0 +1,81 @@
+import { RpgPlayer } from '@rpgjs/server';
+import { ActionBattleAiBehavior, ActionBattleAttackContext, ActionBattleCombatSystem, ActionBattleDamageContext, ActionBattleKnockbackContext, ActionBattleKnockbackResult, ActionBattleSystems } from './contracts';
+export declare const DEFAULT_ZELDA_PLAYER_HITBOXES: {
+    up: {
+        offsetX: number;
+        offsetY: number;
+        width: number;
+        height: number;
+    };
+    down: {
+        offsetX: number;
+        offsetY: number;
+        width: number;
+        height: number;
+    };
+    left: {
+        offsetX: number;
+        offsetY: number;
+        width: number;
+        height: number;
+    };
+    right: {
+        offsetX: number;
+        offsetY: number;
+        width: number;
+        height: number;
+    };
+    default: {
+        offsetX: number;
+        offsetY: number;
+        width: number;
+        height: number;
+    };
+};
+export declare const createDefaultPlayerHitboxResolver: (hitboxes?: {
+    up: {
+        offsetX: number;
+        offsetY: number;
+        width: number;
+        height: number;
+    };
+    down: {
+        offsetX: number;
+        offsetY: number;
+        width: number;
+        height: number;
+    };
+    left: {
+        offsetX: number;
+        offsetY: number;
+        width: number;
+        height: number;
+    };
+    right: {
+        offsetX: number;
+        offsetY: number;
+        width: number;
+        height: number;
+    };
+    default: {
+        offsetX: number;
+        offsetY: number;
+        width: number;
+        height: number;
+    };
+}) => (context: ActionBattleAttackContext) => {
+    x: any;
+    y: any;
+    width: number;
+    height: number;
+}[];
+export declare const defaultRpgjsDamageResolver: (context: ActionBattleDamageContext) => {
+    damage: any;
+    defeated: boolean;
+    raw: any;
+};
+export declare const defaultKnockbackResolver: (context: ActionBattleKnockbackContext) => ActionBattleKnockbackResult;
+export declare const defaultCombatSystem: ActionBattleCombatSystem;
+export declare const defaultEnemyBehaviors: Record<string, ActionBattleAiBehavior>;
+export declare const defaultActionBattleSystems: ActionBattleSystems;
+export declare const getEntityWeaponKnockbackForce: (entity: RpgPlayer) => number;

package/dist/core/hit.d.ts

@@ -0,0 +1,2 @@
+import { ActionBattleCombatSystem, ActionBattleHitContext, ActionBattleHitResult } from './contracts';
+export declare const applyActionBattleHit: (system: ActionBattleCombatSystem, context: ActionBattleHitContext) => ActionBattleHitResult;

package/dist/enemies/factory.d.ts

@@ -0,0 +1,7 @@
+import { RpgEvent } from '@rpgjs/server';
+import { BattleAi, BattleAiOptions } from '../ai.server';
+export interface ActionBattleEnemyPreset extends BattleAiOptions {
+    stats?: (event: RpgEvent) => void;
+}
+export type ActionBattleEnemyPresetMap = Record<string, ActionBattleEnemyPreset>;
+export declare const createActionEnemy: (event: RpgEvent, presetOrOptions: string | BattleAiOptions, presets?: ActionBattleEnemyPresetMap) => BattleAi;

package/dist/index.d.ts

@@ -1,11 +1,16 @@
 import { ActionBattleOptions } from './types';
 export { BattleAi, AiState, EnemyType, AttackPattern, AiDebug, DEFAULT_KNOCKBACK } from './ai.server';
 export type { HitResult, ApplyHitHooks, BattleAiOptions } from './ai.server';
-export type { ActionBattleAnimationContext, ActionBattleAnimationEntity, ActionBattleAnimationKey, ActionBattleAnimationOptions, ActionBattleAnimationResolver, ActionBattleAnimationResult, ActionBattleOptions, ActionBattleActionBarData, ActionBattleActionBarItem, ActionBattleActionBarSkill, ActionBattleSkillTargeting, ActionBattleSkillTargetingResolver, ActionBattleUiOptions, ActionBattleUiActionBarOptions, ActionBattleUiTargetingOptions, } from './types';
+export type { ActionBattleAnimationContext, ActionBattleAnimationEntity, ActionBattleAnimationKey, ActionBattleAnimationOptions, ActionBattleAnimationResolver, ActionBattleAnimationResult, ActionBattleOptions, ActionBattleActionBarData, ActionBattleActionBarItem, 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';
 export { DEFAULT_PLAYER_ATTACK_HITBOXES, getPlayerWeaponKnockbackForce, applyPlayerHitToEvent, ACTION_BATTLE_ACTION_BAR_GUI_ID, openActionBattleActionBar, updateActionBattleActionBar, createActionBattleServer, } from './server';
-export declare function provideActionBattle(options?: ActionBattleOptions): any;
+export declare function provideActionBattle(options?: ActionBattleOptions): any[];
 declare const _default: {
-    server: any;
-    client: any;
+    server: import('@rpgjs/server').RpgServer;
+    client: import('@rpgjs/client').RpgClient;
 };
 export default _default;

package/dist/server/index.js

@@ -1,35 +1,22 @@
-import server, { createActionBattleServer } from "./index2.js";
-import { ACTION_BATTLE_ACTION_BAR_GUI_ID, DEFAULT_PLAYER_ATTACK_HITBOXES, applyPlayerHitToEvent, getPlayerWeaponKnockbackForce, openActionBattleActionBar, updateActionBattleActionBar } from "./index2.js";
+import { DEFAULT_ZELDA_PLAYER_HITBOXES, createDefaultPlayerHitboxResolver, defaultCombatSystem, defaultEnemyBehaviors, defaultKnockbackResolver, defaultRpgjsDamageResolver } from "./index4.js";
+import { createActionBattleSystems, getActionBattleSystems } from "./index5.js";
+import { AiDebug, AiState, AttackPattern, BattleAi, DEFAULT_KNOCKBACK, EnemyType } from "./index6.js";
+import { applyActionBattleHit } from "./index8.js";
+import server_default, { ACTION_BATTLE_ACTION_BAR_GUI_ID, DEFAULT_PLAYER_ATTACK_HITBOXES, applyPlayerHitToEvent, createActionBattleServer, getPlayerWeaponKnockbackForce, openActionBattleActionBar, updateActionBattleActionBar } from "./index9.js";
+import { createActionEnemy } from "./index10.js";
 import { createModule } from "@rpgjs/common";
-import { AiDebug, AiState, AttackPattern, BattleAi, DEFAULT_KNOCKBACK, EnemyType } from "./index3.js";
-const client = null;
-const createActionBattleClient = null;
+//#region src/index.ts
+var client = null;
+var createActionBattleClient = null;
 function provideActionBattle(options = {}) {
-  return createModule("ActionBattle", [
-    {
-      server: createActionBattleServer?.(options),
-      client: createActionBattleClient?.(options)
-    }
-  ]);
+	return createModule("ActionBattle", [{
+		server: createActionBattleServer?.(options),
+		client: createActionBattleClient?.(options)
+	}]);
 }
-const index = {
-  server,
-  client
-};
-export {
-  ACTION_BATTLE_ACTION_BAR_GUI_ID,
-  AiDebug,
-  AiState,
-  AttackPattern,
-  BattleAi,
-  DEFAULT_KNOCKBACK,
-  DEFAULT_PLAYER_ATTACK_HITBOXES,
-  EnemyType,
-  applyPlayerHitToEvent,
-  createActionBattleServer,
-  index as default,
-  getPlayerWeaponKnockbackForce,
-  openActionBattleActionBar,
-  provideActionBattle,
-  updateActionBattleActionBar
+var src_default = {
+	server: server_default,
+	client
 };
+//#endregion
+export { ACTION_BATTLE_ACTION_BAR_GUI_ID, AiDebug, AiState, AttackPattern, BattleAi, DEFAULT_KNOCKBACK, DEFAULT_PLAYER_ATTACK_HITBOXES, DEFAULT_ZELDA_PLAYER_HITBOXES, EnemyType, applyActionBattleHit, applyPlayerHitToEvent, createActionBattleServer, createActionBattleSystems, createActionEnemy, createDefaultPlayerHitboxResolver, src_default as default, defaultCombatSystem, defaultEnemyBehaviors, defaultKnockbackResolver, defaultRpgjsDamageResolver, getActionBattleSystems, getPlayerWeaponKnockbackForce, openActionBattleActionBar, provideActionBattle, updateActionBattleActionBar };

package/dist/server/index10.js

@@ -0,0 +1,10 @@
+import { BattleAi } from "./index6.js";
+//#region src/enemies/factory.ts
+var createActionEnemy = (event, presetOrOptions, presets = {}) => {
+	const options = typeof presetOrOptions === "string" ? presets[presetOrOptions] : presetOrOptions;
+	if (!options) throw new Error(`Action battle enemy preset not found: ${presetOrOptions}`);
+	options.stats?.(event);
+	return new BattleAi(event, options);
+};
+//#endregion
+export { createActionEnemy };