Update game.js

game.js

@@ -33,18 +33,7 @@ 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.targetQuaternion = new THREE.Quaternion();
-        
-        // 오일러 각도 (표시용)
-        this.rotation = new THREE.Euler(0, 0, 0);
-        
-        // 회전 속도 (라디안/초)
-        this.pitchRate = 0;
-        this.yawRate = 0;
-        this.rollRate = 0;
+        this.rotation = new THREE.Euler(0, 0, 0, 'YXZ'); // 오일러 각도 순서를 YXZ로 변경하여 짐벌 락 방지
         
         // 비행 제어
         this.throttle = 0.7; // 초기 스로틀 70%
@@ -53,6 +42,20 @@ class Fighter {
         this.gForce = 1.0;
         this.health = GAME_CONSTANTS.MAX_HEALTH; // 체력 1000
         
+        // 조종 입력 시스템
+        this.pitchInput = 0;
+        this.rollInput = 0;
+        this.yawInput = 0;
+        
+        // 마우스 누적 입력
+        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;
@@ -180,11 +183,7 @@ class Fighter {
             this.mesh = result.scene;
             this.mesh.position.copy(this.position);
             this.mesh.scale.set(2, 2, 2);
-            
-            // 초기 회전 설정 (쿼터니언 사용)
-            const initialRotation = new THREE.Euler(0, Math.PI / 4, 0);
-            this.quaternion.setFromEuler(initialRotation);
-            this.mesh.quaternion.copy(this.quaternion);
+            this.mesh.rotation.y = Math.PI / 4;
             
             this.mesh.traverse((child) => {
                 if (child.isMesh) {
@@ -243,88 +242,117 @@ class Fighter {
         // Over-G 상태에서 스톨이 해제되지 않았으면 피치 조작 불가
         if (this.overG && this.overGTimer > 1.0 && this.stallWarning) {
             // 요(Yaw)만 제한적으로 허용
-            const sensitivity = GAME_CONSTANTS.MOUSE_SENSITIVITY * 0.3;
-            this.yawRate = deltaX * sensitivity * 0.3;
+            const sensitivity = GAME_CONSTANTS.MOUSE_SENSITIVITY * 0.3; // 감도 대폭 감소
+            this.targetYaw += deltaX * sensitivity * 0.3;
             
-            // 피치와 롤은 제한
-            this.pitchRate = 0;
-            this.rollRate = -this.yawRate * 5; // 매우 제한된 롤
+            // 피치는 조작 불가
+            // 롤도 제한적으로만 허용
+            const yawRate = deltaX * sensitivity * 0.3;
+            this.targetRoll = -yawRate * 5; // 매우 제한된 롤
             
-            return;
+            return; // 추가 처리 중단
         }
         
         const sensitivity = GAME_CONSTANTS.MOUSE_SENSITIVITY * 1.0;
         
-        // 마우스 입력을 회전 속도로 변환
-        this.pitchRate = -deltaY * sensitivity * 2.0;
-        this.yawRate = deltaX * sensitivity * 0.8 * 2.0;
+        // 마우스 Y축: 피치(기수 상하) - 항상 동일하게 작동
+        this.targetPitch -= deltaY * sensitivity;
+        
+        // 마우스 X축: 요(좌우 회전) - 항상 동일하게 작동
+        this.targetYaw += deltaX * sensitivity * 0.8;
         
-        // 요 회전에 따른 자동 롤
-        this.rollRate = -deltaX * sensitivity * 15;
+        // 요 회전에 따른 자동 롤 (뱅크 턴)
+        // 좌우로 회전할 때 자연스럽게 날개가 기울어짐
+        const yawRate = deltaX * sensitivity * 0.8;
+        this.targetRoll = -yawRate * 15; // 요 회전량에 비례하여 롤 발생
+        
+        // 각도 제한
+        const maxPitchAngle = Math.PI / 3; // 60도
+        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));
+        }
     }
 
     updateControls(keys, deltaTime) {
+        // 디버깅을 위한 로그
+        if (keys.w || keys.s || keys.a || keys.d) {
+            console.log('updateControls called:', {
+                w: keys.w,
+                a: keys.a,
+                s: keys.s,
+                d: keys.d,
+                throttle_before: this.throttle,
+                targetYaw_before: this.targetYaw,
+                deltaTime: deltaTime
+            });
+        }
+        
         // W/S: 스로틀만 제어 (가속/감속)
         if (keys.w) {
             this.throttle = Math.min(1.0, this.throttle + deltaTime * 0.5);
+            console.log('W pressed - New throttle:', this.throttle);
         }
         if (keys.s) {
             this.throttle = Math.max(0.1, this.throttle - deltaTime * 0.5);
+            console.log('S pressed - New throttle:', this.throttle);
         }
         
-        // A/D: 보조 요 제어 (러더)
+        // A/D: 보조 요 제어 (러더) - 반응성 개선
         if (keys.a) {
-            this.yawRate = -1.2;
-        } else if (keys.d) {
-            this.yawRate = 1.2;
-        } else if (!this.isMouseMoving) {
-            // 마우스 입력이 없고 키 입력도 없으면 요 속도를 0으로
-            this.yawRate *= 0.9;
+            this.targetYaw -= deltaTime * 1.2;
+            console.log('A pressed - New targetYaw:', this.targetYaw);
+        }
+        if (keys.d) {
+            this.targetYaw += deltaTime * 1.2;
+            console.log('D pressed - New targetYaw:', this.targetYaw);
         }
     }
 
     updatePhysics(deltaTime) {
         if (!this.mesh) return;
         
-        // 쿼터니언을 사용한 회전 업데이트
-        // 각 축에 대한 회전을 독립적으로 적용
-        
-        // 피치 회전 (항공기의 로컬 X축 기준)
-        const pitchAxis = new THREE.Vector3(1, 0, 0);
-        pitchAxis.applyQuaternion(this.quaternion);
-        const pitchQuat = new THREE.Quaternion().setFromAxisAngle(pitchAxis, this.pitchRate * deltaTime);
+        // 부드러운 회전 보간 - Yaw 회전 속도 개선
+        const rotationSpeed = deltaTime * 2.0;
+        const yawRotationSpeed = deltaTime * 3.0; // Yaw는 더 빠르게 반응하도록 별도 설정
         
-        // 요 회전 (월드 Y축 기준)
-        const yawAxis = new THREE.Vector3(0, 1, 0);
-        const yawQuat = new THREE.Quaternion().setFromAxisAngle(yawAxis, this.yawRate * deltaTime);
+        // 피치와 롤은 직접 보간
+        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); // 롤은 더 빠르게 반응
         
-        // 롤 회전 (항공기의 로컬 Z축 기준)
-        const rollAxis = new THREE.Vector3(0, 0, 1);
-        rollAxis.applyQuaternion(this.quaternion);
-        const rollQuat = new THREE.Quaternion().setFromAxisAngle(rollAxis, this.rollRate * deltaTime);
+        // Yaw 보간을 위한 각도 차이 계산 (최단 경로)
+        let yawDiff = this.targetYaw - this.rotation.y;
         
-        // 회전 적용 순서: yaw -> pitch -> roll
-        this.quaternion.multiply(yawQuat);
-        this.quaternion.multiply(pitchQuat);
-        this.quaternion.multiply(rollQuat);
+        // 각도 차이를 -π ~ π 범위로 정규화 (최단 회전 경로)
+        while (yawDiff > Math.PI) yawDiff -= Math.PI * 2;
+        while (yawDiff < -Math.PI) yawDiff += Math.PI * 2;
         
-        // 쿼터니언을 오일러 각도로 변환 (표시용)
-        this.rotation.setFromQuaternion(this.quaternion);
+        // 부드러운 yaw 회전 적용
+        this.rotation.y += yawDiff * yawRotationSpeed;
         
-        // 롤 자동 복귀
-        if (Math.abs(this.yawRate) < 0.1) {
-            this.rollRate *= 0.95;
+        // 롤 자동 복귀 시스템
+        if (Math.abs(this.targetYaw - this.rotation.y) < 0.05) {
+            // 요 회전이 거의 없을 때 롤을 0으로 복귀
+            this.targetRoll *= 0.95;
         }
         
-        // 회전 속도 감쇠
-        this.pitchRate *= 0.9;
-        if (!this.stallWarning) {
-            this.rollRate *= 0.9;
+        // 워썬더 스타일: 요 회전이 주도적, 롤은 보조적
+        // 롤에 따른 추가 요 회전은 제거하거나 최소화
+        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;
-        const maxSpeed = 600;
+        const minSpeed = 0; // 최소 속도 0kt
+        const maxSpeed = 600; // 최대 속도 600kt
         let targetSpeed = minSpeed + (maxSpeed - minSpeed) * this.throttle;
         
         // 피치 각도에 따른 속도 변화
@@ -332,81 +360,102 @@ class Fighter {
         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 계산
-        const turnRate = Math.abs(this.yawRate) * 10;
-        const pitchChangeRate = Math.abs(this.pitchRate) * 10;
+        // G-Force 계산 개선
+        const turnRate = Math.abs(bankTurnRate) * 100;
+        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 추가
         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); // 스로틀 배율 추가
         }
         
-        const maneuverG = (turnRate + pitchChangeRate + (Math.abs(this.rotation.z) * 3)) * (1 + throttleGMultiplier * 0.5);
+        // 급격한 기동에 의한 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);
         }
         
@@ -416,75 +465,89 @@ class Fighter {
         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.pitchRate = 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.pitchRate = 2.5;
-            
-            // 조종 불능 상태 - 흔들림 효과를 쿼터니언으로
-            const randomAxis = new THREE.Vector3(
-                (Math.random() - 0.5),
-                (Math.random() - 0.5),
-                (Math.random() - 0.5)
-            ).normalize();
-            const randomQuat = new THREE.Quaternion().setFromAxisAngle(randomAxis, deltaTime * 0.8);
-            this.quaternion.multiply(randomQuat);
-            
-            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 속도는 위에서 중력으로 처리됨
         }
         
         // 정상 비행 시 중력 효과
@@ -492,6 +555,7 @@ class Fighter {
             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;
@@ -505,6 +569,7 @@ class Fighter {
             this.position.y = GAME_CONSTANTS.MIN_ALTITUDE;
             this.health = 0;
             
+            // 지면 충돌 시 폭발 효과 추가
             if (window.gameInstance) {
                 window.gameInstance.createExplosionEffect(this.position);
             }
@@ -530,11 +595,10 @@ class Fighter {
         
         // 메시 위치 및 회전 업데이트
         this.mesh.position.copy(this.position);
-        this.mesh.quaternion.copy(this.quaternion);
-        
-        // 모델의 방향 보정 (F-15 모델이 Y축으로 회전되어 있음)
-        const modelOffset = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), 3 * Math.PI / 2);
-        this.mesh.quaternion.multiply(modelOffset);
+        this.mesh.rotation.order = 'YXZ'; // 메시도 같은 오일러 순서 사용
+        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;
@@ -546,21 +610,23 @@ class Fighter {
         // 고도 계산
         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,
@@ -568,35 +634,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();
             });
@@ -610,13 +679,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);
@@ -634,8 +711,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))