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

package/dist/client/index17.js

@@ -1,13 +1,209 @@
-//#region src/core/equipment.ts
-var resolveItemId = (item) => item?.id?.() ?? item?.id;
-function resolveActionBattleWeaponAttackProfile(entity) {
+//#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 = resolveItemId(item);
+		const itemId = item?.id?.() ?? item?.id;
 		const itemData = entity?.databaseById?.(itemId);
-		if (itemData?._type === "weapon" && itemData.attackProfile) return itemData.attackProfile;
+		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 previousHp = typeof target.hp === "number" && Number.isFinite(target.hp) ? target.hp : void 0;
+	const raw = target.applyDamage(context.attacker, context.skill);
+	const resolvedDamage = Number(raw?.damage ?? 0);
+	if (!Number.isFinite(resolvedDamage)) {
+		if (previousHp !== void 0) target.hp = previousHp;
+		return {
+			damage: 0,
+			defeated: false,
+			raw
+		};
+	}
+	return {
+		damage: resolvedDamage,
+		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 defaultEnemyPresets = {
+	[CoreEnemyType.Aggressive]: {
+		enemyType: CoreEnemyType.Aggressive,
+		attackCooldown: 600,
+		visionRange: 150,
+		attackRange: 50,
+		dodgeChance: .1,
+		dodgeCooldown: 3e3,
+		fleeThreshold: .15,
+		behaviorKey: CoreEnemyType.Aggressive
+	},
+	[CoreEnemyType.Defensive]: {
+		enemyType: CoreEnemyType.Defensive,
+		attackCooldown: 1500,
+		visionRange: 120,
+		attackRange: 60,
+		dodgeChance: .5,
+		dodgeCooldown: 1500,
+		fleeThreshold: .3,
+		behaviorKey: CoreEnemyType.Defensive
+	},
+	[CoreEnemyType.Ranged]: {
+		enemyType: CoreEnemyType.Ranged,
+		attackCooldown: 1200,
+		visionRange: 200,
+		attackRange: 120,
+		dodgeChance: .4,
+		dodgeCooldown: 2e3,
+		fleeThreshold: .25,
+		behaviorKey: CoreEnemyType.Ranged
+	},
+	[CoreEnemyType.Tank]: {
+		enemyType: CoreEnemyType.Tank,
+		attackCooldown: 2e3,
+		visionRange: 100,
+		attackRange: 50,
+		dodgeChance: 0,
+		dodgeCooldown: 5e3,
+		fleeThreshold: .1,
+		poise: 2,
+		behaviorKey: CoreEnemyType.Tank
+	},
+	[CoreEnemyType.Berserker]: {
+		enemyType: CoreEnemyType.Berserker,
+		attackCooldown: 800,
+		visionRange: 180,
+		attackRange: 55,
+		dodgeChance: .15,
+		dodgeCooldown: 2500,
+		fleeThreshold: .05,
+		behaviorKey: CoreEnemyType.Berserker
+	}
+};
+var defaultActionBattleSystems = {
+	combat: defaultCombatSystem,
+	ai: {
+		behaviors: defaultEnemyBehaviors,
+		presets: defaultEnemyPresets
+	}
+};
 //#endregion
-export { resolveActionBattleWeaponAttackProfile };
+export { DEFAULT_ZELDA_PLAYER_HITBOXES, createDefaultPlayerHitboxResolver, defaultActionBattleSystems, defaultCombatSystem, defaultEnemyBehaviors, defaultEnemyPresets, defaultKnockbackResolver, defaultRpgjsDamageResolver };

package/dist/client/index18.js

@@ -1,60 +1,34 @@
-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;
+import { defaultActionBattleSystems } from "./index17.js";
+//#region src/core/context.ts
+var mergeSystems = (options = {}) => ({
+	combat: {
+		...defaultActionBattleSystems.combat,
+		resolveDamage: options.combat?.damage ?? options.systems?.combat?.damage ?? defaultActionBattleSystems.combat.resolveDamage,
+		resolveKnockback: options.combat?.knockback ?? options.systems?.combat?.knockback ?? defaultActionBattleSystems.combat.resolveKnockback,
+		hooks: {
+			...defaultActionBattleSystems.combat.hooks,
+			...options.systems?.combat?.hooks,
+			...options.combat?.hooks
+		}
+	},
+	ai: {
+		behaviors: {
+			...defaultActionBattleSystems.ai.behaviors,
+			...options.systems?.ai?.behaviors,
+			...options.ai?.behaviors
+		},
+		presets: {
+			...defaultActionBattleSystems.ai.presets,
+			...options.systems?.ai?.presets,
+			...options.ai?.presets
+		}
+	}
+});
+var currentActionBattleSystems = mergeSystems();
+var setActionBattleSystems = (options = {}) => {
+	currentActionBattleSystems = mergeSystems(options);
 };
+var getActionBattleSystems = () => currentActionBattleSystems;
+var createActionBattleSystems = mergeSystems;
 //#endregion
-export { applyActionBattleHit };
+export { createActionBattleSystems, getActionBattleSystems, setActionBattleSystems };

package/dist/client/index19.js

@@ -1,10 +1,72 @@
-//#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);
+import { normalizeActionBattleAttackProfile } from "./index3.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 { createActionEnemy };
+export { DEFAULT_ACTION_BATTLE_ENEMY_ATTACK_PROFILES, normalizeActionBattleEnemyAttackProfiles };