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

package/dist/client/index8.js

@@ -1,102 +1,26 @@
-import { actionBattleTargetingState, actionBattleUiOptions } from "./index5.js";
-import { parseAoeMask } from "./index7.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;
+//#region src/locomotion.ts
+var withActionBattleAnimationUnlocked = (entity, callback) => {
+	if (!entity) return callback();
+	const previousAnimationFixed = entity.animationFixed;
+	entity.animationFixed = false;
+	try {
+		return callback();
+	} finally {
+		entity.animationFixed = previousAnimationFixed;
+	}
+};
+/**
+* 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.
+*/
+var forceActionBattleLocomotionAnimation = (entity, animationName) => {
+	if (!entity) return;
+	withActionBattleAnimationUnlocked(entity, () => {
+		if (typeof entity.resetAnimationState === "function") entity.resetAnimationState();
+		if (typeof entity.setGraphicAnimation === "function") entity.setGraphicAnimation(animationName);
+		else if (typeof entity.animationName?.set === "function") entity.animationName.set(animationName);
 	});
-	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 })));
-}
-var __ce_component = component;
+};
 //#endregion
-export { __ce_component as default };
+export { forceActionBattleLocomotionAnimation, withActionBattleAnimationUnlocked };

package/dist/client/index9.js

@@ -1,78 +1,310 @@
-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
+import { actionBattleTargetingState, actionBattleUiOptions, moveTargetingOffset, startTargeting, stopTargeting } from "./index5.js";
+import { RpgClientEngine, getKeyboardControlBind, inject } from "@rpgjs/client";
+import { DOMContainer, DOMElement, DOMSprite, computed, cond, effect, h, loop, signal, useDefineProps, useProps } from "canvasengine";
+//#region src/components/action-bar.ce
+if (typeof document !== "undefined") {
+	let styleElement = document.getElementById("ce-style--home-runner-work-RPG-JS-RPG-JS-packages-action-battle-src-components-action-bar-ce");
+	if (!styleElement) {
+		styleElement = document.createElement("style");
+		styleElement.id = "ce-style--home-runner-work-RPG-JS-RPG-JS-packages-action-battle-src-components-action-bar-ce";
+		document.head.appendChild(styleElement);
+	}
+	styleElement.textContent = ".action-battle-actionbar-root {\n    pointer-events: none;\n  }\n\n  .action-battle-actionbar {\n    position: absolute;\n    left: 12px;\n    right: 12px;\n    bottom: 12px;\n    pointer-events: auto;\n    display: flex;\n    justify-content: center;\n  }\n\n  .action-battle-actionbar-plate {\n    width: min(760px, 100%);\n    --rpg-ui-hotbar-size: clamp(38px, 8vw, 52px);\n  }\n\n  .action-battle-actionbar-track {\n    --rpg-ui-hotbar-slots: 10;\n  }";
+}
 function component($$props) {
 	useProps($$props);
-	const { object } = useDefineProps($$props)();
+	const defineProps = useDefineProps($$props);
 	const engine = inject(RpgClientEngine);
-	const now = signal(Date.now());
-	tick(() => {
-		if (actionBattleAttackPreviewState().active) now.set(Date.now());
+	const keyboardControls = engine.globalConfig.keyboardControls;
+	const { data, onInteraction, onBack } = defineProps();
+	const ACTION_BAR_SIZE = 10;
+	const SLOT_LABELS = [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7",
+		"8",
+		"9",
+		"0"
+	];
+	const SLOT_CONFIG_KEYS = [
+		"hotbar1",
+		"hotbar2",
+		"hotbar3",
+		"hotbar4",
+		"hotbar5",
+		"hotbar6",
+		"hotbar7",
+		"hotbar8",
+		"hotbar9",
+		"hotbar0"
+	];
+	const selectedSlotIndex = signal(-1);
+	const uiOptions = computed(() => actionBattleUiOptions());
+	const showItems = computed(() => {
+		const mode = uiOptions().actionBar?.mode || "both";
+		return mode === "items" || mode === "both";
 	});
-	const isCurrentPlayer = computed(() => {
-		if (!object?.id) return false;
-		return (typeof object.id === "function" ? object.id() : object.id) === engine.playerId;
+	const showSkills = computed(() => {
+		const mode = uiOptions().actionBar?.mode || "both";
+		return mode === "skills" || mode === "both";
 	});
-	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 isTargeting = computed(() => actionBattleTargetingState().active);
+	const iconSheet = (iconId) => ({
+		definition: engine.getSpriteSheet(iconId),
+		playing: "default"
 	});
-	const shouldRender = computed(() => {
-		const state = preview();
-		return isCurrentPlayer() && state.active && progress() < 1;
+	const resolveProp = (value) => typeof value === "function" ? value() : value;
+	const actionBarData = computed(() => resolveProp(data) || {
+		items: [],
+		skills: []
 	});
-	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 actionBarSlots = computed(() => {
+		const entries = [];
+		if (showSkills()) (actionBarData().skills || []).forEach((skill, index) => {
+			entries.push({
+				type: "skill",
+				skill,
+				item: null,
+				sourceIndex: index
+			});
+		});
+		if (showItems()) (actionBarData().items || []).forEach((item, index) => {
+			entries.push({
+				type: "item",
+				skill: null,
+				item,
+				sourceIndex: index
+			});
 		});
+		const slots = entries.slice(0, ACTION_BAR_SIZE).map((entry, index) => ({
+			...entry,
+			label: SLOT_LABELS[index]
+		}));
+		while (slots.length < ACTION_BAR_SIZE) slots.push({
+			type: "empty",
+			skill: null,
+			item: null,
+			sourceIndex: -1,
+			label: SLOT_LABELS[slots.length]
+		});
+		return slots;
+	});
+	const hasSlotEntry = (slot) => slot.type === "skill" || slot.type === "item";
+	const isSlotDisabled = (slot) => {
+		if (!hasSlotEntry(slot)) return true;
+		const entry = slot.type === "skill" ? slot.skill : slot.item;
+		return !entry || !entry.usable;
 	};
-	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);
+	const getItemQuantity = (item) => {
+		if (!item) return 0;
+		if (typeof item.quantity === "function") return item.quantity();
+		return item.quantity || 0;
+	};
+	const selectItem = (item) => {
+		if (!item || !item.usable) return;
+		if (onInteraction) onInteraction("useItem", { id: item.id });
+	};
+	const selectSkill = (skill) => {
+		if (!skill || !skill.usable) return;
+		if ((skill.range ?? 0) > 0 || skill.aoeMask) {
+			startTargeting(skill);
 			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);
+		if (onInteraction) onInteraction("useSkill", { id: skill.id });
+	};
+	const selectSlot = (index) => {
+		const slot = actionBarSlots()[index];
+		if (!slot || !hasSlotEntry(slot)) return;
+		if (slot.type === "skill") {
+			selectSkill(slot.skill);
 			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);
+		selectItem(slot.item);
 	};
-	return h(Container, null, cond(shouldRender, () => h(Graphics, { draw: drawSlash })));
+	const onSelectSlot = (index) => () => {
+		selectedSlotIndex.set(index);
+		selectSlot(index);
+	};
+	const getPlayerTile = () => {
+		const player = engine.scene.getCurrentPlayer();
+		if (!player) return null;
+		const hitbox = player.hitbox?.() || {
+			w: 32,
+			h: 32
+		};
+		const tileWidth = hitbox.w || 32;
+		const tileHeight = hitbox.h || 32;
+		return {
+			x: Math.floor((player.x() + hitbox.w / 2) / tileWidth),
+			y: Math.floor((player.y() + hitbox.h / 2) / tileHeight)
+		};
+	};
+	const confirmTargeting = () => {
+		const state = actionBattleTargetingState();
+		if (!state.skill) return;
+		const origin = getPlayerTile();
+		if (!origin) return;
+		const target = {
+			x: origin.x + state.offset.x,
+			y: origin.y + state.offset.y
+		};
+		if (onInteraction) onInteraction("useSkill", {
+			id: state.skill.id,
+			target
+		});
+		stopTargeting();
+	};
+	const resolveKeyBind = (key) => {
+		if (!key) return null;
+		if (typeof key === "string" && keyboardControls?.[key]) return keyboardControls[key];
+		return key;
+	};
+	const slotBind = (index) => keyboardControls?.[SLOT_CONFIG_KEYS[index]] || SLOT_LABELS[index];
+	const buildControls = () => {
+		const hotbarControls = {};
+		actionBarSlots().forEach((slot, index) => {
+			if (!hasSlotEntry(slot)) return;
+			const bind = slotBind(index);
+			hotbarControls[`slot-${index}`] = {
+				bind,
+				keyDown() {
+					if (isTargeting()) return;
+					selectedSlotIndex.set(index);
+					selectSlot(index);
+				}
+			};
+			if (slot.type === "skill") {
+				const skillBind = resolveKeyBind(slot.skill?.key);
+				if (!skillBind || skillBind === bind) return;
+				hotbarControls[`skill-${index}`] = {
+					bind: skillBind,
+					keyDown() {
+						if (isTargeting()) return;
+						selectedSlotIndex.set(index);
+						selectSlot(index);
+					}
+				};
+			}
+		});
+		return {
+			left: {
+				repeat: true,
+				bind: keyboardControls.left,
+				throttle: 150,
+				keyDown() {
+					if (isTargeting()) moveTargetingOffset(-1, 0);
+				}
+			},
+			right: {
+				repeat: true,
+				bind: keyboardControls.right,
+				throttle: 150,
+				keyDown() {
+					if (isTargeting()) moveTargetingOffset(1, 0);
+				}
+			},
+			up: {
+				repeat: true,
+				bind: keyboardControls.up,
+				throttle: 150,
+				keyDown() {
+					if (isTargeting()) moveTargetingOffset(0, -1);
+				}
+			},
+			down: {
+				repeat: true,
+				bind: keyboardControls.down,
+				throttle: 150,
+				keyDown() {
+					if (isTargeting()) moveTargetingOffset(0, 1);
+				}
+			},
+			action: {
+				bind: getKeyboardControlBind(keyboardControls.action),
+				keyDown() {
+					if (isTargeting()) confirmTargeting();
+				}
+			},
+			escape: {
+				bind: keyboardControls.escape,
+				keyDown() {
+					if (isTargeting()) {
+						stopTargeting();
+						return;
+					}
+					if (onBack) onBack();
+				}
+			},
+			...hotbarControls,
+			gamepad: { enabled: true }
+		};
+	};
+	const controls = signal(buildControls());
+	effect(() => {
+		controls.set(buildControls());
+	});
+	return h(DOMContainer, {
+		width: "100%",
+		height: "100%",
+		attrs: { class: "action-battle-actionbar-root" },
+		controls
+	}, h(DOMElement, {
+		element: "div",
+		attrs: { class: "action-battle-actionbar" }
+	}, h(DOMElement, {
+		element: "div",
+		attrs: { class: "rpg-ui-hotbar action-battle-actionbar-plate" }
+	}, h(DOMElement, {
+		element: "div",
+		attrs: { class: "rpg-ui-hotbar-track action-battle-actionbar-track" }
+	}, loop(actionBarSlots, (slot, index) => h(DOMElement, {
+		element: "div",
+		attrs: {
+			class: "rpg-ui-hotbar-slot action-battle-actionbar-slot",
+			"data-selected": computed(() => selectedSlotIndex() === index ? "true" : "false"),
+			"data-disabled": computed(() => isSlotDisabled(slot) ? "true" : "false"),
+			"data-empty": computed(() => hasSlotEntry(slot) ? "false" : "true"),
+			"data-type": slot.type,
+			tabindex: computed(() => hasSlotEntry(slot) ? index : -1),
+			click: hasSlotEntry(slot) ? onSelectSlot(index) : void 0
+		}
+	}, [
+		h(DOMElement, {
+			element: "span",
+			attrs: { class: "rpg-ui-hotbar-key action-battle-actionbar-key" },
+			textContent: slot.label
+		}),
+		cond(computed(() => slot.type === "skill" && slot.skill?.icon), () => h(DOMSprite, {
+			sheet: computed(() => iconSheet(slot.skill.icon)),
+			width: "60px",
+			height: "60px",
+			scale: 2,
+			objectFit: "contain"
+		}), [computed(() => slot.type === "item" && slot.item?.icon), () => h(DOMSprite, {
+			sheet: computed(() => iconSheet(slot.item.icon)),
+			width: "60px",
+			height: "60px",
+			scale: 2,
+			objectFit: "contain"
+		})], [computed(() => slot.type === "skill" && slot.skill), () => h(DOMElement, {
+			element: "span",
+			attrs: { class: "rpg-ui-hotbar-text action-battle-actionbar-text" },
+			textContent: slot.skill.name
+		})], [computed(() => slot.type === "item" && slot.item), () => h(DOMElement, {
+			element: "span",
+			attrs: { class: "rpg-ui-hotbar-text action-battle-actionbar-text" },
+			textContent: slot.item.name
+		})]),
+		cond(computed(() => slot.type === "item" && slot.item), () => h(DOMElement, {
+			element: "span",
+			attrs: { class: "rpg-ui-hotbar-count action-battle-actionbar-count" },
+			textContent: "x" + getItemQuantity(slot.item)
+		}))
+	]))))));
 }
 var __ce_component = component;
 //#endregion

package/dist/client/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/client/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/client/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/client/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/client/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 {};