blacktrigram 0.7.2

package/lib/systems/physics/MovementPhysics.js

@@ -0,0 +1,488 @@
+import { TrigramStance } from "../../types/common.js";
+import * as THREE from "three";
+//#region src/systems/physics/MovementPhysics.ts
+/**
+* Physics-based movement system for realistic combat movement.
+*
+* **Korean**: 이동 물리 시스템 (Movement Physics System)
+*
+* This module implements realistic physics-based player movement with proper
+* acceleration/deceleration, foot-wide step precision, and stance-based speed
+* modifiers for authentic Korean martial arts combat feel.
+*
+* ## Features
+*
+* - **Realistic Acceleration**: 0 to 2m/s in 0.5 seconds (4.0 m/s²)
+* - **Realistic Deceleration**: 2m/s to 0 in 0.3 seconds (6.67 m/s²)
+* - **Foot-wide Steps**: Discrete 30cm movement increments for tactical positioning
+* - **Stance Modifiers**: 8 trigram stances with different speed characteristics
+* - **Injury Integration**: Movement speed reduced by leg damage (10-50%)
+*
+* @module systems/physics/MovementPhysics
+* @category Physics System
+* @korean 이동물리
+*/
+/**
+* Stance-based speed modifiers for Eight Trigram system.
+*
+* **Korean**: 팔괘 속도 배수 (Eight Trigram Speed Multipliers)
+*
+* Each trigram stance has unique movement characteristics based on
+* traditional Korean martial arts philosophy:
+*
+* - ☰ 건 (Geon/Heaven): 100% - Balanced, standard speed
+* - ☱ 태 (Tae/Lake): 110% - Fluid movement, flowing techniques
+* - ☲ 리 (Li/Fire): 120% - Aggressive, fast attacks
+* - ☳ 진 (Jin/Thunder): 115% - Explosive power
+* - ☴ 손 (Son/Wind): 125% - Continuous motion, fastest stance
+* - ☵ 감 (Gam/Water): 105% - Adaptive, slightly faster than neutral
+* - ☶ 간 (Gan/Mountain): 80% - Solid defense, slower movement
+* - ☷ 곤 (Gon/Earth): 85% - Grounded, stable but slower
+*
+* @korean 자세속도배수
+*/
+var STANCE_SPEED_MODIFIERS = {
+	[TrigramStance.GEON]: 1,
+	[TrigramStance.TAE]: 1.1,
+	[TrigramStance.LI]: 1.2,
+	[TrigramStance.JIN]: 1.15,
+	[TrigramStance.SON]: 1.25,
+	[TrigramStance.GAM]: 1.05,
+	[TrigramStance.GAN]: .8,
+	[TrigramStance.GON]: .85
+};
+/**
+* Physics-based movement engine for combat.
+*
+* **Korean**: 이동 물리 엔진 (Movement Physics Engine)
+*
+* Implements realistic acceleration, deceleration, and stance-based movement
+* for authentic Korean martial arts combat. Supports both continuous movement
+* and tactical foot-wide steps for precise positioning.
+*
+* @example
+* ```typescript
+* const physics = new MovementPhysics();
+*
+* const state: MovementState = {
+*   position: new THREE.Vector3(0, 0, 0),
+*   velocity: new THREE.Vector3(0, 0, 0),
+*   acceleration: 0,
+*   maxSpeed: 2.0,
+*   currentStance: TrigramStance.GEON,
+*   legInjuryFactor: 0,
+* };
+*
+* const input: MovementInput = {
+*   forward: 1.0,
+*   lateral: 0,
+*   isRunning: false,
+*   isMoving: true,
+*   useTacticalSteps: false,
+* };
+*
+* // In game loop at 60fps
+* physics.updateMovement(state, input, deltaTime);
+* ```
+*
+* @public
+* @category Physics System
+* @korean 이동물리엔진
+*/
+var MovementPhysics = class {
+	/**
+	* Base acceleration rate (m/s²)
+	* Achieves 0 to 6m/s in 0.2 seconds (instant-response combat movement)
+	* Increased from 12.0 to 30.0 for arcade-style responsiveness
+	*
+	* Imported from physicsConstants.ts to maintain consistency across systems.
+	*
+	* **Korean**: 기본 가속도 (Base Acceleration)
+	*/
+	BASE_ACCELERATION = 30;
+	/**
+	* Base deceleration rate (m/s²)
+	* Achieves 6m/s to 0 in 0.3 seconds (responsive combat stopping)
+	*
+	* **Korean**: 기본 감속도 (Base Deceleration)
+	*/
+	BASE_DECELERATION = 20;
+	/**
+	* Foot-wide step size (meters)
+	* Standard Korean martial arts step is approximately 30cm
+	*
+	* **Korean**: 보법 거리 (Step Distance)
+	*/
+	STEP_SIZE = .3;
+	/**
+	* Base walking speed (m/s)
+	* Optimized for responsive combat movement - crosses 14m arena in ~2.3s
+	*
+	* **Korean**: 기본 걷기 속도 (Base Walking Speed)
+	*/
+	BASE_WALK_SPEED = 6;
+	/**
+	* Base running speed (m/s)
+	* Sprint speed for rapid repositioning - crosses 14m arena in ~1.4s
+	*
+	* **Korean**: 기본 달리기 속도 (Base Running Speed)
+	*/
+	BASE_RUN_SPEED = 10;
+	/**
+	* Reference arena size for speed calibration (meters).
+	* All speeds are calibrated for a 10m arena.
+	*
+	* **Korean**: 기준 경기장 크기 (Reference Arena Size)
+	*/
+	REFERENCE_ARENA_SIZE = 10;
+	/**
+	* Current arena width in meters for arena-aware speed scaling.
+	*
+	* **Korean**: 현재 경기장 너비 (Current Arena Width)
+	*/
+	_arenaWidthMeters = 10;
+	/**
+	* Override for max speed from external speed modifier systems.
+	*
+	* **Korean**: 최대속도 재정의 (Max Speed Override)
+	*/
+	_overrideMaxSpeed = null;
+	/**
+	* Override for acceleration from external speed modifier systems.
+	*
+	* **Korean**: 가속도 재정의 (Acceleration Override)
+	*/
+	_overrideAcceleration = null;
+	/**
+	* Cached arena speed scale to avoid repeated calculations.
+	*
+	* **Korean**: 캐시된 경기장 속도 배수 (Cached Arena Speed Scale)
+	*/
+	_cachedArenaSpeedScale = 1;
+	tempTargetVelocity = new THREE.Vector3();
+	tempMovement = new THREE.Vector3();
+	tempDirection = new THREE.Vector3();
+	tempTargetDirection = new THREE.Vector3();
+	/**
+	* Create a new MovementPhysics instance.
+	*
+	* **Korean**: 이동 물리 생성 (Create Movement Physics)
+	*
+	* @param arenaWidthMeters - Width of the arena in meters (default: 10m, min: 1m)
+	* @throws {Error} If arenaWidthMeters is not a positive number
+	*
+	* @example
+	* ```typescript
+	* // Default 10m arena (1.0x speed scale)
+	* const physics = new MovementPhysics();
+	*
+	* // Small 6m arena (0.7x speed scale)
+	* const smallPhysics = new MovementPhysics(6.0);
+	*
+	* // Large 14m arena (1.3x speed scale)
+	* const largePhysics = new MovementPhysics(14.0);
+	* ```
+	*
+	* @public
+	*/
+	constructor(arenaWidthMeters = 10) {
+		if (arenaWidthMeters <= 0 || !Number.isFinite(arenaWidthMeters)) throw new Error(`Arena width must be a positive finite number, got: ${arenaWidthMeters}`);
+		this._arenaWidthMeters = arenaWidthMeters;
+		this._cachedArenaSpeedScale = this.calculateArenaSpeedScale();
+	}
+	/**
+	* Calculate arena-aware speed scaling factor.
+	*
+	* **Korean**: 경기장 크기 기반 속도 배수 (Arena-Based Speed Multiplier)
+	*
+	* Scales movement speed proportionally to arena size to maintain consistent
+	* gameplay feel across different screen resolutions. Smaller arenas get
+	* slightly slower speeds, larger arenas get slightly faster speeds.
+	*
+	* Formula: scaleFactor = arenaWidth / referenceArenaSize
+	* Clamped to [0.7, 1.3] range for balanced gameplay
+	*
+	* Examples:
+	* - 6m arena: 0.7x speed (70% of base)
+	* - 10m arena: 1.0x speed (baseline)
+	* - 14m arena: 1.3x speed (130% of base)
+	*
+	* @returns Speed multiplier (0.7 to 1.3)
+	*
+	* @korean 경기장속도배수
+	*/
+	calculateArenaSpeedScale() {
+		const rawScale = this._arenaWidthMeters / this.REFERENCE_ARENA_SIZE;
+		return Math.max(.7, Math.min(1.3, rawScale));
+	}
+	/**
+	* Update player movement based on input and physics.
+	*
+	* **Korean**: 이동 업데이트 (Update Movement)
+	*
+	* Called every frame (60fps) to update player position based on
+	* current velocity, acceleration, and input. Applies stance modifiers
+	* and injury penalties automatically.
+	*
+	* @param state - Current movement state (modified in-place)
+	* @param input - Current movement input from controls
+	* @param deltaTime - Time since last update (seconds)
+	* @param bounds - Optional arena bounds for clamping position (meters)
+	*
+	* @korean 이동업데이트
+	*/
+	updateMovement(state, input, deltaTime, bounds) {
+		const arenaSpeedScale = this._cachedArenaSpeedScale;
+		const stanceModifier = this.getStanceSpeedModifier(state.currentStance);
+		const injuryPenalty = 1 - state.legInjuryFactor * .5;
+		const baseSpeed = input.isRunning ? this.BASE_RUN_SPEED : this.BASE_WALK_SPEED;
+		state.maxSpeed = this._overrideMaxSpeed ?? baseSpeed * arenaSpeedScale * stanceModifier * injuryPenalty;
+		const currentAcceleration = this._overrideAcceleration ?? this.BASE_ACCELERATION;
+		this.tempTargetVelocity.set(input.lateral * state.maxSpeed, 0, input.forward * state.maxSpeed);
+		if (input.isMoving) {
+			const currentSpeed = state.velocity.length();
+			const targetSpeed = this.tempTargetVelocity.length();
+			if (currentSpeed < targetSpeed) if (currentSpeed > .001 && targetSpeed > .001) {
+				this.tempDirection.copy(state.velocity).normalize();
+				this.tempTargetDirection.copy(this.tempTargetVelocity).normalize();
+				const directionDot = this.tempDirection.dot(this.tempTargetDirection);
+				if (directionDot < 0) {
+					const velocityDelta = this.BASE_DECELERATION * deltaTime;
+					const newSpeed = Math.max(currentSpeed - velocityDelta, 0);
+					if (newSpeed > .001) state.velocity.copy(this.tempDirection.multiplyScalar(newSpeed));
+					else state.velocity.set(0, 0, 0);
+					state.acceleration = -this.BASE_DECELERATION;
+				} else if (directionDot < .7) {
+					const blendedAccel = currentAcceleration * .6;
+					const velocityDelta = blendedAccel * deltaTime;
+					const newSpeed = Math.min(currentSpeed + velocityDelta, targetSpeed);
+					this.tempDirection.copy(this.tempTargetVelocity).normalize();
+					state.velocity.copy(this.tempDirection.multiplyScalar(newSpeed));
+					state.acceleration = blendedAccel;
+				} else {
+					this.tempDirection.copy(this.tempTargetVelocity).normalize();
+					const velocityDelta = currentAcceleration * deltaTime;
+					const newSpeed = Math.min(currentSpeed + velocityDelta, targetSpeed);
+					state.velocity.copy(this.tempDirection.multiplyScalar(newSpeed));
+					state.acceleration = currentAcceleration;
+				}
+			} else {
+				this.tempDirection.copy(this.tempTargetVelocity).normalize();
+				const velocityDelta = currentAcceleration * deltaTime;
+				const newSpeed = Math.min(currentSpeed + velocityDelta, targetSpeed);
+				state.velocity.copy(this.tempDirection.multiplyScalar(newSpeed));
+				state.acceleration = currentAcceleration;
+			}
+			else {
+				state.velocity.copy(this.tempTargetVelocity);
+				state.acceleration = 0;
+			}
+		} else {
+			const currentSpeed = state.velocity.length();
+			if (currentSpeed > .01) {
+				this.tempDirection.copy(state.velocity).normalize();
+				const velocityDelta = this.BASE_DECELERATION * deltaTime;
+				const newSpeed = Math.max(currentSpeed - velocityDelta, 0);
+				state.velocity.copy(this.tempDirection.multiplyScalar(newSpeed));
+			} else state.velocity.set(0, 0, 0);
+			state.acceleration = -this.BASE_DECELERATION;
+		}
+		this.tempMovement.copy(state.velocity).multiplyScalar(deltaTime);
+		if (input.useTacticalSteps) {
+			this.tempMovement.x = Math.round(this.tempMovement.x / this.STEP_SIZE) * this.STEP_SIZE;
+			this.tempMovement.z = Math.round(this.tempMovement.z / this.STEP_SIZE) * this.STEP_SIZE;
+		}
+		state.position.add(this.tempMovement);
+		if (bounds) {
+			const exceededMinX = state.position.x < bounds.minX;
+			const exceededMaxX = state.position.x > bounds.maxX;
+			const exceededMinZ = state.position.z < bounds.minZ;
+			const exceededMaxZ = state.position.z > bounds.maxZ;
+			state.position.x = Math.max(bounds.minX, Math.min(bounds.maxX, state.position.x));
+			state.position.z = Math.max(bounds.minZ, Math.min(bounds.maxZ, state.position.z));
+			if (exceededMinX || exceededMaxX) state.velocity.x = 0;
+			if (exceededMinZ || exceededMaxZ) state.velocity.z = 0;
+		}
+	}
+	/**
+	* Get speed modifier for a specific trigram stance.
+	*
+	* **Korean**: 자세 속도 배수 가져오기 (Get Stance Speed Modifier)
+	*
+	* @param stance - Eight Trigram stance
+	* @returns Speed multiplier (0.8 to 1.25)
+	*
+	* @korean 자세속도배수
+	*/
+	getStanceSpeedModifier(stance) {
+		return STANCE_SPEED_MODIFIERS[stance];
+	}
+	/**
+	* Calculate movement penalty from leg injury.
+	*
+	* **Korean**: 부상 이동 페널티 (Injury Movement Penalty)
+	*
+	* Leg damage reduces movement speed by 10-50% based on injury severity.
+	*
+	* @param legHealthPercentage - Remaining leg health (0-1)
+	* @returns Injury factor (0 = no injury, 1 = maximum injury)
+	*
+	* @korean 부상페널티
+	*/
+	calculateInjuryPenalty(legHealthPercentage) {
+		return 1 - Math.max(0, Math.min(1, legHealthPercentage));
+	}
+	/**
+	* Get maximum speed for current state configuration.
+	*
+	* **Korean**: 최대 속도 계산 (Calculate Maximum Speed)
+	*
+	* @param isRunning - Whether running (vs walking)
+	* @param stance - Current trigram stance
+	* @param legInjuryFactor - Leg injury severity (0-1)
+	* @returns Maximum speed in m/s (includes arena scaling)
+	*
+	* @korean 최대속도
+	*/
+	getMaxSpeed(isRunning, stance, legInjuryFactor) {
+		const arenaSpeedScale = this._cachedArenaSpeedScale;
+		const baseSpeed = isRunning ? this.BASE_RUN_SPEED : this.BASE_WALK_SPEED;
+		const stanceModifier = this.getStanceSpeedModifier(stance);
+		const injuryPenalty = 1 - legInjuryFactor * .5;
+		return baseSpeed * arenaSpeedScale * stanceModifier * injuryPenalty;
+	}
+	/**
+	* Calculate time required to reach target speed from current velocity.
+	*
+	* **Korean**: 가속 시간 (Acceleration Time)
+	*
+	* @param currentSpeed - Current speed magnitude (m/s)
+	* @param targetSpeed - Desired speed magnitude (m/s)
+	* @returns Time in seconds to reach target speed
+	*
+	* @korean 가속시간
+	*/
+	getAccelerationTime(currentSpeed, targetSpeed) {
+		return Math.abs(targetSpeed - currentSpeed) / this.BASE_ACCELERATION;
+	}
+	/**
+	* Calculate stopping distance from current velocity.
+	*
+	* **Korean**: 제동 거리 (Braking Distance)
+	*
+	* @param currentSpeed - Current speed magnitude (m/s)
+	* @returns Distance in meters required to stop
+	*
+	* @korean 제동거리
+	*/
+	getStoppingDistance(currentSpeed) {
+		return currentSpeed * currentSpeed / (2 * this.BASE_DECELERATION);
+	}
+	/**
+	* Get tactical step size.
+	*
+	* **Korean**: 보법 거리 (Step Distance)
+	*
+	* @returns Step size in meters (0.3m = 30cm)
+	*
+	* @korean 보법거리
+	*/
+	getStepSize() {
+		return this.STEP_SIZE;
+	}
+	/**
+	* Override maximum speed for external speed modifier systems.
+	*
+	* **Korean**: 최대 속도 설정 (Set Maximum Speed)
+	*
+	* Allows external systems (like SpeedModifierSystem) to override
+	* the calculated maximum speed. This is applied in the next
+	* updateMovement call.
+	*
+	* @param speed - Maximum speed in m/s
+	*
+	* @public
+	*/
+	setMaxSpeed(speed) {
+		this._overrideMaxSpeed = speed;
+	}
+	/**
+	* Override acceleration for external speed modifier systems.
+	*
+	* **Korean**: 가속도 설정 (Set Acceleration)
+	*
+	* Allows external systems (like SpeedModifierSystem) to override
+	* the base acceleration rate. This is applied in the next
+	* updateMovement call.
+	*
+	* @param acceleration - Acceleration in m/s²
+	*
+	* @public
+	*/
+	setAcceleration(acceleration) {
+		this._overrideAcceleration = acceleration;
+	}
+	/**
+	* Clear speed and acceleration overrides.
+	*
+	* **Korean**: 속도 재정의 해제 (Clear Speed Overrides)
+	*
+	* Resets movement to use default calculations without external
+	* override values.
+	*
+	* @public
+	*/
+	clearOverrides() {
+		this._overrideMaxSpeed = null;
+		this._overrideAcceleration = null;
+	}
+	/**
+	* Set arena width for arena-aware speed scaling.
+	*
+	* **Korean**: 경기장 너비 설정 (Set Arena Width)
+	*
+	* Updates the arena width used for speed scaling calculations.
+	* Call this when the arena size changes (e.g., screen resize).
+	* Recalculates and caches the arena speed scale.
+	*
+	* @param widthMeters - Arena width in meters (must be positive)
+	* @throws {Error} If widthMeters is not a positive number
+	*
+	* @public
+	*/
+	setArenaWidth(widthMeters) {
+		if (widthMeters <= 0 || !Number.isFinite(widthMeters)) throw new Error(`Arena width must be a positive finite number, got: ${widthMeters}`);
+		this._arenaWidthMeters = widthMeters;
+		this._cachedArenaSpeedScale = this.calculateArenaSpeedScale();
+	}
+	/**
+	* Get current arena width.
+	*
+	* **Korean**: 경기장 너비 가져오기 (Get Arena Width)
+	*
+	* @returns Arena width in meters
+	*
+	* @public
+	*/
+	getArenaWidth() {
+		return this._arenaWidthMeters;
+	}
+	/**
+	* Get current arena speed scale factor.
+	*
+	* **Korean**: 경기장 속도 배수 가져오기 (Get Arena Speed Scale)
+	*
+	* Returns the cached arena speed scale value.
+	*
+	* @returns Arena-based speed multiplier (0.7 to 1.3)
+	*
+	* @public
+	*/
+	getArenaSpeedScale() {
+		return this._cachedArenaSpeedScale;
+	}
+};
+//#endregion
+export { MovementPhysics, STANCE_SPEED_MODIFIERS };
+
+//# sourceMappingURL=MovementPhysics.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MovementPhysics.js","names":[],"sources":["../../../src/systems/physics/MovementPhysics.ts"],"sourcesContent":["/**\n * Physics-based movement system for realistic combat movement.\n *\n * **Korean**: 이동 물리 시스템 (Movement Physics System)\n *\n * This module implements realistic physics-based player movement with proper\n * acceleration/deceleration, foot-wide step precision, and stance-based speed\n * modifiers for authentic Korean martial arts combat feel.\n *\n * ## Features\n *\n * - **Realistic Acceleration**: 0 to 2m/s in 0.5 seconds (4.0 m/s²)\n * - **Realistic Deceleration**: 2m/s to 0 in 0.3 seconds (6.67 m/s²)\n * - **Foot-wide Steps**: Discrete 30cm movement increments for tactical positioning\n * - **Stance Modifiers**: 8 trigram stances with different speed characteristics\n * - **Injury Integration**: Movement speed reduced by leg damage (10-50%)\n *\n * @module systems/physics/MovementPhysics\n * @category Physics System\n * @korean 이동물리\n */\n\nimport { TrigramStance } from \"@/types/common\";\nimport { BASE_MOVEMENT_ACCELERATION } from \"@/types/physicsConstants\";\nimport type { MovementArenaBounds } from \"@/types/PhysicsTypes\";\nimport * as THREE from \"three\";\n\n/**\n * Movement input from keyboard/gamepad controls.\n *\n * **Korean**: 이동 입력 (Movement Input)\n *\n * @public\n * @category Physics System\n * @korean 이동입력\n */\nexport interface MovementInput {\n  /** Forward/backward input (-1 to 1, where 1 is forward) */\n  readonly forward: number;\n  /** Lateral left/right input (-1 to 1, where 1 is right) */\n  readonly lateral: number;\n  /** Whether sprint/run key is held */\n  readonly isRunning: boolean;\n  /** Whether any movement input is active */\n  readonly isMoving: boolean;\n  /** Whether to use tactical step mode (30cm grid) */\n  readonly useTacticalSteps: boolean;\n}\n\n/**\n * Complete movement state for physics calculations.\n *\n * **Korean**: 이동 상태 (Movement State)\n *\n * Contains position, velocity, and current movement parameters.\n * All vectors are mutable for performance (updated in-place during physics loop).\n *\n * @public\n * @category Physics System\n * @korean 이동상태\n */\nexport interface MovementState {\n  /**\n   * Current position in 3D space (meters).\n   *\n   * NOTE: This is a readonly reference to a mutable THREE.Vector3.\n   * The physics engine intentionally mutates the vector in-place\n   * (e.g. via position.add(...)) for performance. The readonly\n   * modifier prevents reassignment of the Vector3 instance, not\n   * mutation of its components.\n   */\n  readonly position: THREE.Vector3;\n  /**\n   * Current velocity vector (m/s).\n   *\n   * NOTE: This is a readonly reference to a mutable THREE.Vector3.\n   * The physics engine updates this vector in-place each frame.\n   * Callers must not reassign the velocity reference, but may pass\n   * it to APIs that read or modify its components.\n   */\n  readonly velocity: THREE.Vector3;\n  /** Current acceleration magnitude (m/s²) */\n  acceleration: number;\n  /** Maximum speed for current state (m/s) */\n  maxSpeed: number;\n  /** Current Eight Trigram stance */\n  readonly currentStance: TrigramStance;\n  /** Leg injury percentage (0-1, where 1 is fully injured) */\n  legInjuryFactor: number;\n}\n\n/**\n * Stance-based speed modifiers for Eight Trigram system.\n *\n * **Korean**: 팔괘 속도 배수 (Eight Trigram Speed Multipliers)\n *\n * Each trigram stance has unique movement characteristics based on\n * traditional Korean martial arts philosophy:\n *\n * - ☰ 건 (Geon/Heaven): 100% - Balanced, standard speed\n * - ☱ 태 (Tae/Lake): 110% - Fluid movement, flowing techniques\n * - ☲ 리 (Li/Fire): 120% - Aggressive, fast attacks\n * - ☳ 진 (Jin/Thunder): 115% - Explosive power\n * - ☴ 손 (Son/Wind): 125% - Continuous motion, fastest stance\n * - ☵ 감 (Gam/Water): 105% - Adaptive, slightly faster than neutral\n * - ☶ 간 (Gan/Mountain): 80% - Solid defense, slower movement\n * - ☷ 곤 (Gon/Earth): 85% - Grounded, stable but slower\n *\n * @korean 자세속도배수\n */\nexport const STANCE_SPEED_MODIFIERS: Record<TrigramStance, number> = {\n  [TrigramStance.GEON]: 1.0, // Heaven: balanced\n  [TrigramStance.TAE]: 1.1, // Lake: fluid\n  [TrigramStance.LI]: 1.2, // Fire: aggressive\n  [TrigramStance.JIN]: 1.15, // Thunder: explosive\n  [TrigramStance.SON]: 1.25, // Wind: fastest\n  [TrigramStance.GAM]: 1.05, // Water: adaptive\n  [TrigramStance.GAN]: 0.8, // Mountain: defensive\n  [TrigramStance.GON]: 0.85, // Earth: grounded\n};\n\n/**\n * Physics-based movement engine for combat.\n *\n * **Korean**: 이동 물리 엔진 (Movement Physics Engine)\n *\n * Implements realistic acceleration, deceleration, and stance-based movement\n * for authentic Korean martial arts combat. Supports both continuous movement\n * and tactical foot-wide steps for precise positioning.\n *\n * @example\n * ```typescript\n * const physics = new MovementPhysics();\n *\n * const state: MovementState = {\n *   position: new THREE.Vector3(0, 0, 0),\n *   velocity: new THREE.Vector3(0, 0, 0),\n *   acceleration: 0,\n *   maxSpeed: 2.0,\n *   currentStance: TrigramStance.GEON,\n *   legInjuryFactor: 0,\n * };\n *\n * const input: MovementInput = {\n *   forward: 1.0,\n *   lateral: 0,\n *   isRunning: false,\n *   isMoving: true,\n *   useTacticalSteps: false,\n * };\n *\n * // In game loop at 60fps\n * physics.updateMovement(state, input, deltaTime);\n * ```\n *\n * @public\n * @category Physics System\n * @korean 이동물리엔진\n */\nexport class MovementPhysics {\n  /**\n   * Base acceleration rate (m/s²)\n   * Achieves 0 to 6m/s in 0.2 seconds (instant-response combat movement)\n   * Increased from 12.0 to 30.0 for arcade-style responsiveness\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   * Base deceleration rate (m/s²)\n   * Achieves 6m/s to 0 in 0.3 seconds (responsive combat stopping)\n   *\n   * **Korean**: 기본 감속도 (Base Deceleration)\n   */\n  private readonly BASE_DECELERATION = 20.0;\n\n  /**\n   * Foot-wide step size (meters)\n   * Standard Korean martial arts step is approximately 30cm\n   *\n   * **Korean**: 보법 거리 (Step Distance)\n   */\n  private readonly STEP_SIZE = 0.3;\n\n  /**\n   * Base walking speed (m/s)\n   * Optimized for responsive combat movement - crosses 14m arena in ~2.3s\n   *\n   * **Korean**: 기본 걷기 속도 (Base Walking Speed)\n   */\n  private readonly BASE_WALK_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_RUN_SPEED = 10.0;\n\n  /**\n   * Reference arena size for speed calibration (meters).\n   * All speeds are calibrated for a 10m arena.\n   *\n   * **Korean**: 기준 경기장 크기 (Reference Arena Size)\n   */\n  private readonly REFERENCE_ARENA_SIZE = 10.0;\n\n  /**\n   * Current arena width in meters for arena-aware speed scaling.\n   *\n   * **Korean**: 현재 경기장 너비 (Current Arena Width)\n   */\n  private _arenaWidthMeters: number = 10.0;\n\n  // LATERAL_SPEED removed - now using state.maxSpeed for all directions\n  // This ensures speed override applies to lateral movement too\n\n  /**\n   * Override for max speed from external speed modifier systems.\n   *\n   * **Korean**: 최대속도 재정의 (Max Speed Override)\n   */\n  private _overrideMaxSpeed: number | null = null;\n\n  /**\n   * Override for acceleration from external speed modifier systems.\n   *\n   * **Korean**: 가속도 재정의 (Acceleration Override)\n   */\n  private _overrideAcceleration: number | null = null;\n\n  /**\n   * Cached arena speed scale to avoid repeated calculations.\n   *\n   * **Korean**: 캐시된 경기장 속도 배수 (Cached Arena Speed Scale)\n   */\n  private _cachedArenaSpeedScale: number = 1.0;\n\n  // Temporary vectors to avoid allocations in update loop\n  private readonly tempTargetVelocity = new THREE.Vector3();\n  private readonly tempMovement = new THREE.Vector3();\n  private readonly tempDirection = new THREE.Vector3();\n  private readonly tempTargetDirection = new THREE.Vector3();\n\n  /**\n   * Create a new MovementPhysics instance.\n   *\n   * **Korean**: 이동 물리 생성 (Create Movement Physics)\n   *\n   * @param arenaWidthMeters - Width of the arena in meters (default: 10m, min: 1m)\n   * @throws {Error} If arenaWidthMeters is not a positive number\n   *\n   * @example\n   * ```typescript\n   * // Default 10m arena (1.0x speed scale)\n   * const physics = new MovementPhysics();\n   *\n   * // Small 6m arena (0.7x speed scale)\n   * const smallPhysics = new MovementPhysics(6.0);\n   *\n   * // Large 14m arena (1.3x speed scale)\n   * const largePhysics = new MovementPhysics(14.0);\n   * ```\n   *\n   * @public\n   */\n  constructor(arenaWidthMeters: number = 10.0) {\n    if (arenaWidthMeters <= 0 || !Number.isFinite(arenaWidthMeters)) {\n      throw new Error(\n        `Arena width must be a positive finite number, got: ${arenaWidthMeters}`,\n      );\n    }\n    this._arenaWidthMeters = arenaWidthMeters;\n    this._cachedArenaSpeedScale = this.calculateArenaSpeedScale();\n  }\n\n  /**\n   * Calculate arena-aware speed scaling factor.\n   *\n   * **Korean**: 경기장 크기 기반 속도 배수 (Arena-Based Speed Multiplier)\n   *\n   * Scales movement speed proportionally to arena size to maintain consistent\n   * gameplay feel across different screen resolutions. Smaller arenas get\n   * slightly slower speeds, larger arenas get slightly faster speeds.\n   *\n   * Formula: scaleFactor = arenaWidth / referenceArenaSize\n   * Clamped to [0.7, 1.3] range for balanced gameplay\n   *\n   * Examples:\n   * - 6m arena: 0.7x speed (70% of base)\n   * - 10m arena: 1.0x speed (baseline)\n   * - 14m arena: 1.3x speed (130% of base)\n   *\n   * @returns Speed multiplier (0.7 to 1.3)\n   *\n   * @korean 경기장속도배수\n   */\n  private calculateArenaSpeedScale(): number {\n    const rawScale = this._arenaWidthMeters / this.REFERENCE_ARENA_SIZE;\n    // Clamp to reasonable range to maintain gameplay balance\n    return Math.max(0.7, Math.min(1.3, rawScale));\n  }\n\n  /**\n   * Update player movement based on input and physics.\n   *\n   * **Korean**: 이동 업데이트 (Update Movement)\n   *\n   * Called every frame (60fps) to update player position based on\n   * current velocity, acceleration, and input. Applies stance modifiers\n   * and injury penalties automatically.\n   *\n   * @param state - Current movement state (modified in-place)\n   * @param input - Current movement input from controls\n   * @param deltaTime - Time since last update (seconds)\n   * @param bounds - Optional arena bounds for clamping position (meters)\n   *\n   * @korean 이동업데이트\n   */\n  public updateMovement(\n    state: MovementState,\n    input: MovementInput,\n    deltaTime: number,\n    bounds?: MovementArenaBounds,\n  ): void {\n    // Use cached arena-aware speed scaling\n    const arenaSpeedScale = this._cachedArenaSpeedScale;\n\n    // Calculate stance speed modifier\n    const stanceModifier = this.getStanceSpeedModifier(state.currentStance);\n\n    // Calculate injury penalty (0-50% speed reduction)\n    const injuryPenalty = 1.0 - state.legInjuryFactor * 0.5;\n\n    // Calculate base target speed (walking or running)\n    const baseSpeed = input.isRunning\n      ? this.BASE_RUN_SPEED\n      : this.BASE_WALK_SPEED;\n\n    // Apply all modifiers including arena scaling to get final max speed (or use override)\n    state.maxSpeed =\n      this._overrideMaxSpeed ??\n      baseSpeed * arenaSpeedScale * stanceModifier * injuryPenalty;\n\n    // Use override acceleration if set, otherwise use base\n    const currentAcceleration =\n      this._overrideAcceleration ?? this.BASE_ACCELERATION;\n\n    // Calculate target velocity based on input direction\n    // forward > 0 = moving in positive Z direction (toward bottom of screen)\n    // forward < 0 = moving in negative Z direction (toward top of screen)\n    // ✅ REMOVED backward multiplier: All directions use full speed for responsive gameplay\n    // The backward penalty should be applied contextually by the combat system\n    // based on player facing direction vs movement direction\n    // ✅ FIX: Both lateral and forward now use state.maxSpeed (which includes all modifiers)\n    // This ensures consistent speed in all movement directions and includes arena scaling\n    this.tempTargetVelocity.set(\n      input.lateral * state.maxSpeed,\n      0,\n      input.forward * state.maxSpeed,\n    );\n\n    // Apply acceleration or deceleration\n    if (input.isMoving) {\n      // Accelerate toward target velocity with realistic direction changes\n      const currentSpeed = state.velocity.length();\n      const targetSpeed = this.tempTargetVelocity.length();\n\n      if (currentSpeed < targetSpeed) {\n        // Check if direction change is needed\n        if (currentSpeed > 0.001 && targetSpeed > 0.001) {\n          // Current movement direction\n          this.tempDirection.copy(state.velocity).normalize();\n          // Desired movement direction (reuse temp vector to avoid allocation)\n          this.tempTargetDirection.copy(this.tempTargetVelocity).normalize();\n          const directionDot = this.tempDirection.dot(this.tempTargetDirection);\n\n          if (directionDot < 0) {\n            // Moving in opposite direction: decelerate first before reversing\n            const velocityDelta = this.BASE_DECELERATION * deltaTime;\n            const newSpeed = Math.max(currentSpeed - velocityDelta, 0);\n\n            if (newSpeed > 0.001) {\n              state.velocity.copy(this.tempDirection.multiplyScalar(newSpeed));\n            } else {\n              // Fully stopped; can now start accelerating in new direction\n              state.velocity.set(0, 0, 0);\n            }\n            state.acceleration = -this.BASE_DECELERATION;\n          } else if (directionDot < 0.7) {\n            // Perpendicular direction change (e.g., forward to strafe): moderate deceleration\n            const blendedAccel = currentAcceleration * 0.6; // Reduced acceleration for sharp turns\n            const velocityDelta = blendedAccel * deltaTime;\n            const newSpeed = Math.min(\n              currentSpeed + velocityDelta,\n              targetSpeed,\n            );\n            this.tempDirection.copy(this.tempTargetVelocity).normalize();\n            state.velocity.copy(this.tempDirection.multiplyScalar(newSpeed));\n            state.acceleration = blendedAccel;\n          } else {\n            // Same or similar direction: full acceleration\n            this.tempDirection.copy(this.tempTargetVelocity).normalize();\n            const velocityDelta = currentAcceleration * deltaTime;\n            const newSpeed = Math.min(\n              currentSpeed + velocityDelta,\n              targetSpeed,\n            );\n            state.velocity.copy(this.tempDirection.multiplyScalar(newSpeed));\n            state.acceleration = currentAcceleration;\n          }\n        } else {\n          // Very low speed: safe to accelerate directly toward target\n          this.tempDirection.copy(this.tempTargetVelocity).normalize();\n          const velocityDelta = currentAcceleration * deltaTime;\n          const newSpeed = Math.min(currentSpeed + velocityDelta, targetSpeed);\n          state.velocity.copy(this.tempDirection.multiplyScalar(newSpeed));\n          state.acceleration = currentAcceleration;\n        }\n      } else {\n        // Already at or above target speed: snap to target velocity\n        state.velocity.copy(this.tempTargetVelocity);\n        state.acceleration = 0;\n      }\n    } else {\n      // Decelerate to stop\n      const currentSpeed = state.velocity.length();\n      if (currentSpeed > 0.01) {\n        this.tempDirection.copy(state.velocity).normalize();\n        const velocityDelta = this.BASE_DECELERATION * deltaTime;\n        const newSpeed = Math.max(currentSpeed - velocityDelta, 0);\n        state.velocity.copy(this.tempDirection.multiplyScalar(newSpeed));\n      } else {\n        state.velocity.set(0, 0, 0);\n      }\n      state.acceleration = -this.BASE_DECELERATION;\n    }\n\n    // Calculate movement delta for this frame\n    this.tempMovement.copy(state.velocity).multiplyScalar(deltaTime);\n\n    // Apply tactical step quantization if enabled\n    if (input.useTacticalSteps) {\n      // Quantize to 30cm grid steps\n      this.tempMovement.x =\n        Math.round(this.tempMovement.x / this.STEP_SIZE) * this.STEP_SIZE;\n      this.tempMovement.z =\n        Math.round(this.tempMovement.z / this.STEP_SIZE) * this.STEP_SIZE;\n    }\n\n    // Update position\n    state.position.add(this.tempMovement);\n\n    // Apply arena bounds clamping if bounds provided\n    if (bounds) {\n      // Check if position exceeded boundaries\n      const exceededMinX = state.position.x < bounds.minX;\n      const exceededMaxX = state.position.x > bounds.maxX;\n      const exceededMinZ = state.position.z < bounds.minZ;\n      const exceededMaxZ = state.position.z > bounds.maxZ;\n\n      // Clamp position to arena boundaries\n      state.position.x = Math.max(bounds.minX, Math.min(bounds.maxX, state.position.x));\n      state.position.z = Math.max(bounds.minZ, Math.min(bounds.maxZ, state.position.z));\n\n      // Zero velocity component if exceeded boundary (smooth stopping)\n      if (exceededMinX || exceededMaxX) {\n        state.velocity.x = 0;\n      }\n      if (exceededMinZ || exceededMaxZ) {\n        state.velocity.z = 0;\n      }\n    }\n  }\n\n  /**\n   * Get speed modifier for a specific trigram stance.\n   *\n   * **Korean**: 자세 속도 배수 가져오기 (Get Stance Speed Modifier)\n   *\n   * @param stance - Eight Trigram stance\n   * @returns Speed multiplier (0.8 to 1.25)\n   *\n   * @korean 자세속도배수\n   */\n  public getStanceSpeedModifier(stance: TrigramStance): number {\n    return STANCE_SPEED_MODIFIERS[stance];\n  }\n\n  /**\n   * Calculate movement penalty from leg injury.\n   *\n   * **Korean**: 부상 이동 페널티 (Injury Movement Penalty)\n   *\n   * Leg damage reduces movement speed by 10-50% based on injury severity.\n   *\n   * @param legHealthPercentage - Remaining leg health (0-1)\n   * @returns Injury factor (0 = no injury, 1 = maximum injury)\n   *\n   * @korean 부상페널티\n   */\n  public calculateInjuryPenalty(legHealthPercentage: number): number {\n    // Injury penalty scales from 0% (healthy) to 50% (critical)\n    // Clamp between 0 and 1\n    const healthFactor = Math.max(0, Math.min(1, legHealthPercentage));\n    return 1.0 - healthFactor;\n  }\n\n  /**\n   * Get maximum speed for current state configuration.\n   *\n   * **Korean**: 최대 속도 계산 (Calculate Maximum Speed)\n   *\n   * @param isRunning - Whether running (vs walking)\n   * @param stance - Current trigram stance\n   * @param legInjuryFactor - Leg injury severity (0-1)\n   * @returns Maximum speed in m/s (includes arena scaling)\n   *\n   * @korean 최대속도\n   */\n  public getMaxSpeed(\n    isRunning: boolean,\n    stance: TrigramStance,\n    legInjuryFactor: number,\n  ): number {\n    const arenaSpeedScale = this._cachedArenaSpeedScale;\n    const baseSpeed = isRunning ? this.BASE_RUN_SPEED : this.BASE_WALK_SPEED;\n    const stanceModifier = this.getStanceSpeedModifier(stance);\n    const injuryPenalty = 1.0 - legInjuryFactor * 0.5;\n    return baseSpeed * arenaSpeedScale * stanceModifier * injuryPenalty;\n  }\n\n  /**\n   * Calculate time required to reach target speed from current velocity.\n   *\n   * **Korean**: 가속 시간 (Acceleration Time)\n   *\n   * @param currentSpeed - Current speed magnitude (m/s)\n   * @param targetSpeed - Desired speed magnitude (m/s)\n   * @returns Time in seconds to reach target speed\n   *\n   * @korean 가속시간\n   */\n  public getAccelerationTime(\n    currentSpeed: number,\n    targetSpeed: number,\n  ): number {\n    const speedDiff = Math.abs(targetSpeed - currentSpeed);\n    return speedDiff / this.BASE_ACCELERATION;\n  }\n\n  /**\n   * Calculate stopping distance from current velocity.\n   *\n   * **Korean**: 제동 거리 (Braking Distance)\n   *\n   * @param currentSpeed - Current speed magnitude (m/s)\n   * @returns Distance in meters required to stop\n   *\n   * @korean 제동거리\n   */\n  public getStoppingDistance(currentSpeed: number): number {\n    // Using kinematic equation: d = v² / (2a)\n    return (currentSpeed * currentSpeed) / (2 * this.BASE_DECELERATION);\n  }\n\n  /**\n   * Get tactical step size.\n   *\n   * **Korean**: 보법 거리 (Step Distance)\n   *\n   * @returns Step size in meters (0.3m = 30cm)\n   *\n   * @korean 보법거리\n   */\n  public getStepSize(): number {\n    return this.STEP_SIZE;\n  }\n\n  /**\n   * Override maximum speed for external speed modifier systems.\n   *\n   * **Korean**: 최대 속도 설정 (Set Maximum Speed)\n   *\n   * Allows external systems (like SpeedModifierSystem) to override\n   * the calculated maximum speed. This is applied in the next\n   * updateMovement call.\n   *\n   * @param speed - Maximum speed in m/s\n   *\n   * @public\n   */\n  public setMaxSpeed(speed: number): void {\n    this._overrideMaxSpeed = speed;\n  }\n\n  /**\n   * Override acceleration for external speed modifier systems.\n   *\n   * **Korean**: 가속도 설정 (Set Acceleration)\n   *\n   * Allows external systems (like SpeedModifierSystem) to override\n   * the base acceleration rate. This is applied in the next\n   * updateMovement call.\n   *\n   * @param acceleration - Acceleration in m/s²\n   *\n   * @public\n   */\n  public setAcceleration(acceleration: number): void {\n    this._overrideAcceleration = acceleration;\n  }\n\n  /**\n   * Clear speed and acceleration overrides.\n   *\n   * **Korean**: 속도 재정의 해제 (Clear Speed Overrides)\n   *\n   * Resets movement to use default calculations without external\n   * override values.\n   *\n   * @public\n   */\n  public clearOverrides(): void {\n    this._overrideMaxSpeed = null;\n    this._overrideAcceleration = null;\n  }\n\n  /**\n   * Set arena width for arena-aware speed scaling.\n   *\n   * **Korean**: 경기장 너비 설정 (Set Arena Width)\n   *\n   * Updates the arena width used for speed scaling calculations.\n   * Call this when the arena size changes (e.g., screen resize).\n   * Recalculates and caches the arena speed scale.\n   *\n   * @param widthMeters - Arena width in meters (must be positive)\n   * @throws {Error} If widthMeters is not a positive number\n   *\n   * @public\n   */\n  public setArenaWidth(widthMeters: number): void {\n    if (widthMeters <= 0 || !Number.isFinite(widthMeters)) {\n      throw new Error(\n        `Arena width must be a positive finite number, got: ${widthMeters}`,\n      );\n    }\n    this._arenaWidthMeters = widthMeters;\n    this._cachedArenaSpeedScale = this.calculateArenaSpeedScale();\n  }\n\n  /**\n   * Get current arena width.\n   *\n   * **Korean**: 경기장 너비 가져오기 (Get Arena Width)\n   *\n   * @returns Arena width in meters\n   *\n   * @public\n   */\n  public getArenaWidth(): number {\n    return this._arenaWidthMeters;\n  }\n\n  /**\n   * Get current arena speed scale factor.\n   *\n   * **Korean**: 경기장 속도 배수 가져오기 (Get Arena Speed Scale)\n   *\n   * Returns the cached arena speed scale value.\n   *\n   * @returns Arena-based speed multiplier (0.7 to 1.3)\n   *\n   * @public\n   */\n  public getArenaSpeedScale(): number {\n    return this._cachedArenaSpeedScale;\n  }\n}\n"],"mappings":"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"}