Update game.js

game.js

@@ -25,7 +25,10 @@ const GAME_CONSTANTS = {
     AIM9_DAMAGE: 1000,  // AIM-9 미사일 피해 1000!
     AIM9_SPEED: 514.4, // 1000kt를 m/s로 변환
     AIM9_LOCK_RANGE: 6000, // 락온 거리 6000m
-    AIM9_LOCK_REQUIRED: 3  // 3번 락온 필요
+    AIM9_LOCK_REQUIRED: 3,  // 3번 락온 필요
+    ENEMY_AIM9_COUNT: 4,    // 적 AIM-9 미사일 수
+    ENEMY_LOCK_RANGE: 5000, // 적 락온 거리
+    ENEMY_LOCK_ANGLE: Math.PI / 12 // 적 락온 각도 (15도)
 };
 
 // 전투기 클래스
@@ -108,9 +111,16 @@ class Fighter {
            pullup: null,
            overg: null,
            stall: null,
-           normal: null // 엔진 소리
+           normal: null, // 엔진 소리
+           missileLock: null,
+           missileIncoming: null
        };
        this.initializeWarningAudios();
+       
+       // 미사일 경고 시스템
+       this.incomingMissiles = []; // 플레이어를 향해 날아오는 미사일
+       this.missileWarningActive = false;
+       this.beingLockedBy = []; // 락온 중인 적들
    }
    
    // 헤딩을 0~360도로 정규화하는 헬퍼 함수
@@ -147,9 +157,18 @@ class Fighter {
            this.warningAudios.normal.volume = 0.5;
            this.warningAudios.normal.loop = true; // 엔진 소리는 계속 반복
            
+           // 미사일 경고음 추가
+           this.warningAudios.missileLock = new Audio('sounds/missile2.ogg');
+           this.warningAudios.missileLock.volume = 0.8;
+           this.warningAudios.missileLock.loop = true;
+           
+           this.warningAudios.missileIncoming = new Audio('sounds/missile3.ogg');
+           this.warningAudios.missileIncoming.volume = 1.0;
+           this.warningAudios.missileIncoming.loop = true;
+           
            // 경고음에만 ended 이벤트 리스너 추가 (엔진 소리 제외)
            Object.keys(this.warningAudios).forEach(key => {
-               if (key !== 'normal' && this.warningAudios[key]) {
+               if (key !== 'normal' && key !== 'missileLock' && key !== 'missileIncoming' && this.warningAudios[key]) {
                    this.warningAudios[key].addEventListener('ended', () => {
                        this.updateWarningAudios();
                    });
@@ -185,6 +204,35 @@ class Fighter {
    updateWarningAudios() {
        let currentWarning = null;
        
+       // 미사일 경고가 최우선
+       if (this.incomingMissiles.length > 0) {
+           // missileIncoming 재생
+           if (this.warningAudios.missileIncoming && this.warningAudios.missileIncoming.paused) {
+               this.warningAudios.missileIncoming.play().catch(e => {});
+           }
+       } else {
+           // 미사일이 없으면 missileIncoming 중지
+           if (this.warningAudios.missileIncoming && !this.warningAudios.missileIncoming.paused) {
+               this.warningAudios.missileIncoming.pause();
+               this.warningAudios.missileIncoming.currentTime = 0;
+           }
+       }
+       
+       // 락온 경고
+       if (this.beingLockedBy.length > 0 && this.incomingMissiles.length === 0) {
+           // missileLock 재생
+           if (this.warningAudios.missileLock && this.warningAudios.missileLock.paused) {
+               this.warningAudios.missileLock.play().catch(e => {});
+           }
+       } else {
+           // 락온이 없으면 missileLock 중지
+           if (this.warningAudios.missileLock && !this.warningAudios.missileLock.paused) {
+               this.warningAudios.missileLock.pause();
+               this.warningAudios.missileLock.currentTime = 0;
+           }
+       }
+       
+       // 기존 경고음 처리
        if (this.altitude < 250) {
            currentWarning = 'pullup';
        }
@@ -198,9 +246,10 @@ class Fighter {
            currentWarning = 'stall';
        }
        
-       // 경고음만 관리 (엔진 소리는 제외)
+       // 경고음만 관리 (엔진 소리, 미사일 경고음 제외)
        Object.keys(this.warningAudios).forEach(key => {
-           if (key !== 'normal' && key !== currentWarning && this.warningAudios[key] && !this.warningAudios[key].paused) {
+           if (key !== 'normal' && key !== 'missileLock' && key !== 'missileIncoming' && 
+               key !== currentWarning && this.warningAudios[key] && !this.warningAudios[key].paused) {
                this.warningAudios[key].pause();
                this.warningAudios[key].currentTime = 0;
            }
@@ -1616,6 +1665,15 @@ class EnemyFighter {
         this.nearbyEnemies = [];
         this.avoidanceVector = new THREE.Vector3();
         
+        // AIM-9 미사일 시스템
+        this.aim9Missiles = GAME_CONSTANTS.ENEMY_AIM9_COUNT;
+        this.firedMissiles = [];
+        this.lockTarget = null;
+        this.lockProgress = 0;
+        this.lastLockTime = 0;
+        this.lastMissileFireTime = 0;
+        this.isLocking = false;
+        
         // 초기 목표 설정
         this.selectNewPatrolTarget();
     }
@@ -1711,6 +1769,14 @@ update(playerPosition, deltaTime) {
     
     // 탄환 업데이트
     this.updateBullets(deltaTime);
+    
+    // 미사일 업데이트
+    this.updateMissiles(deltaTime);
+    
+    // 락온 시스템 업데이트
+    if (this.playerFighter) {
+        this.updateLockOn(deltaTime);
+    }
 }
     
     executePatrol(deltaTime) {
@@ -1732,7 +1798,6 @@ update(playerPosition, deltaTime) {
     executeCombat(playerPosition, deltaTime) {
         const distance = this.position.distanceTo(playerPosition);
         
-        
         // 플레이어를 향해 회전
         this.smoothTurnToTarget(playerPosition, deltaTime);
         
@@ -2093,6 +2158,136 @@ update(playerPosition, deltaTime) {
         }
     }
     
+    updateMissiles(deltaTime) {
+        for (let i = this.firedMissiles.length - 1; i >= 0; i--) {
+            const missile = this.firedMissiles[i];
+            const result = missile.update(deltaTime, this.position);
+            
+            if (result === 'hit' || result === 'expired') {
+                this.firedMissiles.splice(i, 1);
+            }
+        }
+    }
+    
+    updateLockOn(deltaTime) {
+        if (!this.playerFighter || this.aim9Missiles <= 0) {
+            this.lockTarget = null;
+            this.lockProgress = 0;
+            this.isLocking = false;
+            return;
+        }
+        
+        const now = Date.now();
+        const distance = this.position.distanceTo(this.playerFighter.position);
+        
+        // 락온 범위 내에 있고 전투 중일 때만
+        if (distance <= GAME_CONSTANTS.ENEMY_LOCK_RANGE && this.aiState === 'combat') {
+            // 플레이어가 시야각 내에 있는지 확인
+            const toPlayer = this.playerFighter.position.clone().sub(this.position).normalize();
+            const forward = new THREE.Vector3(0, 0, 1).applyEuler(this.rotation);
+            const dotProduct = forward.dot(toPlayer);
+            const angle = Math.acos(Math.max(-1, Math.min(1, dotProduct)));
+            
+            if (angle < GAME_CONSTANTS.ENEMY_LOCK_ANGLE) {
+                // 1초마다 락온 진행
+                if (now - this.lastLockTime >= 1000) {
+                    if (this.lockTarget === this.playerFighter) {
+                        this.lockProgress++;
+                        this.lastLockTime = now;
+                        
+                        // 락온 시작 알림
+                        if (this.lockProgress === 1 && !this.isLocking) {
+                            this.isLocking = true;
+                            if (window.gameInstance) {
+                                window.gameInstance.onEnemyLockStart(this);
+                            }
+                        }
+                        
+                        // 락온 완료 및 발사
+                        if (this.lockProgress >= GAME_CONSTANTS.AIM9_LOCK_REQUIRED) {
+                            // 미사일 쿨다운 체크 (3초)
+                            if (now - this.lastMissileFireTime >= 3000) {
+                                this.fireAIM9();
+                                this.lastMissileFireTime = now;
+                            }
+                            // 락온 리셋
+                            this.lockTarget = null;
+                            this.lockProgress = 0;
+                            this.isLocking = false;
+                        }
+                    } else {
+                        // 새로운 락온 시작
+                        this.lockTarget = this.playerFighter;
+                        this.lockProgress = 1;
+                        this.lastLockTime = now;
+                        this.isLocking = true;
+                        if (window.gameInstance) {
+                            window.gameInstance.onEnemyLockStart(this);
+                        }
+                    }
+                }
+            } else {
+                // 시야각을 벗어나면 락온 해제
+                if (this.lockTarget) {
+                    this.lockTarget = null;
+                    this.lockProgress = 0;
+                    if (this.isLocking) {
+                        this.isLocking = false;
+                        if (window.gameInstance) {
+                            window.gameInstance.onEnemyLockLost(this);
+                        }
+                    }
+                }
+            }
+        } else {
+            // 범위를 벗어나면 락온 해제
+            if (this.lockTarget) {
+                this.lockTarget = null;
+                this.lockProgress = 0;
+                if (this.isLocking) {
+                    this.isLocking = false;
+                    if (window.gameInstance) {
+                        window.gameInstance.onEnemyLockLost(this);
+                    }
+                }
+            }
+        }
+    }
+    
+    fireAIM9() {
+        if (this.aim9Missiles <= 0 || !this.lockTarget) return;
+        
+        this.aim9Missiles--;
+        
+        // 날개 발사 위치
+        const isLeftWing = Math.random() < 0.5;
+        const wingOffset = new THREE.Vector3(isLeftWing ? -6 : 6, -1, 2);
+        wingOffset.applyEuler(this.rotation);
+        const missileStartPos = this.position.clone().add(wingOffset);
+        
+        // 미사일 생성
+        const missile = new EnemyAIM9Missile(this.scene, missileStartPos, this.lockTarget, this.rotation.clone());
+        this.firedMissiles.push(missile);
+        
+        // 발사 알림
+        if (window.gameInstance) {
+            window.gameInstance.onEnemyMissileLaunch(this, missile);
+        }
+        
+        // 발사음 (거리에 따라)
+        if (this.playerFighter) {
+            const distanceToPlayer = this.position.distanceTo(this.playerFighter.position);
+            if (distanceToPlayer < 3000) {
+                try {
+                    const missileSound = new Audio('sounds/missile.ogg');
+                    const volumeMultiplier = 1 - (distanceToPlayer / 3000);
+                    missileSound.volume = 0.5 * volumeMultiplier;
+                    missileSound.play().catch(e => {});
+                } catch (e) {}
+            }
+        }
+    }
+    
     calculateAimAccuracy(target) {
         const toTarget = target.clone().sub(this.position).normalize();
         const forward = new THREE.Vector3(0, 0, 1).applyEuler(this.rotation);
@@ -2152,6 +2347,8 @@ update(playerPosition, deltaTime) {
             this.scene.remove(this.mesh);
             this.bullets.forEach(bullet => this.scene.remove(bullet));
             this.bullets = [];
+            this.firedMissiles.forEach(missile => missile.destroy());
+            this.firedMissiles = [];
             this.isLoaded = false;
         }
     }
@@ -2565,6 +2762,50 @@ class Game {
         }, 1000);
     }
 
+    // 적이 플레이어를 락온 시작할 때
+    onEnemyLockStart(enemy) {
+        console.log('Warning: Enemy locking on!');
+        
+        // 락온 중인 적 추가
+        if (!this.fighter.beingLockedBy.includes(enemy)) {
+            this.fighter.beingLockedBy.push(enemy);
+        }
+        
+        // 경고음 업데이트
+        this.fighter.updateWarningAudios();
+    }
+    
+    // 적이 락온을 잃었을 때
+    onEnemyLockLost(enemy) {
+        console.log('Enemy lock lost');
+        
+        // 락온 목록에서 제거
+        const index = this.fighter.beingLockedBy.indexOf(enemy);
+        if (index !== -1) {
+            this.fighter.beingLockedBy.splice(index, 1);
+        }
+        
+        // 경고음 업데이트
+        this.fighter.updateWarningAudios();
+    }
+    
+    // 적이 미사일을 발사했을 때
+    onEnemyMissileLaunch(enemy, missile) {
+        console.log('Warning: Missile launched!');
+        
+        // 플레이어의 incoming missiles 목록에 추가
+        this.fighter.incomingMissiles.push(missile);
+        
+        // 락온 목록에서 제거 (미사일 발사 후 락온 해제)
+        const index = this.fighter.beingLockedBy.indexOf(enemy);
+        if (index !== -1) {
+            this.fighter.beingLockedBy.splice(index, 1);
+        }
+        
+        // 경고음 업데이트
+        this.fighter.updateWarningAudios();
+    }
+
     updateUI() {
         if (this.fighter.isLoaded) {
             const speedKnots = Math.round(this.fighter.speed * 1.94384);
@@ -2781,9 +3022,60 @@ class Game {
         const existingStallWarnings = document.querySelectorAll('.stall-escape-warning');
         existingStallWarnings.forEach(w => w.remove());
         
+        // 미사일 경고 제거
+        const existingMissileWarnings = document.querySelectorAll('.missile-warning');
+        existingMissileWarnings.forEach(w => w.remove());
+        
         // 고도 경고 외곽 효과
         let altitudeEdgeEffect = document.getElementById('altitudeEdgeEffect');
-        if (this.fighter.altitude < 500) {
+        
+        // 미사일 경고가 최우선
+        if (this.fighter.incomingMissiles.length > 0) {
+            if (!altitudeEdgeEffect) {
+                altitudeEdgeEffect = document.createElement('div');
+                altitudeEdgeEffect.id = 'altitudeEdgeEffect';
+                document.body.appendChild(altitudeEdgeEffect);
+            }
+            
+            // 강렬한 붉은색 효과
+            const edgeIntensity = 0.8;
+            altitudeEdgeEffect.style.cssText = `
+                position: fixed;
+                top: 0;
+                left: 0;
+                width: 100%;
+                height: 100%;
+                pointer-events: none;
+                z-index: 1300;
+                background: radial-gradient(ellipse at center, 
+                    transparent 30%, 
+                    rgba(255, 0, 0, ${edgeIntensity * 0.4}) 50%, 
+                    rgba(255, 0, 0, ${edgeIntensity}) 100%);
+                box-shadow: inset 0 0 200px rgba(255, 0, 0, ${edgeIntensity}),
+                           inset 0 0 150px rgba(255, 0, 0, ${edgeIntensity * 0.8});
+                animation: missile-pulse 0.3s infinite;
+            `;
+            
+            // 미사일 경고 텍스트
+            const missileWarning = document.createElement('div');
+            missileWarning.className = 'missile-warning';
+            missileWarning.style.cssText = `
+                position: fixed;
+                top: 20%;
+                left: 50%;
+                transform: translateX(-50%);
+                color: #ff0000;
+                font-size: 36px;
+                font-weight: bold;
+                text-shadow: 0 0 20px rgba(255,0,0,1), 0 0 40px rgba(255,0,0,0.8);
+                z-index: 1600;
+                text-align: center;
+                animation: missile-blink 0.2s infinite;
+            `;
+            missileWarning.innerHTML = 'MISSILE INCOMING!<br>EVADE! EVADE!';
+            document.body.appendChild(missileWarning);
+            
+        } else if (this.fighter.altitude < 500) {
             if (!altitudeEdgeEffect) {
                 altitudeEdgeEffect = document.createElement('div');
                 altitudeEdgeEffect.id = 'altitudeEdgeEffect';
@@ -2940,6 +3232,18 @@ class Game {
                             opacity: 0.7;
                         }
                     }
+                    @keyframes missile-pulse {
+                        0%, 100% { 
+                            opacity: 1;
+                        }
+                        50% { 
+                            opacity: 0.5;
+                        }
+                    }
+                    @keyframes missile-blink {
+                        0%, 50% { opacity: 1; }
+                        51%, 100% { opacity: 0.2; }
+                    }
                 `;
                 document.head.appendChild(style);
             }
@@ -3216,33 +3520,6 @@ class Game {
         }
     }
 
-    // 적이 플레이어를 락온 시작할 때
-    onEnemyLockStart(enemy) {
-        console.log('Warning: Enemy locking on!');
-        // 여기에 락온 경고 UI나 사운드 추가 가능
-    }
-    
-    // 적이 락온을 잃었을 때
-    onEnemyLockLost(enemy) {
-        console.log('Enemy lock lost');
-        // 락온 경고 해제
-    }
-    
-    // 적이 미사일을 발사했을 때
-    onEnemyMissileLaunch(enemy, missile) {
-        console.log('Warning: Missile launched!');
-        // 미사일 경고음 재생
-        try {
-            const warningSound = new Audio('sounds/missilewarning.ogg');
-            warningSound.volume = 0.8;
-            warningSound.play().catch(e => {
-                console.log('Missile warning sound not found');
-            });
-        } catch (e) {}
-    }
-
-  
-    
     checkCollisions() {
         // 플레이어와 적기의 직접 충돌 체크 (최우선)
         for (let i = this.enemies.length - 1; i >= 0; i--) {
@@ -3370,6 +3647,11 @@ class Game {
                 }
             }
         });
+        
+        // incoming missiles 업데이트 (파괴된 미사일 제거)
+        this.fighter.incomingMissiles = this.fighter.incomingMissiles.filter(missile => {
+            return missile && missile.mesh && missile.mesh.parent;
+        });
     }
 
     createHitEffect(position) {
@@ -3812,7 +4094,7 @@ class Game {
         document.exitPointerLock();
         
         // 모든 경고 및 효과 제거
-        const existingWarnings = document.querySelectorAll('.warning-message, .stall-escape-warning');
+        const existingWarnings = document.querySelectorAll('.warning-message, .stall-escape-warning, .missile-warning');
         existingWarnings.forEach(w => w.remove());
         
         const blurEffect = document.getElementById('overGBlurEffect');