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

package/dist/server/index3.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 { getActionBattleOptions, normalizeActionBattleOptions, setActionBattleOptions };
+export { DEFAULT_ACTION_BATTLE_HIT_REACTION, isActionBattleEntityInvincible, normalizeActionBattleHitReaction, setActionBattleInvincibility };

package/dist/server/index4.js

@@ -1,143 +1,47 @@
-//#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)
+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
+};
+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
 	};
-};
-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 }
-};
+	if (hitboxes) normalized.hitboxes = hitboxes;
+	return normalized;
+}
 //#endregion
-export { DEFAULT_ZELDA_PLAYER_HITBOXES, createDefaultPlayerHitboxResolver, defaultActionBattleSystems, defaultCombatSystem, defaultEnemyBehaviors, defaultKnockbackResolver, defaultRpgjsDamageResolver };
+export { DEFAULT_ACTION_BATTLE_ATTACK_PROFILE, normalizeActionBattleAttackProfile };

package/dist/server/index5.js

@@ -1,25 +1,108 @@
-import { defaultActionBattleSystems } from "./index4.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
+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
+			}
 		}
 	},
-	ai: { behaviors: {
-		...defaultActionBattleSystems.ai.behaviors,
-		...options.systems?.ai?.behaviors
-	} }
-});
-var currentActionBattleSystems = mergeSystems();
-var setActionBattleSystems = (options = {}) => {
-	currentActionBattleSystems = mergeSystems(options);
+	skills: { defaultAoeMask: ["#"] },
+	targeting: {
+		affects: "events",
+		allowEmptyTarget: true
+	},
+	attack: {
+		lockMovement: true,
+		lockDurationMs: 350,
+		showPreview: true,
+		previewDurationMs: 180,
+		previewColor: 16774064,
+		previewAccentColor: 16777215
+	},
+	animations: {}
 };
-var getActionBattleSystems = () => currentActionBattleSystems;
-var createActionBattleSystems = mergeSystems;
+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 { createActionBattleSystems, getActionBattleSystems, setActionBattleSystems };
+export { getActionBattleOptions, normalizeActionBattleOptions, setActionBattleOptions };