Update game.js

game.js

@@ -19,7 +19,7 @@ const GAME_CONSTANTS = {
     ENEMY_COUNT: 4,
     MISSILE_COUNT: 6,
     AMMO_COUNT: 940,  // 940발로 변경
-    BULLET_DAMAGE: 50, // 발당 25 데미지
+    BULLET_DAMAGE: 50, // 발당 50 데미지
     MAX_HEALTH: 1000  // 체력 1000
 };
 
@@ -311,427 +311,489 @@ class Fighter {
             this.targetYaw += deltaTime * 1.2;
         }
     }
+  updatePhysics(deltaTime) {
+       if (!this.mesh) return;
+       
+       // 부드러운 회전 보간
+       const rotationSpeed = deltaTime * 2.0;
+       const yawRotationSpeed = deltaTime * 3.0;
+       
+       // 피치와 롤은 직접 보간
+       this.rotation.x = THREE.MathUtils.lerp(this.rotation.x, this.targetPitch, rotationSpeed);
+       this.rotation.z = THREE.MathUtils.lerp(this.rotation.z, this.targetRoll, rotationSpeed * 1.5);
+       
+       // Yaw 보간 (최단 경로)
+       let yawDiff = this.normalizeAngle(this.targetYaw - this.rotation.y);
+       this.rotation.y += yawDiff * yawRotationSpeed;
+       
+       // rotation.y를 -π ~ π 범위로 유지
+       this.rotation.y = this.normalizeAngle(this.rotation.y);
+       this.targetYaw = this.normalizeAngle(this.targetYaw);
+       
+       // 롤 자동 복귀 시스템
+       if (Math.abs(yawDiff) < 0.05) {
+           // 요 회전이 거의 없을 때 롤을 0으로 복귀
+           this.targetRoll *= 0.95;
+       }
+       
+       // 워썬더 스타일: 요 회전이 주도적, 롤은 보조적
+       let bankTurnRate = 0;
+       if (Math.abs(this.rotation.z) > 0.3) { // 롤이 충분히 클 때만
+           const bankAngle = this.rotation.z;
+           bankTurnRate = Math.sin(bankAngle) * deltaTime * 0.1; // 매우 작은 선회율
+           this.targetYaw += bankTurnRate;
+       }
+       
+       // 현실적인 속도 계산
+       const minSpeed = 0; // 최소 속도 0kt
+       const maxSpeed = 600; // 최대 속도 600kt
+       let targetSpeed = minSpeed + (maxSpeed - minSpeed) * this.throttle;
+       
+       // 피치 각도에 따른 속도 변화
+       const pitchAngle = this.rotation.x;
+       const pitchDegrees = Math.abs(pitchAngle) * (180 / Math.PI);
+       
+       // 기수가 위를 향하고 있을 경우 빠른 속도 감소
+       if (pitchAngle < -0.1 && !this.stallWarning) { // 스톨이 아닐 때만 상승으로 인한 감속
+           const climbFactor = Math.abs(pitchAngle) / (Math.PI / 2); // 90도 기준
+           if (pitchDegrees > 30) { // 30도 이상일 때 급격한 감속
+               targetSpeed *= Math.max(0, 1 - climbFactor * 1.5); // 최대 150% 감속 (0kt까지)
+           } else {
+               targetSpeed *= (1 - climbFactor * 0.3); // 정상적인 감속
+           }
+       } else if (pitchAngle > 0.1) { // 기수가 아래로 (하강) - 스톨 상태에서도 적용
+           const diveFactor = pitchAngle / (Math.PI / 3);
+           targetSpeed *= (1 + diveFactor * 0.4); // 하강 시 가속 증가 (0.2 -> 0.4)
+       }
+       
+       // G-Force 계산 개선
+       const turnRate = Math.abs(bankTurnRate) * 100;
+       const pitchRate = Math.abs(this.rotation.x - this.targetPitch) * 10;
+       
+       // 고도에 따른 G-Force 증가 배율 계산
+       const altitudeInKm = this.position.y / 1000; // 미터를 킬로미터로 변환
+       const altitudeMultiplier = 1 + (altitudeInKm * 0.2); // 1km당 20% 증가
+       
+       // 스로틀에 따른 G-Force 증가 배율 계산
+       // THR 50% 이하: 0배, THR 75%: 0.5배, THR 100%: 1.0배
+       let throttleGMultiplier = 0;
+       if (this.throttle > 0.5) {
+           // 0.5 ~ 1.0 범위를 0 ~ 1.0으로 매핑
+           throttleGMultiplier = (this.throttle - 0.5) * 2.0;
+       }
+       
+       // 비정상적인 자세에 의한 G-Force 추가
+       let abnormalG = 0;
+       
+       // 뒤집힌 상태 (롤이 90도 이상)
+       const isInverted = Math.abs(this.rotation.z) > Math.PI / 2;
+       if (isInverted) {
+           const baseG = 3.0 + Math.abs(Math.abs(this.rotation.z) - Math.PI / 2) * 2;
+           abnormalG += baseG * altitudeMultiplier * (1 + throttleGMultiplier); // 스로틀 배율 추가
+       }
+       
+       // 롤이 ±30도 이상일 때 추가 G-Force
+       const rollDegrees = Math.abs(this.rotation.z) * (180 / Math.PI);
+       if (rollDegrees > 30) {
+           // 30도 초과분당 0.1G 추가
+           const extremeRollG = (rollDegrees - 30) * 0.1;
+           abnormalG += extremeRollG * altitudeMultiplier * (1 + throttleGMultiplier);
+       }
+       
+       // 피치 각도가 ±40도 이상일 때 추가 G-Force
+       if (pitchDegrees >= 40) {
+           // 40도 이상일 때 급격한 G-Force 증가
+           const extremePitchG = (pitchDegrees - 40) * 0.15; // 40도 초과분당 0.15G 추가
+           abnormalG += extremePitchG * altitudeMultiplier * (1 + throttleGMultiplier);
+       }
+       
+       // 기수가 계속 위를 향하고 있는 경우 (피치가 -30도 이하)
+       if (pitchAngle < -Math.PI / 6) {
+           const baseG = 2.0 + Math.abs(pitchAngle + Math.PI / 6) * 3;
+           abnormalG += baseG * altitudeMultiplier * (1 + throttleGMultiplier); // 스로틀 배율 추가
+       }
+       
+       // 기수가 과도하게 아래를 향하고 있는 경우 (피치가 60도 이상)
+       if (pitchAngle > Math.PI / 3) {
+           const baseG = 2.0 + Math.abs(pitchAngle - Math.PI / 3) * 3;
+           abnormalG += baseG * altitudeMultiplier * (1 + throttleGMultiplier); // 스로틀 배율 추가
+       }
+       
+       // 급격한 기동에 의한 G-Force
+       const maneuverG = (turnRate + pitchRate + (Math.abs(this.rotation.z) * 3)) * (1 + throttleGMultiplier * 0.5);
+       
+       // 총 G-Force 계산
+       this.gForce = 1.0 + maneuverG + abnormalG;
+       
+       // G-Force 회복 조건 수정
+       // 1. Over-G 상태가 아닌 경우에만 회복
+       // 2. 피치가 ±10도 이내일 때만 회복
+       // 3. 스톨 상태가 아닐 때만 회복
+       const isPitchNeutral = Math.abs(pitchDegrees) <= 10;
+       
+       if (!this.overG && isPitchNeutral && !isInverted && !this.stallWarning) {
+           // 스로틀이 높을수록 G-Force가 천천히 감소
+           const recoveryRate = 2.0 - throttleGMultiplier * 1.5; // THR 100%일 때 0.5, THR 50%일 때 2.0
+           this.gForce = THREE.MathUtils.lerp(this.gForce, 1.0 + maneuverG, deltaTime * recoveryRate);
+       } else if (this.overG) {
+           // Over-G 상태에서는 피치가 0도 근처(±10도)가 되고 스톨이 회복될 때까지 회복하지 않음
+           if (!isPitchNeutral || this.stallWarning) {
+               // 피치가 중립이 아니거나 스톨 상태면 G-Force 유지 또는 증가만 가능
+               this.gForce = Math.max(this.gForce, 1.0 + maneuverG + abnormalG);
+           } else {
+               // 피치가 중립이고 스톨이 아닐 때만 매우 천천히 회복
+               const overGRecoveryRate = 0.3 - throttleGMultiplier * 0.2; // Over-G 상태에서는 더 느린 회복
+               this.gForce = THREE.MathUtils.lerp(this.gForce, 1.0 + maneuverG, deltaTime * overGRecoveryRate);
+           }
+       }
+       
+       // 스톨 상태에서는 Over-G가 감소하지 않도록 추가 처리
+       if (this.stallWarning && this.overG) {
+           // 스톨 중에는 G-Force를 9.0 이상으로 유지
+           this.gForce = Math.max(this.gForce, 9.0);
+       }
+       
+       this.overG = this.gForce > this.maxGForce;
+       
+       // Over-G 타이머 업데이트
+       if (this.overG) {
+           this.overGTimer += deltaTime;
+           
+           // 1.5초 이상 Over-G 상태일 경우 시야 흐림 시작
+           if (this.overGTimer > 1.5) {
+               // 속도 급격히 감소 (2.5초부터)
+               if (this.overGTimer > 2.5) {
+                   targetSpeed *= Math.max(0.3, 1 - (this.overGTimer - 2.5) * 0.3);
+               }
+               // 시야 흐림 효과는 UI에서 처리 (1.5초부터)
+           }
+       } else {
+           this.overGTimer = 0; // Over-G 상태가 아니면 타이머 리셋
+       }
+       
+       // 스톨 경고: 300kt 이하에서 스톨 위험
+       const speedKnots = this.speed * 1.94384; // m/s to knots
+       const wasStalling = this.stallWarning;
+       
+       // 스톨 진입 조건
+       if (!this.stallWarning && speedKnots < GAME_CONSTANTS.STALL_SPEED) {
+           this.stallWarning = true;
+           this.stallEscapeProgress = 0; // 스톨 진입 시 진행도 초기화
+       }
+       
+       // 스톨 탈출 조건
+       if (this.stallWarning) {
+           if (this.escapeKeyPressed) {
+               // F키를 누르고 있으면 진행도 증가
+               this.stallEscapeProgress += deltaTime;
+               
+               // 2초 이상 누르면 스톨에서 탈출
+               if (this.stallEscapeProgress >= 2.0 && speedKnots >= 350) {
+                   this.stallWarning = false;
+                   this.stallEscapeProgress = 0;
+                   // 스톨에서 벗어나면 자세를 약간 안정화
+                   this.targetPitch = Math.max(-0.2, Math.min(0.2, this.targetPitch));
+               }
+           } else {
+               // F키를 놓으면 진행도 감소
+               this.stallEscapeProgress = Math.max(0, this.stallEscapeProgress - deltaTime * 2);
+           }
+       }
+       
+       // 속도 변화 적용
+       if (this.stallWarning) {
+           // 스톨 상태에서의 속도 변화
+           if (pitchAngle > 0.1) { // 기수가 아래를 향할 때
+               // 다이빙으로 인한 속도 증가
+               const diveSpeedGain = Math.min(pitchAngle * 300, 200); // 최대 200m/s 증가
+               this.speed = Math.min(maxSpeed, this.speed + diveSpeedGain * deltaTime);
+           } else {
+               // 기수가 위를 향하거나 수평일 때는 속도 감소
+               this.speed = Math.max(0, this.speed - deltaTime * 100);
+           }
+       } else {
+           // 정상 비행 시 속도 변화
+           this.speed = THREE.MathUtils.lerp(this.speed, targetSpeed, deltaTime * 0.5);
+       }
+       
+       // 스톨 상태에서의 물리 효과
+       if (this.stallWarning) {
+           // 바닥으로 추락하며 가속도가 빠르게 붙음
+           this.targetPitch = Math.min(Math.PI / 2.5, this.targetPitch + deltaTime * 2.5); // 기수가 더 극단적으로 아래로 (72도까지)
+           
+           // 조종 불능 상태 - 더 심한 흔들림
+           this.rotation.x += (Math.random() - 0.5) * deltaTime * 0.8;
+           this.rotation.z += (Math.random() - 0.5) * deltaTime * 0.8;
+           
+           // 중력에 의한 가속
+           const gravityAcceleration = GAME_CONSTANTS.GRAVITY * deltaTime * 3.0; // 3배 중력
+           this.velocity.y -= gravityAcceleration;
+       }
+    // 속도 벡터 계산 - 쿼터니언을 사용하여 짐벌 락 완전 회피
+       const noseDirection = new THREE.Vector3(0, 0, 1);
+       
+       // 쿼터니언 기반 회전 시스템
+       const quaternion = new THREE.Quaternion();
+       
+       // 각 축의 회전을 개별 쿼터니언으로 생성
+       const pitchQuat = new THREE.Quaternion();
+       const yawQuat = new THREE.Quaternion();
+       const rollQuat = new THREE.Quaternion();
+       
+       // 축 벡터 정의
+       const xAxis = new THREE.Vector3(1, 0, 0);
+       const yAxis = new THREE.Vector3(0, 1, 0);
+       const zAxis = new THREE.Vector3(0, 0, 1);
+       
+       // 각 축에 대한 회전 설정
+       pitchQuat.setFromAxisAngle(xAxis, this.rotation.x);
+       yawQuat.setFromAxisAngle(yAxis, this.rotation.y);
+       rollQuat.setFromAxisAngle(zAxis, this.rotation.z);
+       
+       // 쿼터니언 합성 (항공기 표준 순서: Yaw -> Pitch -> Roll)
+       quaternion.multiply(yawQuat);
+       quaternion.multiply(pitchQuat);
+       quaternion.multiply(rollQuat);
+       
+       // 방향 벡터에 회전 적용
+       noseDirection.applyQuaternion(quaternion);
+       
+       if (!this.stallWarning) {
+           // 정상 비행 시
+           this.velocity = noseDirection.multiplyScalar(this.speed);
+       } else {
+           // 스톨 시에는 중력이 주도적이지만 다이빙 속도도 반영
+           this.velocity.x = noseDirection.x * this.speed * 0.5; // 전방 속도 증가
+           this.velocity.z = noseDirection.z * this.speed * 0.5;
+           // y 속도는 위에서 중력으로 처리됨
+       }
+       
+       // 정상 비행 시 중력 효과
+       if (!this.stallWarning) {
+           const gravityEffect = GAME_CONSTANTS.GRAVITY * deltaTime * 0.15;
+           this.velocity.y -= gravityEffect;
+           
+           // 양력 효과 (속도에 비례)
+           const liftFactor = (this.speed / maxSpeed) * 0.8;
+           const lift = gravityEffect * liftFactor;
+           this.velocity.y += lift;
+       }
+       
+       // 위치 업데이트
+       this.position.add(this.velocity.clone().multiplyScalar(deltaTime));
+       
+       // 지면 충돌
+       if (this.position.y <= GAME_CONSTANTS.MIN_ALTITUDE) {
+           this.position.y = GAME_CONSTANTS.MIN_ALTITUDE;
+           this.health = 0;
+           
+           // 지면 충돌 시 폭발 효과 추가
+           if (window.gameInstance) {
+               window.gameInstance.createExplosionEffect(this.position);
+           }
+           
+           return;
+       }
+       
+       // 최대 고도 제한
+       if (this.position.y > GAME_CONSTANTS.MAX_ALTITUDE) {
+           this.position.y = GAME_CONSTANTS.MAX_ALTITUDE;
+           this.altitudeWarning = true;
+           if (this.velocity.y > 0) this.velocity.y = 0;
+       } else {
+           this.altitudeWarning = false;
+       }
+       
+       // 맵 경계 처리
+       const mapLimit = GAME_CONSTANTS.MAP_SIZE / 2;
+       if (this.position.x > mapLimit) this.position.x = -mapLimit;
+       if (this.position.x < -mapLimit) this.position.x = mapLimit;
+       if (this.position.z > mapLimit) this.position.z = -mapLimit;
+       if (this.position.z < -mapLimit) this.position.z = mapLimit;
+       
+       // 메시 위치 및 회전 업데이트 - 쿼터니언 사용
+       this.mesh.position.copy(this.position);
+       
+       // 메시 회전을 쿼터니언으로 설정
+       const meshQuaternion = new THREE.Quaternion();
+       
+       // Y축 회전에 3π/2 추가 (모델 오프셋)
+       const meshPitchQuat = new THREE.Quaternion();
+       const meshYawQuat = new THREE.Quaternion();
+       const meshRollQuat = new THREE.Quaternion();
+       
+       meshPitchQuat.setFromAxisAngle(new THREE.Vector3(1, 0, 0), this.rotation.x);
+       meshYawQuat.setFromAxisAngle(new THREE.Vector3(0, 1, 0), this.rotation.y + 3 * Math.PI / 2);
+       meshRollQuat.setFromAxisAngle(new THREE.Vector3(0, 0, 1), this.rotation.z);
+       
+       // 쿼터니언 합성
+       meshQuaternion.multiply(meshYawQuat);
+       meshQuaternion.multiply(meshPitchQuat);
+       meshQuaternion.multiply(meshRollQuat);
+       
+       this.mesh.quaternion.copy(meshQuaternion);
+       
+       // 경고 깜빡임 타이머
+       this.warningBlinkTimer += deltaTime;
+       if (this.warningBlinkTimer >= 1.0) {
+           this.warningBlinkTimer = 0;
+           this.warningBlinkState = !this.warningBlinkState;
+       }
+       
+       // 고도 계산
+       this.altitude = this.position.y;
+       
+       // 경고음 업데이트 (엔진 소리는 계속 유지)
+       this.updateWarningAudios();
+       
+       // 엔진 소리 볼륨을 스로틀에 연동
+       if (this.warningAudios.normal && !this.warningAudios.normal.paused) {
+           this.warningAudios.normal.volume = 0.3 + this.throttle * 0.4; // 0.3~0.7
+       }
+   }
 
-    updatePhysics(deltaTime) {
-        if (!this.mesh) return;
-        
-        // 부드러운 회전 보간
-        const rotationSpeed = deltaTime * 2.0;
-        const yawRotationSpeed = deltaTime * 3.0;
-        
-        // 피치와 롤은 직접 보간
-        this.rotation.x = THREE.MathUtils.lerp(this.rotation.x, this.targetPitch, rotationSpeed);
-        this.rotation.z = THREE.MathUtils.lerp(this.rotation.z, this.targetRoll, rotationSpeed * 1.5);
-        
-        // Yaw 보간 (최단 경로)
-        let yawDiff = this.normalizeAngle(this.targetYaw - this.rotation.y);
-        this.rotation.y += yawDiff * yawRotationSpeed;
-        
-        // rotation.y를 -π ~ π 범위로 유지
-        this.rotation.y = this.normalizeAngle(this.rotation.y);
-        this.targetYaw = this.normalizeAngle(this.targetYaw);
-        
-        // 롤 자동 복귀 시스템
-        if (Math.abs(yawDiff) < 0.05) {
-            // 요 회전이 거의 없을 때 롤을 0으로 복귀
-            this.targetRoll *= 0.95;
-        }
-        
-        // 워썬더 스타일: 요 회전이 주도적, 롤은 보조적
-        let bankTurnRate = 0;
-        if (Math.abs(this.rotation.z) > 0.3) { // 롤이 충분히 클 때만
-            const bankAngle = this.rotation.z;
-            bankTurnRate = Math.sin(bankAngle) * deltaTime * 0.1; // 매우 작은 선회율
-            this.targetYaw += bankTurnRate;
-        }
-        
-        // 현실적인 속도 계산
-        const minSpeed = 0; // 최소 속도 0kt
-        const maxSpeed = 600; // 최대 속도 600kt
-        let targetSpeed = minSpeed + (maxSpeed - minSpeed) * this.throttle;
-        
-        // 피치 각도에 따른 속도 변화
-        const pitchAngle = this.rotation.x;
-        const pitchDegrees = Math.abs(pitchAngle) * (180 / Math.PI);
-        
-        // 기수가 위를 향하고 있을 경우 빠른 속도 감소
-        if (pitchAngle < -0.1 && !this.stallWarning) { // 스톨이 아닐 때만 상승으로 인한 감속
-            const climbFactor = Math.abs(pitchAngle) / (Math.PI / 2); // 90도 기준
-            if (pitchDegrees > 30) { // 30도 이상일 때 급격한 감속
-                targetSpeed *= Math.max(0, 1 - climbFactor * 1.5); // 최대 150% 감속 (0kt까지)
-            } else {
-                targetSpeed *= (1 - climbFactor * 0.3); // 정상적인 감속
-            }
-        } else if (pitchAngle > 0.1) { // 기수가 아래로 (하강) - 스톨 상태에서도 적용
-            const diveFactor = pitchAngle / (Math.PI / 3);
-            targetSpeed *= (1 + diveFactor * 0.4); // 하강 시 가속 증가 (0.2 -> 0.4)
-        }
-        
-        // G-Force 계산 개선
-        const turnRate = Math.abs(bankTurnRate) * 100;
-        const pitchRate = Math.abs(this.rotation.x - this.targetPitch) * 10;
-        
-        // 고도에 따른 G-Force 증가 배율 계산
-        const altitudeInKm = this.position.y / 1000; // 미터를 킬로미터로 변환
-        const altitudeMultiplier = 1 + (altitudeInKm * 0.2); // 1km당 20% 증가
-        
-        // 스로틀에 따른 G-Force 증가 배율 계산
-        // THR 50% 이하: 0배, THR 75%: 0.5배, THR 100%: 1.0배
-        let throttleGMultiplier = 0;
-        if (this.throttle > 0.5) {
-            // 0.5 ~ 1.0 범위를 0 ~ 1.0으로 매핑
-            throttleGMultiplier = (this.throttle - 0.5) * 2.0;
-        }
-        
-        // 비정상적인 자세에 의한 G-Force 추가
-        let abnormalG = 0;
-        
-        // 뒤집힌 상태 (롤이 90도 이상)
-        const isInverted = Math.abs(this.rotation.z) > Math.PI / 2;
-        if (isInverted) {
-            const baseG = 3.0 + Math.abs(Math.abs(this.rotation.z) - Math.PI / 2) * 2;
-            abnormalG += baseG * altitudeMultiplier * (1 + throttleGMultiplier); // 스로틀 배율 추가
-        }
-        
-        // 롤이 ±30도 이상일 때 추가 G-Force
-        const rollDegrees = Math.abs(this.rotation.z) * (180 / Math.PI);
-        if (rollDegrees > 30) {
-            // 30도 초과분당 0.1G 추가
-            const extremeRollG = (rollDegrees - 30) * 0.1;
-            abnormalG += extremeRollG * altitudeMultiplier * (1 + throttleGMultiplier);
-        }
-        
-        // 피치 각도가 ±40도 이상일 때 추가 G-Force
-        if (pitchDegrees >= 40) {
-            // 40도 이상일 때 급격한 G-Force 증가
-            const extremePitchG = (pitchDegrees - 40) * 0.15; // 40도 초과분당 0.15G 추가
-            abnormalG += extremePitchG * altitudeMultiplier * (1 + throttleGMultiplier);
-        }
-        
-        // 기수가 계속 위를 향하고 있는 경우 (피치가 -30도 이하)
-        if (pitchAngle < -Math.PI / 6) {
-            const baseG = 2.0 + Math.abs(pitchAngle + Math.PI / 6) * 3;
-            abnormalG += baseG * altitudeMultiplier * (1 + throttleGMultiplier); // 스로틀 배율 추가
-        }
-        
-        // 기수가 과도하게 아래를 향하고 있는 경우 (피치가 60도 이상)
-        if (pitchAngle > Math.PI / 3) {
-            const baseG = 2.0 + Math.abs(pitchAngle - Math.PI / 3) * 3;
-            abnormalG += baseG * altitudeMultiplier * (1 + throttleGMultiplier); // 스로틀 배율 추가
-        }
-        
-        // 급격한 기동에 의한 G-Force
-        const maneuverG = (turnRate + pitchRate + (Math.abs(this.rotation.z) * 3)) * (1 + throttleGMultiplier * 0.5);
-        
-        // 총 G-Force 계산
-        this.gForce = 1.0 + maneuverG + abnormalG;
-        
-        // G-Force 회복 조건 수정
-        // 1. Over-G 상태가 아닌 경우에만 회복
-        // 2. 피치가 ±10도 이내일 때만 회복
-        // 3. 스톨 상태가 아닐 때만 회복
-        const isPitchNeutral = Math.abs(pitchDegrees) <= 10;
-        
-        if (!this.overG && isPitchNeutral && !isInverted && !this.stallWarning) {
-            // 스로틀이 높을수록 G-Force가 천천히 감소
-            const recoveryRate = 2.0 - throttleGMultiplier * 1.5; // THR 100%일 때 0.5, THR 50%일 때 2.0
-            this.gForce = THREE.MathUtils.lerp(this.gForce, 1.0 + maneuverG, deltaTime * recoveryRate);
-        } else if (this.overG) {
-            // Over-G 상태에서는 피치가 0도 근처(±10도)가 되고 스톨이 회복될 때까지 회복하지 않음
-            if (!isPitchNeutral || this.stallWarning) {
-                // 피치가 중립이 아니거나 스톨 상태면 G-Force 유지 또는 증가만 가능
-                this.gForce = Math.max(this.gForce, 1.0 + maneuverG + abnormalG);
-            } else {
-                // 피치가 중립이고 스톨이 아닐 때만 매우 천천히 회복
-                const overGRecoveryRate = 0.3 - throttleGMultiplier * 0.2; // Over-G 상태에서는 더 느린 회복
-                this.gForce = THREE.MathUtils.lerp(this.gForce, 1.0 + maneuverG, deltaTime * overGRecoveryRate);
-            }
-        }
-        
-        // 스톨 상태에서는 Over-G가 감소하지 않도록 추가 처리
-        if (this.stallWarning && this.overG) {
-            // 스톨 중에는 G-Force를 9.0 이상으로 유지
-            this.gForce = Math.max(this.gForce, 9.0);
-        }
-        
-        this.overG = this.gForce > this.maxGForce;
-        
-        // Over-G 타이머 업데이트
-        if (this.overG) {
-            this.overGTimer += deltaTime;
-            
-            // 1.5초 이상 Over-G 상태일 경우 시야 흐림 시작
-            if (this.overGTimer > 1.5) {
-                // 속도 급격히 감소 (2.5초부터)
-                if (this.overGTimer > 2.5) {
-                    targetSpeed *= Math.max(0.3, 1 - (this.overGTimer - 2.5) * 0.3);
-                }
-                // 시야 흐림 효과는 UI에서 처리 (1.5초부터)
-            }
-        } else {
-            this.overGTimer = 0; // Over-G 상태가 아니면 타이머 리셋
-        }
-        
-        // 스톨 경고: 300kt 이하에서 스톨 위험
-        const speedKnots = this.speed * 1.94384; // m/s to knots
-        const wasStalling = this.stallWarning;
-        
-        // 스톨 진입 조건
-        if (!this.stallWarning && speedKnots < GAME_CONSTANTS.STALL_SPEED) {
-            this.stallWarning = true;
-            this.stallEscapeProgress = 0; // 스톨 진입 시 진행도 초기화
-        }
-        
-        // 스톨 탈출 조건
-        if (this.stallWarning) {
-            if (this.escapeKeyPressed) {
-                // F키를 누르고 있으면 진행도 증가
-                this.stallEscapeProgress += deltaTime;
-                
-                // 2초 이상 누르면 스톨에서 탈출
-                if (this.stallEscapeProgress >= 2.0 && speedKnots >= 350) {
-                    this.stallWarning = false;
-                    this.stallEscapeProgress = 0;
-                    // 스톨에서 벗어나면 자세를 약간 안정화
-                    this.targetPitch = Math.max(-0.2, Math.min(0.2, this.targetPitch));
-                }
-            } else {
-                // F키를 놓으면 진행도 감소
-                this.stallEscapeProgress = Math.max(0, this.stallEscapeProgress - deltaTime * 2);
-            }
-        }
-        
-        // 속도 변화 적용
-        if (this.stallWarning) {
-            // 스톨 상태에서의 속도 변화
-            if (pitchAngle > 0.1) { // 기수가 아래를 향할 때
-                // 다이빙으로 인한 속도 증가
-                const diveSpeedGain = Math.min(pitchAngle * 300, 200); // 최대 200m/s 증가
-                this.speed = Math.min(maxSpeed, this.speed + diveSpeedGain * deltaTime);
-            } else {
-                // 기수가 위를 향하거나 수평일 때는 속도 감소
-                this.speed = Math.max(0, this.speed - deltaTime * 100);
-            }
-        } else {
-            // 정상 비행 시 속도 변화
-            this.speed = THREE.MathUtils.lerp(this.speed, targetSpeed, deltaTime * 0.5);
-        }
-        
-        // 스톨 상태에서의 물리 효과
-        if (this.stallWarning) {
-            // 바닥으로 추락하며 가속도가 빠르게 붙음
-            this.targetPitch = Math.min(Math.PI / 2.5, this.targetPitch + deltaTime * 2.5); // 기수가 더 극단적으로 아래로 (72도까지)
-            
-            // 조종 불능 상태 - 더 심한 흔들림
-            this.rotation.x += (Math.random() - 0.5) * deltaTime * 0.8;
-            this.rotation.z += (Math.random() - 0.5) * deltaTime * 0.8;
-            
-            // 중력에 의한 가속
-            const gravityAcceleration = GAME_CONSTANTS.GRAVITY * deltaTime * 3.0; // 3배 중력
-            this.velocity.y -= gravityAcceleration;
-        }
-        
-        // 속도 벡터 계산 - 매트릭스를 사용하여 짐벌 락 회피
-        const noseDirection = new THREE.Vector3(0, 0, 1);
-        
-        // 회전 매트릭스를 직접 구성하여 적용
-        const rotationMatrix = new THREE.Matrix4();
-        rotationMatrix.makeRotationFromEuler(new THREE.Euler(this.rotation.x, this.rotation.y, this.rotation.z, 'YXZ'));
-        noseDirection.applyMatrix4(rotationMatrix);
-        
-        if (!this.stallWarning) {
-            // 정상 비행 시
-            this.velocity = noseDirection.multiplyScalar(this.speed);
-        } else {
-            // 스톨 시에는 중력이 주도적이지만 다이빙 속도도 반영
-            this.velocity.x = noseDirection.x * this.speed * 0.5; // 전방 속도 증가
-            this.velocity.z = noseDirection.z * this.speed * 0.5;
-            // y 속도는 위에서 중력으로 처리됨
-        }
-        
-        // 정상 비행 시 중력 효과
-        if (!this.stallWarning) {
-            const gravityEffect = GAME_CONSTANTS.GRAVITY * deltaTime * 0.15;
-            this.velocity.y -= gravityEffect;
-            
-            // 양력 효과 (속도에 비례)
-            const liftFactor = (this.speed / maxSpeed) * 0.8;
-            const lift = gravityEffect * liftFactor;
-            this.velocity.y += lift;
-        }
-        
-        // 위치 업데이트
-        this.position.add(this.velocity.clone().multiplyScalar(deltaTime));
-        
-        // 지면 충돌
-        if (this.position.y <= GAME_CONSTANTS.MIN_ALTITUDE) {
-            this.position.y = GAME_CONSTANTS.MIN_ALTITUDE;
-            this.health = 0;
-            
-            // 지면 충돌 시 폭발 효과 추가
-            if (window.gameInstance) {
-                window.gameInstance.createExplosionEffect(this.position);
-            }
-            
-            return;
-        }
-        
-        // 최대 고도 제한
-        if (this.position.y > GAME_CONSTANTS.MAX_ALTITUDE) {
-            this.position.y = GAME_CONSTANTS.MAX_ALTITUDE;
-            this.altitudeWarning = true;
-            if (this.velocity.y > 0) this.velocity.y = 0;
-        } else {
-            this.altitudeWarning = false;
-        }
-        
-        // 맵 경계 처리
-        const mapLimit = GAME_CONSTANTS.MAP_SIZE / 2;
-        if (this.position.x > mapLimit) this.position.x = -mapLimit;
-        if (this.position.x < -mapLimit) this.position.x = mapLimit;
-        if (this.position.z > mapLimit) this.position.z = -mapLimit;
-        if (this.position.z < -mapLimit) this.position.z = mapLimit;
-        
-        // 메시 위치 및 회전 업데이트
-        this.mesh.position.copy(this.position);
-        this.mesh.rotation.x = this.rotation.x;
-        this.mesh.rotation.y = this.rotation.y + 3 * Math.PI / 2;
-        this.mesh.rotation.z = this.rotation.z;
-        
-        // 경고 깜빡임 타이머
-        this.warningBlinkTimer += deltaTime;
-        if (this.warningBlinkTimer >= 1.0) {
-            this.warningBlinkTimer = 0;
-            this.warningBlinkState = !this.warningBlinkState;
-        }
-        
-        // 고도 계산
-        this.altitude = this.position.y;
-        
-        // 경고음 업데이트 (엔진 소리는 계속 유지)
-        this.updateWarningAudios();
-        
-        // 엔진 소리 볼륨을 스로틀에 연동
-        if (this.warningAudios.normal && !this.warningAudios.normal.paused) {
-            this.warningAudios.normal.volume = 0.3 + this.throttle * 0.4; // 0.3~0.7
-        }
-    }
-
-    shoot(scene) {
-        // 탄약이 없으면 발사하지 않음
-        if (this.ammo <= 0) return;
-        
-        this.ammo--;
-        
-        // 직선 모양의 탄환 (100% 더 크게)
-        const bulletGeometry = new THREE.CylinderGeometry(1.0, 1.0, 16, 8); // 반지름 0.75→1.0, 길이 12→16
-        const bulletMaterial = new THREE.MeshBasicMaterial({ 
-            color: 0xffff00,
-            emissive: 0xffff00,
-            emissiveIntensity: 1.0
-        });
-        const bullet = new THREE.Mesh(bulletGeometry, bulletMaterial);
-        
-        // 기수 끝에서 발사 (더 앞쪽에서)
-        const muzzleOffset = new THREE.Vector3(0, 0, 10);
-        const rotationMatrix = new THREE.Matrix4();
-        rotationMatrix.makeRotationFromEuler(new THREE.Euler(this.rotation.x, this.rotation.y, this.rotation.z, 'YXZ'));
-        muzzleOffset.applyMatrix4(rotationMatrix);
-        bullet.position.copy(this.position).add(muzzleOffset);
-        
-        // 탄환을 발사 방향으로 회전
-        bullet.rotation.copy(this.rotation);
-        bullet.rotateX(Math.PI / 2); // 실린더가 Z축 방향을 향하도록
-        
-        // 탄환 초기 위치 저장
-        bullet.startPosition = bullet.position.clone();
-        
-        const bulletSpeed = 1500; // 1000에서 1500으로 증가 (50% 빠르게)
-        const direction = new THREE.Vector3(0, 0, 1);
-        direction.applyMatrix4(rotationMatrix);
-        bullet.velocity = direction.multiplyScalar(bulletSpeed);
-        
-        scene.add(bullet);
-        this.bullets.push(bullet);
-        
-        // m134.ogg 소리 재생 - 중첩 제한 해제, 랜덤 피치
-        try {
-            const audio = new Audio('sounds/m134.ogg');
-            audio.volume = 0.15; // 0.3에서 0.15로 감소 (50% 줄임)
-            
-            // -2 ~ +2 사이의 랜덤 피치 (playbackRate로 시뮬레이션)
-            const randomPitch = 0.8 + Math.random() * 0.4; // 0.8 ~ 1.2 범위
-            audio.playbackRate = randomPitch;
-            
-            audio.play().catch(e => console.log('Gunfire sound failed to play'));
-            
-            // 재생 완료 시 메모리 정리를 위해 참조 제거
-            audio.addEventListener('ended', () => {
-                audio.remove();
-            });
-        } catch (e) {
-            console.log('Audio error:', e);
-        }
-    }
+   shoot(scene) {
+       // 탄약이 없으면 발사하지 않음
+       if (this.ammo <= 0) return;
+       
+       this.ammo--;
+       
+       // 직선 모양의 탄환 (100% 더 크게)
+       const bulletGeometry = new THREE.CylinderGeometry(1.0, 1.0, 16, 8); // 반지름 0.75→1.0, 길이 12→16
+       const bulletMaterial = new THREE.MeshBasicMaterial({ 
+           color: 0xffff00,
+           emissive: 0xffff00,
+           emissiveIntensity: 1.0
+       });
+       const bullet = new THREE.Mesh(bulletGeometry, bulletMaterial);
+       
+       // 기수 끝에서 발사 (쿼터니언 사용)
+       const muzzleOffset = new THREE.Vector3(0, 0, 10);
+       
+       // 전투기와 동일한 쿼터니언 생성
+       const quaternion = new THREE.Quaternion();
+       const pitchQuat = new THREE.Quaternion();
+       const yawQuat = new THREE.Quaternion();
+       const rollQuat = new THREE.Quaternion();
+       
+       pitchQuat.setFromAxisAngle(new THREE.Vector3(1, 0, 0), this.rotation.x);
+       yawQuat.setFromAxisAngle(new THREE.Vector3(0, 1, 0), this.rotation.y);
+       rollQuat.setFromAxisAngle(new THREE.Vector3(0, 0, 1), this.rotation.z);
+       
+       quaternion.multiply(yawQuat);
+       quaternion.multiply(pitchQuat);
+       quaternion.multiply(rollQuat);
+       
+       muzzleOffset.applyQuaternion(quaternion);
+       bullet.position.copy(this.position).add(muzzleOffset);
+       
+       // 탄환을 발사 방향으로 회전
+       bullet.quaternion.copy(quaternion);
+       // 실린더가 Z축 방향을 향하도록 추가 회전
+       const cylinderRotation = new THREE.Quaternion();
+       cylinderRotation.setFromAxisAngle(new THREE.Vector3(1, 0, 0), Math.PI / 2);
+       bullet.quaternion.multiply(cylinderRotation);
+       
+       // 탄환 초기 위치 저장
+       bullet.startPosition = bullet.position.clone();
+       
+       const bulletSpeed = 1500; // 1000에서 1500으로 증가 (50% 빠르게)
+       const direction = new THREE.Vector3(0, 0, 1);
+       direction.applyQuaternion(quaternion);
+       bullet.velocity = direction.multiplyScalar(bulletSpeed);
+       
+       scene.add(bullet);
+       this.bullets.push(bullet);
+       
+       // m134.ogg 소리 재생 - 중첩 제한 해제, 랜덤 피치
+       try {
+           const audio = new Audio('sounds/m134.ogg');
+           audio.volume = 0.15; // 0.3에서 0.15로 감소 (50% 줄임)
+           
+           // -2 ~ +2 사이의 랜덤 피치 (playbackRate로 시뮬레이션)
+           const randomPitch = 0.8 + Math.random() * 0.4; // 0.8 ~ 1.2 범위
+           audio.playbackRate = randomPitch;
+           
+           audio.play().catch(e => console.log('Gunfire sound failed to play'));
+           
+           // 재생 완료 시 메모리 정리를 위해 참조 제거
+           audio.addEventListener('ended', () => {
+               audio.remove();
+           });
+       } catch (e) {
+           console.log('Audio error:', e);
+       }
+   }
 
-    updateBullets(scene, deltaTime, gameInstance) {
-        for (let i = this.bullets.length - 1; i >= 0; i--) {
-            const bullet = this.bullets[i];
-            bullet.position.add(bullet.velocity.clone().multiplyScalar(deltaTime));
-            
-            // 탄환도 같은 방향을 유지하도록 회전 업데이트
-            const direction = bullet.velocity.clone().normalize();
-            const angle = Math.atan2(direction.x, direction.z);
-            bullet.rotation.y = angle;
-            
-            // 지면 충돌 체크 추가
-            if (bullet.position.y <= 0) {
-                // 크고 화려한 지면 충돌 효과
-                gameInstance.createGroundImpactEffect(bullet.position);
-                scene.remove(bullet);
-                this.bullets.splice(i, 1);
-                continue;
-            }
-            
-            // 6000m 이상 날아가거나 높이 제한 초과 시 제거
-            if (bullet.position.distanceTo(bullet.startPosition) > 6000 || 
-                bullet.position.y > GAME_CONSTANTS.MAX_ALTITUDE + 500) {
-                scene.remove(bullet);
-                this.bullets.splice(i, 1);
-            }
-        }
-    }
+   updateBullets(scene, deltaTime, gameInstance) {
+       for (let i = this.bullets.length - 1; i >= 0; i--) {
+           const bullet = this.bullets[i];
+           bullet.position.add(bullet.velocity.clone().multiplyScalar(deltaTime));
+           
+           // 탄환도 같은 방향을 유지하도록 회전 업데이트
+           const direction = bullet.velocity.clone().normalize();
+           const angle = Math.atan2(direction.x, direction.z);
+           bullet.rotation.y = angle;
+           
+           // 지면 충돌 체크 추가
+           if (bullet.position.y <= 0) {
+               // 크고 화려한 지면 충돌 효과
+               gameInstance.createGroundImpactEffect(bullet.position);
+               scene.remove(bullet);
+               this.bullets.splice(i, 1);
+               continue;
+           }
+           
+           // 6000m 이상 날아가거나 높이 제한 초과 시 제거
+           if (bullet.position.distanceTo(bullet.startPosition) > 6000 || 
+               bullet.position.y > GAME_CONSTANTS.MAX_ALTITUDE + 500) {
+               scene.remove(bullet);
+               this.bullets.splice(i, 1);
+           }
+       }
+   }
 
-    takeDamage(damage) {
-        this.health -= damage;
-        return this.health <= 0;
-    }
+   takeDamage(damage) {
+       this.health -= damage;
+       return this.health <= 0;
+   }
 
-    getCameraPosition() {
-        const backward = new THREE.Vector3(0, 0, -1);
-        const up = new THREE.Vector3(0, 1, 0);
-        
-        const rotationMatrix = new THREE.Matrix4();
-        rotationMatrix.makeRotationFromEuler(new THREE.Euler(this.rotation.x, this.rotation.y, this.rotation.z, 'YXZ'));
-        
-        backward.applyMatrix4(rotationMatrix);
-        up.applyMatrix4(rotationMatrix);
-        
-        const cameraPosition = this.position.clone()
-            .add(backward.multiplyScalar(this.cameraDistance))
-            .add(up.multiplyScalar(this.cameraHeight));
-        
-        return cameraPosition;
-    }
+   getCameraPosition() {
+       const backward = new THREE.Vector3(0, 0, -1);
+       const up = new THREE.Vector3(0, 1, 0);
+       
+       // 카메라 위치 계산에도 쿼터니언 사용
+       const quaternion = new THREE.Quaternion();
+       const pitchQuat = new THREE.Quaternion();
+       const yawQuat = new THREE.Quaternion();
+       const rollQuat = new THREE.Quaternion();
+       
+       pitchQuat.setFromAxisAngle(new THREE.Vector3(1, 0, 0), this.rotation.x);
+       yawQuat.setFromAxisAngle(new THREE.Vector3(0, 1, 0), this.rotation.y);
+       rollQuat.setFromAxisAngle(new THREE.Vector3(0, 0, 1), this.rotation.z);
+       
+       quaternion.multiply(yawQuat);
+       quaternion.multiply(pitchQuat);
+       quaternion.multiply(rollQuat);
+       
+       backward.applyQuaternion(quaternion);
+       up.applyQuaternion(quaternion);
+       
+       const cameraPosition = this.position.clone()
+           .add(backward.multiplyScalar(this.cameraDistance))
+           .add(up.multiplyScalar(this.cameraHeight));
+       
+       return cameraPosition;
+   }
 
-    getCameraTarget() {
-        return this.position.clone();
-    }
-    
-    // HUD 표시용 헤딩 getter (0~360도)
-    getHeadingDegrees() {
-        return this.normalizeHeading(this.rotation.y);
-    }
+   getCameraTarget() {
+       return this.position.clone();
+   }
+   
+   // HUD 표시용 헤딩 getter (0~360도)
+   getHeadingDegrees() {
+       return this.normalizeHeading(this.rotation.y);
+   }
 }
 
 // 적 전투기 클래스 - 완전히 재설계