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

package/dist/server/index22.js

@@ -0,0 +1,78 @@
+//#region src/ui.ts
+var inject = null;
+var RpgClientEngine = null;
+var ActionBattleUi = {
+	ActionBar: null,
+	TargetingOverlay: null,
+	AttackPreview: null
+};
+var normalizeToggle = (value, defaults) => {
+	if (value === false) return {
+		...defaults,
+		enabled: false
+	};
+	if (value === true) return {
+		...defaults,
+		enabled: true
+	};
+	if (value === void 0) return { ...defaults };
+	return {
+		...defaults,
+		...value,
+		enabled: value.enabled ?? defaults.enabled
+	};
+};
+function createActionBattleUi(input = "classic") {
+	if (input === "classic") return {};
+	return input;
+}
+function resolveActionBattleUi(options = {}) {
+	const actionBar = normalizeToggle(options.actionBar, {
+		enabled: false,
+		autoOpen: false,
+		mode: "both",
+		component: ActionBattleUi.ActionBar
+	});
+	const targeting = normalizeToggle(options.targeting, {
+		enabled: true,
+		showGrid: true,
+		component: ActionBattleUi.TargetingOverlay,
+		colors: {
+			area: 3120887,
+			edge: 1796760,
+			cursor: 16765286
+		}
+	});
+	const attackPreview = normalizeToggle(options.attackPreview, {
+		enabled: true,
+		component: ActionBattleUi.AttackPreview
+	});
+	const gui = [...options.gui ?? []];
+	if (actionBar.enabled && actionBar.component) gui.unshift({
+		id: "action-battle-action-bar",
+		component: actionBar.component,
+		dependencies: () => {
+			return [inject(RpgClientEngine).scene.currentPlayer];
+		}
+	});
+	const configuredSpriteComponents = Array.isArray(options.spriteComponents) ? {
+		front: options.spriteComponents,
+		back: []
+	} : options.spriteComponents ?? {};
+	return {
+		gui,
+		sprite: {
+			componentsInFront: [
+				...targeting.enabled && targeting.component ? [targeting.component] : [],
+				...attackPreview.enabled && attackPreview.component ? [attackPreview.component] : [],
+				...configuredSpriteComponents.front ?? []
+			],
+			componentsBehind: configuredSpriteComponents.back ?? []
+		},
+		actionBar,
+		targeting,
+		attackPreview
+	};
+}
+//#endregion
+export { ActionBattleUi, createActionBattleUi, resolveActionBattleUi };

package/dist/server/index23.js

@@ -0,0 +1,12 @@
+import { BattleAi } from "./index19.js";
+//#region src/enemies/factory.ts
+var defineActionBattleEnemy = (preset) => preset;
+var defineActionBattleAiPreset = (preset) => preset;
+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, defineActionBattleAiPreset, defineActionBattleEnemy };

package/dist/server/index5.js

@@ -34,67 +34,108 @@ var DEFAULT_ACTION_BATTLE_OPTIONS = {
 };
 var currentActionBattleOptions = DEFAULT_ACTION_BATTLE_OPTIONS;
 function normalizeActionBattleOptions(options = {}) {
+	const combat = {
+		...DEFAULT_ACTION_BATTLE_OPTIONS.systems?.combat,
+		...options.systems?.combat,
+		...options.combat,
+		hooks: {
+			...DEFAULT_ACTION_BATTLE_OPTIONS.systems?.combat?.hooks,
+			...options.systems?.combat?.hooks,
+			...options.combat?.hooks
+		}
+	};
 	const attack = {
 		...DEFAULT_ACTION_BATTLE_OPTIONS.attack,
-		...options.attack
+		...options.attack,
+		...combat.attack
 	};
 	const attackProfile = normalizeActionBattleAttackProfile(attack.profile, {
 		lockMovement: attack.lockMovement,
 		lockDurationMs: attack.lockDurationMs,
 		hitboxes: attack.hitboxes
 	});
+	const normalizedAttack = {
+		...attack,
+		profile: attackProfile
+	};
+	const skills = {
+		...DEFAULT_ACTION_BATTLE_OPTIONS.skills,
+		...options.skills
+	};
+	skills.targeting = skills.targeting ?? skills.getTargeting;
+	skills.getTargeting = skills.getTargeting ?? skills.targeting;
+	const defaultActionBar = DEFAULT_ACTION_BATTLE_OPTIONS.ui?.actionBar;
+	const defaultTargeting = DEFAULT_ACTION_BATTLE_OPTIONS.ui?.targeting;
+	const optionActionBar = options.ui?.actionBar;
+	const optionTargeting = options.ui?.targeting;
+	const optionAttackPreview = options.ui?.attackPreview;
+	const actionBar = options.ui?.actionBar === false ? {
+		...defaultActionBar,
+		enabled: false
+	} : {
+		...defaultActionBar,
+		...options.ui?.actionBar === true ? { enabled: true } : optionActionBar
+	};
+	const legacyPreviewEnabled = normalizedAttack.showPreview !== false;
+	const attackPreview = options.ui?.attackPreview === false ? { enabled: false } : {
+		enabled: options.ui?.attackPreview === true ? true : legacyPreviewEnabled,
+		...options.ui?.attackPreview === true ? {} : optionAttackPreview
+	};
+	const targeting = options.ui?.targeting === false ? {
+		...defaultTargeting,
+		enabled: false
+	} : {
+		...defaultTargeting,
+		...options.ui?.targeting === true ? { enabled: true } : optionTargeting,
+		colors: {
+			...defaultTargeting?.colors,
+			...typeof options.ui?.targeting === "object" ? optionTargeting?.colors : void 0
+		}
+	};
+	const ai = {
+		...DEFAULT_ACTION_BATTLE_OPTIONS.systems?.ai,
+		...options.systems?.ai,
+		...options.ai,
+		behaviors: {
+			...DEFAULT_ACTION_BATTLE_OPTIONS.systems?.ai?.behaviors,
+			...options.systems?.ai?.behaviors,
+			...options.ai?.behaviors
+		},
+		presets: {
+			...DEFAULT_ACTION_BATTLE_OPTIONS.systems?.ai?.presets,
+			...options.systems?.ai?.presets,
+			...options.ai?.presets
+		}
+	};
 	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
+			...options.ui,
+			actionBar,
+			targeting,
+			attackPreview
 		},
+		skills,
 		targeting: {
 			...DEFAULT_ACTION_BATTLE_OPTIONS.targeting,
 			...options.targeting
 		},
-		debug: {
-			...DEFAULT_ACTION_BATTLE_OPTIONS.debug,
-			...options.debug
-		},
-		attack: {
-			...attack,
-			profile: attackProfile
+		attack: normalizedAttack,
+		combat: {
+			...combat,
+			attack: normalizedAttack
 		},
+		ai,
+		visual: options.visual,
 		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
-				}
+				...combat,
+				attack: normalizedAttack
 			},
-			ai: {
-				...DEFAULT_ACTION_BATTLE_OPTIONS.systems?.ai,
-				...options.systems?.ai,
-				behaviors: {
-					...DEFAULT_ACTION_BATTLE_OPTIONS.systems?.ai?.behaviors,
-					...options.systems?.ai?.behaviors
-				}
-			}
+			ai
 		}
 	};
 }

package/dist/server/index6.js

@@ -1,143 +1,206 @@
-//#region src/core/defaults.ts
-var DEFAULT_CORE_KNOCKBACK = {
-	force: 50,
-	duration: 300
+import { playActionBattleAnimation } from "./index2.js";
+import { getActionBattleOptions } from "./index5.js";
+//#region src/visual.ts
+var ACTION_BATTLE_CLIENT_VISUAL_ID = "action-battle.visual";
+var ACTION_BATTLE_HIT_FX_COMPONENT_ID = "action-battle-hit-fx";
+var previewStarter;
+function setActionBattlePreviewStarter(starter) {
+	previewStarter = starter;
+}
+var entityId = (entity) => typeof entity?.id === "string" ? entity.id : void 0;
+var serializeSkill = (skill) => {
+	const id = skill?.id;
+	if (typeof id === "string") return { id };
+	if (typeof id === "function") {
+		const value = id.call(skill);
+		if (typeof value === "string") return { id: value };
+	}
 };
-var CoreAttackPattern = {
-	Melee: "melee",
-	Combo: "combo",
-	Charged: "charged",
-	Zone: "zone",
-	DashAttack: "dashAttack"
+var serializeResult = (result) => {
+	if (!result) return void 0;
+	return {
+		damage: result.damage,
+		knockbackForce: result.knockbackForce,
+		knockbackDuration: result.knockbackDuration,
+		defeated: result.defeated,
+		attackerId: entityId(result.attacker),
+		targetId: entityId(result.target),
+		rawDamage: result.rawDamage,
+		reaction: result.reaction,
+		cancelled: result.cancelled,
+		metadata: result.metadata
+	};
 };
-var CoreEnemyType = {
-	Aggressive: "aggressive",
-	Defensive: "defensive",
-	Ranged: "ranged",
-	Tank: "tank",
-	Berserker: "berserker"
+var serializeActionBattleVisualContext = (context) => ({
+	moment: context.moment,
+	objectId: entityId(context.entity),
+	sourceId: entityId(context.attacker ?? context.entity),
+	targetId: entityId(context.target),
+	damage: context.damage,
+	defeated: context.defeated,
+	result: serializeResult(context.result),
+	skill: serializeSkill(context.skill),
+	pattern: context.pattern,
+	animations: context.animations,
+	animationDefaults: context.animationDefaults
+});
+function emitActionBattleClientVisual(context) {
+	if (getActionBattleOptions().visual === "none") return;
+	const map = (context.entity ?? context.target ?? context.attacker)?.getCurrentMap?.();
+	if (!map?.clientVisual) return;
+	map.clientVisual(ACTION_BATTLE_CLIENT_VISUAL_ID, serializeActionBattleVisualContext(context));
+}
+function createActionBattleClientVisuals(options = getActionBattleOptions()) {
+	return { [ACTION_BATTLE_CLIENT_VISUAL_ID]: (context) => {
+		const data = context.data ?? {};
+		playActionBattleVisual(options.visual, {
+			moment: data.moment,
+			entity: context.object ?? context.source ?? context.target,
+			target: context.target,
+			attacker: context.source,
+			damage: data.damage,
+			defeated: data.defeated,
+			result: data.result,
+			skill: data.skill,
+			pattern: data.pattern,
+			animations: data.animations ?? options.animations,
+			animationDefaults: data.animationDefaults
+		});
+	} };
+}
+var callGraphic = (entity, keyOrOptions, context) => {
+	if (!entity || keyOrOptions == null) return;
+	if (typeof keyOrOptions === "string") {
+		playActionBattleAnimation(keyOrOptions, entity, context?.animations ?? getActionBattleOptions().animations, {
+			attacker: context?.attacker,
+			target: context?.target,
+			skill: context?.skill
+		}, context?.animationDefaults);
+		return;
+	}
+	const animationName = keyOrOptions.animationName;
+	if (!animationName) return;
+	const repeat = keyOrOptions.repeat ?? 1;
+	const graphic = keyOrOptions.graphic;
+	if (typeof entity.setGraphicAnimation === "function") {
+		if (graphic !== void 0) entity.setGraphicAnimation(animationName, graphic, repeat);
+		else entity.setGraphicAnimation(animationName, repeat);
+		return;
+	}
+	if (typeof entity.setAnimation === "function") if (graphic !== void 0) entity.setAnimation(animationName, graphic, repeat);
+	else entity.setAnimation(animationName, repeat);
 };
-var DEFAULT_ZELDA_PLAYER_HITBOXES = {
-	up: {
-		offsetX: -16,
-		offsetY: -48,
-		width: 32,
-		height: 32
+var createHelpers = (context) => ({
+	graphic(entity, keyOrOptions) {
+		callGraphic(entity, keyOrOptions, context);
 	},
-	down: {
-		offsetX: -16,
-		offsetY: 16,
-		width: 32,
-		height: 32
+	flash(entity, options = {}) {
+		entity?.flash?.({
+			type: "tint",
+			tint: "red",
+			duration: 200,
+			cycles: 1,
+			...options
+		});
 	},
-	left: {
-		offsetX: -48,
-		offsetY: -16,
-		width: 32,
-		height: 32
+	damageText(entity, damageOrText) {
+		if (typeof damageOrText === "string") {
+			if (entity?.showHit) {
+				entity.showHit(damageOrText);
+				return;
+			}
+			entity?.showComponentAnimation?.("hit", {
+				text: damageOrText,
+				direction: entity?.direction?.() ?? entity?.direction
+			});
+			return;
+		}
+		const damage = damageOrText ?? context.damage ?? context.result?.damage;
+		if (damage === void 0) return;
+		const text = `-${damage}`;
+		if (entity?.showHit) {
+			entity.showHit(text);
+			return;
+		}
+		entity?.showComponentAnimation?.("hit", {
+			text,
+			direction: entity?.direction?.() ?? entity?.direction
+		});
 	},
-	right: {
-		offsetX: 16,
-		offsetY: -16,
-		width: 32,
-		height: 32
+	component(entity, id, params = {}) {
+		entity?.showComponentAnimation?.(id, params);
 	},
-	default: {
-		offsetX: 0,
-		offsetY: -32,
-		width: 32,
-		height: 32
+	preview(entity, options = {}) {
+		previewStarter?.(entity, options);
 	}
-};
-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;
+});
+var classicParts = {
+	attack({ entity }, fx) {
+		fx.graphic(entity, "attack");
+	},
+	castSkill({ entity }, fx) {
+		fx.graphic(entity, "castSkill");
+	},
+	preview({ entity }, fx) {
+		fx.preview(entity);
+	},
+	hit({ target, damage }, fx) {
+		fx.flash(target);
+		fx.damageText(target, damage);
+	},
+	hurt({ entity, target }, fx) {
+		const hurtTarget = target ?? entity;
+		fx.flash(hurtTarget);
+		fx.damageText(hurtTarget);
+		fx.graphic(hurtTarget, "hurt");
+	},
+	defeat({ entity, target }, fx) {
+		fx.graphic(target ?? entity, "die");
 	}
-	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 fxParts = {
+	...classicParts,
+	hit(context, fx) {
+		classicParts.hit?.(context, fx);
+		fx.component(context.target, ACTION_BATTLE_HIT_FX_COMPONENT_ID, {
+			name: "hitSpark",
+			scale: .8,
+			zIndex: 1e3
+		});
+	},
+	hurt(context, fx) {
+		classicParts.hurt?.(context, fx);
+		fx.component(context.target ?? context.entity, ACTION_BATTLE_HIT_FX_COMPONENT_ID, {
+			name: "hitSpark",
+			scale: .8,
+			zIndex: 1e3
+		});
+	}
 };
-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 resolveParts = (input) => {
+	const visual = input ?? "classic";
+	if (visual === "none") return null;
+	if (visual === "classic") return classicParts;
+	if (visual === "fx") return fxParts;
+	if (typeof visual === "function") return null;
+	return visual;
 };
-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
+function createActionBattleVisual(input = "classic") {
+	if (typeof input === "function") return input;
+	const parts = resolveParts(input);
+	const composer = (context) => {
+		if (!parts) return;
+		const part = parts[context.moment];
+		if (!part) return;
+		part(context, createHelpers(context));
 	};
-};
-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 }
-};
+	composer.__actionBattleUsesFx = input === "fx";
+	return composer;
+}
+var createClassicActionBattleVisual = () => createActionBattleVisual("classic");
+var createFxActionBattleVisual = () => createActionBattleVisual("fx");
+function playActionBattleVisual(visual, context) {
+	(typeof visual === "function" ? visual : createActionBattleVisual(visual))(context);
+}
 //#endregion
-export { DEFAULT_ZELDA_PLAYER_HITBOXES, createDefaultPlayerHitboxResolver, defaultActionBattleSystems, defaultCombatSystem, defaultEnemyBehaviors, defaultKnockbackResolver, defaultRpgjsDamageResolver };
+export { ACTION_BATTLE_CLIENT_VISUAL_ID, ACTION_BATTLE_HIT_FX_COMPONENT_ID, createActionBattleClientVisuals, createActionBattleVisual, createClassicActionBattleVisual, createFxActionBattleVisual, emitActionBattleClientVisual, playActionBattleVisual, setActionBattlePreviewStarter };