blacktrigram 0.7.44 → 0.7.45

package/lib/systems/TrigramSystem.js.map

@@ -1 +1 @@
-{"version":3,"file":"TrigramSystem.js","names":[],"sources":["../../src/systems/TrigramSystem.ts"],"sourcesContent":["import { KoreanText, TrigramStance } from \"../types/common\";\nimport { PlayerState } from \"./player\";\n\nimport { TRIGRAM_STANCES_ORDER, TrigramTransitionCost } from \"./trigram\";\nimport { TrigramCalculator } from \"./trigram/TrigramCalculator\";\nimport { PLAYER_ARCHETYPES_DATA } from \"./types\";\n\n/**\n * Stance counter relationships based on I Ching philosophy\n * \n * Each stance has a counter stance that provides tactical advantage:\n * - **GEON (Heaven)** countered by **GAM (Water)** - Water flows around Heaven's force\n * - **TAE (Lake)** countered by **GON (Earth)** - Earth contains and grounds Lake\n * - **LI (Fire)** countered by **SON (Wind)** - Wind disperses Fire's intensity\n * - **JIN (Thunder)** countered by **GAN (Mountain)** - Mountain absorbs Thunder's impact\n * - **SON (Wind)** countered by **GEON (Heaven)** - Heaven's force overpowers Wind\n * - **GAM (Water)** countered by **TAE (Lake)** - Lake contains and channels Water\n * - **GAN (Mountain)** countered by **LI (Fire)** - Fire melts Mountain's solidity\n * - **GON (Earth)** countered by **JIN (Thunder)** - Thunder breaks Earth's stability\n * \n * Using a counter stance provides a 1.2x damage multiplier in combat.\n * \n * @korean 팔괘 상극 관계 (Eight Trigram Counter Relationships)\n */\nexport const STANCE_COUNTERS: Record<TrigramStance, TrigramStance> = {\n  [TrigramStance.GEON]: TrigramStance.GAM, // Water flows around Heaven\n  [TrigramStance.TAE]: TrigramStance.GON, // Earth grounds Lake\n  [TrigramStance.LI]: TrigramStance.SON, // Wind disperses Fire\n  [TrigramStance.JIN]: TrigramStance.GAN, // Mountain absorbs Thunder\n  [TrigramStance.SON]: TrigramStance.GEON, // Heaven overpowers Wind\n  [TrigramStance.GAM]: TrigramStance.TAE, // Lake contains Water\n  [TrigramStance.GAN]: TrigramStance.LI, // Fire melts Mountain\n  [TrigramStance.GON]: TrigramStance.JIN, // Thunder breaks Earth\n};\n\n/**\n * Counter stance damage multiplier\n * Applied when using a counter stance against opponent's stance\n * \n * @korean 상극 자세 피해 배율\n */\nexport const COUNTER_STANCE_DAMAGE_MULTIPLIER = 1.2;\n\n/**\n * Apply counter stance damage bonus when appropriate.\n *\n * This helper should be used by combat damage calculation code after it has\n * determined whether the current stance matchup is a counter stance\n * (for example, via an `isCounterStance` check elsewhere in the system).\n *\n * When `isCounterStance` is `true`, the base damage is multiplied by\n * {@link COUNTER_STANCE_DAMAGE_MULTIPLIER}. Non-positive damage values are\n * returned unchanged to avoid introducing invalid negative or zero scaling.\n *\n * @param baseDamage - The pre-modifier damage value.\n * @param isCounterStance - Whether the attacker is using a counter stance.\n * @returns The adjusted damage value with counter stance bonus applied when relevant.\n *\n * @example\n * ```ts\n * const isCounter = trigramSystem.isCounterStance(attackerStance, defenderStance);\n * const finalDamage = applyCounterStanceDamage(baseDamage, isCounter);\n * ```\n *\n * @korean\n * 반격 자세(상극 자세)일 때만 피해 배율(1.2배)을 적용합니다.\n */\nexport function applyCounterStanceDamage(\n  baseDamage: number,\n  isCounterStance: boolean\n): number {\n  if (!isCounterStance || baseDamage <= 0) {\n    return baseDamage;\n  }\n\n  return baseDamage * COUNTER_STANCE_DAMAGE_MULTIPLIER;\n}\n\n/**\n * System for managing Eight Trigram (팔괘) stance transitions and combat calculations.\n *\n * **Korean**: 팔괘 시스템 (Eight Trigram System)\n *\n * The TrigramSystem implements the core mechanics of the Eight Trigram martial arts system,\n * managing stance transitions, calculating effectiveness, and determining resource costs.\n * Based on I Ching (易經) philosophy adapted for tactical combat.\n *\n * ## Key Responsibilities\n *\n * - Validate stance transitions based on Ki and Stamina costs\n * - Calculate transition difficulty between stances\n * - Recommend optimal stance choices\n * - Determine stance effectiveness in combat matchups\n * - Apply archetype-specific modifiers to transitions\n *\n * @example\n * ```typescript\n * const trigramSystem = new TrigramSystem();\n *\n * // Check if transition is possible\n * const canTransition = trigramSystem.canTransitionTo(\n *   TrigramStance.GEON,\n *   TrigramStance.GAM,\n *   playerState\n * );\n *\n * // Get recommended stance\n * const recommendedStance = trigramSystem.recommendStance(playerState);\n * ```\n *\n * @public\n * @category Trigram System\n * @korean 팔괘시스템\n */\nexport class TrigramSystem {\n  private calculator: TrigramCalculator;\n\n  /**\n   * Creates a new TrigramSystem instance.\n   *\n   * Initializes the internal calculator for stance effectiveness and transition difficulty.\n   */\n  constructor() {\n    this.calculator = new TrigramCalculator();\n  }\n\n  /**\n   * Gets the defensive/offensive characteristic of a stance.\n   *\n   * **Korean**: 자세 특성 조회 (Stance Characteristic Query)\n   *\n   * Returns whether a stance is primarily defensive, offensive, or balanced.\n   * This information is useful for UI display and tactical decision-making.\n   *\n   * ## Stance Classifications\n   *\n   * - **Defensive**: 간 (GAN/Mountain), 곤 (GON/Earth) - Protect vital areas\n   * - **Offensive**: 건 (GEON/Heaven), 진 (JIN/Thunder) - Expose for power\n   * - **Balanced**: 태 (TAE/Lake), 리 (LI/Fire), 손 (SON/Wind), 감 (GAM/Water)\n   *\n   * @param stance - Trigram stance to query\n   * @returns \"defensive\", \"offensive\", or \"balanced\"\n   *\n   * @example\n   * ```typescript\n   * const characteristic = trigramSystem.getStanceCharacteristic(TrigramStance.GAN);\n   * console.log(characteristic); // \"defensive\"\n   *\n   * const offensive = trigramSystem.getStanceCharacteristic(TrigramStance.GEON);\n   * console.log(offensive); // \"offensive\"\n   * ```\n   *\n   * @public\n   * @korean 자세특성조회\n   */\n  getStanceCharacteristic(\n    stance: TrigramStance\n  ): \"defensive\" | \"offensive\" | \"balanced\" {\n    switch (stance) {\n      case TrigramStance.GAN: // Mountain - Immovable defense\n      case TrigramStance.GON: // Earth - Grounding and stability\n        return \"defensive\";\n\n      case TrigramStance.GEON: // Heaven - Direct force and aggression\n      case TrigramStance.JIN: // Thunder - Explosive power\n        return \"offensive\";\n\n      default:\n        return \"balanced\";\n    }\n  }\n\n  /**\n   * Checks if a stance provides defensive advantages.\n   *\n   * **Korean**: 방어 자세 확인 (Check Defensive Stance)\n   *\n   * @param stance - Trigram stance to check\n   * @returns true if stance is defensive, false otherwise\n   *\n   * @example\n   * ```typescript\n   * if (trigramSystem.isDefensiveStance(player.currentStance)) {\n   *   console.log(\"Player is in defensive posture\");\n   * }\n   * ```\n   *\n   * @public\n   * @korean 방어자세확인\n   */\n  isDefensiveStance(stance: TrigramStance): boolean {\n    return this.getStanceCharacteristic(stance) === \"defensive\";\n  }\n\n  /**\n   * Checks if a stance provides offensive advantages.\n   *\n   * **Korean**: 공격 자세 확인 (Check Offensive Stance)\n   *\n   * @param stance - Trigram stance to check\n   * @returns true if stance is offensive, false otherwise\n   *\n   * @example\n   * ```typescript\n   * if (trigramSystem.isOffensiveStance(player.currentStance)) {\n   *   console.log(\"Player is in offensive posture\");\n   * }\n   * ```\n   *\n   * @public\n   * @korean 공격자세확인\n   */\n  isOffensiveStance(stance: TrigramStance): boolean {\n    return this.getStanceCharacteristic(stance) === \"offensive\";\n  }\n\n  /**\n   * Checks if a player can transition from one stance to another.\n   *\n   * Validates that the player has sufficient Ki (氣) and Stamina resources\n   * to perform the stance transition. Same-stance transitions are always valid.\n   *\n   * @param fromStance - Current stance\n   * @param toStance - Target stance\n   * @param player - Player state with current Ki and Stamina\n   * @returns true if transition is possible, false otherwise\n   *\n   * @example\n   * ```typescript\n   * const canChange = trigramSystem.canTransitionTo(\n   *   TrigramStance.GEON, // From Heaven\n   *   TrigramStance.GON,  // To Earth\n   *   player\n   * );\n   * ```\n   *\n   * @public\n   * @korean 자세전환가능확인\n   */\n  canTransitionTo(\n    fromStance: TrigramStance,\n    toStance: TrigramStance,\n    player: PlayerState\n  ): boolean {\n    if (fromStance === toStance) return true;\n\n    const cost = this.getTransitionCost(fromStance, toStance, player);\n\n    // Check if player has sufficient resources\n    const hasEnoughKi = player.ki >= cost.ki;\n    const hasEnoughStamina = player.stamina >= cost.stamina;\n\n    return hasEnoughKi && hasEnoughStamina;\n  }\n\n  /**\n   * Recommends the optimal stance for current combat situation.\n   *\n   * Calculates the least-cost stance transition from the player's current position.\n   * Uses combined cost of Ki, Stamina, and transition time to determine best option.\n   *\n   * **Algorithm**: Evaluates all eight stances and selects the one with minimum\n   * total cost (Ki + Stamina + Time).\n   *\n   * @param player - Player state with current stance\n   * @returns Recommended stance to transition to\n   *\n   * @example\n   * ```typescript\n   * const recommended = trigramSystem.recommendStance(player);\n   * console.log(`Consider switching to ${recommended}`);\n   * ```\n   *\n   * @public\n   * @korean 최적자세추천\n   */\n  recommendStance(player: PlayerState): TrigramStance {\n    const from = player.currentStance;\n    let best = from;\n    let bestScore = Infinity;\n\n    for (const to of TRIGRAM_STANCES_ORDER) {\n      const costObj: TrigramTransitionCost = this.getTransitionCost(from, to);\n      const score = costObj.ki + costObj.stamina + costObj.timeMilliseconds;\n      if (score < bestScore) {\n        bestScore = score;\n        best = to;\n      }\n    }\n\n    return best;\n  }\n\n  /**\n   * Calculates the resource cost for transitioning between stances.\n   *\n   * Determines Ki, Stamina, and time costs based on the I Ching philosophical\n   * distance between trigrams. Applies archetype-specific modifiers for favored stances.\n   *\n   * ## Cost Calculation\n   *\n   * - **Base Cost**: 10 Ki, 15 Stamina per difficulty point\n   * - **Base Time**: 500ms per difficulty point\n   * - **Archetype Modifier**: 0.8x for favored stances, 1.0x otherwise\n   * - **Same Stance**: Zero cost\n   *\n   * @param from - Starting stance\n   * @param to - Target stance\n   * @param player - Optional player for archetype modifiers\n   * @returns Transition cost breakdown\n   *\n   * @example\n   * ```typescript\n   * const cost = trigramSystem.getTransitionCost(\n   *   TrigramStance.GEON,\n   *   TrigramStance.TAE,\n   *   player\n   * );\n   * console.log(`Cost: ${cost.ki} Ki, ${cost.stamina} Stamina`);\n   * ```\n   *\n   * @public\n   * @korean 자세전환비용\n   */\n  public getTransitionCost(\n    from: TrigramStance,\n    to: TrigramStance,\n    player?: PlayerState\n  ): TrigramTransitionCost {\n    if (from === to) {\n      return {\n        ki: 0,\n        stamina: 0,\n        timeMilliseconds: 0, // neutral\n      };\n    }\n\n    const difficulty = TrigramCalculator.calculateTransitionDifficulty(\n      from,\n      to\n    );\n    const baseCost = 10;\n    const baseTime = 500;\n\n    let ki = Math.ceil(baseCost * difficulty);\n    let stamina = Math.ceil(baseCost * difficulty * 1.5);\n\n    // apply archetype stance‐change cost modifier if player provided\n    if (player) {\n      const archData = PLAYER_ARCHETYPES_DATA[player.archetype];\n      const favs = archData.favoredStances || [];\n      const mod = favs.includes(to) ? 0.8 : 1.0;\n      ki = Math.ceil(ki * mod);\n      stamina = Math.ceil(stamina * mod);\n    }\n\n    return {\n      ki,\n      stamina,\n      timeMilliseconds: Math.ceil(baseTime * difficulty),\n    };\n  }\n\n  /**\n   * Calculates stance effectiveness in combat matchup.\n   *\n   * Determines the multiplier advantage/disadvantage when one stance attacks another.\n   * Based on I Ching elemental relationships (e.g., Water extinguishes Fire).\n   *\n   * @param attackerStance - Attacking player's stance\n   * @param defenderStance - Defending player's stance\n   * @returns Effectiveness multiplier (0.5 = disadvantage, 1.0 = neutral, 1.5 = advantage)\n   *\n   * @example\n   * ```typescript\n   * const effectiveness = trigramSystem.calculateStanceEffectiveness(\n   *   TrigramStance.GAM,  // Water\n   *   TrigramStance.LI    // Fire\n   * ); // Returns > 1.0 (Water beats Fire)\n   * ```\n   *\n   * @public\n   * @korean 자세효과성계산\n   */\n  calculateStanceEffectiveness(\n    attackerStance: TrigramStance,\n    defenderStance: TrigramStance\n  ): number {\n    return this.calculator.calculateStanceEffectiveness(\n      attackerStance,\n      defenderStance\n    );\n  }\n\n  /**\n   * Gets bilingual name for a stance.\n   *\n   * Returns Korean (Hangul) and English names for display purposes.\n   *\n   * @param stance - Stance to get name for\n   * @returns Object with korean and english name properties\n   *\n   * @example\n   * ```typescript\n   * const name = trigramSystem.getStanceName(TrigramStance.GEON);\n   * console.log(`${name.korean} (${name.english})`); // \"건 (Heaven)\"\n   * ```\n   *\n   * @public\n   * @korean 자세이름조회\n   */\n  getStanceName(stance: TrigramStance): { korean: string; english: string } {\n    const stanceNames = {\n      [TrigramStance.GEON]: { korean: \"건\", english: \"Heaven\" },\n      [TrigramStance.TAE]: { korean: \"태\", english: \"Lake\" },\n      [TrigramStance.LI]: { korean: \"리\", english: \"Fire\" },\n      [TrigramStance.JIN]: { korean: \"진\", english: \"Thunder\" },\n      [TrigramStance.SON]: { korean: \"손\", english: \"Wind\" },\n      [TrigramStance.GAM]: { korean: \"감\", english: \"Water\" },\n      [TrigramStance.GAN]: { korean: \"간\", english: \"Mountain\" },\n      [TrigramStance.GON]: { korean: \"곤\", english: \"Earth\" },\n    };\n\n    return stanceNames[stance] || { korean: \"Unknown\", english: \"Unknown\" };\n  }\n\n  /**\n   * Gets the counter stance for opponent's current stance.\n   * \n   * Returns the stance that provides tactical advantage against the opponent's stance,\n   * based on I Ching elemental relationships. Using a counter stance provides a 1.2x\n   * damage multiplier in combat.\n   * \n   * **Korean Philosophy (상극 자세)**:\n   * - Water counters Heaven (flows around force)\n   * - Earth counters Lake (grounds and contains)\n   * - Wind counters Fire (disperses intensity)\n   * - Mountain counters Thunder (absorbs impact)\n   * \n   * @param opponentStance - Opponent's current stance\n   * @returns Counter stance that provides advantage\n   * \n   * @example\n   * ```typescript\n   * const counterStance = trigramSystem.getCounterStance(TrigramStance.GEON);\n   * console.log(counterStance); // TrigramStance.GAM (Water counters Heaven)\n   * ```\n   * \n   * @public\n   * @korean 상극자세조회\n   */\n  getCounterStance(opponentStance: TrigramStance): TrigramStance {\n    return STANCE_COUNTERS[opponentStance];\n  }\n\n  /**\n   * Checks if player's stance counters opponent's stance.\n   * \n   * Determines if the player has a tactical advantage through stance matchup.\n   * When true, player should receive a 1.2x damage multiplier for attacks.\n   * \n   * @param myStance - Player's current stance\n   * @param opponentStance - Opponent's current stance\n   * @returns True if player's stance counters opponent's stance\n   * \n   * @example\n   * ```typescript\n   * const hasAdvantage = trigramSystem.isCounterStance(\n   *   TrigramStance.GAM,  // My stance: Water\n   *   TrigramStance.GEON  // Opponent: Heaven\n   * ); // Returns true - Water counters Heaven\n   * \n   * if (hasAdvantage) {\n   *   damage *= 1.2; // Apply counter bonus\n   * }\n   * ```\n   * \n   * @public\n   * @korean 상극자세확인\n   */\n  isCounterStance(myStance: TrigramStance, opponentStance: TrigramStance): boolean {\n    return this.getCounterStance(opponentStance) === myStance;\n  }\n\n  /**\n   * Gets complete stance data for UI display.\n   *\n   * Returns structured data object containing stance ID and bilingual names.\n   *\n   * @param stance - Stance to get data for\n   * @returns Stance data object\n   *\n   * @public\n   * @korean 자세데이터조회\n   */\n  getCurrentStanceData(stance: TrigramStance): {\n    id: TrigramStance;\n    name: KoreanText;\n    korean: string;\n    english: string;\n  } {\n    const stanceName = this.getStanceName(stance);\n    return {\n      id: stance,\n      name: stanceName,\n      korean: stanceName.korean,\n      english: stanceName.english,\n    };\n  }\n\n  /**\n   * Validates a stance transition with detailed feedback.\n   *\n   * Checks if transition is valid and provides reason if not.\n   * More detailed than {@link canTransitionTo}, includes specific failure reasons.\n   *\n   * @param fromStance - Current stance\n   * @param toStance - Target stance\n   * @param player - Player state\n   * @returns Validation result with optional failure reason\n   *\n   * @example\n   * ```typescript\n   * const validation = trigramSystem.validateTransition(\n   *   TrigramStance.GEON,\n   *   TrigramStance.GON,\n   *   player\n   * );\n   * if (!validation.valid) {\n   *   console.error(validation.reason);\n   * }\n   * ```\n   *\n   * @public\n   * @korean 자세전환검증\n   */\n  validateTransition(\n    fromStance: TrigramStance,\n    toStance: TrigramStance,\n    player: PlayerState\n  ): { valid: boolean; reason?: string } {\n    if (fromStance === toStance) {\n      return { valid: true };\n    }\n\n    const cost = this.getTransitionCost(fromStance, toStance, player);\n\n    if (player.ki < cost.ki) {\n      return {\n        valid: false,\n        reason: `Insufficient Ki: need ${cost.ki}, have ${player.ki}`,\n      };\n    }\n\n    if (player.stamina < cost.stamina) {\n      return {\n        valid: false,\n        reason: `Insufficient Stamina: need ${cost.stamina}, have ${player.stamina}`,\n      };\n    }\n\n    return { valid: true };\n  }\n}\n\nexport default TrigramSystem;\n"],"mappings":"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"}
+{"version":3,"file":"TrigramSystem.js","names":[],"sources":["../../src/systems/TrigramSystem.ts"],"sourcesContent":["import { KoreanText, TrigramStance } from \"../types/common\";\nimport { PlayerState } from \"./player\";\n\nimport { TRIGRAM_STANCES_ORDER, TrigramTransitionCost } from \"./trigram\";\nimport { TrigramCalculator } from \"./trigram/TrigramCalculator\";\nimport { PLAYER_ARCHETYPES_DATA } from \"./types\";\n\n/**\n * Stance counter relationships based on I Ching philosophy\n * \n * Each stance has a counter stance that provides tactical advantage:\n * - **GEON (Heaven)** countered by **GAM (Water)** - Water flows around Heaven's force\n * - **TAE (Lake)** countered by **GON (Earth)** - Earth contains and grounds Lake\n * - **LI (Fire)** countered by **SON (Wind)** - Wind disperses Fire's intensity\n * - **JIN (Thunder)** countered by **GAN (Mountain)** - Mountain absorbs Thunder's impact\n * - **SON (Wind)** countered by **GEON (Heaven)** - Heaven's force overpowers Wind\n * - **GAM (Water)** countered by **TAE (Lake)** - Lake contains and channels Water\n * - **GAN (Mountain)** countered by **LI (Fire)** - Fire melts Mountain's solidity\n * - **GON (Earth)** countered by **JIN (Thunder)** - Thunder breaks Earth's stability\n * \n * Using a counter stance provides a 1.2x damage multiplier in combat.\n * \n * @korean 팔괘 상극 관계 (Eight Trigram Counter Relationships)\n */\nexport const STANCE_COUNTERS: Record<TrigramStance, TrigramStance> = {\n  [TrigramStance.GEON]: TrigramStance.GAM, // Water flows around Heaven\n  [TrigramStance.TAE]: TrigramStance.GON, // Earth grounds Lake\n  [TrigramStance.LI]: TrigramStance.SON, // Wind disperses Fire\n  [TrigramStance.JIN]: TrigramStance.GAN, // Mountain absorbs Thunder\n  [TrigramStance.SON]: TrigramStance.GEON, // Heaven overpowers Wind\n  [TrigramStance.GAM]: TrigramStance.TAE, // Lake contains Water\n  [TrigramStance.GAN]: TrigramStance.LI, // Fire melts Mountain\n  [TrigramStance.GON]: TrigramStance.JIN, // Thunder breaks Earth\n};\n\n/**\n * Counter stance damage multiplier\n * Applied when using a counter stance against opponent's stance\n * \n * @korean 상극 자세 피해 배율\n */\nexport const COUNTER_STANCE_DAMAGE_MULTIPLIER = 1.2;\n\n/**\n * Apply counter stance damage bonus when appropriate.\n *\n * This helper should be used by combat damage calculation code after it has\n * determined whether the current stance matchup is a counter stance\n * (for example, via an `isCounterStance` check elsewhere in the system).\n *\n * When `isCounterStance` is `true`, the base damage is multiplied by\n * {@link COUNTER_STANCE_DAMAGE_MULTIPLIER}. Non-positive damage values are\n * returned unchanged to avoid introducing invalid negative or zero scaling.\n *\n * @param baseDamage - The pre-modifier damage value.\n * @param isCounterStance - Whether the attacker is using a counter stance.\n * @returns The adjusted damage value with counter stance bonus applied when relevant.\n *\n * @example\n * ```ts\n * const isCounter = trigramSystem.isCounterStance(attackerStance, defenderStance);\n * const finalDamage = applyCounterStanceDamage(baseDamage, isCounter);\n * ```\n *\n * @korean\n * 반격 자세(상극 자세)일 때만 피해 배율(1.2배)을 적용합니다.\n */\nexport function applyCounterStanceDamage(\n  baseDamage: number,\n  isCounterStance: boolean\n): number {\n  if (!isCounterStance || baseDamage <= 0) {\n    return baseDamage;\n  }\n\n  return baseDamage * COUNTER_STANCE_DAMAGE_MULTIPLIER;\n}\n\n/**\n * System for managing Eight Trigram (팔괘) stance transitions and combat calculations.\n *\n * **Korean**: 팔괘 시스템 (Eight Trigram System)\n *\n * The TrigramSystem implements the core mechanics of the Eight Trigram martial arts system,\n * managing stance transitions, calculating effectiveness, and determining resource costs.\n * Based on I Ching (易經) philosophy adapted for tactical combat.\n *\n * ## Key Responsibilities\n *\n * - Validate stance transitions based on Ki and Stamina costs\n * - Calculate transition difficulty between stances\n * - Recommend optimal stance choices\n * - Determine stance effectiveness in combat matchups\n * - Apply archetype-specific modifiers to transitions\n *\n * @example\n * ```typescript\n * const trigramSystem = new TrigramSystem();\n *\n * // Check if transition is possible\n * const canTransition = trigramSystem.canTransitionTo(\n *   TrigramStance.GEON,\n *   TrigramStance.GAM,\n *   playerState\n * );\n *\n * // Get recommended stance\n * const recommendedStance = trigramSystem.recommendStance(playerState);\n * ```\n *\n * @category Trigram System\n * @korean 팔괘시스템\n */\nexport class TrigramSystem {\n  private calculator: TrigramCalculator;\n\n  /**\n   * Creates a new TrigramSystem instance.\n   *\n   * Initializes the internal calculator for stance effectiveness and transition difficulty.\n   */\n  constructor() {\n    this.calculator = new TrigramCalculator();\n  }\n\n  /**\n   * Gets the defensive/offensive characteristic of a stance.\n   *\n   * **Korean**: 자세 특성 조회 (Stance Characteristic Query)\n   *\n   * Returns whether a stance is primarily defensive, offensive, or balanced.\n   * This information is useful for UI display and tactical decision-making.\n   *\n   * ## Stance Classifications\n   *\n   * - **Defensive**: 간 (GAN/Mountain), 곤 (GON/Earth) - Protect vital areas\n   * - **Offensive**: 건 (GEON/Heaven), 진 (JIN/Thunder) - Expose for power\n   * - **Balanced**: 태 (TAE/Lake), 리 (LI/Fire), 손 (SON/Wind), 감 (GAM/Water)\n   *\n   * @param stance - Trigram stance to query\n   * @returns \"defensive\", \"offensive\", or \"balanced\"\n   *\n   * @example\n   * ```typescript\n   * const characteristic = trigramSystem.getStanceCharacteristic(TrigramStance.GAN);\n   * console.log(characteristic); // \"defensive\"\n   *\n   * const offensive = trigramSystem.getStanceCharacteristic(TrigramStance.GEON);\n   * console.log(offensive); // \"offensive\"\n   * ```\n   *\n   * @korean 자세특성조회\n   */\n  getStanceCharacteristic(\n    stance: TrigramStance\n  ): \"defensive\" | \"offensive\" | \"balanced\" {\n    switch (stance) {\n      case TrigramStance.GAN: // Mountain - Immovable defense\n      case TrigramStance.GON: // Earth - Grounding and stability\n        return \"defensive\";\n\n      case TrigramStance.GEON: // Heaven - Direct force and aggression\n      case TrigramStance.JIN: // Thunder - Explosive power\n        return \"offensive\";\n\n      default:\n        return \"balanced\";\n    }\n  }\n\n  /**\n   * Checks if a stance provides defensive advantages.\n   *\n   * **Korean**: 방어 자세 확인 (Check Defensive Stance)\n   *\n   * @param stance - Trigram stance to check\n   * @returns true if stance is defensive, false otherwise\n   *\n   * @example\n   * ```typescript\n   * if (trigramSystem.isDefensiveStance(player.currentStance)) {\n   *   console.log(\"Player is in defensive posture\");\n   * }\n   * ```\n   *\n   * @korean 방어자세확인\n   */\n  isDefensiveStance(stance: TrigramStance): boolean {\n    return this.getStanceCharacteristic(stance) === \"defensive\";\n  }\n\n  /**\n   * Checks if a stance provides offensive advantages.\n   *\n   * **Korean**: 공격 자세 확인 (Check Offensive Stance)\n   *\n   * @param stance - Trigram stance to check\n   * @returns true if stance is offensive, false otherwise\n   *\n   * @example\n   * ```typescript\n   * if (trigramSystem.isOffensiveStance(player.currentStance)) {\n   *   console.log(\"Player is in offensive posture\");\n   * }\n   * ```\n   *\n   * @korean 공격자세확인\n   */\n  isOffensiveStance(stance: TrigramStance): boolean {\n    return this.getStanceCharacteristic(stance) === \"offensive\";\n  }\n\n  /**\n   * Checks if a player can transition from one stance to another.\n   *\n   * Validates that the player has sufficient Ki (氣) and Stamina resources\n   * to perform the stance transition. Same-stance transitions are always valid.\n   *\n   * @param fromStance - Current stance\n   * @param toStance - Target stance\n   * @param player - Player state with current Ki and Stamina\n   * @returns true if transition is possible, false otherwise\n   *\n   * @example\n   * ```typescript\n   * const canChange = trigramSystem.canTransitionTo(\n   *   TrigramStance.GEON, // From Heaven\n   *   TrigramStance.GON,  // To Earth\n   *   player\n   * );\n   * ```\n   *\n   * @korean 자세전환가능확인\n   */\n  canTransitionTo(\n    fromStance: TrigramStance,\n    toStance: TrigramStance,\n    player: PlayerState\n  ): boolean {\n    if (fromStance === toStance) return true;\n\n    const cost = this.getTransitionCost(fromStance, toStance, player);\n\n    // Check if player has sufficient resources\n    const hasEnoughKi = player.ki >= cost.ki;\n    const hasEnoughStamina = player.stamina >= cost.stamina;\n\n    return hasEnoughKi && hasEnoughStamina;\n  }\n\n  /**\n   * Recommends the optimal stance for current combat situation.\n   *\n   * Calculates the least-cost stance transition from the player's current position.\n   * Uses combined cost of Ki, Stamina, and transition time to determine best option.\n   *\n   * **Algorithm**: Evaluates all eight stances and selects the one with minimum\n   * total cost (Ki + Stamina + Time).\n   *\n   * @param player - Player state with current stance\n   * @returns Recommended stance to transition to\n   *\n   * @example\n   * ```typescript\n   * const recommended = trigramSystem.recommendStance(player);\n   * console.log(`Consider switching to ${recommended}`);\n   * ```\n   *\n   * @korean 최적자세추천\n   */\n  recommendStance(player: PlayerState): TrigramStance {\n    const from = player.currentStance;\n    let best = from;\n    let bestScore = Infinity;\n\n    for (const to of TRIGRAM_STANCES_ORDER) {\n      const costObj: TrigramTransitionCost = this.getTransitionCost(from, to);\n      const score = costObj.ki + costObj.stamina + costObj.timeMilliseconds;\n      if (score < bestScore) {\n        bestScore = score;\n        best = to;\n      }\n    }\n\n    return best;\n  }\n\n  /**\n   * Calculates the resource cost for transitioning between stances.\n   *\n   * Determines Ki, Stamina, and time costs based on the I Ching philosophical\n   * distance between trigrams. Applies archetype-specific modifiers for favored stances.\n   *\n   * ## Cost Calculation\n   *\n   * - **Base Cost**: 10 Ki, 15 Stamina per difficulty point\n   * - **Base Time**: 500ms per difficulty point\n   * - **Archetype Modifier**: 0.8x for favored stances, 1.0x otherwise\n   * - **Same Stance**: Zero cost\n   *\n   * @param from - Starting stance\n   * @param to - Target stance\n   * @param player - Optional player for archetype modifiers\n   * @returns Transition cost breakdown\n   *\n   * @example\n   * ```typescript\n   * const cost = trigramSystem.getTransitionCost(\n   *   TrigramStance.GEON,\n   *   TrigramStance.TAE,\n   *   player\n   * );\n   * console.log(`Cost: ${cost.ki} Ki, ${cost.stamina} Stamina`);\n   * ```\n   *\n   * @korean 자세전환비용\n   */\n  public getTransitionCost(\n    from: TrigramStance,\n    to: TrigramStance,\n    player?: PlayerState\n  ): TrigramTransitionCost {\n    if (from === to) {\n      return {\n        ki: 0,\n        stamina: 0,\n        timeMilliseconds: 0, // neutral\n      };\n    }\n\n    const difficulty = TrigramCalculator.calculateTransitionDifficulty(\n      from,\n      to\n    );\n    const baseCost = 10;\n    const baseTime = 500;\n\n    let ki = Math.ceil(baseCost * difficulty);\n    let stamina = Math.ceil(baseCost * difficulty * 1.5);\n\n    // apply archetype stance‐change cost modifier if player provided\n    if (player) {\n      const archData = PLAYER_ARCHETYPES_DATA[player.archetype];\n      const favs = archData.favoredStances || [];\n      const mod = favs.includes(to) ? 0.8 : 1.0;\n      ki = Math.ceil(ki * mod);\n      stamina = Math.ceil(stamina * mod);\n    }\n\n    return {\n      ki,\n      stamina,\n      timeMilliseconds: Math.ceil(baseTime * difficulty),\n    };\n  }\n\n  /**\n   * Calculates stance effectiveness in combat matchup.\n   *\n   * Determines the multiplier advantage/disadvantage when one stance attacks another.\n   * Based on I Ching elemental relationships (e.g., Water extinguishes Fire).\n   *\n   * @param attackerStance - Attacking player's stance\n   * @param defenderStance - Defending player's stance\n   * @returns Effectiveness multiplier (0.5 = disadvantage, 1.0 = neutral, 1.5 = advantage)\n   *\n   * @example\n   * ```typescript\n   * const effectiveness = trigramSystem.calculateStanceEffectiveness(\n   *   TrigramStance.GAM,  // Water\n   *   TrigramStance.LI    // Fire\n   * ); // Returns > 1.0 (Water beats Fire)\n   * ```\n   *\n   * @korean 자세효과성계산\n   */\n  calculateStanceEffectiveness(\n    attackerStance: TrigramStance,\n    defenderStance: TrigramStance\n  ): number {\n    return this.calculator.calculateStanceEffectiveness(\n      attackerStance,\n      defenderStance\n    );\n  }\n\n  /**\n   * Gets bilingual name for a stance.\n   *\n   * Returns Korean (Hangul) and English names for display purposes.\n   *\n   * @param stance - Stance to get name for\n   * @returns Object with korean and english name properties\n   *\n   * @example\n   * ```typescript\n   * const name = trigramSystem.getStanceName(TrigramStance.GEON);\n   * console.log(`${name.korean} (${name.english})`); // \"건 (Heaven)\"\n   * ```\n   *\n   * @korean 자세이름조회\n   */\n  getStanceName(stance: TrigramStance): { korean: string; english: string } {\n    const stanceNames = {\n      [TrigramStance.GEON]: { korean: \"건\", english: \"Heaven\" },\n      [TrigramStance.TAE]: { korean: \"태\", english: \"Lake\" },\n      [TrigramStance.LI]: { korean: \"리\", english: \"Fire\" },\n      [TrigramStance.JIN]: { korean: \"진\", english: \"Thunder\" },\n      [TrigramStance.SON]: { korean: \"손\", english: \"Wind\" },\n      [TrigramStance.GAM]: { korean: \"감\", english: \"Water\" },\n      [TrigramStance.GAN]: { korean: \"간\", english: \"Mountain\" },\n      [TrigramStance.GON]: { korean: \"곤\", english: \"Earth\" },\n    };\n\n    return stanceNames[stance] || { korean: \"Unknown\", english: \"Unknown\" };\n  }\n\n  /**\n   * Gets the counter stance for opponent's current stance.\n   * \n   * Returns the stance that provides tactical advantage against the opponent's stance,\n   * based on I Ching elemental relationships. Using a counter stance provides a 1.2x\n   * damage multiplier in combat.\n   * \n   * **Korean Philosophy (상극 자세)**:\n   * - Water counters Heaven (flows around force)\n   * - Earth counters Lake (grounds and contains)\n   * - Wind counters Fire (disperses intensity)\n   * - Mountain counters Thunder (absorbs impact)\n   * \n   * @param opponentStance - Opponent's current stance\n   * @returns Counter stance that provides advantage\n   * \n   * @example\n   * ```typescript\n   * const counterStance = trigramSystem.getCounterStance(TrigramStance.GEON);\n   * console.log(counterStance); // TrigramStance.GAM (Water counters Heaven)\n   * ```\n   * \n   * @korean 상극자세조회\n   */\n  getCounterStance(opponentStance: TrigramStance): TrigramStance {\n    return STANCE_COUNTERS[opponentStance];\n  }\n\n  /**\n   * Checks if player's stance counters opponent's stance.\n   * \n   * Determines if the player has a tactical advantage through stance matchup.\n   * When true, player should receive a 1.2x damage multiplier for attacks.\n   * \n   * @param myStance - Player's current stance\n   * @param opponentStance - Opponent's current stance\n   * @returns True if player's stance counters opponent's stance\n   * \n   * @example\n   * ```typescript\n   * const hasAdvantage = trigramSystem.isCounterStance(\n   *   TrigramStance.GAM,  // My stance: Water\n   *   TrigramStance.GEON  // Opponent: Heaven\n   * ); // Returns true - Water counters Heaven\n   * \n   * if (hasAdvantage) {\n   *   damage *= 1.2; // Apply counter bonus\n   * }\n   * ```\n   * \n   * @korean 상극자세확인\n   */\n  isCounterStance(myStance: TrigramStance, opponentStance: TrigramStance): boolean {\n    return this.getCounterStance(opponentStance) === myStance;\n  }\n\n  /**\n   * Gets complete stance data for UI display.\n   *\n   * Returns structured data object containing stance ID and bilingual names.\n   *\n   * @param stance - Stance to get data for\n   * @returns Stance data object\n   *\n   * @korean 자세데이터조회\n   */\n  getCurrentStanceData(stance: TrigramStance): {\n    id: TrigramStance;\n    name: KoreanText;\n    korean: string;\n    english: string;\n  } {\n    const stanceName = this.getStanceName(stance);\n    return {\n      id: stance,\n      name: stanceName,\n      korean: stanceName.korean,\n      english: stanceName.english,\n    };\n  }\n\n  /**\n   * Validates a stance transition with detailed feedback.\n   *\n   * Checks if transition is valid and provides reason if not.\n   * More detailed than {@link canTransitionTo}, includes specific failure reasons.\n   *\n   * @param fromStance - Current stance\n   * @param toStance - Target stance\n   * @param player - Player state\n   * @returns Validation result with optional failure reason\n   *\n   * @example\n   * ```typescript\n   * const validation = trigramSystem.validateTransition(\n   *   TrigramStance.GEON,\n   *   TrigramStance.GON,\n   *   player\n   * );\n   * if (!validation.valid) {\n   *   console.error(validation.reason);\n   * }\n   * ```\n   *\n   * @korean 자세전환검증\n   */\n  validateTransition(\n    fromStance: TrigramStance,\n    toStance: TrigramStance,\n    player: PlayerState\n  ): { valid: boolean; reason?: string } {\n    if (fromStance === toStance) {\n      return { valid: true };\n    }\n\n    const cost = this.getTransitionCost(fromStance, toStance, player);\n\n    if (player.ki < cost.ki) {\n      return {\n        valid: false,\n        reason: `Insufficient Ki: need ${cost.ki}, have ${player.ki}`,\n      };\n    }\n\n    if (player.stamina < cost.stamina) {\n      return {\n        valid: false,\n        reason: `Insufficient Stamina: need ${cost.stamina}, have ${player.stamina}`,\n      };\n    }\n\n    return { valid: true };\n  }\n}\n\nexport default TrigramSystem;\n"],"mappings":"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"}

package/lib/systems/VitalPointSystem.d.ts

@@ -52,7 +52,6 @@
  * }
  * ```
  *
- * @public
  * @category Vital Point System
  * @korean 급소시스템
  */
@@ -84,7 +83,6 @@ export declare class VitalPointSystem {
      * vitalPointSystem.setCurrentHour(20); // 8 PM - Pericardium peak time
      * ```
      *
-     * @public
      * @korean 시간설정
      */
     setCurrentHour(hour: number): void;
@@ -95,7 +93,6 @@ export declare class VitalPointSystem {
      *
      * @returns Current hour (0-23)
      *
-     * @public
      * @korean 시간조회
      */
     getCurrentHour(): number;
@@ -107,7 +104,6 @@ export declare class VitalPointSystem {
      * @param meridianId - ID of the meridian
      * @param disruptionLevel - Disruption level (0-1, where 1 is fully blocked)
      *
-     * @public
      * @korean 경락차단업데이트
      */
     setMeridianDisruption(meridianId: string, disruptionLevel: number): void;
@@ -119,7 +115,6 @@ export declare class VitalPointSystem {
      * @param meridianId - ID of the meridian
      * @returns Disruption level (0-1)
      *
-     * @public
      * @korean 경락차단조회
      */
     getMeridianDisruption(meridianId: string): number;
@@ -128,7 +123,6 @@ export declare class VitalPointSystem {
      *
      * **Korean**: 경락 상태 초기화
      *
-     * @public
      * @korean 경락초기화
      */
     clearMeridianDisruptions(): void;
@@ -182,7 +176,6 @@ export declare class VitalPointSystem {
      * );
      * ```
      *
-     * @public
      * @korean 타격처리
      */
     processHit(targetPosition: Position, _hitBox: {
@@ -204,7 +197,6 @@ export declare class VitalPointSystem {
      * }
      * ```
      *
-     * @public
      * @korean 급소조회
      */
     getVitalPointById(id: string): VitalPoint | null;
@@ -219,7 +211,6 @@ export declare class VitalPointSystem {
      * console.log(`${allPoints.length} vital points registered`);
      * ```
      *
-     * @public
      * @korean 급소목록조회
      */
     getVitalPoints(): readonly VitalPoint[];
@@ -251,7 +242,6 @@ export declare class VitalPointSystem {
      * );
      * ```
      *
-     * @public
      * @korean 기술타격계산
      */
     calculateHit(technique: any, attackerPosition: Position, _defenderPosition: Position, // Prefixed with underscore to indicate intentionally unused

package/lib/systems/VitalPointSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VitalPointSystem.d.ts","sourceRoot":"","sources":["../../src/systems/VitalPointSystem.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,OAAO,EACL,eAAe,EACf,QAAQ,EACR,aAAa,EAEd,MAAM,iBAAiB,CAAC;AASzB,OAAO,EAAE,UAAU,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAQrE,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,WAAW,CAAoB;IACvC,OAAO,CAAC,cAAc,CAAkC;IACxD,OAAO,CAAC,WAAW,CAAc;IAEjC;;;;;;;OAOG;gBACS,WAAW,GAAE,MAAW;IAMpC;;;;;;;;;;;;;;;OAeG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAOlC;;;;;;;;;OASG;IACH,cAAc,IAAI,MAAM;IAIxB;;;;;;;;;;OAUG;IACH,qBAAqB,CAAC,UAAU,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG,IAAI;IAOxE;;;;;;;;;;OAUG;IACH,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;IAIjD;;;;;;;OAOG;IACH,wBAAwB,IAAI,IAAI;IAIhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoDG;IACH,UAAU,CACR,cAAc,EAAE,QAAQ,EACxB,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAAE,4DAA4D;IACxG,oBAAoB,CAAC,EAAE,MAAM,GAAG,IAAI,EACpC,IAAI,CAAC,EAAE,MAAM,EACb,iBAAiB,CAAC,EAAE,eAAe,EACnC,iBAAiB,CAAC,EAAE,eAAe,EACnC,cAAc,CAAC,EAAE,aAAa,GAC7B,mBAAmB;IA6DtB;;;;;;;;;;;;;;;;OAgBG;IACH,iBAAiB,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI;IAIhD;;;;;;;;;;;;;OAaG;IACH,cAAc,IAAI,SAAS,UAAU,EAAE;IAIvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,YAAY,CAEV,SAAS,EAAE,GAAG,EACd,gBAAgB,EAAE,QAAQ,EAC1B,iBAAiB,EAAE,QAAQ,EAAE,4DAA4D;IAEzF,eAAe,EAAE,GAAG,GACnB,mBAAmB;IAsCtB;;;;;;;;;;OAUG;IACH,OAAO,CAAC,qBAAqB;IAiB7B;;;;;;;;;OASG;IACH,OAAO,CAAC,iBAAiB;IAMzB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,OAAO,CAAC,sBAAsB;IA+F9B;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,mBAAmB;IAS3B;;;;;;;;OAQG;IACH,OAAO,CAAC,qBAAqB;CAI9B;AAED,eAAe,gBAAgB,CAAC"}
+{"version":3,"file":"VitalPointSystem.d.ts","sourceRoot":"","sources":["../../src/systems/VitalPointSystem.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,OAAO,EACL,eAAe,EACf,QAAQ,EACR,aAAa,EAEd,MAAM,iBAAiB,CAAC;AASzB,OAAO,EAAE,UAAU,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAQrE,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,WAAW,CAAoB;IACvC,OAAO,CAAC,cAAc,CAAkC;IACxD,OAAO,CAAC,WAAW,CAAc;IAEjC;;;;;;;OAOG;gBACS,WAAW,GAAE,MAAW;IAKpC;;;;;;;;;;;;;;OAcG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAOlC;;;;;;;;OAQG;IACH,cAAc,IAAI,MAAM;IAIxB;;;;;;;;;OASG;IACH,qBAAqB,CAAC,UAAU,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG,IAAI;IAOxE;;;;;;;;;OASG;IACH,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;IAIjD;;;;;;OAMG;IACH,wBAAwB,IAAI,IAAI;IAIhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmDG;IACH,UAAU,CACR,cAAc,EAAE,QAAQ,EACxB,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAAE,4DAA4D;IACxG,oBAAoB,CAAC,EAAE,MAAM,GAAG,IAAI,EACpC,IAAI,CAAC,EAAE,MAAM,EACb,iBAAiB,CAAC,EAAE,eAAe,EACnC,iBAAiB,CAAC,EAAE,eAAe,EACnC,cAAc,CAAC,EAAE,aAAa,GAC7B,mBAAmB;IA2DtB;;;;;;;;;;;;;;;OAeG;IACH,iBAAiB,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI;IAIhD;;;;;;;;;;;;OAYG;IACH,cAAc,IAAI,SAAS,UAAU,EAAE;IAIvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,YAAY,CAEV,SAAS,EAAE,GAAG,EACd,gBAAgB,EAAE,QAAQ,EAC1B,iBAAiB,EAAE,QAAQ,EAAE,4DAA4D;IAEzF,eAAe,EAAE,GAAG,GACnB,mBAAmB;IAoCtB;;;;;;;;;;OAUG;IACH,OAAO,CAAC,qBAAqB;IAiB7B;;;;;;;;;OASG;IACH,OAAO,CAAC,iBAAiB;IAMzB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,OAAO,CAAC,sBAAsB;IAwF9B;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,mBAAmB;IAS3B;;;;;;;;OAQG;IACH,OAAO,CAAC,qBAAqB;CAG9B;AAED,eAAe,gBAAgB,CAAC"}

package/lib/systems/VitalPointSystem.js

@@ -58,7 +58,6 @@ import { calculateEnhancedVulnerability, calculateMeridianFlow, generateMeridian
 * }
 * ```
 *
-* @public
 * @category Vital Point System
 * @korean 급소시스템
 */
@@ -95,7 +94,6 @@ var VitalPointSystem = class {
 	* vitalPointSystem.setCurrentHour(20); // 8 PM - Pericardium peak time
 	* ```
 	*
-	* @public
 	* @korean 시간설정
 	*/
 	setCurrentHour(hour) {
@@ -109,7 +107,6 @@ var VitalPointSystem = class {
 	*
 	* @returns Current hour (0-23)
 	*
-	* @public
 	* @korean 시간조회
 	*/
 	getCurrentHour() {
@@ -123,7 +120,6 @@ var VitalPointSystem = class {
 	* @param meridianId - ID of the meridian
 	* @param disruptionLevel - Disruption level (0-1, where 1 is fully blocked)
 	*
-	* @public
 	* @korean 경락차단업데이트
 	*/
 	setMeridianDisruption(meridianId, disruptionLevel) {
@@ -137,7 +133,6 @@ var VitalPointSystem = class {
 	* @param meridianId - ID of the meridian
 	* @returns Disruption level (0-1)
 	*
-	* @public
 	* @korean 경락차단조회
 	*/
 	getMeridianDisruption(meridianId) {
@@ -148,7 +143,6 @@ var VitalPointSystem = class {
 	*
 	* **Korean**: 경락 상태 초기화
 	*
-	* @public
 	* @korean 경락초기화
 	*/
 	clearMeridianDisruptions() {
@@ -204,7 +198,6 @@ var VitalPointSystem = class {
 	* );
 	* ```
 	*
-	* @public
 	* @korean 타격처리
 	*/
 	processHit(targetPosition, _hitBox, targetedVitalPointId, hour, attackerArchetype, defenderArchetype, defenderStance) {
@@ -245,7 +238,6 @@ var VitalPointSystem = class {
 	* }
 	* ```
 	*
-	* @public
 	* @korean 급소조회
 	*/
 	getVitalPointById(id) {
@@ -262,7 +254,6 @@ var VitalPointSystem = class {
 	* console.log(`${allPoints.length} vital points registered`);
 	* ```
 	*
-	* @public
 	* @korean 급소목록조회
 	*/
 	getVitalPoints() {
@@ -296,7 +287,6 @@ var VitalPointSystem = class {
 	* );
 	* ```
 	*
-	* @public
 	* @korean 기술타격계산
 	*/
 	calculateHit(technique, attackerPosition, _defenderPosition, _defenderStance) {

package/lib/systems/VitalPointSystem.js.map

@@ -1 +1 @@
-{"version":3,"file":"VitalPointSystem.js","names":[],"sources":["../../src/systems/VitalPointSystem.ts"],"sourcesContent":["/**\n * System for managing Korean martial arts vital point (급소) targeting and damage calculation.\n *\n * **Korean**: 급소 시스템 (Vital Point System)\n *\n * The VitalPointSystem implements anatomical targeting mechanics based on traditional\n * Korean martial arts knowledge of 70 vital points (급소). It handles hit detection,\n * damage calculation, and status effect application for precise strikes.\n *\n * ## Vital Point Philosophy\n *\n * Korean martial arts identify specific anatomical locations that, when struck precisely,\n * can cause disproportionate effects. The system categorizes points by:\n *\n * - **Location**: Head, neck, torso, limbs, and core\n * - **Category**: Neurological, vascular, respiratory, muscular, skeletal, etc.\n * - **Severity**: Minor, moderate, major, critical, lethal\n * - **Effects**: Unconsciousness, paralysis, pain, stunning, etc.\n *\n * ## Meridian Integration (경락 통합)\n *\n * The system integrates Traditional Korean Medicine (TKM) meridian theory:\n * - **Time-of-Day Flow**: +30% effectiveness at meridian peak hours\n * - **Meridian Disruption**: Status effects from energy flow blockage\n * - **Elemental Relationships**: 五行 (Wu Xing) elemental advantages\n *\n * ## Key Features\n *\n * - Distance-based hit detection with accuracy falloff\n * - Severity multipliers for damage calculation\n * - Targeted vs. proximity-based strikes\n * - Bilingual Korean-English vital point names\n * - Realistic anatomical positioning\n * - Meridian state tracking and flow calculation\n *\n * @example\n * ```typescript\n * const vitalPointSystem = new VitalPointSystem();\n *\n * // Process a strike at specific position with time-of-day\n * const result = vitalPointSystem.processHit(\n *   { x: 100, y: 50 }, // Target position\n *   { width: 10, height: 10 }, // Hit box\n *   \"GB-20\", // Optional: target specific vital point\n *   14 // Optional: hour of day for meridian flow\n * );\n *\n * if (result.hit && result.vitalPointHit) {\n *   console.log(`Hit ${result.vitalPointHit.names.english}!`);\n *   console.log(`Damage: ${result.damage}, Severity: ${result.severity}`);\n *   console.log(`Meridian bonus: ${result.meridianMultiplier}x`);\n * }\n * ```\n *\n * @public\n * @category Vital Point System\n * @korean 급소시스템\n */\nimport {\n  PlayerArchetype,\n  Position,\n  TrigramStance,\n  VitalPointSeverity,\n} from \"../types/common\";\nimport { convertToStatusEffect } from \"./EffectCalculator\";\nimport { StatusEffect } from \"./types\";\nimport {\n  calculateEnhancedVulnerability,\n  calculateMeridianFlow,\n  generateMeridianEffects,\n} from \"./vitalpoint/KoreanAnatomy\";\nimport { getMeridiansForVitalPoint } from \"./vitalpoint/MeridianVitalPointMapping\";\nimport { VitalPoint, VitalPointHitResult } from \"./vitalpoint/types\";\nimport { VITAL_POINTS_DATA } from \"./vitalpoint/VitalPointsData\";\n\n/**\n * Amount of meridian disruption added per vital point hit (15%)\n */\nconst DISRUPTION_INCREMENT_PER_HIT = 0.15;\n\nexport class VitalPointSystem {\n  private vitalPoints: VitalPoint[] = [];\n  private meridianStates: Map<string, number> = new Map(); // Tracks disruption level per meridian\n  private currentHour: number = 12; // Default to noon\n\n  /**\n   * Creates a new VitalPointSystem instance.\n   *\n   * Initializes the system with comprehensive Korean vital points database\n   * and meridian state tracking.\n   *\n   * @param initialHour - Optional initial hour of day (0-23) for meridian flow calculations\n   */\n  constructor(initialHour: number = 12) {\n    // Initialize with comprehensive Korean vital points database\n    this.initializeVitalPoints();\n    this.currentHour = initialHour;\n  }\n\n  /**\n   * Sets the current hour of day for meridian flow calculations.\n   *\n   * **Korean**: 시간 설정\n   *\n   * @param hour - Hour of day (0-23)\n   * @throws Error if hour is not a finite number\n   *\n   * @example\n   * ```typescript\n   * vitalPointSystem.setCurrentHour(20); // 8 PM - Pericardium peak time\n   * ```\n   *\n   * @public\n   * @korean 시간설정\n   */\n  setCurrentHour(hour: number): void {\n    if (!Number.isFinite(hour)) {\n      throw new Error(\"Hour must be a finite number\");\n    }\n    this.currentHour = Math.max(0, Math.min(23, Math.floor(hour)));\n  }\n\n  /**\n   * Gets the current hour of day used for meridian calculations.\n   *\n   * **Korean**: 현재 시간 조회\n   *\n   * @returns Current hour (0-23)\n   *\n   * @public\n   * @korean 시간조회\n   */\n  getCurrentHour(): number {\n    return this.currentHour;\n  }\n\n  /**\n   * Updates meridian disruption state for a specific meridian.\n   *\n   * **Korean**: 경락 차단 상태 업데이트\n   *\n   * @param meridianId - ID of the meridian\n   * @param disruptionLevel - Disruption level (0-1, where 1 is fully blocked)\n   *\n   * @public\n   * @korean 경락차단업데이트\n   */\n  setMeridianDisruption(meridianId: string, disruptionLevel: number): void {\n    this.meridianStates.set(\n      meridianId,\n      Math.max(0, Math.min(1, disruptionLevel)),\n    );\n  }\n\n  /**\n   * Gets the current disruption level for a meridian.\n   *\n   * **Korean**: 경락 차단 수준 조회\n   *\n   * @param meridianId - ID of the meridian\n   * @returns Disruption level (0-1)\n   *\n   * @public\n   * @korean 경락차단조회\n   */\n  getMeridianDisruption(meridianId: string): number {\n    return this.meridianStates.get(meridianId) ?? 0;\n  }\n\n  /**\n   * Clears all meridian disruption states (e.g., after rest or healing).\n   *\n   * **Korean**: 경락 상태 초기화\n   *\n   * @public\n   * @korean 경락초기화\n   */\n  clearMeridianDisruptions(): void {\n    this.meridianStates.clear();\n  }\n\n  /**\n   * Processes a hit at a specific position to determine vital point impact.\n   *\n   * Evaluates whether a strike lands on or near a vital point, calculating\n   * damage and effects based on accuracy, severity, and meridian flow.\n   * Supports both targeted strikes (specific vital point ID) and proximity-based detection.\n   *\n   * Enhanced with archetype-specific modifiers for realistic combat simulation.\n   *\n   * ## Hit Detection Algorithm\n   *\n   * 1. If targetedVitalPointId provided, validate that specific point\n   * 2. Otherwise, find closest vital point to target position\n   * 3. Calculate distance from strike to vital point\n   * 4. Apply accuracy falloff based on distance (max 50px)\n   * 5. Calculate meridian flow bonus based on time of day\n   * 6. Apply meridian disruption if applicable\n   * 7. Apply archetype offensive/defensive modifiers\n   * 8. Apply enhanced vulnerability with stance and anatomical zone\n   * 9. Return hit result with damage multipliers and effects\n   *\n   * @param targetPosition - Position where strike lands\n   * @param _hitBox - Size of hit box (currently unused, reserved for future)\n   * @param targetedVitalPointId - Optional specific vital point being targeted\n   * @param hour - Optional hour of day (0-23) for meridian flow calculation\n   * @param attackerArchetype - Optional attacker's archetype (default: MUSA)\n   * @param defenderArchetype - Optional defender's archetype (default: MUSA)\n   * @param defenderStance - Optional defender's trigram stance (default: GEON)\n   * @returns Hit result with damage, effects, severity, and meridian multiplier\n   *\n   * @example\n   * ```typescript\n   * // Proximity-based strike\n   * const result1 = vitalPointSystem.processHit(\n   *   { x: 100, y: 50 },\n   *   { width: 10, height: 10 }\n   * );\n   *\n   * // Targeted strike with archetype modifiers and stance\n   * const result2 = vitalPointSystem.processHit(\n   *   { x: 100, y: 50 },\n   *   { width: 10, height: 10 },\n   *   \"head_temple\",\n   *   2, // Liver meridian peak hour\n   *   PlayerArchetype.AMSALJA, // Assassin attacker (+30% effect)\n   *   PlayerArchetype.MUSA, // Warrior defender (+20% resistance)\n   *   TrigramStance.GEON // Heaven stance (exposes head +20%)\n   * );\n   * ```\n   *\n   * @public\n   * @korean 타격처리\n   */\n  processHit(\n    targetPosition: Position,\n    _hitBox: { width: number; height: number }, // Prefixed with underscore to indicate intentionally unused\n    targetedVitalPointId?: string | null,\n    hour?: number,\n    attackerArchetype?: PlayerArchetype,\n    defenderArchetype?: PlayerArchetype,\n    defenderStance?: TrigramStance,\n  ): VitalPointHitResult {\n    // Use provided hour or current system hour\n    const effectiveHour = hour ?? this.currentHour;\n    const effectiveAttackerArchetype =\n      attackerArchetype ?? PlayerArchetype.MUSA;\n    const effectiveDefenderArchetype =\n      defenderArchetype ?? PlayerArchetype.MUSA;\n    const effectiveDefenderStance = defenderStance ?? TrigramStance.GEON;\n\n    // If a specific vital point is targeted, check that one\n    if (targetedVitalPointId) {\n      const targetVitalPoint = this.getVitalPointById(targetedVitalPointId);\n      if (targetVitalPoint) {\n        return this.calculateVitalPointHit(\n          targetVitalPoint,\n          targetPosition,\n          effectiveHour,\n          effectiveAttackerArchetype,\n          effectiveDefenderArchetype,\n          effectiveDefenderStance,\n        );\n      }\n    }\n\n    // Otherwise, find the closest vital point\n    const closestVitalPoint = this.findClosestVitalPoint(targetPosition);\n    if (!closestVitalPoint) {\n      return {\n        hit: false,\n        damage: 0,\n        effects: [],\n        severity: VitalPointSeverity.MINOR,\n      };\n    }\n\n    // Calculate distance to determine hit accuracy\n    const distance = this.calculateDistance(\n      targetPosition,\n      closestVitalPoint.position,\n    );\n    const maxHitDistance = 50; // pixels\n\n    if (distance <= maxHitDistance) {\n      return this.calculateVitalPointHit(\n        closestVitalPoint,\n        targetPosition,\n        effectiveHour,\n        effectiveAttackerArchetype,\n        effectiveDefenderArchetype,\n        effectiveDefenderStance,\n      );\n    }\n\n    return {\n      hit: false,\n      damage: 0,\n      effects: [],\n      severity: VitalPointSeverity.MINOR,\n    };\n  }\n\n  /**\n   * Retrieves a vital point by its unique identifier.\n   *\n   * @param id - Vital point identifier (e.g., \"GB-20\", \"head_temple\")\n   * @returns Vital point if found, null otherwise\n   *\n   * @example\n   * ```typescript\n   * const temple = vitalPointSystem.getVitalPointById(\"head_temple\");\n   * if (temple) {\n   *   console.log(temple.names.korean); // \"태양혈\"\n   * }\n   * ```\n   *\n   * @public\n   * @korean 급소조회\n   */\n  getVitalPointById(id: string): VitalPoint | null {\n    return this.vitalPoints.find((vp) => vp.id === id) ?? null;\n  }\n\n  /**\n   * Gets all registered vital points in the system.\n   *\n   * @returns Read-only array of all vital points\n   *\n   * @example\n   * ```typescript\n   * const allPoints = vitalPointSystem.getVitalPoints();\n   * console.log(`${allPoints.length} vital points registered`);\n   * ```\n   *\n   * @public\n   * @korean 급소목록조회\n   */\n  getVitalPoints(): readonly VitalPoint[] {\n    return this.vitalPoints;\n  }\n\n  /**\n   * Calculates hit result for a technique-based attack.\n   *\n   * Determines whether a technique successfully lands on a vital point,\n   * factoring in technique accuracy, attacker position, and randomness.\n   * Used for AI and player technique execution.\n   *\n   * @param technique - Technique being executed with accuracy property\n   * @param attackerPosition - Position where attack originates\n   * @param _defenderPosition - Defender position (reserved for future use)\n   * @param _defenderStance - Defender stance (reserved for future use)\n   * @returns Hit result with damage and effects\n   *\n   * @example\n   * ```typescript\n   * const technique = {\n   *   id: \"geon-thunder-strike\",\n   *   accuracy: 0.85\n   * };\n   *\n   * const result = vitalPointSystem.calculateHit(\n   *   technique,\n   *   { x: 100, y: 50 },\n   *   { x: 120, y: 50 },\n   *   TrigramStance.GEON\n   * );\n   * ```\n   *\n   * @public\n   * @korean 기술타격계산\n   */\n  calculateHit(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- technique type is dynamically determined by combat system\n    technique: any,\n    attackerPosition: Position,\n    _defenderPosition: Position, // Prefixed with underscore to indicate intentionally unused\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- stance type is dynamically determined by combat system\n    _defenderStance: any, // Prefixed with underscore to indicate intentionally unused\n  ): VitalPointHitResult {\n    // Find closest vital point to attack\n    const closestVitalPoint = this.findClosestVitalPoint(attackerPosition);\n\n    if (!closestVitalPoint) {\n      return {\n        hit: false,\n        damage: 0,\n        effects: [],\n        severity: VitalPointSeverity.MINOR,\n      };\n    }\n\n    // Calculate hit based on technique accuracy and distance\n    const distance = this.calculateDistance(\n      attackerPosition,\n      closestVitalPoint.position,\n    );\n    const hitChance = technique.accuracy * (1 - distance / 100);\n\n    if (Math.random() < hitChance) {\n      return {\n        hit: true,\n        vitalPointHit: closestVitalPoint,\n        damage: this.calculateBaseDamage(closestVitalPoint, distance),\n        effects: [],\n        severity: closestVitalPoint.severity,\n      };\n    }\n\n    return {\n      hit: false,\n      damage: 0,\n      effects: [],\n      severity: VitalPointSeverity.MINOR,\n    };\n  }\n\n  /**\n   * Finds the closest vital point to a given position.\n   *\n   * Uses Euclidean distance to determine proximity.\n   *\n   * @param position - Target position\n   * @returns Closest vital point or null if none registered\n   *\n   * @private\n   * @korean 최근접급소검색\n   */\n  private findClosestVitalPoint(position: Position): VitalPoint | null {\n    if (this.vitalPoints.length === 0) return null;\n\n    let closest = this.vitalPoints[0];\n    let minDistance = this.calculateDistance(position, closest.position);\n\n    for (const vitalPoint of this.vitalPoints) {\n      const distance = this.calculateDistance(position, vitalPoint.position);\n      if (distance < minDistance) {\n        minDistance = distance;\n        closest = vitalPoint;\n      }\n    }\n\n    return closest;\n  }\n\n  /**\n   * Calculates Euclidean distance between two positions.\n   *\n   * @param pos1 - First position\n   * @param pos2 - Second position\n   * @returns Distance in pixels\n   *\n   * @private\n   * @korean 거리계산\n   */\n  private calculateDistance(pos1: Position, pos2: Position): number {\n    const dx = pos1.x - pos2.x;\n    const dy = pos1.y - pos2.y;\n    return Math.sqrt(dx * dx + dy * dy);\n  }\n\n  /**\n   * Calculates vital point hit result with accuracy, damage, and meridian effects.\n   *\n   * **Korean**: 급소타격결과계산\n   *\n   * Enhanced with comprehensive effect calculation including:\n   * - Duration based on accuracy, severity, and archetype modifiers\n   * - Intensity scaling with hit accuracy\n   * - Critical hit bonuses for accuracy >= 0.9\n   * - Archetype offensive/defensive modifiers\n   *\n   * @param vitalPoint - Vital point being struck\n   * @param hitPosition - Exact position of strike\n   * @param hour - Hour of day for meridian flow calculation\n   * @param attackerArchetype - Attacker's archetype (default: MUSA)\n   * @param defenderArchetype - Defender's archetype (default: MUSA)\n   * @returns Hit result with calculated damage, accuracy, and meridian bonuses\n   *\n   * @private\n   * @korean 급소타격결과계산\n   */\n  private calculateVitalPointHit(\n    vitalPoint: VitalPoint,\n    hitPosition: Position,\n    hour: number,\n    attackerArchetype: PlayerArchetype = PlayerArchetype.MUSA,\n    defenderArchetype: PlayerArchetype = PlayerArchetype.MUSA,\n    defenderStance: TrigramStance = TrigramStance.GEON,\n  ): VitalPointHitResult {\n    const distance = this.calculateDistance(hitPosition, vitalPoint.position);\n    const baseDamage = this.calculateBaseDamage(vitalPoint, distance);\n    const now = Date.now(); // Single timestamp for all effects\n\n    // Calculate hit accuracy (0-1 scale based on distance)\n    const accuracy = Math.max(0, 1 - distance / 50);\n\n    // Get meridians for this vital point\n    const meridians = getMeridiansForVitalPoint(vitalPoint.id);\n\n    // Calculate meridian flow effectiveness (highest value if multiple meridians)\n    let meridianMultiplier = 1.0;\n    const allMeridianEffects: StatusEffect[] = [];\n\n    if (meridians.length > 0) {\n      // Use the best meridian flow multiplier\n      meridianMultiplier = Math.max(\n        ...meridians.map((meridianId) =>\n          calculateMeridianFlow(meridianId, hour),\n        ),\n      );\n\n      // Generate meridian disruption effects for each affected meridian\n      meridians.forEach((meridianId) => {\n        const currentDisruption = this.getMeridianDisruption(meridianId);\n        const newDisruption = Math.min(\n          1,\n          currentDisruption + DISRUPTION_INCREMENT_PER_HIT,\n        );\n        this.setMeridianDisruption(meridianId, newDisruption);\n\n        // Generate effects if disruption is significant (using shared timestamp)\n        const effects = generateMeridianEffects(meridianId, newDisruption, now);\n        allMeridianEffects.push(...effects);\n      });\n    }\n\n    // Calculate enhanced vulnerability based on anatomical zone, stance, meridian flow, and time\n    const meridianStates: Record<string, number> = {};\n    meridians.forEach((meridianId) => {\n      // Convert disruption (0=normal, 1=blocked) to flow state (1=normal, 0=blocked)\n      const disruption = this.getMeridianDisruption(meridianId);\n      meridianStates[meridianId] = 1.0 - disruption;\n    });\n\n    const vulnerabilityMultiplier = calculateEnhancedVulnerability(\n      vitalPoint.position,\n      hour,\n      defenderStance,\n      meridianStates,\n    );\n\n    // Apply all multipliers to damage: base × meridian flow × vulnerability\n    const finalDamage = Math.floor(\n      baseDamage * meridianMultiplier * vulnerabilityMultiplier,\n    );\n\n    // Convert VitalPointEffect to StatusEffect with comprehensive calculations\n    const vitalPointStatusEffects: StatusEffect[] = vitalPoint.effects.map(\n      (effect) =>\n        convertToStatusEffect(\n          effect,\n          accuracy,\n          vitalPoint.severity,\n          attackerArchetype,\n          defenderArchetype,\n          vitalPoint.id,\n          now,\n        ),\n    );\n\n    // Combine vital point effects with meridian effects\n    const combinedEffects = [...vitalPointStatusEffects, ...allMeridianEffects];\n\n    return {\n      hit: true,\n      vitalPointHit: vitalPoint,\n      damage: finalDamage,\n      effects: combinedEffects,\n      severity: vitalPoint.severity,\n      accuracy,\n      meridianMultiplier,\n      meridianEffects: allMeridianEffects,\n      multiplier: vulnerabilityMultiplier,\n    };\n  }\n\n  /**\n   * Calculates base damage for a vital point strike.\n   *\n   * Applies distance-based falloff to vital point's base damage value.\n   * Closer strikes deal more damage up to maximum base damage.\n   *\n   * @param vitalPoint - Vital point with base damage property\n   * @param distance - Distance from strike to vital point center\n   * @returns Calculated damage value\n   *\n   * @private\n   * @korean 기본피해계산\n   */\n  private calculateBaseDamage(\n    vitalPoint: VitalPoint,\n    distance: number,\n  ): number {\n    const baseDamage = vitalPoint.baseDamage ?? 10;\n    const distanceModifier = Math.max(0.1, 1 - distance / 100);\n    return Math.floor(baseDamage * distanceModifier);\n  }\n\n  /**\n   * Initializes the system with comprehensive Korean vital points.\n   *\n   * Loads all 70 Korean vital points from the comprehensive database\n   * covering head, torso, arms, and legs with proper categorization.\n   *\n   * @private\n   * @korean 급소초기화\n   */\n  private initializeVitalPoints(): void {\n    // Load all 70 vital points from the comprehensive database\n    this.vitalPoints = [...VITAL_POINTS_DATA];\n  }\n}\n\nexport default VitalPointSystem;\n"],"mappings":"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"}
+{"version":3,"file":"VitalPointSystem.js","names":[],"sources":["../../src/systems/VitalPointSystem.ts"],"sourcesContent":["/**\n * System for managing Korean martial arts vital point (급소) targeting and damage calculation.\n *\n * **Korean**: 급소 시스템 (Vital Point System)\n *\n * The VitalPointSystem implements anatomical targeting mechanics based on traditional\n * Korean martial arts knowledge of 70 vital points (급소). It handles hit detection,\n * damage calculation, and status effect application for precise strikes.\n *\n * ## Vital Point Philosophy\n *\n * Korean martial arts identify specific anatomical locations that, when struck precisely,\n * can cause disproportionate effects. The system categorizes points by:\n *\n * - **Location**: Head, neck, torso, limbs, and core\n * - **Category**: Neurological, vascular, respiratory, muscular, skeletal, etc.\n * - **Severity**: Minor, moderate, major, critical, lethal\n * - **Effects**: Unconsciousness, paralysis, pain, stunning, etc.\n *\n * ## Meridian Integration (경락 통합)\n *\n * The system integrates Traditional Korean Medicine (TKM) meridian theory:\n * - **Time-of-Day Flow**: +30% effectiveness at meridian peak hours\n * - **Meridian Disruption**: Status effects from energy flow blockage\n * - **Elemental Relationships**: 五行 (Wu Xing) elemental advantages\n *\n * ## Key Features\n *\n * - Distance-based hit detection with accuracy falloff\n * - Severity multipliers for damage calculation\n * - Targeted vs. proximity-based strikes\n * - Bilingual Korean-English vital point names\n * - Realistic anatomical positioning\n * - Meridian state tracking and flow calculation\n *\n * @example\n * ```typescript\n * const vitalPointSystem = new VitalPointSystem();\n *\n * // Process a strike at specific position with time-of-day\n * const result = vitalPointSystem.processHit(\n *   { x: 100, y: 50 }, // Target position\n *   { width: 10, height: 10 }, // Hit box\n *   \"GB-20\", // Optional: target specific vital point\n *   14 // Optional: hour of day for meridian flow\n * );\n *\n * if (result.hit && result.vitalPointHit) {\n *   console.log(`Hit ${result.vitalPointHit.names.english}!`);\n *   console.log(`Damage: ${result.damage}, Severity: ${result.severity}`);\n *   console.log(`Meridian bonus: ${result.meridianMultiplier}x`);\n * }\n * ```\n *\n * @category Vital Point System\n * @korean 급소시스템\n */\nimport {\n  PlayerArchetype,\n  Position,\n  TrigramStance,\n  VitalPointSeverity,\n} from \"../types/common\";\nimport { convertToStatusEffect } from \"./EffectCalculator\";\nimport { StatusEffect } from \"./types\";\nimport {\n  calculateEnhancedVulnerability,\n  calculateMeridianFlow,\n  generateMeridianEffects,\n} from \"./vitalpoint/KoreanAnatomy\";\nimport { getMeridiansForVitalPoint } from \"./vitalpoint/MeridianVitalPointMapping\";\nimport { VitalPoint, VitalPointHitResult } from \"./vitalpoint/types\";\nimport { VITAL_POINTS_DATA } from \"./vitalpoint/VitalPointsData\";\n\n/**\n * Amount of meridian disruption added per vital point hit (15%)\n */\nconst DISRUPTION_INCREMENT_PER_HIT = 0.15;\n\nexport class VitalPointSystem {\n  private vitalPoints: VitalPoint[] = [];\n  private meridianStates: Map<string, number> = new Map(); // Tracks disruption level per meridian\n  private currentHour: number = 12; // Default to noon\n\n  /**\n   * Creates a new VitalPointSystem instance.\n   *\n   * Initializes the system with comprehensive Korean vital points database\n   * and meridian state tracking.\n   *\n   * @param initialHour - Optional initial hour of day (0-23) for meridian flow calculations\n   */\n  constructor(initialHour: number = 12) {\n    this.initializeVitalPoints();\n    this.currentHour = initialHour;\n  }\n\n  /**\n   * Sets the current hour of day for meridian flow calculations.\n   *\n   * **Korean**: 시간 설정\n   *\n   * @param hour - Hour of day (0-23)\n   * @throws Error if hour is not a finite number\n   *\n   * @example\n   * ```typescript\n   * vitalPointSystem.setCurrentHour(20); // 8 PM - Pericardium peak time\n   * ```\n   *\n   * @korean 시간설정\n   */\n  setCurrentHour(hour: number): void {\n    if (!Number.isFinite(hour)) {\n      throw new Error(\"Hour must be a finite number\");\n    }\n    this.currentHour = Math.max(0, Math.min(23, Math.floor(hour)));\n  }\n\n  /**\n   * Gets the current hour of day used for meridian calculations.\n   *\n   * **Korean**: 현재 시간 조회\n   *\n   * @returns Current hour (0-23)\n   *\n   * @korean 시간조회\n   */\n  getCurrentHour(): number {\n    return this.currentHour;\n  }\n\n  /**\n   * Updates meridian disruption state for a specific meridian.\n   *\n   * **Korean**: 경락 차단 상태 업데이트\n   *\n   * @param meridianId - ID of the meridian\n   * @param disruptionLevel - Disruption level (0-1, where 1 is fully blocked)\n   *\n   * @korean 경락차단업데이트\n   */\n  setMeridianDisruption(meridianId: string, disruptionLevel: number): void {\n    this.meridianStates.set(\n      meridianId,\n      Math.max(0, Math.min(1, disruptionLevel)),\n    );\n  }\n\n  /**\n   * Gets the current disruption level for a meridian.\n   *\n   * **Korean**: 경락 차단 수준 조회\n   *\n   * @param meridianId - ID of the meridian\n   * @returns Disruption level (0-1)\n   *\n   * @korean 경락차단조회\n   */\n  getMeridianDisruption(meridianId: string): number {\n    return this.meridianStates.get(meridianId) ?? 0;\n  }\n\n  /**\n   * Clears all meridian disruption states (e.g., after rest or healing).\n   *\n   * **Korean**: 경락 상태 초기화\n   *\n   * @korean 경락초기화\n   */\n  clearMeridianDisruptions(): void {\n    this.meridianStates.clear();\n  }\n\n  /**\n   * Processes a hit at a specific position to determine vital point impact.\n   *\n   * Evaluates whether a strike lands on or near a vital point, calculating\n   * damage and effects based on accuracy, severity, and meridian flow.\n   * Supports both targeted strikes (specific vital point ID) and proximity-based detection.\n   *\n   * Enhanced with archetype-specific modifiers for realistic combat simulation.\n   *\n   * ## Hit Detection Algorithm\n   *\n   * 1. If targetedVitalPointId provided, validate that specific point\n   * 2. Otherwise, find closest vital point to target position\n   * 3. Calculate distance from strike to vital point\n   * 4. Apply accuracy falloff based on distance (max 50px)\n   * 5. Calculate meridian flow bonus based on time of day\n   * 6. Apply meridian disruption if applicable\n   * 7. Apply archetype offensive/defensive modifiers\n   * 8. Apply enhanced vulnerability with stance and anatomical zone\n   * 9. Return hit result with damage multipliers and effects\n   *\n   * @param targetPosition - Position where strike lands\n   * @param _hitBox - Size of hit box (currently unused, reserved for future)\n   * @param targetedVitalPointId - Optional specific vital point being targeted\n   * @param hour - Optional hour of day (0-23) for meridian flow calculation\n   * @param attackerArchetype - Optional attacker's archetype (default: MUSA)\n   * @param defenderArchetype - Optional defender's archetype (default: MUSA)\n   * @param defenderStance - Optional defender's trigram stance (default: GEON)\n   * @returns Hit result with damage, effects, severity, and meridian multiplier\n   *\n   * @example\n   * ```typescript\n   * // Proximity-based strike\n   * const result1 = vitalPointSystem.processHit(\n   *   { x: 100, y: 50 },\n   *   { width: 10, height: 10 }\n   * );\n   *\n   * // Targeted strike with archetype modifiers and stance\n   * const result2 = vitalPointSystem.processHit(\n   *   { x: 100, y: 50 },\n   *   { width: 10, height: 10 },\n   *   \"head_temple\",\n   *   2, // Liver meridian peak hour\n   *   PlayerArchetype.AMSALJA, // Assassin attacker (+30% effect)\n   *   PlayerArchetype.MUSA, // Warrior defender (+20% resistance)\n   *   TrigramStance.GEON // Heaven stance (exposes head +20%)\n   * );\n   * ```\n   *\n   * @korean 타격처리\n   */\n  processHit(\n    targetPosition: Position,\n    _hitBox: { width: number; height: number }, // Prefixed with underscore to indicate intentionally unused\n    targetedVitalPointId?: string | null,\n    hour?: number,\n    attackerArchetype?: PlayerArchetype,\n    defenderArchetype?: PlayerArchetype,\n    defenderStance?: TrigramStance,\n  ): VitalPointHitResult {\n    const effectiveHour = hour ?? this.currentHour;\n    const effectiveAttackerArchetype =\n      attackerArchetype ?? PlayerArchetype.MUSA;\n    const effectiveDefenderArchetype =\n      defenderArchetype ?? PlayerArchetype.MUSA;\n    const effectiveDefenderStance = defenderStance ?? TrigramStance.GEON;\n\n    // If a specific vital point is targeted, check that one\n    if (targetedVitalPointId) {\n      const targetVitalPoint = this.getVitalPointById(targetedVitalPointId);\n      if (targetVitalPoint) {\n        return this.calculateVitalPointHit(\n          targetVitalPoint,\n          targetPosition,\n          effectiveHour,\n          effectiveAttackerArchetype,\n          effectiveDefenderArchetype,\n          effectiveDefenderStance,\n        );\n      }\n    }\n\n    // Otherwise, find the closest vital point\n    const closestVitalPoint = this.findClosestVitalPoint(targetPosition);\n    if (!closestVitalPoint) {\n      return {\n        hit: false,\n        damage: 0,\n        effects: [],\n        severity: VitalPointSeverity.MINOR,\n      };\n    }\n\n    const distance = this.calculateDistance(\n      targetPosition,\n      closestVitalPoint.position,\n    );\n    const maxHitDistance = 50; // pixels\n\n    if (distance <= maxHitDistance) {\n      return this.calculateVitalPointHit(\n        closestVitalPoint,\n        targetPosition,\n        effectiveHour,\n        effectiveAttackerArchetype,\n        effectiveDefenderArchetype,\n        effectiveDefenderStance,\n      );\n    }\n\n    return {\n      hit: false,\n      damage: 0,\n      effects: [],\n      severity: VitalPointSeverity.MINOR,\n    };\n  }\n\n  /**\n   * Retrieves a vital point by its unique identifier.\n   *\n   * @param id - Vital point identifier (e.g., \"GB-20\", \"head_temple\")\n   * @returns Vital point if found, null otherwise\n   *\n   * @example\n   * ```typescript\n   * const temple = vitalPointSystem.getVitalPointById(\"head_temple\");\n   * if (temple) {\n   *   console.log(temple.names.korean); // \"태양혈\"\n   * }\n   * ```\n   *\n   * @korean 급소조회\n   */\n  getVitalPointById(id: string): VitalPoint | null {\n    return this.vitalPoints.find((vp) => vp.id === id) ?? null;\n  }\n\n  /**\n   * Gets all registered vital points in the system.\n   *\n   * @returns Read-only array of all vital points\n   *\n   * @example\n   * ```typescript\n   * const allPoints = vitalPointSystem.getVitalPoints();\n   * console.log(`${allPoints.length} vital points registered`);\n   * ```\n   *\n   * @korean 급소목록조회\n   */\n  getVitalPoints(): readonly VitalPoint[] {\n    return this.vitalPoints;\n  }\n\n  /**\n   * Calculates hit result for a technique-based attack.\n   *\n   * Determines whether a technique successfully lands on a vital point,\n   * factoring in technique accuracy, attacker position, and randomness.\n   * Used for AI and player technique execution.\n   *\n   * @param technique - Technique being executed with accuracy property\n   * @param attackerPosition - Position where attack originates\n   * @param _defenderPosition - Defender position (reserved for future use)\n   * @param _defenderStance - Defender stance (reserved for future use)\n   * @returns Hit result with damage and effects\n   *\n   * @example\n   * ```typescript\n   * const technique = {\n   *   id: \"geon-thunder-strike\",\n   *   accuracy: 0.85\n   * };\n   *\n   * const result = vitalPointSystem.calculateHit(\n   *   technique,\n   *   { x: 100, y: 50 },\n   *   { x: 120, y: 50 },\n   *   TrigramStance.GEON\n   * );\n   * ```\n   *\n   * @korean 기술타격계산\n   */\n  calculateHit(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- technique type is dynamically determined by combat system\n    technique: any,\n    attackerPosition: Position,\n    _defenderPosition: Position, // Prefixed with underscore to indicate intentionally unused\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- stance type is dynamically determined by combat system\n    _defenderStance: any, // Prefixed with underscore to indicate intentionally unused\n  ): VitalPointHitResult {\n    const closestVitalPoint = this.findClosestVitalPoint(attackerPosition);\n\n    if (!closestVitalPoint) {\n      return {\n        hit: false,\n        damage: 0,\n        effects: [],\n        severity: VitalPointSeverity.MINOR,\n      };\n    }\n\n    const distance = this.calculateDistance(\n      attackerPosition,\n      closestVitalPoint.position,\n    );\n    const hitChance = technique.accuracy * (1 - distance / 100);\n\n    if (Math.random() < hitChance) {\n      return {\n        hit: true,\n        vitalPointHit: closestVitalPoint,\n        damage: this.calculateBaseDamage(closestVitalPoint, distance),\n        effects: [],\n        severity: closestVitalPoint.severity,\n      };\n    }\n\n    return {\n      hit: false,\n      damage: 0,\n      effects: [],\n      severity: VitalPointSeverity.MINOR,\n    };\n  }\n\n  /**\n   * Finds the closest vital point to a given position.\n   *\n   * Uses Euclidean distance to determine proximity.\n   *\n   * @param position - Target position\n   * @returns Closest vital point or null if none registered\n   *\n   * @private\n   * @korean 최근접급소검색\n   */\n  private findClosestVitalPoint(position: Position): VitalPoint | null {\n    if (this.vitalPoints.length === 0) return null;\n\n    let closest = this.vitalPoints[0];\n    let minDistance = this.calculateDistance(position, closest.position);\n\n    for (const vitalPoint of this.vitalPoints) {\n      const distance = this.calculateDistance(position, vitalPoint.position);\n      if (distance < minDistance) {\n        minDistance = distance;\n        closest = vitalPoint;\n      }\n    }\n\n    return closest;\n  }\n\n  /**\n   * Calculates Euclidean distance between two positions.\n   *\n   * @param pos1 - First position\n   * @param pos2 - Second position\n   * @returns Distance in pixels\n   *\n   * @private\n   * @korean 거리계산\n   */\n  private calculateDistance(pos1: Position, pos2: Position): number {\n    const dx = pos1.x - pos2.x;\n    const dy = pos1.y - pos2.y;\n    return Math.sqrt(dx * dx + dy * dy);\n  }\n\n  /**\n   * Calculates vital point hit result with accuracy, damage, and meridian effects.\n   *\n   * **Korean**: 급소타격결과계산\n   *\n   * Enhanced with comprehensive effect calculation including:\n   * - Duration based on accuracy, severity, and archetype modifiers\n   * - Intensity scaling with hit accuracy\n   * - Critical hit bonuses for accuracy >= 0.9\n   * - Archetype offensive/defensive modifiers\n   *\n   * @param vitalPoint - Vital point being struck\n   * @param hitPosition - Exact position of strike\n   * @param hour - Hour of day for meridian flow calculation\n   * @param attackerArchetype - Attacker's archetype (default: MUSA)\n   * @param defenderArchetype - Defender's archetype (default: MUSA)\n   * @returns Hit result with calculated damage, accuracy, and meridian bonuses\n   *\n   * @private\n   * @korean 급소타격결과계산\n   */\n  private calculateVitalPointHit(\n    vitalPoint: VitalPoint,\n    hitPosition: Position,\n    hour: number,\n    attackerArchetype: PlayerArchetype = PlayerArchetype.MUSA,\n    defenderArchetype: PlayerArchetype = PlayerArchetype.MUSA,\n    defenderStance: TrigramStance = TrigramStance.GEON,\n  ): VitalPointHitResult {\n    const distance = this.calculateDistance(hitPosition, vitalPoint.position);\n    const baseDamage = this.calculateBaseDamage(vitalPoint, distance);\n    const now = Date.now(); // Single timestamp for all effects\n\n    const accuracy = Math.max(0, 1 - distance / 50);\n\n    const meridians = getMeridiansForVitalPoint(vitalPoint.id);\n\n    let meridianMultiplier = 1.0;\n    const allMeridianEffects: StatusEffect[] = [];\n\n    if (meridians.length > 0) {\n      // Use the best meridian flow multiplier\n      meridianMultiplier = Math.max(\n        ...meridians.map((meridianId) =>\n          calculateMeridianFlow(meridianId, hour),\n        ),\n      );\n\n      // Generate meridian disruption effects for each affected meridian\n      meridians.forEach((meridianId) => {\n        const currentDisruption = this.getMeridianDisruption(meridianId);\n        const newDisruption = Math.min(\n          1,\n          currentDisruption + DISRUPTION_INCREMENT_PER_HIT,\n        );\n        this.setMeridianDisruption(meridianId, newDisruption);\n\n        const effects = generateMeridianEffects(meridianId, newDisruption, now);\n        allMeridianEffects.push(...effects);\n      });\n    }\n\n    const meridianStates: Record<string, number> = {};\n    meridians.forEach((meridianId) => {\n      // Convert disruption (0=normal, 1=blocked) to flow state (1=normal, 0=blocked)\n      const disruption = this.getMeridianDisruption(meridianId);\n      meridianStates[meridianId] = 1.0 - disruption;\n    });\n\n    const vulnerabilityMultiplier = calculateEnhancedVulnerability(\n      vitalPoint.position,\n      hour,\n      defenderStance,\n      meridianStates,\n    );\n\n    // Apply all multipliers to damage: base × meridian flow × vulnerability\n    const finalDamage = Math.floor(\n      baseDamage * meridianMultiplier * vulnerabilityMultiplier,\n    );\n\n    const vitalPointStatusEffects: StatusEffect[] = vitalPoint.effects.map(\n      (effect) =>\n        convertToStatusEffect(\n          effect,\n          accuracy,\n          vitalPoint.severity,\n          attackerArchetype,\n          defenderArchetype,\n          vitalPoint.id,\n          now,\n        ),\n    );\n\n    const combinedEffects = [...vitalPointStatusEffects, ...allMeridianEffects];\n\n    return {\n      hit: true,\n      vitalPointHit: vitalPoint,\n      damage: finalDamage,\n      effects: combinedEffects,\n      severity: vitalPoint.severity,\n      accuracy,\n      meridianMultiplier,\n      meridianEffects: allMeridianEffects,\n      multiplier: vulnerabilityMultiplier,\n    };\n  }\n\n  /**\n   * Calculates base damage for a vital point strike.\n   *\n   * Applies distance-based falloff to vital point's base damage value.\n   * Closer strikes deal more damage up to maximum base damage.\n   *\n   * @param vitalPoint - Vital point with base damage property\n   * @param distance - Distance from strike to vital point center\n   * @returns Calculated damage value\n   *\n   * @private\n   * @korean 기본피해계산\n   */\n  private calculateBaseDamage(\n    vitalPoint: VitalPoint,\n    distance: number,\n  ): number {\n    const baseDamage = vitalPoint.baseDamage ?? 10;\n    const distanceModifier = Math.max(0.1, 1 - distance / 100);\n    return Math.floor(baseDamage * distanceModifier);\n  }\n\n  /**\n   * Initializes the system with comprehensive Korean vital points.\n   *\n   * Loads all 70 Korean vital points from the comprehensive database\n   * covering head, torso, arms, and legs with proper categorization.\n   *\n   * @private\n   * @korean 급소초기화\n   */\n  private initializeVitalPoints(): void {\n    this.vitalPoints = [...VITAL_POINTS_DATA];\n  }\n}\n\nexport default VitalPointSystem;\n"],"mappings":"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"}

package/lib/systems/animation/builders/KeyframeInterpolation.d.ts

@@ -24,7 +24,6 @@ type EasingFunction = (t: number) => number;
  *
  * **Korean**: 3차 베지어 제어점
  *
- * @public
  * @category Animation
  * @korean 베지어제어점
  */
@@ -122,7 +121,6 @@ export declare function createBezierEasing(points: BezierControlPoints): EasingF
  *
  * **Korean**: 무도 동작 이징 곡선
  *
- * @public
  * @category Animation
  * @korean 무도동작이징곡선
  */
@@ -263,7 +261,6 @@ export declare const easeExplosivePower: EasingFunction;
  *
  * **Korean**: 확장된 이징 함수 이름
  *
- * @public
  * @category Animation
  * @korean 확장이징함수이름
  */
@@ -423,7 +420,6 @@ export declare const crossFadeAnimations: (animation1: SkeletalAnimation, time1:
  *
  * Stores recent animation velocities for motion prediction.
  *
- * @public
  * @category Animation
  * @korean 동작예측상태
  */

package/lib/systems/animation/builders/KeyframeInterpolation.d.ts.map

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

package/lib/systems/animation/builders/KeyframeInterpolation.js

@@ -4,7 +4,6 @@ import * as THREE from "three";
 * 
 * **Korean**: 무도 동작 이징 곡선
 * 
-* @public
 * @category Animation
 * @korean 무도동작이징곡선
 */

package/lib/systems/animation/builders/KeyframeInterpolation.js.map

@@ -1 +1 @@
-{"version":3,"file":"KeyframeInterpolation.js","names":[],"sources":["../../../../src/systems/animation/builders/KeyframeInterpolation.ts"],"sourcesContent":["/**\n * Keyframe interpolation for smooth skeletal animations\n * \n * Provides interpolation between animation keyframes for smooth 60fps playback.\n * Supports linear, ease-in, ease-out, and ease-in-out easing functions.\n * \n * @module systems/animation/KeyframeInterpolation\n * @category Animation System\n * @korean 키프레임보간\n */\n\nimport * as THREE from \"three\";\nimport type {\n  AnimationKeyframe,\n  SkeletalAnimation,\n  SkeletalRig,\n} from \"@/types/skeletal\";\n\n/**\n * Easing function type\n * \n * @param t - Time value between 0 and 1\n * @returns Eased value between 0 and 1\n * \n * @korean 이징함수타입\n */\ntype EasingFunction = (t: number) => number;\n\n/**\n * Cubic bezier control points for easing curves\n * \n * **Korean**: 3차 베지어 제어점\n * \n * @public\n * @category Animation\n * @korean 베지어제어점\n */\nexport interface BezierControlPoints {\n  /** First control point x (0-1) */\n  readonly p1x: number;\n  /** First control point y (0-1) */\n  readonly p1y: number;\n  /** Second control point x (0-1) */\n  readonly p2x: number;\n  /** Second control point y (0-1) */\n  readonly p2y: number;\n  /** \n   * Enable precision mode for exact bezier curve calculation\n   * \n   * **Reserved for future implementation.**\n   * \n   * When false (default), uses simplified approximation assuming x progresses linearly with t.\n   * This is standard for CSS cubic-bezier() and provides good results with minimal overhead.\n   * \n   * When true (future), will perform iterative solving for accurate x-t mapping (higher CPU cost).\n   * This would enable non-linear time progression for more complex easing curves.\n   * \n   * Currently unused - kept in interface for forward compatibility without breaking API changes.\n   * \n   * @korean 정밀모드\n   */\n  readonly precisionMode?: boolean;\n}\n\n/**\n * Cubic bezier easing for natural movement\n * \n * **Korean**: 3차 베지어 이징\n * \n * Implements cubic bezier curve interpolation for smooth, natural motion.\n * Based on CSS cubic-bezier() function specification.\n * \n * This function uses a configuration object approach for better API clarity.\n * By default, uses simplified approximation (x progresses linearly with t) which\n * provides good results for animation with minimal overhead. Enable precisionMode\n * for exact calculations when needed.\n * \n * @param t - Input time (0-1)\n * @param options - Bezier control points and configuration\n * @returns Eased value\n * \n * @example\n * ```typescript\n * // Natural Korean martial arts movement (physics-based)\n * const eased = cubicBezierWithOptions(0.5, { \n *   p1x: 0.25, p1y: 0.1, p2x: 0.25, p2y: 1.0 \n * });\n * \n * // With precision mode for exact calculation\n * const precise = cubicBezierWithOptions(0.5, {\n *   p1x: 0.42, p1y: 0, p2x: 0.58, p2y: 1.0,\n *   precisionMode: true\n * });\n * ```\n * \n * @korean 3차베지어이징옵션\n */\nexport function cubicBezierWithOptions(\n  t: number,\n  options: BezierControlPoints\n): number {\n  // Clamp t to [0, 1]\n  const clampedT = Math.max(0, Math.min(1, t));\n  \n  // For performance, use direct calculation (standard for CSS cubic-bezier)\n  // Note: options.precisionMode is currently unused and reserved for future implementation\n  // where we could add iterative solving for exact x-t mapping\n  const u = 1 - clampedT;\n  \n  // Cubic bezier formula: B(t) = (1-t)³P₀ + 3(1-t)²tP₁ + 3(1-t)t²P₂ + t³P₃\n  // For easing, P₀ = (0,0) and P₃ = (1,1), so:\n  // y(t) = 3(1-t)²t*p1y + 3(1-t)t²*p2y + t³\n  const result = 3 * u * u * clampedT * options.p1y + \n                 3 * u * clampedT * clampedT * options.p2y + \n                 clampedT * clampedT * clampedT;\n  \n  return result;\n}\n\n/**\n * Cubic bezier easing (legacy function signature for backward compatibility)\n * \n * **Korean**: 3차 베지어 이징 (레거시)\n * \n * @param t - Input time (0-1)\n * @param p1x - First control point x (0-1) - currently unused, reserved for precision mode\n * @param p1y - First control point y (can exceed 0-1 for overshoot)\n * @param p2x - Second control point x (0-1) - currently unused, reserved for precision mode\n * @param p2y - Second control point y (can exceed 0-1 for overshoot)\n * @returns Eased value\n * \n * @deprecated Use cubicBezierWithOptions for clearer API\n * @korean 3차베지어이징레거시\n */\nexport function cubicBezier(\n  t: number,\n  p1x: number,\n  p1y: number,\n  p2x: number,\n  p2y: number\n): number {\n  return cubicBezierWithOptions(t, { p1x, p1y, p2x, p2y });\n}\n\n/**\n * Create a cubic bezier easing function with control points\n * \n * **Korean**: 베지어 이징 함수 생성\n * \n * Factory function to create reusable bezier easing functions.\n * \n * @param points - Bezier control points\n * @returns Easing function\n * \n * @korean 베지어이징함수생성\n */\nexport function createBezierEasing(points: BezierControlPoints): EasingFunction {\n  return (t: number) => cubicBezier(t, points.p1x, points.p1y, points.p2x, points.p2y);\n}\n\n/**\n * Preset bezier easing curves for Korean martial arts movements\n * \n * **Korean**: 무도 동작 이징 곡선\n * \n * @public\n * @category Animation\n * @korean 무도동작이징곡선\n */\nexport const BEZIER_PRESETS = {\n  /**\n   * Natural motion with physics-based acceleration/deceleration\n   * Ideal for: Stance transitions, body rotations, weight shifts\n   * **Korean**: 자연스러운 물리 기반 동작\n   */\n  naturalMotion: { p1x: 0.25, p1y: 0.1, p2x: 0.25, p2y: 1.0 },\n  \n  /**\n   * Smooth S-curve for fluid transitions\n   * Ideal for: Attack wind-ups, defensive positioning, footwork\n   * **Korean**: 부드러운 S곡선 전환\n   */\n  smoothTransition: { p1x: 0.42, p1y: 0.0, p2x: 0.58, p2y: 1.0 },\n  \n  /**\n   * Quick start with gentle landing\n   * Ideal for: Strike recoil, guard recovery, step completion\n   * **Korean**: 빠른 시작과 부드러운 착지\n   */\n  quickStart: { p1x: 0.1, p1y: 0.8, p2x: 0.25, p2y: 1.0 },\n  \n  /**\n   * Explosive power curve\n   * Ideal for: Explosive strikes, power techniques, ki projection\n   * **Korean**: 폭발적 힘 곡선\n   */\n  explosivePower: { p1x: 0.05, p1y: 0.9, p2x: 0.2, p2y: 1.0 },\n  \n  /**\n   * Controlled deceleration\n   * Ideal for: Defensive withdrawals, cautious movements, guard stance\n   * **Korean**: 제어된 감속\n   */\n  controlledSlow: { p1x: 0.6, p1y: 0.0, p2x: 0.9, p2y: 0.4 },\n} as const;\n\n/**\n * Linear easing (no easing)\n * \n * @param t - Input time (0-1)\n * @returns Same as input\n * \n * @korean 선형이징\n */\nexport const easeLinear: EasingFunction = (t: number): number => t;\n\n/**\n * Ease-in (slow start, fast end) - Simple quadratic\n * \n * @param t - Input time (0-1)\n * @returns Eased value\n * \n * @korean 이즈인\n */\nexport const easeIn: EasingFunction = (t: number): number => t * t;\n\n/**\n * Ease-out (fast start, slow end) - Simple quadratic\n * \n * @param t - Input time (0-1)\n * @returns Eased value\n * \n * @korean 이즈아웃\n */\nexport const easeOut: EasingFunction = (t: number): number => t * (2 - t);\n\n/**\n * Ease-in-out (slow start, slow end) - Simple quadratic\n * \n * @param t - Input time (0-1)\n * @returns Eased value\n * \n * @korean 이즈인아웃\n */\nexport const easeInOut: EasingFunction = (t: number): number => {\n  if (t < 0.5) {\n    return 2 * t * t;\n  }\n  return -1 + (4 - 2 * t) * t;\n};\n\n/**\n * Natural motion bezier easing (preset)\n * \n * **Korean**: 자연스러운 동작 이징\n * \n * Physics-based movement ideal for Korean martial arts.\n * \n * @param t - Input time (0-1)\n * @returns Eased value\n * \n * @korean 자연동작이징\n */\nexport const easeNaturalMotion: EasingFunction = createBezierEasing(BEZIER_PRESETS.naturalMotion);\n\n/**\n * Smooth transition bezier easing (preset)\n * \n * **Korean**: 부드러운 전환 이징\n * \n * S-curve for fluid stance transitions.\n * \n * @param t - Input time (0-1)\n * @returns Eased value\n * \n * @korean 부드러운전환이징\n */\nexport const easeSmoothTransition: EasingFunction = createBezierEasing(BEZIER_PRESETS.smoothTransition);\n\n/**\n * Explosive power bezier easing (preset)\n * \n * **Korean**: 폭발적 힘 이징\n * \n * Explosive acceleration for power strikes.\n * \n * @param t - Input time (0-1)\n * @returns Eased value\n * \n * @korean 폭발적힘이징\n */\nexport const easeExplosivePower: EasingFunction = createBezierEasing(BEZIER_PRESETS.explosivePower);\n\n/**\n * Extended easing function names including bezier presets\n * \n * **Korean**: 확장된 이징 함수 이름\n * \n * @public\n * @category Animation\n * @korean 확장이징함수이름\n */\nexport type EasingName = \n  | \"linear\"\n  | \"ease-in\" \n  | \"ease-out\" \n  | \"ease-in-out\"\n  | \"natural-motion\"\n  | \"smooth-transition\"\n  | \"quick-start\"\n  | \"explosive-power\"\n  | \"controlled-slow\";\n\n/**\n * Get easing function by name\n * \n * **Korean**: 이름으로 이징 함수 구하기\n * \n * @param name - Easing function name (supports bezier presets)\n * @returns Easing function\n * \n * @example\n * ```typescript\n * // Get natural motion easing for Korean martial arts\n * const easing = getEasingFunction(\"natural-motion\");\n * const easedValue = easing(0.5); // Smooth physics-based interpolation\n * \n * // Get explosive power for strike animations\n * const powerEasing = getEasingFunction(\"explosive-power\");\n * ```\n * \n * @korean 이징함수구하기\n */\nexport const getEasingFunction = (\n  name: EasingName = \"linear\"\n): EasingFunction => {\n  switch (name) {\n    case \"ease-in\":\n      return easeIn;\n    case \"ease-out\":\n      return easeOut;\n    case \"ease-in-out\":\n      return easeInOut;\n    case \"natural-motion\":\n      return easeNaturalMotion;\n    case \"smooth-transition\":\n      return easeSmoothTransition;\n    case \"quick-start\":\n      return createBezierEasing(BEZIER_PRESETS.quickStart);\n    case \"explosive-power\":\n      return easeExplosivePower;\n    case \"controlled-slow\":\n      return createBezierEasing(BEZIER_PRESETS.controlledSlow);\n    default:\n      return easeLinear;\n  }\n};\n\n/**\n * Find keyframes surrounding current time\n * \n * Returns the two keyframes to interpolate between for current animation time.\n * \n * @param animation - Skeletal animation\n * @param currentTime - Current time in animation (seconds)\n * @returns Tuple of [previousKeyframe, nextKeyframe, interpolationFactor]\n * \n * @korean 주변키프레임찾기\n */\nexport const findSurroundingKeyframes = (\n  animation: SkeletalAnimation,\n  currentTime: number\n): [AnimationKeyframe, AnimationKeyframe, number] => {\n  const { keyframes } = animation;\n\n  // Clamp time to animation duration\n  const clampedTime = Math.max(\n    0,\n    Math.min(currentTime, animation.duration)\n  );\n\n  // Find keyframes\n  let prevKeyframe = keyframes[0];\n  let nextKeyframe = keyframes[keyframes.length - 1];\n  let interpolationFactor = 0;\n\n  for (let i = 0; i < keyframes.length - 1; i++) {\n    const current = keyframes[i];\n    const next = keyframes[i + 1];\n\n    if (clampedTime >= current.time && clampedTime <= next.time) {\n      prevKeyframe = current;\n      nextKeyframe = next;\n\n      // Calculate interpolation factor (0 to 1)\n      const timeDelta = next.time - current.time;\n      if (timeDelta > 0) {\n        interpolationFactor = (clampedTime - current.time) / timeDelta;\n      }\n      break;\n    }\n  }\n\n  return [prevKeyframe, nextKeyframe, interpolationFactor];\n};\n\n/**\n * Interpolate between two Euler rotations\n * \n * Performs spherical linear interpolation (slerp) for smooth rotation.\n * \n * @param from - Start rotation\n * @param to - End rotation\n * @param t - Interpolation factor (0-1)\n * @param easingFn - Easing function to apply\n * @returns Interpolated rotation\n * \n * @korean 회전보간\n */\nexport const interpolateRotation = (\n  from: THREE.Euler,\n  to: THREE.Euler,\n  t: number,\n  easingFn: EasingFunction = easeLinear\n): THREE.Euler => {\n  const easedT = easingFn(t);\n\n  // Convert Euler to Quaternion for proper slerp\n  const fromQuat = new THREE.Quaternion().setFromEuler(from);\n  const toQuat = new THREE.Quaternion().setFromEuler(to);\n\n  // Slerp between quaternions\n  const result = new THREE.Quaternion().slerpQuaternions(\n    fromQuat,\n    toQuat,\n    easedT\n  );\n\n  // Convert back to Euler\n  const resultEuler = new THREE.Euler().setFromQuaternion(result);\n  return resultEuler;\n};\n\n/**\n * Interpolate between two Vector3 positions\n * \n * Performs linear interpolation for smooth position changes.\n * \n * @param from - Start position\n * @param to - End position\n * @param t - Interpolation factor (0-1)\n * @param easingFn - Easing function to apply\n * @returns Interpolated position\n * \n * @korean 위치보간\n */\nexport const interpolatePosition = (\n  from: THREE.Vector3,\n  to: THREE.Vector3,\n  t: number,\n  easingFn: EasingFunction = easeLinear\n): THREE.Vector3 => {\n  const easedT = easingFn(t);\n  return new THREE.Vector3().lerpVectors(from, to, easedT);\n};\n\n/**\n * Get interpolated keyframe at current time\n * \n * Calculates bone transformations by interpolating between keyframes.\n * \n * @param animation - Skeletal animation\n * @param currentTime - Current time in animation (seconds)\n * @returns Interpolated keyframe\n * \n * @korean 보간된키프레임구하기\n */\nexport const getInterpolatedKeyframe = (\n  animation: SkeletalAnimation,\n  currentTime: number\n): AnimationKeyframe => {\n  const [prevKeyframe, nextKeyframe, t] =\n    findSurroundingKeyframes(animation, currentTime);\n\n  // Get easing function from next keyframe\n  const easingFn = getEasingFunction(nextKeyframe.easing);\n\n  // Interpolate bone rotations\n  const boneRotations = new Map<string, THREE.Euler>();\n  const allBoneNames = new Set([\n    ...prevKeyframe.boneRotations.keys(),\n    ...nextKeyframe.boneRotations.keys(),\n  ]);\n\n  for (const boneName of allBoneNames) {\n    const prevRotation =\n      prevKeyframe.boneRotations.get(boneName) ?? new THREE.Euler();\n    const nextRotation =\n      nextKeyframe.boneRotations.get(boneName) ?? new THREE.Euler();\n\n    const interpolated = interpolateRotation(\n      prevRotation,\n      nextRotation,\n      t,\n      easingFn\n    );\n    boneRotations.set(boneName, interpolated);\n  }\n\n  // Interpolate bone positions\n  const bonePositions = new Map<string, THREE.Vector3>();\n  const allPositionBones = new Set([\n    ...prevKeyframe.bonePositions.keys(),\n    ...nextKeyframe.bonePositions.keys(),\n  ]);\n\n  for (const boneName of allPositionBones) {\n    const prevPosition =\n      prevKeyframe.bonePositions.get(boneName) ?? new THREE.Vector3();\n    const nextPosition =\n      nextKeyframe.bonePositions.get(boneName) ?? new THREE.Vector3();\n\n    const interpolated = interpolatePosition(\n      prevPosition,\n      nextPosition,\n      t,\n      easingFn\n    );\n    bonePositions.set(boneName, interpolated);\n  }\n\n  return {\n    time: currentTime,\n    boneRotations,\n    bonePositions,\n    easing: nextKeyframe.easing,\n  };\n};\n\n/**\n * Apply keyframe to skeletal rig\n * \n * Updates all bone transformations based on keyframe data.\n * \n * @param rig - Skeletal rig to update\n * @param keyframe - Keyframe to apply\n * \n * @korean 키프레임적용\n */\nexport const applyKeyframeToRig = (\n  rig: SkeletalRig,\n  keyframe: AnimationKeyframe\n): void => {\n  // Apply bone rotations\n  keyframe.boneRotations.forEach((rotation, boneName) => {\n    const bone = rig.bones.get(boneName);\n    if (bone) {\n      bone.rotation.copy(rotation);\n    }\n  });\n\n  // Apply bone positions (offset from rest pose)\n  keyframe.bonePositions.forEach((position, boneName) => {\n    const bone = rig.bones.get(boneName);\n    if (bone) {\n      // Add position offset to rest position\n      bone.position.copy(bone.restPosition).add(position);\n    }\n  });\n};\n\n/**\n * Blend between two keyframes\n * \n * Creates smooth transition between two animations for animation blending.\n * Useful for transitioning between stance change and attack, etc.\n * \n * @param keyframe1 - First keyframe\n * @param keyframe2 - Second keyframe\n * @param blendFactor - Blend amount (0 = keyframe1, 1 = keyframe2)\n * @returns Blended keyframe\n * \n * @korean 키프레임블렌드\n */\nexport const blendKeyframes = (\n  keyframe1: AnimationKeyframe,\n  keyframe2: AnimationKeyframe,\n  blendFactor: number\n): AnimationKeyframe => {\n  const clampedBlend = Math.max(0, Math.min(1, blendFactor));\n\n  // Blend rotations\n  const boneRotations = new Map<string, THREE.Euler>();\n  const allBones = new Set([\n    ...keyframe1.boneRotations.keys(),\n    ...keyframe2.boneRotations.keys(),\n  ]);\n\n  allBones.forEach((boneName) => {\n    const rot1 = keyframe1.boneRotations.get(boneName) ?? new THREE.Euler();\n    const rot2 = keyframe2.boneRotations.get(boneName) ?? new THREE.Euler();\n    const blended = interpolateRotation(rot1, rot2, clampedBlend);\n    boneRotations.set(boneName, blended);\n  });\n\n  // Blend positions\n  const bonePositions = new Map<string, THREE.Vector3>();\n  const allPositionBones = new Set([\n    ...keyframe1.bonePositions.keys(),\n    ...keyframe2.bonePositions.keys(),\n  ]);\n\n  allPositionBones.forEach((boneName) => {\n    const pos1 = keyframe1.bonePositions.get(boneName) ?? new THREE.Vector3();\n    const pos2 = keyframe2.bonePositions.get(boneName) ?? new THREE.Vector3();\n    const blended = interpolatePosition(pos1, pos2, clampedBlend);\n    bonePositions.set(boneName, blended);\n  });\n\n  return {\n    time: 0,\n    boneRotations,\n    bonePositions,\n    easing: \"linear\",\n  };\n};\n\n/**\n * Update animation state\n * \n * Advances animation time and returns current interpolated keyframe.\n * Handles looping animations automatically.\n * \n * @param animation - Skeletal animation\n * @param currentTime - Current time in animation\n * @param deltaTime - Time since last update (seconds)\n * @param playbackSpeed - Speed multiplier (1.0 = normal)\n * @returns Updated time and current keyframe\n * \n * @korean 애니메이션상태업데이트\n */\nexport const updateAnimation = (\n  animation: SkeletalAnimation,\n  currentTime: number,\n  deltaTime: number,\n  playbackSpeed = 1.0\n): { time: number; keyframe: AnimationKeyframe; completed: boolean } => {\n  // Advance time\n  let newTime = currentTime + deltaTime * playbackSpeed;\n  let completed = false;\n\n  // Handle looping or completion\n  if (newTime >= animation.duration) {\n    if (animation.loop) {\n      newTime = newTime % animation.duration;\n    } else {\n      newTime = animation.duration;\n      completed = true;\n    }\n  }\n\n  // Get interpolated keyframe\n  const keyframe = getInterpolatedKeyframe(animation, newTime);\n\n  return {\n    time: newTime,\n    keyframe,\n    completed,\n  };\n};\n\n/**\n * Cross-fade blend between two animations\n * \n * **Korean**: 크로스페이드 블렌드\n * \n * Smoothly blends between two overlapping animations to prevent popping.\n * Uses cubic bezier easing for natural transitions.\n * \n * @param animation1 - First animation\n * @param time1 - Current time in first animation\n * @param animation2 - Second animation\n * @param time2 - Current time in second animation\n * @param blendFactor - Blend weight (0 = animation1, 1 = animation2)\n * @param easingName - Easing curve for blend transition\n * @returns Blended keyframe\n * \n * @example\n * ```typescript\n * // Cross-fade from idle to attack over 100ms\n * const blended = crossFadeAnimations(\n *   idleAnim, idleTime,\n *   attackAnim, attackTime,\n *   0.5, // 50% blend\n *   \"smooth-transition\"\n * );\n * applyKeyframeToRig(rig, blended);\n * ```\n * \n * @korean 크로스페이드블렌드\n */\nexport const crossFadeAnimations = (\n  animation1: SkeletalAnimation,\n  time1: number,\n  animation2: SkeletalAnimation,\n  time2: number,\n  blendFactor: number,\n  easingName: EasingName = \"smooth-transition\"\n): AnimationKeyframe => {\n  const keyframe1 = getInterpolatedKeyframe(animation1, time1);\n  const keyframe2 = getInterpolatedKeyframe(animation2, time2);\n  \n  // Apply easing to blend factor\n  const easingFn = getEasingFunction(easingName);\n  const easedBlend = easingFn(Math.max(0, Math.min(1, blendFactor)));\n  \n  return blendKeyframes(keyframe1, keyframe2, easedBlend);\n};\n\n/**\n * Motion prediction state for latency reduction\n * \n * **Korean**: 동작 예측 상태\n * \n * Stores recent animation velocities for motion prediction.\n * \n * @public\n * @category Animation\n * @korean 동작예측상태\n */\nexport interface MotionPredictionState {\n  /** Recent position velocities per bone */\n  readonly velocities: Map<string, THREE.Vector3>;\n  /** Recent rotation velocities per bone */\n  readonly angularVelocities: Map<string, THREE.Euler>;\n  /** Last update timestamp */\n  readonly lastUpdateTime: number;\n}\n\n/**\n * Create motion prediction state\n * \n * **Korean**: 동작 예측 상태 생성\n * \n * @returns Initial motion prediction state\n * @korean 동작예측상태생성\n */\nexport const createMotionPredictionState = (): MotionPredictionState => ({\n  velocities: new Map(),\n  angularVelocities: new Map(),\n  lastUpdateTime: 0,\n});\n\n/**\n * Update motion prediction state with new keyframe\n * \n * **Korean**: 동작 예측 상태 업데이트\n * \n * Calculates velocities from keyframe differences for motion prediction.\n * \n * @param state - Current prediction state\n * @param previousKeyframe - Previous animation keyframe\n * @param currentKeyframe - Current animation keyframe\n * @param deltaTime - Time elapsed between keyframes\n * @returns Updated prediction state\n * \n * @korean 동작예측상태업데이트\n */\nexport const updateMotionPrediction = (\n  state: MotionPredictionState,\n  previousKeyframe: AnimationKeyframe,\n  currentKeyframe: AnimationKeyframe,\n  deltaTime: number\n): MotionPredictionState => {\n  if (deltaTime <= 0) return state;\n  \n  const newVelocities = new Map<string, THREE.Vector3>();\n  const newAngularVelocities = new Map<string, THREE.Euler>();\n  \n  // Calculate position velocities\n  currentKeyframe.bonePositions.forEach((currentPos, boneName) => {\n    const prevPos = previousKeyframe.bonePositions.get(boneName);\n    if (prevPos) {\n      const velocity = new THREE.Vector3()\n        .subVectors(currentPos, prevPos)\n        .divideScalar(deltaTime);\n      newVelocities.set(boneName, velocity);\n    }\n  });\n  \n  // Calculate angular velocities using quaternion-based rotation differences\n  // This avoids gimbal lock and angle wrapping issues with Euler angle differences\n  currentKeyframe.boneRotations.forEach((currentRot, boneName) => {\n    const prevRot = previousKeyframe.boneRotations.get(boneName);\n    if (prevRot) {\n      // Convert Euler rotations to quaternions\n      const qCurrent = new THREE.Quaternion().setFromEuler(currentRot);\n      const qPrev = new THREE.Quaternion().setFromEuler(prevRot);\n      \n      // Calculate relative rotation: qDiff = qCurrent * qPrev^(-1)\n      const qDiff = qCurrent.clone().multiply(qPrev.clone().invert());\n      \n      // Extract axis-angle representation for angular velocity\n      const axis = new THREE.Vector3();\n      const wClamped = THREE.MathUtils.clamp(qDiff.w, -1, 1);\n      let angle = 2 * Math.acos(wClamped);\n      const sinHalfAngle = Math.sqrt(1 - wClamped * wClamped);\n      \n      if (sinHalfAngle < 0.0001) {\n        // If sinHalfAngle is too small, rotation is negligible - use zero velocity\n        axis.set(0, 0, 0);\n        angle = 0;\n      } else {\n        // Extract normalized axis from quaternion\n        axis.set(\n          qDiff.x / sinHalfAngle,\n          qDiff.y / sinHalfAngle,\n          qDiff.z / sinHalfAngle\n        );\n      }\n      \n      // Use shortest rotation path\n      if (angle > Math.PI) {\n        angle -= 2 * Math.PI;\n      }\n      \n      // Angular velocity vector = axis * (angle / deltaTime)\n      const angularVelocityVec = axis.multiplyScalar(angle / deltaTime);\n      \n      // Store as Euler for consistency with existing API\n      const angularVel = new THREE.Euler(\n        angularVelocityVec.x,\n        angularVelocityVec.y,\n        angularVelocityVec.z,\n        currentRot.order\n      );\n      newAngularVelocities.set(boneName, angularVel);\n    }\n  });\n  \n  return {\n    velocities: newVelocities,\n    angularVelocities: newAngularVelocities,\n    lastUpdateTime: performance.now(),\n  };\n};\n\n/**\n * Predict future keyframe using motion prediction\n * \n * **Korean**: 동작 예측으로 미래 키프레임 예측\n * \n * Reduces perceived latency by predicting future bone positions/rotations\n * based on current velocities. Typical prediction: 16-33ms (1-2 frames at 60fps).\n * \n * @param currentKeyframe - Current animation keyframe\n * @param predictionState - Motion prediction state\n * @param predictionTime - Time ahead to predict (seconds, typically 0.016-0.033)\n * @returns Predicted keyframe\n * \n * @example\n * ```typescript\n * // Predict 1 frame ahead (16.67ms at 60fps) for <50ms total latency\n * const predicted = predictFutureKeyframe(\n *   currentKeyframe,\n *   motionState,\n *   0.01667\n * );\n * applyKeyframeToRig(rig, predicted);\n * ```\n * \n * @korean 미래키프레임예측\n */\nexport const predictFutureKeyframe = (\n  currentKeyframe: AnimationKeyframe,\n  predictionState: MotionPredictionState,\n  predictionTime: number\n): AnimationKeyframe => {\n  // Clamp prediction time to reasonable bounds (max 50ms)\n  const clampedPrediction = Math.min(predictionTime, 0.05);\n  \n  // Predict bone positions\n  const predictedPositions = new Map<string, THREE.Vector3>();\n  currentKeyframe.bonePositions.forEach((currentPos, boneName) => {\n    const velocity = predictionState.velocities.get(boneName);\n    if (velocity) {\n      // Apply damping to prevent overshoot (0.8 factor for natural motion)\n      const predicted = currentPos.clone().add(\n        velocity.clone().multiplyScalar(clampedPrediction * 0.8)\n      );\n      predictedPositions.set(boneName, predicted);\n    } else {\n      predictedPositions.set(boneName, currentPos.clone());\n    }\n  });\n  \n  // Predict bone rotations\n  const predictedRotations = new Map<string, THREE.Euler>();\n  currentKeyframe.boneRotations.forEach((currentRot, boneName) => {\n    const angularVel = predictionState.angularVelocities.get(boneName);\n    if (angularVel) {\n      // Apply damping to prevent overshoot\n      const predicted = new THREE.Euler(\n        currentRot.x + angularVel.x * clampedPrediction * 0.8,\n        currentRot.y + angularVel.y * clampedPrediction * 0.8,\n        currentRot.z + angularVel.z * clampedPrediction * 0.8,\n        currentRot.order\n      );\n      predictedRotations.set(boneName, predicted);\n    } else {\n      predictedRotations.set(boneName, currentRot.clone());\n    }\n  });\n  \n  return {\n    time: currentKeyframe.time + clampedPrediction,\n    boneRotations: predictedRotations,\n    bonePositions: predictedPositions,\n    easing: currentKeyframe.easing,\n  };\n};\n"],"mappings":"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"}
+{"version":3,"file":"KeyframeInterpolation.js","names":[],"sources":["../../../../src/systems/animation/builders/KeyframeInterpolation.ts"],"sourcesContent":["/**\n * Keyframe interpolation for smooth skeletal animations\n * \n * Provides interpolation between animation keyframes for smooth 60fps playback.\n * Supports linear, ease-in, ease-out, and ease-in-out easing functions.\n * \n * @module systems/animation/KeyframeInterpolation\n * @category Animation System\n * @korean 키프레임보간\n */\n\nimport * as THREE from \"three\";\nimport type {\n  AnimationKeyframe,\n  SkeletalAnimation,\n  SkeletalRig,\n} from \"@/types/skeletal\";\n\n/**\n * Easing function type\n * \n * @param t - Time value between 0 and 1\n * @returns Eased value between 0 and 1\n * \n * @korean 이징함수타입\n */\ntype EasingFunction = (t: number) => number;\n\n/**\n * Cubic bezier control points for easing curves\n * \n * **Korean**: 3차 베지어 제어점\n * \n * @category Animation\n * @korean 베지어제어점\n */\nexport interface BezierControlPoints {\n  /** First control point x (0-1) */\n  readonly p1x: number;\n  /** First control point y (0-1) */\n  readonly p1y: number;\n  /** Second control point x (0-1) */\n  readonly p2x: number;\n  /** Second control point y (0-1) */\n  readonly p2y: number;\n  /** \n   * Enable precision mode for exact bezier curve calculation\n   * \n   * **Reserved for future implementation.**\n   * \n   * When false (default), uses simplified approximation assuming x progresses linearly with t.\n   * This is standard for CSS cubic-bezier() and provides good results with minimal overhead.\n   * \n   * When true (future), will perform iterative solving for accurate x-t mapping (higher CPU cost).\n   * This would enable non-linear time progression for more complex easing curves.\n   * \n   * Currently unused - kept in interface for forward compatibility without breaking API changes.\n   * \n   * @korean 정밀모드\n   */\n  readonly precisionMode?: boolean;\n}\n\n/**\n * Cubic bezier easing for natural movement\n * \n * **Korean**: 3차 베지어 이징\n * \n * Implements cubic bezier curve interpolation for smooth, natural motion.\n * Based on CSS cubic-bezier() function specification.\n * \n * This function uses a configuration object approach for better API clarity.\n * By default, uses simplified approximation (x progresses linearly with t) which\n * provides good results for animation with minimal overhead. Enable precisionMode\n * for exact calculations when needed.\n * \n * @param t - Input time (0-1)\n * @param options - Bezier control points and configuration\n * @returns Eased value\n * \n * @example\n * ```typescript\n * // Natural Korean martial arts movement (physics-based)\n * const eased = cubicBezierWithOptions(0.5, { \n *   p1x: 0.25, p1y: 0.1, p2x: 0.25, p2y: 1.0 \n * });\n * \n * // With precision mode for exact calculation\n * const precise = cubicBezierWithOptions(0.5, {\n *   p1x: 0.42, p1y: 0, p2x: 0.58, p2y: 1.0,\n *   precisionMode: true\n * });\n * ```\n * \n * @korean 3차베지어이징옵션\n */\nexport function cubicBezierWithOptions(\n  t: number,\n  options: BezierControlPoints\n): number {\n  // Clamp t to [0, 1]\n  const clampedT = Math.max(0, Math.min(1, t));\n  \n  // For performance, use direct calculation (standard for CSS cubic-bezier)\n  // Note: options.precisionMode is currently unused and reserved for future implementation\n  // where we could add iterative solving for exact x-t mapping\n  const u = 1 - clampedT;\n  \n  // Cubic bezier formula: B(t) = (1-t)³P₀ + 3(1-t)²tP₁ + 3(1-t)t²P₂ + t³P₃\n  // For easing, P₀ = (0,0) and P₃ = (1,1), so:\n  // y(t) = 3(1-t)²t*p1y + 3(1-t)t²*p2y + t³\n  const result = 3 * u * u * clampedT * options.p1y + \n                 3 * u * clampedT * clampedT * options.p2y + \n                 clampedT * clampedT * clampedT;\n  \n  return result;\n}\n\n/**\n * Cubic bezier easing (legacy function signature for backward compatibility)\n * \n * **Korean**: 3차 베지어 이징 (레거시)\n * \n * @param t - Input time (0-1)\n * @param p1x - First control point x (0-1) - currently unused, reserved for precision mode\n * @param p1y - First control point y (can exceed 0-1 for overshoot)\n * @param p2x - Second control point x (0-1) - currently unused, reserved for precision mode\n * @param p2y - Second control point y (can exceed 0-1 for overshoot)\n * @returns Eased value\n * \n * @deprecated Use cubicBezierWithOptions for clearer API\n * @korean 3차베지어이징레거시\n */\nexport function cubicBezier(\n  t: number,\n  p1x: number,\n  p1y: number,\n  p2x: number,\n  p2y: number\n): number {\n  return cubicBezierWithOptions(t, { p1x, p1y, p2x, p2y });\n}\n\n/**\n * Create a cubic bezier easing function with control points\n * \n * **Korean**: 베지어 이징 함수 생성\n * \n * Factory function to create reusable bezier easing functions.\n * \n * @param points - Bezier control points\n * @returns Easing function\n * \n * @korean 베지어이징함수생성\n */\nexport function createBezierEasing(points: BezierControlPoints): EasingFunction {\n  return (t: number) => cubicBezier(t, points.p1x, points.p1y, points.p2x, points.p2y);\n}\n\n/**\n * Preset bezier easing curves for Korean martial arts movements\n * \n * **Korean**: 무도 동작 이징 곡선\n * \n * @category Animation\n * @korean 무도동작이징곡선\n */\nexport const BEZIER_PRESETS = {\n  /**\n   * Natural motion with physics-based acceleration/deceleration\n   * Ideal for: Stance transitions, body rotations, weight shifts\n   * **Korean**: 자연스러운 물리 기반 동작\n   */\n  naturalMotion: { p1x: 0.25, p1y: 0.1, p2x: 0.25, p2y: 1.0 },\n  \n  /**\n   * Smooth S-curve for fluid transitions\n   * Ideal for: Attack wind-ups, defensive positioning, footwork\n   * **Korean**: 부드러운 S곡선 전환\n   */\n  smoothTransition: { p1x: 0.42, p1y: 0.0, p2x: 0.58, p2y: 1.0 },\n  \n  /**\n   * Quick start with gentle landing\n   * Ideal for: Strike recoil, guard recovery, step completion\n   * **Korean**: 빠른 시작과 부드러운 착지\n   */\n  quickStart: { p1x: 0.1, p1y: 0.8, p2x: 0.25, p2y: 1.0 },\n  \n  /**\n   * Explosive power curve\n   * Ideal for: Explosive strikes, power techniques, ki projection\n   * **Korean**: 폭발적 힘 곡선\n   */\n  explosivePower: { p1x: 0.05, p1y: 0.9, p2x: 0.2, p2y: 1.0 },\n  \n  /**\n   * Controlled deceleration\n   * Ideal for: Defensive withdrawals, cautious movements, guard stance\n   * **Korean**: 제어된 감속\n   */\n  controlledSlow: { p1x: 0.6, p1y: 0.0, p2x: 0.9, p2y: 0.4 },\n} as const;\n\n/**\n * Linear easing (no easing)\n * \n * @param t - Input time (0-1)\n * @returns Same as input\n * \n * @korean 선형이징\n */\nexport const easeLinear: EasingFunction = (t: number): number => t;\n\n/**\n * Ease-in (slow start, fast end) - Simple quadratic\n * \n * @param t - Input time (0-1)\n * @returns Eased value\n * \n * @korean 이즈인\n */\nexport const easeIn: EasingFunction = (t: number): number => t * t;\n\n/**\n * Ease-out (fast start, slow end) - Simple quadratic\n * \n * @param t - Input time (0-1)\n * @returns Eased value\n * \n * @korean 이즈아웃\n */\nexport const easeOut: EasingFunction = (t: number): number => t * (2 - t);\n\n/**\n * Ease-in-out (slow start, slow end) - Simple quadratic\n * \n * @param t - Input time (0-1)\n * @returns Eased value\n * \n * @korean 이즈인아웃\n */\nexport const easeInOut: EasingFunction = (t: number): number => {\n  if (t < 0.5) {\n    return 2 * t * t;\n  }\n  return -1 + (4 - 2 * t) * t;\n};\n\n/**\n * Natural motion bezier easing (preset)\n * \n * **Korean**: 자연스러운 동작 이징\n * \n * Physics-based movement ideal for Korean martial arts.\n * \n * @param t - Input time (0-1)\n * @returns Eased value\n * \n * @korean 자연동작이징\n */\nexport const easeNaturalMotion: EasingFunction = createBezierEasing(BEZIER_PRESETS.naturalMotion);\n\n/**\n * Smooth transition bezier easing (preset)\n * \n * **Korean**: 부드러운 전환 이징\n * \n * S-curve for fluid stance transitions.\n * \n * @param t - Input time (0-1)\n * @returns Eased value\n * \n * @korean 부드러운전환이징\n */\nexport const easeSmoothTransition: EasingFunction = createBezierEasing(BEZIER_PRESETS.smoothTransition);\n\n/**\n * Explosive power bezier easing (preset)\n * \n * **Korean**: 폭발적 힘 이징\n * \n * Explosive acceleration for power strikes.\n * \n * @param t - Input time (0-1)\n * @returns Eased value\n * \n * @korean 폭발적힘이징\n */\nexport const easeExplosivePower: EasingFunction = createBezierEasing(BEZIER_PRESETS.explosivePower);\n\n/**\n * Extended easing function names including bezier presets\n * \n * **Korean**: 확장된 이징 함수 이름\n * \n * @category Animation\n * @korean 확장이징함수이름\n */\nexport type EasingName = \n  | \"linear\"\n  | \"ease-in\" \n  | \"ease-out\" \n  | \"ease-in-out\"\n  | \"natural-motion\"\n  | \"smooth-transition\"\n  | \"quick-start\"\n  | \"explosive-power\"\n  | \"controlled-slow\";\n\n/**\n * Get easing function by name\n * \n * **Korean**: 이름으로 이징 함수 구하기\n * \n * @param name - Easing function name (supports bezier presets)\n * @returns Easing function\n * \n * @example\n * ```typescript\n * // Get natural motion easing for Korean martial arts\n * const easing = getEasingFunction(\"natural-motion\");\n * const easedValue = easing(0.5); // Smooth physics-based interpolation\n * \n * // Get explosive power for strike animations\n * const powerEasing = getEasingFunction(\"explosive-power\");\n * ```\n * \n * @korean 이징함수구하기\n */\nexport const getEasingFunction = (\n  name: EasingName = \"linear\"\n): EasingFunction => {\n  switch (name) {\n    case \"ease-in\":\n      return easeIn;\n    case \"ease-out\":\n      return easeOut;\n    case \"ease-in-out\":\n      return easeInOut;\n    case \"natural-motion\":\n      return easeNaturalMotion;\n    case \"smooth-transition\":\n      return easeSmoothTransition;\n    case \"quick-start\":\n      return createBezierEasing(BEZIER_PRESETS.quickStart);\n    case \"explosive-power\":\n      return easeExplosivePower;\n    case \"controlled-slow\":\n      return createBezierEasing(BEZIER_PRESETS.controlledSlow);\n    default:\n      return easeLinear;\n  }\n};\n\n/**\n * Find keyframes surrounding current time\n * \n * Returns the two keyframes to interpolate between for current animation time.\n * \n * @param animation - Skeletal animation\n * @param currentTime - Current time in animation (seconds)\n * @returns Tuple of [previousKeyframe, nextKeyframe, interpolationFactor]\n * \n * @korean 주변키프레임찾기\n */\nexport const findSurroundingKeyframes = (\n  animation: SkeletalAnimation,\n  currentTime: number\n): [AnimationKeyframe, AnimationKeyframe, number] => {\n  const { keyframes } = animation;\n\n  // Clamp time to animation duration\n  const clampedTime = Math.max(\n    0,\n    Math.min(currentTime, animation.duration)\n  );\n\n  // Find keyframes\n  let prevKeyframe = keyframes[0];\n  let nextKeyframe = keyframes[keyframes.length - 1];\n  let interpolationFactor = 0;\n\n  for (let i = 0; i < keyframes.length - 1; i++) {\n    const current = keyframes[i];\n    const next = keyframes[i + 1];\n\n    if (clampedTime >= current.time && clampedTime <= next.time) {\n      prevKeyframe = current;\n      nextKeyframe = next;\n\n      // Calculate interpolation factor (0 to 1)\n      const timeDelta = next.time - current.time;\n      if (timeDelta > 0) {\n        interpolationFactor = (clampedTime - current.time) / timeDelta;\n      }\n      break;\n    }\n  }\n\n  return [prevKeyframe, nextKeyframe, interpolationFactor];\n};\n\n/**\n * Interpolate between two Euler rotations\n * \n * Performs spherical linear interpolation (slerp) for smooth rotation.\n * \n * @param from - Start rotation\n * @param to - End rotation\n * @param t - Interpolation factor (0-1)\n * @param easingFn - Easing function to apply\n * @returns Interpolated rotation\n * \n * @korean 회전보간\n */\nexport const interpolateRotation = (\n  from: THREE.Euler,\n  to: THREE.Euler,\n  t: number,\n  easingFn: EasingFunction = easeLinear\n): THREE.Euler => {\n  const easedT = easingFn(t);\n\n  // Convert Euler to Quaternion for proper slerp\n  const fromQuat = new THREE.Quaternion().setFromEuler(from);\n  const toQuat = new THREE.Quaternion().setFromEuler(to);\n\n  // Slerp between quaternions\n  const result = new THREE.Quaternion().slerpQuaternions(\n    fromQuat,\n    toQuat,\n    easedT\n  );\n\n  // Convert back to Euler\n  const resultEuler = new THREE.Euler().setFromQuaternion(result);\n  return resultEuler;\n};\n\n/**\n * Interpolate between two Vector3 positions\n * \n * Performs linear interpolation for smooth position changes.\n * \n * @param from - Start position\n * @param to - End position\n * @param t - Interpolation factor (0-1)\n * @param easingFn - Easing function to apply\n * @returns Interpolated position\n * \n * @korean 위치보간\n */\nexport const interpolatePosition = (\n  from: THREE.Vector3,\n  to: THREE.Vector3,\n  t: number,\n  easingFn: EasingFunction = easeLinear\n): THREE.Vector3 => {\n  const easedT = easingFn(t);\n  return new THREE.Vector3().lerpVectors(from, to, easedT);\n};\n\n/**\n * Get interpolated keyframe at current time\n * \n * Calculates bone transformations by interpolating between keyframes.\n * \n * @param animation - Skeletal animation\n * @param currentTime - Current time in animation (seconds)\n * @returns Interpolated keyframe\n * \n * @korean 보간된키프레임구하기\n */\nexport const getInterpolatedKeyframe = (\n  animation: SkeletalAnimation,\n  currentTime: number\n): AnimationKeyframe => {\n  const [prevKeyframe, nextKeyframe, t] =\n    findSurroundingKeyframes(animation, currentTime);\n\n  // Get easing function from next keyframe\n  const easingFn = getEasingFunction(nextKeyframe.easing);\n\n  // Interpolate bone rotations\n  const boneRotations = new Map<string, THREE.Euler>();\n  const allBoneNames = new Set([\n    ...prevKeyframe.boneRotations.keys(),\n    ...nextKeyframe.boneRotations.keys(),\n  ]);\n\n  for (const boneName of allBoneNames) {\n    const prevRotation =\n      prevKeyframe.boneRotations.get(boneName) ?? new THREE.Euler();\n    const nextRotation =\n      nextKeyframe.boneRotations.get(boneName) ?? new THREE.Euler();\n\n    const interpolated = interpolateRotation(\n      prevRotation,\n      nextRotation,\n      t,\n      easingFn\n    );\n    boneRotations.set(boneName, interpolated);\n  }\n\n  // Interpolate bone positions\n  const bonePositions = new Map<string, THREE.Vector3>();\n  const allPositionBones = new Set([\n    ...prevKeyframe.bonePositions.keys(),\n    ...nextKeyframe.bonePositions.keys(),\n  ]);\n\n  for (const boneName of allPositionBones) {\n    const prevPosition =\n      prevKeyframe.bonePositions.get(boneName) ?? new THREE.Vector3();\n    const nextPosition =\n      nextKeyframe.bonePositions.get(boneName) ?? new THREE.Vector3();\n\n    const interpolated = interpolatePosition(\n      prevPosition,\n      nextPosition,\n      t,\n      easingFn\n    );\n    bonePositions.set(boneName, interpolated);\n  }\n\n  return {\n    time: currentTime,\n    boneRotations,\n    bonePositions,\n    easing: nextKeyframe.easing,\n  };\n};\n\n/**\n * Apply keyframe to skeletal rig\n * \n * Updates all bone transformations based on keyframe data.\n * \n * @param rig - Skeletal rig to update\n * @param keyframe - Keyframe to apply\n * \n * @korean 키프레임적용\n */\nexport const applyKeyframeToRig = (\n  rig: SkeletalRig,\n  keyframe: AnimationKeyframe\n): void => {\n  // Apply bone rotations\n  keyframe.boneRotations.forEach((rotation, boneName) => {\n    const bone = rig.bones.get(boneName);\n    if (bone) {\n      bone.rotation.copy(rotation);\n    }\n  });\n\n  // Apply bone positions (offset from rest pose)\n  keyframe.bonePositions.forEach((position, boneName) => {\n    const bone = rig.bones.get(boneName);\n    if (bone) {\n      // Add position offset to rest position\n      bone.position.copy(bone.restPosition).add(position);\n    }\n  });\n};\n\n/**\n * Blend between two keyframes\n * \n * Creates smooth transition between two animations for animation blending.\n * Useful for transitioning between stance change and attack, etc.\n * \n * @param keyframe1 - First keyframe\n * @param keyframe2 - Second keyframe\n * @param blendFactor - Blend amount (0 = keyframe1, 1 = keyframe2)\n * @returns Blended keyframe\n * \n * @korean 키프레임블렌드\n */\nexport const blendKeyframes = (\n  keyframe1: AnimationKeyframe,\n  keyframe2: AnimationKeyframe,\n  blendFactor: number\n): AnimationKeyframe => {\n  const clampedBlend = Math.max(0, Math.min(1, blendFactor));\n\n  // Blend rotations\n  const boneRotations = new Map<string, THREE.Euler>();\n  const allBones = new Set([\n    ...keyframe1.boneRotations.keys(),\n    ...keyframe2.boneRotations.keys(),\n  ]);\n\n  allBones.forEach((boneName) => {\n    const rot1 = keyframe1.boneRotations.get(boneName) ?? new THREE.Euler();\n    const rot2 = keyframe2.boneRotations.get(boneName) ?? new THREE.Euler();\n    const blended = interpolateRotation(rot1, rot2, clampedBlend);\n    boneRotations.set(boneName, blended);\n  });\n\n  // Blend positions\n  const bonePositions = new Map<string, THREE.Vector3>();\n  const allPositionBones = new Set([\n    ...keyframe1.bonePositions.keys(),\n    ...keyframe2.bonePositions.keys(),\n  ]);\n\n  allPositionBones.forEach((boneName) => {\n    const pos1 = keyframe1.bonePositions.get(boneName) ?? new THREE.Vector3();\n    const pos2 = keyframe2.bonePositions.get(boneName) ?? new THREE.Vector3();\n    const blended = interpolatePosition(pos1, pos2, clampedBlend);\n    bonePositions.set(boneName, blended);\n  });\n\n  return {\n    time: 0,\n    boneRotations,\n    bonePositions,\n    easing: \"linear\",\n  };\n};\n\n/**\n * Update animation state\n * \n * Advances animation time and returns current interpolated keyframe.\n * Handles looping animations automatically.\n * \n * @param animation - Skeletal animation\n * @param currentTime - Current time in animation\n * @param deltaTime - Time since last update (seconds)\n * @param playbackSpeed - Speed multiplier (1.0 = normal)\n * @returns Updated time and current keyframe\n * \n * @korean 애니메이션상태업데이트\n */\nexport const updateAnimation = (\n  animation: SkeletalAnimation,\n  currentTime: number,\n  deltaTime: number,\n  playbackSpeed = 1.0\n): { time: number; keyframe: AnimationKeyframe; completed: boolean } => {\n  // Advance time\n  let newTime = currentTime + deltaTime * playbackSpeed;\n  let completed = false;\n\n  // Handle looping or completion\n  if (newTime >= animation.duration) {\n    if (animation.loop) {\n      newTime = newTime % animation.duration;\n    } else {\n      newTime = animation.duration;\n      completed = true;\n    }\n  }\n\n  // Get interpolated keyframe\n  const keyframe = getInterpolatedKeyframe(animation, newTime);\n\n  return {\n    time: newTime,\n    keyframe,\n    completed,\n  };\n};\n\n/**\n * Cross-fade blend between two animations\n * \n * **Korean**: 크로스페이드 블렌드\n * \n * Smoothly blends between two overlapping animations to prevent popping.\n * Uses cubic bezier easing for natural transitions.\n * \n * @param animation1 - First animation\n * @param time1 - Current time in first animation\n * @param animation2 - Second animation\n * @param time2 - Current time in second animation\n * @param blendFactor - Blend weight (0 = animation1, 1 = animation2)\n * @param easingName - Easing curve for blend transition\n * @returns Blended keyframe\n * \n * @example\n * ```typescript\n * // Cross-fade from idle to attack over 100ms\n * const blended = crossFadeAnimations(\n *   idleAnim, idleTime,\n *   attackAnim, attackTime,\n *   0.5, // 50% blend\n *   \"smooth-transition\"\n * );\n * applyKeyframeToRig(rig, blended);\n * ```\n * \n * @korean 크로스페이드블렌드\n */\nexport const crossFadeAnimations = (\n  animation1: SkeletalAnimation,\n  time1: number,\n  animation2: SkeletalAnimation,\n  time2: number,\n  blendFactor: number,\n  easingName: EasingName = \"smooth-transition\"\n): AnimationKeyframe => {\n  const keyframe1 = getInterpolatedKeyframe(animation1, time1);\n  const keyframe2 = getInterpolatedKeyframe(animation2, time2);\n  \n  // Apply easing to blend factor\n  const easingFn = getEasingFunction(easingName);\n  const easedBlend = easingFn(Math.max(0, Math.min(1, blendFactor)));\n  \n  return blendKeyframes(keyframe1, keyframe2, easedBlend);\n};\n\n/**\n * Motion prediction state for latency reduction\n * \n * **Korean**: 동작 예측 상태\n * \n * Stores recent animation velocities for motion prediction.\n * \n * @category Animation\n * @korean 동작예측상태\n */\nexport interface MotionPredictionState {\n  /** Recent position velocities per bone */\n  readonly velocities: Map<string, THREE.Vector3>;\n  /** Recent rotation velocities per bone */\n  readonly angularVelocities: Map<string, THREE.Euler>;\n  /** Last update timestamp */\n  readonly lastUpdateTime: number;\n}\n\n/**\n * Create motion prediction state\n * \n * **Korean**: 동작 예측 상태 생성\n * \n * @returns Initial motion prediction state\n * @korean 동작예측상태생성\n */\nexport const createMotionPredictionState = (): MotionPredictionState => ({\n  velocities: new Map(),\n  angularVelocities: new Map(),\n  lastUpdateTime: 0,\n});\n\n/**\n * Update motion prediction state with new keyframe\n * \n * **Korean**: 동작 예측 상태 업데이트\n * \n * Calculates velocities from keyframe differences for motion prediction.\n * \n * @param state - Current prediction state\n * @param previousKeyframe - Previous animation keyframe\n * @param currentKeyframe - Current animation keyframe\n * @param deltaTime - Time elapsed between keyframes\n * @returns Updated prediction state\n * \n * @korean 동작예측상태업데이트\n */\nexport const updateMotionPrediction = (\n  state: MotionPredictionState,\n  previousKeyframe: AnimationKeyframe,\n  currentKeyframe: AnimationKeyframe,\n  deltaTime: number\n): MotionPredictionState => {\n  if (deltaTime <= 0) return state;\n  \n  const newVelocities = new Map<string, THREE.Vector3>();\n  const newAngularVelocities = new Map<string, THREE.Euler>();\n  \n  // Calculate position velocities\n  currentKeyframe.bonePositions.forEach((currentPos, boneName) => {\n    const prevPos = previousKeyframe.bonePositions.get(boneName);\n    if (prevPos) {\n      const velocity = new THREE.Vector3()\n        .subVectors(currentPos, prevPos)\n        .divideScalar(deltaTime);\n      newVelocities.set(boneName, velocity);\n    }\n  });\n  \n  // Calculate angular velocities using quaternion-based rotation differences\n  // This avoids gimbal lock and angle wrapping issues with Euler angle differences\n  currentKeyframe.boneRotations.forEach((currentRot, boneName) => {\n    const prevRot = previousKeyframe.boneRotations.get(boneName);\n    if (prevRot) {\n      // Convert Euler rotations to quaternions\n      const qCurrent = new THREE.Quaternion().setFromEuler(currentRot);\n      const qPrev = new THREE.Quaternion().setFromEuler(prevRot);\n      \n      // Calculate relative rotation: qDiff = qCurrent * qPrev^(-1)\n      const qDiff = qCurrent.clone().multiply(qPrev.clone().invert());\n      \n      // Extract axis-angle representation for angular velocity\n      const axis = new THREE.Vector3();\n      const wClamped = THREE.MathUtils.clamp(qDiff.w, -1, 1);\n      let angle = 2 * Math.acos(wClamped);\n      const sinHalfAngle = Math.sqrt(1 - wClamped * wClamped);\n      \n      if (sinHalfAngle < 0.0001) {\n        // If sinHalfAngle is too small, rotation is negligible - use zero velocity\n        axis.set(0, 0, 0);\n        angle = 0;\n      } else {\n        // Extract normalized axis from quaternion\n        axis.set(\n          qDiff.x / sinHalfAngle,\n          qDiff.y / sinHalfAngle,\n          qDiff.z / sinHalfAngle\n        );\n      }\n      \n      // Use shortest rotation path\n      if (angle > Math.PI) {\n        angle -= 2 * Math.PI;\n      }\n      \n      // Angular velocity vector = axis * (angle / deltaTime)\n      const angularVelocityVec = axis.multiplyScalar(angle / deltaTime);\n      \n      // Store as Euler for consistency with existing API\n      const angularVel = new THREE.Euler(\n        angularVelocityVec.x,\n        angularVelocityVec.y,\n        angularVelocityVec.z,\n        currentRot.order\n      );\n      newAngularVelocities.set(boneName, angularVel);\n    }\n  });\n  \n  return {\n    velocities: newVelocities,\n    angularVelocities: newAngularVelocities,\n    lastUpdateTime: performance.now(),\n  };\n};\n\n/**\n * Predict future keyframe using motion prediction\n * \n * **Korean**: 동작 예측으로 미래 키프레임 예측\n * \n * Reduces perceived latency by predicting future bone positions/rotations\n * based on current velocities. Typical prediction: 16-33ms (1-2 frames at 60fps).\n * \n * @param currentKeyframe - Current animation keyframe\n * @param predictionState - Motion prediction state\n * @param predictionTime - Time ahead to predict (seconds, typically 0.016-0.033)\n * @returns Predicted keyframe\n * \n * @example\n * ```typescript\n * // Predict 1 frame ahead (16.67ms at 60fps) for <50ms total latency\n * const predicted = predictFutureKeyframe(\n *   currentKeyframe,\n *   motionState,\n *   0.01667\n * );\n * applyKeyframeToRig(rig, predicted);\n * ```\n * \n * @korean 미래키프레임예측\n */\nexport const predictFutureKeyframe = (\n  currentKeyframe: AnimationKeyframe,\n  predictionState: MotionPredictionState,\n  predictionTime: number\n): AnimationKeyframe => {\n  // Clamp prediction time to reasonable bounds (max 50ms)\n  const clampedPrediction = Math.min(predictionTime, 0.05);\n  \n  // Predict bone positions\n  const predictedPositions = new Map<string, THREE.Vector3>();\n  currentKeyframe.bonePositions.forEach((currentPos, boneName) => {\n    const velocity = predictionState.velocities.get(boneName);\n    if (velocity) {\n      // Apply damping to prevent overshoot (0.8 factor for natural motion)\n      const predicted = currentPos.clone().add(\n        velocity.clone().multiplyScalar(clampedPrediction * 0.8)\n      );\n      predictedPositions.set(boneName, predicted);\n    } else {\n      predictedPositions.set(boneName, currentPos.clone());\n    }\n  });\n  \n  // Predict bone rotations\n  const predictedRotations = new Map<string, THREE.Euler>();\n  currentKeyframe.boneRotations.forEach((currentRot, boneName) => {\n    const angularVel = predictionState.angularVelocities.get(boneName);\n    if (angularVel) {\n      // Apply damping to prevent overshoot\n      const predicted = new THREE.Euler(\n        currentRot.x + angularVel.x * clampedPrediction * 0.8,\n        currentRot.y + angularVel.y * clampedPrediction * 0.8,\n        currentRot.z + angularVel.z * clampedPrediction * 0.8,\n        currentRot.order\n      );\n      predictedRotations.set(boneName, predicted);\n    } else {\n      predictedRotations.set(boneName, currentRot.clone());\n    }\n  });\n  \n  return {\n    time: currentKeyframe.time + clampedPrediction,\n    boneRotations: predictedRotations,\n    bonePositions: predictedPositions,\n    easing: currentKeyframe.easing,\n  };\n};\n"],"mappings":"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"}

package/lib/systems/animation/builders/SkeletonRig.d.ts

@@ -109,7 +109,6 @@ export declare const createHumanoidRig: () => SkeletalRig;
  * // Height: 188cm, Legs: 100cm, Arms: 84cm, Shoulders: 54cm (25% wider!)
  * ```
  *
- * @public
  * @korean 크기조정된인간형골격생성
  */
 export declare const createScaledHumanoidRig: (attributes: PhysicalAttributes) => SkeletalRig;
@@ -231,7 +230,6 @@ export declare const createHumanoidRigWithHands: (includeHandBones?: boolean) =>
  * - 허리회전 (Heorhwoejeon) - Torso rotation
  * - 해부학적제약 (Haebuhakjeok Jeyak) - Anatomical constraints
  *
- * @public
  * @korean 허리회전제약조건
  */
 export declare const TORSO_CONSTRAINTS: {
@@ -288,7 +286,6 @@ export declare const TORSO_CONSTRAINTS: {
  * // Returns 0 (opponent is already aligned with hips)
  * ```
  *
- * @public
  * @korean 상대를향한허리회전계산
  */
 export declare function calculateTorsoRotation(currentPosition: THREE.Vector3, opponentPosition: THREE.Vector3, _movementDirection: THREE.Vector3, hipRotation: number): number;
@@ -314,7 +311,6 @@ export declare function calculateTorsoRotation(currentPosition: THREE.Vector3, o
  * // Returns 1.05 (5% damage bonus)
  * ```
  *
- * @public
  * @korean 허리회전으로인한데미지배율계산
  */
 export declare function calculateHipRotationPowerModifier(hipRotationAngle: number, techniqueType: "strike" | "throw" | "joint"): number;