blacktrigram 0.7.2

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

@@ -0,0 +1,302 @@
+/**
+ * Speed Modifier System
+ *
+ * **Korean**: 속도 변경 시스템 (Speed Modifier System)
+ *
+ * Implements comprehensive movement speed modifier system that dynamically adjusts
+ * player movement speed based on multiple factors: combat stance, leg injuries,
+ * stamina depletion, and combat state. Integrates with physics-based movement
+ * system for authentic Korean martial arts combat feel.
+ *
+ * ## System Features
+ *
+ * - Base movement speeds for walking, running, backward, lateral, and crouching
+ * - Eight Trigram stance-based speed modifiers (80% to 125%)
+ * - Injury-based speed reduction from leg damage (0% to 100% penalty)
+ * - Stamina-based acceleration penalty (0% to 75% penalty)
+ * - Combat state speed adjustments (0% to 100% penalty)
+ * - Multiplicative and additive modifier stacking
+ *
+ * ## Speed Calculation Formula
+ *
+ * ```
+ * Final Speed = Base Speed
+ *               × Stance Modifier
+ *               × (1 - Injury Penalty from Legs, Torso & Pain)
+ *               × (1 - Combat State Penalty)
+ *
+ * Final Acceleration = Base Acceleration
+ *                      × (1 - Stamina Penalty)
+ * ```
+ *
+ * @module systems/physics/SpeedModifierSystem
+ * @category Physics System
+ * @korean 속도변경시스템
+ */
+import type { PlayerState } from "../player";
+/**
+ * Complete speed modifier state for physics calculations.
+ *
+ * **Korean**: 속도 변경 상태 (Speed Modifier State)
+ *
+ * Contains all calculated speed modifiers and final values for application
+ * to the physics-based movement system.
+ *
+ * @public
+ * @category Physics System
+ * @korean 속도변경상태
+ */
+export interface SpeedModifierState {
+    /** Base movement speed before modifiers (m/s) */
+    readonly baseSpeed: number;
+    /** Stance-based speed multiplier (0.80 to 1.25) */
+    readonly stanceModifier: number;
+    /** Injury-based speed reduction (0.0 to 0.75, percentage reduction) - Korean: 부상감소 */
+    readonly injuryPenalty: number;
+    /** Combat state speed reduction (0.0 to 1.0, percentage reduction) */
+    readonly combatStatePenalty: number;
+    /** Stamina-based acceleration reduction (0.0 to 0.75, percentage reduction) - Korean: 스태미나효과 */
+    readonly staminaPenalty: number;
+    /** Final calculated movement speed (m/s) */
+    readonly finalSpeed: number;
+    /** Final calculated acceleration (m/s²) */
+    readonly finalAcceleration: number;
+    /** Whether running is allowed (false when stamina < 10%) */
+    readonly canRun: boolean;
+}
+/**
+ * Movement type enumeration.
+ *
+ * **Korean**: 이동 유형 (Movement Type)
+ *
+ * @public
+ * @category Physics System
+ */
+export declare enum MovementType {
+    /** Walking forward - Korean: 걷기 */
+    WALKING = "walking",
+    /** Running/sprinting forward - Korean: 달리기 */
+    RUNNING = "running",
+    /** Moving backward - Korean: 후퇴 */
+    BACKWARD = "backward",
+    /** Side-stepping left/right - Korean: 측면이동 */
+    LATERAL = "lateral",
+    /** Crouching movement - Korean: 웅크리기 */
+    CROUCHING = "crouching"
+}
+/**
+ * Speed Modifier System class.
+ *
+ * **Korean**: 속도 변경 시스템 클래스
+ *
+ * Calculates comprehensive speed modifiers from multiple factors including
+ * stance, injuries, stamina, and combat state. Integrates with existing
+ * body part and movement systems.
+ *
+ * @example
+ * ```typescript
+ * const system = new SpeedModifierSystem();
+ *
+ * const modifiers = system.calculateSpeedModifiers(
+ *   playerState,
+ *   MovementType.RUNNING,
+ *   true // isCrouching
+ * );
+ *
+ * // Apply to movement physics
+ * movementPhysics.setMaxSpeed(modifiers.finalSpeed);
+ * movementPhysics.setAcceleration(modifiers.finalAcceleration);
+ * ```
+ *
+ * @public
+ * @category Physics System
+ */
+export declare class SpeedModifierSystem {
+    /**
+     * Base walking speed (m/s)
+     * Standard walking pace for combat movement - crosses 14m arena in ~2.3s
+     *
+     * **Korean**: 기본 걷기 속도 (Base Walking Speed)
+     */
+    private readonly BASE_WALKING_SPEED;
+    /**
+     * Base running speed (m/s)
+     * Sprint speed for rapid repositioning - crosses 14m arena in ~1.4s
+     *
+     * **Korean**: 기본 달리기 속도 (Base Running Speed)
+     */
+    private readonly BASE_RUNNING_SPEED;
+    /**
+     * Lateral movement speed (m/s)
+     * Fast side-stepping for combat positioning
+     *
+     * **Korean**: 측면 이동 속도 (Lateral Movement Speed)
+     */
+    private readonly LATERAL_SPEED;
+    /**
+     * Crouching movement speed (m/s)
+     * Defensive low movement for cautious approach
+     *
+     * **Korean**: 웅크림 이동 속도 (Crouching Movement Speed)
+     */
+    private readonly CROUCHING_SPEED;
+    /**
+     * Backward speed multiplier (75% of forward speed)
+     *
+     * **Korean**: 후퇴 속도 배수 (Backward Speed Multiplier)
+     */
+    private readonly BACKWARD_SPEED_MULTIPLIER;
+    /**
+     * Base acceleration rate (m/s²)
+     * Instant-response acceleration for combat movement
+     * (e.g., reaches 6 m/s walking speed in 0.2s; 10 m/s sprint speed in 0.33s)
+     * Increased from 12.0 to 30.0 for responsive, arcade-style combat feel
+     *
+     * Imported from physicsConstants.ts to maintain consistency across systems.
+     *
+     * **Korean**: 기본 가속도 (Base Acceleration)
+     */
+    private readonly BASE_ACCELERATION;
+    /**
+     * Combat state speed penalty multipliers
+     *
+     * **Korean**: 전투 상태 속도 패널티 (Combat State Speed Penalties)
+     */
+    private readonly COMBAT_STATE_PENALTIES;
+    /**
+     * Calculate comprehensive speed modifiers for player movement.
+     *
+     * **Korean**: 속도 변경 계산 (Calculate Speed Modifiers)
+     *
+     * Analyzes player state and returns complete speed modifier information
+     * including all individual factors and final calculated values.
+     *
+     * @param playerState - Current player state with stance, health, stamina
+     * @param movementType - Type of movement being performed
+     * @param isCrouching - Whether player is in crouching stance
+     * @returns Complete speed modifier state with all factors
+     *
+     * @public
+     */
+    calculateSpeedModifiers(playerState: PlayerState, movementType?: MovementType, isCrouching?: boolean): SpeedModifierState;
+    /**
+     * Get base speed for movement type.
+     *
+     * **Korean**: 기본 속도 계산 (Get Base Speed)
+     *
+     * Uses archetype-specific walk/run speeds when available,
+     * falls back to default values for backwards compatibility.
+     *
+     * @param movementType - Type of movement
+     * @param isCrouching - Whether player is crouching
+     * @param physicalAttributes - Player's physical attributes (optional)
+     * @returns Base speed in m/s
+     *
+     * @private
+     */
+    private getBaseSpeed;
+    /**
+     * Get stance-based speed modifier.
+     *
+     * **Korean**: 자세 속도 배수 계산 (Get Stance Speed Modifier)
+     *
+     * @param stance - Current Eight Trigram stance
+     * @returns Speed multiplier (0.80 to 1.25)
+     *
+     * @private
+     */
+    private getStanceSpeedModifier;
+    /**
+     * Calculate injury-based speed penalty from leg damage.
+     *
+     * **Korean**: 부상 속도 패널티 계산 (Calculate Injury Penalty)
+     *
+     * Uses NEW InjuryMovementModifier to determine speed reduction based on
+     * leg damage severity, torso damage, and pain levels.
+     * NOTE: Stance modifier is calculated separately to maintain compatibility
+     * with existing SpeedModifierState interface.
+     *
+     * Penalties are progressive and realistic:
+     * - Leg injuries: 0-100% penalty based on health
+     * - Torso injuries: 0-30% minor penalty
+     * - Both legs injured: Additional 20% cumulative penalty
+     * - Pain overload: -15% when pain ≥ 80
+     *
+     * @param bodyPartHealth - Current body part health
+     * @param bodyPartMaxHealth - Maximum body part health
+     * @param painLevel - Current pain level (0-100)
+     * @returns Speed penalty as percentage (0.0 to 0.9 max)
+     *
+     * @private
+     */
+    private calculateInjuryPenalty;
+    /**
+     * Calculate combat state speed penalty.
+     *
+     * **Korean**: 전투 상태 속도 패널티 계산 (Get Combat State Penalty)
+     *
+     * Different combat states restrict movement:
+     * - IDLE: 0% penalty (full movement)
+     * - ATTACKING: -30% penalty (committed to technique)
+     * - DEFENDING: -20% penalty (guard up, limited mobility)
+     * - STUNNED: -100% penalty (cannot move)
+     * - RECOVERING: -40% penalty (vulnerable, slow movement)
+     * - COUNTERING: -25% penalty (counter execution)
+     * - TRANSITIONING: -15% penalty (stance change)
+     *
+     * @param combatState - Current combat state
+     * @returns Speed penalty as percentage (0.0 to 1.0)
+     *
+     * @private
+     */
+    private getCombatStatePenalty;
+    /**
+     * Calculate stamina-based acceleration penalty.
+     *
+     * **Korean**: 스태미나 가속 패널티 계산 (Calculate Stamina Penalty)
+     *
+     * Stamina affects acceleration rate, making it harder to change direction
+     * or speed up when fatigued:
+     * - High stamina (70-100%): 0% penalty (normal acceleration)
+     * - Medium stamina (40-70%): -20% penalty
+     * - Low stamina (10-40%): -50% penalty
+     * - Depleted stamina (<10%): -75% penalty, cannot run
+     *
+     * @param currentStamina - Current stamina points
+     * @param maxStamina - Maximum stamina capacity
+     * @returns Acceleration penalty as percentage (0.0 to 0.75)
+     *
+     * @private
+     */
+    private calculateStaminaPenalty;
+    /**
+     * Check if player can run based on stamina level.
+     *
+     * **Korean**: 달리기 가능 확인 (Can Player Run)
+     *
+     * @param currentStamina - Current stamina points
+     * @param maxStamina - Maximum stamina capacity
+     * @returns True if player has enough stamina to run
+     *
+     * @private
+     */
+    private canPlayerRun;
+    /**
+     * Apply speed modifiers to movement physics system.
+     *
+     * **Korean**: 속도 변경 적용 (Apply Speed Modifiers)
+     *
+     * Convenience method to directly apply calculated modifiers to a
+     * movement physics instance.
+     *
+     * @param movementPhysics - Movement physics system to update
+     * @param modifiers - Calculated speed modifier state
+     *
+     * @public
+     */
+    applySpeedModifiers(movementPhysics: {
+        setMaxSpeed: (speed: number) => void;
+        setAcceleration: (accel: number) => void;
+    }, modifiers: SpeedModifierState): void;
+}
+//# sourceMappingURL=SpeedModifierSystem.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SpeedModifierSystem.d.ts","sourceRoot":"","sources":["../../../src/systems/physics/SpeedModifierSystem.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAMH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAMpD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,kBAAkB;IACjC,iDAAiD;IACjD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,mDAAmD;IACnD,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,sFAAsF;IACtF,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,sEAAsE;IACtE,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,gGAAgG;IAChG,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,4CAA4C;IAC5C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,2CAA2C;IAC3C,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,4DAA4D;IAC5D,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B;AAED;;;;;;;GAOG;AACH,oBAAY,YAAY;IACtB,mCAAmC;IACnC,OAAO,YAAY;IACnB,8CAA8C;IAC9C,OAAO,YAAY;IACnB,mCAAmC;IACnC,QAAQ,aAAa;IACrB,8CAA8C;IAC9C,OAAO,YAAY;IACnB,wCAAwC;IACxC,SAAS,cAAc;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,mBAAmB;IAC9B;;;;;OAKG;IACH,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAO;IAE1C;;;;;OAKG;IACH,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAQ;IAE3C;;;;;OAKG;IACH,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAO;IAErC;;;;;OAKG;IACH,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAO;IAEvC;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAAQ;IAElD;;;;;;;;;OASG;IACH,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAA8B;IAEhE;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAUrC;IAKF;;;;;;;;;;;;;;OAcG;IACI,uBAAuB,CAC5B,WAAW,EAAE,WAAW,EACxB,YAAY,GAAE,YAAmC,EACjD,WAAW,GAAE,OAAe,GAC3B,kBAAkB;IAoErB;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,YAAY;IAkCpB;;;;;;;;;OASG;IACH,OAAO,CAAC,sBAAsB;IAI9B;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,OAAO,CAAC,sBAAsB;IA6B9B;;;;;;;;;;;;;;;;;;OAkBG;IACH,OAAO,CAAC,qBAAqB;IAI7B;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,uBAAuB;IAqB/B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,YAAY;IASpB;;;;;;;;;;;;OAYG;IACI,mBAAmB,CACxB,eAAe,EAAE;QACf,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;QACrC,eAAe,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;KAC1C,EACD,SAAS,EAAE,kBAAkB,GAC5B,IAAI;CAIR"}

package/lib/systems/physics/SpeedModifierSystem.js

@@ -0,0 +1,301 @@
+import { CombatState, TrigramStance } from "../../types/common.js";
+import { STANCE_SPEED_MODIFIERS } from "./MovementPhysics.js";
+import { injuryMovementModifier } from "../movement/InjuryMovementModifier.js";
+//#region src/systems/physics/SpeedModifierSystem.ts
+/**
+* Movement type enumeration.
+*
+* **Korean**: 이동 유형 (Movement Type)
+*
+* @public
+* @category Physics System
+*/
+var MovementType = /* @__PURE__ */ function(MovementType) {
+	/** Walking forward - Korean: 걷기 */
+	MovementType["WALKING"] = "walking";
+	/** Running/sprinting forward - Korean: 달리기 */
+	MovementType["RUNNING"] = "running";
+	/** Moving backward - Korean: 후퇴 */
+	MovementType["BACKWARD"] = "backward";
+	/** Side-stepping left/right - Korean: 측면이동 */
+	MovementType["LATERAL"] = "lateral";
+	/** Crouching movement - Korean: 웅크리기 */
+	MovementType["CROUCHING"] = "crouching";
+	return MovementType;
+}({});
+/**
+* Speed Modifier System class.
+*
+* **Korean**: 속도 변경 시스템 클래스
+*
+* Calculates comprehensive speed modifiers from multiple factors including
+* stance, injuries, stamina, and combat state. Integrates with existing
+* body part and movement systems.
+*
+* @example
+* ```typescript
+* const system = new SpeedModifierSystem();
+*
+* const modifiers = system.calculateSpeedModifiers(
+*   playerState,
+*   MovementType.RUNNING,
+*   true // isCrouching
+* );
+*
+* // Apply to movement physics
+* movementPhysics.setMaxSpeed(modifiers.finalSpeed);
+* movementPhysics.setAcceleration(modifiers.finalAcceleration);
+* ```
+*
+* @public
+* @category Physics System
+*/
+var SpeedModifierSystem = class {
+	/**
+	* Base walking speed (m/s)
+	* Standard walking pace for combat movement - crosses 14m arena in ~2.3s
+	*
+	* **Korean**: 기본 걷기 속도 (Base Walking Speed)
+	*/
+	BASE_WALKING_SPEED = 6;
+	/**
+	* Base running speed (m/s)
+	* Sprint speed for rapid repositioning - crosses 14m arena in ~1.4s
+	*
+	* **Korean**: 기본 달리기 속도 (Base Running Speed)
+	*/
+	BASE_RUNNING_SPEED = 10;
+	/**
+	* Lateral movement speed (m/s)
+	* Fast side-stepping for combat positioning
+	*
+	* **Korean**: 측면 이동 속도 (Lateral Movement Speed)
+	*/
+	LATERAL_SPEED = 5;
+	/**
+	* Crouching movement speed (m/s)
+	* Defensive low movement for cautious approach
+	*
+	* **Korean**: 웅크림 이동 속도 (Crouching Movement Speed)
+	*/
+	CROUCHING_SPEED = 3;
+	/**
+	* Backward speed multiplier (75% of forward speed)
+	*
+	* **Korean**: 후퇴 속도 배수 (Backward Speed Multiplier)
+	*/
+	BACKWARD_SPEED_MULTIPLIER = .75;
+	/**
+	* Base acceleration rate (m/s²)
+	* Instant-response acceleration for combat movement
+	* (e.g., reaches 6 m/s walking speed in 0.2s; 10 m/s sprint speed in 0.33s)
+	* Increased from 12.0 to 30.0 for responsive, arcade-style combat feel
+	*
+	* Imported from physicsConstants.ts to maintain consistency across systems.
+	*
+	* **Korean**: 기본 가속도 (Base Acceleration)
+	*/
+	BASE_ACCELERATION = 30;
+	/**
+	* Combat state speed penalty multipliers
+	*
+	* **Korean**: 전투 상태 속도 패널티 (Combat State Speed Penalties)
+	*/
+	COMBAT_STATE_PENALTIES = {
+		[CombatState.IDLE]: 0,
+		[CombatState.ATTACKING]: .3,
+		[CombatState.DEFENDING]: .2,
+		[CombatState.STUNNED]: 1,
+		[CombatState.RECOVERING]: .4,
+		[CombatState.COUNTERING]: .25,
+		[CombatState.TRANSITIONING]: .15,
+		[CombatState.GRAPPLING]: .8,
+		[CombatState.GRAPPLED]: 1
+	};
+	/**
+	* Calculate comprehensive speed modifiers for player movement.
+	*
+	* **Korean**: 속도 변경 계산 (Calculate Speed Modifiers)
+	*
+	* Analyzes player state and returns complete speed modifier information
+	* including all individual factors and final calculated values.
+	*
+	* @param playerState - Current player state with stance, health, stamina
+	* @param movementType - Type of movement being performed
+	* @param isCrouching - Whether player is in crouching stance
+	* @returns Complete speed modifier state with all factors
+	*
+	* @public
+	*/
+	calculateSpeedModifiers(playerState, movementType = MovementType.WALKING, isCrouching = false) {
+		const baseSpeed = this.getBaseSpeed(movementType, isCrouching, playerState.physicalAttributes);
+		const injuryPenalty = this.calculateInjuryPenalty(playerState.bodyPartHealth, playerState.bodyPartMaxHealth, playerState.pain);
+		const stanceModifier = this.getStanceSpeedModifier(playerState.currentStance);
+		const combatStatePenalty = this.getCombatStatePenalty(playerState.combatState);
+		const staminaPenalty = this.calculateStaminaPenalty(playerState.stamina, playerState.maxStamina);
+		const canRun = this.canPlayerRun(playerState.stamina, playerState.maxStamina);
+		return {
+			baseSpeed,
+			stanceModifier,
+			injuryPenalty,
+			combatStatePenalty,
+			staminaPenalty,
+			finalSpeed: baseSpeed * stanceModifier * (1 - injuryPenalty) * (1 - combatStatePenalty),
+			finalAcceleration: (playerState.physicalAttributes?.acceleration ?? this.BASE_ACCELERATION) * (1 - staminaPenalty),
+			canRun
+		};
+	}
+	/**
+	* Get base speed for movement type.
+	*
+	* **Korean**: 기본 속도 계산 (Get Base Speed)
+	*
+	* Uses archetype-specific walk/run speeds when available,
+	* falls back to default values for backwards compatibility.
+	*
+	* @param movementType - Type of movement
+	* @param isCrouching - Whether player is crouching
+	* @param physicalAttributes - Player's physical attributes (optional)
+	* @returns Base speed in m/s
+	*
+	* @private
+	*/
+	getBaseSpeed(movementType, isCrouching, physicalAttributes) {
+		if (isCrouching) return this.CROUCHING_SPEED;
+		const archetypeWalkSpeed = physicalAttributes?.walkSpeed ?? this.BASE_WALKING_SPEED;
+		const archetypeRunSpeed = physicalAttributes?.runSpeed ?? this.BASE_RUNNING_SPEED;
+		switch (movementType) {
+			case MovementType.WALKING: return archetypeWalkSpeed;
+			case MovementType.RUNNING: return archetypeRunSpeed;
+			case MovementType.BACKWARD: return archetypeWalkSpeed * this.BACKWARD_SPEED_MULTIPLIER;
+			case MovementType.LATERAL: return archetypeWalkSpeed * (this.LATERAL_SPEED / this.BASE_WALKING_SPEED);
+			case MovementType.CROUCHING: return this.CROUCHING_SPEED;
+			default: return archetypeWalkSpeed;
+		}
+	}
+	/**
+	* Get stance-based speed modifier.
+	*
+	* **Korean**: 자세 속도 배수 계산 (Get Stance Speed Modifier)
+	*
+	* @param stance - Current Eight Trigram stance
+	* @returns Speed multiplier (0.80 to 1.25)
+	*
+	* @private
+	*/
+	getStanceSpeedModifier(stance) {
+		return STANCE_SPEED_MODIFIERS[stance] ?? 1;
+	}
+	/**
+	* Calculate injury-based speed penalty from leg damage.
+	*
+	* **Korean**: 부상 속도 패널티 계산 (Calculate Injury Penalty)
+	*
+	* Uses NEW InjuryMovementModifier to determine speed reduction based on
+	* leg damage severity, torso damage, and pain levels.
+	* NOTE: Stance modifier is calculated separately to maintain compatibility
+	* with existing SpeedModifierState interface.
+	* 
+	* Penalties are progressive and realistic:
+	* - Leg injuries: 0-100% penalty based on health
+	* - Torso injuries: 0-30% minor penalty
+	* - Both legs injured: Additional 20% cumulative penalty
+	* - Pain overload: -15% when pain ≥ 80
+	*
+	* @param bodyPartHealth - Current body part health
+	* @param bodyPartMaxHealth - Maximum body part health
+	* @param painLevel - Current pain level (0-100)
+	* @returns Speed penalty as percentage (0.0 to 0.9 max)
+	*
+	* @private
+	*/
+	calculateInjuryPenalty(bodyPartHealth, bodyPartMaxHealth, painLevel) {
+		if (!bodyPartHealth || !bodyPartMaxHealth) return 0;
+		const penalty = 1 - injuryMovementModifier.calculateMovementSpeed(1, bodyPartHealth, TrigramStance.GEON, painLevel).speedMultiplier;
+		return Math.min(penalty, .9);
+	}
+	/**
+	* Calculate combat state speed penalty.
+	*
+	* **Korean**: 전투 상태 속도 패널티 계산 (Get Combat State Penalty)
+	*
+	* Different combat states restrict movement:
+	* - IDLE: 0% penalty (full movement)
+	* - ATTACKING: -30% penalty (committed to technique)
+	* - DEFENDING: -20% penalty (guard up, limited mobility)
+	* - STUNNED: -100% penalty (cannot move)
+	* - RECOVERING: -40% penalty (vulnerable, slow movement)
+	* - COUNTERING: -25% penalty (counter execution)
+	* - TRANSITIONING: -15% penalty (stance change)
+	*
+	* @param combatState - Current combat state
+	* @returns Speed penalty as percentage (0.0 to 1.0)
+	*
+	* @private
+	*/
+	getCombatStatePenalty(combatState) {
+		return this.COMBAT_STATE_PENALTIES[combatState] ?? 0;
+	}
+	/**
+	* Calculate stamina-based acceleration penalty.
+	*
+	* **Korean**: 스태미나 가속 패널티 계산 (Calculate Stamina Penalty)
+	*
+	* Stamina affects acceleration rate, making it harder to change direction
+	* or speed up when fatigued:
+	* - High stamina (70-100%): 0% penalty (normal acceleration)
+	* - Medium stamina (40-70%): -20% penalty
+	* - Low stamina (10-40%): -50% penalty
+	* - Depleted stamina (<10%): -75% penalty, cannot run
+	*
+	* @param currentStamina - Current stamina points
+	* @param maxStamina - Maximum stamina capacity
+	* @returns Acceleration penalty as percentage (0.0 to 0.75)
+	*
+	* @private
+	*/
+	calculateStaminaPenalty(currentStamina, maxStamina) {
+		if (maxStamina <= 0) return 0;
+		const staminaPercent = currentStamina / maxStamina * 100;
+		if (staminaPercent >= 70) return 0;
+		else if (staminaPercent >= 40) return .2;
+		else if (staminaPercent >= 10) return .5;
+		else return .75;
+	}
+	/**
+	* Check if player can run based on stamina level.
+	*
+	* **Korean**: 달리기 가능 확인 (Can Player Run)
+	*
+	* @param currentStamina - Current stamina points
+	* @param maxStamina - Maximum stamina capacity
+	* @returns True if player has enough stamina to run
+	*
+	* @private
+	*/
+	canPlayerRun(currentStamina, maxStamina) {
+		if (maxStamina <= 0) return true;
+		return currentStamina / maxStamina * 100 >= 10;
+	}
+	/**
+	* Apply speed modifiers to movement physics system.
+	*
+	* **Korean**: 속도 변경 적용 (Apply Speed Modifiers)
+	*
+	* Convenience method to directly apply calculated modifiers to a
+	* movement physics instance.
+	*
+	* @param movementPhysics - Movement physics system to update
+	* @param modifiers - Calculated speed modifier state
+	*
+	* @public
+	*/
+	applySpeedModifiers(movementPhysics, modifiers) {
+		movementPhysics.setMaxSpeed(modifiers.finalSpeed);
+		movementPhysics.setAcceleration(modifiers.finalAcceleration);
+	}
+};
+//#endregion
+export { MovementType, SpeedModifierSystem };
+
+//# sourceMappingURL=SpeedModifierSystem.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SpeedModifierSystem.js","names":[],"sources":["../../../src/systems/physics/SpeedModifierSystem.ts"],"sourcesContent":["/**\n * Speed Modifier System\n *\n * **Korean**: 속도 변경 시스템 (Speed Modifier System)\n *\n * Implements comprehensive movement speed modifier system that dynamically adjusts\n * player movement speed based on multiple factors: combat stance, leg injuries,\n * stamina depletion, and combat state. Integrates with physics-based movement\n * system for authentic Korean martial arts combat feel.\n *\n * ## System Features\n *\n * - Base movement speeds for walking, running, backward, lateral, and crouching\n * - Eight Trigram stance-based speed modifiers (80% to 125%)\n * - Injury-based speed reduction from leg damage (0% to 100% penalty)\n * - Stamina-based acceleration penalty (0% to 75% penalty)\n * - Combat state speed adjustments (0% to 100% penalty)\n * - Multiplicative and additive modifier stacking\n *\n * ## Speed Calculation Formula\n *\n * ```\n * Final Speed = Base Speed\n *               × Stance Modifier\n *               × (1 - Injury Penalty from Legs, Torso & Pain)\n *               × (1 - Combat State Penalty)\n *\n * Final Acceleration = Base Acceleration\n *                      × (1 - Stamina Penalty)\n * ```\n *\n * @module systems/physics/SpeedModifierSystem\n * @category Physics System\n * @korean 속도변경시스템\n */\n\nimport type {\n  BodyPartHealth,\n  BodyPartMaxHealth,\n} from \"@/systems/bodypart/types\";\nimport type { PlayerState } from \"@/systems/player\";\nimport { CombatState, TrigramStance } from \"@/types/common\";\nimport { BASE_MOVEMENT_ACCELERATION } from \"@/types/physicsConstants\";\nimport { STANCE_SPEED_MODIFIERS } from \"./MovementPhysics\";\nimport { injuryMovementModifier } from \"@/systems/movement/InjuryMovementModifier\";\n\n/**\n * Complete speed modifier state for physics calculations.\n *\n * **Korean**: 속도 변경 상태 (Speed Modifier State)\n *\n * Contains all calculated speed modifiers and final values for application\n * to the physics-based movement system.\n *\n * @public\n * @category Physics System\n * @korean 속도변경상태\n */\nexport interface SpeedModifierState {\n  /** Base movement speed before modifiers (m/s) */\n  readonly baseSpeed: number;\n  /** Stance-based speed multiplier (0.80 to 1.25) */\n  readonly stanceModifier: number;\n  /** Injury-based speed reduction (0.0 to 0.75, percentage reduction) - Korean: 부상감소 */\n  readonly injuryPenalty: number;\n  /** Combat state speed reduction (0.0 to 1.0, percentage reduction) */\n  readonly combatStatePenalty: number;\n  /** Stamina-based acceleration reduction (0.0 to 0.75, percentage reduction) - Korean: 스태미나효과 */\n  readonly staminaPenalty: number;\n  /** Final calculated movement speed (m/s) */\n  readonly finalSpeed: number;\n  /** Final calculated acceleration (m/s²) */\n  readonly finalAcceleration: number;\n  /** Whether running is allowed (false when stamina < 10%) */\n  readonly canRun: boolean;\n}\n\n/**\n * Movement type enumeration.\n *\n * **Korean**: 이동 유형 (Movement Type)\n *\n * @public\n * @category Physics System\n */\nexport enum MovementType {\n  /** Walking forward - Korean: 걷기 */\n  WALKING = \"walking\",\n  /** Running/sprinting forward - Korean: 달리기 */\n  RUNNING = \"running\",\n  /** Moving backward - Korean: 후퇴 */\n  BACKWARD = \"backward\",\n  /** Side-stepping left/right - Korean: 측면이동 */\n  LATERAL = \"lateral\",\n  /** Crouching movement - Korean: 웅크리기 */\n  CROUCHING = \"crouching\",\n}\n\n/**\n * Speed Modifier System class.\n *\n * **Korean**: 속도 변경 시스템 클래스\n *\n * Calculates comprehensive speed modifiers from multiple factors including\n * stance, injuries, stamina, and combat state. Integrates with existing\n * body part and movement systems.\n *\n * @example\n * ```typescript\n * const system = new SpeedModifierSystem();\n *\n * const modifiers = system.calculateSpeedModifiers(\n *   playerState,\n *   MovementType.RUNNING,\n *   true // isCrouching\n * );\n *\n * // Apply to movement physics\n * movementPhysics.setMaxSpeed(modifiers.finalSpeed);\n * movementPhysics.setAcceleration(modifiers.finalAcceleration);\n * ```\n *\n * @public\n * @category Physics System\n */\nexport class SpeedModifierSystem {\n  /**\n   * Base walking speed (m/s)\n   * Standard walking pace for combat movement - crosses 14m arena in ~2.3s\n   *\n   * **Korean**: 기본 걷기 속도 (Base Walking Speed)\n   */\n  private readonly BASE_WALKING_SPEED = 6.0;\n\n  /**\n   * Base running speed (m/s)\n   * Sprint speed for rapid repositioning - crosses 14m arena in ~1.4s\n   *\n   * **Korean**: 기본 달리기 속도 (Base Running Speed)\n   */\n  private readonly BASE_RUNNING_SPEED = 10.0;\n\n  /**\n   * Lateral movement speed (m/s)\n   * Fast side-stepping for combat positioning\n   *\n   * **Korean**: 측면 이동 속도 (Lateral Movement Speed)\n   */\n  private readonly LATERAL_SPEED = 5.0;\n\n  /**\n   * Crouching movement speed (m/s)\n   * Defensive low movement for cautious approach\n   *\n   * **Korean**: 웅크림 이동 속도 (Crouching Movement Speed)\n   */\n  private readonly CROUCHING_SPEED = 3.0;\n\n  /**\n   * Backward speed multiplier (75% of forward speed)\n   *\n   * **Korean**: 후퇴 속도 배수 (Backward Speed Multiplier)\n   */\n  private readonly BACKWARD_SPEED_MULTIPLIER = 0.75;\n\n  /**\n   * Base acceleration rate (m/s²)\n   * Instant-response acceleration for combat movement\n   * (e.g., reaches 6 m/s walking speed in 0.2s; 10 m/s sprint speed in 0.33s)\n   * Increased from 12.0 to 30.0 for responsive, arcade-style combat feel\n   *\n   * Imported from physicsConstants.ts to maintain consistency across systems.\n   *\n   * **Korean**: 기본 가속도 (Base Acceleration)\n   */\n  private readonly BASE_ACCELERATION = BASE_MOVEMENT_ACCELERATION;\n\n  /**\n   * Combat state speed penalty multipliers\n   *\n   * **Korean**: 전투 상태 속도 패널티 (Combat State Speed Penalties)\n   */\n  private readonly COMBAT_STATE_PENALTIES: Record<CombatState, number> = {\n    [CombatState.IDLE]: 0.0, // No penalty when idle\n    [CombatState.ATTACKING]: 0.3, // -30% during attack commitment\n    [CombatState.DEFENDING]: 0.2, // -20% while guarding\n    [CombatState.STUNNED]: 1.0, // Cannot move when stunned\n    [CombatState.RECOVERING]: 0.4, // -40% during recovery frames\n    [CombatState.COUNTERING]: 0.25, // -25% during counter execution\n    [CombatState.TRANSITIONING]: 0.15, // -15% during stance transitions\n    [CombatState.GRAPPLING]: 0.8, // -80% while controlling opponent\n    [CombatState.GRAPPLED]: 1.0, // Cannot move while being controlled\n  };\n\n  // Constructor removed - no longer need MovementPenaltySystem instance\n  // Using injuryMovementModifier singleton instead\n\n  /**\n   * Calculate comprehensive speed modifiers for player movement.\n   *\n   * **Korean**: 속도 변경 계산 (Calculate Speed Modifiers)\n   *\n   * Analyzes player state and returns complete speed modifier information\n   * including all individual factors and final calculated values.\n   *\n   * @param playerState - Current player state with stance, health, stamina\n   * @param movementType - Type of movement being performed\n   * @param isCrouching - Whether player is in crouching stance\n   * @returns Complete speed modifier state with all factors\n   *\n   * @public\n   */\n  public calculateSpeedModifiers(\n    playerState: PlayerState,\n    movementType: MovementType = MovementType.WALKING,\n    isCrouching: boolean = false,\n  ): SpeedModifierState {\n    // Get base speed based on movement type and archetype-specific speeds\n    const baseSpeed = this.getBaseSpeed(\n      movementType,\n      isCrouching,\n      playerState.physicalAttributes,\n    );\n\n    // Calculate injury penalty from leg damage using NEW InjuryMovementModifier system\n    // This replaces the old MovementPenaltySystem with comprehensive injury calculations\n    const injuryPenalty = this.calculateInjuryPenalty(\n      playerState.bodyPartHealth,\n      playerState.bodyPartMaxHealth,\n      playerState.pain,\n    );\n\n    // Calculate stance modifier separately.\n    // NOTE: InjuryMovementModifier is called with neutral GEON stance inside\n    // calculateInjuryPenalty() so that injury effects are isolated from stance.\n    // The actual current stance effect must be applied here via stanceModifier.\n    const stanceModifier = this.getStanceSpeedModifier(\n      playerState.currentStance,\n    );\n\n    // Calculate combat state penalty\n    const combatStatePenalty = this.getCombatStatePenalty(\n      playerState.combatState,\n    );\n\n    // Calculate stamina penalty (affects acceleration only)\n    const staminaPenalty = this.calculateStaminaPenalty(\n      playerState.stamina,\n      playerState.maxStamina,\n    );\n\n    // Check if running is allowed\n    const canRun = this.canPlayerRun(\n      playerState.stamina,\n      playerState.maxStamina,\n    );\n\n    // Calculate final speed with all modifiers applied multiplicatively\n    // Formula: Base × Stance × (1 - Injury) × (1 - CombatState)\n    // Note: Injury penalty now excludes stance (calculated with GEON), so we apply stance here\n    const finalSpeed =\n      baseSpeed *\n      stanceModifier *\n      (1.0 - injuryPenalty) *\n      (1.0 - combatStatePenalty);\n\n    // Calculate final acceleration using archetype-specific base and stamina penalty\n    // Formula: ArchetypeAcceleration × (1 - StaminaPenalty)\n    const archetypeAcceleration =\n      playerState.physicalAttributes?.acceleration ?? this.BASE_ACCELERATION;\n    const finalAcceleration = archetypeAcceleration * (1.0 - staminaPenalty);\n\n    return {\n      baseSpeed,\n      stanceModifier,\n      injuryPenalty,\n      combatStatePenalty,\n      staminaPenalty,\n      finalSpeed,\n      finalAcceleration,\n      canRun,\n    };\n  }\n\n  /**\n   * Get base speed for movement type.\n   *\n   * **Korean**: 기본 속도 계산 (Get Base Speed)\n   *\n   * Uses archetype-specific walk/run speeds when available,\n   * falls back to default values for backwards compatibility.\n   *\n   * @param movementType - Type of movement\n   * @param isCrouching - Whether player is crouching\n   * @param physicalAttributes - Player's physical attributes (optional)\n   * @returns Base speed in m/s\n   *\n   * @private\n   */\n  private getBaseSpeed(\n    movementType: MovementType,\n    isCrouching: boolean,\n    physicalAttributes?: import(\"@/types\").PhysicalAttributes,\n  ): number {\n    if (isCrouching) {\n      return this.CROUCHING_SPEED;\n    }\n\n    // Use archetype-specific speeds if available\n    const archetypeWalkSpeed =\n      physicalAttributes?.walkSpeed ?? this.BASE_WALKING_SPEED;\n    const archetypeRunSpeed =\n      physicalAttributes?.runSpeed ?? this.BASE_RUNNING_SPEED;\n\n    switch (movementType) {\n      case MovementType.WALKING:\n        return archetypeWalkSpeed;\n      case MovementType.RUNNING:\n        return archetypeRunSpeed;\n      case MovementType.BACKWARD:\n        return archetypeWalkSpeed * this.BACKWARD_SPEED_MULTIPLIER;\n      case MovementType.LATERAL:\n        // Lateral speed scales proportionally to archetype walk speed\n        return (\n          archetypeWalkSpeed * (this.LATERAL_SPEED / this.BASE_WALKING_SPEED)\n        );\n      case MovementType.CROUCHING:\n        return this.CROUCHING_SPEED;\n      default:\n        return archetypeWalkSpeed;\n    }\n  }\n\n  /**\n   * Get stance-based speed modifier.\n   *\n   * **Korean**: 자세 속도 배수 계산 (Get Stance Speed Modifier)\n   *\n   * @param stance - Current Eight Trigram stance\n   * @returns Speed multiplier (0.80 to 1.25)\n   *\n   * @private\n   */\n  private getStanceSpeedModifier(stance: TrigramStance): number {\n    return STANCE_SPEED_MODIFIERS[stance] ?? 1.0;\n  }\n\n  /**\n   * Calculate injury-based speed penalty from leg damage.\n   *\n   * **Korean**: 부상 속도 패널티 계산 (Calculate Injury Penalty)\n   *\n   * Uses NEW InjuryMovementModifier to determine speed reduction based on\n   * leg damage severity, torso damage, and pain levels.\n   * NOTE: Stance modifier is calculated separately to maintain compatibility\n   * with existing SpeedModifierState interface.\n   * \n   * Penalties are progressive and realistic:\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   * - Pain overload: -15% when pain ≥ 80\n   *\n   * @param bodyPartHealth - Current body part health\n   * @param bodyPartMaxHealth - Maximum body part health\n   * @param painLevel - Current pain level (0-100)\n   * @returns Speed penalty as percentage (0.0 to 0.9 max)\n   *\n   * @private\n   */\n  private calculateInjuryPenalty(\n    bodyPartHealth: BodyPartHealth | undefined,\n    bodyPartMaxHealth: BodyPartMaxHealth | undefined,\n    painLevel: number,\n  ): number {\n    if (!bodyPartHealth || !bodyPartMaxHealth) {\n      return 0.0; // No penalty if body part health not tracked\n    }\n\n    // Use NEW InjuryMovementModifier system for comprehensive injury calculation\n    // Use NEUTRAL stance (GEON = 1.0x) to get pure injury penalty without stance influence\n    // Stance is applied separately in calculateSpeedModifiers for compatibility\n    const result = injuryMovementModifier.calculateMovementSpeed(\n      1.0, // Base speed of 1.0 to get pure multiplier\n      bodyPartHealth,\n      TrigramStance.GEON, // Neutral stance to isolate injury penalty\n      painLevel,\n    );\n\n    // Convert speedMultiplier to penalty percentage\n    // speedMultiplier of 1.0 = no penalty (0.0)\n    // speedMultiplier of 0.5 = 50% penalty (0.5)\n    // speedMultiplier of 0.1 = 90% penalty (0.9)\n    const penalty = 1.0 - result.speedMultiplier;\n\n    // Return penalty (already clamped by InjuryMovementModifier to min 0.1 speed)\n    return Math.min(penalty, 0.9);\n  }\n\n  /**\n   * Calculate combat state speed penalty.\n   *\n   * **Korean**: 전투 상태 속도 패널티 계산 (Get Combat State Penalty)\n   *\n   * Different combat states restrict movement:\n   * - IDLE: 0% penalty (full movement)\n   * - ATTACKING: -30% penalty (committed to technique)\n   * - DEFENDING: -20% penalty (guard up, limited mobility)\n   * - STUNNED: -100% penalty (cannot move)\n   * - RECOVERING: -40% penalty (vulnerable, slow movement)\n   * - COUNTERING: -25% penalty (counter execution)\n   * - TRANSITIONING: -15% penalty (stance change)\n   *\n   * @param combatState - Current combat state\n   * @returns Speed penalty as percentage (0.0 to 1.0)\n   *\n   * @private\n   */\n  private getCombatStatePenalty(combatState: CombatState): number {\n    return this.COMBAT_STATE_PENALTIES[combatState] ?? 0.0;\n  }\n\n  /**\n   * Calculate stamina-based acceleration penalty.\n   *\n   * **Korean**: 스태미나 가속 패널티 계산 (Calculate Stamina Penalty)\n   *\n   * Stamina affects acceleration rate, making it harder to change direction\n   * or speed up when fatigued:\n   * - High stamina (70-100%): 0% penalty (normal acceleration)\n   * - Medium stamina (40-70%): -20% penalty\n   * - Low stamina (10-40%): -50% penalty\n   * - Depleted stamina (<10%): -75% penalty, cannot run\n   *\n   * @param currentStamina - Current stamina points\n   * @param maxStamina - Maximum stamina capacity\n   * @returns Acceleration penalty as percentage (0.0 to 0.75)\n   *\n   * @private\n   */\n  private calculateStaminaPenalty(\n    currentStamina: number,\n    maxStamina: number,\n  ): number {\n    if (maxStamina <= 0) {\n      return 0.0; // No penalty if stamina not tracked\n    }\n\n    const staminaPercent = (currentStamina / maxStamina) * 100;\n\n    if (staminaPercent >= 70) {\n      return 0.0; // High stamina: no penalty\n    } else if (staminaPercent >= 40) {\n      return 0.2; // Medium stamina: -20% acceleration\n    } else if (staminaPercent >= 10) {\n      return 0.5; // Low stamina: -50% acceleration\n    } else {\n      return 0.75; // Depleted stamina: -75% acceleration\n    }\n  }\n\n  /**\n   * Check if player can run based on stamina level.\n   *\n   * **Korean**: 달리기 가능 확인 (Can Player Run)\n   *\n   * @param currentStamina - Current stamina points\n   * @param maxStamina - Maximum stamina capacity\n   * @returns True if player has enough stamina to run\n   *\n   * @private\n   */\n  private canPlayerRun(currentStamina: number, maxStamina: number): boolean {\n    if (maxStamina <= 0) {\n      return true; // Allow running if stamina not tracked\n    }\n\n    const staminaPercent = (currentStamina / maxStamina) * 100;\n    return staminaPercent >= 10; // Cannot run when stamina < 10%\n  }\n\n  /**\n   * Apply speed modifiers to movement physics system.\n   *\n   * **Korean**: 속도 변경 적용 (Apply Speed Modifiers)\n   *\n   * Convenience method to directly apply calculated modifiers to a\n   * movement physics instance.\n   *\n   * @param movementPhysics - Movement physics system to update\n   * @param modifiers - Calculated speed modifier state\n   *\n   * @public\n   */\n  public applySpeedModifiers(\n    movementPhysics: {\n      setMaxSpeed: (speed: number) => void;\n      setAcceleration: (accel: number) => void;\n    },\n    modifiers: SpeedModifierState,\n  ): void {\n    movementPhysics.setMaxSpeed(modifiers.finalSpeed);\n    movementPhysics.setAcceleration(modifiers.finalAcceleration);\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAqFA,IAAY,eAAL,yBAAA,cAAA;;AAEL,cAAA,aAAA;;AAEA,cAAA,aAAA;;AAEA,cAAA,cAAA;;AAEA,cAAA,aAAA;;AAEA,cAAA,eAAA;;KACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BD,IAAa,sBAAb,MAAiC;;;;;;;CAO/B,qBAAsC;;;;;;;CAQtC,qBAAsC;;;;;;;CAQtC,gBAAiC;;;;;;;CAQjC,kBAAmC;;;;;;CAOnC,4BAA6C;;;;;;;;;;;CAY7C,oBAAA;;;;;;CAOA,yBAAuE;GACpE,YAAY,OAAO;GACnB,YAAY,YAAY;GACxB,YAAY,YAAY;GACxB,YAAY,UAAU;GACtB,YAAY,aAAa;GACzB,YAAY,aAAa;GACzB,YAAY,gBAAgB;GAC5B,YAAY,YAAY;GACxB,YAAY,WAAW;EACzB;;;;;;;;;;;;;;;;CAoBD,wBACE,aACA,eAA6B,aAAa,SAC1C,cAAuB,OACH;EAEpB,MAAM,YAAY,KAAK,aACrB,cACA,aACA,YAAY,mBACb;EAID,MAAM,gBAAgB,KAAK,uBACzB,YAAY,gBACZ,YAAY,mBACZ,YAAY,KACb;EAMD,MAAM,iBAAiB,KAAK,uBAC1B,YAAY,cACb;EAGD,MAAM,qBAAqB,KAAK,sBAC9B,YAAY,YACb;EAGD,MAAM,iBAAiB,KAAK,wBAC1B,YAAY,SACZ,YAAY,WACb;EAGD,MAAM,SAAS,KAAK,aAClB,YAAY,SACZ,YAAY,WACb;AAiBD,SAAO;GACL;GACA;GACA;GACA;GACA;GACA,YAjBA,YACA,kBACC,IAAM,kBACN,IAAM;GAeP,oBAVA,YAAY,oBAAoB,gBAAgB,KAAK,sBACJ,IAAM;GAUvD;GACD;;;;;;;;;;;;;;;;;CAkBH,aACE,cACA,aACA,oBACQ;AACR,MAAI,YACF,QAAO,KAAK;EAId,MAAM,qBACJ,oBAAoB,aAAa,KAAK;EACxC,MAAM,oBACJ,oBAAoB,YAAY,KAAK;AAEvC,UAAQ,cAAR;GACE,KAAK,aAAa,QAChB,QAAO;GACT,KAAK,aAAa,QAChB,QAAO;GACT,KAAK,aAAa,SAChB,QAAO,qBAAqB,KAAK;GACnC,KAAK,aAAa,QAEhB,QACE,sBAAsB,KAAK,gBAAgB,KAAK;GAEpD,KAAK,aAAa,UAChB,QAAO,KAAK;GACd,QACE,QAAO;;;;;;;;;;;;;CAcb,uBAA+B,QAA+B;AAC5D,SAAO,uBAAuB,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;CA0B3C,uBACE,gBACA,mBACA,WACQ;AACR,MAAI,CAAC,kBAAkB,CAAC,kBACtB,QAAO;EAiBT,MAAM,UAAU,IAXD,uBAAuB,uBACpC,GACA,gBACA,cAAc,MACd,UACD,CAM4B;AAG7B,SAAO,KAAK,IAAI,SAAS,GAAI;;;;;;;;;;;;;;;;;;;;;CAsB/B,sBAA8B,aAAkC;AAC9D,SAAO,KAAK,uBAAuB,gBAAgB;;;;;;;;;;;;;;;;;;;;CAqBrD,wBACE,gBACA,YACQ;AACR,MAAI,cAAc,EAChB,QAAO;EAGT,MAAM,iBAAkB,iBAAiB,aAAc;AAEvD,MAAI,kBAAkB,GACpB,QAAO;WACE,kBAAkB,GAC3B,QAAO;WACE,kBAAkB,GAC3B,QAAO;MAEP,QAAO;;;;;;;;;;;;;CAeX,aAAqB,gBAAwB,YAA6B;AACxE,MAAI,cAAc,EAChB,QAAO;AAIT,SADwB,iBAAiB,aAAc,OAC9B;;;;;;;;;;;;;;;CAgB3B,oBACE,iBAIA,WACM;AACN,kBAAgB,YAAY,UAAU,WAAW;AACjD,kBAAgB,gBAAgB,UAAU,kBAAkB"}

package/lib/systems/physics/__tests__/PhysicsPerformance.bench.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Combat Physics Performance Benchmarks
+ *
+ * Performance benchmarks for physics systems targeting 60fps (16.67ms per frame).
+ *
+ * **Budget Allocation** (per frame):
+ * - Physics: <5.0ms (30% of frame budget)
+ * - Rendering: <8.0ms (48% of frame budget)
+ * - Game logic: <3.67ms (22% of frame budget)
+ *
+ * Run with: `npm run test:ai-performance`
+ *
+ * @module systems/physics/__tests__/PhysicsPerformance
+ */
+export {};
+//# sourceMappingURL=PhysicsPerformance.bench.d.ts.map

package/lib/systems/physics/__tests__/PhysicsPerformance.bench.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhysicsPerformance.bench.d.ts","sourceRoot":"","sources":["../../../../src/systems/physics/__tests__/PhysicsPerformance.bench.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG"}