blacktrigram 0.7.2

package/lib/hooks/useMatchCountdown.js

@@ -0,0 +1,162 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+//#region src/hooks/useMatchCountdown.ts
+/**
+* useMatchCountdown Hook - Manages match start countdown sequence
+*
+* Korean: 매치 시작 카운트다운 훅 (Match Start Countdown Hook)
+*
+* Handles the state machine for match start countdown:
+* - idle: Waiting to start
+* - ready: Showing "Ready?" message
+* - counting: Counting down "3... 2... 1..."
+* - fight: Showing "Fight!" announcement
+* - complete: Countdown finished, combat can begin
+*
+* @module hooks/useMatchCountdown
+* @category Combat Hooks
+*/
+/**
+* Default configuration values
+*/
+var DEFAULT_CONFIG = {
+	readyDuration: 1,
+	countdownInterval: 1,
+	fightDuration: 1,
+	startNumber: 3
+};
+/**
+* useMatchCountdown Hook
+*
+* Manages the complete match start countdown flow:
+* 1. Idle state waiting for match start
+* 2. Ready state shows "Ready?" message (1s)
+* 3. Counting state counts down from 3 to 1 (1s intervals)
+* 4. Fight state shows "Fight!" message (1s)
+* 5. Complete state signals combat can begin
+*
+* @param config - Configuration for countdown timings
+* @param onComplete - Callback when countdown completes
+* @returns Match countdown state and control functions
+*
+* @example
+* ```typescript
+* const {
+*   state,
+*   currentNumber,
+*   startCountdown,
+*   skipCountdown,
+* } = useMatchCountdown(
+*   { startNumber: 3 },
+*   () => {
+*     // Enable combat inputs
+*     enableCombatControls();
+*   }
+* );
+*
+* // When match initializes
+* startCountdown();
+* ```
+*/
+function useMatchCountdown(config = {}, onComplete) {
+	const mergedConfig = useMemo(() => ({
+		readyDuration: config.readyDuration ?? DEFAULT_CONFIG.readyDuration,
+		countdownInterval: config.countdownInterval ?? DEFAULT_CONFIG.countdownInterval,
+		fightDuration: config.fightDuration ?? DEFAULT_CONFIG.fightDuration,
+		startNumber: config.startNumber ?? DEFAULT_CONFIG.startNumber
+	}), [
+		config.readyDuration,
+		config.countdownInterval,
+		config.fightDuration,
+		config.startNumber
+	]);
+	const [state, setState] = useState("idle");
+	const [currentNumber, setCurrentNumber] = useState(mergedConfig.startNumber);
+	const readyTimer = useRef(null);
+	const countdownTimer = useRef(null);
+	const fightTimer = useRef(null);
+	const onCompleteRef = useRef(onComplete);
+	useEffect(() => {
+		onCompleteRef.current = onComplete;
+	}, [onComplete]);
+	/**
+	* Clear all active timers
+	*/
+	const clearTimers = useCallback(() => {
+		if (readyTimer.current) {
+			clearTimeout(readyTimer.current);
+			readyTimer.current = null;
+		}
+		if (countdownTimer.current) {
+			clearInterval(countdownTimer.current);
+			countdownTimer.current = null;
+		}
+		if (fightTimer.current) {
+			clearTimeout(fightTimer.current);
+			fightTimer.current = null;
+		}
+	}, []);
+	/**
+	* Start the countdown sequence
+	*/
+	const startCountdown = useCallback(() => {
+		clearTimers();
+		setState("ready");
+		setCurrentNumber(mergedConfig.startNumber);
+		readyTimer.current = setTimeout(() => {
+			setState("counting");
+			setCurrentNumber(mergedConfig.startNumber);
+			let count = mergedConfig.startNumber;
+			countdownTimer.current = setInterval(() => {
+				count -= 1;
+				setCurrentNumber(count);
+				if (count <= 0) {
+					if (countdownTimer.current) {
+						clearInterval(countdownTimer.current);
+						countdownTimer.current = null;
+					}
+					setState("fight");
+					fightTimer.current = setTimeout(() => {
+						setState("complete");
+						onCompleteRef.current?.();
+					}, mergedConfig.fightDuration * 1e3);
+				}
+			}, mergedConfig.countdownInterval * 1e3);
+		}, mergedConfig.readyDuration * 1e3);
+	}, [clearTimers, mergedConfig]);
+	/**
+	* Skip countdown and proceed immediately to fight state
+	*/
+	const skipCountdown = useCallback(() => {
+		clearTimers();
+		setState("complete");
+		onCompleteRef.current?.();
+	}, [clearTimers]);
+	/**
+	* Reset countdown to idle state
+	*/
+	const resetCountdown = useCallback(() => {
+		clearTimers();
+		setState("idle");
+		setCurrentNumber(mergedConfig.startNumber);
+	}, [clearTimers, mergedConfig.startNumber]);
+	/**
+	* Cleanup on unmount
+	*/
+	useEffect(() => {
+		return () => {
+			clearTimers();
+		};
+	}, [clearTimers]);
+	return {
+		state,
+		currentNumber,
+		startCountdown,
+		skipCountdown,
+		resetCountdown,
+		isActive: state !== "idle" && state !== "complete"
+	};
+}
+//#endregion
+export { useMatchCountdown as default };
+
+//# sourceMappingURL=useMatchCountdown.js.map

package/lib/hooks/useMatchCountdown.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMatchCountdown.js","names":[],"sources":["../../src/hooks/useMatchCountdown.ts"],"sourcesContent":["/**\n * useMatchCountdown Hook - Manages match start countdown sequence\n *\n * Korean: 매치 시작 카운트다운 훅 (Match Start Countdown Hook)\n *\n * Handles the state machine for match start countdown:\n * - idle: Waiting to start\n * - ready: Showing \"Ready?\" message\n * - counting: Counting down \"3... 2... 1...\"\n * - fight: Showing \"Fight!\" announcement\n * - complete: Countdown finished, combat can begin\n *\n * @module hooks/useMatchCountdown\n * @category Combat Hooks\n */\n\nimport { useCallback, useEffect, useMemo, useRef, useState } from \"react\";\n\n/**\n * Match countdown states\n *\n * Korean: 매치 카운트다운 상태\n */\nexport type MatchCountdownState =\n  | \"idle\"\n  | \"ready\"\n  | \"counting\"\n  | \"fight\"\n  | \"complete\";\n\n/**\n * Match countdown configuration\n */\nexport interface MatchCountdownConfig {\n  /** Duration of \"Ready?\" display in seconds */\n  readonly readyDuration?: number;\n  /** Duration of each countdown number in seconds */\n  readonly countdownInterval?: number;\n  /** Duration of \"Fight!\" display in seconds */\n  readonly fightDuration?: number;\n  /** Starting countdown number */\n  readonly startNumber?: number;\n}\n\n/**\n * Match countdown hook state\n */\nexport interface UseMatchCountdownResult {\n  /** Current countdown state */\n  readonly state: MatchCountdownState;\n  /** Current countdown number (3, 2, 1, or 0) */\n  readonly currentNumber: number;\n  /** Start countdown sequence */\n  readonly startCountdown: () => void;\n  /** Skip countdown and proceed immediately */\n  readonly skipCountdown: () => void;\n  /** Reset countdown to idle state */\n  readonly resetCountdown: () => void;\n  /** Whether countdown is in progress */\n  readonly isActive: boolean;\n}\n\n/**\n * Default configuration values\n */\nconst DEFAULT_CONFIG: Required<MatchCountdownConfig> = {\n  readyDuration: 1,\n  countdownInterval: 1,\n  fightDuration: 1,\n  startNumber: 3,\n};\n\n/**\n * useMatchCountdown Hook\n *\n * Manages the complete match start countdown flow:\n * 1. Idle state waiting for match start\n * 2. Ready state shows \"Ready?\" message (1s)\n * 3. Counting state counts down from 3 to 1 (1s intervals)\n * 4. Fight state shows \"Fight!\" message (1s)\n * 5. Complete state signals combat can begin\n *\n * @param config - Configuration for countdown timings\n * @param onComplete - Callback when countdown completes\n * @returns Match countdown state and control functions\n *\n * @example\n * ```typescript\n * const {\n *   state,\n *   currentNumber,\n *   startCountdown,\n *   skipCountdown,\n * } = useMatchCountdown(\n *   { startNumber: 3 },\n *   () => {\n *     // Enable combat inputs\n *     enableCombatControls();\n *   }\n * );\n *\n * // When match initializes\n * startCountdown();\n * ```\n */\nexport function useMatchCountdown(\n  config: MatchCountdownConfig = {},\n  onComplete?: () => void\n): UseMatchCountdownResult {\n  // Memoize with individual config values to avoid reference equality issues\n  const mergedConfig = useMemo(\n    () => ({\n      readyDuration: config.readyDuration ?? DEFAULT_CONFIG.readyDuration,\n      countdownInterval:\n        config.countdownInterval ?? DEFAULT_CONFIG.countdownInterval,\n      fightDuration: config.fightDuration ?? DEFAULT_CONFIG.fightDuration,\n      startNumber: config.startNumber ?? DEFAULT_CONFIG.startNumber,\n    }),\n    [\n      config.readyDuration,\n      config.countdownInterval,\n      config.fightDuration,\n      config.startNumber,\n    ]\n  );\n\n  const [state, setState] = useState<MatchCountdownState>(\"idle\");\n  const [currentNumber, setCurrentNumber] = useState(mergedConfig.startNumber);\n\n  // Use refs to track active timers\n  const readyTimer = useRef<ReturnType<typeof setTimeout> | null>(null);\n  const countdownTimer = useRef<ReturnType<typeof setInterval> | null>(null);\n  const fightTimer = useRef<ReturnType<typeof setTimeout> | null>(null);\n\n  // Use ref to always call the latest callback\n  const onCompleteRef = useRef(onComplete);\n  useEffect(() => {\n    onCompleteRef.current = onComplete;\n  }, [onComplete]);\n\n  /**\n   * Clear all active timers\n   */\n  const clearTimers = useCallback(() => {\n    if (readyTimer.current) {\n      clearTimeout(readyTimer.current);\n      readyTimer.current = null;\n    }\n    if (countdownTimer.current) {\n      clearInterval(countdownTimer.current);\n      countdownTimer.current = null;\n    }\n    if (fightTimer.current) {\n      clearTimeout(fightTimer.current);\n      fightTimer.current = null;\n    }\n  }, []);\n\n  /**\n   * Start the countdown sequence\n   */\n  const startCountdown = useCallback(() => {\n    clearTimers();\n    setState(\"ready\");\n    setCurrentNumber(mergedConfig.startNumber);\n\n    // Show \"Ready?\" message\n    readyTimer.current = setTimeout(() => {\n      setState(\"counting\");\n      setCurrentNumber(mergedConfig.startNumber);\n\n      // Countdown timer\n      let count = mergedConfig.startNumber;\n      countdownTimer.current = setInterval(() => {\n        count -= 1;\n        setCurrentNumber(count);\n\n        if (count <= 0) {\n          if (countdownTimer.current) {\n            clearInterval(countdownTimer.current);\n            countdownTimer.current = null;\n          }\n\n          // Show \"Fight!\" message\n          setState(\"fight\");\n\n          fightTimer.current = setTimeout(() => {\n            setState(\"complete\");\n            onCompleteRef.current?.();\n          }, mergedConfig.fightDuration * 1000);\n        }\n      }, mergedConfig.countdownInterval * 1000);\n    }, mergedConfig.readyDuration * 1000);\n  }, [clearTimers, mergedConfig]);\n\n  /**\n   * Skip countdown and proceed immediately to fight state\n   */\n  const skipCountdown = useCallback(() => {\n    clearTimers();\n    setState(\"complete\");\n    onCompleteRef.current?.();\n  }, [clearTimers]);\n\n  /**\n   * Reset countdown to idle state\n   */\n  const resetCountdown = useCallback(() => {\n    clearTimers();\n    setState(\"idle\");\n    setCurrentNumber(mergedConfig.startNumber);\n  }, [clearTimers, mergedConfig.startNumber]);\n\n  /**\n   * Cleanup on unmount\n   */\n  useEffect(() => {\n    return () => {\n      clearTimers();\n    };\n  }, [clearTimers]);\n\n  return {\n    state,\n    currentNumber,\n    startCountdown,\n    skipCountdown,\n    resetCountdown,\n    isActive: state !== \"idle\" && state !== \"complete\",\n  };\n}\n\nexport default useMatchCountdown;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAiEA,IAAM,iBAAiD;CACrD,eAAe;CACf,mBAAmB;CACnB,eAAe;CACf,aAAa;CACd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCD,SAAgB,kBACd,SAA+B,EAAE,EACjC,YACyB;CAEzB,MAAM,eAAe,eACZ;EACL,eAAe,OAAO,iBAAiB,eAAe;EACtD,mBACE,OAAO,qBAAqB,eAAe;EAC7C,eAAe,OAAO,iBAAiB,eAAe;EACtD,aAAa,OAAO,eAAe,eAAe;EACnD,GACD;EACE,OAAO;EACP,OAAO;EACP,OAAO;EACP,OAAO;EACR,CACF;CAED,MAAM,CAAC,OAAO,YAAY,SAA8B,OAAO;CAC/D,MAAM,CAAC,eAAe,oBAAoB,SAAS,aAAa,YAAY;CAG5E,MAAM,aAAa,OAA6C,KAAK;CACrE,MAAM,iBAAiB,OAA8C,KAAK;CAC1E,MAAM,aAAa,OAA6C,KAAK;CAGrE,MAAM,gBAAgB,OAAO,WAAW;AACxC,iBAAgB;AACd,gBAAc,UAAU;IACvB,CAAC,WAAW,CAAC;;;;CAKhB,MAAM,cAAc,kBAAkB;AACpC,MAAI,WAAW,SAAS;AACtB,gBAAa,WAAW,QAAQ;AAChC,cAAW,UAAU;;AAEvB,MAAI,eAAe,SAAS;AAC1B,iBAAc,eAAe,QAAQ;AACrC,kBAAe,UAAU;;AAE3B,MAAI,WAAW,SAAS;AACtB,gBAAa,WAAW,QAAQ;AAChC,cAAW,UAAU;;IAEtB,EAAE,CAAC;;;;CAKN,MAAM,iBAAiB,kBAAkB;AACvC,eAAa;AACb,WAAS,QAAQ;AACjB,mBAAiB,aAAa,YAAY;AAG1C,aAAW,UAAU,iBAAiB;AACpC,YAAS,WAAW;AACpB,oBAAiB,aAAa,YAAY;GAG1C,IAAI,QAAQ,aAAa;AACzB,kBAAe,UAAU,kBAAkB;AACzC,aAAS;AACT,qBAAiB,MAAM;AAEvB,QAAI,SAAS,GAAG;AACd,SAAI,eAAe,SAAS;AAC1B,oBAAc,eAAe,QAAQ;AACrC,qBAAe,UAAU;;AAI3B,cAAS,QAAQ;AAEjB,gBAAW,UAAU,iBAAiB;AACpC,eAAS,WAAW;AACpB,oBAAc,WAAW;QACxB,aAAa,gBAAgB,IAAK;;MAEtC,aAAa,oBAAoB,IAAK;KACxC,aAAa,gBAAgB,IAAK;IACpC,CAAC,aAAa,aAAa,CAAC;;;;CAK/B,MAAM,gBAAgB,kBAAkB;AACtC,eAAa;AACb,WAAS,WAAW;AACpB,gBAAc,WAAW;IACxB,CAAC,YAAY,CAAC;;;;CAKjB,MAAM,iBAAiB,kBAAkB;AACvC,eAAa;AACb,WAAS,OAAO;AAChB,mBAAiB,aAAa,YAAY;IACzC,CAAC,aAAa,aAAa,YAAY,CAAC;;;;AAK3C,iBAAgB;AACd,eAAa;AACX,gBAAa;;IAEd,CAAC,YAAY,CAAC;AAEjB,QAAO;EACL;EACA;EACA;EACA;EACA;EACA,UAAU,UAAU,UAAU,UAAU;EACzC"}

package/lib/hooks/useMuscleActivation.d.ts

@@ -0,0 +1,76 @@
+/**
+ * useMuscleActivation - Shared hook for muscle activation management
+ *
+ * Manages muscle activation state based on current actions and stamina.
+ * Reduces code duplication in skeletal animation components.
+ * Includes stance-based leg muscle tension for isometric holds.
+ *
+ * @module hooks/useMuscleActivation
+ * @category Hooks
+ * @korean 근육활성화훅
+ */
+import type { TrigramStance } from "../types/common";
+import type { PlayerAnimation } from "../types/player-visual";
+/**
+ * Options for useMuscleActivation hook
+ * @korean 근육활성화훅옵션
+ */
+export interface UseMuscleActivationOptions {
+    /** Current animation name */
+    readonly currentAnimation: PlayerAnimation;
+    /** Specific attack animation name (for attack state) */
+    readonly attackAnimation?: string;
+    /** Whether player is blocking */
+    readonly isBlocking?: boolean;
+    /** Current stamina level (0-100) */
+    readonly stamina: number;
+    /** Current trigram stance (for leg muscle tension) */
+    readonly currentStance?: TrigramStance;
+}
+/**
+ * Return type for useMuscleActivation hook
+ * @korean 근육활성화훅반환타입
+ */
+export interface UseMuscleActivationReturn {
+    /** Current muscle activation states (bone name -> activation 0-1) */
+    readonly muscleStates: Map<string, number>;
+    /** Update muscle activations (call in useFrame) */
+    readonly updateMuscleActivations: (delta: number, frameCounter: number) => void;
+}
+/**
+ * useMuscleActivation hook
+ *
+ * Manages muscle activation based on current actions (attack, defend, movement).
+ * Updates at 60fps with periodic state syncs to reduce re-renders.
+ *
+ * @param options - Muscle activation options
+ * @returns Muscle states and update function
+ *
+ * @example
+ * ```tsx
+ * const { muscleStates, updateMuscleActivations } = useMuscleActivation({
+ *   currentAnimation: "attack",
+ *   attackAnimation: "jab",
+ *   isBlocking: false,
+ *   stamina: 85,
+ * });
+ *
+ * // In useFrame callback
+ * let frameCounter = 0;
+ * useFrame((_, delta) => {
+ *   frameCounter = (frameCounter + 1) % 10;
+ *   updateMuscleActivations(delta, frameCounter);
+ * });
+ *
+ * // Use muscle states in rendering
+ * <BoneRenderer
+ *   rig={rig}
+ *   muscleStates={muscleStates}
+ *   isExhausted={stamina < 20}
+ * />
+ * ```
+ *
+ * @korean 근육활성화훅
+ */
+export declare function useMuscleActivation(options: UseMuscleActivationOptions): UseMuscleActivationReturn;
+//# sourceMappingURL=useMuscleActivation.d.ts.map

package/lib/hooks/useMuscleActivation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMuscleActivation.d.ts","sourceRoot":"","sources":["../../src/hooks/useMuscleActivation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAOH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAU9D;;;GAGG;AACH,MAAM,WAAW,0BAA0B;IACzC,6BAA6B;IAC7B,QAAQ,CAAC,gBAAgB,EAAE,eAAe,CAAC;IAC3C,wDAAwD;IACxD,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,iCAAiC;IACjC,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,oCAAoC;IACpC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,sDAAsD;IACtD,QAAQ,CAAC,aAAa,CAAC,EAAE,aAAa,CAAC;CACxC;AAED;;;GAGG;AACH,MAAM,WAAW,yBAAyB;IACxC,qEAAqE;IACrE,QAAQ,CAAC,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC3C,mDAAmD;IACnD,QAAQ,CAAC,uBAAuB,EAAE,CAChC,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,MAAM,KACjB,IAAI,CAAC;CACX;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,0BAA0B,GAClC,yBAAyB,CA0F3B"}

package/lib/hooks/useMuscleActivation.js

@@ -0,0 +1,99 @@
+import { MuscleActivationManager, getMuscleTensionForStance } from "../systems/animation/systems/MuscleActivation.js";
+import "../systems/animation/index.js";
+import { DEFAULT_MUSCLE_CONFIG } from "../types/muscle.js";
+import { useEffect, useMemo, useRef, useState } from "react";
+//#region src/hooks/useMuscleActivation.ts
+/**
+* useMuscleActivation - Shared hook for muscle activation management
+*
+* Manages muscle activation state based on current actions and stamina.
+* Reduces code duplication in skeletal animation components.
+* Includes stance-based leg muscle tension for isometric holds.
+*
+* @module hooks/useMuscleActivation
+* @category Hooks
+* @korean 근육활성화훅
+*/
+/**
+* Simple lerp function for muscle tension interpolation
+* Defined at module level to avoid recreation
+* @korean 선형보간함수
+*/
+var lerp = (start, end, t) => start + (end - start) * t;
+/**
+* useMuscleActivation hook
+*
+* Manages muscle activation based on current actions (attack, defend, movement).
+* Updates at 60fps with periodic state syncs to reduce re-renders.
+*
+* @param options - Muscle activation options
+* @returns Muscle states and update function
+*
+* @example
+* ```tsx
+* const { muscleStates, updateMuscleActivations } = useMuscleActivation({
+*   currentAnimation: "attack",
+*   attackAnimation: "jab",
+*   isBlocking: false,
+*   stamina: 85,
+* });
+*
+* // In useFrame callback
+* let frameCounter = 0;
+* useFrame((_, delta) => {
+*   frameCounter = (frameCounter + 1) % 10;
+*   updateMuscleActivations(delta, frameCounter);
+* });
+*
+* // Use muscle states in rendering
+* <BoneRenderer
+*   rig={rig}
+*   muscleStates={muscleStates}
+*   isExhausted={stamina < 20}
+* />
+* ```
+*
+* @korean 근육활성화훅
+*/
+function useMuscleActivation(options) {
+	const { currentAnimation, attackAnimation, isBlocking = false, stamina, currentStance } = options;
+	const muscleManager = useRef(new MuscleActivationManager());
+	const [muscleStates, setMuscleStates] = useState(/* @__PURE__ */ new Map());
+	useEffect(() => {
+		const manager = muscleManager.current;
+		return () => {
+			try {
+				manager.reset();
+			} catch (error) {
+				console.warn("MuscleActivationManager reset failed:", error);
+			}
+		};
+	}, []);
+	const stanceTension = useMemo(() => {
+		return currentStance ? getMuscleTensionForStance(currentStance) : null;
+	}, [currentStance]);
+	const updateMuscleActivations = (delta, frameCounter) => {
+		if (currentAnimation === "attack" && attackAnimation) muscleManager.current.update(attackAnimation, stamina, delta);
+		else if (currentAnimation === "defend" || isBlocking) muscleManager.current.update("block", stamina, delta);
+		else if (currentAnimation === "walk" || currentAnimation === "stance_change") muscleManager.current.update("stance_change", stamina, delta);
+		else if (currentAnimation === "idle" && stanceTension) {
+			const allActivations = muscleManager.current.getAllActivations();
+			stanceTension.forEach((tension, muscleGroup) => {
+				const state = allActivations.get(muscleGroup);
+				if (state) {
+					state.targetTension = tension;
+					state.tension = lerp(state.tension, state.targetTension, DEFAULT_MUSCLE_CONFIG.activationSpeed * delta);
+				}
+			});
+		} else muscleManager.current.relaxAllMuscles(delta);
+		if (frameCounter === 0) setMuscleStates(muscleManager.current.getScratchMapForSync());
+	};
+	return {
+		muscleStates,
+		updateMuscleActivations
+	};
+}
+//#endregion
+export { useMuscleActivation };
+
+//# sourceMappingURL=useMuscleActivation.js.map

package/lib/hooks/useMuscleActivation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMuscleActivation.js","names":[],"sources":["../../src/hooks/useMuscleActivation.ts"],"sourcesContent":["/**\n * useMuscleActivation - Shared hook for muscle activation management\n *\n * Manages muscle activation state based on current actions and stamina.\n * Reduces code duplication in skeletal animation components.\n * Includes stance-based leg muscle tension for isometric holds.\n *\n * @module hooks/useMuscleActivation\n * @category Hooks\n * @korean 근육활성화훅\n */\n\nimport { useEffect, useMemo, useRef, useState } from \"react\";\nimport {\n  MuscleActivationManager,\n  getMuscleTensionForStance,\n} from \"../systems/animation\";\nimport type { TrigramStance } from \"../types/common\";\nimport { DEFAULT_MUSCLE_CONFIG } from \"../types/muscle\";\nimport type { PlayerAnimation } from \"../types/player-visual\";\n\n/**\n * Simple lerp function for muscle tension interpolation\n * Defined at module level to avoid recreation\n * @korean 선형보간함수\n */\nconst lerp = (start: number, end: number, t: number): number =>\n  start + (end - start) * t;\n\n/**\n * Options for useMuscleActivation hook\n * @korean 근육활성화훅옵션\n */\nexport interface UseMuscleActivationOptions {\n  /** Current animation name */\n  readonly currentAnimation: PlayerAnimation;\n  /** Specific attack animation name (for attack state) */\n  readonly attackAnimation?: string;\n  /** Whether player is blocking */\n  readonly isBlocking?: boolean;\n  /** Current stamina level (0-100) */\n  readonly stamina: number;\n  /** Current trigram stance (for leg muscle tension) */\n  readonly currentStance?: TrigramStance;\n}\n\n/**\n * Return type for useMuscleActivation hook\n * @korean 근육활성화훅반환타입\n */\nexport interface UseMuscleActivationReturn {\n  /** Current muscle activation states (bone name -> activation 0-1) */\n  readonly muscleStates: Map<string, number>;\n  /** Update muscle activations (call in useFrame) */\n  readonly updateMuscleActivations: (\n    delta: number,\n    frameCounter: number\n  ) => void;\n}\n\n/**\n * useMuscleActivation hook\n *\n * Manages muscle activation based on current actions (attack, defend, movement).\n * Updates at 60fps with periodic state syncs to reduce re-renders.\n *\n * @param options - Muscle activation options\n * @returns Muscle states and update function\n *\n * @example\n * ```tsx\n * const { muscleStates, updateMuscleActivations } = useMuscleActivation({\n *   currentAnimation: \"attack\",\n *   attackAnimation: \"jab\",\n *   isBlocking: false,\n *   stamina: 85,\n * });\n *\n * // In useFrame callback\n * let frameCounter = 0;\n * useFrame((_, delta) => {\n *   frameCounter = (frameCounter + 1) % 10;\n *   updateMuscleActivations(delta, frameCounter);\n * });\n *\n * // Use muscle states in rendering\n * <BoneRenderer\n *   rig={rig}\n *   muscleStates={muscleStates}\n *   isExhausted={stamina < 20}\n * />\n * ```\n *\n * @korean 근육활성화훅\n */\nexport function useMuscleActivation(\n  options: UseMuscleActivationOptions\n): UseMuscleActivationReturn {\n  const {\n    currentAnimation,\n    attackAnimation,\n    isBlocking = false,\n    stamina,\n    currentStance,\n  } = options;\n\n  // Muscle activation manager\n  const muscleManager = useRef(new MuscleActivationManager());\n  const [muscleStates, setMuscleStates] = useState<Map<string, number>>(\n    new Map()\n  );\n\n  // Cleanup muscle manager on unmount\n  useEffect(() => {\n    const manager = muscleManager.current;\n    return () => {\n      try {\n        manager.reset();\n      } catch (error) {\n        console.warn(\"MuscleActivationManager reset failed:\", error);\n      }\n    };\n  }, []);\n\n  // Memoize stance tension to avoid recalculation at 60fps\n  const stanceTension = useMemo(() => {\n    return currentStance ? getMuscleTensionForStance(currentStance) : null;\n  }, [currentStance]);\n\n  // Update muscle activations (called at 60fps in useFrame)\n  const updateMuscleActivations = (\n    delta: number,\n    frameCounter: number\n  ): void => {\n    // Update muscle system based on current action\n    if (currentAnimation === \"attack\" && attackAnimation) {\n      muscleManager.current.update(attackAnimation, stamina, delta);\n    } else if (currentAnimation === \"defend\" || isBlocking) {\n      muscleManager.current.update(\"block\", stamina, delta);\n    } else if (\n      currentAnimation === \"walk\" ||\n      currentAnimation === \"stance_change\"\n    ) {\n      // Engage stance/leg/core muscles during movement and stance changes\n      muscleManager.current.update(\"stance_change\", stamina, delta);\n    } else if (currentAnimation === \"idle\" && stanceTension) {\n      // Apply stance-based leg muscle tension for idle/guard positions\n      // This provides realistic isometric contraction visualization\n\n      // Get all activation states once (not in the loop)\n      const allActivations = muscleManager.current.getAllActivations();\n\n      // Update manager with stance muscle activations\n      stanceTension.forEach((tension, muscleGroup) => {\n        // Get existing activation state\n        const state = allActivations.get(muscleGroup);\n\n        if (state) {\n          // Set target tension for smooth interpolation\n          state.targetTension = tension;\n\n          // Smoothly interpolate to target (using config activation speed)\n          state.tension = lerp(\n            state.tension,\n            state.targetTension,\n            DEFAULT_MUSCLE_CONFIG.activationSpeed * delta\n          );\n        }\n      });\n    } else {\n      muscleManager.current.relaxAllMuscles(delta);\n    }\n\n    // Sync muscle states to React state deterministically\n    // (every 10 frames at 60fps = ~6 times/sec)\n    // Balances animation smoothness with performance and reduces GC pressure\n    if (frameCounter === 0) {\n      // Reuse scratch map from manager to avoid repeated allocations\n      const scratchMap = muscleManager.current.getScratchMapForSync();\n      setMuscleStates(scratchMap);\n    }\n  };\n\n  return {\n    muscleStates,\n    updateMuscleActivations,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AA0BA,IAAM,QAAQ,OAAe,KAAa,MACxC,SAAS,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoE1B,SAAgB,oBACd,SAC2B;CAC3B,MAAM,EACJ,kBACA,iBACA,aAAa,OACb,SACA,kBACE;CAGJ,MAAM,gBAAgB,OAAO,IAAI,yBAAyB,CAAC;CAC3D,MAAM,CAAC,cAAc,mBAAmB,yBACtC,IAAI,KAAK,CACV;AAGD,iBAAgB;EACd,MAAM,UAAU,cAAc;AAC9B,eAAa;AACX,OAAI;AACF,YAAQ,OAAO;YACR,OAAO;AACd,YAAQ,KAAK,yCAAyC,MAAM;;;IAG/D,EAAE,CAAC;CAGN,MAAM,gBAAgB,cAAc;AAClC,SAAO,gBAAgB,0BAA0B,cAAc,GAAG;IACjE,CAAC,cAAc,CAAC;CAGnB,MAAM,2BACJ,OACA,iBACS;AAET,MAAI,qBAAqB,YAAY,gBACnC,eAAc,QAAQ,OAAO,iBAAiB,SAAS,MAAM;WACpD,qBAAqB,YAAY,WAC1C,eAAc,QAAQ,OAAO,SAAS,SAAS,MAAM;WAErD,qBAAqB,UACrB,qBAAqB,gBAGrB,eAAc,QAAQ,OAAO,iBAAiB,SAAS,MAAM;WACpD,qBAAqB,UAAU,eAAe;GAKvD,MAAM,iBAAiB,cAAc,QAAQ,mBAAmB;AAGhE,iBAAc,SAAS,SAAS,gBAAgB;IAE9C,MAAM,QAAQ,eAAe,IAAI,YAAY;AAE7C,QAAI,OAAO;AAET,WAAM,gBAAgB;AAGtB,WAAM,UAAU,KACd,MAAM,SACN,MAAM,eACN,sBAAsB,kBAAkB,MACzC;;KAEH;QAEF,eAAc,QAAQ,gBAAgB,MAAM;AAM9C,MAAI,iBAAiB,EAGnB,iBADmB,cAAc,QAAQ,sBAAsB,CACpC;;AAI/B,QAAO;EACL;EACA;EACD"}

package/lib/hooks/usePauseMenu.d.ts

@@ -0,0 +1,32 @@
+/**
+ * usePauseMenu Hook - State management for pause menu
+ *
+ * Manages:
+ * - Pause menu visibility
+ * - Active submenu (controls, settings)
+ * - Confirmation dialog state
+ */
+export type PauseSubmenu = "main" | "controls" | "settings" | null;
+export interface ConfirmDialogState {
+    readonly isOpen: boolean;
+    readonly title: string;
+    readonly titleKorean: string;
+    readonly message: string;
+    readonly messageKorean: string;
+    readonly onConfirm: () => void;
+}
+export interface UsePauseMenuResult {
+    readonly activeSubmenu: PauseSubmenu;
+    readonly confirmDialog: ConfirmDialogState;
+    readonly showControls: () => void;
+    readonly showSettings: () => void;
+    readonly closeSubmenu: () => void;
+    readonly openConfirmDialog: (config: Omit<ConfirmDialogState, "isOpen">) => void;
+    readonly closeConfirmDialog: () => void;
+    readonly confirmAndClose: () => void;
+}
+/**
+ * Hook for managing pause menu state
+ */
+export declare function usePauseMenu(): UsePauseMenuResult;
+//# sourceMappingURL=usePauseMenu.d.ts.map

package/lib/hooks/usePauseMenu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePauseMenu.d.ts","sourceRoot":"","sources":["../../src/hooks/usePauseMenu.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,UAAU,GAAG,UAAU,GAAG,IAAI,CAAC;AAEnE,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,IAAI,CAAC;CAChC;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,aAAa,EAAE,YAAY,CAAC;IACrC,QAAQ,CAAC,aAAa,EAAE,kBAAkB,CAAC;IAC3C,QAAQ,CAAC,YAAY,EAAE,MAAM,IAAI,CAAC;IAClC,QAAQ,CAAC,YAAY,EAAE,MAAM,IAAI,CAAC;IAClC,QAAQ,CAAC,YAAY,EAAE,MAAM,IAAI,CAAC;IAClC,QAAQ,CAAC,iBAAiB,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,kBAAkB,EAAE,QAAQ,CAAC,KAAK,IAAI,CAAC;IACjF,QAAQ,CAAC,kBAAkB,EAAE,MAAM,IAAI,CAAC;IACxC,QAAQ,CAAC,eAAe,EAAE,MAAM,IAAI,CAAC;CACtC;AAWD;;GAEG;AACH,wBAAgB,YAAY,IAAI,kBAAkB,CA+CjD"}

package/lib/hooks/usePlayerAnimation.d.ts

@@ -0,0 +1,188 @@
+/**
+ * usePlayerAnimation - React hook for player animation state
+ *
+ * Provides a React interface to the PlayerAnimationStateMachine
+ * with automatic cleanup and event handling.
+ *
+ * @module hooks/usePlayerAnimation
+ * @category Hooks
+ * @korean 플레이어애니메이션훅
+ */
+import { AnimationEvents, AnimationState } from "../systems/animation";
+import type { AnimationConfig, AnimationUpdateResult } from "../systems/animation/core/types";
+import type { TrigramStance } from "../types/common";
+/**
+ * Options for usePlayerAnimation hook
+ *
+ * @korean 플레이어애니메이션훅옵션
+ */
+export interface UsePlayerAnimationOptions {
+    /**
+     * Custom animation configurations
+     * If not provided, uses DEFAULT_ANIMATION_CONFIGS
+     *
+     * @korean 커스텀애니메이션설정
+     */
+    readonly customConfigs?: Map<AnimationState, AnimationConfig>;
+    /**
+     * Animation event callbacks
+     *
+     * **IMPORTANT**: The events object should be stable (memoized) to prevent
+     * unnecessary re-initialization of the animation system. Changes to event
+     * callbacks after the hook is initialized will NOT be reflected in the
+     * animation system. Use `useMemo` or define events outside the component
+     * to ensure stability.
+     *
+     * @korean 이벤트콜백
+     */
+    readonly events?: AnimationEvents;
+    /**
+     * Initial animation state (defaults to "idle")
+     *
+     * @korean 초기상태
+     */
+    readonly initialState?: AnimationState;
+}
+/**
+ * Return type for usePlayerAnimation hook
+ *
+ * @korean 플레이어애니메이션훅반환타입
+ */
+export interface UsePlayerAnimationReturn {
+    /**
+     * Current animation state
+     *
+     * @korean 현재상태
+     */
+    readonly currentState: AnimationState;
+    /**
+     * Current frame index
+     *
+     * @korean 현재프레임
+     */
+    readonly currentFrame: number;
+    /**
+     * Update animation state (call in useFrame)
+     *
+     * @param deltaTime - Time elapsed since last update in seconds
+     * @returns Animation update result
+     *
+     * @korean 업데이트
+     */
+    readonly update: (deltaTime: number) => AnimationUpdateResult;
+    /**
+     * Transition to a new animation state
+     *
+     * @param newState - Target animation state
+     * @returns Whether transition was successful
+     *
+     * @korean 상태전환
+     */
+    readonly transitionTo: (newState: AnimationState) => boolean;
+    /**
+     * Transition to ATTACK state with technique-specific duration.
+     *
+     * The default ATTACK config is 200ms (12 frames), but real techniques
+     * range from 350ms to 1200ms. This method overrides the duration so
+     * the state machine stays in ATTACK for the full technique animation.
+     *
+     * @param durationSeconds - The skeletal animation duration in seconds
+     * @returns Whether transition was successful
+     *
+     * @korean 공격전환 (기술별 지속시간)
+     */
+    readonly transitionToAttack: (durationSeconds: number) => boolean;
+    /**
+     * Transition to stance-specific guard animation
+     *
+     * @param stance - Trigram stance
+     * @returns Whether transition was successful
+     *
+     * @korean 자세가드전환
+     */
+    readonly transitionToStanceGuard: (stance: TrigramStance) => boolean;
+    /**
+     * Transition to stance_change animation with specific transition data
+     *
+     * **Korean**: 자세 전환 애니메이션 시작
+     *
+     * Initiates a stance change animation with the specific transition data
+     * from the 64-transition matrix. This provides stance-specific keyframes
+     * and blend weights for smooth interpolation.
+     *
+     * @param fromStance - Source trigram stance
+     * @param toStance - Target trigram stance
+     * @returns Whether transition was successful
+     *
+     * @korean 자세전환애니메이션시작
+     */
+    readonly transitionToStanceChange: (fromStance: TrigramStance, toStance: TrigramStance) => boolean;
+    /**
+     * Check if currently in a stance guard animation
+     *
+     * @returns True if in any stance guard state
+     *
+     * @korean 자세가드확인
+     */
+    readonly isInStanceGuard: () => boolean;
+    /**
+     * Get current guard stance (if in guard animation)
+     *
+     * @returns Trigram stance or null
+     *
+     * @korean 현재가드자세
+     */
+    readonly getCurrentGuardStance: () => TrigramStance | null;
+    /**
+     * Reset animation to idle state
+     *
+     * @korean 초기화
+     */
+    readonly reset: () => void;
+}
+/**
+ * React hook for player animation state management
+ *
+ * Provides frame-accurate animation control with priority system
+ * and event callbacks. Integrates seamlessly with useFrame for
+ * 60fps updates.
+ *
+ * @param options - Animation options
+ * @returns Animation control interface
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const { currentState, currentFrame, update, transitionTo } = usePlayerAnimation({
+ *   events: {
+ *     onAnimationStart: (state) => console.log(`Started ${state}`),
+ *     onAnimationComplete: (state) => console.log(`Completed ${state}`),
+ *     onFrame: (frame, state) => {
+ *       if (state === "attack" && frame === 6) {
+ *         // Execute attack at midpoint
+ *         executeAttack();
+ *       }
+ *     }
+ *   }
+ * });
+ *
+ * // In useFrame callback
+ * useFrame((state, delta) => {
+ *   const result = update(delta);
+ *   // Update visuals based on result.state and result.frame
+ * });
+ *
+ * // Trigger animations
+ * const handleAttackInput = () => {
+ *   transitionTo("attack");
+ * };
+ *
+ * const handleMovement = (isMoving: boolean) => {
+ *   transitionTo(isMoving ? "walk" : "idle");
+ * };
+ * ```
+ *
+ * @korean 플레이어애니메이션훅
+ */
+export declare function usePlayerAnimation(options?: UsePlayerAnimationOptions): UsePlayerAnimationReturn;
+//# sourceMappingURL=usePlayerAnimation.d.ts.map

package/lib/hooks/usePlayerAnimation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePlayerAnimation.d.ts","sourceRoot":"","sources":["../../src/hooks/usePlayerAnimation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,EACL,eAAe,EACf,cAAc,EAGf,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EACV,eAAe,EACf,qBAAqB,EACtB,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD;;;;GAIG;AACH,MAAM,WAAW,yBAAyB;IACxC;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,GAAG,CAAC,cAAc,EAAE,eAAe,CAAC,CAAC;IAE9D;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,eAAe,CAAC;IAElC;;;;OAIG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,cAAc,CAAC;CACxC;AAED;;;;GAIG;AACH,MAAM,WAAW,wBAAwB;IACvC;;;;OAIG;IACH,QAAQ,CAAC,YAAY,EAAE,cAAc,CAAC;IAEtC;;;;OAIG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAE9B;;;;;;;OAOG;IACH,QAAQ,CAAC,MAAM,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,qBAAqB,CAAC;IAE9D;;;;;;;OAOG;IACH,QAAQ,CAAC,YAAY,EAAE,CAAC,QAAQ,EAAE,cAAc,KAAK,OAAO,CAAC;IAE7D;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,kBAAkB,EAAE,CAAC,eAAe,EAAE,MAAM,KAAK,OAAO,CAAC;IAElE;;;;;;;OAOG;IACH,QAAQ,CAAC,uBAAuB,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,OAAO,CAAC;IAErE;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,wBAAwB,EAAE,CACjC,UAAU,EAAE,aAAa,EACzB,QAAQ,EAAE,aAAa,KACpB,OAAO,CAAC;IAEb;;;;;;OAMG;IACH,QAAQ,CAAC,eAAe,EAAE,MAAM,OAAO,CAAC;IAExC;;;;;;OAMG;IACH,QAAQ,CAAC,qBAAqB,EAAE,MAAM,aAAa,GAAG,IAAI,CAAC;IAE3D;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,GAAE,yBAA8B,GACtC,wBAAwB,CAyI1B"}