Update game.js

game.js

@@ -12,7 +12,7 @@ const GAME_CONSTANTS = {
     MAX_ALTITUDE: 15000,
     MIN_ALTITUDE: 0,
     MAX_SPEED: 800,
-    STALL_SPEED: 120,
+    STALL_SPEED: 300, // 300kt 이하에서 스톨 위험
     GRAVITY: 9.8,
     MOUSE_SENSITIVITY: 0.001,
     MAX_G_FORCE: 12.0,
@@ -29,14 +29,13 @@ class Fighter {
         
         // 물리 속성
         this.position = new THREE.Vector3(0, 2000, 0);
-        this.velocity = new THREE.Vector3(0, 0, 150);
+        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);
         
         // 비행 제어
-        this.baseSpeed = 150;
-        this.throttle = 0.5;
-        this.speed = 150;
+        this.throttle = 0.6; // 초기 스로틀 60%
+        this.speed = 350; // 초기 속도 350kt
         this.altitude = 2000;
         this.gForce = 1.0;
         this.health = 100;
@@ -81,7 +80,8 @@ class Fighter {
             altitude: null,
             pullup: null,
             overg: null,
-            stall: null
+            stall: null,
+            normal: null // 엔진 소리 추가
         };
         this.initializeWarningAudios();
     }
@@ -100,8 +100,14 @@ class Fighter {
             this.warningAudios.stall = new Audio('sounds/alert.ogg');
             this.warningAudios.stall.volume = 0.75;
             
+            // 엔진 소리 설정
+            this.warningAudios.normal = new Audio('sounds/normal.ogg');
+            this.warningAudios.normal.volume = 0.5;
+            this.warningAudios.normal.loop = true; // 엔진 소리는 계속 반복
+            
+            // 경고음에만 ended 이벤트 리스너 추가 (엔진 소리 제외)
             Object.keys(this.warningAudios).forEach(key => {
-                if (this.warningAudios[key]) {
+                if (key !== 'normal' && this.warningAudios[key]) {
                     this.warningAudios[key].addEventListener('ended', () => {
                         this.updateWarningAudios();
                     });
@@ -112,6 +118,15 @@ class Fighter {
         }
     }
     
+    startEngineSound() {
+        // 엔진 소리 시작
+        if (this.warningAudios.normal) {
+            this.warningAudios.normal.play().catch(e => {
+                console.log('Engine sound failed to start:', e);
+            });
+        }
+    }
+    
     updateWarningAudios() {
         let currentWarning = null;
         
@@ -128,8 +143,9 @@ class Fighter {
             currentWarning = 'stall';
         }
         
+        // 경고음만 관리 (엔진 소리는 제외)
         Object.keys(this.warningAudios).forEach(key => {
-            if (key !== currentWarning && this.warningAudios[key] && !this.warningAudios[key].paused) {
+            if (key !== 'normal' && key !== currentWarning && this.warningAudios[key] && !this.warningAudios[key].paused) {
                 this.warningAudios[key].pause();
                 this.warningAudios[key].currentTime = 0;
             }
@@ -143,6 +159,7 @@ class Fighter {
     }
     
     stopAllWarningAudios() {
+        // 모든 오디오 정지 (엔진 소리 포함)
         Object.values(this.warningAudios).forEach(audio => {
             if (audio && !audio.paused) {
                 audio.pause();
@@ -215,24 +232,30 @@ class Fighter {
     updateMouseInput(deltaX, deltaY) {
         const sensitivity = GAME_CONSTANTS.MOUSE_SENSITIVITY * 2.0;
         
+        // 마우스 X축: 순수 롤(날개 기울이기)만 조정
         this.targetRoll += deltaX * sensitivity;
+        
+        // 마우스 Y축: 피치(기수 상하)
         this.targetPitch -= deltaY * sensitivity;
         
-        const maxPitchAngle = Math.PI / 3;
-        const maxRollAngle = Math.PI;
+        // 각도 제한
+        const maxPitchAngle = Math.PI / 3; // 60도
+        const maxRollAngle = Math.PI; // 180도
         
         this.targetPitch = Math.max(-maxPitchAngle, Math.min(maxPitchAngle, this.targetPitch));
         this.targetRoll = Math.max(-maxRollAngle, Math.min(maxRollAngle, this.targetRoll));
     }
 
     updateControls(keys, deltaTime) {
+        // W/S: 스로틀만 제어 (가속/감속)
         if (keys.w) {
-            this.throttle = Math.min(1.0, this.throttle + deltaTime * 0.8);
+            this.throttle = Math.min(1.0, this.throttle + deltaTime * 0.5); // 천천히 가속
         }
         if (keys.s) {
-            this.throttle = Math.max(0.1, this.throttle - deltaTime * 0.8);
+            this.throttle = Math.max(0.1, this.throttle - deltaTime * 0.5); // 천천히 감속
         }
         
+        // A/D: 러더 제어 (요 회전)
         if (keys.a) {
             this.targetYaw -= deltaTime * 0.8;
         }
@@ -244,48 +267,81 @@ class Fighter {
     updatePhysics(deltaTime) {
         if (!this.mesh) return;
         
+        // 부드러운 회전 보간
         const rotationSpeed = 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);
         
+        // 현실적인 비행 물리: 롤에 따른 자연스러운 선회
         let bankTurnRate = 0;
         if (Math.abs(this.rotation.z) > 0.1) {
             const bankAngle = this.rotation.z;
-            bankTurnRate = Math.sin(bankAngle) * deltaTime * 0.7;
+            // 날개가 기울어질 때만 선회 (현실적인 비행)
+            bankTurnRate = Math.sin(bankAngle) * deltaTime * 0.5; // 선회율 감소
             this.targetYaw += bankTurnRate;
         }
         
+        // 요 회전 적용
         this.rotation.y = THREE.MathUtils.lerp(this.rotation.y, this.targetYaw, rotationSpeed);
         
-        const minSpeed = 100;
-        const maxSpeed = 300;
+        // 현실적인 속도 계산
+        const minSpeed = 150; // 최소 속도 150kt
+        const maxSpeed = 600; // 최대 속도 600kt
         let targetSpeed = minSpeed + (maxSpeed - minSpeed) * this.throttle;
         
-        const pitchAngle = Math.abs(this.rotation.x);
-        if (pitchAngle > Math.PI / 6) {
-            const stallFactor = Math.max(0.3, 1 - (pitchAngle - Math.PI / 6) * 2);
-            targetSpeed *= stallFactor;
+        // 피치 각도에 따른 속도 변화 (상승시 감속, 하강시 가속)
+        const pitchAngle = this.rotation.x;
+        if (pitchAngle < -0.1) { // 기수가 위로 (상승)
+            const climbFactor = Math.abs(pitchAngle) / (Math.PI / 3);
+            targetSpeed *= (1 - climbFactor * 0.3); // 최대 30% 감속
+        } else if (pitchAngle > 0.1) { // 기수가 아래로 (하강)
+            const diveFactor = pitchAngle / (Math.PI / 3);
+            targetSpeed *= (1 + diveFactor * 0.2); // 최대 20% 가속
         }
         
-        this.speed = THREE.MathUtils.lerp(this.speed, targetSpeed, deltaTime * 2);
+        // 속도 변화를 천천히 적용
+        this.speed = THREE.MathUtils.lerp(this.speed, targetSpeed, deltaTime * 0.5);
         
-        this.stallWarning = this.speed < GAME_CONSTANTS.STALL_SPEED;
+        // 스톨 경고: 300kt 이하에서 스톨 위험
+        const speedKnots = this.speed * 1.94384; // m/s to knots
+        this.stallWarning = speedKnots < GAME_CONSTANTS.STALL_SPEED;
         
+        // 스톨 상태에서의 물리 효과
+        if (this.stallWarning) {
+            // 기수가 아래로 떨어짐
+            this.targetPitch += deltaTime * 0.5;
+            // 조종성 감소
+            this.rotation.x += (Math.random() - 0.5) * deltaTime * 0.2;
+            this.rotation.z += (Math.random() - 0.5) * deltaTime * 0.2;
+        }
+        
+        // 속도 벡터 계산
         const noseDirection = new THREE.Vector3(0, 0, 1);
         noseDirection.applyEuler(this.rotation);
         this.velocity = noseDirection.multiplyScalar(this.speed);
         
-        const gravityEffect = GAME_CONSTANTS.GRAVITY * deltaTime * 0.1;
+        // 현실적인 중력 효과
+        const gravityEffect = GAME_CONSTANTS.GRAVITY * deltaTime * 0.15;
         this.velocity.y -= gravityEffect;
         
+        // 양력 효과 (속도에 비례)
+        if (!this.stallWarning) {
+            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;
             return;
         }
         
+        // 최대 고도 제한
         if (this.position.y > GAME_CONSTANTS.MAX_ALTITUDE) {
             this.position.y = GAME_CONSTANTS.MAX_ALTITUDE;
             this.altitudeWarning = true;
@@ -294,32 +350,44 @@ 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.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;
         }
         
+        // 고도 및 G-Force 계산
         this.altitude = this.position.y;
         
+        // G-Force 계산
         const turnRate = Math.abs(bankTurnRate) * 100;
         const pitchRate = Math.abs(this.rotation.x - this.targetPitch) * 10;
         this.gForce = 1.0 + turnRate + pitchRate + (Math.abs(this.rotation.z) * 3);
         
+        // Over-G 체크
         this.overG = this.gForce > this.maxGForce;
         
+        // 경고음 업데이트 (엔진 소리는 계속 유지)
         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) {
@@ -821,6 +889,9 @@ class Game {
         this.isStarted = true;
         this.startGameTimer();
         
+        // 엔진 소리 시작
+        this.fighter.startEngineSound();
+        
         console.log('게임 시작!');
     }
 
@@ -936,6 +1007,7 @@ class Game {
             
             if (this.fighter.stallWarning) {
                 warningText += 'STALL WARNING\n';
+                warningText += '<span style="font-size: 16px;">INCREASE THROTTLE</span>\n';
             }
             
             if (this.fighter.overG) {