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

package/dist/client/index11.js

@@ -1,55 +1,102 @@
-import { normalizeActionBattleAttackProfile } from "./index3.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
+import { actionBattleTargetingState, actionBattleUiOptions } from "./index5.js";
+import { parseAoeMask } from "./index10.js";
+import { RpgClientEngine, inject } from "@rpgjs/client";
+import { Container, Graphics, computed, cond, h, useDefineProps, useProps } from "canvasengine";
+//#region src/components/targeting-overlay.ce
+function component($$props) {
+	useProps($$props);
+	const { object } = useDefineProps($$props)();
+	const engine = inject(RpgClientEngine);
+	const isCurrentPlayer = computed(() => {
+		if (!object?.id) return false;
+		return (typeof object.id === "function" ? object.id() : object.id) === engine.playerId;
 	});
+	const uiOptions = computed(() => actionBattleUiOptions());
+	const targetingState = computed(() => actionBattleTargetingState());
+	const shouldRender = computed(() => {
+		if (!isCurrentPlayer()) return false;
+		if (!uiOptions().targeting?.enabled) return false;
+		return targetingState().active;
+	});
+	const getTileSize = () => {
+		const uiTile = uiOptions().targeting?.tileSize;
+		if (uiTile?.width && uiTile?.height) return uiTile;
+		const hitbox = object.hitbox?.() || {
+			w: 32,
+			h: 32
+		};
+		return {
+			width: hitbox.w || 32,
+			height: hitbox.h || 32
+		};
+	};
+	const getOriginTile = () => {
+		const hitbox = object.hitbox?.() || {
+			w: 32,
+			h: 32
+		};
+		const tileSize = getTileSize();
+		return {
+			x: Math.floor((object.x() + hitbox.w / 2) / tileSize.width),
+			y: Math.floor((object.y() + hitbox.h / 2) / tileSize.height)
+		};
+	};
+	const toColor = (value, fallback) => {
+		if (typeof value === "number") return value;
+		return fallback;
+	};
+	const drawGrid = (g) => {
+		const state = targetingState();
+		if (!state.active) return;
+		const tileSize = getTileSize();
+		const origin = getOriginTile();
+		const target = {
+			x: origin.x + state.offset.x,
+			y: origin.y + state.offset.y
+		};
+		const mask = parseAoeMask(state.aoeMask);
+		const colors = uiOptions().targeting?.colors || {};
+		const areaColor = toColor(colors.area, 3120887);
+		const edgeColor = toColor(colors.edge, 1796760);
+		const cursorColor = toColor(colors.cursor, 16765286);
+		const showGrid = uiOptions().targeting?.showGrid !== false;
+		const playerX = object.x();
+		const playerY = object.y();
+		g.clear();
+		mask.cells.forEach((cell) => {
+			const tileX = target.x + cell.dx;
+			const tileY = target.y + cell.dy;
+			const worldX = tileX * tileSize.width;
+			const worldY = tileY * tileSize.height;
+			const relX = worldX - playerX;
+			const relY = worldY - playerY;
+			g.rect(relX, relY, tileSize.width, tileSize.height);
+			g.fill({
+				color: areaColor,
+				alpha: .35
+			});
+			if (showGrid) {
+				g.rect(relX, relY, tileSize.width, tileSize.height);
+				g.stroke({
+					color: edgeColor,
+					alpha: .9,
+					width: 1
+				});
+			}
+		});
+		const cursorWorldX = target.x * tileSize.width;
+		const cursorWorldY = target.y * tileSize.height;
+		const cursorRelX = cursorWorldX - playerX;
+		const cursorRelY = cursorWorldY - playerY;
+		g.rect(cursorRelX, cursorRelY, tileSize.width, tileSize.height);
+		g.stroke({
+			color: cursorColor,
+			alpha: 1,
+			width: 2
+		});
+	};
+	return h(Container, null, cond(shouldRender, () => h(Graphics, { draw: drawGrid })));
 }
-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;
-	}
-};
+var __ce_component = component;
 //#endregion
-export { ACTION_BATTLE_HITBOX_FRAME_MS, ActionBattleHitTracker, createActionBattleAttackId, getNormalizedActionBattleAttackProfile, resolveActionBattleHitboxSpeed, scheduleActionBattleStartup };
+export { __ce_component as default };

package/dist/client/index12.js

@@ -1,106 +1,79 @@
-import { normalizeActionBattleOptions } from "./index4.js";
-import { setActionBattleOptions, startAttackPreview, stopAttackPreview } from "./index5.js";
-import __ce_component from "./index6.js";
-import __ce_component$1 from "./index8.js";
-import __ce_component$2 from "./index9.js";
-import { resolveActionBattleAnimation } from "./index10.js";
-import { getNormalizedActionBattleAttackProfile } from "./index11.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, locks) => {
-	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 = player.canMove;
-	const previousDirectionFixed = player.directionFixed;
-	const previousAnimationFixed = player.animationFixed;
-	if (locks.movement) {
-		if (typeof engine.interruptCurrentPlayerMovement === "function") engine.interruptCurrentPlayerMovement(player);
-		else engine.scene?.stopMovement?.(player);
-		player.canMove = false;
-	}
-	if (locks.direction) player.directionFixed = true;
-	player.animationFixed = true;
-	setTimeout(() => {
-		if (runtimePlayer.__actionBattleAttackLockId !== lockId) return;
-		runtimePlayer.__actionBattleAttackLockedUntil = 0;
-		player.canMove = previousCanMove;
-		player.directionFixed = previousDirectionFixed;
-		player.animationFixed = previousAnimationFixed;
-	}, durationMs);
-	return true;
-};
-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
+import { actionBattleAttackPreviewState } from "./index5.js";
+import { RpgClientEngine, inject } from "@rpgjs/client";
+import { Container, Graphics, computed, cond, h, signal, tick, useDefineProps, useProps } from "canvasengine";
+//#region src/components/attack-preview.ce
+function component($$props) {
+	useProps($$props);
+	const { object } = useDefineProps($$props)();
+	const engine = inject(RpgClientEngine);
+	const now = signal(Date.now());
+	tick(() => {
+		if (actionBattleAttackPreviewState().active) now.set(Date.now());
 	});
-	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 ? [__ce_component$1] : [], __ce_component$2];
-	const hitComponent = PrebuiltComponentAnimations?.Hit;
-	return defineModule({
-		componentAnimations: hitComponent ? [{
-			id: "hit",
-			component: hitComponent
-		}] : [],
-		gui: actionBarEnabled ? [{
-			id: "action-battle-action-bar",
-			component: __ce_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 attackProfile = getNormalizedActionBattleAttackProfile(normalized);
-			const lockDurationMs = Math.max(0, attackProfile.totalDurationMs ?? DEFAULT_ATTACK_LOCK_DURATION_MS);
-			if (attackProfile.movementLock || attackProfile.directionLock) beginLocalPlayerAttackLock(engine, lockDurationMs, {
-				movement: attackProfile.movementLock,
-				direction: attackProfile.directionLock
-			});
-			playLocalPlayerAttackAnimation(player, normalized);
-			showLocalAttackPreview(player, normalized);
-		} }
+	const isCurrentPlayer = computed(() => {
+		if (!object?.id) return false;
+		return (typeof object.id === "function" ? object.id() : object.id) === engine.playerId;
 	});
-};
-var client_default = createActionBattleClient();
+	const preview = computed(() => actionBattleAttackPreviewState());
+	const progress = computed(() => {
+		const state = preview();
+		if (!state.active) return 1;
+		const elapsed = now() - state.startedAt;
+		return Math.max(0, Math.min(1, elapsed / state.durationMs));
+	});
+	const shouldRender = computed(() => {
+		const state = preview();
+		return isCurrentPlayer() && state.active && progress() < 1;
+	});
+	const getHitbox = () => object.hitbox?.() || {
+		w: 32,
+		h: 32
+	};
+	const drawRect = (g, x, y, width, height, color, alpha) => {
+		g.rect(x, y, width, height);
+		g.fill({
+			color,
+			alpha
+		});
+	};
+	const drawSlash = (g) => {
+		g.clear();
+		if (!shouldRender()) return;
+		const state = preview();
+		const p = progress();
+		const alpha = Math.sin(Math.PI * p);
+		if (alpha <= 0) return;
+		const hitbox = getHitbox();
+		const width = hitbox.w || 32;
+		const height = hitbox.h || 32;
+		const reach = 16 + 18 * p;
+		const thickness = 4 + 3 * (1 - p);
+		const color = state.color;
+		const accent = state.accentColor;
+		if (state.direction === "left") {
+			drawRect(g, -reach - 6, height * .24, reach, thickness, accent, alpha * .55);
+			drawRect(g, -reach - 10, height * .46, reach + 4, thickness + 2, color, alpha);
+			drawRect(g, -reach - 6, height * .7, reach, thickness, accent, alpha * .4);
+			return;
+		}
+		if (state.direction === "right") {
+			drawRect(g, width + 6, height * .24, reach, thickness, accent, alpha * .55);
+			drawRect(g, width + 6, height * .46, reach + 4, thickness + 2, color, alpha);
+			drawRect(g, width + 6, height * .7, reach, thickness, accent, alpha * .4);
+			return;
+		}
+		if (state.direction === "up") {
+			drawRect(g, width * .24, -reach - 6, thickness, reach, accent, alpha * .55);
+			drawRect(g, width * .46, -reach - 10, thickness + 2, reach + 4, color, alpha);
+			drawRect(g, width * .7, -reach - 6, thickness, reach, accent, alpha * .4);
+			return;
+		}
+		drawRect(g, width * .24, height + 6, thickness, reach, accent, alpha * .55);
+		drawRect(g, width * .46, height + 6, thickness + 2, reach + 4, color, alpha);
+		drawRect(g, width * .7, height + 6, thickness, reach, accent, alpha * .4);
+	};
+	return h(Container, null, cond(shouldRender, () => h(Graphics, { draw: drawSlash })));
+}
+var __ce_component = component;
 //#endregion
-export { createActionBattleClient, client_default as default };
+export { __ce_component as default };

package/dist/client/index13.js

@@ -1,143 +1,80 @@
-//#region src/core/defaults.ts
-var DEFAULT_CORE_KNOCKBACK = {
-	force: 50,
-	duration: 300
+import __ce_component from "./index9.js";
+import __ce_component$1 from "./index11.js";
+import __ce_component$2 from "./index12.js";
+import { RpgClientEngine, inject } from "@rpgjs/client";
+//#region src/ui.ts
+var ActionBattleUi = {
+	ActionBar: __ce_component,
+	TargetingOverlay: __ce_component$1,
+	AttackPreview: __ce_component$2
 };
-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 normalizeToggle = (value, defaults) => {
+	if (value === false) return {
+		...defaults,
+		enabled: false
 	};
-};
-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);
+	if (value === true) return {
+		...defaults,
+		enabled: true
+	};
+	if (value === void 0) return { ...defaults };
 	return {
-		damage: raw?.damage ?? 0,
-		defeated: target.hp <= 0,
-		raw
+		...defaults,
+		...value,
+		enabled: value.enabled ?? defaults.enabled
 	};
 };
-var defaultKnockbackResolver = (context) => {
-	const weapon = context.weapon ?? resolveEquippedWeapon(context.attacker);
+function createActionBattleUi(input = "classic") {
+	if (input === "classic") return {};
+	return input;
+}
+function resolveActionBattleUi(options = {}) {
+	const actionBar = normalizeToggle(options.actionBar, {
+		enabled: false,
+		autoOpen: false,
+		mode: "both",
+		component: ActionBattleUi.ActionBar
+	});
+	const targeting = normalizeToggle(options.targeting, {
+		enabled: true,
+		showGrid: true,
+		component: ActionBattleUi.TargetingOverlay,
+		colors: {
+			area: 3120887,
+			edge: 1796760,
+			cursor: 16765286
+		}
+	});
+	const attackPreview = normalizeToggle(options.attackPreview, {
+		enabled: true,
+		component: ActionBattleUi.AttackPreview
+	});
+	const gui = [...options.gui ?? []];
+	if (actionBar.enabled && actionBar.component) gui.unshift({
+		id: "action-battle-action-bar",
+		component: actionBar.component,
+		dependencies: () => {
+			return [inject(RpgClientEngine).scene.currentPlayer];
+		}
+	});
+	const configuredSpriteComponents = Array.isArray(options.spriteComponents) ? {
+		front: options.spriteComponents,
+		back: []
+	} : options.spriteComponents ?? {};
 	return {
-		force: weapon?.knockbackForce ?? DEFAULT_CORE_KNOCKBACK.force,
-		duration: weapon?.knockbackDuration ?? DEFAULT_CORE_KNOCKBACK.duration,
-		direction: resolveDirection(context.attacker, context.target)
+		gui,
+		sprite: {
+			componentsInFront: [
+				...targeting.enabled && targeting.component ? [targeting.component] : [],
+				...attackPreview.enabled && attackPreview.component ? [attackPreview.component] : [],
+				...configuredSpriteComponents.front ?? []
+			],
+			componentsBehind: configuredSpriteComponents.back ?? []
+		},
+		actionBar,
+		targeting,
+		attackPreview
 	};
-};
-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 defaultActionBattleSystems = {
-	combat: defaultCombatSystem,
-	ai: { behaviors: defaultEnemyBehaviors }
-};
+}
 //#endregion
-export { DEFAULT_ZELDA_PLAYER_HITBOXES, createDefaultPlayerHitboxResolver, defaultActionBattleSystems, defaultCombatSystem, defaultEnemyBehaviors, defaultKnockbackResolver, defaultRpgjsDamageResolver };
+export { ActionBattleUi, createActionBattleUi, resolveActionBattleUi };

package/dist/client/index14.js

@@ -1,25 +1,69 @@
-import { defaultActionBattleSystems } from "./index13.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 playResolvedAnimation = (entity, animation) => {
+	if (typeof entity.setGraphicAnimation === "function") {
+		if (animation.graphic !== void 0) entity.setGraphicAnimation(animation.animationName, animation.graphic, animation.repeat);
+		else entity.setGraphicAnimation(animation.animationName, animation.repeat);
+		return;
+	}
+	if (typeof entity.setAnimation === "function") if (animation.graphic !== void 0) entity.setAnimation(animation.animationName, animation.graphic, animation.repeat);
+	else entity.setAnimation(animation.animationName, animation.repeat);
 };
-var getActionBattleSystems = () => currentActionBattleSystems;
-var createActionBattleSystems = mergeSystems;
+var DEFAULT_ANIMATION_BY_KEY = {
+	attack: "attack",
+	hurt: "hurt",
+	die: "die",
+	castSkill: "skill",
+	castSpell: "skill"
+};
+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 playActionBattleAnimation(key, entity, animations, context, defaults = {}) {
+	const animation = resolveActionBattleAnimation(key, entity, animations, context, defaults);
+	if (!animation) return null;
+	playResolvedAnimation(entity, animation);
+	return animation;
+}
+function getActionBattleAnimationRemovalDelay(animation) {
+	if (!animation) return 0;
+	if (animation.delayMs !== void 0) return animation.delayMs;
+	return animation.waitEnd ? 500 : 0;
+}
 //#endregion
-export { createActionBattleSystems, getActionBattleSystems, setActionBattleSystems };
+export { getActionBattleAnimationRemovalDelay, playActionBattleAnimation, resolveActionBattleAnimation };