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

package/dist/server/index11.js

@@ -1,37 +1,37 @@
-//#region src/targeting.ts
-var normalizeMaskRows = (mask) => {
-	if (!mask) return ["#"];
-	if (Array.isArray(mask)) return mask;
-	return mask.trim().split("\n").map((row) => row.replace(/\r/g, ""));
+//#region src/attack-input.ts
+var ACTION_BATTLE_DIRECTIONS = new Set([
+	"up",
+	"down",
+	"left",
+	"right"
+]);
+var normalizeDirection = (value) => {
+	if (typeof value !== "string") return void 0;
+	return ACTION_BATTLE_DIRECTIONS.has(value) ? value : void 0;
 };
-var parseAoeMask = (mask) => {
-	const rows = normalizeMaskRows(mask);
-	const height = rows.length;
-	const width = rows.reduce((max, row) => Math.max(max, row.length), 0);
-	const centerX = Math.floor(width / 2);
-	const centerY = Math.floor(height / 2);
-	const cells = [];
-	rows.forEach((row, y) => {
-		for (let x = 0; x < row.length; x++) {
-			const char = row[x];
-			if (char && char !== "." && char !== " ") cells.push({
-				dx: x - centerX,
-				dy: y - centerY
-			});
+var resolveActionBattleAttackDirection = (entity, input) => {
+	const payloadDirection = normalizeDirection(input?.data?.direction) ?? normalizeDirection(input?.data?.attackDirection) ?? normalizeDirection(input?.direction);
+	if (payloadDirection) return payloadDirection;
+	if (typeof entity?.getDirection === "function") {
+		const direction = normalizeDirection(entity.getDirection());
+		if (direction) return direction;
+	}
+	if (typeof entity?.direction === "function") {
+		const direction = normalizeDirection(entity.direction());
+		if (direction) return direction;
+	}
+	return normalizeDirection(entity?.direction) ?? "down";
+};
+var applyActionBattleAttackDirection = (entity, direction) => {
+	if (typeof entity?.changeDirection === "function") {
+		const previousDirectionFixed = entity.directionFixed;
+		if (previousDirectionFixed === true) entity.directionFixed = false;
+		try {
+			entity.changeDirection(direction);
+		} finally {
+			if (previousDirectionFixed === true) entity.directionFixed = previousDirectionFixed;
 		}
-	});
-	if (cells.length === 0) cells.push({
-		dx: 0,
-		dy: 0
-	});
-	return {
-		width,
-		height,
-		centerX,
-		centerY,
-		cells
-	};
+	}
 };
-var manhattanDistance = (a, b) => Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
 //#endregion
-export { manhattanDistance, parseAoeMask };
+export { applyActionBattleAttackDirection, resolveActionBattleAttackDirection };

package/dist/server/index13.js

@@ -1,13 +1,68 @@
-//#region src/core/equipment.ts
-var resolveItemId = (item) => item?.id?.() ?? item?.id;
-function resolveActionBattleWeaponAttackProfile(entity) {
-	const equipments = entity?.equipments?.() || [];
-	for (const item of equipments) {
-		const itemId = resolveItemId(item);
-		const itemData = entity?.databaseById?.(itemId);
-		if (itemData?._type === "weapon" && itemData.attackProfile) return itemData.attackProfile;
+import { RpgEvent, RpgPlayer } from "@rpgjs/server";
+//#region src/core/targets.ts
+var ACTION_BATTLE_PLAYER_FACTION = "players";
+var ACTION_BATTLE_ENEMY_FACTION = "enemies";
+var getBattleAi = (entity) => entity?.battleAi;
+var getActionBattleEntityKind = (entity) => {
+	if (getBattleAi(entity)) return "event";
+	if (entity instanceof RpgEvent) return "event";
+	if (typeof entity?.attachShape === "function") return "event";
+	if (entity instanceof RpgPlayer) return "player";
+	return "player";
+};
+var isActionBattlePlayer = (entity) => getActionBattleEntityKind(entity) === "player";
+var isActionBattleEvent = (entity) => getActionBattleEntityKind(entity) === "event";
+var isActionBattleCombatEntity = (entity) => {
+	if (!entity) return false;
+	if (isActionBattlePlayer(entity)) return true;
+	return !!getBattleAi(entity);
+};
+var getActionBattleFaction = (entity, options = {}) => {
+	const configured = options.getFaction?.(entity);
+	if (configured !== void 0) return configured;
+	const battleAi = getBattleAi(entity);
+	if (battleAi && typeof battleAi.getFaction === "function") {
+		const faction = battleAi.getFaction();
+		if (faction !== void 0) return faction;
 	}
-	return null;
-}
+	const entityFaction = entity.actionBattleFaction ?? entity.faction;
+	if (entityFaction !== void 0) return String(entityFaction);
+	if (isActionBattlePlayer(entity)) return ACTION_BATTLE_PLAYER_FACTION;
+	if (battleAi) return ACTION_BATTLE_ENEMY_FACTION;
+};
+var getActionBattleTargets = (entity, fallback) => {
+	const battleAi = getBattleAi(entity);
+	if (battleAi && typeof battleAi.getTargets === "function") return battleAi.getTargets();
+	return entity.actionBattleTargets ?? fallback;
+};
+var isActionBattleTargetDefeated = (target) => {
+	if (!target) return true;
+	const hp = target.hp;
+	return typeof hp === "number" && hp <= 0;
+};
+var matchesActionBattleTargetSelector = (selector, context) => {
+	if (!selector) return false;
+	if (typeof selector === "function") return selector(context);
+	if (selector === "all") return true;
+	if (selector === "players") return isActionBattlePlayer(context.target);
+	if (selector === "events") return isActionBattleEvent(context.target);
+	if (selector === "hostile") return !!context.attackerFaction && !!context.targetFaction && context.attackerFaction !== context.targetFaction;
+	if (Array.isArray(selector)) return !!context.targetFaction && selector.includes(context.targetFaction);
+	return false;
+};
+var canActionBattleTarget = (attacker, target, selector, options = {}) => {
+	if (attacker === target) return false;
+	if (!isActionBattleCombatEntity(target)) return false;
+	if (isActionBattleTargetDefeated(target)) return false;
+	const context = {
+		attacker,
+		target,
+		attackerFaction: getActionBattleFaction(attacker, options),
+		targetFaction: getActionBattleFaction(target, options)
+	};
+	const allowed = options.canTarget?.(context);
+	if (allowed !== void 0) return allowed;
+	return matchesActionBattleTargetSelector(selector, context);
+};
 //#endregion
-export { resolveActionBattleWeaponAttackProfile };
+export { ACTION_BATTLE_ENEMY_FACTION, ACTION_BATTLE_PLAYER_FACTION, canActionBattleTarget, getActionBattleFaction, getActionBattleTargets, isActionBattleCombatEntity, isActionBattleEvent, isActionBattlePlayer, isActionBattleTargetDefeated, matchesActionBattleTargetSelector };