@rpgjs/action-battle 5.0.0-beta.5 → 5.0.0-beta.6

package/dist/client/index17.js

@@ -0,0 +1,13 @@
+//#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;
+	}
+	return null;
+}
+//#endregion
+export { resolveActionBattleWeaponAttackProfile };

package/dist/client/index18.js

@@ -0,0 +1,60 @@
+import { isActionBattleEntityInvincible, setActionBattleInvincibility } from "./index2.js";
+//#region src/core/hit.ts
+var applyActionBattleHit = (system, context) => {
+	let hitContext = { ...context };
+	const before = system.hooks?.beforeHit?.(hitContext);
+	if (before === false) return {
+		damage: 0,
+		knockbackForce: 0,
+		knockbackDuration: 0,
+		defeated: false,
+		attacker: hitContext.attacker,
+		target: hitContext.target,
+		cancelled: true,
+		metadata: hitContext.metadata
+	};
+	if (before) hitContext = before;
+	if (isActionBattleEntityInvincible(hitContext.target)) return {
+		damage: 0,
+		knockbackForce: 0,
+		knockbackDuration: 0,
+		defeated: false,
+		attacker: hitContext.attacker,
+		target: hitContext.target,
+		cancelled: true,
+		metadata: hitContext.metadata,
+		reaction: hitContext.reaction
+	};
+	const damage = hitContext.damage ?? system.resolveDamage({
+		attacker: hitContext.attacker,
+		target: hitContext.target,
+		skill: hitContext.skill,
+		pattern: hitContext.pattern
+	});
+	hitContext.damage = damage;
+	const afterDamage = system.hooks?.afterDamage?.(hitContext);
+	if (afterDamage) hitContext = afterDamage;
+	const knockback = hitContext.knockback ?? system.resolveKnockback({
+		attacker: hitContext.attacker,
+		target: hitContext.target,
+		damage
+	});
+	hitContext.knockback = knockback;
+	if (!damage.defeated && knockback.force > 0 && knockback.direction) hitContext.target.knockback?.(knockback.direction, knockback.force, knockback.duration);
+	if (!damage.defeated && hitContext.reaction?.invincibilityMs) setActionBattleInvincibility(hitContext.target, hitContext.reaction.invincibilityMs);
+	const result = {
+		damage: damage.damage,
+		knockbackForce: knockback.force,
+		knockbackDuration: knockback.duration,
+		defeated: damage.defeated,
+		attacker: hitContext.attacker,
+		target: hitContext.target,
+		rawDamage: damage.raw,
+		reaction: hitContext.reaction,
+		metadata: hitContext.metadata
+	};
+	system.hooks?.afterHit?.(result);
+	return result;
+};
+//#endregion
+export { applyActionBattleHit };

package/dist/client/index19.js

@@ -0,0 +1,10 @@
+//#region src/enemies/factory.ts
+var BattleAi = null;
+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);
+};
+//#endregion
+export { createActionEnemy };

package/dist/client/index2.js

@@ -1,94 +1,32 @@
-//#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: {}
+//#region src/core/hit-reaction.ts
+var DEFAULT_ACTION_BATTLE_HIT_REACTION = {
+	invincibilityMs: 250,
+	hitstunMs: 150,
+	staggerPower: 1
 };
-var currentActionBattleOptions = DEFAULT_ACTION_BATTLE_OPTIONS;
-function normalizeActionBattleOptions(options = {}) {
+var STATE_KEY = "__actionBattleHitReaction";
+var isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
+var nonNegativeMs = (value, fallback) => isFiniteNumber(value) ? Math.max(0, value) : fallback;
+var nonNegativeValue = (value, fallback) => isFiniteNumber(value) ? Math.max(0, value) : fallback;
+var getRuntimeState = (entity) => {
+	if (!entity[STATE_KEY]) entity[STATE_KEY] = { invincibleUntil: 0 };
+	return entity[STATE_KEY];
+};
+function normalizeActionBattleHitReaction(reaction, defaults = DEFAULT_ACTION_BATTLE_HIT_REACTION) {
 	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
-		},
-		attack: {
-			...DEFAULT_ACTION_BATTLE_OPTIONS.attack,
-			...options.attack
-		},
-		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
-				}
-			}
-		}
+		invincibilityMs: nonNegativeMs(reaction?.invincibilityMs, defaults.invincibilityMs),
+		hitstunMs: nonNegativeMs(reaction?.hitstunMs, defaults.hitstunMs),
+		staggerPower: nonNegativeValue(reaction?.staggerPower, defaults.staggerPower)
 	};
 }
-function setActionBattleOptions(options) {
-	currentActionBattleOptions = options;
+function isActionBattleEntityInvincible(entity, now = Date.now()) {
+	if (!entity) return false;
+	return getRuntimeState(entity).invincibleUntil > now;
 }
-function getActionBattleOptions() {
-	return currentActionBattleOptions;
+function setActionBattleInvincibility(entity, durationMs, now = Date.now()) {
+	if (!entity || durationMs <= 0) return;
+	const state = getRuntimeState(entity);
+	state.invincibleUntil = Math.max(state.invincibleUntil, now + durationMs);
 }
 //#endregion
-export { DEFAULT_ACTION_BATTLE_OPTIONS, getActionBattleOptions, normalizeActionBattleOptions, setActionBattleOptions };
+export { DEFAULT_ACTION_BATTLE_HIT_REACTION, isActionBattleEntityInvincible, normalizeActionBattleHitReaction, setActionBattleInvincibility };