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

package/dist/server/index15.js

@@ -1,10 +1,16 @@
-import { BattleAi } from "./index10.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);
-};
+//#region src/core/equipment.ts
+var resolveItemId = (item) => item?.id?.() ?? item?.id;
+function resolveActionBattleWeapon(entity) {
+	const equipments = entity?.equipments?.() || [];
+	for (const item of equipments) {
+		const itemId = resolveItemId(item);
+		const itemData = entity?.databaseById?.(itemId);
+		if (itemData?._type === "weapon") return itemData;
+	}
+	return null;
+}
+function resolveActionBattleWeaponAttackProfile(entity) {
+	return resolveActionBattleWeapon(entity)?.attackProfile ?? null;
+}
 //#endregion
-export { createActionEnemy };
+export { resolveActionBattleWeapon, resolveActionBattleWeaponAttackProfile };

package/dist/server/index16.js

@@ -0,0 +1,26 @@
+//#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);
+	});
+};
+//#endregion
+export { forceActionBattleLocomotionAnimation, withActionBattleAnimationUnlocked };

package/dist/server/index17.js

@@ -0,0 +1,25 @@
+//#region src/movement.ts
+var UNRESOLVED_ENTITY_MESSAGE = "unable to resolve entity";
+var isActionBattleMovementResolutionError = (error) => {
+	return (error instanceof Error ? error.message : String(error ?? "")).includes(UNRESOLVED_ENTITY_MESSAGE);
+};
+var hasActionBattlePhysicsBody = (entity) => {
+	if (!entity) return false;
+	const map = entity.getCurrentMap?.();
+	if (!map) return false;
+	if (typeof map.getBody !== "function" || !entity.id) return true;
+	return Boolean(map.getBody(entity.id));
+};
+var safeActionBattleDash = (entity, direction, additionalSpeed, duration) => {
+	if (!entity || typeof entity.dash !== "function") return false;
+	if (!hasActionBattlePhysicsBody(entity)) return false;
+	try {
+		entity.dash(direction, additionalSpeed, duration);
+		return true;
+	} catch (error) {
+		if (isActionBattleMovementResolutionError(error)) return false;
+		throw error;
+	}
+};
+//#endregion
+export { safeActionBattleDash };

package/dist/server/index18.js

@@ -0,0 +1,107 @@
+//#region src/core/ai-behavior-tree.ts
+var isTreeNode = (input) => Boolean(input && typeof input.tick === "function");
+var normalizeTreeResult = (result) => result ?? { status: "failure" };
+var runIntentInput = (input, context) => {
+	if (isTreeNode(input)) return input.tick(context);
+	return {
+		status: "success",
+		intent: typeof input === "function" ? input(context) : input
+	};
+};
+var defineAiTree = (input) => {
+	if (isTreeNode(input)) return input;
+	return { tick(context) {
+		return normalizeTreeResult(input(context));
+	} };
+};
+var selector = (children) => ({ tick(context) {
+	for (const child of children) {
+		const result = defineAiTree(child).tick(context);
+		if (result.status !== "failure") return result;
+	}
+	return { status: "failure" };
+} });
+var sequence = (children) => ({ tick(context) {
+	let last = { status: "success" };
+	for (const child of children) {
+		last = defineAiTree(child).tick(context);
+		if (last.status !== "success") return last;
+	}
+	return last;
+} });
+var condition = (predicate) => ({ tick(context) {
+	return { status: predicate(context) ? "success" : "failure" };
+} });
+var action = (input, status = "success") => ({ tick(context) {
+	return {
+		...runIntentInput(input, context),
+		status
+	};
+} });
+var decision = (resolve) => ({ tick(context) {
+	return {
+		status: "success",
+		decision: typeof resolve === "function" ? resolve(context) : resolve
+	};
+} });
+var rule = (predicate, then) => ({
+	condition: predicate,
+	then
+});
+var defineAiBehavior = (behavior) => {
+	const branches = [...(behavior.when ?? []).map((entry) => sequence([condition(entry.condition), action(entry.then)]))];
+	if (behavior.otherwise) branches.push(action(behavior.otherwise));
+	return selector(branches);
+};
+var hpBelow = (ratio) => {
+	return ({ self }) => self.hpPercent !== null && self.hpPercent < ratio;
+};
+var targetVisible = () => {
+	return ({ targetInfo }) => Boolean(targetInfo?.visible);
+};
+var targetInRange = (range) => {
+	return ({ self, targetInfo }) => {
+		if (!targetInfo) return false;
+		return targetInfo.distance <= (range ?? self.attackRange);
+	};
+};
+var distanceLessThan = (distance) => {
+	return ({ targetInfo }) => targetInfo !== null && targetInfo.distance < distance;
+};
+var inState = (state) => {
+	return ({ self }) => self.state === state;
+};
+var isEnemyType = (enemyType) => {
+	return ({ self }) => self.enemyType === enemyType;
+};
+var idle = () => ({ type: "idle" });
+var patrol = () => ({ type: "patrol" });
+var faceTarget = () => ({ type: "faceTarget" });
+var chase = () => ({ type: "moveToTarget" });
+var moveToTarget = chase;
+var flee = () => ({ type: "fleeFromTarget" });
+var fleeFromTarget = flee;
+var keepDistance = (distance, tolerance) => ({
+	type: "keepDistance",
+	distance,
+	tolerance
+});
+var useAttack = (pattern) => ({
+	type: "useAttack",
+	pattern
+});
+var useSkill = (skill) => ({
+	type: "useSkill",
+	skill
+});
+var setMode = (mode) => ({
+	type: "setMode",
+	mode,
+	consume: false
+});
+var ifHpBelow = (ratio, then) => rule(hpBelow(ratio), then);
+var ifTargetVisible = (then) => rule(targetVisible(), then);
+var ifTargetInRange = (then, range) => rule(targetInRange(range), then);
+var ifDistanceLessThan = (distance, then) => rule(distanceLessThan(distance), then);
+//#endregion
+export { action, chase, condition, decision, defineAiBehavior, defineAiTree, distanceLessThan, faceTarget, flee, fleeFromTarget, hpBelow, idle, ifDistanceLessThan, ifHpBelow, ifTargetInRange, ifTargetVisible, inState, isEnemyType, keepDistance, moveToTarget, patrol, rule, selector, sequence, setMode, targetInRange, targetVisible, useAttack, useSkill };