@rpgjs/action-battle 5.0.0-alpha.44 → 5.0.0-beta.10

package/dist/server/index4.js

@@ -1,55 +1,47 @@
-const DEFAULT_ACTION_BATTLE_OPTIONS = {
-  ui: {
-    actionBar: {
-      enabled: false,
-      autoOpen: false,
-      mode: "both"
-    },
-    targeting: {
-      enabled: true,
-      showGrid: true,
-      colors: {
-        area: 3120887,
-        edge: 1796760,
-        cursor: 16765286
-      }
-    }
-  },
-  skills: {
-    defaultAoeMask: ["#"]
-  },
-  targeting: {
-    affects: "events",
-    allowEmptyTarget: true
-  }
+import { DEFAULT_ACTION_BATTLE_HIT_REACTION, normalizeActionBattleHitReaction } from "./index3.js";
+//#region src/core/attack-profile.ts
+var DEFAULT_ACTION_BATTLE_ATTACK_PROFILE = {
+	id: "basic",
+	startupMs: 0,
+	activeMs: 120,
+	recoveryMs: 230,
+	cooldownMs: 350,
+	movementLock: true,
+	directionLock: true,
+	animationKey: "attack",
+	hitPolicy: "oncePerTarget",
+	reaction: DEFAULT_ACTION_BATTLE_HIT_REACTION,
+	totalDurationMs: 350
 };
-function normalizeActionBattleOptions(options = {}) {
-  return {
-    ui: {
-      actionBar: {
-        ...DEFAULT_ACTION_BATTLE_OPTIONS.ui?.actionBar,
-        ...options.ui?.actionBar
-      },
-      targeting: {
-        ...DEFAULT_ACTION_BATTLE_OPTIONS.ui?.targeting,
-        ...options.ui?.targeting,
-        colors: {
-          ...DEFAULT_ACTION_BATTLE_OPTIONS.ui?.targeting?.colors,
-          ...options.ui?.targeting?.colors
-        }
-      }
-    },
-    skills: {
-      ...DEFAULT_ACTION_BATTLE_OPTIONS.skills,
-      ...options.skills
-    },
-    targeting: {
-      ...DEFAULT_ACTION_BATTLE_OPTIONS.targeting,
-      ...options.targeting
-    }
-  };
+var isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
+var nonNegativeMs = (value, fallback) => isFiniteNumber(value) ? Math.max(0, value) : fallback;
+var positiveMs = (value, fallback) => isFiniteNumber(value) ? Math.max(1, value) : fallback;
+var resolveHitPolicy = (value) => value === "allowRepeatHits" ? "allowRepeatHits" : "oncePerTarget";
+var resolveAnimationKey = (value) => value ?? DEFAULT_ACTION_BATTLE_ATTACK_PROFILE.animationKey;
+function normalizeActionBattleAttackProfile(profile = {}, fallbacks = {}) {
+	const startupMs = nonNegativeMs(profile.startupMs, DEFAULT_ACTION_BATTLE_ATTACK_PROFILE.startupMs);
+	const activeMs = positiveMs(profile.activeMs, DEFAULT_ACTION_BATTLE_ATTACK_PROFILE.activeMs);
+	const legacyDuration = nonNegativeMs(fallbacks.lockDurationMs, DEFAULT_ACTION_BATTLE_ATTACK_PROFILE.totalDurationMs);
+	const fallbackRecoveryMs = Math.max(0, legacyDuration - startupMs - activeMs);
+	const recoveryMs = nonNegativeMs(profile.recoveryMs, fallbackRecoveryMs);
+	const totalDurationMs = startupMs + activeMs + recoveryMs;
+	const cooldownMs = nonNegativeMs(profile.cooldownMs, totalDurationMs);
+	const hitboxes = profile.hitboxes ?? fallbacks.hitboxes;
+	const normalized = {
+		id: profile.id || fallbacks.id || DEFAULT_ACTION_BATTLE_ATTACK_PROFILE.id,
+		startupMs,
+		activeMs,
+		recoveryMs,
+		cooldownMs,
+		movementLock: profile.movementLock ?? fallbacks.lockMovement ?? DEFAULT_ACTION_BATTLE_ATTACK_PROFILE.movementLock,
+		directionLock: profile.directionLock ?? DEFAULT_ACTION_BATTLE_ATTACK_PROFILE.directionLock,
+		animationKey: resolveAnimationKey(profile.animationKey),
+		hitPolicy: resolveHitPolicy(profile.hitPolicy),
+		reaction: normalizeActionBattleHitReaction(profile.reaction),
+		totalDurationMs
+	};
+	if (hitboxes) normalized.hitboxes = hitboxes;
+	return normalized;
 }
-export {
-  DEFAULT_ACTION_BATTLE_OPTIONS,
-  normalizeActionBattleOptions
-};
+//#endregion
+export { DEFAULT_ACTION_BATTLE_ATTACK_PROFILE, normalizeActionBattleAttackProfile };

package/dist/server/index5.js

@@ -1,30 +1,108 @@
-const normalizeMaskRows = (mask) => {
-  if (!mask) return ["#"];
-  if (Array.isArray(mask)) return mask;
-  return mask.trim().split("\n").map((row) => row.replace(/\r/g, ""));
-};
-const 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 });
-      }
-    }
-  });
-  if (cells.length === 0) {
-    cells.push({ dx: 0, dy: 0 });
-  }
-  return { width, height, centerX, centerY, cells };
-};
-const manhattanDistance = (a, b) => Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
-export {
-  manhattanDistance,
-  parseAoeMask
+import { normalizeActionBattleAttackProfile } from "./index4.js";
+//#region src/config.ts
+var DEFAULT_ACTION_BATTLE_OPTIONS = {
+	ui: {
+		actionBar: {
+			enabled: false,
+			autoOpen: false,
+			mode: "both"
+		},
+		targeting: {
+			enabled: true,
+			showGrid: true,
+			colors: {
+				area: 3120887,
+				edge: 1796760,
+				cursor: 16765286
+			}
+		}
+	},
+	skills: { defaultAoeMask: ["#"] },
+	targeting: {
+		affects: "events",
+		allowEmptyTarget: true
+	},
+	attack: {
+		lockMovement: true,
+		lockDurationMs: 350,
+		showPreview: true,
+		previewDurationMs: 180,
+		previewColor: 16774064,
+		previewAccentColor: 16777215
+	},
+	animations: {}
 };
+var currentActionBattleOptions = DEFAULT_ACTION_BATTLE_OPTIONS;
+function normalizeActionBattleOptions(options = {}) {
+	const attack = {
+		...DEFAULT_ACTION_BATTLE_OPTIONS.attack,
+		...options.attack
+	};
+	const attackProfile = normalizeActionBattleAttackProfile(attack.profile, {
+		lockMovement: attack.lockMovement,
+		lockDurationMs: attack.lockDurationMs,
+		hitboxes: attack.hitboxes
+	});
+	return {
+		ui: {
+			actionBar: {
+				...DEFAULT_ACTION_BATTLE_OPTIONS.ui?.actionBar,
+				...options.ui?.actionBar
+			},
+			targeting: {
+				...DEFAULT_ACTION_BATTLE_OPTIONS.ui?.targeting,
+				...options.ui?.targeting,
+				colors: {
+					...DEFAULT_ACTION_BATTLE_OPTIONS.ui?.targeting?.colors,
+					...options.ui?.targeting?.colors
+				}
+			}
+		},
+		skills: {
+			...DEFAULT_ACTION_BATTLE_OPTIONS.skills,
+			...options.skills
+		},
+		targeting: {
+			...DEFAULT_ACTION_BATTLE_OPTIONS.targeting,
+			...options.targeting
+		},
+		debug: {
+			...DEFAULT_ACTION_BATTLE_OPTIONS.debug,
+			...options.debug
+		},
+		attack: {
+			...attack,
+			profile: attackProfile
+		},
+		animations: {
+			...DEFAULT_ACTION_BATTLE_OPTIONS.animations,
+			...options.animations
+		},
+		systems: {
+			combat: {
+				...DEFAULT_ACTION_BATTLE_OPTIONS.systems?.combat,
+				...options.systems?.combat,
+				hooks: {
+					...DEFAULT_ACTION_BATTLE_OPTIONS.systems?.combat?.hooks,
+					...options.systems?.combat?.hooks
+				}
+			},
+			ai: {
+				...DEFAULT_ACTION_BATTLE_OPTIONS.systems?.ai,
+				...options.systems?.ai,
+				behaviors: {
+					...DEFAULT_ACTION_BATTLE_OPTIONS.systems?.ai?.behaviors,
+					...options.systems?.ai?.behaviors
+				}
+			}
+		}
+	};
+}
+function setActionBattleOptions(options) {
+	currentActionBattleOptions = options;
+}
+function getActionBattleOptions() {
+	return currentActionBattleOptions;
+}
+//#endregion
+export { getActionBattleOptions, normalizeActionBattleOptions, setActionBattleOptions };

package/dist/server/index6.js

@@ -0,0 +1,143 @@
+//#region src/core/defaults.ts
+var DEFAULT_CORE_KNOCKBACK = {
+	force: 50,
+	duration: 300
+};
+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 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);
+	return {
+		damage: raw?.damage ?? 0,
+		defeated: target.hp <= 0,
+		raw
+	};
+};
+var defaultKnockbackResolver = (context) => {
+	const weapon = context.weapon ?? resolveEquippedWeapon(context.attacker);
+	return {
+		force: weapon?.knockbackForce ?? DEFAULT_CORE_KNOCKBACK.force,
+		duration: weapon?.knockbackDuration ?? DEFAULT_CORE_KNOCKBACK.duration,
+		direction: resolveDirection(context.attacker, context.target)
+	};
+};
+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 };

package/dist/server/index7.js

@@ -0,0 +1,25 @@
+import { defaultActionBattleSystems } from "./index6.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 getActionBattleSystems = () => currentActionBattleSystems;
+var createActionBattleSystems = mergeSystems;
+//#endregion
+export { createActionBattleSystems, getActionBattleSystems, setActionBattleSystems };

package/dist/server/index8.js

@@ -0,0 +1,72 @@
+import { normalizeActionBattleAttackProfile } from "./index4.js";
+//#region src/core/enemy-attack-profiles.ts
+var DEFAULT_ACTION_BATTLE_ENEMY_ATTACK_PROFILES = {
+	melee: {
+		id: "enemy-melee",
+		startupMs: 120,
+		activeMs: 100,
+		recoveryMs: 220,
+		cooldownMs: 440,
+		reaction: {
+			invincibilityMs: 250,
+			hitstunMs: 120,
+			staggerPower: 1
+		}
+	},
+	combo: {
+		id: "enemy-combo",
+		startupMs: 80,
+		activeMs: 80,
+		recoveryMs: 140,
+		cooldownMs: 300,
+		reaction: {
+			invincibilityMs: 180,
+			hitstunMs: 90,
+			staggerPower: .75
+		}
+	},
+	charged: {
+		id: "enemy-charged",
+		startupMs: 800,
+		activeMs: 140,
+		recoveryMs: 320,
+		cooldownMs: 1260,
+		reaction: {
+			invincibilityMs: 350,
+			hitstunMs: 220,
+			staggerPower: 2
+		}
+	},
+	zone: {
+		id: "enemy-zone",
+		startupMs: 450,
+		activeMs: 180,
+		recoveryMs: 320,
+		cooldownMs: 950,
+		reaction: {
+			invincibilityMs: 300,
+			hitstunMs: 160,
+			staggerPower: 1.25
+		}
+	},
+	dashAttack: {
+		id: "enemy-dash",
+		startupMs: 180,
+		activeMs: 120,
+		recoveryMs: 260,
+		cooldownMs: 560,
+		reaction: {
+			invincibilityMs: 280,
+			hitstunMs: 150,
+			staggerPower: 1.2
+		}
+	}
+};
+function normalizeActionBattleEnemyAttackProfiles(overrides = {}) {
+	return Object.fromEntries(Object.entries(DEFAULT_ACTION_BATTLE_ENEMY_ATTACK_PROFILES).map(([key, defaultProfile]) => [key, normalizeActionBattleAttackProfile({
+		...defaultProfile,
+		...overrides[key]
+	})]));
+}
+//#endregion
+export { DEFAULT_ACTION_BATTLE_ENEMY_ATTACK_PROFILES, normalizeActionBattleEnemyAttackProfiles };

package/dist/server/index9.js

@@ -0,0 +1,55 @@
+import { normalizeActionBattleAttackProfile } from "./index4.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
+	});
+}
+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;
+	}
+};
+//#endregion
+export { ACTION_BATTLE_HITBOX_FRAME_MS, ActionBattleHitTracker, createActionBattleAttackId, getNormalizedActionBattleAttackProfile, resolveActionBattleHitboxSpeed, scheduleActionBattleStartup };

package/dist/server/server.d.ts

@@ -0,0 +1,106 @@
+import { RpgEvent, RpgPlayer, RpgServer } from '@rpgjs/server';
+import { HitResult, ApplyHitHooks } from './ai.server';
+import { ActionBattleOptions } from './types';
+export declare const ACTION_BATTLE_ACTION_BAR_GUI_ID = "action-battle-action-bar";
+/**
+ * Default player attack hitboxes offsets for each direction
+ *
+ * These hitboxes define the attack areas relative to the player's position
+ * for each cardinal direction. They are converted to absolute coordinates
+ * when creating the moving hitbox.
+ */
+export declare const DEFAULT_PLAYER_ATTACK_HITBOXES: {
+    up: {
+        offsetX: number;
+        offsetY: number;
+        width: number;
+        height: number;
+    };
+    down: {
+        offsetX: number;
+        offsetY: number;
+        width: number;
+        height: number;
+    };
+    left: {
+        offsetX: number;
+        offsetY: number;
+        width: number;
+        height: number;
+    };
+    right: {
+        offsetX: number;
+        offsetY: number;
+        width: number;
+        height: number;
+    };
+    default: {
+        offsetX: number;
+        offsetY: number;
+        width: number;
+        height: number;
+    };
+};
+/**
+ * Get knockback force from player's equipped weapon
+ *
+ * Retrieves the knockbackForce property from the player's equipped weapon.
+ * Falls back to DEFAULT_KNOCKBACK.force if no weapon or property is set.
+ *
+ * @param player - The player to get weapon knockback from
+ * @returns Knockback force value
+ *
+ * @example
+ * ```ts
+ * // Player with weapon having knockbackForce: 80
+ * const force = getPlayerWeaponKnockbackForce(player); // 80
+ *
+ * // No weapon equipped
+ * const force = getPlayerWeaponKnockbackForce(player); // 50 (default)
+ * ```
+ */
+export declare function getPlayerWeaponKnockbackForce(player: RpgPlayer): number;
+/**
+ * Apply hit from player to target (event with AI)
+ *
+ * Handles damage calculation, knockback based on weapon, and visual effects.
+ * Can be customized using hooks.
+ *
+ * @param player - The attacking player
+ * @param target - The event being hit
+ * @param hooks - Optional hooks for customizing hit behavior
+ * @returns Hit result if AI exists, undefined otherwise
+ *
+ * @example
+ * ```ts
+ * // Basic hit
+ * const result = applyPlayerHitToEvent(player, event);
+ *
+ * // With custom hooks
+ * const result = applyPlayerHitToEvent(player, event, {
+ *   onBeforeHit(result) {
+ *     result.knockbackForce *= 2; // Double knockback
+ *     return result;
+ *   },
+ *   onAfterHit(result) {
+ *     if (result.defeated) {
+ *       player.gold += 10;
+ *     }
+ *   }
+ * });
+ * ```
+ */
+export declare function applyPlayerHitToEvent(player: RpgPlayer, target: 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 { 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 { 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 { 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/server/targeting.d.ts

@@ -0,0 +1,19 @@
+import { ActionBattleAoeMask } from './types';
+export interface ParsedAoeMask {
+    width: number;
+    height: number;
+    centerX: number;
+    centerY: number;
+    cells: Array<{
+        dx: number;
+        dy: number;
+    }>;
+}
+export declare const parseAoeMask: (mask: ActionBattleAoeMask | undefined) => ParsedAoeMask;
+export declare const manhattanDistance: (a: {
+    x: number;
+    y: number;
+}, b: {
+    x: number;
+    y: number;
+}) => number;