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

package/dist/client/index9.js

@@ -1,30 +1,79 @@
-const normalizeMaskRows = (mask) => {
-  if (!mask) return ["#"];
-  if (Array.isArray(mask)) return mask;
-  return mask.trim().split("\n").map((row) => row.replace(/\r/g, ""));
-};
-const parseAoeMask = (mask) => {
-  const rows = normalizeMaskRows(mask);
-  const height = rows.length;
-  const width = rows.reduce((max, row) => Math.max(max, row.length), 0);
-  const centerX = Math.floor(width / 2);
-  const centerY = Math.floor(height / 2);
-  const cells = [];
-  rows.forEach((row, y) => {
-    for (let x = 0; x < row.length; x++) {
-      const char = row[x];
-      if (char && char !== "." && char !== " ") {
-        cells.push({ dx: x - centerX, dy: y - centerY });
-      }
-    }
-  });
-  if (cells.length === 0) {
-    cells.push({ dx: 0, dy: 0 });
-  }
-  return { width, height, centerX, centerY, cells };
-};
-const manhattanDistance = (a, b) => Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
-export {
-  manhattanDistance,
-  parseAoeMask
-};
+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());
+	});
+	const isCurrentPlayer = computed(() => {
+		if (!object?.id) return false;
+		return (typeof object.id === "function" ? object.id() : object.id) === engine.playerId;
+	});
+	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 })));
+}
+var __ce_component = component;
+//#endregion
+export { __ce_component as default };

package/dist/{server.d.ts → client/server.d.ts}

@@ -1,4 +1,4 @@
-import { RpgEvent, RpgPlayer } from '@rpgjs/server';
+import { RpgEvent, RpgPlayer, RpgServer } from '@rpgjs/server';
 import { HitResult, ApplyHitHooks } from './ai.server';
 import { ActionBattleOptions } from './types';
 export declare const ACTION_BATTLE_ACTION_BAR_GUI_ID = "action-battle-action-bar";
@@ -90,9 +90,17 @@ export declare function getPlayerWeaponKnockbackForce(player: RpgPlayer): number
  * });
  * ```
  */
-export declare function applyPlayerHitToEvent(player: RpgPlayer, target: RpgEvent, hooks?: ApplyHitHooks): HitResult | undefined;
+export declare function applyPlayerHitToEvent(player: RpgPlayer, target: RpgEvent, hooks?: ApplyHitHooks, metadata?: Record<string, any>): HitResult | undefined;
 export declare const openActionBattleActionBar: (player: RpgPlayer, rawOptions?: ActionBattleOptions) => void;
 export declare const updateActionBattleActionBar: (player: RpgPlayer, rawOptions?: ActionBattleOptions) => void;
-export declare const createActionBattleServer: (rawOptions?: ActionBattleOptions) => any;
-declare const _default: any;
+export declare const createActionBattleServer: (rawOptions?: ActionBattleOptions) => RpgServer;
+declare const _default: RpgServer;
 export default _default;
+export { ACTION_BATTLE_HITBOX_FRAME_MS, ActionBattleHitTracker, createActionBattleAttackId, getNormalizedActionBattleAttackProfile, resolveActionBattleHitboxSpeed, scheduleActionBattleStartup, } from './core/attack-runtime';
+export { DEFAULT_ACTION_BATTLE_ATTACK_PROFILE, normalizeActionBattleAttackProfile, type ActionBattleAttackProfileFallbacks, } from './core/attack-profile';
+export type { ActionBattleAttackDirection, ActionBattleAttackHitboxConfig, ActionBattleAttackHitboxMap, ActionBattleAttackHitPolicy, ActionBattleAttackProfile, ActionBattleDebugOptions, ActionBattleHitReactionProfile, NormalizedActionBattleHitReactionProfile, NormalizedActionBattleAttackProfile, } from './types';
+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 { AiDebug, AiState, AttackPattern, BattleAi, DEFAULT_KNOCKBACK, EnemyType, } from './ai.server';
+export type { ApplyHitHooks, BattleAiDefeatedCallback, BattleAiDefeatedContext, BattleAiDefeatReward, BattleAiLegacyDefeatedCallback, BattleAiLegacyOptions, BattleAiOptions, BattleAiRewardItem, BattleAiRewards, HitResult, } from './ai.server';

package/dist/client/ui/state.d.ts

@@ -0,0 +1,35 @@
+import { ActionBattleActionBarSkill, ActionBattleOptions } from '../types';
+export interface ActionBattleAttackPreviewState {
+    active: boolean;
+    id: number;
+    direction: string;
+    startedAt: number;
+    durationMs: number;
+    color: number;
+    accentColor: number;
+}
+export interface ActionBattleTargetingState {
+    active: boolean;
+    skill: ActionBattleActionBarSkill | null;
+    range: number;
+    offset: {
+        x: number;
+        y: number;
+    };
+    aoeMask: string[] | string;
+}
+export declare const actionBattleUiOptions: import('canvasengine').WritableObjectSignal<import('..').ActionBattleUiOptions>;
+export declare const actionBattleSkillOptions: import('canvasengine').WritableObjectSignal<import('../types').ActionBattleSkillOptions>;
+export declare const actionBattleTargetingState: import('canvasengine').WritableObjectSignal<ActionBattleTargetingState>;
+export declare const actionBattleAttackPreviewState: import('canvasengine').WritableObjectSignal<ActionBattleAttackPreviewState>;
+export declare const setActionBattleOptions: (options?: ActionBattleOptions) => void;
+export declare const startTargeting: (skill: ActionBattleActionBarSkill) => void;
+export declare const stopTargeting: () => void;
+export declare const moveTargetingOffset: (dx: number, dy: number) => void;
+export declare const startAttackPreview: (options: {
+    direction: string;
+    durationMs?: number;
+    color?: number;
+    accentColor?: number;
+}) => number;
+export declare const stopAttackPreview: (id?: number) => void;