blacktrigram 0.7.44 → 0.7.47

package/lib/systems/movement/InjuryMovementModifier.js

@@ -38,7 +38,6 @@ var DEFAULT_INJURY_MOVEMENT_CONFIG = {
 * console.log(`Status: ${result.statusText.korean} | ${result.statusText.english}`);
 * ```
 * 
-* @public
 * @category Movement System
 * @korean 손상기반이동수정자
 */
@@ -93,7 +92,6 @@ var InjuryMovementModifier = class InjuryMovementModifier {
 	* @param painLevel - Current pain level (0-100)
 	* @returns Complete movement calculation result
 	* 
-	* @public
 	* @korean 이동속도계산
 	*/
 	calculateMovementSpeed(baseSpeed, bodyPartHealth, stance, painLevel) {
@@ -181,7 +179,6 @@ var InjuryMovementModifier = class InjuryMovementModifier {
 	* @param stance - Current trigram stance
 	* @returns Speed multiplier (0.8-1.25), defaults to 1.0 for unknown stances
 	* 
-	* @public
 	*/
 	getStanceSpeedModifier(stance) {
 		const modifier = STANCE_SPEED_MODIFIERS[stance];
@@ -257,7 +254,6 @@ var InjuryMovementModifier = class InjuryMovementModifier {
 	* @param bodyPartHealth - Current body part health
 	* @returns True if limping animation should play
 	* 
-	* @public
 	*/
 	shouldLimp(bodyPartHealth) {
 		return Math.min(bodyPartHealth.legLeft, bodyPartHealth.legRight) < this.config.legThresholds.normal;
@@ -272,7 +268,6 @@ var InjuryMovementModifier = class InjuryMovementModifier {
 	* @param bodyPartHealth - Current body part health
 	* @returns True if severe limp (leg health < 30%)
 	* 
-	* @public
 	*/
 	hasSevereLimp(bodyPartHealth) {
 		return Math.min(bodyPartHealth.legLeft, bodyPartHealth.legRight) < this.config.legThresholds.limping;
@@ -287,7 +282,6 @@ var InjuryMovementModifier = class InjuryMovementModifier {
 	* @param bodyPartHealth - Current body part health
 	* @returns Bilingual injury description
 	* 
-	* @public
 	*/
 	getInjuryDescription(bodyPartHealth) {
 		const worstLegHealth = Math.min(bodyPartHealth.legLeft, bodyPartHealth.legRight);
@@ -300,7 +294,6 @@ var InjuryMovementModifier = class InjuryMovementModifier {
 /**
 * Singleton instance for global access.
 * 
-* @public
 */
 var injuryMovementModifier = new InjuryMovementModifier();
 //#endregion

package/lib/systems/movement/InjuryMovementModifier.js.map

@@ -1 +1 @@
-{"version":3,"file":"InjuryMovementModifier.js","names":[],"sources":["../../../src/systems/movement/InjuryMovementModifier.ts"],"sourcesContent":["/**\n * Injury-Based Movement Modifier System\n * \n * **Korean**: 손상 기반 이동 시스템 (Injury-Based Movement System)\n * \n * Dynamically calculates movement speed modifiers based on leg injuries, torso\n * damage, stance configuration, and pain levels. Part of the 12 combat realism\n * systems for authentic Korean martial arts gameplay.\n * \n * ## Movement Speed Calculation\n * \n * Base speed is modified by multiple factors:\n * - **Leg Injuries**: 0-100% penalty based on health\n * - **Torso Injuries**: 0-30% minor penalty\n * - **Both Legs Injured**: Additional 20% cumulative penalty\n * - **Stance Modifiers**: -20% (defensive) to +25% (offensive)\n * - **Pain Overload**: -15% when pain ≥ 80\n * \n * ## Injury Severity Thresholds\n * \n * | Leg Health | State | Speed Penalty |\n * |-----------|-------|---------------|\n * | 70-100% | Normal | 0% |\n * | 30-69% | Limping | 0-40% |\n * | 10-29% | Severe Limp | 40-80% |\n * | 0-9% | Critical | 80-100% |\n * \n * @module systems/movement/InjuryMovementModifier\n * @category Movement System\n * @korean 손상기반이동\n */\n\nimport type { TrigramStance } from \"@/types/common\";\nimport type { BodyPartHealth } from \"../bodypart/types\";\nimport { STANCE_SPEED_MODIFIERS } from \"../physics/MovementPhysics\";\n\n/**\n * Configuration for injury-based movement calculations.\n * \n * **Korean**: 손상 이동 설정\n * \n * @public\n * @category Movement System\n */\nexport interface InjuryMovementConfig {\n  /** Leg health thresholds for injury states */\n  readonly legThresholds: {\n    readonly normal: number;       // 70% - no penalty\n    readonly limping: number;      // 30% - start of severe penalty\n    readonly critical: number;     // 10% - near-maximum penalty\n  };\n  /** Maximum torso injury penalty (0.3 = 30%) */\n  readonly maxTorsoPenalty: number;\n  /** Both legs injured cumulative penalty multiplier (0.8 = -20%) */\n  readonly bothLegsInjuredMultiplier: number;\n  /** Pain overload threshold (80) */\n  readonly painOverloadThreshold: number;\n  /** Pain overload penalty multiplier (0.85 = -15%) */\n  readonly painOverloadMultiplier: number;\n  /** Minimum speed multiplier (0.1 = 10% of base speed) */\n  readonly minSpeedMultiplier: number;\n}\n\n/**\n * Deep partial type for InjuryMovementConfig to support partial overrides.\n * Allows callers to override individual threshold values without providing all.\n * \n * @public\n * @category Movement System\n */\nexport type PartialInjuryMovementConfig = {\n  readonly legThresholds?: Partial<InjuryMovementConfig[\"legThresholds\"]>;\n  readonly maxTorsoPenalty?: number;\n  readonly bothLegsInjuredMultiplier?: number;\n  readonly painOverloadThreshold?: number;\n  readonly painOverloadMultiplier?: number;\n  readonly minSpeedMultiplier?: number;\n};\n\n/**\n * Default configuration matching acceptance criteria.\n */\nexport const DEFAULT_INJURY_MOVEMENT_CONFIG: InjuryMovementConfig = {\n  legThresholds: {\n    normal: 70,\n    limping: 30,\n    critical: 10,\n  },\n  maxTorsoPenalty: 0.3,\n  bothLegsInjuredMultiplier: 0.8,\n  painOverloadThreshold: 80,\n  painOverloadMultiplier: 0.85,\n  minSpeedMultiplier: 0.1,\n} as const;\n\n/**\n * Result of injury-based movement calculation.\n * \n * **Korean**: 손상 이동 결과\n * \n * @public\n * @category Movement System\n */\nexport interface InjuryMovementResult {\n  /** Final speed in units/second */\n  readonly finalSpeed: number;\n  /** Combined speed multiplier (0.1-1.0+) */\n  readonly speedMultiplier: number;\n  /** Breakdown of penalty sources */\n  readonly penalties: {\n    readonly leftLegPenalty: number;\n    readonly rightLegPenalty: number;\n    readonly torsoPenalty: number;\n    readonly bothLegsInjured: boolean;\n    readonly stanceModifier: number;\n    readonly painOverload: boolean;\n  };\n  /** Whether player is limping */\n  readonly isLimping: boolean;\n  /** Whether player has severe limp */\n  readonly isSevereLimp: boolean;\n  /** Bilingual status text */\n  readonly statusText: {\n    readonly korean: string;\n    readonly english: string;\n  };\n}\n\n/**\n * Injury-Based Movement Modifier System.\n * \n * **Korean**: 손상 기반 이동 수정자 시스템\n * \n * Calculates dynamic movement speed based on injuries, stance, and pain.\n * Integrates with MovementPhysics to apply realistic combat trauma effects.\n * \n * @example\n * ```typescript\n * const modifier = new InjuryMovementModifier();\n * \n * const result = modifier.calculateMovementSpeed(\n *   5.0,                    // base speed\n *   bodyPartHealth,         // current health\n *   TrigramStance.GEON,     // current stance\n *   65                      // pain level\n * );\n * \n * console.log(`Speed: ${result.finalSpeed} m/s`);\n * console.log(`Status: ${result.statusText.korean} | ${result.statusText.english}`);\n * ```\n * \n * @public\n * @category Movement System\n * @korean 손상기반이동수정자\n */\nexport class InjuryMovementModifier {\n  private readonly config: InjuryMovementConfig;\n\n  /**\n   * Threshold for determining if both legs are significantly injured.\n   * Uses epsilon to avoid floating-point rounding issues at boundary.\n   * \n   * @private\n   */\n  private static readonly BOTH_LEGS_THRESHOLD = 0.3 + 1e-10;\n\n  /**\n   * Creates a new InjuryMovementModifier with optional configuration.\n   * \n   * @param config - Optional configuration overrides (supports partial threshold overrides)\n   */\n  constructor(config?: PartialInjuryMovementConfig) {\n    // Deep merge leg thresholds to prevent partial overrides from breaking the config.\n    // Use ?? to avoid undefined values overwriting defaults when exactOptionalPropertyTypes is disabled.\n    const mergedLegThresholds = {\n      normal:\n        config?.legThresholds?.normal ??\n        DEFAULT_INJURY_MOVEMENT_CONFIG.legThresholds.normal,\n      limping:\n        config?.legThresholds?.limping ??\n        DEFAULT_INJURY_MOVEMENT_CONFIG.legThresholds.limping,\n      critical:\n        config?.legThresholds?.critical ??\n        DEFAULT_INJURY_MOVEMENT_CONFIG.legThresholds.critical,\n    };\n\n    const mergedConfig: InjuryMovementConfig = {\n      legThresholds: mergedLegThresholds,\n      maxTorsoPenalty:\n        config?.maxTorsoPenalty ??\n        DEFAULT_INJURY_MOVEMENT_CONFIG.maxTorsoPenalty,\n      bothLegsInjuredMultiplier:\n        config?.bothLegsInjuredMultiplier ??\n        DEFAULT_INJURY_MOVEMENT_CONFIG.bothLegsInjuredMultiplier,\n      painOverloadThreshold:\n        config?.painOverloadThreshold ??\n        DEFAULT_INJURY_MOVEMENT_CONFIG.painOverloadThreshold,\n      painOverloadMultiplier:\n        config?.painOverloadMultiplier ??\n        DEFAULT_INJURY_MOVEMENT_CONFIG.painOverloadMultiplier,\n      minSpeedMultiplier:\n        config?.minSpeedMultiplier ??\n        DEFAULT_INJURY_MOVEMENT_CONFIG.minSpeedMultiplier,\n    };\n\n    // Development-mode sanity check: ensure thresholds are finite and ordered\n    if (process.env.NODE_ENV !== \"production\") {\n      const { normal, limping, critical } = mergedConfig.legThresholds;\n      const allFinite =\n        Number.isFinite(normal) &&\n        Number.isFinite(limping) &&\n        Number.isFinite(critical);\n      const ordered = normal >= limping && limping >= critical;\n\n      if (!allFinite || !ordered) {\n        // Non-throwing warning to avoid breaking existing behavior\n        console.warn(\n          \"[InjuryMovementModifier] Invalid legThresholds configuration detected:\",\n          mergedConfig.legThresholds\n        );\n      }\n    }\n\n    this.config = mergedConfig;\n  }\n\n  /**\n   * Calculate modified movement speed based on all injury factors.\n   * \n   * **Korean**: 이동 속도 계산\n   * \n   * Applies penalties from:\n   * 1. Leg injuries (primary factor)\n   * 2. Torso injuries (minor factor)\n   * 3. Both legs injured (cumulative penalty)\n   * 4. Stance modifiers\n   * 5. Pain overload\n   * \n   * @param baseSpeed - Base movement speed (m/s)\n   * @param bodyPartHealth - Current body part health values\n   * @param stance - Current trigram stance\n   * @param painLevel - Current pain level (0-100)\n   * @returns Complete movement calculation result\n   * \n   * @public\n   * @korean 이동속도계산\n   */\n  public calculateMovementSpeed(\n    baseSpeed: number,\n    bodyPartHealth: BodyPartHealth,\n    stance: TrigramStance,\n    painLevel: number\n  ): InjuryMovementResult {\n    // Calculate individual leg penalties\n    const leftLegPenalty = this.calculateLegPenalty(bodyPartHealth.legLeft);\n    const rightLegPenalty = this.calculateLegPenalty(bodyPartHealth.legRight);\n\n    // Use worst leg penalty as base\n    const baseLegPenalty = Math.max(leftLegPenalty, rightLegPenalty);\n    let speedMultiplier = 1.0 - baseLegPenalty;\n\n    // Check if both legs are significantly injured using centralized method\n    const bothLegsInjured = this.areBothLegsInjured(leftLegPenalty, rightLegPenalty);\n    if (bothLegsInjured) {\n      // Additional 20% penalty when both legs injured\n      speedMultiplier *= this.config.bothLegsInjuredMultiplier;\n    }\n\n    // Calculate torso penalty (minor effect, 0-30% max)\n    const avgTorsoHealth = (bodyPartHealth.torsoUpper + bodyPartHealth.torsoLower) / 2;\n    // Clamp torso health to prevent negative penalties or exceeding max penalty\n    const clampedAvgTorsoHealth = Math.min(100, Math.max(0, avgTorsoHealth));\n    const torsoPenalty = ((100 - clampedAvgTorsoHealth) / 100) * this.config.maxTorsoPenalty;\n    speedMultiplier *= (1 - torsoPenalty);\n\n    // Apply stance modifier\n    const stanceModifier = this.getStanceSpeedModifier(stance);\n    speedMultiplier *= stanceModifier;\n\n    // Apply pain overload penalty if applicable (>= threshold, not just >)\n    const painOverload = painLevel >= this.config.painOverloadThreshold;\n    if (painOverload) {\n      speedMultiplier *= this.config.painOverloadMultiplier; // -15%\n    }\n\n    // Clamp to minimum speed (10% of base)\n    speedMultiplier = Math.max(speedMultiplier, this.config.minSpeedMultiplier);\n\n    // Calculate final speed\n    const finalSpeed = baseSpeed * speedMultiplier;\n\n    // Determine injury state for status text based on worst leg health\n    // This ensures status matches the actual movement penalty (which uses worst leg)\n    // Note: isLimping = true when leg health is in range [30-70) (limping range with 0-40% penalty)\n    //       isSevereLimp = true when leg health is < 30 (severe/critical with 40-100% penalty)\n    const worstLegHealth = Math.min(bodyPartHealth.legLeft, bodyPartHealth.legRight);\n    const isLimping =\n      worstLegHealth < this.config.legThresholds.normal &&\n      worstLegHealth >= this.config.legThresholds.limping;\n    const isSevereLimp = worstLegHealth < this.config.legThresholds.limping;\n\n    // Generate status text\n    const statusText = this.generateStatusText(worstLegHealth, bothLegsInjured, painOverload);\n\n    return {\n      finalSpeed,\n      speedMultiplier,\n      penalties: {\n        leftLegPenalty,\n        rightLegPenalty,\n        torsoPenalty,\n        bothLegsInjured,\n        stanceModifier,\n        painOverload,\n      },\n      isLimping,\n      isSevereLimp,\n      statusText,\n    };\n  }\n\n  /**\n   * Calculate movement penalty from leg injury severity.\n   * \n   * **Korean**: 다리 부상 페널티 계산\n   * \n   * Progressive penalty scaling:\n   * - 100-70%: No penalty (0%)\n   * - 70-30%: Linear scaling (0-40%)\n   * - 30-10%: Accelerated scaling (40-80%)\n   * - 10-0%: Critical scaling (80-100%)\n   * \n   * @param legHealth - Leg health (0-100)\n   * @returns Penalty factor (0.0-1.0), clamped to valid range\n   * \n   * @private\n   */\n  private calculateLegPenalty(legHealth: number): number {\n    const { normal, limping, critical } = this.config.legThresholds;\n\n    // Clamp input health to valid range to prevent runaway penalties\n    const clampedHealth = Math.min(Math.max(legHealth, 0), 100);\n\n    let penalty: number;\n\n    if (clampedHealth >= normal) {\n      // 70-100%: No penalty\n      penalty = 0;\n    } else if (clampedHealth >= limping) {\n      // 30-70%: 0-40% penalty (linear)\n      const healthRange = normal - limping;\n      // Guard against division by zero if thresholds are misconfigured\n      const healthFactor = healthRange > 0 \n        ? (normal - clampedHealth) / healthRange \n        : 0;\n      penalty = healthFactor * 0.4;\n    } else if (clampedHealth >= critical) {\n      // 10-30%: 40-80% penalty (accelerated)\n      const healthRange = limping - critical;\n      // Guard against division by zero if thresholds are misconfigured\n      const healthFactor = healthRange > 0 \n        ? (limping - clampedHealth) / healthRange \n        : 0;\n      penalty = 0.4 + (healthFactor * 0.4);\n    } else {\n      // 0-10%: 80-100% penalty (critical)\n      // Guard against division by zero if critical is 0\n      const healthFactor = critical > 0 \n        ? (critical - clampedHealth) / critical \n        : 1;\n      penalty = 0.8 + (healthFactor * 0.2);\n    }\n\n    // Ensure returned penalty is always within [0, 1]\n    return Math.min(Math.max(penalty, 0), 1);\n  }\n\n  /**\n   * Checks if both legs are significantly injured (>30% penalty each).\n   * Uses epsilon-based comparison for floating-point robustness.\n   * \n   * @param leftLegPenalty - Penalty for left leg (0-1)\n   * @param rightLegPenalty - Penalty for right leg (0-1)\n   * @returns True if both legs are significantly injured\n   * @private\n   */\n  private areBothLegsInjured(leftLegPenalty: number, rightLegPenalty: number): boolean {\n    return leftLegPenalty >= InjuryMovementModifier.BOTH_LEGS_THRESHOLD && \n           rightLegPenalty >= InjuryMovementModifier.BOTH_LEGS_THRESHOLD;\n  }\n\n  /**\n   * Get stance-based speed modifier.\n   * \n   * **Korean**: 자세 속도 배수 가져오기\n   * \n   * @param stance - Current trigram stance\n   * @returns Speed multiplier (0.8-1.25), defaults to 1.0 for unknown stances\n   * \n   * @public\n   */\n  public getStanceSpeedModifier(stance: TrigramStance): number {\n    const modifier = STANCE_SPEED_MODIFIERS[stance];\n\n    // Defensive fallback for unknown stances (e.g., test/invalid values)\n    if (modifier == null) {\n      // Runtime-safe environment check (works in both Node and browser/Vite environments)\n      if (\n        typeof process !== \"undefined\" &&\n        process.env?.NODE_ENV === \"development\"\n      ) {\n        console.warn(\n          `[InjuryMovementModifier] Unknown stance \"${String(\n            stance\n          )}\" received in getStanceSpeedModifier; defaulting to 1.0.`\n        );\n      }\n      return 1.0;\n    }\n\n    return modifier;\n  }\n\n  /**\n   * Generate bilingual status text based on injury state.\n   * \n   * **Korean**: 상태 텍스트 생성\n   * \n   * @param legHealthForStatus - Leg health percentage used for status determination (typically worst leg)\n   * @param bothLegsInjured - Whether both legs are significantly injured\n   * @param painOverload - Whether pain is over threshold\n   * @returns Bilingual status text\n   * \n   * @private\n   */\n  private generateStatusText(\n    legHealthForStatus: number,\n    bothLegsInjured: boolean,\n    painOverload: boolean\n  ): { korean: string; english: string } {\n    const { normal, limping, critical } = this.config.legThresholds;\n\n    if (legHealthForStatus < critical) {\n      const painText = painOverload ? \" | 고통 과부하\" : \"\";\n      const painTextEn = painOverload ? \" | Pain Overload\" : \"\";\n      const baseKorean = bothLegsInjured ? \"심각한 부상 | 양 다리\" : \"심각한 부상\";\n      const baseEnglish = bothLegsInjured ? \"Critical Injury | Both Legs\" : \"Critical Injury\";\n      return {\n        korean: `${baseKorean}${painText}`,\n        english: `${baseEnglish}${painTextEn}`,\n      };\n    } else if (legHealthForStatus < limping) {\n      const painText = painOverload ? \" | 고통 과부하\" : \"\";\n      const painTextEn = painOverload ? \" | Pain Overload\" : \"\";\n      const baseKorean = bothLegsInjured ? \"중증 절름거림 | 양 다리\" : \"중증 절름거림\";\n      const baseEnglish = bothLegsInjured ? \"Severe Limping | Both Legs\" : \"Severe Limping\";\n      return {\n        korean: `${baseKorean}${painText}`,\n        english: `${baseEnglish}${painTextEn}`,\n      };\n    } else if (legHealthForStatus < normal) {\n      const statusKrParts = [\"절름거림\"];\n      const statusEnParts = [\"Limping\"];\n\n      if (bothLegsInjured) {\n        statusKrParts.push(\"양 다리\");\n        statusEnParts.push(\"Both Legs\");\n      }\n\n      if (painOverload) {\n        statusKrParts.push(\"고통 과부하\");\n        statusEnParts.push(\"Pain Overload\");\n      }\n\n      return {\n        korean: statusKrParts.join(\" | \"),\n        english: statusEnParts.join(\" | \"),\n      };\n    } else if (painOverload) {\n      return {\n        korean: \"고통 과부하\",\n        english: \"Pain Overload\",\n      };\n    } else {\n      return {\n        korean: \"정상\",\n        english: \"Normal\",\n      };\n    }\n  }\n\n  /**\n   * Check if player should display limping animation.\n   * \n   * **Korean**: 절름거림 확인\n   * \n   * Uses worst leg health to match movement penalty behavior.\n   * \n   * @param bodyPartHealth - Current body part health\n   * @returns True if limping animation should play\n   * \n   * @public\n   */\n  public shouldLimp(bodyPartHealth: BodyPartHealth): boolean {\n    const worstLegHealth = Math.min(bodyPartHealth.legLeft, bodyPartHealth.legRight);\n    return worstLegHealth < this.config.legThresholds.normal;\n  }\n\n  /**\n   * Check if player has severe limp.\n   * \n   * **Korean**: 중증 절름거림 확인\n   * \n   * Uses worst leg health to match movement penalty behavior.\n   * \n   * @param bodyPartHealth - Current body part health\n   * @returns True if severe limp (leg health < 30%)\n   * \n   * @public\n   */\n  public hasSevereLimp(bodyPartHealth: BodyPartHealth): boolean {\n    const worstLegHealth = Math.min(bodyPartHealth.legLeft, bodyPartHealth.legRight);\n    return worstLegHealth < this.config.legThresholds.limping;\n  }\n\n  /**\n   * Get current injury state description.\n   * \n   * **Korean**: 부상 상태 설명\n   * \n   * Uses worst leg health to match movement penalty behavior.\n   * \n   * @param bodyPartHealth - Current body part health\n   * @returns Bilingual injury description\n   * \n   * @public\n   */\n  public getInjuryDescription(bodyPartHealth: BodyPartHealth): {\n    korean: string;\n    english: string;\n  } {\n    const worstLegHealth = Math.min(bodyPartHealth.legLeft, bodyPartHealth.legRight);\n    const leftLegPenalty = this.calculateLegPenalty(bodyPartHealth.legLeft);\n    const rightLegPenalty = this.calculateLegPenalty(bodyPartHealth.legRight);\n    const bothLegsInjured = this.areBothLegsInjured(leftLegPenalty, rightLegPenalty);\n\n    return this.generateStatusText(worstLegHealth, bothLegsInjured, false);\n  }\n}\n\n/**\n * Singleton instance for global access.\n * \n * @public\n */\nexport const injuryMovementModifier = new InjuryMovementModifier();\n"],"mappings":"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"}
+{"version":3,"file":"InjuryMovementModifier.js","names":[],"sources":["../../../src/systems/movement/InjuryMovementModifier.ts"],"sourcesContent":["/**\n * Injury-Based Movement Modifier System\n * \n * **Korean**: 손상 기반 이동 시스템 (Injury-Based Movement System)\n * \n * Dynamically calculates movement speed modifiers based on leg injuries, torso\n * damage, stance configuration, and pain levels. Part of the 12 combat realism\n * systems for authentic Korean martial arts gameplay.\n * \n * ## Movement Speed Calculation\n * \n * Base speed is modified by multiple factors:\n * - **Leg Injuries**: 0-100% penalty based on health\n * - **Torso Injuries**: 0-30% minor penalty\n * - **Both Legs Injured**: Additional 20% cumulative penalty\n * - **Stance Modifiers**: -20% (defensive) to +25% (offensive)\n * - **Pain Overload**: -15% when pain ≥ 80\n * \n * ## Injury Severity Thresholds\n * \n * | Leg Health | State | Speed Penalty |\n * |-----------|-------|---------------|\n * | 70-100% | Normal | 0% |\n * | 30-69% | Limping | 0-40% |\n * | 10-29% | Severe Limp | 40-80% |\n * | 0-9% | Critical | 80-100% |\n * \n * @module systems/movement/InjuryMovementModifier\n * @category Movement System\n * @korean 손상기반이동\n */\n\nimport type { TrigramStance } from \"@/types/common\";\nimport type { BodyPartHealth } from \"../bodypart/types\";\nimport { STANCE_SPEED_MODIFIERS } from \"../physics/MovementPhysics\";\n\n/**\n * Configuration for injury-based movement calculations.\n * \n * **Korean**: 손상 이동 설정\n * \n * @category Movement System\n */\nexport interface InjuryMovementConfig {\n  /** Leg health thresholds for injury states */\n  readonly legThresholds: {\n    readonly normal: number;       // 70% - no penalty\n    readonly limping: number;      // 30% - start of severe penalty\n    readonly critical: number;     // 10% - near-maximum penalty\n  };\n  /** Maximum torso injury penalty (0.3 = 30%) */\n  readonly maxTorsoPenalty: number;\n  /** Both legs injured cumulative penalty multiplier (0.8 = -20%) */\n  readonly bothLegsInjuredMultiplier: number;\n  /** Pain overload threshold (80) */\n  readonly painOverloadThreshold: number;\n  /** Pain overload penalty multiplier (0.85 = -15%) */\n  readonly painOverloadMultiplier: number;\n  /** Minimum speed multiplier (0.1 = 10% of base speed) */\n  readonly minSpeedMultiplier: number;\n}\n\n/**\n * Deep partial type for InjuryMovementConfig to support partial overrides.\n * Allows callers to override individual threshold values without providing all.\n * \n * @category Movement System\n */\nexport type PartialInjuryMovementConfig = {\n  readonly legThresholds?: Partial<InjuryMovementConfig[\"legThresholds\"]>;\n  readonly maxTorsoPenalty?: number;\n  readonly bothLegsInjuredMultiplier?: number;\n  readonly painOverloadThreshold?: number;\n  readonly painOverloadMultiplier?: number;\n  readonly minSpeedMultiplier?: number;\n};\n\n/**\n * Default configuration matching acceptance criteria.\n */\nexport const DEFAULT_INJURY_MOVEMENT_CONFIG: InjuryMovementConfig = {\n  legThresholds: {\n    normal: 70,\n    limping: 30,\n    critical: 10,\n  },\n  maxTorsoPenalty: 0.3,\n  bothLegsInjuredMultiplier: 0.8,\n  painOverloadThreshold: 80,\n  painOverloadMultiplier: 0.85,\n  minSpeedMultiplier: 0.1,\n} as const;\n\n/**\n * Result of injury-based movement calculation.\n * \n * **Korean**: 손상 이동 결과\n * \n * @category Movement System\n */\nexport interface InjuryMovementResult {\n  /** Final speed in units/second */\n  readonly finalSpeed: number;\n  /** Combined speed multiplier (0.1-1.0+) */\n  readonly speedMultiplier: number;\n  /** Breakdown of penalty sources */\n  readonly penalties: {\n    readonly leftLegPenalty: number;\n    readonly rightLegPenalty: number;\n    readonly torsoPenalty: number;\n    readonly bothLegsInjured: boolean;\n    readonly stanceModifier: number;\n    readonly painOverload: boolean;\n  };\n  /** Whether player is limping */\n  readonly isLimping: boolean;\n  /** Whether player has severe limp */\n  readonly isSevereLimp: boolean;\n  /** Bilingual status text */\n  readonly statusText: {\n    readonly korean: string;\n    readonly english: string;\n  };\n}\n\n/**\n * Injury-Based Movement Modifier System.\n * \n * **Korean**: 손상 기반 이동 수정자 시스템\n * \n * Calculates dynamic movement speed based on injuries, stance, and pain.\n * Integrates with MovementPhysics to apply realistic combat trauma effects.\n * \n * @example\n * ```typescript\n * const modifier = new InjuryMovementModifier();\n * \n * const result = modifier.calculateMovementSpeed(\n *   5.0,                    // base speed\n *   bodyPartHealth,         // current health\n *   TrigramStance.GEON,     // current stance\n *   65                      // pain level\n * );\n * \n * console.log(`Speed: ${result.finalSpeed} m/s`);\n * console.log(`Status: ${result.statusText.korean} | ${result.statusText.english}`);\n * ```\n * \n * @category Movement System\n * @korean 손상기반이동수정자\n */\nexport class InjuryMovementModifier {\n  private readonly config: InjuryMovementConfig;\n\n  /**\n   * Threshold for determining if both legs are significantly injured.\n   * Uses epsilon to avoid floating-point rounding issues at boundary.\n   * \n   * @private\n   */\n  private static readonly BOTH_LEGS_THRESHOLD = 0.3 + 1e-10;\n\n  /**\n   * Creates a new InjuryMovementModifier with optional configuration.\n   * \n   * @param config - Optional configuration overrides (supports partial threshold overrides)\n   */\n  constructor(config?: PartialInjuryMovementConfig) {\n    // Deep merge leg thresholds to prevent partial overrides from breaking the config.\n    // Use ?? to avoid undefined values overwriting defaults when exactOptionalPropertyTypes is disabled.\n    const mergedLegThresholds = {\n      normal:\n        config?.legThresholds?.normal ??\n        DEFAULT_INJURY_MOVEMENT_CONFIG.legThresholds.normal,\n      limping:\n        config?.legThresholds?.limping ??\n        DEFAULT_INJURY_MOVEMENT_CONFIG.legThresholds.limping,\n      critical:\n        config?.legThresholds?.critical ??\n        DEFAULT_INJURY_MOVEMENT_CONFIG.legThresholds.critical,\n    };\n\n    const mergedConfig: InjuryMovementConfig = {\n      legThresholds: mergedLegThresholds,\n      maxTorsoPenalty:\n        config?.maxTorsoPenalty ??\n        DEFAULT_INJURY_MOVEMENT_CONFIG.maxTorsoPenalty,\n      bothLegsInjuredMultiplier:\n        config?.bothLegsInjuredMultiplier ??\n        DEFAULT_INJURY_MOVEMENT_CONFIG.bothLegsInjuredMultiplier,\n      painOverloadThreshold:\n        config?.painOverloadThreshold ??\n        DEFAULT_INJURY_MOVEMENT_CONFIG.painOverloadThreshold,\n      painOverloadMultiplier:\n        config?.painOverloadMultiplier ??\n        DEFAULT_INJURY_MOVEMENT_CONFIG.painOverloadMultiplier,\n      minSpeedMultiplier:\n        config?.minSpeedMultiplier ??\n        DEFAULT_INJURY_MOVEMENT_CONFIG.minSpeedMultiplier,\n    };\n\n    // Development-mode sanity check: ensure thresholds are finite and ordered\n    if (process.env.NODE_ENV !== \"production\") {\n      const { normal, limping, critical } = mergedConfig.legThresholds;\n      const allFinite =\n        Number.isFinite(normal) &&\n        Number.isFinite(limping) &&\n        Number.isFinite(critical);\n      const ordered = normal >= limping && limping >= critical;\n\n      if (!allFinite || !ordered) {\n        // Non-throwing warning to avoid breaking existing behavior\n        console.warn(\n          \"[InjuryMovementModifier] Invalid legThresholds configuration detected:\",\n          mergedConfig.legThresholds\n        );\n      }\n    }\n\n    this.config = mergedConfig;\n  }\n\n  /**\n   * Calculate modified movement speed based on all injury factors.\n   * \n   * **Korean**: 이동 속도 계산\n   * \n   * Applies penalties from:\n   * 1. Leg injuries (primary factor)\n   * 2. Torso injuries (minor factor)\n   * 3. Both legs injured (cumulative penalty)\n   * 4. Stance modifiers\n   * 5. Pain overload\n   * \n   * @param baseSpeed - Base movement speed (m/s)\n   * @param bodyPartHealth - Current body part health values\n   * @param stance - Current trigram stance\n   * @param painLevel - Current pain level (0-100)\n   * @returns Complete movement calculation result\n   * \n   * @korean 이동속도계산\n   */\n  public calculateMovementSpeed(\n    baseSpeed: number,\n    bodyPartHealth: BodyPartHealth,\n    stance: TrigramStance,\n    painLevel: number\n  ): InjuryMovementResult {\n    // Calculate individual leg penalties\n    const leftLegPenalty = this.calculateLegPenalty(bodyPartHealth.legLeft);\n    const rightLegPenalty = this.calculateLegPenalty(bodyPartHealth.legRight);\n\n    // Use worst leg penalty as base\n    const baseLegPenalty = Math.max(leftLegPenalty, rightLegPenalty);\n    let speedMultiplier = 1.0 - baseLegPenalty;\n\n    // Check if both legs are significantly injured using centralized method\n    const bothLegsInjured = this.areBothLegsInjured(leftLegPenalty, rightLegPenalty);\n    if (bothLegsInjured) {\n      // Additional 20% penalty when both legs injured\n      speedMultiplier *= this.config.bothLegsInjuredMultiplier;\n    }\n\n    // Calculate torso penalty (minor effect, 0-30% max)\n    const avgTorsoHealth = (bodyPartHealth.torsoUpper + bodyPartHealth.torsoLower) / 2;\n    // Clamp torso health to prevent negative penalties or exceeding max penalty\n    const clampedAvgTorsoHealth = Math.min(100, Math.max(0, avgTorsoHealth));\n    const torsoPenalty = ((100 - clampedAvgTorsoHealth) / 100) * this.config.maxTorsoPenalty;\n    speedMultiplier *= (1 - torsoPenalty);\n\n    // Apply stance modifier\n    const stanceModifier = this.getStanceSpeedModifier(stance);\n    speedMultiplier *= stanceModifier;\n\n    // Apply pain overload penalty if applicable (>= threshold, not just >)\n    const painOverload = painLevel >= this.config.painOverloadThreshold;\n    if (painOverload) {\n      speedMultiplier *= this.config.painOverloadMultiplier; // -15%\n    }\n\n    // Clamp to minimum speed (10% of base)\n    speedMultiplier = Math.max(speedMultiplier, this.config.minSpeedMultiplier);\n\n    // Calculate final speed\n    const finalSpeed = baseSpeed * speedMultiplier;\n\n    // Determine injury state for status text based on worst leg health\n    // This ensures status matches the actual movement penalty (which uses worst leg)\n    // Note: isLimping = true when leg health is in range [30-70) (limping range with 0-40% penalty)\n    //       isSevereLimp = true when leg health is < 30 (severe/critical with 40-100% penalty)\n    const worstLegHealth = Math.min(bodyPartHealth.legLeft, bodyPartHealth.legRight);\n    const isLimping =\n      worstLegHealth < this.config.legThresholds.normal &&\n      worstLegHealth >= this.config.legThresholds.limping;\n    const isSevereLimp = worstLegHealth < this.config.legThresholds.limping;\n\n    // Generate status text\n    const statusText = this.generateStatusText(worstLegHealth, bothLegsInjured, painOverload);\n\n    return {\n      finalSpeed,\n      speedMultiplier,\n      penalties: {\n        leftLegPenalty,\n        rightLegPenalty,\n        torsoPenalty,\n        bothLegsInjured,\n        stanceModifier,\n        painOverload,\n      },\n      isLimping,\n      isSevereLimp,\n      statusText,\n    };\n  }\n\n  /**\n   * Calculate movement penalty from leg injury severity.\n   * \n   * **Korean**: 다리 부상 페널티 계산\n   * \n   * Progressive penalty scaling:\n   * - 100-70%: No penalty (0%)\n   * - 70-30%: Linear scaling (0-40%)\n   * - 30-10%: Accelerated scaling (40-80%)\n   * - 10-0%: Critical scaling (80-100%)\n   * \n   * @param legHealth - Leg health (0-100)\n   * @returns Penalty factor (0.0-1.0), clamped to valid range\n   * \n   * @private\n   */\n  private calculateLegPenalty(legHealth: number): number {\n    const { normal, limping, critical } = this.config.legThresholds;\n\n    // Clamp input health to valid range to prevent runaway penalties\n    const clampedHealth = Math.min(Math.max(legHealth, 0), 100);\n\n    let penalty: number;\n\n    if (clampedHealth >= normal) {\n      // 70-100%: No penalty\n      penalty = 0;\n    } else if (clampedHealth >= limping) {\n      // 30-70%: 0-40% penalty (linear)\n      const healthRange = normal - limping;\n      // Guard against division by zero if thresholds are misconfigured\n      const healthFactor = healthRange > 0 \n        ? (normal - clampedHealth) / healthRange \n        : 0;\n      penalty = healthFactor * 0.4;\n    } else if (clampedHealth >= critical) {\n      // 10-30%: 40-80% penalty (accelerated)\n      const healthRange = limping - critical;\n      // Guard against division by zero if thresholds are misconfigured\n      const healthFactor = healthRange > 0 \n        ? (limping - clampedHealth) / healthRange \n        : 0;\n      penalty = 0.4 + (healthFactor * 0.4);\n    } else {\n      // 0-10%: 80-100% penalty (critical)\n      // Guard against division by zero if critical is 0\n      const healthFactor = critical > 0 \n        ? (critical - clampedHealth) / critical \n        : 1;\n      penalty = 0.8 + (healthFactor * 0.2);\n    }\n\n    // Ensure returned penalty is always within [0, 1]\n    return Math.min(Math.max(penalty, 0), 1);\n  }\n\n  /**\n   * Checks if both legs are significantly injured (>30% penalty each).\n   * Uses epsilon-based comparison for floating-point robustness.\n   * \n   * @param leftLegPenalty - Penalty for left leg (0-1)\n   * @param rightLegPenalty - Penalty for right leg (0-1)\n   * @returns True if both legs are significantly injured\n   * @private\n   */\n  private areBothLegsInjured(leftLegPenalty: number, rightLegPenalty: number): boolean {\n    return leftLegPenalty >= InjuryMovementModifier.BOTH_LEGS_THRESHOLD && \n           rightLegPenalty >= InjuryMovementModifier.BOTH_LEGS_THRESHOLD;\n  }\n\n  /**\n   * Get stance-based speed modifier.\n   * \n   * **Korean**: 자세 속도 배수 가져오기\n   * \n   * @param stance - Current trigram stance\n   * @returns Speed multiplier (0.8-1.25), defaults to 1.0 for unknown stances\n   * \n   */\n  public getStanceSpeedModifier(stance: TrigramStance): number {\n    const modifier = STANCE_SPEED_MODIFIERS[stance];\n\n    // Defensive fallback for unknown stances (e.g., test/invalid values)\n    if (modifier == null) {\n      // Runtime-safe environment check (works in both Node and browser/Vite environments)\n      if (\n        typeof process !== \"undefined\" &&\n        process.env?.NODE_ENV === \"development\"\n      ) {\n        console.warn(\n          `[InjuryMovementModifier] Unknown stance \"${String(\n            stance\n          )}\" received in getStanceSpeedModifier; defaulting to 1.0.`\n        );\n      }\n      return 1.0;\n    }\n\n    return modifier;\n  }\n\n  /**\n   * Generate bilingual status text based on injury state.\n   * \n   * **Korean**: 상태 텍스트 생성\n   * \n   * @param legHealthForStatus - Leg health percentage used for status determination (typically worst leg)\n   * @param bothLegsInjured - Whether both legs are significantly injured\n   * @param painOverload - Whether pain is over threshold\n   * @returns Bilingual status text\n   * \n   * @private\n   */\n  private generateStatusText(\n    legHealthForStatus: number,\n    bothLegsInjured: boolean,\n    painOverload: boolean\n  ): { korean: string; english: string } {\n    const { normal, limping, critical } = this.config.legThresholds;\n\n    if (legHealthForStatus < critical) {\n      const painText = painOverload ? \" | 고통 과부하\" : \"\";\n      const painTextEn = painOverload ? \" | Pain Overload\" : \"\";\n      const baseKorean = bothLegsInjured ? \"심각한 부상 | 양 다리\" : \"심각한 부상\";\n      const baseEnglish = bothLegsInjured ? \"Critical Injury | Both Legs\" : \"Critical Injury\";\n      return {\n        korean: `${baseKorean}${painText}`,\n        english: `${baseEnglish}${painTextEn}`,\n      };\n    } else if (legHealthForStatus < limping) {\n      const painText = painOverload ? \" | 고통 과부하\" : \"\";\n      const painTextEn = painOverload ? \" | Pain Overload\" : \"\";\n      const baseKorean = bothLegsInjured ? \"중증 절름거림 | 양 다리\" : \"중증 절름거림\";\n      const baseEnglish = bothLegsInjured ? \"Severe Limping | Both Legs\" : \"Severe Limping\";\n      return {\n        korean: `${baseKorean}${painText}`,\n        english: `${baseEnglish}${painTextEn}`,\n      };\n    } else if (legHealthForStatus < normal) {\n      const statusKrParts = [\"절름거림\"];\n      const statusEnParts = [\"Limping\"];\n\n      if (bothLegsInjured) {\n        statusKrParts.push(\"양 다리\");\n        statusEnParts.push(\"Both Legs\");\n      }\n\n      if (painOverload) {\n        statusKrParts.push(\"고통 과부하\");\n        statusEnParts.push(\"Pain Overload\");\n      }\n\n      return {\n        korean: statusKrParts.join(\" | \"),\n        english: statusEnParts.join(\" | \"),\n      };\n    } else if (painOverload) {\n      return {\n        korean: \"고통 과부하\",\n        english: \"Pain Overload\",\n      };\n    } else {\n      return {\n        korean: \"정상\",\n        english: \"Normal\",\n      };\n    }\n  }\n\n  /**\n   * Check if player should display limping animation.\n   * \n   * **Korean**: 절름거림 확인\n   * \n   * Uses worst leg health to match movement penalty behavior.\n   * \n   * @param bodyPartHealth - Current body part health\n   * @returns True if limping animation should play\n   * \n   */\n  public shouldLimp(bodyPartHealth: BodyPartHealth): boolean {\n    const worstLegHealth = Math.min(bodyPartHealth.legLeft, bodyPartHealth.legRight);\n    return worstLegHealth < this.config.legThresholds.normal;\n  }\n\n  /**\n   * Check if player has severe limp.\n   * \n   * **Korean**: 중증 절름거림 확인\n   * \n   * Uses worst leg health to match movement penalty behavior.\n   * \n   * @param bodyPartHealth - Current body part health\n   * @returns True if severe limp (leg health < 30%)\n   * \n   */\n  public hasSevereLimp(bodyPartHealth: BodyPartHealth): boolean {\n    const worstLegHealth = Math.min(bodyPartHealth.legLeft, bodyPartHealth.legRight);\n    return worstLegHealth < this.config.legThresholds.limping;\n  }\n\n  /**\n   * Get current injury state description.\n   * \n   * **Korean**: 부상 상태 설명\n   * \n   * Uses worst leg health to match movement penalty behavior.\n   * \n   * @param bodyPartHealth - Current body part health\n   * @returns Bilingual injury description\n   * \n   */\n  public getInjuryDescription(bodyPartHealth: BodyPartHealth): {\n    korean: string;\n    english: string;\n  } {\n    const worstLegHealth = Math.min(bodyPartHealth.legLeft, bodyPartHealth.legRight);\n    const leftLegPenalty = this.calculateLegPenalty(bodyPartHealth.legLeft);\n    const rightLegPenalty = this.calculateLegPenalty(bodyPartHealth.legRight);\n    const bothLegsInjured = this.areBothLegsInjured(leftLegPenalty, rightLegPenalty);\n\n    return this.generateStatusText(worstLegHealth, bothLegsInjured, false);\n  }\n}\n\n/**\n * Singleton instance for global access.\n * \n */\nexport const injuryMovementModifier = new InjuryMovementModifier();\n"],"mappings":"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"}

package/lib/systems/movement/integration.d.ts

@@ -33,7 +33,6 @@ import { TrigramStance } from "../../types/common";
  * movementState.legInjuryFactor = legInjuryFactor;
  * ```
  *
- * @public
  * @korean 다리손상요소계산
  */
 export declare function calculateLegInjuryFactor(bodyPartHealth: BodyPartHealth): number;
@@ -67,7 +66,6 @@ export declare function calculateLegInjuryFactor(bodyPartHealth: BodyPartHealth)
  * movementPhysics.setMaxSpeed(finalSpeed);
  * ```
  *
- * @public
  * @korean 종합이동속도계산
  */
 export declare function calculateMovementSpeed(baseSpeed: number, bodyPartHealth: BodyPartHealth, stance: TrigramStance, painLevel: number): number;
@@ -84,7 +82,6 @@ export declare function calculateMovementSpeed(baseSpeed: number, bodyPartHealth
  * @param bodyPartHealth - Current body part health
  * @returns Speed multiplier (0.1-1.0)
  *
- * @public
  * @korean 손상속도배수계산
  */
 export declare function calculateInjuryMultiplier(bodyPartHealth: BodyPartHealth): number;

package/lib/systems/movement/integration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"integration.d.ts","sourceRoot":"","sources":["../../../src/systems/movement/integration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,wBAAwB,CACtC,cAAc,EAAE,cAAc,GAC7B,MAAM,CAeR;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,cAAc,EAC9B,MAAM,EAAE,aAAa,EACrB,SAAS,EAAE,MAAM,GAChB,MAAM,CASR;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,yBAAyB,CACvC,cAAc,EAAE,cAAc,GAC7B,MAAM,CAWR"}
+{"version":3,"file":"integration.d.ts","sourceRoot":"","sources":["../../../src/systems/movement/integration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,wBAAwB,CACtC,cAAc,EAAE,cAAc,GAC7B,MAAM,CAeR;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,cAAc,EAC9B,MAAM,EAAE,aAAa,EACrB,SAAS,EAAE,MAAM,GAChB,MAAM,CASR;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,yBAAyB,CACvC,cAAc,EAAE,cAAc,GAC7B,MAAM,CAWR"}

package/lib/systems/movement/integration.js

@@ -34,7 +34,6 @@ import { injuryMovementModifier } from "./InjuryMovementModifier.js";
 * movementState.legInjuryFactor = legInjuryFactor;
 * ```
 * 
-* @public
 * @korean 다리손상요소계산
 */
 function calculateLegInjuryFactor(bodyPartHealth) {
@@ -72,7 +71,6 @@ function calculateLegInjuryFactor(bodyPartHealth) {
 * movementPhysics.setMaxSpeed(finalSpeed);
 * ```
 * 
-* @public
 * @korean 종합이동속도계산
 */
 function calculateMovementSpeed(baseSpeed, bodyPartHealth, stance, painLevel) {
@@ -91,7 +89,6 @@ function calculateMovementSpeed(baseSpeed, bodyPartHealth, stance, painLevel) {
 * @param bodyPartHealth - Current body part health
 * @returns Speed multiplier (0.1-1.0)
 * 
-* @public
 * @korean 손상속도배수계산
 */
 function calculateInjuryMultiplier(bodyPartHealth) {

package/lib/systems/movement/integration.js.map

@@ -1 +1 @@
-{"version":3,"file":"integration.js","names":[],"sources":["../../../src/systems/movement/integration.ts"],"sourcesContent":["/**\n * Integration module for InjuryMovementModifier with MovementPhysics\n * \n * **Korean**: 손상 이동 통합 (Injury Movement Integration)\n * \n * Provides helper functions to integrate the InjuryMovementModifier system\n * with the existing MovementPhysics system.\n * \n * @module systems/movement/integration\n * @category Movement System\n * @korean 손상이동통합\n */\n\nimport { injuryMovementModifier } from \"./InjuryMovementModifier\";\nimport type { BodyPartHealth } from \"../bodypart/types\";\nimport { TrigramStance } from \"@/types/common\";\n\n/**\n * Calculate leg injury factor for MovementPhysics from body part health.\n * \n * **Korean**: 다리 손상 요소 계산\n * \n * Converts detailed body part health into a simple 0-1 injury factor\n * that MovementPhysics.MovementState expects. This allows gradual\n * migration from the old simple system to the new detailed system.\n * \n * Uses the **worst** (minimum) leg health to match the main injury system's behavior,\n * ensuring asymmetric injuries (e.g., one leg at 0%, other at 100%) are properly represented.\n * \n * @param bodyPartHealth - Current body part health\n * @returns Leg injury factor (0 = healthy, 1 = fully injured), clamped to 0-1 range\n * \n * @example\n * ```typescript\n * const legInjuryFactor = calculateLegInjuryFactor(bodyPartHealth);\n * movementState.legInjuryFactor = legInjuryFactor;\n * ```\n * \n * @public\n * @korean 다리손상요소계산\n */\nexport function calculateLegInjuryFactor(\n  bodyPartHealth: BodyPartHealth\n): number {\n  // Use worst (minimum) leg health to match main injury system behavior\n  // This ensures asymmetric injuries are properly represented\n  const worstLegHealth = Math.min(bodyPartHealth.legLeft, bodyPartHealth.legRight);\n  \n  // Clamp worst leg health to valid 0-100 range to avoid invalid injury factors\n  const clampedLegHealth = Math.min(100, Math.max(0, worstLegHealth));\n\n  // Normalize to 0-1 health ratio (1 = fully healthy, 0 = no health)\n  const healthRatio = clampedLegHealth / 100;\n\n  // Convert to 0-1 injury factor (0 = healthy, 1 = fully injured)\n  // Use inverse of health ratio and clamp defensively to 0-1\n  const injuryFactor = 1.0 - healthRatio;\n  return Math.min(1, Math.max(0, injuryFactor));\n}\n\n/**\n * Calculate comprehensive movement speed with all injury modifiers.\n * \n * **Korean**: 종합 이동 속도 계산\n * \n * This is the recommended function for full integration with the new\n * injury system. It applies all modifiers including leg injuries,\n * torso damage, stance bonuses, and pain penalties.\n * \n * Uses the shared singleton instance to avoid allocations in per-frame loops.\n * \n * @param baseSpeed - Base movement speed (m/s)\n * @param bodyPartHealth - Current body part health\n * @param stance - Current trigram stance\n * @param painLevel - Current pain level (0-100)\n * @returns Final calculated speed in m/s\n * \n * @example\n * ```typescript\n * const finalSpeed = calculateMovementSpeed(\n *   5.0,\n *   playerBodyHealth,\n *   TrigramStance.GEON,\n *   65\n * );\n * \n * // Use this speed to override MovementPhysics\n * movementPhysics.setMaxSpeed(finalSpeed);\n * ```\n * \n * @public\n * @korean 종합이동속도계산\n */\nexport function calculateMovementSpeed(\n  baseSpeed: number,\n  bodyPartHealth: BodyPartHealth,\n  stance: TrigramStance,\n  painLevel: number\n): number {\n  const result = injuryMovementModifier.calculateMovementSpeed(\n    baseSpeed,\n    bodyPartHealth,\n    stance,\n    painLevel\n  );\n  \n  return result.finalSpeed;\n}\n\n/**\n * Calculate speed multiplier from injuries (without stance or pain).\n * \n * **Korean**: 손상 속도 배수 계산\n * \n * Useful when you want to apply injury penalties separately from\n * stance and pain modifiers.\n * \n * Uses the shared singleton instance to avoid allocations in per-frame loops.\n * \n * @param bodyPartHealth - Current body part health\n * @returns Speed multiplier (0.1-1.0)\n * \n * @public\n * @korean 손상속도배수계산\n */\nexport function calculateInjuryMultiplier(\n  bodyPartHealth: BodyPartHealth\n): number {\n  // Calculate without stance or pain modifiers\n  const result = injuryMovementModifier.calculateMovementSpeed(\n    1.0, // Base speed of 1.0 to get pure multiplier\n    bodyPartHealth,\n    TrigramStance.GEON, // Neutral stance (1.0x)\n    0 // No pain\n  );\n  \n  // The result will be the pure injury multiplier\n  return result.speedMultiplier;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,SAAgB,yBACd,gBACQ;CAGR,MAAM,iBAAiB,KAAK,IAAI,eAAe,SAAS,eAAe,SAAS;CAUhF,MAAM,eAAe,IAPI,KAAK,IAAI,KAAK,KAAK,IAAI,GAAG,eAAe,CAG9C,GAAmB;CAKvC,OAAO,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoC/C,SAAgB,uBACd,WACA,gBACA,QACA,WACQ;CAQR,OAPe,uBAAuB,uBACpC,WACA,gBACA,QACA,UAGK,CAAO;;;;;;;;;;;;;;;;;;AAmBhB,SAAgB,0BACd,gBACQ;CAUR,OARe,uBAAuB,uBACpC,GACA,gBACA,cAAc,MACd,EAIK,CAAO"}
+{"version":3,"file":"integration.js","names":[],"sources":["../../../src/systems/movement/integration.ts"],"sourcesContent":["/**\n * Integration module for InjuryMovementModifier with MovementPhysics\n * \n * **Korean**: 손상 이동 통합 (Injury Movement Integration)\n * \n * Provides helper functions to integrate the InjuryMovementModifier system\n * with the existing MovementPhysics system.\n * \n * @module systems/movement/integration\n * @category Movement System\n * @korean 손상이동통합\n */\n\nimport { injuryMovementModifier } from \"./InjuryMovementModifier\";\nimport type { BodyPartHealth } from \"../bodypart/types\";\nimport { TrigramStance } from \"@/types/common\";\n\n/**\n * Calculate leg injury factor for MovementPhysics from body part health.\n * \n * **Korean**: 다리 손상 요소 계산\n * \n * Converts detailed body part health into a simple 0-1 injury factor\n * that MovementPhysics.MovementState expects. This allows gradual\n * migration from the old simple system to the new detailed system.\n * \n * Uses the **worst** (minimum) leg health to match the main injury system's behavior,\n * ensuring asymmetric injuries (e.g., one leg at 0%, other at 100%) are properly represented.\n * \n * @param bodyPartHealth - Current body part health\n * @returns Leg injury factor (0 = healthy, 1 = fully injured), clamped to 0-1 range\n * \n * @example\n * ```typescript\n * const legInjuryFactor = calculateLegInjuryFactor(bodyPartHealth);\n * movementState.legInjuryFactor = legInjuryFactor;\n * ```\n * \n * @korean 다리손상요소계산\n */\nexport function calculateLegInjuryFactor(\n  bodyPartHealth: BodyPartHealth\n): number {\n  // Use worst (minimum) leg health to match main injury system behavior\n  // This ensures asymmetric injuries are properly represented\n  const worstLegHealth = Math.min(bodyPartHealth.legLeft, bodyPartHealth.legRight);\n  \n  // Clamp worst leg health to valid 0-100 range to avoid invalid injury factors\n  const clampedLegHealth = Math.min(100, Math.max(0, worstLegHealth));\n\n  // Normalize to 0-1 health ratio (1 = fully healthy, 0 = no health)\n  const healthRatio = clampedLegHealth / 100;\n\n  // Convert to 0-1 injury factor (0 = healthy, 1 = fully injured)\n  // Use inverse of health ratio and clamp defensively to 0-1\n  const injuryFactor = 1.0 - healthRatio;\n  return Math.min(1, Math.max(0, injuryFactor));\n}\n\n/**\n * Calculate comprehensive movement speed with all injury modifiers.\n * \n * **Korean**: 종합 이동 속도 계산\n * \n * This is the recommended function for full integration with the new\n * injury system. It applies all modifiers including leg injuries,\n * torso damage, stance bonuses, and pain penalties.\n * \n * Uses the shared singleton instance to avoid allocations in per-frame loops.\n * \n * @param baseSpeed - Base movement speed (m/s)\n * @param bodyPartHealth - Current body part health\n * @param stance - Current trigram stance\n * @param painLevel - Current pain level (0-100)\n * @returns Final calculated speed in m/s\n * \n * @example\n * ```typescript\n * const finalSpeed = calculateMovementSpeed(\n *   5.0,\n *   playerBodyHealth,\n *   TrigramStance.GEON,\n *   65\n * );\n * \n * // Use this speed to override MovementPhysics\n * movementPhysics.setMaxSpeed(finalSpeed);\n * ```\n * \n * @korean 종합이동속도계산\n */\nexport function calculateMovementSpeed(\n  baseSpeed: number,\n  bodyPartHealth: BodyPartHealth,\n  stance: TrigramStance,\n  painLevel: number\n): number {\n  const result = injuryMovementModifier.calculateMovementSpeed(\n    baseSpeed,\n    bodyPartHealth,\n    stance,\n    painLevel\n  );\n  \n  return result.finalSpeed;\n}\n\n/**\n * Calculate speed multiplier from injuries (without stance or pain).\n * \n * **Korean**: 손상 속도 배수 계산\n * \n * Useful when you want to apply injury penalties separately from\n * stance and pain modifiers.\n * \n * Uses the shared singleton instance to avoid allocations in per-frame loops.\n * \n * @param bodyPartHealth - Current body part health\n * @returns Speed multiplier (0.1-1.0)\n * \n * @korean 손상속도배수계산\n */\nexport function calculateInjuryMultiplier(\n  bodyPartHealth: BodyPartHealth\n): number {\n  // Calculate without stance or pain modifiers\n  const result = injuryMovementModifier.calculateMovementSpeed(\n    1.0, // Base speed of 1.0 to get pure multiplier\n    bodyPartHealth,\n    TrigramStance.GEON, // Neutral stance (1.0x)\n    0 // No pain\n  );\n  \n  // The result will be the pure injury multiplier\n  return result.speedMultiplier;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,SAAgB,yBACd,gBACQ;CAGR,MAAM,iBAAiB,KAAK,IAAI,eAAe,SAAS,eAAe,SAAS;CAUhF,MAAM,eAAe,IAPI,KAAK,IAAI,KAAK,KAAK,IAAI,GAAG,eAAe,CAG9C,GAAmB;CAKvC,OAAO,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmC/C,SAAgB,uBACd,WACA,gBACA,QACA,WACQ;CAQR,OAPe,uBAAuB,uBACpC,WACA,gBACA,QACA,UAGK,CAAO;;;;;;;;;;;;;;;;;AAkBhB,SAAgB,0BACd,gBACQ;CAUR,OARe,uBAAuB,uBACpC,GACA,gBACA,cAAc,MACd,EAIK,CAAO"}

package/lib/systems/physics/AttackMovementPhysics.d.ts

@@ -38,7 +38,6 @@ import { AnimationType } from "../animation";
  *
  * **Korean**: 공격 이동 설정 (Attack Movement Configuration)
  *
- * @public
  * @korean 공격이동설정
  */
 export interface AttackMovementConfig {
@@ -58,7 +57,6 @@ export interface AttackMovementConfig {
  *
  * Contains displacement vector and timing for attack lunge.
  *
- * @public
  * @korean 공격이동결과
  */
 export interface AttackMovementResult {
@@ -98,7 +96,6 @@ export interface AttackMovementResult {
  * // recoveryDuration: 0.24s (50% of animation)
  * ```
  *
- * @public
  * @korean 공격이동물리
  */
 export declare class AttackMovementPhysics {
@@ -136,7 +133,6 @@ export declare class AttackMovementPhysics {
      * // Result: ~0.24m forward (0.3m * 0.8 Gan modifier)
      * ```
      *
-     * @public
      * @korean 공격이동계산
      */
     calculateAttackMovement(config: AttackMovementConfig): AttackMovementResult;
@@ -220,7 +216,6 @@ export declare class AttackMovementPhysics {
      * }
      * ```
      *
-     * @public
      * @korean 공격이동적용
      */
     applyAttackMovement(basePosition: THREE.Vector3, result: AttackMovementResult, elapsedTime: number, isRecoveryPhase: boolean): THREE.Vector3;
@@ -233,7 +228,6 @@ export declare class AttackMovementPhysics {
      * @param lungeDuration - Total lunge phase duration
      * @returns True if in forward lunge phase
      *
-     * @public
      * @korean 돌진상태확인
      */
     isInLungePhase(elapsedTime: number, lungeDuration: number): boolean;
@@ -246,7 +240,6 @@ export declare class AttackMovementPhysics {
      * @param result - Attack movement result with timing
      * @returns True if in recovery return phase
      *
-     * @public
      * @korean 회복상태확인
      */
     isInRecoveryPhase(elapsedTime: number, result: AttackMovementResult): boolean;
@@ -257,7 +250,6 @@ export declare class AttackMovementPhysics {
      *
      * @returns Korean and English phase names
      *
-     * @public
      * @korean 돌진단계이름
      */
     getLungePhaseName(): {
@@ -271,7 +263,6 @@ export declare class AttackMovementPhysics {
      *
      * @returns Korean and English phase names
      *
-     * @public
      * @korean 복귀단계이름
      */
     getRecoveryPhaseName(): {

package/lib/systems/physics/AttackMovementPhysics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AttackMovementPhysics.d.ts","sourceRoot":"","sources":["../../../src/systems/physics/AttackMovementPhysics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD;;;;;;;GAOG;AACH,MAAM,WAAW,oBAAoB;IACnC,oCAAoC;IACpC,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IACtC,6BAA6B;IAC7B,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IACtC,6DAA6D;IAC7D,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC,OAAO,CAAC;IAClC,iDAAiD;IACjD,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;CACpC;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,oBAAoB;IACnC,uDAAuD;IACvD,QAAQ,CAAC,YAAY,EAAE,KAAK,CAAC,OAAO,CAAC;IACrC,iDAAiD;IACjD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,mDAAmD;IACnD,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,+CAA+C;IAC/C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,qBAAa,qBAAqB;IAChC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,uBAAuB,CACrB,MAAM,EAAE,oBAAoB,GAC3B,oBAAoB;IAuBvB;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,uBAAuB;IAqJ/B;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,OAAO,CAAC,yBAAyB;IAcjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0CG;IACH,mBAAmB,CACjB,YAAY,EAAE,KAAK,CAAC,OAAO,EAC3B,MAAM,EAAE,oBAAoB,EAC5B,WAAW,EAAE,MAAM,EACnB,eAAe,EAAE,OAAO,GACvB,KAAK,CAAC,OAAO;IAmChB;;;;;;;;;;;OAWG;IACH,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO;IAInE;;;;;;;;;;;OAWG;IACH,iBAAiB,CACf,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,oBAAoB,GAC3B,OAAO;IAOV;;;;;;;;;OASG;IACH,iBAAiB,IAAI;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;IAOxD;;;;;;;;;OASG;IACH,oBAAoB,IAAI;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;CAM5D;AAED,eAAe,qBAAqB,CAAC"}
+{"version":3,"file":"AttackMovementPhysics.d.ts","sourceRoot":"","sources":["../../../src/systems/physics/AttackMovementPhysics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD;;;;;;GAMG;AACH,MAAM,WAAW,oBAAoB;IACnC,oCAAoC;IACpC,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IACtC,6BAA6B;IAC7B,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IACtC,6DAA6D;IAC7D,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC,OAAO,CAAC;IAClC,iDAAiD;IACjD,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;CACpC;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,oBAAoB;IACnC,uDAAuD;IACvD,QAAQ,CAAC,YAAY,EAAE,KAAK,CAAC,OAAO,CAAC;IACrC,iDAAiD;IACjD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,mDAAmD;IACnD,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,+CAA+C;IAC/C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,qBAAqB;IAChC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,uBAAuB,CACrB,MAAM,EAAE,oBAAoB,GAC3B,oBAAoB;IAuBvB;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,uBAAuB;IAqJ/B;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,OAAO,CAAC,yBAAyB;IAcjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;IACH,mBAAmB,CACjB,YAAY,EAAE,KAAK,CAAC,OAAO,EAC3B,MAAM,EAAE,oBAAoB,EAC5B,WAAW,EAAE,MAAM,EACnB,eAAe,EAAE,OAAO,GACvB,KAAK,CAAC,OAAO;IAmChB;;;;;;;;;;OAUG;IACH,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO;IAInE;;;;;;;;;;OAUG;IACH,iBAAiB,CACf,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,oBAAoB,GAC3B,OAAO;IAOV;;;;;;;;OAQG;IACH,iBAAiB,IAAI;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;IAOxD;;;;;;;;OAQG;IACH,oBAAoB,IAAI;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;CAM5D;AAED,eAAe,qBAAqB,CAAC"}

package/lib/systems/physics/AttackMovementPhysics.js

@@ -28,7 +28,6 @@ import { AnimationType } from "../animation/builders/MartialArtsConstants.js";
 * // recoveryDuration: 0.24s (50% of animation)
 * ```
 *
-* @public
 * @korean 공격이동물리
 */
 var AttackMovementPhysics = class {
@@ -66,7 +65,6 @@ var AttackMovementPhysics = class {
 	* // Result: ~0.24m forward (0.3m * 0.8 Gan modifier)
 	* ```
 	*
-	* @public
 	* @korean 공격이동계산
 	*/
 	calculateAttackMovement(config) {
@@ -184,7 +182,6 @@ var AttackMovementPhysics = class {
 	* }
 	* ```
 	*
-	* @public
 	* @korean 공격이동적용
 	*/
 	applyAttackMovement(basePosition, result, elapsedTime, isRecoveryPhase) {
@@ -211,7 +208,6 @@ var AttackMovementPhysics = class {
 	* @param lungeDuration - Total lunge phase duration
 	* @returns True if in forward lunge phase
 	*
-	* @public
 	* @korean 돌진상태확인
 	*/
 	isInLungePhase(elapsedTime, lungeDuration) {
@@ -226,7 +222,6 @@ var AttackMovementPhysics = class {
 	* @param result - Attack movement result with timing
 	* @returns True if in recovery return phase
 	*
-	* @public
 	* @korean 회복상태확인
 	*/
 	isInRecoveryPhase(elapsedTime, result) {
@@ -239,7 +234,6 @@ var AttackMovementPhysics = class {
 	*
 	* @returns Korean and English phase names
 	*
-	* @public
 	* @korean 돌진단계이름
 	*/
 	getLungePhaseName() {
@@ -255,7 +249,6 @@ var AttackMovementPhysics = class {
 	*
 	* @returns Korean and English phase names
 	*
-	* @public
 	* @korean 복귀단계이름
 	*/
 	getRecoveryPhaseName() {

package/lib/systems/physics/AttackMovementPhysics.js.map

@@ -1 +1 @@
-{"version":3,"file":"AttackMovementPhysics.js","names":[],"sources":["../../../src/systems/physics/AttackMovementPhysics.ts"],"sourcesContent":["/**\n * Attack Movement Physics System for realistic forward momentum during attacks.\n *\n * **Korean**: 공격 이동 물리 시스템 (Attack Movement Physics System)\n *\n * Implements realistic forward movement physics when fighters execute attacks.\n * Kicks naturally extend the body forward, punches lunge with body weight,\n * and spinning techniques carry rotational momentum.\n *\n * ## Attack Movement Mechanics\n *\n * Forward movement distance is determined by:\n * - Animation type (kicks > punches > elbows/knees)\n * - Stance modifiers (8 trigram stances affect aggression)\n * - Animation phase timing (extension → peak → recovery)\n *\n * ## Movement Integration\n *\n * - Extension phase (frames 3-6): Forward lunge with ease-out\n * - Peak phase (frame 6): Maximum extension reached\n * - Recovery phase (frames 7-10): Return to original stance\n * - Arena bounds: Automatically clamp movement to valid zone\n *\n * ## Performance\n *\n * Optimized for 60fps with efficient vector calculations and\n * smooth easing curves for realistic attack momentum feel.\n *\n * @module systems/physics/AttackMovementPhysics\n * @category Physics System\n * @korean 공격이동물리\n */\n\nimport * as THREE from \"three\";\nimport { TrigramStance } from \"@/types/common\";\nimport { AnimationType } from \"@/systems/animation\";\n\n/**\n * Configuration for attack movement calculation.\n *\n * **Korean**: 공격 이동 설정 (Attack Movement Configuration)\n *\n * @public\n * @korean 공격이동설정\n */\nexport interface AttackMovementConfig {\n  /** Animation type being executed */\n  readonly animationType: AnimationType;\n  /** Current trigram stance */\n  readonly currentStance: TrigramStance;\n  /** Normalized attack direction vector (attacker → target) */\n  readonly direction: THREE.Vector3;\n  /** Total attack animation duration in seconds */\n  readonly animationDuration: number;\n}\n\n/**\n * Result of attack movement calculation.\n *\n * **Korean**: 공격 이동 결과 (Attack Movement Result)\n *\n * Contains displacement vector and timing for attack lunge.\n *\n * @public\n * @korean 공격이동결과\n */\nexport interface AttackMovementResult {\n  /** Total forward displacement vector in world space */\n  readonly displacement: THREE.Vector3;\n  /** Duration of forward lunge phase in seconds */\n  readonly lungeDuration: number;\n  /** Duration of recovery return phase in seconds */\n  readonly recoveryDuration: number;\n  /** Total movement cycle duration in seconds */\n  readonly totalDuration: number;\n}\n\n/**\n * Attack Movement Physics Engine.\n *\n * **Korean**: 공격 이동 물리 엔진\n *\n * Calculates realistic forward movement during attack animations\n * based on technique type, stance modifiers, and animation timing.\n * Provides smooth lunge and recovery phases for authentic martial arts feel.\n *\n * @example\n * ```typescript\n * const physics = new AttackMovementPhysics();\n *\n * // Calculate movement for roundhouse kick\n * const config: AttackMovementConfig = {\n *   animationType: AnimationType.ROUNDHOUSE_KICK,\n *   currentStance: TrigramStance.LI, // Fire stance (aggressive)\n *   direction: new THREE.Vector3(1, 0, 0).normalize(),\n *   animationDuration: 0.48, // 480ms kick animation\n * };\n *\n * const result = physics.calculateAttackMovement(config);\n * // Result: 1.0m base * 1.3 (Fire bonus) = ~1.3m forward lunge\n * // lungeDuration: 0.24s (50% of animation)\n * // recoveryDuration: 0.24s (50% of animation)\n * ```\n *\n * @public\n * @korean 공격이동물리\n */\nexport class AttackMovementPhysics {\n  /**\n   * Calculates attack movement displacement and timing.\n   *\n   * **Korean**: 공격 이동 계산 (Calculate Attack Movement)\n   *\n   * Determines forward lunge distance and recovery timing based on:\n   * 1. Base movement from animation type\n   * 2. Stance movement modifier (8 trigram effects)\n   * 3. Animation phase durations (lunge vs recovery)\n   *\n   * @param config - Attack movement configuration\n   * @returns Attack movement result with displacement and timing\n   *\n   * @example\n   * ```typescript\n   * // Front kick with Heaven stance\n   * const kick = physics.calculateAttackMovement({\n   *   animationType: AnimationType.FRONT_KICK,\n   *   currentStance: TrigramStance.GEON,\n   *   direction: attackVector,\n   *   animationDuration: 0.4,\n   * });\n   * // Result: ~0.88m forward (0.8m * 1.1 Geon modifier)\n   *\n   * // Jab with Mountain stance\n   * const jab = physics.calculateAttackMovement({\n   *   animationType: AnimationType.JAB,\n   *   currentStance: TrigramStance.GAN,\n   *   direction: attackVector,\n   *   animationDuration: 0.25,\n   * });\n   * // Result: ~0.24m forward (0.3m * 0.8 Gan modifier)\n   * ```\n   *\n   * @public\n   * @korean 공격이동계산\n   */\n  calculateAttackMovement(\n    config: AttackMovementConfig\n  ): AttackMovementResult {\n    // 1. Get base movement distance for animation type\n    const baseDistance = this.getBaseMovementDistance(config.animationType);\n\n    // 2. Apply stance movement modifier\n    const stanceModifier = this.getStanceMovementModifier(config.currentStance);\n    const finalDistance = baseDistance * stanceModifier;\n\n    // 3. Calculate displacement vector\n    const displacement = config.direction.clone().multiplyScalar(finalDistance);\n\n    // 4. Calculate phase durations (lunge + recovery)\n    const lungeDuration = config.animationDuration * 0.5; // First 50% = forward\n    const recoveryDuration = config.animationDuration * 0.5; // Last 50% = return\n\n    return {\n      displacement,\n      lungeDuration,\n      recoveryDuration,\n      totalDuration: config.animationDuration,\n    };\n  }\n\n  /**\n   * Gets base forward movement distance for animation type.\n   *\n   * **Korean**: 기본 이동 거리 (Base Movement Distance)\n   *\n   * Movement distances by technique category:\n   * - Kicks: 0.8-1.2m (leg extension, longest reach)\n   * - Punches: 0.3-0.5m (arm extension, body lunge)\n   * - Elbows/Knees: 0.2-0.3m (close range techniques)\n   * - Spinning: 0.5-0.8m (rotation carries momentum)\n   *\n   * @param animationType - Type of attack animation\n   * @returns Base movement distance in meters\n   *\n   * @private\n   * @korean 기본이동거리\n   */\n  private getBaseMovementDistance(animationType: AnimationType): number {\n    // Kicks - highest forward movement (leg extension)\n    if (\n      animationType === AnimationType.ROUNDHOUSE_KICK ||\n      animationType === AnimationType.SIDE_KICK ||\n      animationType === AnimationType.BACK_KICK\n    ) {\n      return 1.0; // 1.0m forward lunge\n    }\n\n    if (\n      animationType === AnimationType.FRONT_KICK ||\n      animationType === AnimationType.PUSH_KICK\n    ) {\n      return 0.8; // 0.8m forward lunge\n    }\n\n    if (\n      animationType === AnimationType.AXE_KICK ||\n      animationType === AnimationType.CRESCENT_KICK ||\n      animationType === AnimationType.LOW_KICK\n    ) {\n      return 0.9; // 0.9m forward lunge\n    }\n\n    // Spinning kicks - momentum carries body forward\n    if (\n      animationType === AnimationType.SPINNING_HOOK ||\n      animationType === AnimationType.SPINNING_HEEL_KICK ||\n      animationType === AnimationType.TORNADO_KICK\n    ) {\n      return 0.8; // 0.8m with rotation\n    }\n\n    // Jumping/flying kicks - aerial momentum\n    if (\n      animationType === AnimationType.FLYING_KICK ||\n      animationType === AnimationType.JUMPING_KICK\n    ) {\n      return 1.2; // 1.2m maximum extension\n    }\n\n    // Punches - moderate forward movement (arm + body lunge)\n    if (\n      animationType === AnimationType.CROSS ||\n      animationType === AnimationType.OVERHAND ||\n      animationType === AnimationType.HOOK\n    ) {\n      return 0.5; // 0.5m forward lunge\n    }\n\n    if (\n      animationType === AnimationType.JAB ||\n      animationType === AnimationType.BACKFIST\n    ) {\n      return 0.3; // 0.3m forward lunge\n    }\n\n    if (\n      animationType === AnimationType.UPPERCUT ||\n      animationType === AnimationType.HAMMER_FIST ||\n      animationType === AnimationType.PALM_STRIKE\n    ) {\n      return 0.4; // 0.4m forward lunge\n    }\n\n    // Elbow/Knee - minimal movement (close range)\n    if (\n      animationType === AnimationType.ELBOW_STRIKE ||\n      animationType === AnimationType.KNEE_STRIKE ||\n      animationType === AnimationType.KNEE_KICK ||\n      animationType === AnimationType.ELBOW_UPPERCUT ||\n      animationType === AnimationType.FLYING_KNEE ||\n      animationType === AnimationType.CLINCH_KNEE ||\n      animationType === AnimationType.SPINNING_ELBOW ||\n      animationType === AnimationType.TEMPLE_ELBOW ||\n      animationType === AnimationType.SPINNING_BACK_ELBOW ||\n      animationType === AnimationType.SPINAL_ELBOW ||\n      animationType === AnimationType.BRACHIAL_ELBOW ||\n      animationType === AnimationType.KIDNEY_KNEE ||\n      animationType === AnimationType.FEMORAL_KNEE\n    ) {\n      return 0.2; // 0.2m forward lunge\n    }\n\n    // Specialized jab variants - similar to jab (quick extension)\n    if (\n      animationType === AnimationType.SPEAR_HAND_STRIKE ||\n      animationType === AnimationType.NERVE_STRIKE ||\n      animationType === AnimationType.PRESSURE_POINT_STRIKE ||\n      animationType === AnimationType.LIGHTNING_STRIKE ||\n      animationType === AnimationType.RAPID_BARRAGE ||\n      animationType === AnimationType.RHYTHMIC_STRIKES ||\n      animationType === AnimationType.NERVE_PARALYSIS ||\n      animationType === AnimationType.THROAT_STRIKE ||\n      animationType === AnimationType.EYE_GOUGE\n    ) {\n      return 0.3; // 0.3m forward lunge (jab-like)\n    }\n\n    // Specialized cross variants - similar to cross (body weight transfer)\n    if (\n      animationType === AnimationType.HEAVEN_STRIKE ||\n      animationType === AnimationType.FLOWING_CROSS\n    ) {\n      return 0.5; // 0.5m forward lunge (cross-like)\n    }\n\n    // Specialized palm strikes - similar to palm strike\n    if (\n      animationType === AnimationType.SOLAR_PLEXUS_STRIKE ||\n      animationType === AnimationType.FLOWING_PUSH ||\n      animationType === AnimationType.LIVER_DISRUPTION ||\n      animationType === AnimationType.EAR_STRIKE\n    ) {\n      return 0.4; // 0.4m forward lunge (palm-like)\n    }\n\n    // Grappling - minimal forward movement (rotation/off-balancing in place)\n    if (\n      animationType === AnimationType.THROW ||\n      animationType === AnimationType.JOINT_LOCK ||\n      animationType === AnimationType.TAKEDOWN ||\n      animationType === AnimationType.SWEEP ||\n      animationType === AnimationType.CLINCH ||\n      animationType === AnimationType.GRAPPLE ||\n      animationType === AnimationType.SLAM ||\n      animationType === AnimationType.WRIST_LOCK ||\n      animationType === AnimationType.ARM_BAR ||\n      animationType === AnimationType.SHOULDER_LOCK ||\n      animationType === AnimationType.HIP_THROW ||\n      animationType === AnimationType.LEG_REAP ||\n      animationType === AnimationType.SMALL_CIRCLE_LOCK ||\n      animationType === AnimationType.FINGER_LOCK ||\n      animationType === AnimationType.ELBOW_LOCK ||\n      animationType === AnimationType.SHOULDER_MANIPULATION ||\n      animationType === AnimationType.MOUNTAIN_LOCK ||\n      animationType === AnimationType.EARTH_EMBRACE ||\n      animationType === AnimationType.CAROTID_CHOKE\n    ) {\n      return 0.05; // 0.05m forward movement for grappling entries\n    }\n\n    // Default - conservative minimal movement for any unmapped types\n    // Additional AnimationType values can be grouped with the closest category above\n    // to fine-tune their forward displacement without changing overall behavior\n    return 0.2;\n  }\n\n  /**\n   * Gets stance movement modifier for attack lunge.\n   *\n   * **Korean**: 자세 이동 배율 (Stance Movement Modifier)\n   *\n   * Trigram stance movement modifiers based on combat philosophy:\n   * - ☰ 건 (Geon/Heaven): +30% movement (aggressive, drives forward with pure yang)\n   * - ☳ 진 (Jin/Thunder): +20% movement (explosive power, shocking force)\n   * - ☴ 손 (Son/Wind): +15% movement (continuous flow, mobile)\n   * - ☲ 리 (Li/Fire): +10% movement (precision strikes, controlled aggression)\n   * - ☱ 태 (Tae/Lake): 0% (neutral, fluid and adaptive)\n   * - ☵ 감 (Gam/Water): 0% (neutral, flowing and flexible)\n   * - ☷ 곤 (Gon/Earth): -10% movement (grounded, stable techniques)\n   * - ☶ 간 (Gan/Mountain): -20% movement (defensive mastery, minimal advance)\n   *\n   * @param stance - Current trigram stance\n   * @returns Movement multiplier (0.8 to 1.3)\n   *\n   * @private\n   * @korean 자세이동배율\n   */\n  private getStanceMovementModifier(stance: TrigramStance): number {\n    const modifiers: Record<TrigramStance, number> = {\n      [TrigramStance.GEON]: 1.3, // Heaven: +30% aggressive forward pressure (pure yang drives forward)\n      [TrigramStance.JIN]: 1.2, // Thunder: +20% explosive movement\n      [TrigramStance.SON]: 1.15, // Wind: +15% flowing movement\n      [TrigramStance.LI]: 1.1, // Fire: +10% precision strikes with controlled forward movement\n      [TrigramStance.TAE]: 1.0, // Lake: neutral movement\n      [TrigramStance.GAM]: 1.0, // Water: neutral movement\n      [TrigramStance.GON]: 0.9, // Earth: -10% grounded movement\n      [TrigramStance.GAN]: 0.8, // Mountain: -20% defensive movement\n    };\n    return modifiers[stance];\n  }\n\n  /**\n   * Applies attack movement force to attacker position over time.\n   *\n   * **Korean**: 공격 이동 적용 (Apply Attack Movement)\n   *\n   * Uses smooth ease-out cubic curve for realistic lunge feel:\n   * - Fast initial forward movement (attack commitment)\n   * - Gradual deceleration at peak extension\n   * - Smooth return during recovery phase\n   *\n   * @param basePosition - Original stance position (does not change during attack)\n   * @param result - Attack movement result with displacement\n   * @param elapsedTime - Time elapsed since attack started\n   * @param isRecoveryPhase - Whether in recovery (return) phase\n   * @returns New position with attack displacement applied\n   *\n   * @example\n   * ```typescript\n   * // In animation update loop (60fps)\n   * const basePos = new THREE.Vector3(0, 0, 0); // Original stance position\n   * \n   * if (elapsedTime < result.lungeDuration) {\n   *   // Lunge forward phase\n   *   const newPosition = physics.applyAttackMovement(\n   *     basePos,\n   *     result,\n   *     elapsedTime,\n   *     false\n   *   );\n   * } else if (elapsedTime < result.totalDuration) {\n   *   // Recovery return phase\n   *   const newPosition = physics.applyAttackMovement(\n   *     basePos,\n   *     result,\n   *     elapsedTime,\n   *     true\n   *   );\n   * }\n   * ```\n   *\n   * @public\n   * @korean 공격이동적용\n   */\n  applyAttackMovement(\n    basePosition: THREE.Vector3,\n    result: AttackMovementResult,\n    elapsedTime: number,\n    isRecoveryPhase: boolean\n  ): THREE.Vector3 {\n    let progress: number;\n\n    if (!isRecoveryPhase) {\n      // Lunge forward phase\n      progress = Math.min(1.0, elapsedTime / result.lungeDuration);\n\n      // Smooth forward lunge curve (ease-out cubic)\n      // Fast initial commitment, gradual deceleration at peak\n      const easedProgress = 1 - Math.pow(1 - progress, 3);\n\n      // Calculate position along forward path\n      const currentDisplacement = result.displacement\n        .clone()\n        .multiplyScalar(easedProgress);\n\n      return basePosition.clone().add(currentDisplacement);\n    } else {\n      // Recovery return phase\n      const recoveryTime = elapsedTime - result.lungeDuration;\n      progress = Math.min(1.0, recoveryTime / result.recoveryDuration);\n\n      // Smooth return curve (ease-in cubic)\n      // Gradual start, faster finish back to stance\n      const easedProgress = Math.pow(progress, 3);\n\n      // Calculate return position (from peak back to origin)\n      const returnDisplacement = result.displacement\n        .clone()\n        .multiplyScalar(1.0 - easedProgress);\n\n      return basePosition.clone().add(returnDisplacement);\n    }\n  }\n\n  /**\n   * Checks if attacker is currently in lunge phase.\n   *\n   * **Korean**: 돌진 상태 확인 (Check Lunge State)\n   *\n   * @param elapsedTime - Time elapsed since attack started\n   * @param lungeDuration - Total lunge phase duration\n   * @returns True if in forward lunge phase\n   *\n   * @public\n   * @korean 돌진상태확인\n   */\n  isInLungePhase(elapsedTime: number, lungeDuration: number): boolean {\n    return elapsedTime < lungeDuration;\n  }\n\n  /**\n   * Checks if attacker is in recovery return phase.\n   *\n   * **Korean**: 회복 상태 확인 (Check Recovery State)\n   *\n   * @param elapsedTime - Time elapsed since attack started\n   * @param result - Attack movement result with timing\n   * @returns True if in recovery return phase\n   *\n   * @public\n   * @korean 회복상태확인\n   */\n  isInRecoveryPhase(\n    elapsedTime: number,\n    result: AttackMovementResult\n  ): boolean {\n    return (\n      elapsedTime >= result.lungeDuration &&\n      elapsedTime < result.totalDuration\n    );\n  }\n\n  /**\n   * Gets bilingual Korean-English name for lunge phase.\n   *\n   * **Korean**: 돌진 단계 이름 (Lunge Phase Name)\n   *\n   * @returns Korean and English phase names\n   *\n   * @public\n   * @korean 돌진단계이름\n   */\n  getLungePhaseName(): { korean: string; english: string } {\n    return {\n      korean: \"돌진\",\n      english: \"Lunge\",\n    };\n  }\n\n  /**\n   * Gets bilingual Korean-English name for recovery phase.\n   *\n   * **Korean**: 복귀 단계 이름 (Recovery Phase Name)\n   *\n   * @returns Korean and English phase names\n   *\n   * @public\n   * @korean 복귀단계이름\n   */\n  getRecoveryPhaseName(): { korean: string; english: string } {\n    return {\n      korean: \"복귀\",\n      english: \"Recovery\",\n    };\n  }\n}\n\nexport default AttackMovementPhysics;\n"],"mappings":"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"}
+{"version":3,"file":"AttackMovementPhysics.js","names":[],"sources":["../../../src/systems/physics/AttackMovementPhysics.ts"],"sourcesContent":["/**\n * Attack Movement Physics System for realistic forward momentum during attacks.\n *\n * **Korean**: 공격 이동 물리 시스템 (Attack Movement Physics System)\n *\n * Implements realistic forward movement physics when fighters execute attacks.\n * Kicks naturally extend the body forward, punches lunge with body weight,\n * and spinning techniques carry rotational momentum.\n *\n * ## Attack Movement Mechanics\n *\n * Forward movement distance is determined by:\n * - Animation type (kicks > punches > elbows/knees)\n * - Stance modifiers (8 trigram stances affect aggression)\n * - Animation phase timing (extension → peak → recovery)\n *\n * ## Movement Integration\n *\n * - Extension phase (frames 3-6): Forward lunge with ease-out\n * - Peak phase (frame 6): Maximum extension reached\n * - Recovery phase (frames 7-10): Return to original stance\n * - Arena bounds: Automatically clamp movement to valid zone\n *\n * ## Performance\n *\n * Optimized for 60fps with efficient vector calculations and\n * smooth easing curves for realistic attack momentum feel.\n *\n * @module systems/physics/AttackMovementPhysics\n * @category Physics System\n * @korean 공격이동물리\n */\n\nimport * as THREE from \"three\";\nimport { TrigramStance } from \"@/types/common\";\nimport { AnimationType } from \"@/systems/animation\";\n\n/**\n * Configuration for attack movement calculation.\n *\n * **Korean**: 공격 이동 설정 (Attack Movement Configuration)\n *\n * @korean 공격이동설정\n */\nexport interface AttackMovementConfig {\n  /** Animation type being executed */\n  readonly animationType: AnimationType;\n  /** Current trigram stance */\n  readonly currentStance: TrigramStance;\n  /** Normalized attack direction vector (attacker → target) */\n  readonly direction: THREE.Vector3;\n  /** Total attack animation duration in seconds */\n  readonly animationDuration: number;\n}\n\n/**\n * Result of attack movement calculation.\n *\n * **Korean**: 공격 이동 결과 (Attack Movement Result)\n *\n * Contains displacement vector and timing for attack lunge.\n *\n * @korean 공격이동결과\n */\nexport interface AttackMovementResult {\n  /** Total forward displacement vector in world space */\n  readonly displacement: THREE.Vector3;\n  /** Duration of forward lunge phase in seconds */\n  readonly lungeDuration: number;\n  /** Duration of recovery return phase in seconds */\n  readonly recoveryDuration: number;\n  /** Total movement cycle duration in seconds */\n  readonly totalDuration: number;\n}\n\n/**\n * Attack Movement Physics Engine.\n *\n * **Korean**: 공격 이동 물리 엔진\n *\n * Calculates realistic forward movement during attack animations\n * based on technique type, stance modifiers, and animation timing.\n * Provides smooth lunge and recovery phases for authentic martial arts feel.\n *\n * @example\n * ```typescript\n * const physics = new AttackMovementPhysics();\n *\n * // Calculate movement for roundhouse kick\n * const config: AttackMovementConfig = {\n *   animationType: AnimationType.ROUNDHOUSE_KICK,\n *   currentStance: TrigramStance.LI, // Fire stance (aggressive)\n *   direction: new THREE.Vector3(1, 0, 0).normalize(),\n *   animationDuration: 0.48, // 480ms kick animation\n * };\n *\n * const result = physics.calculateAttackMovement(config);\n * // Result: 1.0m base * 1.3 (Fire bonus) = ~1.3m forward lunge\n * // lungeDuration: 0.24s (50% of animation)\n * // recoveryDuration: 0.24s (50% of animation)\n * ```\n *\n * @korean 공격이동물리\n */\nexport class AttackMovementPhysics {\n  /**\n   * Calculates attack movement displacement and timing.\n   *\n   * **Korean**: 공격 이동 계산 (Calculate Attack Movement)\n   *\n   * Determines forward lunge distance and recovery timing based on:\n   * 1. Base movement from animation type\n   * 2. Stance movement modifier (8 trigram effects)\n   * 3. Animation phase durations (lunge vs recovery)\n   *\n   * @param config - Attack movement configuration\n   * @returns Attack movement result with displacement and timing\n   *\n   * @example\n   * ```typescript\n   * // Front kick with Heaven stance\n   * const kick = physics.calculateAttackMovement({\n   *   animationType: AnimationType.FRONT_KICK,\n   *   currentStance: TrigramStance.GEON,\n   *   direction: attackVector,\n   *   animationDuration: 0.4,\n   * });\n   * // Result: ~0.88m forward (0.8m * 1.1 Geon modifier)\n   *\n   * // Jab with Mountain stance\n   * const jab = physics.calculateAttackMovement({\n   *   animationType: AnimationType.JAB,\n   *   currentStance: TrigramStance.GAN,\n   *   direction: attackVector,\n   *   animationDuration: 0.25,\n   * });\n   * // Result: ~0.24m forward (0.3m * 0.8 Gan modifier)\n   * ```\n   *\n   * @korean 공격이동계산\n   */\n  calculateAttackMovement(\n    config: AttackMovementConfig\n  ): AttackMovementResult {\n    // 1. Get base movement distance for animation type\n    const baseDistance = this.getBaseMovementDistance(config.animationType);\n\n    // 2. Apply stance movement modifier\n    const stanceModifier = this.getStanceMovementModifier(config.currentStance);\n    const finalDistance = baseDistance * stanceModifier;\n\n    // 3. Calculate displacement vector\n    const displacement = config.direction.clone().multiplyScalar(finalDistance);\n\n    // 4. Calculate phase durations (lunge + recovery)\n    const lungeDuration = config.animationDuration * 0.5; // First 50% = forward\n    const recoveryDuration = config.animationDuration * 0.5; // Last 50% = return\n\n    return {\n      displacement,\n      lungeDuration,\n      recoveryDuration,\n      totalDuration: config.animationDuration,\n    };\n  }\n\n  /**\n   * Gets base forward movement distance for animation type.\n   *\n   * **Korean**: 기본 이동 거리 (Base Movement Distance)\n   *\n   * Movement distances by technique category:\n   * - Kicks: 0.8-1.2m (leg extension, longest reach)\n   * - Punches: 0.3-0.5m (arm extension, body lunge)\n   * - Elbows/Knees: 0.2-0.3m (close range techniques)\n   * - Spinning: 0.5-0.8m (rotation carries momentum)\n   *\n   * @param animationType - Type of attack animation\n   * @returns Base movement distance in meters\n   *\n   * @private\n   * @korean 기본이동거리\n   */\n  private getBaseMovementDistance(animationType: AnimationType): number {\n    // Kicks - highest forward movement (leg extension)\n    if (\n      animationType === AnimationType.ROUNDHOUSE_KICK ||\n      animationType === AnimationType.SIDE_KICK ||\n      animationType === AnimationType.BACK_KICK\n    ) {\n      return 1.0; // 1.0m forward lunge\n    }\n\n    if (\n      animationType === AnimationType.FRONT_KICK ||\n      animationType === AnimationType.PUSH_KICK\n    ) {\n      return 0.8; // 0.8m forward lunge\n    }\n\n    if (\n      animationType === AnimationType.AXE_KICK ||\n      animationType === AnimationType.CRESCENT_KICK ||\n      animationType === AnimationType.LOW_KICK\n    ) {\n      return 0.9; // 0.9m forward lunge\n    }\n\n    // Spinning kicks - momentum carries body forward\n    if (\n      animationType === AnimationType.SPINNING_HOOK ||\n      animationType === AnimationType.SPINNING_HEEL_KICK ||\n      animationType === AnimationType.TORNADO_KICK\n    ) {\n      return 0.8; // 0.8m with rotation\n    }\n\n    // Jumping/flying kicks - aerial momentum\n    if (\n      animationType === AnimationType.FLYING_KICK ||\n      animationType === AnimationType.JUMPING_KICK\n    ) {\n      return 1.2; // 1.2m maximum extension\n    }\n\n    // Punches - moderate forward movement (arm + body lunge)\n    if (\n      animationType === AnimationType.CROSS ||\n      animationType === AnimationType.OVERHAND ||\n      animationType === AnimationType.HOOK\n    ) {\n      return 0.5; // 0.5m forward lunge\n    }\n\n    if (\n      animationType === AnimationType.JAB ||\n      animationType === AnimationType.BACKFIST\n    ) {\n      return 0.3; // 0.3m forward lunge\n    }\n\n    if (\n      animationType === AnimationType.UPPERCUT ||\n      animationType === AnimationType.HAMMER_FIST ||\n      animationType === AnimationType.PALM_STRIKE\n    ) {\n      return 0.4; // 0.4m forward lunge\n    }\n\n    // Elbow/Knee - minimal movement (close range)\n    if (\n      animationType === AnimationType.ELBOW_STRIKE ||\n      animationType === AnimationType.KNEE_STRIKE ||\n      animationType === AnimationType.KNEE_KICK ||\n      animationType === AnimationType.ELBOW_UPPERCUT ||\n      animationType === AnimationType.FLYING_KNEE ||\n      animationType === AnimationType.CLINCH_KNEE ||\n      animationType === AnimationType.SPINNING_ELBOW ||\n      animationType === AnimationType.TEMPLE_ELBOW ||\n      animationType === AnimationType.SPINNING_BACK_ELBOW ||\n      animationType === AnimationType.SPINAL_ELBOW ||\n      animationType === AnimationType.BRACHIAL_ELBOW ||\n      animationType === AnimationType.KIDNEY_KNEE ||\n      animationType === AnimationType.FEMORAL_KNEE\n    ) {\n      return 0.2; // 0.2m forward lunge\n    }\n\n    // Specialized jab variants - similar to jab (quick extension)\n    if (\n      animationType === AnimationType.SPEAR_HAND_STRIKE ||\n      animationType === AnimationType.NERVE_STRIKE ||\n      animationType === AnimationType.PRESSURE_POINT_STRIKE ||\n      animationType === AnimationType.LIGHTNING_STRIKE ||\n      animationType === AnimationType.RAPID_BARRAGE ||\n      animationType === AnimationType.RHYTHMIC_STRIKES ||\n      animationType === AnimationType.NERVE_PARALYSIS ||\n      animationType === AnimationType.THROAT_STRIKE ||\n      animationType === AnimationType.EYE_GOUGE\n    ) {\n      return 0.3; // 0.3m forward lunge (jab-like)\n    }\n\n    // Specialized cross variants - similar to cross (body weight transfer)\n    if (\n      animationType === AnimationType.HEAVEN_STRIKE ||\n      animationType === AnimationType.FLOWING_CROSS\n    ) {\n      return 0.5; // 0.5m forward lunge (cross-like)\n    }\n\n    // Specialized palm strikes - similar to palm strike\n    if (\n      animationType === AnimationType.SOLAR_PLEXUS_STRIKE ||\n      animationType === AnimationType.FLOWING_PUSH ||\n      animationType === AnimationType.LIVER_DISRUPTION ||\n      animationType === AnimationType.EAR_STRIKE\n    ) {\n      return 0.4; // 0.4m forward lunge (palm-like)\n    }\n\n    // Grappling - minimal forward movement (rotation/off-balancing in place)\n    if (\n      animationType === AnimationType.THROW ||\n      animationType === AnimationType.JOINT_LOCK ||\n      animationType === AnimationType.TAKEDOWN ||\n      animationType === AnimationType.SWEEP ||\n      animationType === AnimationType.CLINCH ||\n      animationType === AnimationType.GRAPPLE ||\n      animationType === AnimationType.SLAM ||\n      animationType === AnimationType.WRIST_LOCK ||\n      animationType === AnimationType.ARM_BAR ||\n      animationType === AnimationType.SHOULDER_LOCK ||\n      animationType === AnimationType.HIP_THROW ||\n      animationType === AnimationType.LEG_REAP ||\n      animationType === AnimationType.SMALL_CIRCLE_LOCK ||\n      animationType === AnimationType.FINGER_LOCK ||\n      animationType === AnimationType.ELBOW_LOCK ||\n      animationType === AnimationType.SHOULDER_MANIPULATION ||\n      animationType === AnimationType.MOUNTAIN_LOCK ||\n      animationType === AnimationType.EARTH_EMBRACE ||\n      animationType === AnimationType.CAROTID_CHOKE\n    ) {\n      return 0.05; // 0.05m forward movement for grappling entries\n    }\n\n    // Default - conservative minimal movement for any unmapped types\n    // Additional AnimationType values can be grouped with the closest category above\n    // to fine-tune their forward displacement without changing overall behavior\n    return 0.2;\n  }\n\n  /**\n   * Gets stance movement modifier for attack lunge.\n   *\n   * **Korean**: 자세 이동 배율 (Stance Movement Modifier)\n   *\n   * Trigram stance movement modifiers based on combat philosophy:\n   * - ☰ 건 (Geon/Heaven): +30% movement (aggressive, drives forward with pure yang)\n   * - ☳ 진 (Jin/Thunder): +20% movement (explosive power, shocking force)\n   * - ☴ 손 (Son/Wind): +15% movement (continuous flow, mobile)\n   * - ☲ 리 (Li/Fire): +10% movement (precision strikes, controlled aggression)\n   * - ☱ 태 (Tae/Lake): 0% (neutral, fluid and adaptive)\n   * - ☵ 감 (Gam/Water): 0% (neutral, flowing and flexible)\n   * - ☷ 곤 (Gon/Earth): -10% movement (grounded, stable techniques)\n   * - ☶ 간 (Gan/Mountain): -20% movement (defensive mastery, minimal advance)\n   *\n   * @param stance - Current trigram stance\n   * @returns Movement multiplier (0.8 to 1.3)\n   *\n   * @private\n   * @korean 자세이동배율\n   */\n  private getStanceMovementModifier(stance: TrigramStance): number {\n    const modifiers: Record<TrigramStance, number> = {\n      [TrigramStance.GEON]: 1.3, // Heaven: +30% aggressive forward pressure (pure yang drives forward)\n      [TrigramStance.JIN]: 1.2, // Thunder: +20% explosive movement\n      [TrigramStance.SON]: 1.15, // Wind: +15% flowing movement\n      [TrigramStance.LI]: 1.1, // Fire: +10% precision strikes with controlled forward movement\n      [TrigramStance.TAE]: 1.0, // Lake: neutral movement\n      [TrigramStance.GAM]: 1.0, // Water: neutral movement\n      [TrigramStance.GON]: 0.9, // Earth: -10% grounded movement\n      [TrigramStance.GAN]: 0.8, // Mountain: -20% defensive movement\n    };\n    return modifiers[stance];\n  }\n\n  /**\n   * Applies attack movement force to attacker position over time.\n   *\n   * **Korean**: 공격 이동 적용 (Apply Attack Movement)\n   *\n   * Uses smooth ease-out cubic curve for realistic lunge feel:\n   * - Fast initial forward movement (attack commitment)\n   * - Gradual deceleration at peak extension\n   * - Smooth return during recovery phase\n   *\n   * @param basePosition - Original stance position (does not change during attack)\n   * @param result - Attack movement result with displacement\n   * @param elapsedTime - Time elapsed since attack started\n   * @param isRecoveryPhase - Whether in recovery (return) phase\n   * @returns New position with attack displacement applied\n   *\n   * @example\n   * ```typescript\n   * // In animation update loop (60fps)\n   * const basePos = new THREE.Vector3(0, 0, 0); // Original stance position\n   * \n   * if (elapsedTime < result.lungeDuration) {\n   *   // Lunge forward phase\n   *   const newPosition = physics.applyAttackMovement(\n   *     basePos,\n   *     result,\n   *     elapsedTime,\n   *     false\n   *   );\n   * } else if (elapsedTime < result.totalDuration) {\n   *   // Recovery return phase\n   *   const newPosition = physics.applyAttackMovement(\n   *     basePos,\n   *     result,\n   *     elapsedTime,\n   *     true\n   *   );\n   * }\n   * ```\n   *\n   * @korean 공격이동적용\n   */\n  applyAttackMovement(\n    basePosition: THREE.Vector3,\n    result: AttackMovementResult,\n    elapsedTime: number,\n    isRecoveryPhase: boolean\n  ): THREE.Vector3 {\n    let progress: number;\n\n    if (!isRecoveryPhase) {\n      // Lunge forward phase\n      progress = Math.min(1.0, elapsedTime / result.lungeDuration);\n\n      // Smooth forward lunge curve (ease-out cubic)\n      // Fast initial commitment, gradual deceleration at peak\n      const easedProgress = 1 - Math.pow(1 - progress, 3);\n\n      // Calculate position along forward path\n      const currentDisplacement = result.displacement\n        .clone()\n        .multiplyScalar(easedProgress);\n\n      return basePosition.clone().add(currentDisplacement);\n    } else {\n      // Recovery return phase\n      const recoveryTime = elapsedTime - result.lungeDuration;\n      progress = Math.min(1.0, recoveryTime / result.recoveryDuration);\n\n      // Smooth return curve (ease-in cubic)\n      // Gradual start, faster finish back to stance\n      const easedProgress = Math.pow(progress, 3);\n\n      // Calculate return position (from peak back to origin)\n      const returnDisplacement = result.displacement\n        .clone()\n        .multiplyScalar(1.0 - easedProgress);\n\n      return basePosition.clone().add(returnDisplacement);\n    }\n  }\n\n  /**\n   * Checks if attacker is currently in lunge phase.\n   *\n   * **Korean**: 돌진 상태 확인 (Check Lunge State)\n   *\n   * @param elapsedTime - Time elapsed since attack started\n   * @param lungeDuration - Total lunge phase duration\n   * @returns True if in forward lunge phase\n   *\n   * @korean 돌진상태확인\n   */\n  isInLungePhase(elapsedTime: number, lungeDuration: number): boolean {\n    return elapsedTime < lungeDuration;\n  }\n\n  /**\n   * Checks if attacker is in recovery return phase.\n   *\n   * **Korean**: 회복 상태 확인 (Check Recovery State)\n   *\n   * @param elapsedTime - Time elapsed since attack started\n   * @param result - Attack movement result with timing\n   * @returns True if in recovery return phase\n   *\n   * @korean 회복상태확인\n   */\n  isInRecoveryPhase(\n    elapsedTime: number,\n    result: AttackMovementResult\n  ): boolean {\n    return (\n      elapsedTime >= result.lungeDuration &&\n      elapsedTime < result.totalDuration\n    );\n  }\n\n  /**\n   * Gets bilingual Korean-English name for lunge phase.\n   *\n   * **Korean**: 돌진 단계 이름 (Lunge Phase Name)\n   *\n   * @returns Korean and English phase names\n   *\n   * @korean 돌진단계이름\n   */\n  getLungePhaseName(): { korean: string; english: string } {\n    return {\n      korean: \"돌진\",\n      english: \"Lunge\",\n    };\n  }\n\n  /**\n   * Gets bilingual Korean-English name for recovery phase.\n   *\n   * **Korean**: 복귀 단계 이름 (Recovery Phase Name)\n   *\n   * @returns Korean and English phase names\n   *\n   * @korean 복귀단계이름\n   */\n  getRecoveryPhaseName(): { korean: string; english: string } {\n    return {\n      korean: \"복귀\",\n      english: \"Recovery\",\n    };\n  }\n}\n\nexport default AttackMovementPhysics;\n"],"mappings":"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"}

package/lib/systems/physics/CollisionDetection.d.ts

@@ -57,7 +57,6 @@ import type { VitalPoint } from "../vitalpoint/types";
  * Provides efficient collision detection for combat using bounding boxes and raycasting.
  * Optimized for 60fps performance with multiple simultaneous collision checks.
  *
- * @public
  * @category Combat Systems
  * @korean 충돌감지엔진
  */
@@ -82,7 +81,6 @@ export declare class CollisionDetection {
      * Disposes of cached geometries and releases memory to prevent leaks.
      * Should be called when the CollisionDetection instance is no longer needed.
      *
-     * @public
      * @korean 자원정리
      */
     dispose(): void;
@@ -115,7 +113,6 @@ export declare class CollisionDetection {
      * );
      * ```
      *
-     * @public
      * @korean 공격타격확인
      */
     checkAttackHit(attackerPosition: Position3D, defenderPosition: Position3D, technique: {
@@ -295,7 +292,6 @@ export declare class CollisionDetection {
      * @param region - Anatomical region
      * @returns Bounding box or undefined if not found
      *
-     * @public
      * @korean 경계상자조회
      */
     getBoundingBox(region: AnatomicalRegionPhysics): BoundingBox | undefined;
@@ -304,7 +300,6 @@ export declare class CollisionDetection {
      *
      * @returns Map of all bounding boxes by region
      *
-     * @public
      * @korean 모든경계상자조회
      */
     getAllBoundingBoxes(): ReadonlyMap<AnatomicalRegionPhysics, BoundingBox>;
@@ -314,7 +309,6 @@ export declare class CollisionDetection {
      * @param region - Anatomical region
      * @returns Array of vital points in that region
      *
-     * @public
      * @korean 영역별급소조회
      */
     getVitalPointsInRegion(region: AnatomicalRegionPhysics): readonly VitalPoint[];

package/lib/systems/physics/CollisionDetection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CollisionDetection.d.ts","sourceRoot":"","sources":["../../../src/systems/physics/CollisionDetection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAGH,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,KAAK,EACV,uBAAuB,EACvB,WAAW,EACX,eAAe,EACf,UAAU,EAGX,MAAM,qBAAqB,CAAC;AAM7B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAKtD;;;;;;;;;;;GAWG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,aAAa,CAClB;IACZ,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0C;IACpE,OAAO,CAAC,mBAAmB,CACf;IAGZ,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgD;IAG9E,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAmB;IAEpD;;;;;OAKG;;IAQH;;;;;;;;;;OAUG;IACI,OAAO,IAAI,IAAI;IAQtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,cAAc,CACZ,gBAAgB,EAAE,UAAU,EAC5B,gBAAgB,EAAE,UAAU,EAE5B,SAAS,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,EAChD,cAAc,EAAE,aAAa,EAC7B,YAAY,EAAE,uBAAuB,GACpC,eAAe;IA4FlB;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,oBAAoB;IA0B5B;;;;;;;;;;;;;;;;;;OAkBG;IACH,OAAO,CAAC,kBAAkB;IAwD1B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,oBAAoB;IAoB5B;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,kBAAkB;IA6B1B;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,oBAAoB;IAkB5B;;;;;;;;;OASG;IACH,OAAO,CAAC,mBAAmB;IAO3B;;;;;;;;;OASG;IACH,OAAO,CAAC,iBAAiB;IAQzB;;;;;;;;OAQG;IACH,OAAO,CAAC,iBAAiB;IAYzB;;;;;;;;OAQG;IACH,OAAO,CAAC,kBAAkB;IAa1B;;;;;;;;OAQG;IACH,OAAO,CAAC,uBAAuB;IA8D/B;;;;;;;;;OASG;IACH,OAAO,CAAC,uBAAuB;IAS/B;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,OAAO,CAAC,2BAA2B;IAmDnC;;;;;;;;OAQG;IACH,cAAc,CAAC,MAAM,EAAE,uBAAuB,GAAG,WAAW,GAAG,SAAS;IAIxE;;;;;;;OAOG;IACH,mBAAmB,IAAI,WAAW,CAAC,uBAAuB,EAAE,WAAW,CAAC;IAIxE;;;;;;;;OAQG;IACH,sBAAsB,CACpB,MAAM,EAAE,uBAAuB,GAC9B,SAAS,UAAU,EAAE;CAGzB;AAED,eAAe,kBAAkB,CAAC"}
+{"version":3,"file":"CollisionDetection.d.ts","sourceRoot":"","sources":["../../../src/systems/physics/CollisionDetection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAGH,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,KAAK,EACV,uBAAuB,EACvB,WAAW,EACX,eAAe,EACf,UAAU,EAGX,MAAM,qBAAqB,CAAC;AAM7B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAKtD;;;;;;;;;;GAUG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,aAAa,CAClB;IACZ,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0C;IACpE,OAAO,CAAC,mBAAmB,CACf;IAGZ,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgD;IAG9E,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAmB;IAEpD;;;;;OAKG;;IAQH;;;;;;;;;OASG;IACI,OAAO,IAAI,IAAI;IAQtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,cAAc,CACZ,gBAAgB,EAAE,UAAU,EAC5B,gBAAgB,EAAE,UAAU,EAE5B,SAAS,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,EAChD,cAAc,EAAE,aAAa,EAC7B,YAAY,EAAE,uBAAuB,GACpC,eAAe;IA4FlB;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,oBAAoB;IA0B5B;;;;;;;;;;;;;;;;;;OAkBG;IACH,OAAO,CAAC,kBAAkB;IAwD1B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,oBAAoB;IAoB5B;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,kBAAkB;IA6B1B;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,oBAAoB;IAkB5B;;;;;;;;;OASG;IACH,OAAO,CAAC,mBAAmB;IAO3B;;;;;;;;;OASG;IACH,OAAO,CAAC,iBAAiB;IAQzB;;;;;;;;OAQG;IACH,OAAO,CAAC,iBAAiB;IAYzB;;;;;;;;OAQG;IACH,OAAO,CAAC,kBAAkB;IAa1B;;;;;;;;OAQG;IACH,OAAO,CAAC,uBAAuB;IA8D/B;;;;;;;;;OASG;IACH,OAAO,CAAC,uBAAuB;IAS/B;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,OAAO,CAAC,2BAA2B;IAmDnC;;;;;;;OAOG;IACH,cAAc,CAAC,MAAM,EAAE,uBAAuB,GAAG,WAAW,GAAG,SAAS;IAIxE;;;;;;OAMG;IACH,mBAAmB,IAAI,WAAW,CAAC,uBAAuB,EAAE,WAAW,CAAC;IAIxE;;;;;;;OAOG;IACH,sBAAsB,CACpB,MAAM,EAAE,uBAAuB,GAC9B,SAAS,UAAU,EAAE;CAGzB;AAED,eAAe,kBAAkB,CAAC"}

package/lib/systems/physics/CollisionDetection.js

@@ -60,7 +60,6 @@ import * as THREE from "three";
 * Provides efficient collision detection for combat using bounding boxes and raycasting.
 * Optimized for 60fps performance with multiple simultaneous collision checks.
 *
-* @public
 * @category Combat Systems
 * @korean 충돌감지엔진
 */
@@ -90,7 +89,6 @@ var CollisionDetection = class {
 	* Disposes of cached geometries and releases memory to prevent leaks.
 	* Should be called when the CollisionDetection instance is no longer needed.
 	*
-	* @public
 	* @korean 자원정리
 	*/
 	dispose() {
@@ -126,7 +124,6 @@ var CollisionDetection = class {
 	* );
 	* ```
 	*
-	* @public
 	* @korean 공격타격확인
 	*/
 	checkAttackHit(attackerPosition, defenderPosition, technique, attackerStance, targetRegion) {
@@ -507,7 +504,6 @@ var CollisionDetection = class {
 	* @param region - Anatomical region
 	* @returns Bounding box or undefined if not found
 	*
-	* @public
 	* @korean 경계상자조회
 	*/
 	getBoundingBox(region) {
@@ -518,7 +514,6 @@ var CollisionDetection = class {
 	*
 	* @returns Map of all bounding boxes by region
 	*
-	* @public
 	* @korean 모든경계상자조회
 	*/
 	getAllBoundingBoxes() {
@@ -530,7 +525,6 @@ var CollisionDetection = class {
 	* @param region - Anatomical region
 	* @returns Array of vital points in that region
 	*
-	* @public
 	* @korean 영역별급소조회
 	*/
 	getVitalPointsInRegion(region) {