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

package/dist/server/index7.js

@@ -1,25 +1,199 @@
-import { defaultActionBattleSystems } from "./index6.js";
-//#region src/core/context.ts
-var mergeSystems = (options = {}) => ({
-	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
-	} }
-});
-var currentActionBattleSystems = mergeSystems();
-var setActionBattleSystems = (options = {}) => {
-	currentActionBattleSystems = mergeSystems(options);
-};
-var getActionBattleSystems = () => currentActionBattleSystems;
-var createActionBattleSystems = mergeSystems;
+//#region src/core/defaults.ts
+var DEFAULT_CORE_KNOCKBACK = {
+	force: 50,
+	duration: 300
+};
+var CoreAttackPattern = {
+	Melee: "melee",
+	Combo: "combo",
+	Charged: "charged",
+	Zone: "zone",
+	DashAttack: "dashAttack"
+};
+var CoreEnemyType = {
+	Aggressive: "aggressive",
+	Defensive: "defensive",
+	Ranged: "ranged",
+	Tank: "tank",
+	Berserker: "berserker"
+};
+var 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
+	}
+};
+var resolveEquippedWeapon = (entity) => {
+	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;
+};
+var resolveDirection = (attacker, target) => {
+	const dx = target.x() - attacker.x();
+	const dy = target.y() - attacker.y();
+	const distance = Math.sqrt(dx * dx + dy * dy);
+	if (distance <= 0) return void 0;
+	return {
+		x: dx / distance,
+		y: dy / distance
+	};
+};
+var createDefaultPlayerHitboxResolver = (hitboxes = DEFAULT_ZELDA_PLAYER_HITBOXES) => (context) => {
+	const attacker = context.attacker;
+	const config = hitboxes[context.direction ?? (typeof attacker.getDirection === "function" ? attacker.getDirection() : "default")] || hitboxes.default;
+	return [{
+		x: attacker.x() + config.offsetX,
+		y: attacker.y() + config.offsetY,
+		width: config.width,
+		height: config.height
+	}];
+};
+var defaultRpgjsDamageResolver = (context) => {
+	const target = context.target;
+	const raw = target.applyDamage(context.attacker, context.skill);
+	return {
+		damage: raw?.damage ?? 0,
+		defeated: target.hp <= 0,
+		raw
+	};
+};
+var defaultKnockbackResolver = (context) => {
+	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, context.target)
+	};
+};
+var defaultCombatSystem = {
+	resolveHitboxes: createDefaultPlayerHitboxResolver(),
+	resolveDamage: defaultRpgjsDamageResolver,
+	resolveKnockback: defaultKnockbackResolver
+};
+var defaultEnemyBehaviors = {
+	[CoreEnemyType.Aggressive]: ({ hpPercent }) => ({
+		mode: hpPercent !== null && hpPercent < .15 ? "retreat" : "assault",
+		attackPatterns: [
+			CoreAttackPattern.Melee,
+			CoreAttackPattern.Combo,
+			CoreAttackPattern.DashAttack
+		]
+	}),
+	[CoreEnemyType.Defensive]: ({ hpPercent }) => ({
+		mode: hpPercent !== null && hpPercent < .3 ? "retreat" : "tactical",
+		attackPatterns: [CoreAttackPattern.Melee, CoreAttackPattern.Charged]
+	}),
+	[CoreEnemyType.Ranged]: ({ distance }) => ({
+		mode: distance !== null && distance < 80 ? "retreat" : "tactical",
+		attackPatterns: [CoreAttackPattern.Melee, CoreAttackPattern.Zone]
+	}),
+	[CoreEnemyType.Tank]: () => ({
+		mode: "assault",
+		attackPatterns: [
+			CoreAttackPattern.Melee,
+			CoreAttackPattern.Charged,
+			CoreAttackPattern.Zone
+		]
+	}),
+	[CoreEnemyType.Berserker]: ({ hpPercent }) => ({
+		mode: "assault",
+		attackCooldown: hpPercent === null ? void 0 : Math.max(250, 800 * Math.max(.3, hpPercent)),
+		attackPatterns: [
+			CoreAttackPattern.Melee,
+			CoreAttackPattern.Combo,
+			CoreAttackPattern.DashAttack
+		]
+	})
+};
+var defaultEnemyPresets = {
+	[CoreEnemyType.Aggressive]: {
+		enemyType: CoreEnemyType.Aggressive,
+		attackCooldown: 600,
+		visionRange: 150,
+		attackRange: 50,
+		dodgeChance: .1,
+		dodgeCooldown: 3e3,
+		fleeThreshold: .15,
+		behaviorKey: CoreEnemyType.Aggressive
+	},
+	[CoreEnemyType.Defensive]: {
+		enemyType: CoreEnemyType.Defensive,
+		attackCooldown: 1500,
+		visionRange: 120,
+		attackRange: 60,
+		dodgeChance: .5,
+		dodgeCooldown: 1500,
+		fleeThreshold: .3,
+		behaviorKey: CoreEnemyType.Defensive
+	},
+	[CoreEnemyType.Ranged]: {
+		enemyType: CoreEnemyType.Ranged,
+		attackCooldown: 1200,
+		visionRange: 200,
+		attackRange: 120,
+		dodgeChance: .4,
+		dodgeCooldown: 2e3,
+		fleeThreshold: .25,
+		behaviorKey: CoreEnemyType.Ranged
+	},
+	[CoreEnemyType.Tank]: {
+		enemyType: CoreEnemyType.Tank,
+		attackCooldown: 2e3,
+		visionRange: 100,
+		attackRange: 50,
+		dodgeChance: 0,
+		dodgeCooldown: 5e3,
+		fleeThreshold: .1,
+		poise: 2,
+		behaviorKey: CoreEnemyType.Tank
+	},
+	[CoreEnemyType.Berserker]: {
+		enemyType: CoreEnemyType.Berserker,
+		attackCooldown: 800,
+		visionRange: 180,
+		attackRange: 55,
+		dodgeChance: .15,
+		dodgeCooldown: 2500,
+		fleeThreshold: .05,
+		behaviorKey: CoreEnemyType.Berserker
+	}
+};
+var defaultActionBattleSystems = {
+	combat: defaultCombatSystem,
+	ai: {
+		behaviors: defaultEnemyBehaviors,
+		presets: defaultEnemyPresets
+	}
+};
 //#endregion
-export { createActionBattleSystems, getActionBattleSystems, setActionBattleSystems };
+export { DEFAULT_ZELDA_PLAYER_HITBOXES, createDefaultPlayerHitboxResolver, defaultActionBattleSystems, defaultCombatSystem, defaultEnemyBehaviors, defaultEnemyPresets, defaultKnockbackResolver, defaultRpgjsDamageResolver };

package/dist/server/index8.js

@@ -1,72 +1,34 @@
-import { normalizeActionBattleAttackProfile } from "./index4.js";
-//#region src/core/enemy-attack-profiles.ts
-var DEFAULT_ACTION_BATTLE_ENEMY_ATTACK_PROFILES = {
-	melee: {
-		id: "enemy-melee",
-		startupMs: 120,
-		activeMs: 100,
-		recoveryMs: 220,
-		cooldownMs: 440,
-		reaction: {
-			invincibilityMs: 250,
-			hitstunMs: 120,
-			staggerPower: 1
+import { defaultActionBattleSystems } from "./index7.js";
+//#region src/core/context.ts
+var mergeSystems = (options = {}) => ({
+	combat: {
+		...defaultActionBattleSystems.combat,
+		resolveDamage: options.combat?.damage ?? options.systems?.combat?.damage ?? defaultActionBattleSystems.combat.resolveDamage,
+		resolveKnockback: options.combat?.knockback ?? options.systems?.combat?.knockback ?? defaultActionBattleSystems.combat.resolveKnockback,
+		hooks: {
+			...defaultActionBattleSystems.combat.hooks,
+			...options.systems?.combat?.hooks,
+			...options.combat?.hooks
 		}
 	},
-	combo: {
-		id: "enemy-combo",
-		startupMs: 80,
-		activeMs: 80,
-		recoveryMs: 140,
-		cooldownMs: 300,
-		reaction: {
-			invincibilityMs: 180,
-			hitstunMs: 90,
-			staggerPower: .75
-		}
-	},
-	charged: {
-		id: "enemy-charged",
-		startupMs: 800,
-		activeMs: 140,
-		recoveryMs: 320,
-		cooldownMs: 1260,
-		reaction: {
-			invincibilityMs: 350,
-			hitstunMs: 220,
-			staggerPower: 2
-		}
-	},
-	zone: {
-		id: "enemy-zone",
-		startupMs: 450,
-		activeMs: 180,
-		recoveryMs: 320,
-		cooldownMs: 950,
-		reaction: {
-			invincibilityMs: 300,
-			hitstunMs: 160,
-			staggerPower: 1.25
-		}
-	},
-	dashAttack: {
-		id: "enemy-dash",
-		startupMs: 180,
-		activeMs: 120,
-		recoveryMs: 260,
-		cooldownMs: 560,
-		reaction: {
-			invincibilityMs: 280,
-			hitstunMs: 150,
-			staggerPower: 1.2
+	ai: {
+		behaviors: {
+			...defaultActionBattleSystems.ai.behaviors,
+			...options.systems?.ai?.behaviors,
+			...options.ai?.behaviors
+		},
+		presets: {
+			...defaultActionBattleSystems.ai.presets,
+			...options.systems?.ai?.presets,
+			...options.ai?.presets
 		}
 	}
+});
+var currentActionBattleSystems = mergeSystems();
+var setActionBattleSystems = (options = {}) => {
+	currentActionBattleSystems = mergeSystems(options);
 };
-function normalizeActionBattleEnemyAttackProfiles(overrides = {}) {
-	return Object.fromEntries(Object.entries(DEFAULT_ACTION_BATTLE_ENEMY_ATTACK_PROFILES).map(([key, defaultProfile]) => [key, normalizeActionBattleAttackProfile({
-		...defaultProfile,
-		...overrides[key]
-	})]));
-}
+var getActionBattleSystems = () => currentActionBattleSystems;
+var createActionBattleSystems = mergeSystems;
 //#endregion
-export { DEFAULT_ACTION_BATTLE_ENEMY_ATTACK_PROFILES, normalizeActionBattleEnemyAttackProfiles };
+export { createActionBattleSystems, getActionBattleSystems, setActionBattleSystems };

package/dist/server/index9.js

@@ -1,55 +1,72 @@
 import { normalizeActionBattleAttackProfile } from "./index4.js";
-//#region src/core/attack-runtime.ts
-var ACTION_BATTLE_HITBOX_FRAME_MS = 16;
-function getNormalizedActionBattleAttackProfile(options = {}) {
-	const attack = options.attack ?? {};
-	return normalizeActionBattleAttackProfile(attack.profile, {
-		lockMovement: attack.lockMovement,
-		lockDurationMs: attack.lockDurationMs,
-		hitboxes: attack.hitboxes
-	});
-}
-function resolveActionBattleHitboxSpeed(profile, hitboxCount) {
-	const positions = Math.max(1, Math.floor(hitboxCount));
-	const activeFrames = Math.max(1, Math.ceil(profile.activeMs / 16));
-	return Math.max(1, Math.ceil(activeFrames / positions));
-}
-function scheduleActionBattleStartup(profile, callback, scheduler = setTimeout) {
-	if (profile.startupMs <= 0) {
-		callback();
-		return null;
-	}
-	return scheduler(callback, profile.startupMs);
-}
-var attackIdCounter = 0;
-function createActionBattleAttackId(attackerId, profileId) {
-	attackIdCounter++;
-	return `${attackerId ?? "unknown"}:${profileId}:${Date.now()}:${attackIdCounter}`;
-}
-var getTargetKey = (target) => {
-	if (!target || target.id === void 0 || target.id === null) return null;
-	return String(target.id);
-};
-var ActionBattleHitTracker = class {
-	hitPolicy;
-	hitTargets = /* @__PURE__ */ new Set();
-	constructor(hitPolicy) {
-		this.hitPolicy = hitPolicy;
-	}
-	canHit(target) {
-		if (this.hitPolicy === "allowRepeatHits") return true;
-		const key = getTargetKey(target);
-		return !key || !this.hitTargets.has(key);
-	}
-	recordHit(target) {
-		const key = getTargetKey(target);
-		if (key) this.hitTargets.add(key);
-	}
-	tryHit(target) {
-		if (!this.canHit(target)) return false;
-		this.recordHit(target);
-		return true;
+//#region src/core/enemy-attack-profiles.ts
+var DEFAULT_ACTION_BATTLE_ENEMY_ATTACK_PROFILES = {
+	melee: {
+		id: "enemy-melee",
+		startupMs: 120,
+		activeMs: 100,
+		recoveryMs: 220,
+		cooldownMs: 440,
+		reaction: {
+			invincibilityMs: 250,
+			hitstunMs: 120,
+			staggerPower: 1
+		}
+	},
+	combo: {
+		id: "enemy-combo",
+		startupMs: 80,
+		activeMs: 80,
+		recoveryMs: 140,
+		cooldownMs: 300,
+		reaction: {
+			invincibilityMs: 180,
+			hitstunMs: 90,
+			staggerPower: .75
+		}
+	},
+	charged: {
+		id: "enemy-charged",
+		startupMs: 800,
+		activeMs: 140,
+		recoveryMs: 320,
+		cooldownMs: 1260,
+		reaction: {
+			invincibilityMs: 350,
+			hitstunMs: 220,
+			staggerPower: 2
+		}
+	},
+	zone: {
+		id: "enemy-zone",
+		startupMs: 450,
+		activeMs: 180,
+		recoveryMs: 320,
+		cooldownMs: 950,
+		reaction: {
+			invincibilityMs: 300,
+			hitstunMs: 160,
+			staggerPower: 1.25
+		}
+	},
+	dashAttack: {
+		id: "enemy-dash",
+		startupMs: 180,
+		activeMs: 120,
+		recoveryMs: 260,
+		cooldownMs: 560,
+		reaction: {
+			invincibilityMs: 280,
+			hitstunMs: 150,
+			staggerPower: 1.2
+		}
 	}
 };
+function normalizeActionBattleEnemyAttackProfiles(overrides = {}) {
+	return Object.fromEntries(Object.entries(DEFAULT_ACTION_BATTLE_ENEMY_ATTACK_PROFILES).map(([key, defaultProfile]) => [key, normalizeActionBattleAttackProfile({
+		...defaultProfile,
+		...overrides[key]
+	})]));
+}
 //#endregion
-export { ACTION_BATTLE_HITBOX_FRAME_MS, ActionBattleHitTracker, createActionBattleAttackId, getNormalizedActionBattleAttackProfile, resolveActionBattleHitboxSpeed, scheduleActionBattleStartup };
+export { DEFAULT_ACTION_BATTLE_ENEMY_ATTACK_PROFILES, normalizeActionBattleEnemyAttackProfiles };

package/dist/server/locomotion.d.ts

@@ -0,0 +1,16 @@
+type LocomotionEntity = {
+    animationFixed?: boolean;
+    setGraphicAnimation?: (...args: any[]) => unknown;
+    animationName?: {
+        set?: (animationName: string) => unknown;
+    };
+    resetAnimationState?: () => unknown;
+};
+export declare const withActionBattleAnimationUnlocked: <T>(entity: LocomotionEntity | undefined, callback: () => T) => T;
+/**
+ * Force a locomotion animation even when an action lock temporarily froze
+ * animation changes. This keeps server state and local rendering coherent
+ * after attack recovery interrupts movement.
+ */
+export declare const forceActionBattleLocomotionAnimation: (entity: LocomotionEntity | undefined, animationName: "stand" | "walk") => void;
+export {};

package/dist/server/movement.d.ts

@@ -0,0 +1,14 @@
+export type ActionBattleDashEntity = {
+    id?: string;
+    getCurrentMap?: () => any;
+    dash?: (direction: {
+        x: number;
+        y: number;
+    }, additionalSpeed?: number, duration?: number) => unknown;
+};
+export declare const isActionBattleMovementResolutionError: (error: unknown) => boolean;
+export declare const hasActionBattlePhysicsBody: (entity: ActionBattleDashEntity | null | undefined) => boolean;
+export declare const safeActionBattleDash: (entity: ActionBattleDashEntity | null | undefined, direction: {
+    x: number;
+    y: number;
+}, additionalSpeed?: number, duration?: number) => boolean;

package/dist/server/server.d.ts

@@ -91,16 +91,20 @@ export declare function getPlayerWeaponKnockbackForce(player: RpgPlayer): number
  * ```
  */
 export declare function applyPlayerHitToEvent(player: RpgPlayer, target: RpgEvent, hooks?: ApplyHitHooks, metadata?: Record<string, any>): HitResult | undefined;
+export declare function applyActionBattleEntityHit(attacker: RpgPlayer | RpgEvent, target: RpgPlayer | RpgEvent, hooks?: ApplyHitHooks, metadata?: Record<string, any>): HitResult | undefined;
 export declare const openActionBattleActionBar: (player: RpgPlayer, rawOptions?: ActionBattleOptions) => void;
 export declare const updateActionBattleActionBar: (player: RpgPlayer, rawOptions?: ActionBattleOptions) => void;
 export declare const createActionBattleServer: (rawOptions?: ActionBattleOptions) => RpgServer;
 declare const _default: RpgServer;
 export default _default;
-export { ACTION_BATTLE_HITBOX_FRAME_MS, ActionBattleHitTracker, createActionBattleAttackId, getNormalizedActionBattleAttackProfile, resolveActionBattleHitboxSpeed, scheduleActionBattleStartup, } from './core/attack-runtime';
+export { ACTION_BATTLE_HITBOX_FRAME_MS, ActionBattleHitTracker, createActionBattleAttackId, getNormalizedActionBattleAttackProfile, resolveActionBattleHitboxSpeed, runActionBattleActiveHitbox, 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 type { ActionBattleAttackDirection, ActionBattleAttackHitboxConfig, ActionBattleAttackHitboxMap, ActionBattleAttackHitPolicy, ActionBattleAttackProfile, 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, 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 { 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, AttackPattern, BattleAi, DEFAULT_KNOCKBACK, EnemyType, } from './ai.server';
 export type { ApplyHitHooks, BattleAiDefeatedCallback, BattleAiDefeatedContext, BattleAiDefeatReward, BattleAiLegacyDefeatedCallback, BattleAiLegacyOptions, BattleAiOptions, BattleAiRewardItem, BattleAiRewards, HitResult, } from './ai.server';

package/dist/server/ui.d.ts

@@ -0,0 +1,22 @@
+import { ActionBattleUiActionBarOptions, ActionBattleUiAttackPreviewOptions, ActionBattleUiOptions, ActionBattleUiTargetingOptions } from './types';
+export declare const ActionBattleUi: {
+    ActionBar: any;
+    TargetingOverlay: any;
+    AttackPreview: any;
+};
+export interface ResolvedActionBattleUi {
+    gui: Array<{
+        id: string;
+        component: any;
+        dependencies?: Function;
+    }>;
+    sprite: {
+        componentsInFront: any[];
+        componentsBehind: any[];
+    };
+    actionBar: ActionBattleUiActionBarOptions;
+    targeting: ActionBattleUiTargetingOptions;
+    attackPreview: ActionBattleUiAttackPreviewOptions;
+}
+export declare function createActionBattleUi(input?: "classic" | ActionBattleUiOptions): ActionBattleUiOptions;
+export declare function resolveActionBattleUi(options?: ActionBattleUiOptions): ResolvedActionBattleUi;

package/dist/server/visual.d.ts

@@ -0,0 +1,15 @@
+import { ActionBattleVisualComposer, ActionBattleVisualContext, ActionBattleVisualInput } from './types';
+export declare const ACTION_BATTLE_CLIENT_VISUAL_ID = "action-battle.visual";
+export declare const ACTION_BATTLE_HIT_FX_COMPONENT_ID = "action-battle-hit-fx";
+type PreviewStarter = (entity: any, options?: Record<string, any>) => void;
+export declare function setActionBattlePreviewStarter(starter?: PreviewStarter): void;
+export declare function emitActionBattleClientVisual(context: ActionBattleVisualContext): void;
+export declare function createActionBattleClientVisuals(options?: import('./types').ActionBattleOptions): {
+    "action-battle.visual": (context: any) => void;
+};
+export declare function createActionBattleVisual(input?: ActionBattleVisualInput): ActionBattleVisualComposer;
+export declare const createClassicActionBattleVisual: () => ActionBattleVisualComposer;
+export declare const createFxActionBattleVisual: () => ActionBattleVisualComposer;
+export declare function playActionBattleVisual(visual: ActionBattleVisualInput | ActionBattleVisualComposer | undefined, context: ActionBattleVisualContext): void;
+export declare function usesActionBattleFxVisual(visual: ActionBattleVisualInput | undefined): boolean;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpgjs/action-battle",
-  "version": "5.0.0-beta.11",
+  "version": "5.0.0-beta.12",
   "main": "dist/client/index.js",
   "types": "dist/client/index.d.ts",
   "exports": {
@@ -23,10 +23,10 @@
   "description": "RPGJS is a framework for creating RPG/MMORPG games",
   "peerDependencies": {
     "@canvasengine/presets": "^2.0.0-rc.4",
-    "@rpgjs/client": "5.0.0-beta.11",
-    "@rpgjs/common": "5.0.0-beta.11",
-    "@rpgjs/server": "5.0.0-beta.11",
-    "@rpgjs/vite": "5.0.0-beta.11",
+    "@rpgjs/client": "5.0.0-beta.12",
+    "@rpgjs/common": "5.0.0-beta.12",
+    "@rpgjs/server": "5.0.0-beta.12",
+    "@rpgjs/vite": "5.0.0-beta.12",
     "canvasengine": "^2.0.0-rc.4"
   },
   "publishConfig": {