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

package/dist/client/index12.js

@@ -0,0 +1,106 @@
+import { normalizeActionBattleOptions } from "./index4.js";
+import { setActionBattleOptions, startAttackPreview, stopAttackPreview } from "./index5.js";
+import __ce_component from "./index6.js";
+import __ce_component$1 from "./index8.js";
+import __ce_component$2 from "./index9.js";
+import { resolveActionBattleAnimation } from "./index10.js";
+import { getNormalizedActionBattleAttackProfile } from "./index11.js";
+import { PrebuiltComponentAnimations, RpgClientEngine, RpgGui, inject } from "@rpgjs/client";
+import { defineModule } from "@rpgjs/common";
+//#region src/client.ts
+var DEFAULT_ATTACK_LOCK_DURATION_MS = 350;
+var beginLocalPlayerAttackLock = (engine, durationMs, locks) => {
+	if (durationMs <= 0) return true;
+	const player = engine.scene?.getCurrentPlayer?.();
+	if (!player) return true;
+	const runtimePlayer = player;
+	const now = Date.now();
+	if (typeof runtimePlayer.__actionBattleAttackLockedUntil === "number" && runtimePlayer.__actionBattleAttackLockedUntil > now) return false;
+	const lockId = (runtimePlayer.__actionBattleAttackLockId ?? 0) + 1;
+	runtimePlayer.__actionBattleAttackLockId = lockId;
+	runtimePlayer.__actionBattleAttackLockedUntil = now + durationMs;
+	const previousCanMove = player.canMove;
+	const previousDirectionFixed = player.directionFixed;
+	const previousAnimationFixed = player.animationFixed;
+	if (locks.movement) {
+		if (typeof engine.interruptCurrentPlayerMovement === "function") engine.interruptCurrentPlayerMovement(player);
+		else engine.scene?.stopMovement?.(player);
+		player.canMove = false;
+	}
+	if (locks.direction) player.directionFixed = true;
+	player.animationFixed = true;
+	setTimeout(() => {
+		if (runtimePlayer.__actionBattleAttackLockId !== lockId) return;
+		runtimePlayer.__actionBattleAttackLockedUntil = 0;
+		player.canMove = previousCanMove;
+		player.directionFixed = previousDirectionFixed;
+		player.animationFixed = previousAnimationFixed;
+	}, durationMs);
+	return true;
+};
+var resolveLocalPlayerDirection = (player) => {
+	if (typeof player.getDirection === "function") return player.getDirection();
+	if (typeof player.direction === "function") return player.direction();
+	return player.direction ?? "down";
+};
+var playLocalPlayerAttackAnimation = (player, options) => {
+	if (!player || typeof player.setAnimation !== "function") return;
+	const animation = resolveActionBattleAnimation("attack", player, options.animations);
+	if (!animation) return;
+	if (animation.graphic !== void 0) {
+		player.setAnimation(animation.animationName, animation.graphic, animation.repeat);
+		return;
+	}
+	player.setAnimation(animation.animationName, animation.repeat);
+};
+var showLocalAttackPreview = (player, options) => {
+	if (!player || options.attack?.showPreview === false) return;
+	const durationMs = Math.max(1, options.attack?.previewDurationMs ?? 180);
+	const previewId = startAttackPreview({
+		direction: resolveLocalPlayerDirection(player),
+		durationMs,
+		color: options.attack?.previewColor,
+		accentColor: options.attack?.previewAccentColor
+	});
+	setTimeout(() => stopAttackPreview(previewId), durationMs);
+};
+var createActionBattleClient = (options = {}) => {
+	const normalized = normalizeActionBattleOptions(options);
+	setActionBattleOptions(normalized);
+	const actionBarEnabled = normalized.ui?.actionBar?.enabled;
+	const componentsInFront = [...normalized.ui?.targeting?.enabled ? [__ce_component$1] : [], __ce_component$2];
+	const hitComponent = PrebuiltComponentAnimations?.Hit;
+	return defineModule({
+		componentAnimations: hitComponent ? [{
+			id: "hit",
+			component: hitComponent
+		}] : [],
+		gui: actionBarEnabled ? [{
+			id: "action-battle-action-bar",
+			component: __ce_component,
+			dependencies: () => {
+				return [inject(RpgClientEngine).scene.currentPlayer];
+			}
+		}] : [],
+		sprite: { componentsInFront },
+		sceneMap: { onAfterLoading() {
+			if (actionBarEnabled && normalized.ui?.actionBar?.autoOpen) inject(RpgGui).display("action-battle-action-bar");
+		} },
+		engine: { onInput(engine, { input }) {
+			if (input !== "action") return;
+			const player = engine.scene?.getCurrentPlayer?.();
+			if (!player) return;
+			const attackProfile = getNormalizedActionBattleAttackProfile(normalized);
+			const lockDurationMs = Math.max(0, attackProfile.totalDurationMs ?? DEFAULT_ATTACK_LOCK_DURATION_MS);
+			if (attackProfile.movementLock || attackProfile.directionLock) beginLocalPlayerAttackLock(engine, lockDurationMs, {
+				movement: attackProfile.movementLock,
+				direction: attackProfile.directionLock
+			});
+			playLocalPlayerAttackAnimation(player, normalized);
+			showLocalAttackPreview(player, normalized);
+		} }
+	});
+};
+var client_default = createActionBattleClient();
+//#endregion
+export { createActionBattleClient, client_default as default };

package/dist/client/index13.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/client/index14.js

@@ -0,0 +1,25 @@
+import { defaultActionBattleSystems } from "./index13.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/client/index15.js

@@ -0,0 +1,72 @@
+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 { DEFAULT_ACTION_BATTLE_ENEMY_ATTACK_PROFILES, normalizeActionBattleEnemyAttackProfiles };