blacktrigram 0.7.2

package/lib/systems/animation/core/AnimationOptimizations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnimationOptimizations.js","names":[],"sources":["../../../../src/systems/animation/core/AnimationOptimizations.ts"],"sourcesContent":["/**\n * Optimized Animation System with Caching and Batch Processing\n *\n * High-performance animation pipeline optimizations:\n * - Keyframe caching to avoid redundant interpolations\n * - Batch bone transformation updates\n * - Dirty flag optimization\n * - Precomputed interpolation curves\n *\n * Target: Reduce animation overhead from ~8ms to <5ms per frame\n *\n * @module systems/animation/AnimationOptimizations\n * @category Animation System\n * @korean 애니메이션최적화\n */\n\nimport type {\n  AnimationKeyframe,\n  SkeletalAnimation,\n  SkeletalRig,\n} from \"@/types/skeletal\";\nimport { ThreeObjectPools } from \"@/utils/threeObjectPool\";\nimport * as THREE from \"three\";\n\n/**\n * Cached keyframe with interpolated values\n * Reduces redundant interpolation calculations\n *\n * @korean 캐시된키프레임\n */\ninterface CachedKeyframe {\n  /** Original keyframe */\n  readonly keyframe: AnimationKeyframe;\n  /** Cache timestamp (for invalidation) */\n  readonly timestamp: number;\n  /** Interpolated bone rotations (Map to avoid allocations) */\n  readonly rotations: Map<string, THREE.Euler>;\n  /** Interpolated bone positions (if animated) */\n  readonly positions: Map<string, THREE.Vector3>;\n}\n\n/**\n * Animation cache entry\n *\n * @korean 애니메이션캐시항목\n */\ninterface AnimationCache {\n  /** Animation being cached */\n  readonly animation: SkeletalAnimation;\n  /** Cached keyframes by time */\n  readonly keyframes: Map<number, CachedKeyframe>;\n  /** Last access time (for LRU eviction) */\n  lastAccessTime: number;\n}\n\n/**\n * Animation Cache Manager\n *\n * Caches interpolated keyframes to avoid redundant calculations.\n * Uses LRU eviction when cache is full.\n *\n * @korean 애니메이션캐시관리자\n */\nclass AnimationCacheManager {\n  private cache = new Map<string, AnimationCache>();\n  private readonly maxCacheSize: number;\n  private readonly maxKeyframesPerAnimation: number;\n\n  constructor(maxCacheSize = 50, maxKeyframesPerAnimation = 200) {\n    this.maxCacheSize = maxCacheSize;\n    this.maxKeyframesPerAnimation = maxKeyframesPerAnimation;\n  }\n\n  /**\n   * Get cached keyframe or create new entry\n   *\n   * @param animationId - Animation identifier\n   * @param animation - Animation data (reserved for future cache invalidation logic)\n   * @param time - Current time\n   * @returns Cached keyframe or null if not cached\n   */\n  get(\n    animationId: string,\n    animation: SkeletalAnimation,\n    time: number,\n  ): CachedKeyframe | null {\n    // Mark parameter as used for future extensibility (e.g., cache invalidation)\n    void animation;\n    const entry = this.cache.get(animationId);\n    if (!entry) {\n      return null;\n    }\n\n    // Update access time for LRU\n    entry.lastAccessTime = performance.now();\n\n    // Round time to nearest 0.01s for cache hits (100 possible values per second)\n    const roundedTime = Math.round(time * 100) / 100;\n    return entry.keyframes.get(roundedTime) ?? null;\n  }\n\n  /**\n   * Cache an interpolated keyframe\n   *\n   * @param animationId - Animation identifier\n   * @param animation - Animation data\n   * @param time - Current time\n   * @param keyframe - Interpolated keyframe to cache\n   */\n  set(\n    animationId: string,\n    animation: SkeletalAnimation,\n    time: number,\n    keyframe: AnimationKeyframe,\n  ): void {\n    let entry = this.cache.get(animationId);\n\n    if (!entry) {\n      // Evict oldest entry if cache is full\n      if (this.cache.size >= this.maxCacheSize) {\n        this.evictLRU();\n      }\n\n      entry = {\n        animation,\n        keyframes: new Map(),\n        lastAccessTime: performance.now(),\n      };\n      this.cache.set(animationId, entry);\n    }\n\n    // Round time for consistent cache keys\n    const roundedTime = Math.round(time * 100) / 100;\n\n    // Clone keyframe data for caching (avoid reference issues)\n    const cachedRotations = new Map<string, THREE.Euler>();\n    keyframe.boneRotations.forEach((rotation, boneName) => {\n      cachedRotations.set(boneName, rotation.clone());\n    });\n\n    const cachedPositions = new Map<string, THREE.Vector3>();\n    if (keyframe.bonePositions && keyframe.bonePositions.size > 0) {\n      keyframe.bonePositions.forEach((position, boneName) => {\n        cachedPositions.set(boneName, position.clone());\n      });\n    }\n\n    entry.keyframes.set(roundedTime, {\n      keyframe,\n      timestamp: performance.now(),\n      rotations: cachedRotations,\n      positions: cachedPositions,\n    });\n\n    // Evict oldest keyframes if this animation has too many cached\n    if (entry.keyframes.size > this.maxKeyframesPerAnimation) {\n      this.evictOldestKeyframes(\n        entry,\n        entry.keyframes.size - this.maxKeyframesPerAnimation,\n      );\n    }\n  }\n\n  /**\n   * Evict oldest keyframes from an animation cache entry\n   * @param entry - Animation cache entry\n   * @param count - Number of keyframes to evict\n   */\n  private evictOldestKeyframes(entry: AnimationCache, count: number): void {\n    const keyframeTimes = Array.from(entry.keyframes.entries())\n      .sort((a, b) => a[1].timestamp - b[1].timestamp)\n      .slice(0, count)\n      .map(([time]) => time);\n\n    keyframeTimes.forEach((time) => entry.keyframes.delete(time));\n  }\n\n  /**\n   * Evict least recently used cache entry\n   */\n  private evictLRU(): void {\n    let oldestKey: string | null = null;\n    let oldestTime = Infinity;\n\n    this.cache.forEach((entry, key) => {\n      if (entry.lastAccessTime < oldestTime) {\n        oldestTime = entry.lastAccessTime;\n        oldestKey = key;\n      }\n    });\n\n    if (oldestKey) {\n      this.cache.delete(oldestKey);\n    }\n  }\n\n  /**\n   * Clear all cached keyframes\n   */\n  clear(): void {\n    this.cache.clear();\n  }\n\n  /**\n   * Get cache statistics\n   */\n  getStats(): {\n    totalAnimations: number;\n    totalKeyframes: number;\n    cacheSize: number;\n  } {\n    let totalKeyframes = 0;\n    this.cache.forEach((entry) => {\n      totalKeyframes += entry.keyframes.size;\n    });\n\n    return {\n      totalAnimations: this.cache.size,\n      totalKeyframes,\n      cacheSize: this.maxCacheSize,\n    };\n  }\n}\n\n/**\n * Global animation cache instance\n *\n * @korean 전역애니메이션캐시\n */\nexport const animationCache = new AnimationCacheManager(50);\n\n/**\n * Batch update multiple bones with dirty flag optimization\n *\n * Only updates bones that have changed rotations/positions.\n * Uses object pooling to avoid allocations.\n *\n * @param rig - Skeletal rig to update\n * @param keyframe - Keyframe with bone transforms\n * @param dirtyBones - Set of bone names that changed (optional, updates all if not provided)\n *\n * @korean 배치뼈업데이트\n */\nexport function batchUpdateBones(\n  rig: SkeletalRig,\n  keyframe: AnimationKeyframe,\n  dirtyBones?: Set<string>,\n): void {\n  const bonesToUpdate = dirtyBones ?? new Set(keyframe.boneRotations.keys());\n\n  bonesToUpdate.forEach((boneName) => {\n    const bone = rig.bones.get(boneName);\n    if (!bone) {\n      return;\n    }\n\n    // Update rotation\n    const rotation = keyframe.boneRotations.get(boneName);\n    if (rotation) {\n      bone.rotation.copy(rotation);\n    }\n\n    // Update position (if animated) - apply as offset from rest position\n    const position = keyframe.bonePositions?.get(boneName);\n    if (position) {\n      // Position values in animations are offsets from rest position, not absolute values\n      bone.position.copy(bone.restPosition).add(position);\n    }\n  });\n}\n\n/**\n * Precompute and cache animation interpolation\n *\n * Generates cached keyframes at regular intervals for smooth playback.\n * Call this during asset loading or idle time.\n *\n * @param animationId - Animation identifier\n * @param animation - Animation to precompute\n * @param sampleRate - Samples per second (default: 60fps = 60 samples/s)\n *\n * @korean 애니메이션사전계산\n */\nexport function precomputeAnimation(\n  animationId: string,\n  animation: SkeletalAnimation,\n  sampleRate = 60,\n): void {\n  const duration = animation.duration;\n  const step = 1 / sampleRate;\n\n  for (let t = 0; t <= duration; t += step) {\n    // This will populate the cache\n    const keyframe = interpolateKeyframeCached(animationId, animation, t);\n    if (keyframe) {\n      animationCache.set(animationId, animation, t, keyframe);\n    }\n  }\n}\n\n/**\n * Interpolate keyframe with caching\n *\n * Checks cache before performing interpolation.\n * Automatically caches result for future use.\n *\n * @param animationId - Animation identifier\n * @param animation - Animation data\n * @param time - Current time\n * @returns Interpolated keyframe\n *\n * @korean 캐시된키프레임보간\n */\nexport function interpolateKeyframeCached(\n  animationId: string,\n  animation: SkeletalAnimation,\n  time: number,\n): AnimationKeyframe | null {\n  // Check cache first\n  const cached = animationCache.get(animationId, animation, time);\n  if (cached) {\n    return cached.keyframe;\n  }\n\n  // Find surrounding keyframes\n  const keyframes = animation.keyframes;\n  if (keyframes.length === 0) {\n    return null;\n  }\n\n  // Find previous and next keyframes\n  let prevKeyframe = keyframes[0];\n  let nextKeyframe = keyframes[keyframes.length - 1];\n\n  for (let i = 0; i < keyframes.length - 1; i++) {\n    if (time >= keyframes[i].time && time <= keyframes[i + 1].time) {\n      prevKeyframe = keyframes[i];\n      nextKeyframe = keyframes[i + 1];\n      break;\n    }\n  }\n\n  // If at exact keyframe, return it directly\n  if (Math.abs(time - prevKeyframe.time) < 0.001) {\n    animationCache.set(animationId, animation, time, prevKeyframe);\n    return prevKeyframe;\n  }\n\n  // Calculate interpolation factor\n  const timeDiff = nextKeyframe.time - prevKeyframe.time;\n  const t = timeDiff > 0 ? (time - prevKeyframe.time) / timeDiff : 0;\n\n  // Interpolate rotations using object pool\n  const interpolatedRotations = new Map<string, THREE.Euler>();\n\n  prevKeyframe.boneRotations.forEach((prevRot, boneName) => {\n    const nextRot = nextKeyframe.boneRotations.get(boneName);\n    if (nextRot) {\n      // Use pooled quaternions for slerp interpolation\n      const prevQuat = ThreeObjectPools.quaternion.acquire();\n      const nextQuat = ThreeObjectPools.quaternion.acquire();\n      const resultQuat = ThreeObjectPools.quaternion.acquire();\n\n      prevQuat.setFromEuler(prevRot);\n      nextQuat.setFromEuler(nextRot);\n      resultQuat.slerpQuaternions(prevQuat, nextQuat, t);\n\n      // Use pooled Euler, then clone for storage to avoid pooled object reuse issues\n      const tempEuler = ThreeObjectPools.euler.acquire();\n      tempEuler.setFromQuaternion(resultQuat);\n      interpolatedRotations.set(boneName, tempEuler.clone());\n\n      // Release pooled objects\n      ThreeObjectPools.quaternion.release(prevQuat);\n      ThreeObjectPools.quaternion.release(nextQuat);\n      ThreeObjectPools.quaternion.release(resultQuat);\n      ThreeObjectPools.euler.release(tempEuler);\n    } else {\n      interpolatedRotations.set(boneName, prevRot.clone());\n    }\n  });\n\n  // Interpolate positions if present\n  const interpolatedPositions = new Map<string, THREE.Vector3>();\n  if (\n    prevKeyframe.bonePositions &&\n    prevKeyframe.bonePositions.size > 0 &&\n    nextKeyframe.bonePositions &&\n    nextKeyframe.bonePositions.size > 0\n  ) {\n    prevKeyframe.bonePositions.forEach((prevPos, boneName) => {\n      const nextPos = nextKeyframe.bonePositions?.get(boneName);\n      if (nextPos) {\n        // Use pooled Vector3, then clone for storage to avoid pooled object reuse issues\n        const tempVec = ThreeObjectPools.vector3.acquire();\n        tempVec.lerpVectors(prevPos, nextPos, t);\n        interpolatedPositions.set(boneName, tempVec.clone());\n        ThreeObjectPools.vector3.release(tempVec);\n      }\n    });\n  }\n\n  // ═══════════════════════════════════════════════════════════════════════════\n  // ANATOMY STATE INTERPOLATION (해부학 상태 보간)\n  // ═══════════════════════════════════════════════════════════════════════════\n\n  // For anatomy state, we use discrete values (no interpolation - nearest keyframe wins)\n  // At t < 0.5 use prevKeyframe, at t >= 0.5 use nextKeyframe\n  const useNextAnatomy = t >= 0.5;\n  const anatomySource = useNextAnatomy ? nextKeyframe : prevKeyframe;\n\n  // Interpolate muscle activations if present\n  let interpolatedMuscles: Map<string, number> | undefined;\n  if (prevKeyframe.muscleActivations || nextKeyframe.muscleActivations) {\n    interpolatedMuscles = new Map();\n    const prevMuscles = prevKeyframe.muscleActivations ?? new Map();\n    const nextMuscles = nextKeyframe.muscleActivations ?? new Map();\n\n    // Collect all muscle groups from both keyframes\n    const allMuscles = new Set([...prevMuscles.keys(), ...nextMuscles.keys()]);\n    allMuscles.forEach((muscle) => {\n      const prevVal = prevMuscles.get(muscle) ?? 0;\n      const nextVal = nextMuscles.get(muscle) ?? 0;\n      // Linear interpolation for muscle tension\n      interpolatedMuscles?.set(muscle, prevVal + (nextVal - prevVal) * t);\n    });\n  }\n\n  const interpolatedKeyframe: AnimationKeyframe = {\n    time,\n    boneRotations: interpolatedRotations,\n    bonePositions: interpolatedPositions,\n    easing: prevKeyframe.easing,\n    // Anatomy state (discrete, from nearest keyframe)\n    leftHandPose: anatomySource.leftHandPose,\n    rightHandPose: anatomySource.rightHandPose,\n    leftHandHighlightMode: anatomySource.leftHandHighlightMode,\n    rightHandHighlightMode: anatomySource.rightHandHighlightMode,\n    leftFootHighlight: anatomySource.leftFootHighlight,\n    rightFootHighlight: anatomySource.rightFootHighlight,\n    facialExpression: anatomySource.facialExpression,\n    // Muscle activations (interpolated)\n    muscleActivations: interpolatedMuscles,\n  };\n\n  // Cache for future use\n  animationCache.set(animationId, animation, time, interpolatedKeyframe);\n\n  return interpolatedKeyframe;\n}\n\n/**\n * Batch transform multiple bones in a single operation\n *\n * Applies transformations to all bones efficiently using temporary objects.\n * Reduces per-bone overhead by batching operations.\n *\n * @param rig - Skeletal rig\n * @param transforms - Map of bone names to transforms\n *\n * @korean 배치변환\n */\nexport function batchTransformBones(\n  rig: SkeletalRig,\n  transforms: Map<string, { rotation?: THREE.Euler; position?: THREE.Vector3 }>,\n): void {\n  transforms.forEach((transform, boneName) => {\n    const bone = rig.bones.get(boneName);\n    if (!bone) {\n      return;\n    }\n\n    if (transform.rotation) {\n      bone.rotation.copy(transform.rotation);\n    }\n\n    if (transform.position) {\n      bone.position.copy(transform.position);\n    }\n  });\n}\n\n/**\n * Calculate dirty bones between two keyframes\n *\n * Identifies which bones have changed between keyframes for dirty flag optimization.\n * Only changed bones need to be updated.\n *\n * @param prevKeyframe - Previous keyframe\n * @param nextKeyframe - Next keyframe\n * @param threshold - Minimum rotation difference in radians (default: 0.01)\n * @returns Set of bone names that changed\n *\n * @korean 변경된뼈계산\n */\nexport function calculateDirtyBones(\n  prevKeyframe: AnimationKeyframe,\n  nextKeyframe: AnimationKeyframe,\n  threshold = 0.01,\n): Set<string> {\n  const dirtyBones = new Set<string>();\n\n  nextKeyframe.boneRotations.forEach((nextRot, boneName) => {\n    const prevRot = prevKeyframe.boneRotations.get(boneName);\n    if (!prevRot) {\n      dirtyBones.add(boneName);\n      return;\n    }\n\n    // Check if rotation changed significantly\n    const dx = Math.abs(nextRot.x - prevRot.x);\n    const dy = Math.abs(nextRot.y - prevRot.y);\n    const dz = Math.abs(nextRot.z - prevRot.z);\n\n    if (dx > threshold || dy > threshold || dz > threshold) {\n      dirtyBones.add(boneName);\n    }\n  });\n\n  // Check positions if animated\n  if (nextKeyframe.bonePositions && nextKeyframe.bonePositions.size > 0) {\n    nextKeyframe.bonePositions.forEach((nextPos, boneName) => {\n      const prevPos = prevKeyframe.bonePositions?.get(boneName);\n      if (!prevPos) {\n        dirtyBones.add(boneName);\n        return;\n      }\n\n      // Check if position changed\n      const distance = nextPos.distanceTo(prevPos);\n      if (distance > threshold) {\n        dirtyBones.add(boneName);\n      }\n    });\n  }\n\n  return dirtyBones;\n}\n\n/**\n * Animation performance metrics\n *\n * @korean 애니메이션성능지표\n */\nexport interface AnimationPerformanceMetrics {\n  /** Average frame time (ms) */\n  avgFrameTime: number;\n  /** Maximum frame time (ms) */\n  maxFrameTime: number;\n  /** Minimum frame time (ms) */\n  minFrameTime: number;\n  /** Number of frames measured */\n  frameCount: number;\n  /** Cache hit rate (0-1) */\n  cacheHitRate: number;\n  /** Total cache entries */\n  cacheEntries: number;\n}\n\n/**\n * Performance monitor for animation system\n *\n * @korean 성능모니터\n */\nclass AnimationPerformanceMonitor {\n  private frameTimes: number[] = [];\n  private cacheHits = 0;\n  private cacheMisses = 0;\n  private readonly maxSamples = 120; // 2 seconds at 60fps\n\n  /**\n   * Record frame time\n   * @param time - Frame time in milliseconds\n   */\n  recordFrame(time: number): void {\n    this.frameTimes.push(time);\n    if (this.frameTimes.length > this.maxSamples) {\n      this.frameTimes.shift();\n    }\n  }\n\n  /**\n   * Record cache hit\n   */\n  recordCacheHit(): void {\n    this.cacheHits++;\n  }\n\n  /**\n   * Record cache miss\n   */\n  recordCacheMiss(): void {\n    this.cacheMisses++;\n  }\n\n  /**\n   * Get current metrics\n   */\n  getMetrics(): AnimationPerformanceMetrics {\n    const totalHits = this.cacheHits + this.cacheMisses;\n    const cacheHitRate = totalHits > 0 ? this.cacheHits / totalHits : 0;\n\n    const stats = animationCache.getStats();\n\n    if (this.frameTimes.length === 0) {\n      return {\n        avgFrameTime: 0,\n        maxFrameTime: 0,\n        minFrameTime: 0,\n        frameCount: 0,\n        cacheHitRate,\n        cacheEntries: stats.totalKeyframes,\n      };\n    }\n\n    const avgFrameTime =\n      this.frameTimes.reduce((a, b) => a + b, 0) / this.frameTimes.length;\n    const maxFrameTime = Math.max(...this.frameTimes);\n    const minFrameTime = Math.min(...this.frameTimes);\n\n    return {\n      avgFrameTime,\n      maxFrameTime,\n      minFrameTime,\n      frameCount: this.frameTimes.length,\n      cacheHitRate,\n      cacheEntries: stats.totalKeyframes,\n    };\n  }\n\n  /**\n   * Reset metrics\n   */\n  reset(): void {\n    this.frameTimes = [];\n    this.cacheHits = 0;\n    this.cacheMisses = 0;\n  }\n}\n\n/**\n * Global performance monitor instance\n *\n * @korean 전역성능모니터\n */\nexport const performanceMonitor = new AnimationPerformanceMonitor();\n"],"mappings":"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"}

package/lib/systems/animation/core/AnimationPriority.d.ts

@@ -0,0 +1,391 @@
+/**
+ * Animation priority system for Black Trigram
+ *
+ * Determines which animations can interrupt others based on priority levels.
+ * Higher priority animations can interrupt lower priority ones.
+ *
+ * Priority order: recovery > fall > ko > hit > attack > defend > stance_change > movement > idle
+ *
+ * Enhanced with:
+ * - Deterministic conflict resolution for simultaneous equal-priority animations
+ * - Animation queue system for pending animations
+ * - Interruptibility windows (frame-based interrupt control)
+ * - Korean terminology for all priority levels and conflicts
+ *
+ * @module systems/animation/AnimationPriority
+ * @category Animation
+ * @korean 애니메이션우선순위
+ */
+import { AnimationPriority, AnimationState } from "./types";
+/**
+ * Map animation states to their priority levels
+ *
+ * Stance guard animations have same priority as idle (0) since they are
+ * also idle states, just stance-specific.
+ * Tactical steps have priority 5 (same as attacks) to ensure commitment.
+ *
+ * @korean 애니메이션우선순위맵
+ */
+export declare const ANIMATION_PRIORITY_MAP: Record<AnimationState, AnimationPriority>;
+/**
+ * Check if an animation can interrupt another based on priority
+ *
+ * @param current - Current animation state
+ * @param requested - Requested animation state
+ * @param currentInterruptible - Whether current animation is interruptible
+ * @returns Whether the requested animation can interrupt the current one
+ *
+ * @example
+ * ```typescript
+ * // Hit can interrupt attack
+ * canInterrupt("attack", "hit", true); // true
+ *
+ * // Attack cannot interrupt hit
+ * canInterrupt("hit", "attack", true); // false
+ *
+ * // Nothing can interrupt non-interruptible animations
+ * canInterrupt("attack", "hit", false); // false (unless same priority)
+ * ```
+ *
+ * @korean 중단가능여부확인
+ */
+export declare function canInterrupt(current: AnimationState, requested: AnimationState, currentInterruptible: boolean): boolean;
+/**
+ * Get the priority level for an animation state
+ *
+ * @param state - Animation state
+ * @returns Priority level
+ *
+ * @korean 우선순위가져오기
+ */
+export declare function getPriority(state: AnimationState): AnimationPriority;
+/**
+ * Compare two animation priorities
+ *
+ * @param state1 - First animation state
+ * @param state2 - Second animation state
+ * @returns Positive if state1 has higher priority, negative if state2 has higher priority, 0 if equal
+ *
+ * @korean 우선순위비교
+ */
+export declare function comparePriority(state1: AnimationState, state2: AnimationState): number;
+/**
+ * Korean names for each priority level
+ *
+ * Maps priority levels to their Korean martial arts terminology:
+ * - IDLE (0): 대기 (Daegi) - Waiting/Ready state
+ * - WALK (1): 보행 (Bohaeng) - Walking movement
+ * - RUN (2): 질주 (Jilju) - Running movement
+ * - STANCE_CHANGE (3): 자세전환 (Jase Jeonhwan) - Stance transition
+ * - DEFEND (4): 방어 (Bangeo) - Defense action
+ * - ATTACK (5): 공격 (Gonggyeok) - Attack action
+ * - HIT (6): 피격 (Pigyeok) - Being hit
+ * - KO (7): 기절 (Gijeol) - Knockout
+ * - FALL (8): 낙법 (Nakbeop) - Falling technique
+ * - RECOVERY (9): 기상 (Gisang) - Recovery/Getting up
+ *
+ * @korean 우선순위한글용어
+ */
+export declare const PRIORITY_LEVEL_KOREAN_NAMES: Record<AnimationPriority, {
+    korean: string;
+    romanized: string;
+    english: string;
+}>;
+/**
+ * Get Korean name for a priority level
+ *
+ * @param priority - Animation priority level
+ * @returns Korean terminology object
+ *
+ * @korean 우선순위한글이름가져오기
+ */
+export declare function getPriorityKoreanName(priority: AnimationPriority): {
+    korean: string;
+    romanized: string;
+    english: string;
+};
+/**
+ * Conflict resolution strategy for equal-priority animations
+ *
+ * **Korean**: 충돌 해결 전략
+ *
+ * Determines how to handle when two animations of equal priority
+ * are requested simultaneously:
+ *
+ * - `timestamp`: First animation requested wins (FIFO - 선입선출)
+ * - `state_order`: Use AnimationState enum order as tiebreaker
+ * - `current`: Keep current animation running
+ * - `requested`: Always switch to requested animation
+ *
+ * @korean 충돌해결전략
+ */
+export type ConflictResolutionStrategy = "timestamp" | "state_order" | "current" | "requested";
+/**
+ * Animation request with timestamp for conflict resolution
+ *
+ * **Korean**: 애니메이션 요청
+ *
+ * Tracks animation requests with timestamps to enable deterministic
+ * conflict resolution when multiple equal-priority animations compete.
+ *
+ * @korean 애니메이션요청
+ */
+export interface AnimationRequest {
+    /** Requested animation state */
+    readonly state: AnimationState;
+    /** Request timestamp in milliseconds (from performance.now()) */
+    readonly timestamp: number;
+    /** Request priority */
+    readonly priority: AnimationPriority;
+    /**
+     * Whether this is a forced request (wins conflict resolution against non-forced requests)
+     *
+     * Note: This only affects conflict resolution between equal-priority animations in the queue.
+     * It does not bypass priority checks or interrupt rules for the initial transition.
+     *
+     * @korean 강제요청
+     */
+    readonly forced?: boolean;
+}
+/**
+ * Resolve conflict between two equal-priority animations
+ *
+ * **Korean**: 충돌 해결
+ *
+ * Uses the specified strategy to deterministically decide which animation
+ * should play when both have equal priority.
+ *
+ * @param current - Current animation request
+ * @param requested - Requested animation request
+ * @param strategy - Conflict resolution strategy
+ * @returns Which animation should play: 'current' or 'requested'
+ *
+ * @example
+ * ```typescript
+ * const current = {
+ *   state: AnimationState.ATTACK,
+ *   timestamp: 1000,
+ *   priority: AnimationPriority.ATTACK,
+ * };
+ * const requested = {
+ *   state: AnimationState.STEP_FORWARD,
+ *   timestamp: 1001,
+ *   priority: AnimationPriority.ATTACK,
+ * };
+ *
+ * // Timestamp strategy: current wins (1000 < 1001)
+ * resolveConflict(current, requested, "timestamp"); // "current"
+ *
+ * // Requested strategy: always take new animation
+ * resolveConflict(current, requested, "requested"); // "requested"
+ * ```
+ *
+ * @korean 충돌해결
+ */
+export declare function resolveConflict(current: AnimationRequest, requested: AnimationRequest, strategy?: ConflictResolutionStrategy): "current" | "requested";
+/**
+ * Animation queue for managing pending animations
+ *
+ * **Korean**: 애니메이션 대기열
+ *
+ * Stores pending animation requests that should play after the current
+ * animation completes. Useful for:
+ * - Buffering input during non-interruptible animations
+ * - Creating animation chains/combos
+ * - Handling rapid input sequences
+ *
+ * Queue is priority-ordered: highest priority animations are dequeued first.
+ *
+ * @korean 애니메이션대기열
+ */
+export declare class AnimationQueue {
+    private queue;
+    private maxSize;
+    private conflictStrategy;
+    /**
+     * Create a new animation queue
+     *
+     * @param maxSize - Maximum queue size (default: 3)
+     * @param conflictStrategy - Strategy for resolving equal-priority conflicts
+     *
+     * @korean 생성자
+     */
+    constructor(maxSize?: number, conflictStrategy?: ConflictResolutionStrategy);
+    /**
+     * Add animation request to queue
+     *
+     * **Korean**: 대기열에 추가
+     *
+     * Adds an animation request to the queue if space is available.
+     * Queue is kept sorted by priority (highest first).
+     *
+     * @param request - Animation request to enqueue
+     * @returns Whether request was successfully enqueued
+     *
+     * @korean 대기열추가
+     */
+    enqueue(request: AnimationRequest): boolean;
+    /**
+     * Remove and return highest priority request from queue
+     *
+     * **Korean**: 대기열에서 제거
+     *
+     * Dequeues the highest priority animation request.
+     * If multiple requests have equal priority, uses conflict resolution strategy.
+     *
+     * @returns Next animation request or null if queue is empty
+     *
+     * @korean 대기열제거
+     */
+    dequeue(): AnimationRequest | null;
+    /**
+     * Peek at next request without removing it
+     *
+     * **Korean**: 다음 요청 확인
+     *
+     * @returns Next animation request or null if queue is empty
+     *
+     * @korean 다음요청확인
+     */
+    peek(): AnimationRequest | null;
+    /**
+     * Clear all pending requests
+     *
+     * **Korean**: 대기열 초기화
+     *
+     * @korean 대기열초기화
+     */
+    clear(): void;
+    /**
+     * Get number of pending requests
+     *
+     * **Korean**: 대기열 크기
+     *
+     * @returns Number of pending requests
+     *
+     * @korean 대기열크기
+     */
+    size(): number;
+    /**
+     * Check if queue is empty
+     *
+     * **Korean**: 대기열 비어있음
+     *
+     * @returns True if queue has no pending requests
+     *
+     * @korean 대기열비어있음
+     */
+    isEmpty(): boolean;
+    /**
+     * Check if queue is full
+     *
+     * **Korean**: 대기열 가득참
+     *
+     * @returns True if queue is at maximum capacity
+     *
+     * @korean 대기열가득찬
+     */
+    isFull(): boolean;
+    /**
+     * Get all pending requests (read-only)
+     *
+     * **Korean**: 모든 대기 요청
+     *
+     * @returns Array of pending requests
+     *
+     * @korean 모든대기요청
+     */
+    getAll(): readonly AnimationRequest[];
+    /**
+     * Get maximum queue size
+     *
+     * **Korean**: 최대 대기열 크기
+     *
+     * @returns Maximum queue capacity
+     *
+     * @korean 최대대기열크기
+     */
+    getMaxSize(): number;
+    /**
+     * Set conflict resolution strategy
+     *
+     * **Korean**: 충돌 해결 전략 설정
+     *
+     * Updates the strategy used to resolve equal-priority conflicts.
+     *
+     * @param strategy - New conflict resolution strategy
+     *
+     * @korean 충돌해결전략설정
+     */
+    setConflictStrategy(strategy: ConflictResolutionStrategy): void;
+}
+/**
+ * Interruptibility window definition
+ *
+ * **Korean**: 중단 가능 구간
+ *
+ * Defines specific frame ranges where an animation can be interrupted,
+ * allowing for more nuanced control than simple boolean interruptibility.
+ *
+ * Example: Attack animation might be interruptible only in startup frames (0-3)
+ * and recovery frames (10-12), but not during active frames (4-9).
+ *
+ * @korean 중단가능구간
+ */
+export interface InterruptibilityWindow {
+    /** Starting frame (inclusive) */
+    readonly startFrame: number;
+    /** Ending frame (inclusive) */
+    readonly endFrame: number;
+    /** Minimum priority required to interrupt during this window */
+    readonly minPriorityToInterrupt: AnimationPriority;
+}
+/**
+ * Check if an animation can be interrupted at a specific frame
+ *
+ * **Korean**: 프레임별 중단 가능 여부
+ *
+ * Determines if an animation can be interrupted based on:
+ * - Current frame index
+ * - Interruptibility windows
+ * - Requested animation priority
+ *
+ * @param currentFrame - Current frame index in animation
+ * @param requestedPriority - Priority of animation trying to interrupt
+ * @param windows - Array of interruptibility windows
+ * @returns Whether animation can be interrupted at this frame
+ *
+ * @example
+ * ```typescript
+ * const attackWindows: InterruptibilityWindow[] = [
+ *   { startFrame: 0, endFrame: 3, minPriorityToInterrupt: AnimationPriority.ATTACK },
+ *   { startFrame: 10, endFrame: 12, minPriorityToInterrupt: AnimationPriority.DEFEND },
+ * ];
+ *
+ * // Frame 2: interruptible by attacks or higher
+ * canInterruptAtFrame(2, AnimationPriority.HIT, attackWindows); // true
+ * canInterruptAtFrame(2, AnimationPriority.DEFEND, attackWindows); // false
+ *
+ * // Frame 5: not interruptible (no window)
+ * canInterruptAtFrame(5, AnimationPriority.KO, attackWindows); // false
+ * ```
+ *
+ * @korean 프레임별중단가능여부
+ */
+export declare function canInterruptAtFrame(currentFrame: number, requestedPriority: AnimationPriority, windows: readonly InterruptibilityWindow[]): boolean;
+/**
+ * Get interruptibility window for current frame
+ *
+ * **Korean**: 현재 프레임 중단 가능 구간
+ *
+ * Returns the active interruptibility window for the given frame,
+ * or null if frame is not in any window.
+ *
+ * @param currentFrame - Current frame index
+ * @param windows - Array of interruptibility windows
+ * @returns Active window or null
+ *
+ * @korean 현재프레임중단가능구간
+ */
+export declare function getInterruptibilityWindow(currentFrame: number, windows: readonly InterruptibilityWindow[]): InterruptibilityWindow | null;
+//# sourceMappingURL=AnimationPriority.d.ts.map

package/lib/systems/animation/core/AnimationPriority.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnimationPriority.d.ts","sourceRoot":"","sources":["../../../../src/systems/animation/core/AnimationPriority.ts"],"names":[],"mappings":"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"}