Update game.js

game.js

@@ -33,18 +33,8 @@ class Fighter {
         this.position = new THREE.Vector3(0, 2000, 0);
         this.velocity = new THREE.Vector3(0, 0, 350); // 초기 속도 350kt
         this.acceleration = new THREE.Vector3(0, 0, 0);
-        
-        // 쿼터니언 기반 회전 (짐벌 락 방지)
-        this.quaternion = new THREE.Quaternion();
-        
-        // 오일러 각도 (표시 및 제한용)
         this.rotation = new THREE.Euler(0, 0, 0);
         
-        // 부드러운 회전을 위한 목표값
-        this.targetPitch = 0;
-        this.targetRoll = 0;
-        this.targetYaw = 0;
-        
         // 비행 제어
         this.throttle = 0.7; // 초기 스로틀 70%
         this.speed = 350; // 초기 속도 350kt
@@ -61,6 +51,11 @@ class Fighter {
         this.mousePitch = 0;
         this.mouseRoll = 0;
         
+        // 부드러운 회전을 위한 목표값
+        this.targetPitch = 0;
+        this.targetRoll = 0;
+        this.targetYaw = 0;
+        
         // 무기
         this.missiles = GAME_CONSTANTS.MISSILE_COUNT;
         this.ammo = GAME_CONSTANTS.AMMO_COUNT;
@@ -100,6 +95,21 @@ class Fighter {
         this.initializeWarningAudios();
     }
     
+    // 헤딩을 0~360도로 정규화하는 헬퍼 함수
+    normalizeHeading(radians) {
+        let degrees = radians * (180 / Math.PI);
+        while (degrees < 0) degrees += 360;
+        while (degrees >= 360) degrees -= 360;
+        return degrees;
+    }
+    
+    // 라디안을 -π ~ π 범위로 정규화
+    normalizeAngle(angle) {
+        while (angle > Math.PI) angle -= Math.PI * 2;
+        while (angle < -Math.PI) angle += Math.PI * 2;
+        return angle;
+    }
+    
     initializeWarningAudios() {
         try {
             this.warningAudios.altitude = new Audio('sounds/altitude.ogg');
@@ -188,11 +198,7 @@ class Fighter {
             this.mesh = result.scene;
             this.mesh.position.copy(this.position);
             this.mesh.scale.set(2, 2, 2);
-            
-            // 초기 회전 설정
-            const initialYaw = Math.PI / 4;
-            this.quaternion.setFromEuler(new THREE.Euler(0, initialYaw, 0));
-            this.targetYaw = initialYaw;
+            this.mesh.rotation.y = Math.PI / 4;
             
             this.mesh.traverse((child) => {
                 if (child.isMesh) {
@@ -251,34 +257,39 @@ class Fighter {
         // Over-G 상태에서 스톨이 해제되지 않았으면 피치 조작 불가
         if (this.overG && this.overGTimer > 1.0 && this.stallWarning) {
             // 요(Yaw)만 제한적으로 허용
-            const sensitivity = GAME_CONSTANTS.MOUSE_SENSITIVITY * 0.3;
+            const sensitivity = GAME_CONSTANTS.MOUSE_SENSITIVITY * 0.3; // 감도 대폭 감소
             this.targetYaw += deltaX * sensitivity * 0.3;
             
             // 피치는 조작 불가
             // 롤도 제한적으로만 허용
             const yawRate = deltaX * sensitivity * 0.3;
-            this.targetRoll = -yawRate * 5;
+            this.targetRoll = -yawRate * 5; // 매우 제한된 롤
             
-            return;
+            return; // 추가 처리 중단
         }
         
         const sensitivity = GAME_CONSTANTS.MOUSE_SENSITIVITY * 1.0;
         
-        // 마우스 입력을 목표 각도로 변환
+        // 마우스 Y축: 피치(기수 상하) - 항상 동일하게 작동
         this.targetPitch -= deltaY * sensitivity;
+        
+        // 마우스 X축: 요(좌우 회전) - 항상 동일하게 작동
         this.targetYaw += deltaX * sensitivity * 0.8;
         
         // 요 회전에 따른 자동 롤 (뱅크 턴)
+        // 좌우로 회전할 때 자연스럽게 날개가 기울어짐
         const yawRate = deltaX * sensitivity * 0.8;
-        this.targetRoll = -yawRate * 15;
+        this.targetRoll = -yawRate * 15; // 요 회전량에 비례하여 롤 발생
         
         // 각도 제한
         const maxPitchAngle = Math.PI / 3; // 60도
-        const maxRollAngle = Math.PI * 0.5; // 90도
+        const maxRollAngle = Math.PI * 0.5; // 90도로 제한 (자동 롤)
         
         this.targetPitch = Math.max(-maxPitchAngle, Math.min(maxPitchAngle, this.targetPitch));
         
+        // 자동 롤은 제한된 범위 내에서만 작동
         if (Math.abs(this.targetRoll) < maxRollAngle) {
+            // 롤 각도 제한 적용
             this.targetRoll = Math.max(-maxRollAngle, Math.min(maxRollAngle, this.targetRoll));
         }
     }
@@ -292,7 +303,7 @@ class Fighter {
             this.throttle = Math.max(0.1, this.throttle - deltaTime * 0.5);
         }
         
-        // A/D: 보조 요 제어 (러더)
+        // A/D: 보조 요 제어 (러더) - 반응성 개선
         if (keys.a) {
             this.targetYaw -= deltaTime * 1.2;
         }
@@ -304,229 +315,242 @@ class Fighter {
     updatePhysics(deltaTime) {
         if (!this.mesh) return;
         
-        // 쿼터니언을 사용한 부드러운 회전
+        // 부드러운 회전 보간
         const rotationSpeed = deltaTime * 2.0;
         const yawRotationSpeed = deltaTime * 3.0;
         
-        // 현재 쿼터니언에서 오일러 각도 추출 (표시용)
-        this.rotation.setFromQuaternion(this.quaternion);
-        
-        // 각 축의 회전 차이 계산
-        let pitchDiff = this.targetPitch - this.rotation.x;
-        let yawDiff = this.targetYaw - this.rotation.y;
-        let rollDiff = this.targetRoll - this.rotation.z;
+        // 피치와 롤은 직접 보간
+        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);
         
-        // 각도 차이 정규화 (-π ~ π)
-        while (yawDiff > Math.PI) yawDiff -= Math.PI * 2;
-        while (yawDiff < -Math.PI) yawDiff += Math.PI * 2;
+        // Yaw 보간 (최단 경로)
+        let yawDiff = this.normalizeAngle(this.targetYaw - this.rotation.y);
+        this.rotation.y += yawDiff * yawRotationSpeed;
         
-        // 쿼터니언 회전 적용
-        // 1. Yaw 회전 (월드 Y축 기준)
-        const yawQuat = new THREE.Quaternion().setFromAxisAngle(
-            new THREE.Vector3(0, 1, 0), 
-            yawDiff * yawRotationSpeed
-        );
-        
-        // 2. Pitch 회전 (로컬 X축 기준)
-        const localXAxis = new THREE.Vector3(1, 0, 0).applyQuaternion(this.quaternion);
-        const pitchQuat = new THREE.Quaternion().setFromAxisAngle(
-            localXAxis, 
-            pitchDiff * rotationSpeed
-        );
-        
-        // 3. Roll 회전 (로컬 Z축 기준)
-        const localZAxis = new THREE.Vector3(0, 0, 1).applyQuaternion(this.quaternion);
-        const rollQuat = new THREE.Quaternion().setFromAxisAngle(
-            localZAxis, 
-            rollDiff * rotationSpeed * 1.5
-        );
-        
-        // 회전 적용 순서: Yaw -> Pitch -> Roll
-        this.quaternion.multiply(yawQuat);
-        this.quaternion.multiply(pitchQuat);
-        this.quaternion.multiply(rollQuat);
-        this.quaternion.normalize();
+        // 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) {
+        if (Math.abs(this.rotation.z) > 0.3) { // 롤이 충분히 클 때만
             const bankAngle = this.rotation.z;
-            bankTurnRate = Math.sin(bankAngle) * deltaTime * 0.1;
+            bankTurnRate = Math.sin(bankAngle) * deltaTime * 0.1; // 매우 작은 선회율
             this.targetYaw += bankTurnRate;
         }
         
-        // 속도 계산
-        const minSpeed = 0;
-        const maxSpeed = 600;
+        // 현실적인 속도 계산
+        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);
-            if (pitchDegrees > 30) {
-                targetSpeed *= Math.max(0, 1 - climbFactor * 1.5);
+        // 기수가 위를 향하고 있을 경우 빠른 속도 감소
+        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);
+                targetSpeed *= (1 - climbFactor * 0.3); // 정상적인 감속
             }
-        } else if (pitchAngle > 0.1) {
+        } else if (pitchAngle > 0.1) { // 기수가 아래로 (하강) - 스톨 상태에서도 적용
             const diveFactor = pitchAngle / (Math.PI / 3);
-            targetSpeed *= (1 + diveFactor * 0.4);
+            targetSpeed *= (1 + diveFactor * 0.4); // 하강 시 가속 증가 (0.2 -> 0.4)
         }
         
-        // G-Force 계산
+        // G-Force 계산 개선
         const turnRate = Math.abs(bankTurnRate) * 100;
-        const pitchRate = Math.abs(pitchDiff) * 10;
+        const pitchRate = Math.abs(this.rotation.x - this.targetPitch) * 10;
         
-        const altitudeInKm = this.position.y / 1000;
-        const altitudeMultiplier = 1 + (altitudeInKm * 0.2);
+        // 고도에 따른 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
+        // 비정상적인 자세에 의한 G-Force 추가
         let abnormalG = 0;
         
-        const rollDegrees = Math.abs(this.rotation.z) * (180 / Math.PI);
+        // 뒤집힌 상태 (롤이 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);
+            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) {
-            const extremePitchG = (pitchDegrees - 40) * 0.15;
+            // 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);
+            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);
+            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 회복
+        // G-Force 회복 조건 수정
+        // 1. Over-G 상태가 아닌 경우에만 회복
+        // 2. 피치가 ±10도 이내일 때만 회복
+        // 3. 스톨 상태가 아닐 때만 회복
         const isPitchNeutral = Math.abs(pitchDegrees) <= 10;
         
         if (!this.overG && isPitchNeutral && !isInverted && !this.stallWarning) {
-            const recoveryRate = 2.0 - throttleGMultiplier * 1.5;
+            // 스로틀이 높을수록 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;
+                // 피치가 중립이고 스톨이 아닐 때만 매우 천천히 회복
+                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 타이머
+        // 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;
+            this.overGTimer = 0; // Over-G 상태가 아니면 타이머 리셋
         }
         
-        // 스톨 체크
-        const speedKnots = this.speed * 1.94384;
+        // 스톨 경고: 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;
+            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);
+            // 스톨 상태에서의 속도 변화
+            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);
-            
-            // 쿼터니언으로 흔들림 효과
-            const shakeAxis = new THREE.Vector3(
-                (Math.random() - 0.5),
-                (Math.random() - 0.5),
-                (Math.random() - 0.5)
-            ).normalize();
-            const shakeQuat = new THREE.Quaternion().setFromAxisAngle(shakeAxis, deltaTime * 0.8);
-            this.quaternion.multiply(shakeQuat);
-            
-            const gravityAcceleration = GAME_CONSTANTS.GRAVITY * deltaTime * 3.0;
+            // 바닥으로 추락하며 가속도가 빠르게 붙음
+            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);
-        noseDirection.applyQuaternion(this.quaternion);
+        noseDirection.applyEuler(this.rotation);
         
         if (!this.stallWarning) {
+            // 정상 비행 시
             this.velocity = noseDirection.multiplyScalar(this.speed);
         } else {
-            this.velocity.x = noseDirection.x * this.speed * 0.5;
+            // 스톨 시에는 중력이 주도적이지만 다이빙 ��도도 반영
+            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;
@@ -540,6 +564,7 @@ class Fighter {
             this.position.y = GAME_CONSTANTS.MIN_ALTITUDE;
             this.health = 0;
             
+            // 지면 충돌 시 폭발 효과 추가
             if (window.gameInstance) {
                 window.gameInstance.createExplosionEffect(this.position);
             }
@@ -547,7 +572,7 @@ class Fighter {
             return;
         }
         
-        // 고도 제한
+        // 최대 고도 제한
         if (this.position.y > GAME_CONSTANTS.MAX_ALTITUDE) {
             this.position.y = GAME_CONSTANTS.MAX_ALTITUDE;
             this.altitudeWarning = true;
@@ -556,43 +581,46 @@ class Fighter {
             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.quaternion.copy(this.quaternion);
-        
-        // 모델 오프셋 적용
-        const modelOffset = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), 3 * Math.PI / 2);
-        this.mesh.quaternion.multiply(modelOffset);
+        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;
+            this.warningAudios.normal.volume = 0.3 + this.throttle * 0.4; // 0.3~0.7
         }
     }
 
     shoot(scene) {
+        // 탄약이 없으면 발사하지 않음
         if (this.ammo <= 0) return;
         
         this.ammo--;
         
-        const bulletGeometry = new THREE.CylinderGeometry(1.0, 1.0, 16, 8);
+        // 직선 모양의 탄환 (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,
@@ -600,35 +628,38 @@ class Fighter {
         });
         const bullet = new THREE.Mesh(bulletGeometry, bulletMaterial);
         
-        // 쿼터니언을 사용한 발사 위치
+        // 기수 끝에서 발사 (더 앞쪽에서)
         const muzzleOffset = new THREE.Vector3(0, 0, 10);
-        muzzleOffset.applyQuaternion(this.quaternion);
+        muzzleOffset.applyEuler(this.rotation);
         bullet.position.copy(this.position).add(muzzleOffset);
         
-        // 탄환 회전 설정
-        bullet.quaternion.copy(this.quaternion);
-        const bulletRotation = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(1, 0, 0), Math.PI / 2);
-        bullet.quaternion.multiply(bulletRotation);
+        // 탄환을 발사 방향으로 회전
+        bullet.rotation.copy(this.rotation);
+        bullet.rotateX(Math.PI / 2); // 실린더가 Z축 방향을 향하도록
         
+        // 탄환 초기 위치 저장
         bullet.startPosition = bullet.position.clone();
         
-        const bulletSpeed = 1500;
+        const bulletSpeed = 1500; // 1000에서 1500으로 증가 (50% 빠르게)
         const direction = new THREE.Vector3(0, 0, 1);
-        direction.applyQuaternion(this.quaternion);
+        direction.applyEuler(this.rotation);
         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;
+            audio.volume = 0.15; // 0.3에서 0.15로 감소 (50% 줄임)
             
-            const randomPitch = 0.8 + Math.random() * 0.4;
+            // -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();
             });
@@ -642,13 +673,21 @@ class Fighter {
             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);
@@ -666,8 +705,8 @@ class Fighter {
         const backward = new THREE.Vector3(0, 0, -1);
         const up = new THREE.Vector3(0, 1, 0);
         
-        backward.applyQuaternion(this.quaternion);
-        up.applyQuaternion(this.quaternion);
+        backward.applyEuler(this.rotation);
+        up.applyEuler(this.rotation);
         
         const cameraPosition = this.position.clone()
             .add(backward.multiplyScalar(this.cameraDistance))
@@ -679,6 +718,11 @@ class Fighter {
     getCameraTarget() {
         return this.position.clone();
     }
+    
+    // HUD 표시용 헤딩 getter (0~360도)
+    getHeadingDegrees() {
+        return this.normalizeHeading(this.rotation.y);
+    }
 }
 
 // 적 전투기 클래스 - 완전히 재설계
@@ -1720,7 +1764,7 @@ class Game {
         const altitudeMeters = Math.round(this.fighter.altitude);
         const pitchDegrees = Math.round(this.fighter.rotation.x * (180 / Math.PI));
         const rollDegreesRounded = Math.round(rollDegrees);
-        const headingDegrees = Math.round(((this.fighter.rotation.y * (180 / Math.PI)) + 360) % 360);
+        const headingDegrees = Math.round(fighter.getHeadingDegrees());
         
         // 선회율 계산 (도/초)
         if (!this.lastHeading) this.lastHeading = headingDegrees;