blacktrigram 0.7.2

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

@@ -0,0 +1,367 @@
+/**
+ * Knockback Physics System for realistic force-based displacement.
+ *
+ * **Korean**: 밀침 물리 시스템 (Knockback Physics System)
+ *
+ * Implements realistic combat knockback mechanics that calculate force-based
+ * displacement when players are hit. The system integrates with BalanceSystem
+ * for authentic stumbling/falling reactions.
+ *
+ * ## Knockback Mechanics
+ *
+ * Knockback force is determined by:
+ * - Attack damage and technique type
+ * - Impact angle and direction
+ * - Current balance state
+ * - Stance resistance modifiers (8 trigram stances)
+ *
+ * ## Balance Integration
+ *
+ * - High balance (>70%): Reduced knockback by 30%
+ * - Medium balance (40-70%): Normal knockback
+ * - Low balance (<40%): Increased knockback by 50%, stumbling
+ * - Critical balance (<20%): Guaranteed fall, 2s recovery
+ *
+ * ## Performance
+ *
+ * Optimized for 60fps with efficient vector calculations and smooth
+ * easing curves for realistic knockback feel.
+ *
+ * @module systems/physics/KnockbackPhysics
+ * @category Physics System
+ * @korean 밀침물리
+ */
+import * as THREE from 'three';
+import { TrigramStance } from '../../types/common';
+/**
+ * Balance state information for knockback calculations.
+ *
+ * **Korean**: 균형 상태 (Balance State)
+ *
+ * @public
+ * @korean 균형상태
+ */
+export interface BalanceState {
+    /** Current balance value (0-100) */
+    readonly current: number;
+    /** Maximum balance value (typically 100) */
+    readonly max: number;
+}
+/**
+ * Configuration for knockback force calculation.
+ *
+ * **Korean**: 밀침 설정 (Knockback Configuration)
+ *
+ * @public
+ * @korean 밀침설정
+ */
+export interface KnockbackConfig {
+    /** Force magnitude in Newtons */
+    readonly force: number;
+    /** Normalized attack direction vector (attacker → defender) */
+    readonly direction: THREE.Vector3;
+    /** Duration of knockback effect in seconds */
+    readonly duration: number;
+    /** Current balance state */
+    readonly balanceState: BalanceState;
+    /** Current trigram stance */
+    readonly currentStance: TrigramStance;
+}
+/**
+ * Result of knockback calculation.
+ *
+ * **Korean**: 밀침 결과 (Knockback Result)
+ *
+ * Contains displacement vector, animation timing, and fall determination.
+ *
+ * @public
+ * @korean 밀침결과
+ */
+export interface KnockbackResult {
+    /** Total knockback displacement vector in world space */
+    readonly displacement: THREE.Vector3;
+    /** Duration of knockback animation in seconds */
+    readonly duration: number;
+    /** Vulnerable state duration after knockback ends in seconds */
+    readonly recoveryWindow: number;
+    /** Whether fall animation should trigger */
+    readonly shouldFall: boolean;
+}
+/**
+ * Knockback Physics Engine.
+ *
+ * **Korean**: 밀침 물리 엔진
+ *
+ * Calculates realistic knockback displacement based on attack force,
+ * stance resistance, and balance state. Integrates with BalanceSystem
+ * for stumbling and falling mechanics.
+ *
+ * @example
+ * ```typescript
+ * const physics = new KnockbackPhysics();
+ *
+ * // Calculate knockback from heavy strike
+ * const config: KnockbackConfig = {
+ *   force: 800, // 80 damage
+ *   direction: new THREE.Vector3(1, 0, 0).normalize(),
+ *   duration: 0.8,
+ *   balanceState: { current: 35, max: 100 }, // Low balance
+ *   currentStance: TrigramStance.LI, // Fire stance (low resistance)
+ * };
+ *
+ * const result = physics.calculateKnockback(config, 80);
+ * // Result: 2.5m base * 1.3 (Fire penalty) * 1.5 (low balance) = ~4.9m
+ * // shouldFall: false (balance > 20%)
+ * // recoveryWindow: 1.05s (0.7s * 1.5 for low balance)
+ * ```
+ *
+ * @public
+ * @korean 밀침물리
+ */
+export declare class KnockbackPhysics {
+    /**
+     * Calculates knockback displacement and effects.
+     *
+     * **Korean**: 밀침 계산 (Calculate Knockback)
+     *
+     * Determines knockback distance, duration, and fall state based on:
+     * 1. Base knockback from damage amount
+     * 2. Stance resistance modifier (8 trigram effects)
+     * 3. Balance state modifier (stumbling/falling)
+     * 4. Recovery window (vulnerable state after)
+     *
+     * @param config - Knockback configuration with force and state
+     * @param attackDamage - Damage dealt by attack (0-100+)
+     * @returns Knockback result with displacement and timing
+     *
+     * @example
+     * ```typescript
+     * // Light strike on stable player
+     * const light = physics.calculateKnockback({
+     *   force: 300,
+     *   direction: attackVector,
+     *   duration: 0.3,
+     *   balanceState: { current: 85, max: 100 },
+     *   currentStance: TrigramStance.GEON,
+     * }, 30);
+     * // Result: ~0.3m knockback (0.5m * 0.9 Geon * 0.7 high balance)
+     *
+     * // Critical strike on low-balance player
+     * const critical = physics.calculateKnockback({
+     *   force: 1200,
+     *   direction: attackVector,
+     *   duration: 1.2,
+     *   balanceState: { current: 15, max: 100 },
+     *   currentStance: TrigramStance.SON,
+     * }, 110);
+     * // Result: ~9.6m knockback, shouldFall: true, 3.0s recovery
+     * ```
+     *
+     * @public
+     * @korean 밀침계산
+     */
+    calculateKnockback(config: KnockbackConfig, attackDamage: number): KnockbackResult;
+    /**
+     * Gets base knockback distance from damage amount.
+     *
+     * **Korean**: 기본 밀침 거리 (Base Knockback Distance)
+     *
+     * Damage thresholds:
+     * - Light (20-40): 0.5m knockback, 0.3s duration
+     * - Medium (40-70): 1.2m knockback, 0.5s duration
+     * - Heavy (70-100): 2.5m knockback, 0.8s duration
+     * - Critical (100+): 4.0m knockback, 1.2s duration + fall
+     *
+     * @param damage - Attack damage amount
+     * @returns Base knockback distance in meters
+     *
+     * @private
+     * @korean 기본밀침거리
+     */
+    private getBaseKnockbackDistance;
+    /**
+     * Gets stance resistance modifier for knockback.
+     *
+     * **Korean**: 자세 저항 배율 (Stance Resistance Modifier)
+     *
+     * Trigram stance resistance modifiers:
+     * - ☶ 간 (Gan/Mountain): +40% resistance (defensive mastery)
+     * - ☷ 곤 (Gon/Earth): +30% resistance (grounded techniques)
+     * - ☰ 건 (Geon/Heaven): +10% resistance (balanced force)
+     * - ☵ 감 (Gam/Water): 0% (neutral, adaptive)
+     * - ☱ 태 (Tae/Lake): 0% (neutral, fluid)
+     * - ☳ 진 (Jin/Thunder): -10% resistance (explosive power)
+     * - ☴ 손 (Son/Wind): -20% resistance (fluid, mobile)
+     * - ☲ 리 (Li/Fire): -30% resistance (aggressive, exposed)
+     *
+     * @param stance - Current trigram stance
+     * @returns Resistance modifier (-0.3 to +0.4)
+     *
+     * @private
+     * @korean 자세저항배율
+     */
+    private getStanceResistanceModifier;
+    /**
+     * Gets balance modifier for knockback distance.
+     *
+     * **Korean**: 균형 배율 (Balance Modifier)
+     *
+     * Balance thresholds:
+     * - High balance (>70%): 0.70x (30% reduction)
+     * - Medium balance (40-70%): 1.00x (normal)
+     * - Low balance (20-40%): 1.50x (50% increase, stumbling)
+     * - Critical balance (<20%): 2.00x (100% increase, falling)
+     *
+     * @param balanceState - Current balance state
+     * @returns Balance multiplier (0.7 to 2.0)
+     *
+     * @private
+     * @korean 균형배율
+     */
+    private getBalanceModifier;
+    /**
+     * Calculates knockback animation duration.
+     *
+     * **Korean**: 밀침 지속시간 계산 (Calculate Knockback Duration)
+     *
+     * Linear relationship between distance and duration:
+     * - 0.5m = 0.3s (light)
+     * - 1.2m = 0.48s
+     * - 2.5m = 0.86s
+     * - 4.0m = 1.2s (critical)
+     *
+     * @param distance - Knockback distance in meters
+     * @returns Duration in seconds
+     *
+     * @private
+     * @korean 밀침지속시간계산
+     */
+    private calculateKnockbackDuration;
+    /**
+     * Calculates recovery window (vulnerability duration).
+     *
+     * **Korean**: 회복 대기시간 계산 (Calculate Recovery Window)
+     *
+     * Recovery windows by damage:
+     * - Light (<40): 0.2s vulnerability
+     * - Medium (40-70): 0.4s vulnerability
+     * - Heavy (70-100): 0.7s vulnerability
+     * - Critical (100+): 1.5s vulnerability + grounded
+     *
+     * Low balance increases vulnerability by 50%.
+     *
+     * @param damage - Attack damage amount
+     * @param balanceState - Current balance state
+     * @returns Vulnerability duration in seconds
+     *
+     * @private
+     * @korean 회복대기시간계산
+     */
+    private calculateRecoveryWindow;
+    /**
+     * Applies knockback force to player position over time.
+     *
+     * **Korean**: 밀침 힘 적용 (Apply Knockback Force)
+     *
+     * Uses smooth ease-out cubic curve for realistic knockback feel:
+     * - Fast initial displacement (impact)
+     * - Gradual deceleration (friction/resistance)
+     * - Smooth stop at final position
+     *
+     * @param playerPosition - Current player position
+     * @param result - Knockback result with displacement
+     * @param deltaTime - Time elapsed since knockback started
+     * @param progress - Knockback progress (0 to 1)
+     * @returns New player position
+     *
+     * @example
+     * ```typescript
+     * // In game loop (60fps)
+     * const newPosition = physics.applyKnockbackForce(
+     *   playerPosition,
+     *   knockbackResult,
+     *   deltaTime,
+     *   elapsedTime / knockbackResult.duration
+     * );
+     *
+     * // Progress 0.0: At original position
+     * // Progress 0.5: ~88% of total displacement (ease-out)
+     * // Progress 1.0: At final position
+     * ```
+     *
+     * @public
+     * @korean 밀침힘적용
+     */
+    applyKnockbackForce(playerPosition: THREE.Vector3, result: KnockbackResult, _deltaTime: number, progress: number): THREE.Vector3;
+    /**
+     * Checks if player is currently in knockback state.
+     *
+     * **Korean**: 밀침 상태 확인 (Check Knockback State)
+     *
+     * @param elapsedTime - Time elapsed since knockback started
+     * @param duration - Total knockback duration
+     * @returns True if still in knockback animation
+     *
+     * @public
+     * @korean 밀침상태확인
+     */
+    isInKnockback(elapsedTime: number, duration: number): boolean;
+    /**
+     * Checks if player is in recovery window (vulnerable state).
+     *
+     * **Korean**: 회복 대기 확인 (Check Recovery Window)
+     *
+     * @param elapsedTime - Time elapsed since knockback ended
+     * @param recoveryWindow - Total recovery window duration
+     * @returns True if in vulnerable recovery state
+     *
+     * @public
+     * @korean 회복대기확인
+     */
+    isInRecoveryWindow(elapsedTime: number, recoveryWindow: number): boolean;
+    /**
+     * Gets bilingual Korean-English name for knockback state.
+     *
+     * **Korean**: 밀침 상태 이름 (Knockback State Name)
+     *
+     * @param shouldFall - Whether knockback causes fall
+     * @returns Korean and English state names
+     *
+     * @public
+     * @korean 밀침상태이름
+     */
+    static getKnockbackStateName(shouldFall: boolean): {
+        korean: string;
+        english: string;
+    };
+    /**
+     * Gets bilingual Korean-English name for recovery state.
+     *
+     * **Korean**: 회복 상태 이름 (Recovery State Name)
+     *
+     * @returns Korean and English state names
+     *
+     * @public
+     * @korean 회복상태이름
+     */
+    getRecoveryStateName(): {
+        korean: string;
+        english: string;
+    };
+    /**
+     * Gets bilingual Korean-English name for stumbling state.
+     *
+     * **Korean**: 휘청거림 상태 이름 (Stumbling State Name)
+     *
+     * @returns Korean and English state names
+     *
+     * @public
+     * @korean 휘청거림상태이름
+     */
+    getStumblingStateName(): {
+        korean: string;
+        english: string;
+    };
+}
+export default KnockbackPhysics;
+//# sourceMappingURL=KnockbackPhysics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"KnockbackPhysics.d.ts","sourceRoot":"","sources":["../../../src/systems/physics/KnockbackPhysics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAE/C;;;;;;;GAOG;AACH,MAAM,WAAW,YAAY;IAC3B,oCAAoC;IACpC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,4CAA4C;IAC5C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC9B,iCAAiC;IACjC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,+DAA+D;IAC/D,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC,OAAO,CAAC;IAClC,8CAA8C;IAC9C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,4BAA4B;IAC5B,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC;IACpC,6BAA6B;IAC7B,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;CACvC;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,eAAe;IAC9B,yDAAyD;IACzD,QAAQ,CAAC,YAAY,EAAE,KAAK,CAAC,OAAO,CAAC;IACrC,iDAAiD;IACjD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,gEAAgE;IAChE,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,4CAA4C;IAC5C,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;CAC9B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBAAa,gBAAgB;IAC3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;IACH,kBAAkB,CAAC,MAAM,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,GAAG,eAAe;IAgClF;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,wBAAwB;IAOhC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,OAAO,CAAC,2BAA2B;IAcnC;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,kBAAkB;IAS1B;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,0BAA0B;IAKlC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAO,CAAC,uBAAuB;IAW/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,mBAAmB,CACjB,cAAc,EAAE,KAAK,CAAC,OAAO,EAC7B,MAAM,EAAE,eAAe,EACvB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GACf,KAAK,CAAC,OAAO;IAchB;;;;;;;;;;;OAWG;IACH,aAAa,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO;IAI7D;;;;;;;;;;;OAWG;IACH,kBAAkB,CAAC,WAAW,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO;IAIxE;;;;;;;;;;OAUG;IACH,MAAM,CAAC,qBAAqB,CAAC,UAAU,EAAE,OAAO,GAAG;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;IActF;;;;;;;;;OASG;IACH,oBAAoB,IAAI;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;IAO3D;;;;;;;;;OASG;IACH,qBAAqB,IAAI;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;CAM7D;AAED,eAAe,gBAAgB,CAAC"}

package/lib/systems/physics/KnockbackPhysics.js

@@ -0,0 +1,338 @@
+import { TrigramStance } from "../../types/common.js";
+//#region src/systems/physics/KnockbackPhysics.ts
+/**
+* Knockback Physics Engine.
+* 
+* **Korean**: 밀침 물리 엔진
+* 
+* Calculates realistic knockback displacement based on attack force,
+* stance resistance, and balance state. Integrates with BalanceSystem
+* for stumbling and falling mechanics.
+* 
+* @example
+* ```typescript
+* const physics = new KnockbackPhysics();
+* 
+* // Calculate knockback from heavy strike
+* const config: KnockbackConfig = {
+*   force: 800, // 80 damage
+*   direction: new THREE.Vector3(1, 0, 0).normalize(),
+*   duration: 0.8,
+*   balanceState: { current: 35, max: 100 }, // Low balance
+*   currentStance: TrigramStance.LI, // Fire stance (low resistance)
+* };
+* 
+* const result = physics.calculateKnockback(config, 80);
+* // Result: 2.5m base * 1.3 (Fire penalty) * 1.5 (low balance) = ~4.9m
+* // shouldFall: false (balance > 20%)
+* // recoveryWindow: 1.05s (0.7s * 1.5 for low balance)
+* ```
+* 
+* @public
+* @korean 밀침물리
+*/
+var KnockbackPhysics = class {
+	/**
+	* Calculates knockback displacement and effects.
+	* 
+	* **Korean**: 밀침 계산 (Calculate Knockback)
+	* 
+	* Determines knockback distance, duration, and fall state based on:
+	* 1. Base knockback from damage amount
+	* 2. Stance resistance modifier (8 trigram effects)
+	* 3. Balance state modifier (stumbling/falling)
+	* 4. Recovery window (vulnerable state after)
+	* 
+	* @param config - Knockback configuration with force and state
+	* @param attackDamage - Damage dealt by attack (0-100+)
+	* @returns Knockback result with displacement and timing
+	* 
+	* @example
+	* ```typescript
+	* // Light strike on stable player
+	* const light = physics.calculateKnockback({
+	*   force: 300,
+	*   direction: attackVector,
+	*   duration: 0.3,
+	*   balanceState: { current: 85, max: 100 },
+	*   currentStance: TrigramStance.GEON,
+	* }, 30);
+	* // Result: ~0.3m knockback (0.5m * 0.9 Geon * 0.7 high balance)
+	* 
+	* // Critical strike on low-balance player
+	* const critical = physics.calculateKnockback({
+	*   force: 1200,
+	*   direction: attackVector,
+	*   duration: 1.2,
+	*   balanceState: { current: 15, max: 100 },
+	*   currentStance: TrigramStance.SON,
+	* }, 110);
+	* // Result: ~9.6m knockback, shouldFall: true, 3.0s recovery
+	* ```
+	* 
+	* @public
+	* @korean 밀침계산
+	*/
+	calculateKnockback(config, attackDamage) {
+		let baseDistance = this.getBaseKnockbackDistance(attackDamage);
+		const stanceResistance = this.getStanceResistanceModifier(config.currentStance);
+		baseDistance *= 1 - stanceResistance;
+		const balanceModifier = this.getBalanceModifier(config.balanceState);
+		const finalDistance = baseDistance * balanceModifier;
+		return {
+			displacement: config.direction.clone().multiplyScalar(finalDistance),
+			duration: this.calculateKnockbackDuration(finalDistance),
+			recoveryWindow: this.calculateRecoveryWindow(attackDamage, config.balanceState),
+			shouldFall: config.balanceState.current < 20
+		};
+	}
+	/**
+	* Gets base knockback distance from damage amount.
+	* 
+	* **Korean**: 기본 밀침 거리 (Base Knockback Distance)
+	* 
+	* Damage thresholds:
+	* - Light (20-40): 0.5m knockback, 0.3s duration
+	* - Medium (40-70): 1.2m knockback, 0.5s duration
+	* - Heavy (70-100): 2.5m knockback, 0.8s duration
+	* - Critical (100+): 4.0m knockback, 1.2s duration + fall
+	* 
+	* @param damage - Attack damage amount
+	* @returns Base knockback distance in meters
+	* 
+	* @private
+	* @korean 기본밀침거리
+	*/
+	getBaseKnockbackDistance(damage) {
+		if (damage < 40) return .5;
+		if (damage < 70) return 1.2;
+		if (damage < 100) return 2.5;
+		return 4;
+	}
+	/**
+	* Gets stance resistance modifier for knockback.
+	* 
+	* **Korean**: 자세 저항 배율 (Stance Resistance Modifier)
+	* 
+	* Trigram stance resistance modifiers:
+	* - ☶ 간 (Gan/Mountain): +40% resistance (defensive mastery)
+	* - ☷ 곤 (Gon/Earth): +30% resistance (grounded techniques)
+	* - ☰ 건 (Geon/Heaven): +10% resistance (balanced force)
+	* - ☵ 감 (Gam/Water): 0% (neutral, adaptive)
+	* - ☱ 태 (Tae/Lake): 0% (neutral, fluid)
+	* - ☳ 진 (Jin/Thunder): -10% resistance (explosive power)
+	* - ☴ 손 (Son/Wind): -20% resistance (fluid, mobile)
+	* - ☲ 리 (Li/Fire): -30% resistance (aggressive, exposed)
+	* 
+	* @param stance - Current trigram stance
+	* @returns Resistance modifier (-0.3 to +0.4)
+	* 
+	* @private
+	* @korean 자세저항배율
+	*/
+	getStanceResistanceModifier(stance) {
+		return {
+			[TrigramStance.GAN]: .4,
+			[TrigramStance.GON]: .3,
+			[TrigramStance.GEON]: .1,
+			[TrigramStance.GAM]: 0,
+			[TrigramStance.TAE]: 0,
+			[TrigramStance.JIN]: -.1,
+			[TrigramStance.SON]: -.2,
+			[TrigramStance.LI]: -.3
+		}[stance];
+	}
+	/**
+	* Gets balance modifier for knockback distance.
+	* 
+	* **Korean**: 균형 배율 (Balance Modifier)
+	* 
+	* Balance thresholds:
+	* - High balance (>70%): 0.70x (30% reduction)
+	* - Medium balance (40-70%): 1.00x (normal)
+	* - Low balance (20-40%): 1.50x (50% increase, stumbling)
+	* - Critical balance (<20%): 2.00x (100% increase, falling)
+	* 
+	* @param balanceState - Current balance state
+	* @returns Balance multiplier (0.7 to 2.0)
+	* 
+	* @private
+	* @korean 균형배율
+	*/
+	getBalanceModifier(balanceState) {
+		const balancePercent = balanceState.current / balanceState.max * 100;
+		if (balancePercent > 70) return .7;
+		if (balancePercent > 40) return 1;
+		if (balancePercent > 20) return 1.5;
+		return 2;
+	}
+	/**
+	* Calculates knockback animation duration.
+	* 
+	* **Korean**: 밀침 지속시간 계산 (Calculate Knockback Duration)
+	* 
+	* Linear relationship between distance and duration:
+	* - 0.5m = 0.3s (light)
+	* - 1.2m = 0.48s
+	* - 2.5m = 0.86s
+	* - 4.0m = 1.2s (critical)
+	* 
+	* @param distance - Knockback distance in meters
+	* @returns Duration in seconds
+	* 
+	* @private
+	* @korean 밀침지속시간계산
+	*/
+	calculateKnockbackDuration(distance) {
+		return .3 + distance / 4 * .9;
+	}
+	/**
+	* Calculates recovery window (vulnerability duration).
+	* 
+	* **Korean**: 회복 대기시간 계산 (Calculate Recovery Window)
+	* 
+	* Recovery windows by damage:
+	* - Light (<40): 0.2s vulnerability
+	* - Medium (40-70): 0.4s vulnerability
+	* - Heavy (70-100): 0.7s vulnerability
+	* - Critical (100+): 1.5s vulnerability + grounded
+	* 
+	* Low balance increases vulnerability by 50%.
+	* 
+	* @param damage - Attack damage amount
+	* @param balanceState - Current balance state
+	* @returns Vulnerability duration in seconds
+	* 
+	* @private
+	* @korean 회복대기시간계산
+	*/
+	calculateRecoveryWindow(damage, balanceState) {
+		return (damage < 40 ? .2 : damage < 70 ? .4 : damage < 100 ? .7 : 1.5) * (balanceState.current / balanceState.max * 100 < 40 ? 1.5 : 1);
+	}
+	/**
+	* Applies knockback force to player position over time.
+	* 
+	* **Korean**: 밀침 힘 적용 (Apply Knockback Force)
+	* 
+	* Uses smooth ease-out cubic curve for realistic knockback feel:
+	* - Fast initial displacement (impact)
+	* - Gradual deceleration (friction/resistance)
+	* - Smooth stop at final position
+	* 
+	* @param playerPosition - Current player position
+	* @param result - Knockback result with displacement
+	* @param deltaTime - Time elapsed since knockback started
+	* @param progress - Knockback progress (0 to 1)
+	* @returns New player position
+	* 
+	* @example
+	* ```typescript
+	* // In game loop (60fps)
+	* const newPosition = physics.applyKnockbackForce(
+	*   playerPosition,
+	*   knockbackResult,
+	*   deltaTime,
+	*   elapsedTime / knockbackResult.duration
+	* );
+	* 
+	* // Progress 0.0: At original position
+	* // Progress 0.5: ~88% of total displacement (ease-out)
+	* // Progress 1.0: At final position
+	* ```
+	* 
+	* @public
+	* @korean 밀침힘적용
+	*/
+	applyKnockbackForce(playerPosition, result, _deltaTime, progress) {
+		const easedProgress = 1 - Math.pow(1 - Math.max(0, Math.min(1, progress)), 3);
+		const currentDisplacement = result.displacement.clone().multiplyScalar(easedProgress);
+		return playerPosition.clone().add(currentDisplacement);
+	}
+	/**
+	* Checks if player is currently in knockback state.
+	* 
+	* **Korean**: 밀침 상태 확인 (Check Knockback State)
+	* 
+	* @param elapsedTime - Time elapsed since knockback started
+	* @param duration - Total knockback duration
+	* @returns True if still in knockback animation
+	* 
+	* @public
+	* @korean 밀침상태확인
+	*/
+	isInKnockback(elapsedTime, duration) {
+		return elapsedTime < duration;
+	}
+	/**
+	* Checks if player is in recovery window (vulnerable state).
+	* 
+	* **Korean**: 회복 대기 확인 (Check Recovery Window)
+	* 
+	* @param elapsedTime - Time elapsed since knockback ended
+	* @param recoveryWindow - Total recovery window duration
+	* @returns True if in vulnerable recovery state
+	* 
+	* @public
+	* @korean 회복대기확인
+	*/
+	isInRecoveryWindow(elapsedTime, recoveryWindow) {
+		return elapsedTime < recoveryWindow;
+	}
+	/**
+	* Gets bilingual Korean-English name for knockback state.
+	* 
+	* **Korean**: 밀침 상태 이름 (Knockback State Name)
+	* 
+	* @param shouldFall - Whether knockback causes fall
+	* @returns Korean and English state names
+	* 
+	* @public
+	* @korean 밀침상태이름
+	*/
+	static getKnockbackStateName(shouldFall) {
+		if (shouldFall) return {
+			korean: "넘어짐",
+			english: "Falling"
+		};
+		return {
+			korean: "밀침",
+			english: "Knockback"
+		};
+	}
+	/**
+	* Gets bilingual Korean-English name for recovery state.
+	* 
+	* **Korean**: 회복 상태 이름 (Recovery State Name)
+	* 
+	* @returns Korean and English state names
+	* 
+	* @public
+	* @korean 회복상태이름
+	*/
+	getRecoveryStateName() {
+		return {
+			korean: "회복",
+			english: "Recovery"
+		};
+	}
+	/**
+	* Gets bilingual Korean-English name for stumbling state.
+	* 
+	* **Korean**: 휘청거림 상태 이름 (Stumbling State Name)
+	* 
+	* @returns Korean and English state names
+	* 
+	* @public
+	* @korean 휘청거림상태이름
+	*/
+	getStumblingStateName() {
+		return {
+			korean: "휘청거림",
+			english: "Stumbling"
+		};
+	}
+};
+//#endregion
+export { KnockbackPhysics as default };
+
+//# sourceMappingURL=KnockbackPhysics.js.map