Update game.js

game.js

@@ -33,7 +33,17 @@ 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.rotation = new THREE.Euler(0, 0, 0, 'YXZ'); // 오일러 각도 순서를 YXZ로 변경하여 짐벌 락 방지
+        
+        // 쿼터니언 기반 회전 (짐벌 락 방지)
+        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%
@@ -51,11 +61,6 @@ 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;
@@ -183,7 +188,11 @@ class Fighter {
             this.mesh = result.scene;
             this.mesh.position.copy(this.position);
             this.mesh.scale.set(2, 2, 2);
-            this.mesh.rotation.y = Math.PI / 4;
+            
+            // 초기 회전 설정
+            const initialYaw = Math.PI / 4;
+            this.quaternion.setFromEuler(new THREE.Euler(0, initialYaw, 0));
+            this.targetYaw = initialYaw;
             
             this.mesh.traverse((child) => {
                 if (child.isMesh) {
@@ -242,320 +251,282 @@ 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));
         }
     }
 
     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.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;
         
-        // 부드러운 회전 보간 - Yaw 회전 속도 개선
+        // 쿼터니언을 사용한 부드러운 회전
         const rotationSpeed = deltaTime * 2.0;
-        const yawRotationSpeed = deltaTime * 3.0; // Yaw는 더 빠르게 반응하도록 별도 설정
+        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); // 롤은 더 빠르게 반응
+        // 현재 쿼터니언에서 오일러 각도 추출 (표시용)
+        this.rotation.setFromQuaternion(this.quaternion);
         
-        // Yaw 보간을 위한 각도 차이 계산 (최단 경로)
+        // 각 축의 회전 차이 계산
+        let pitchDiff = this.targetPitch - this.rotation.x;
         let yawDiff = this.targetYaw - this.rotation.y;
+        let rollDiff = this.targetRoll - this.rotation.z;
         
-        // 각도 차이를 -π ~ π 범위로 정규화 (최단 회전 경로)
+        // 각도 차이 정규화 (-π ~ π)
         while (yawDiff > Math.PI) yawDiff -= Math.PI * 2;
         while (yawDiff < -Math.PI) yawDiff += Math.PI * 2;
         
-        // 부드러운 yaw 회전 적용
-        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();
         
         // 롤 자동 복귀 시스템
-        if (Math.abs(this.targetYaw - this.rotation.y) < 0.05) {
-            // 요 회전이 거의 없을 때 롤을 0으로 복귀
+        if (Math.abs(yawDiff) < 0.05) {
             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; // 최소 속도 0kt
-        const maxSpeed = 600; // 최대 속도 600kt
+        // 속도 계산
+        const minSpeed = 0;
+        const maxSpeed = 600;
         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까지)
+        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);
             } 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); // 하강 시 가속 증가 (0.2 -> 0.4)
+            targetSpeed *= (1 + diveFactor * 0.4);
         }
         
-        // G-Force 계산 개선
+        // G-Force 계산
         const turnRate = Math.abs(bankTurnRate) * 100;
-        const pitchRate = Math.abs(this.rotation.x - this.targetPitch) * 10;
+        const pitchRate = Math.abs(pitchDiff) * 10;
         
-        // 고도에 따른 G-Force 증가 배율 계산
-        const altitudeInKm = this.position.y / 1000; // 미터를 킬로미터로 변환
-        const altitudeMultiplier = 1 + (altitudeInKm * 0.2); // 1km당 20% 증가
+        const altitudeInKm = this.position.y / 1000;
+        const altitudeMultiplier = 1 + (altitudeInKm * 0.2);
         
-        // 스로틀에 따른 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;
         
-        // 뒤집힌 상태 (롤이 90도 이상)
+        const rollDegrees = Math.abs(this.rotation.z) * (180 / Math.PI);
         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) {
-            // 40도 이상일 때 급격한 G-Force 증가
-            const extremePitchG = (pitchDegrees - 40) * 0.15; // 40도 초과분당 0.15G 추가
+            const extremePitchG = (pitchDegrees - 40) * 0.15;
             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 회복 조건 수정
-        // 1. Over-G 상태가 아닌 경우에만 회복
-        // 2. 피치가 ±10도 이내일 때만 회복
-        // 3. 스톨 상태가 아닐 때만 회복
+        // G-Force 회복
         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
+            const recoveryRate = 2.0 - throttleGMultiplier * 1.5;
             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 상태���서는 더 느린 회복
+                const overGRecoveryRate = 0.3 - throttleGMultiplier * 0.2;
                 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; // Over-G 상태가 아니면 타이머 리셋
+            this.overGTimer = 0;
         }
         
-        // 스톨 경고: 300kt 이하에서 스톨 위험
-        const speedKnots = this.speed * 1.94384; // m/s to knots
-        const wasStalling = this.stallWarning;
+        // 스톨 체크
+        const speedKnots = this.speed * 1.94384;
         
-        // 스톨 진입 조건
         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); // 최대 200m/s 증가
+            if (pitchAngle > 0.1) {
+                const diveSpeedGain = Math.min(pitchAngle * 300, 200);
                 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.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.velocity.y -= gravityAcceleration;
         }
         
-        // 속도 벡터 계산
+        // 속도 벡터 계산 (쿼터니언 사용)
         const noseDirection = new THREE.Vector3(0, 0, 1);
-        noseDirection.applyEuler(this.rotation);
+        noseDirection.applyQuaternion(this.quaternion);
         
         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;
@@ -569,7 +540,6 @@ class Fighter {
             this.position.y = GAME_CONSTANTS.MIN_ALTITUDE;
             this.health = 0;
             
-            // 지면 충돌 시 폭발 효과 추가
             if (window.gameInstance) {
                 window.gameInstance.createExplosionEffect(this.position);
             }
@@ -577,7 +547,7 @@ class Fighter {
             return;
         }
         
-        // 최대 고도 제한
+        // 고도 제한
         if (this.position.y > GAME_CONSTANTS.MAX_ALTITUDE) {
             this.position.y = GAME_CONSTANTS.MAX_ALTITUDE;
             this.altitudeWarning = true;
@@ -586,47 +556,43 @@ 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.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.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.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
+            this.warningAudios.normal.volume = 0.3 + this.throttle * 0.4;
         }
     }
 
     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 bulletGeometry = new THREE.CylinderGeometry(1.0, 1.0, 16, 8);
         const bulletMaterial = new THREE.MeshBasicMaterial({ 
             color: 0xffff00,
             emissive: 0xffff00,
@@ -634,38 +600,35 @@ class Fighter {
         });
         const bullet = new THREE.Mesh(bulletGeometry, bulletMaterial);
         
-        // 기수 끝에서 발사 (더 앞쪽에서)
+        // 쿼터니언을 사용한 발사 위치
         const muzzleOffset = new THREE.Vector3(0, 0, 10);
-        muzzleOffset.applyEuler(this.rotation);
+        muzzleOffset.applyQuaternion(this.quaternion);
         bullet.position.copy(this.position).add(muzzleOffset);
         
-        // 탄환을 발사 방향으로 회전
-        bullet.rotation.copy(this.rotation);
-        bullet.rotateX(Math.PI / 2); // 실린더가 Z축 방향을 향하도록
+        // 탄환 회전 설정
+        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.startPosition = bullet.position.clone();
         
-        const bulletSpeed = 1500; // 1000에서 1500으로 증가 (50% 빠르게)
+        const bulletSpeed = 1500;
         const direction = new THREE.Vector3(0, 0, 1);
-        direction.applyEuler(this.rotation);
+        direction.applyQuaternion(this.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% 줄임)
+            audio.volume = 0.15;
             
-            // -2 ~ +2 사이의 랜덤 피치 (playbackRate로 시뮬레이션)
-            const randomPitch = 0.8 + Math.random() * 0.4; // 0.8 ~ 1.2 범위
+            const randomPitch = 0.8 + Math.random() * 0.4;
             audio.playbackRate = randomPitch;
             
             audio.play().catch(e => console.log('Gunfire sound failed to play'));
             
-            // 재생 완료 시 메모리 정리를 위해 참조 제거
             audio.addEventListener('ended', () => {
                 audio.remove();
             });
@@ -679,21 +642,13 @@ 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);
@@ -711,8 +666,8 @@ class Fighter {
         const backward = new THREE.Vector3(0, 0, -1);
         const up = new THREE.Vector3(0, 1, 0);
         
-        backward.applyEuler(this.rotation);
-        up.applyEuler(this.rotation);
+        backward.applyQuaternion(this.quaternion);
+        up.applyQuaternion(this.quaternion);
         
         const cameraPosition = this.position.clone()
             .add(backward.multiplyScalar(this.cameraDistance))