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

package/dist/client/index22.js

@@ -0,0 +1,225 @@
+import { getActionBattleOptions } from "./index4.js";
+import { emitActionBattleClientVisual } from "./index15.js";
+import { getActionBattleSystems } from "./index18.js";
+import { applyActionBattleHit } from "./index20.js";
+import { canActionBattleTarget, getActionBattleFaction, getActionBattleTargets, isActionBattleCombatEntity, isActionBattleTargetDefeated } from "./index21.js";
+//#region src/core/action-use.ts
+var MAXHP = null;
+var projectileHandlers = /* @__PURE__ */ new Map();
+var normalizeDirection = (direction) => {
+	const distance = Math.sqrt(direction.x * direction.x + direction.y * direction.y);
+	if (distance <= 0) return {
+		x: 0,
+		y: 1
+	};
+	return {
+		x: direction.x / distance,
+		y: direction.y / distance
+	};
+};
+var directionToTarget = (attacker, target) => {
+	const first = firstTarget(target);
+	if (!first) return void 0;
+	return normalizeDirection({
+		x: first.x() - attacker.x(),
+		y: first.y() - attacker.y()
+	});
+};
+var asArray = (value) => {
+	if (!value) return [];
+	return Array.isArray(value) ? value : [value];
+};
+var firstTarget = (target) => asArray(target)[0];
+var resolveActionConfig = (usable) => usable?.action ?? usable?.actionBattle ?? usable?._skillInstance?.action ?? usable?._skillInstance?.actionBattle ?? usable?._skillData?.action ?? usable?._skillData?.actionBattle;
+var getUseHookTarget = (usable) => usable?._skillInstance ?? usable?._skillData ?? usable;
+var getUseHook = (usable) => {
+	const target = getUseHookTarget(usable);
+	return typeof target?.onUse === "function" ? {
+		hook: target.onUse,
+		target
+	} : void 0;
+};
+var isSkill = (usable, explicitSkill) => !!explicitSkill || usable?._type === "skill" || usable?.spCost !== void 0;
+var consumeSkillUse = (attacker, skill) => {
+	const spCost = typeof skill?.spCost === "number" ? skill.spCost : 0;
+	if (spCost > 0) {
+		if (spCost > (attacker.sp ?? 0)) throw new Error(`Not enough SP to use ${skill?.id ?? skill?.name ?? "skill"}`);
+		const halfCost = attacker.hasEffect?.("HALF_SP_COST") || attacker.hasEffect?.("half_sp_cost");
+		attacker.sp -= spCost / (halfCost ? 2 : 1);
+	}
+	const hitRate = typeof skill?.hitRate === "number" ? skill.hitRate : 1;
+	if (Math.random() > hitRate) throw new Error(`Action battle skill failed: ${skill?.id ?? skill?.name ?? "skill"}`);
+};
+var applyDamageEffect = (attacker, target, skill, reaction, metadata) => {
+	const systems = getActionBattleSystems();
+	attacker.applyStates?.(target, skill);
+	const result = applyActionBattleHit(systems.combat, {
+		attacker,
+		target,
+		skill,
+		reaction,
+		metadata
+	});
+	if (!result.cancelled) {
+		emitActionBattleClientVisual({
+			moment: "hit",
+			entity: attacker,
+			target,
+			damage: result.damage,
+			result,
+			skill
+		});
+		target.battleAi?.handleDamage?.(attacker, {
+			damage: result.damage,
+			defeated: result.defeated,
+			raw: result.rawDamage,
+			reaction: result.reaction
+		});
+	}
+	return result;
+};
+var buildActionContext = (input) => {
+	const action = {};
+	Object.assign(action, {
+		attacker: input.attacker,
+		user: input.attacker,
+		target: input.target,
+		usable: input.usable,
+		skill: input.skill,
+		weapon: input.weapon,
+		action: input.action,
+		pattern: input.pattern,
+		defaultEffect(target = input.target) {
+			return asArray(target).map((entry) => applyDamageEffect(input.attacker, entry, input.skill, input.profile?.reaction, {
+				actionId: input.usable?.id,
+				actionType: input.usable?._type,
+				pattern: input.pattern
+			}));
+		},
+		damage(target = input.target) {
+			const entry = firstTarget(target);
+			if (!entry) return void 0;
+			return applyDamageEffect(input.attacker, entry, input.skill, input.profile?.reaction, {
+				actionId: input.usable?.id,
+				actionType: input.usable?._type,
+				pattern: input.pattern
+			});
+		},
+		heal(target, amount) {
+			if (!target || !Number.isFinite(amount) || amount <= 0) return 0;
+			return asArray(target).reduce((total, entry) => {
+				const currentHp = Number(entry.hp ?? 0);
+				const maxHp = (typeof entry.param === "function" ? entry.param() : entry.param)?.[MAXHP] ?? Number.POSITIVE_INFINITY;
+				const nextHp = Math.min(maxHp, currentHp + amount);
+				entry.hp = nextHp;
+				emitActionBattleClientVisual({
+					moment: "hurt",
+					entity: entry,
+					target: entry,
+					damage: Math.max(0, nextHp - currentHp),
+					skill: input.skill
+				});
+				return total + nextHp - currentHp;
+			}, 0);
+		},
+		projectile(options = { type: "action" }) {
+			const map = input.attacker.getCurrentMap?.();
+			if (!map?.projectiles?.emit) return [];
+			const projectile = {
+				...input.action?.projectile ?? {},
+				...options
+			};
+			const range = projectile.range ?? input.action?.range ?? 160;
+			const speed = projectile.speed ?? 180;
+			const emitted = map.projectiles.emit({
+				type: projectile.type,
+				origin: projectile.origin,
+				direction: projectile.direction ?? directionToTarget(input.attacker, input.target),
+				spreadDegrees: projectile.spreadDegrees,
+				accuracy: projectile.accuracy,
+				trajectory: projectile.trajectory ?? {
+					type: "linear",
+					speed,
+					range
+				},
+				collision: projectile.collision,
+				repeat: projectile.repeat,
+				pattern: projectile.pattern,
+				payload: {
+					...projectile.payload,
+					actionBattle: true,
+					attackerId: input.attacker.id,
+					actionId: input.usable?.id
+				},
+				params: projectile.params,
+				canHit: ({ target }) => {
+					if (!target) return false;
+					return canActionBattleUseTarget(input.attacker, target, input.action?.target ?? "enemy", getActionBattleOptions().combat?.targets);
+				}
+			}, input.attacker);
+			for (const state of emitted) projectileHandlers.set(state.id, {
+				action,
+				onImpact: projectile.onImpact
+			});
+			return emitted;
+		}
+	});
+	return action;
+};
+var getActionBattleActionConfig = (usable) => resolveActionConfig(usable);
+var getActionBattleActionRange = (usable) => resolveActionConfig(usable)?.range;
+var canActionBattleUseTarget = (attacker, target, actionTarget = "enemy", options = {}) => {
+	if (isActionBattleTargetDefeated(target)) return false;
+	if (actionTarget === "self") return attacker === target;
+	if (actionTarget === "any") return attacker === target || isActionBattleCombatEntity(target);
+	if (attacker === target || !isActionBattleCombatEntity(target)) return false;
+	if (actionTarget === "ally") {
+		const attackerFaction = getActionBattleFaction(attacker, options);
+		const targetFaction = getActionBattleFaction(target, options);
+		return !!attackerFaction && attackerFaction === targetFaction;
+	}
+	return canActionBattleTarget(attacker, target, getActionBattleTargets(attacker, "hostile"), options);
+};
+var shouldUseActionBattleUsable = (usable, explicitSkill) => {
+	if (!usable) return false;
+	return isSkill(usable, explicitSkill) || !!getUseHook(usable) || !!resolveActionConfig(usable);
+};
+var executeActionBattleUse = (input) => {
+	if (!shouldUseActionBattleUsable(input.usable, input.skill)) return false;
+	const actionConfig = resolveActionConfig(input.usable);
+	if (isSkill(input.usable, input.skill)) consumeSkillUse(input.attacker, input.skill ?? input.usable);
+	const action = buildActionContext({
+		...input,
+		action: actionConfig
+	});
+	const hook = getUseHook(input.usable);
+	if (input.playVisual !== false) emitActionBattleClientVisual({
+		moment: input.skill ? "castSkill" : "attack",
+		entity: input.attacker,
+		skill: input.skill,
+		target: firstTarget(input.target)
+	});
+	if (hook) {
+		hook.hook.call(hook.target, input.attacker, input.target, action);
+		return true;
+	}
+	if (actionConfig?.mode === "projectile") {
+		action.projectile(actionConfig.projectile);
+		return true;
+	}
+	action.defaultEffect(input.target);
+	return true;
+};
+var handleActionBattleProjectileImpact = (context) => {
+	const handler = projectileHandlers.get(context.projectile.id);
+	if (!handler) return;
+	const target = context.target;
+	handler.action.target = target ?? handler.action.target;
+	if (handler.onImpact) handler.onImpact(context, handler.action);
+	else handler.action.defaultEffect(target ?? void 0);
+};
+var handleActionBattleProjectileDestroy = (projectileId) => {
+	projectileHandlers.delete(projectileId);
+};
+//#endregion
+export { canActionBattleUseTarget, executeActionBattleUse, getActionBattleActionConfig, getActionBattleActionRange, handleActionBattleProjectileDestroy, handleActionBattleProjectileImpact, shouldUseActionBattleUsable };

package/dist/client/index23.js

@@ -0,0 +1,16 @@
+//#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 { resolveActionBattleWeapon, resolveActionBattleWeaponAttackProfile };

package/dist/client/index24.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/client/index25.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 };