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

package/dist/client/index9.js

@@ -1,99 +1,78 @@
-import { normalizeActionBattleOptions } from "./index2.js";
-import { setActionBattleOptions, startAttackPreview, stopAttackPreview } from "./index3.js";
-import component from "./index4.js";
-import component$1 from "./index6.js";
-import component$2 from "./index7.js";
-import { resolveActionBattleAnimation } from "./index8.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) => {
-	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 = typeof player.canMove === "function" ? player.canMove() : true;
-	const previousDirectionFixed = player.directionFixed;
-	const previousAnimationFixed = player.animationFixed;
-	if (typeof engine.interruptCurrentPlayerMovement === "function") engine.interruptCurrentPlayerMovement(player);
-	else engine.scene?.stopMovement?.(player);
-	player.canMove.set(false);
-	player.directionFixed = true;
-	player.animationFixed = true;
-	setTimeout(() => {
-		if (runtimePlayer.__actionBattleAttackLockId !== lockId) return;
-		runtimePlayer.__actionBattleAttackLockedUntil = 0;
-		player.canMove.set(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
+import { actionBattleAttackPreviewState } from "./index5.js";
+import { RpgClientEngine, inject } from "@rpgjs/client";
+import { Container, Graphics, computed, cond, h, signal, tick, useDefineProps, useProps } from "canvasengine";
+//#region src/components/attack-preview.ce
+function component($$props) {
+	useProps($$props);
+	const { object } = useDefineProps($$props)();
+	const engine = inject(RpgClientEngine);
+	const now = signal(Date.now());
+	tick(() => {
+		if (actionBattleAttackPreviewState().active) now.set(Date.now());
 	});
-	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 ? [component$1] : [], component$2];
-	const hitComponent = PrebuiltComponentAnimations?.Hit;
-	return defineModule({
-		componentAnimations: hitComponent ? [{
-			id: "hit",
-			component: hitComponent
-		}] : [],
-		gui: actionBarEnabled ? [{
-			id: "action-battle-action-bar",
-			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 lockDurationMs = Math.max(0, normalized.attack?.lockDurationMs ?? DEFAULT_ATTACK_LOCK_DURATION_MS);
-			beginLocalPlayerAttackLock(engine, normalized.attack?.lockMovement === false ? 0 : lockDurationMs);
-			playLocalPlayerAttackAnimation(player, normalized);
-			showLocalAttackPreview(player, normalized);
-		} }
+	const isCurrentPlayer = computed(() => {
+		if (!object?.id) return false;
+		return (typeof object.id === "function" ? object.id() : object.id) === engine.playerId;
 	});
-};
-var client_default = createActionBattleClient();
+	const preview = computed(() => actionBattleAttackPreviewState());
+	const progress = computed(() => {
+		const state = preview();
+		if (!state.active) return 1;
+		const elapsed = now() - state.startedAt;
+		return Math.max(0, Math.min(1, elapsed / state.durationMs));
+	});
+	const shouldRender = computed(() => {
+		const state = preview();
+		return isCurrentPlayer() && state.active && progress() < 1;
+	});
+	const getHitbox = () => object.hitbox?.() || {
+		w: 32,
+		h: 32
+	};
+	const drawRect = (g, x, y, width, height, color, alpha) => {
+		g.rect(x, y, width, height);
+		g.fill({
+			color,
+			alpha
+		});
+	};
+	const drawSlash = (g) => {
+		g.clear();
+		if (!shouldRender()) return;
+		const state = preview();
+		const p = progress();
+		const alpha = Math.sin(Math.PI * p);
+		if (alpha <= 0) return;
+		const hitbox = getHitbox();
+		const width = hitbox.w || 32;
+		const height = hitbox.h || 32;
+		const reach = 16 + 18 * p;
+		const thickness = 4 + 3 * (1 - p);
+		const color = state.color;
+		const accent = state.accentColor;
+		if (state.direction === "left") {
+			drawRect(g, -reach - 6, height * .24, reach, thickness, accent, alpha * .55);
+			drawRect(g, -reach - 10, height * .46, reach + 4, thickness + 2, color, alpha);
+			drawRect(g, -reach - 6, height * .7, reach, thickness, accent, alpha * .4);
+			return;
+		}
+		if (state.direction === "right") {
+			drawRect(g, width + 6, height * .24, reach, thickness, accent, alpha * .55);
+			drawRect(g, width + 6, height * .46, reach + 4, thickness + 2, color, alpha);
+			drawRect(g, width + 6, height * .7, reach, thickness, accent, alpha * .4);
+			return;
+		}
+		if (state.direction === "up") {
+			drawRect(g, width * .24, -reach - 6, thickness, reach, accent, alpha * .55);
+			drawRect(g, width * .46, -reach - 10, thickness + 2, reach + 4, color, alpha);
+			drawRect(g, width * .7, -reach - 6, thickness, reach, accent, alpha * .4);
+			return;
+		}
+		drawRect(g, width * .24, height + 6, thickness, reach, accent, alpha * .55);
+		drawRect(g, width * .46, height + 6, thickness + 2, reach + 4, color, alpha);
+		drawRect(g, width * .7, height + 6, thickness, reach, accent, alpha * .4);
+	};
+	return h(Container, null, cond(shouldRender, () => h(Graphics, { draw: drawSlash })));
+}
 //#endregion
-export { createActionBattleClient, client_default as default };
+export { component as default };

package/dist/core/attack-profile.d.ts

@@ -0,0 +1,9 @@
+import { ActionBattleAttackHitboxMap, ActionBattleAttackProfile, NormalizedActionBattleAttackProfile } from '../types';
+export declare const DEFAULT_ACTION_BATTLE_ATTACK_PROFILE: NormalizedActionBattleAttackProfile;
+export interface ActionBattleAttackProfileFallbacks {
+    id?: string;
+    lockMovement?: boolean;
+    lockDurationMs?: number;
+    hitboxes?: ActionBattleAttackHitboxMap;
+}
+export declare function normalizeActionBattleAttackProfile(profile?: ActionBattleAttackProfile | undefined, fallbacks?: ActionBattleAttackProfileFallbacks): NormalizedActionBattleAttackProfile;

package/dist/core/attack-runtime.d.ts

@@ -0,0 +1,20 @@
+import { ActionBattleAttackHitPolicy, ActionBattleOptions, NormalizedActionBattleAttackProfile } from '../types';
+export declare const ACTION_BATTLE_HITBOX_FRAME_MS = 16;
+export declare function getNormalizedActionBattleAttackProfile(options?: ActionBattleOptions): NormalizedActionBattleAttackProfile;
+export declare function resolveActionBattleHitboxSpeed(profile: NormalizedActionBattleAttackProfile, hitboxCount: number): number;
+export declare function scheduleActionBattleStartup(profile: NormalizedActionBattleAttackProfile, callback: () => void, scheduler?: (callback: () => void, delayMs: number) => unknown): unknown;
+export declare function createActionBattleAttackId(attackerId: string | number | undefined, profileId: string): string;
+export declare class ActionBattleHitTracker {
+    private readonly hitPolicy;
+    private hitTargets;
+    constructor(hitPolicy: ActionBattleAttackHitPolicy);
+    canHit(target: {
+        id?: string | number;
+    } | undefined): boolean;
+    recordHit(target: {
+        id?: string | number;
+    } | undefined): void;
+    tryHit(target: {
+        id?: string | number;
+    } | undefined): boolean;
+}

package/dist/core/enemy-attack-profiles.d.ts

@@ -0,0 +1,6 @@
+import { ActionBattleAttackProfile, NormalizedActionBattleAttackProfile } from '../types';
+export type ActionBattleEnemyAttackProfileKey = "melee" | "combo" | "charged" | "zone" | "dashAttack";
+export declare const DEFAULT_ACTION_BATTLE_ENEMY_ATTACK_PROFILES: Record<ActionBattleEnemyAttackProfileKey, ActionBattleAttackProfile>;
+export type ActionBattleEnemyAttackProfileMap = Partial<Record<ActionBattleEnemyAttackProfileKey, ActionBattleAttackProfile>>;
+export type NormalizedActionBattleEnemyAttackProfileMap = Record<ActionBattleEnemyAttackProfileKey, NormalizedActionBattleAttackProfile>;
+export declare function normalizeActionBattleEnemyAttackProfiles(overrides?: ActionBattleEnemyAttackProfileMap): NormalizedActionBattleEnemyAttackProfileMap;

package/dist/core/equipment.d.ts

@@ -0,0 +1,2 @@
+import { ActionBattleAttackProfile } from '../types';
+export declare function resolveActionBattleWeaponAttackProfile(entity: any): ActionBattleAttackProfile | null;

package/dist/core/hit-reaction.d.ts

@@ -0,0 +1,5 @@
+import { ActionBattleHitReactionProfile, NormalizedActionBattleHitReactionProfile } from '../types';
+export declare const DEFAULT_ACTION_BATTLE_HIT_REACTION: NormalizedActionBattleHitReactionProfile;
+export declare function normalizeActionBattleHitReaction(reaction: ActionBattleHitReactionProfile | undefined, defaults?: NormalizedActionBattleHitReactionProfile): NormalizedActionBattleHitReactionProfile;
+export declare function isActionBattleEntityInvincible(entity: any, now?: number): boolean;
+export declare function setActionBattleInvincibility(entity: any, durationMs: number, now?: number): void;

package/dist/index.d.ts

@@ -1,8 +1,13 @@
 import { ActionBattleOptions } from './types';
 export { BattleAi, AiState, EnemyType, AttackPattern, AiDebug, DEFAULT_KNOCKBACK } from './ai.server';
 export type { HitResult, ApplyHitHooks, BattleAiOptions } from './ai.server';
-export type { ActionBattleAnimationContext, ActionBattleAnimationEntity, ActionBattleAnimationKey, ActionBattleAnimationOptions, ActionBattleAnimationResolver, ActionBattleAnimationResult, ActionBattleOptions, ActionBattleActionBarData, ActionBattleActionBarItem, ActionBattleActionBarSkill, ActionBattleSkillTargeting, ActionBattleSkillTargetingResolver, ActionBattleAttackOptions, ActionBattleUiOptions, ActionBattleUiActionBarOptions, ActionBattleUiTargetingOptions, ActionBattleCombatOptions, ActionBattleSystemOptions, ActionBattleAiSystemOptions, } from './types';
+export type { ActionBattleAnimationContext, ActionBattleAnimationEntity, ActionBattleAnimationKey, ActionBattleAnimationOptions, ActionBattleAnimationResolver, ActionBattleAnimationResult, ActionBattleOptions, ActionBattleActionBarData, ActionBattleActionBarItem, ActionBattleActionBarSkill, ActionBattleSkillTargeting, ActionBattleSkillTargetingResolver, ActionBattleAttackOptions, ActionBattleUiOptions, ActionBattleUiActionBarOptions, ActionBattleUiTargetingOptions, ActionBattleAttackDirection, ActionBattleAttackHitboxConfig, ActionBattleAttackHitboxMap, ActionBattleAttackHitPolicy, ActionBattleAttackProfile, ActionBattleDebugOptions, ActionBattleHitReactionProfile, NormalizedActionBattleHitReactionProfile, NormalizedActionBattleAttackProfile, ActionBattleCombatOptions, ActionBattleSystemOptions, ActionBattleAiSystemOptions, } from './types';
 export type { ActionBattleAiBehavior, ActionBattleAiContext, ActionBattleAiDecision, ActionBattleAttackContext, ActionBattleCombatSystem, ActionBattleDamageContext, ActionBattleDamageResult, ActionBattleDirection, ActionBattleEntity, ActionBattleHitContext, ActionBattleHitHooks, ActionBattleHitResult, ActionBattleHitbox, ActionBattleKnockbackContext, ActionBattleKnockbackResult, ActionBattleSystems, } from './core/contracts';
+export { DEFAULT_ACTION_BATTLE_ATTACK_PROFILE, normalizeActionBattleAttackProfile, type ActionBattleAttackProfileFallbacks, } from './core/attack-profile';
+export { ACTION_BATTLE_HITBOX_FRAME_MS, ActionBattleHitTracker, createActionBattleAttackId, getNormalizedActionBattleAttackProfile, resolveActionBattleHitboxSpeed, scheduleActionBattleStartup, } from './core/attack-runtime';
+export { DEFAULT_ACTION_BATTLE_HIT_REACTION, isActionBattleEntityInvincible, normalizeActionBattleHitReaction, setActionBattleInvincibility, } from './core/hit-reaction';
+export { DEFAULT_ACTION_BATTLE_ENEMY_ATTACK_PROFILES, normalizeActionBattleEnemyAttackProfiles, type ActionBattleEnemyAttackProfileKey, type ActionBattleEnemyAttackProfileMap, type NormalizedActionBattleEnemyAttackProfileMap, } from './core/enemy-attack-profiles';
+export { resolveActionBattleWeaponAttackProfile } from './core/equipment';
 export { DEFAULT_ZELDA_PLAYER_HITBOXES, createDefaultPlayerHitboxResolver, defaultCombatSystem, defaultEnemyBehaviors, defaultKnockbackResolver, defaultRpgjsDamageResolver, } from './core/defaults';
 export { createActionBattleSystems, getActionBattleSystems, } from './core/context';
 export { applyActionBattleHit } from './core/hit';

package/dist/server/index.js

@@ -1,9 +1,14 @@
-import { DEFAULT_ZELDA_PLAYER_HITBOXES, createDefaultPlayerHitboxResolver, defaultCombatSystem, defaultEnemyBehaviors, defaultKnockbackResolver, defaultRpgjsDamageResolver } from "./index4.js";
-import { createActionBattleSystems, getActionBattleSystems } from "./index5.js";
-import { AiDebug, AiState, AttackPattern, BattleAi, DEFAULT_KNOCKBACK, EnemyType } from "./index6.js";
-import { applyActionBattleHit } from "./index8.js";
-import server_default, { ACTION_BATTLE_ACTION_BAR_GUI_ID, DEFAULT_PLAYER_ATTACK_HITBOXES, applyPlayerHitToEvent, createActionBattleServer, getPlayerWeaponKnockbackForce, openActionBattleActionBar, updateActionBattleActionBar } from "./index9.js";
-import { createActionEnemy } from "./index10.js";
+import { DEFAULT_ACTION_BATTLE_HIT_REACTION, isActionBattleEntityInvincible, normalizeActionBattleHitReaction, setActionBattleInvincibility } from "./index3.js";
+import { DEFAULT_ACTION_BATTLE_ATTACK_PROFILE, normalizeActionBattleAttackProfile } from "./index4.js";
+import { DEFAULT_ZELDA_PLAYER_HITBOXES, createDefaultPlayerHitboxResolver, defaultCombatSystem, defaultEnemyBehaviors, defaultKnockbackResolver, defaultRpgjsDamageResolver } from "./index6.js";
+import { createActionBattleSystems, getActionBattleSystems } from "./index7.js";
+import { DEFAULT_ACTION_BATTLE_ENEMY_ATTACK_PROFILES, normalizeActionBattleEnemyAttackProfiles } from "./index8.js";
+import { ACTION_BATTLE_HITBOX_FRAME_MS, ActionBattleHitTracker, createActionBattleAttackId, getNormalizedActionBattleAttackProfile, resolveActionBattleHitboxSpeed, scheduleActionBattleStartup } from "./index9.js";
+import { AiDebug, AiState, AttackPattern, BattleAi, DEFAULT_KNOCKBACK, EnemyType } from "./index10.js";
+import { applyActionBattleHit } from "./index12.js";
+import { resolveActionBattleWeaponAttackProfile } from "./index13.js";
+import server_default, { ACTION_BATTLE_ACTION_BAR_GUI_ID, DEFAULT_PLAYER_ATTACK_HITBOXES, applyPlayerHitToEvent, createActionBattleServer, getPlayerWeaponKnockbackForce, openActionBattleActionBar, updateActionBattleActionBar } from "./index14.js";
+import { createActionEnemy } from "./index15.js";
 import { createModule } from "@rpgjs/common";
 //#region src/index.ts
 var client = null;
@@ -19,4 +24,4 @@ var src_default = {
 	client
 };
 //#endregion
-export { ACTION_BATTLE_ACTION_BAR_GUI_ID, AiDebug, AiState, AttackPattern, BattleAi, DEFAULT_KNOCKBACK, DEFAULT_PLAYER_ATTACK_HITBOXES, DEFAULT_ZELDA_PLAYER_HITBOXES, EnemyType, applyActionBattleHit, applyPlayerHitToEvent, createActionBattleServer, createActionBattleSystems, createActionEnemy, createDefaultPlayerHitboxResolver, src_default as default, defaultCombatSystem, defaultEnemyBehaviors, defaultKnockbackResolver, defaultRpgjsDamageResolver, getActionBattleSystems, getPlayerWeaponKnockbackForce, openActionBattleActionBar, provideActionBattle, updateActionBattleActionBar };
+export { ACTION_BATTLE_ACTION_BAR_GUI_ID, ACTION_BATTLE_HITBOX_FRAME_MS, ActionBattleHitTracker, AiDebug, AiState, AttackPattern, BattleAi, DEFAULT_ACTION_BATTLE_ATTACK_PROFILE, DEFAULT_ACTION_BATTLE_ENEMY_ATTACK_PROFILES, DEFAULT_ACTION_BATTLE_HIT_REACTION, DEFAULT_KNOCKBACK, DEFAULT_PLAYER_ATTACK_HITBOXES, DEFAULT_ZELDA_PLAYER_HITBOXES, EnemyType, applyActionBattleHit, applyPlayerHitToEvent, createActionBattleAttackId, createActionBattleServer, createActionBattleSystems, createActionEnemy, createDefaultPlayerHitboxResolver, src_default as default, defaultCombatSystem, defaultEnemyBehaviors, defaultKnockbackResolver, defaultRpgjsDamageResolver, getActionBattleSystems, getNormalizedActionBattleAttackProfile, getPlayerWeaponKnockbackForce, isActionBattleEntityInvincible, normalizeActionBattleAttackProfile, normalizeActionBattleEnemyAttackProfiles, normalizeActionBattleHitReaction, openActionBattleActionBar, provideActionBattle, resolveActionBattleHitboxSpeed, resolveActionBattleWeaponAttackProfile, scheduleActionBattleStartup, setActionBattleInvincibility, updateActionBattleActionBar };