Update game.js

game.js

@@ -20,6 +20,7 @@ const GAME_CONSTANTS = {
     MISSILE_COUNT: 6,
     AMMO_COUNT: 940,  // 940발로 변경
     BULLET_DAMAGE: 25, // 발당 25 데미지
+    MISSILE_DAMAGE: 500, // 미사일 데미지
     MAX_HEALTH: 1000  // 체력 1000
 };
 
@@ -60,10 +61,19 @@ class Fighter {
         this.missiles = GAME_CONSTANTS.MISSILE_COUNT;
         this.ammo = GAME_CONSTANTS.AMMO_COUNT;
         this.bullets = [];
+        this.activeMissiles = []; // 발사된 미사일
         this.lastShootTime = 0;
         this.isMouseDown = false; // 마우스 누름 상태 추적
         this.gunfireAudios = []; // 기관총 소리 배열 (최대 5개)
         
+        // 무기 시스템
+        this.currentWeapon = 'mg'; // 'mg' or 'missile'
+        this.weaponCooldown = 0; // 무기 쿨다운
+        this.missileTarget = null; // 미사일 타겟
+        this.missileLockTimer = 0; // 락온 타이머
+        this.missileLockCount = 0; // 락온 카운트 (3번 필요)
+        this.lastMissileFire = 0; // 마지막 미사일 발사 시간
+        
         // 스톨 탈출을 위한 F키 상태
         this.escapeKeyPressed = false;
         this.stallEscapeProgress = 0; // 스톨 탈출 진행도 (0~2초)
@@ -642,6 +652,7 @@ class Fighter {
     }
 
     updateBullets(scene, deltaTime) {
+        // 기관총 탄환 업데이트
         for (let i = this.bullets.length - 1; i >= 0; i--) {
             const bullet = this.bullets[i];
             bullet.position.add(bullet.velocity.clone().multiplyScalar(deltaTime));
@@ -659,6 +670,204 @@ class Fighter {
                 this.bullets.splice(i, 1);
             }
         }
+        
+        // 미사일 업데이트
+        for (let i = this.activeMissiles.length - 1; i >= 0; i--) {
+            const missile = this.activeMissiles[i];
+            
+            if (missile.target && missile.target.mesh && missile.target.isLoaded) {
+                // 타겟을 향해 유도
+                const targetDirection = missile.target.position.clone().sub(missile.position).normalize();
+                
+                // 부드러운 회전을 위한 보간
+                missile.velocity.lerp(targetDirection.multiplyScalar(2000), deltaTime * 4); // 미사일 속도 2000m/s
+                missile.velocity.normalize().multiplyScalar(2000);
+                
+                // 미사일 회전
+                const missileDirection = missile.velocity.clone().normalize();
+                const angle = Math.atan2(missileDirection.x, missileDirection.z);
+                missile.rotation.y = angle;
+                missile.rotation.x = Math.asin(-missileDirection.y);
+            }
+            
+            // 위치 업데이트
+            missile.position.add(missile.velocity.clone().multiplyScalar(deltaTime));
+            
+            // 연기 효과 추가
+            if (Math.random() > 0.7) {
+                this.createMissileTrail(missile.position);
+            }
+            
+            // 10km 이상 날아가거나 지면 충돌시 제거
+            if (missile.position.distanceTo(missile.startPosition) > 10000 || 
+                missile.position.y < 0 || 
+                missile.life > 10) { // 10초 후 자동 파괴
+                scene.remove(missile);
+                this.activeMissiles.splice(i, 1);
+            } else {
+                missile.life += deltaTime;
+            }
+        }
+    }
+    
+    createMissileTrail(position) {
+        const trailGeometry = new THREE.SphereGeometry(2, 4, 4);
+        const trailMaterial = new THREE.MeshBasicMaterial({
+            color: 0x888888,
+            transparent: true,
+            opacity: 0.6
+        });
+        
+        const trail = new THREE.Mesh(trailGeometry, trailMaterial);
+        trail.position.copy(position);
+        
+        this.mesh.parent.add(trail);
+        
+        // 페이드 아웃 애니메이션
+        const fadeOut = () => {
+            trail.material.opacity -= 0.02;
+            trail.scale.multiplyScalar(1.05);
+            
+            if (trail.material.opacity > 0) {
+                requestAnimationFrame(fadeOut);
+            } else {
+                this.mesh.parent.remove(trail);
+            }
+        };
+        
+        fadeOut();
+    }
+    
+    shootMissile(scene, target) {
+        if (this.missiles <= 0 || !target || !target.mesh) return;
+        
+        const currentTime = Date.now();
+        if (currentTime - this.lastMissileFire < 6000) return; // 6초 쿨다운
+        
+        this.missiles--;
+        this.lastMissileFire = currentTime;
+        this.weaponCooldown = 6000; // 6초 쿨다운 설정
+        
+        // 미사일 모델
+        const missileGeometry = new THREE.CylinderGeometry(0.3, 0.5, 4, 8);
+        const missileMaterial = new THREE.MeshBasicMaterial({ 
+            color: 0xcccccc,
+            emissive: 0xff6600,
+            emissiveIntensity: 0.5
+        });
+        const missile = new THREE.Mesh(missileGeometry, missileMaterial);
+        
+        // 날개 추가
+        const wingGeometry = new THREE.BoxGeometry(2, 0.1, 0.5);
+        const wingMaterial = new THREE.MeshBasicMaterial({ color: 0x666666 });
+        const wing1 = new THREE.Mesh(wingGeometry, wingMaterial);
+        const wing2 = new THREE.Mesh(wingGeometry, wingMaterial);
+        wing1.position.z = -1;
+        wing2.position.z = -1;
+        wing2.rotation.z = Math.PI / 2;
+        missile.add(wing1);
+        missile.add(wing2);
+        
+        // 미사일 초기 위치 (날개 아래에서 발사)
+        const launchOffset = new THREE.Vector3(0, -2, 5);
+        launchOffset.applyEuler(this.rotation);
+        missile.position.copy(this.position).add(launchOffset);
+        
+        // 미사일 초기 속도
+        const direction = new THREE.Vector3(0, 0, 1);
+        direction.applyEuler(this.rotation);
+        missile.velocity = direction.multiplyScalar(1000); // 초기 속도
+        
+        missile.rotation.copy(this.rotation);
+        missile.rotateX(Math.PI / 2);
+        
+        // 미사일 속성
+        missile.target = target;
+        missile.startPosition = missile.position.clone();
+        missile.life = 0;
+        missile.type = 'missile';
+        
+        scene.add(missile);
+        this.activeMissiles.push(missile);
+        
+        // 발사 사운드
+        try {
+            const audio = new Audio('sounds/towfirelaunch.ogg');
+            audio.volume = 0.6;
+            audio.play().catch(e => console.log('Missile launch sound failed to play'));
+        } catch (e) {
+            console.log('Audio error:', e);
+        }
+        
+        // 락온 초기화
+        this.missileTarget = null;
+        this.missileLockCount = 0;
+        this.missileLockTimer = 0;
+    }
+    
+    updateMissileLock(enemies, deltaTime) {
+        if (this.currentWeapon !== 'missile' || this.missiles <= 0) {
+            this.missileTarget = null;
+            this.missileLockCount = 0;
+            return;
+        }
+        
+        // 쿨다운 업데이트
+        if (this.weaponCooldown > 0) {
+            this.weaponCooldown -= deltaTime * 1000;
+            return;
+        }
+        
+        // 가장 가까운 적 찾기
+        let closestEnemy = null;
+        let closestDistance = Infinity;
+        
+        enemies.forEach(enemy => {
+            if (!enemy.mesh || !enemy.isLoaded) return;
+            
+            const distance = this.position.distanceTo(enemy.position);
+            if (distance < closestDistance && distance < 5000) { // 5km 이내
+                // 시야각 확인
+                const toEnemy = enemy.position.clone().sub(this.position).normalize();
+                const forward = new THREE.Vector3(0, 0, 1);
+                forward.applyEuler(this.rotation);
+                const angle = forward.dot(toEnemy);
+                
+                if (angle > 0.5) { // 시야각 60도 이내
+                    closestEnemy = enemy;
+                    closestDistance = distance;
+                }
+            }
+        });
+        
+        // 타겟 변경시 락온 초기화
+        if (closestEnemy !== this.missileTarget) {
+            this.missileTarget = closestEnemy;
+            this.missileLockCount = 0;
+            this.missileLockTimer = 0;
+        }
+        
+        // 락온 프로세스
+        if (this.missileTarget) {
+            this.missileLockTimer += deltaTime;
+            
+            // 0.5초마다 락온 카운트 증가
+            if (this.missileLockTimer >= 0.5) {
+                this.missileLockTimer = 0;
+                this.missileLockCount++;
+                
+                // 락온 사운드
+                try {
+                    const lockSound = new Audio('sounds/lock.ogg');
+                    lockSound.volume = 0.3;
+                    lockSound.play().catch(e => {});
+                } catch (e) {}
+                
+                if (this.missileLockCount >= 3) {
+                    this.missileLockCount = 3; // 최대 3
+                }
+            }
+        }
     }
 
     takeDamage(damage) {
@@ -1087,7 +1296,7 @@ class Game {
         this.bgm = null;
         this.bgmPlaying = false;
         
-        this.keys = { w: false, a: false, s: false, d: false, f: false };
+        this.keys = { w: false, a: false, s: false, d: false, f: false, r: false };
         this.isStarted = false;
         
         this.setupScene();
@@ -1328,6 +1537,12 @@ class Game {
                 case 'KeyS': this.keys.s = true; break;
                 case 'KeyD': this.keys.d = true; break;
                 case 'KeyF': this.keys.f = true; break;
+                case 'KeyR': 
+                    if (!this.keys.r) {
+                        this.keys.r = true;
+                        this.switchWeapon();
+                    }
+                    break;
             }
         });
 
@@ -1340,6 +1555,7 @@ class Game {
                 case 'KeyS': this.keys.s = false; break;
                 case 'KeyD': this.keys.d = false; break;
                 case 'KeyF': this.keys.f = false; break;
+                case 'KeyR': this.keys.r = false; break;
             }
         });
 
@@ -1357,8 +1573,15 @@ class Game {
             if (!document.pointerLockElement || this.isGameOver || !gameStarted) return;
             
             if (event.button === 0) { // 왼쪽 마우스 버튼
-                this.fighter.isMouseDown = true;
-                this.lastShootTime = 0; // 즉시 발사
+                if (this.fighter.currentWeapon === 'mg') {
+                    this.fighter.isMouseDown = true;
+                    this.lastShootTime = 0; // 즉시 발사
+                } else if (this.fighter.currentWeapon === 'missile') {
+                    // 미사일 발사
+                    if (this.fighter.missileTarget && this.fighter.missileLockCount >= 3) {
+                        this.fighter.shootMissile(this.scene, this.fighter.missileTarget);
+                    }
+                }
             }
         });
 
@@ -1375,19 +1598,24 @@ class Game {
         });
     }
 
-    startGame() {
-        if (!this.isLoaded) {
-            console.log('게임이 아직 로딩 중입니다...');
-            return;
+    switchWeapon() {
+        if (this.fighter.currentWeapon === 'mg') {
+            this.fighter.currentWeapon = 'missile';
+        } else {
+            this.fighter.currentWeapon = 'mg';
         }
         
-        this.isStarted = true;
-        this.startGameTimer();
+        // 무기 변경시 락온 초기화
+        this.fighter.missileTarget = null;
+        this.fighter.missileLockCount = 0;
+        this.fighter.missileLockTimer = 0;
         
-        // 엔진 소리 시작
-        this.fighter.startEngineSound();
-        
-        console.log('게임 시작!');
+        // 무기 변경 사운드
+        try {
+            const switchSound = new Audio('sounds/switch.ogg');
+            switchSound.volume = 0.3;
+            switchSound.play().catch(e => {});
+        } catch (e) {}
     }
 
     startBGM() {
@@ -1460,7 +1688,47 @@ class Game {
             
             if (scoreElement) scoreElement.textContent = `Score: ${this.score}`;
             if (timeElement) timeElement.textContent = `Time: ${this.gameTime}s`;
-            if (ammoElement) ammoElement.textContent = `AMMO: ${this.fighter.ammo}`;
+            
+            // 무기 표시 업데이트
+            if (ammoElement) {
+                let weaponDisplay = '';
+                if (this.fighter.currentWeapon === 'mg') {
+                    weaponDisplay = `
+                        <div style="font-size: 12px; margin-bottom: 5px;">R: WEAPON CHANGE</div>
+                        <div style="font-size: 16px; color: #00ff00;">20MM MG</div>
+                        <div>AMMO: ${this.fighter.ammo}</div>
+                    `;
+                } else {
+                    const cooldownSeconds = Math.ceil(this.fighter.weaponCooldown / 1000);
+                    weaponDisplay = `
+                        <div style="font-size: 12px; margin-bottom: 5px;">R: WEAPON CHANGE</div>
+                        <div style="font-size: 16px; color: #ff8800;">AIM-9 MISSILE</div>
+                        <div>COUNT: ${this.fighter.missiles}</div>
+                    `;
+                    
+                    // 쿨다운 중이면 모래시계 표시
+                    if (this.fighter.weaponCooldown > 0) {
+                        weaponDisplay += `<div style="font-size: 20px; margin-top: 5px;">⏳ ${cooldownSeconds}s</div>`;
+                    } else if (this.fighter.missileTarget) {
+                        // 락온 진행 상태 표시
+                        const lockSymbols = ['◯', '◉', '◉'];
+                        let lockDisplay = '';
+                        for (let i = 0; i < 3; i++) {
+                            if (i < this.fighter.missileLockCount) {
+                                lockDisplay += `<span style="color: #ff0000;">${lockSymbols[i]}</span> `;
+                            } else {
+                                lockDisplay += `<span style="color: #666;">${lockSymbols[0]}</span> `;
+                            }
+                        }
+                        weaponDisplay += `<div style="margin-top: 5px;">LOCK: ${lockDisplay}</div>`;
+                        
+                        if (this.fighter.missileLockCount >= 3) {
+                            weaponDisplay += `<div style="color: #ff0000; animation: blink 0.5s infinite;">READY TO FIRE</div>`;
+                        }
+                    }
+                }
+                ammoElement.innerHTML = weaponDisplay;
+            }
             
             if (gameStatsElement) {
                 gameStatsElement.innerHTML = `
@@ -1895,6 +2163,32 @@ class Game {
             }
         }
         
+        // 플레이어 미사일 vs 적기 충돌
+        for (let i = this.fighter.activeMissiles.length - 1; i >= 0; i--) {
+            const missile = this.fighter.activeMissiles[i];
+            
+            if (missile.target && missile.target.mesh && missile.target.isLoaded) {
+                const distance = missile.position.distanceTo(missile.target.position);
+                if (distance < 50) { // 미사일 충돌 거리
+                    this.scene.remove(missile);
+                    this.fighter.activeMissiles.splice(i, 1);
+                    
+                    // 큰 폭발 이펙트
+                    this.createMissileExplosion(missile.target.position);
+                    
+                    // 미사일 데미지 (500)
+                    if (missile.target.takeDamage(GAME_CONSTANTS.MISSILE_DAMAGE)) {
+                        const enemyIndex = this.enemies.indexOf(missile.target);
+                        if (enemyIndex !== -1) {
+                            missile.target.destroy();
+                            this.enemies.splice(enemyIndex, 1);
+                            this.score += 250; // 미사일 격추는 더 많은 점수
+                        }
+                    }
+                }
+            }
+        }
+        
         // 적 탄환 vs 플레이어 충돌
         this.enemies.forEach(enemy => {
             enemy.bullets.forEach((bullet, index) => {
@@ -1913,6 +2207,107 @@ class Game {
             });
         });
     }
+    
+    createMissileExplosion(position) {
+        // 대형 폭발 효과
+        const explosionGroup = new THREE.Group();
+        explosionGroup.position.copy(position);
+        
+        // 중앙 폭발
+        const coreGeometry = new THREE.SphereGeometry(10, 16, 16);
+        const coreMaterial = new THREE.MeshBasicMaterial({
+            color: 0xffff00,
+            emissive: 0xffaa00,
+            emissiveIntensity: 2.0,
+            transparent: true,
+            opacity: 1.0
+        });
+        const core = new THREE.Mesh(coreGeometry, coreMaterial);
+        explosionGroup.add(core);
+        
+        // 외부 폭발 링
+        const ringGeometry = new THREE.TorusGeometry(15, 5, 8, 16);
+        const ringMaterial = new THREE.MeshBasicMaterial({
+            color: 0xff6600,
+            emissive: 0xff3300,
+            emissiveIntensity: 1.5,
+            transparent: true,
+            opacity: 0.8
+        });
+        const ring = new THREE.Mesh(ringGeometry, ringMaterial);
+        explosionGroup.add(ring);
+        
+        // 파편 파티클
+        const particleCount = 30;
+        const particles = [];
+        
+        for (let i = 0; i < particleCount; i++) {
+            const particleGeometry = new THREE.SphereGeometry(Math.random() * 2 + 0.5, 4, 4);
+            const particleMaterial = new THREE.MeshBasicMaterial({
+                color: Math.random() > 0.5 ? 0xffaa00 : 0xff6600,
+                emissive: 0xffaa00,
+                emissiveIntensity: 1.0,
+                transparent: true,
+                opacity: 1.0
+            });
+            
+            const particle = new THREE.Mesh(particleGeometry, particleMaterial);
+            particle.position.set(
+                (Math.random() - 0.5) * 10,
+                (Math.random() - 0.5) * 10,
+                (Math.random() - 0.5) * 10
+            );
+            
+            particle.velocity = new THREE.Vector3(
+                (Math.random() - 0.5) * 200,
+                (Math.random() - 0.5) * 200,
+                (Math.random() - 0.5) * 200
+            );
+            
+            particle.life = 1.5;
+            explosionGroup.add(particle);
+            particles.push(particle);
+        }
+        
+        this.scene.add(explosionGroup);
+        
+        // 폭발 애니메이션
+        const animateExplosion = () => {
+            // 중앙 폭발 확장
+            core.scale.multiplyScalar(1.15);
+            core.material.opacity *= 0.92;
+            
+            // 링 확장 및 회전
+            ring.scale.multiplyScalar(1.1);
+            ring.rotation.x += 0.1;
+            ring.rotation.y += 0.15;
+            ring.material.opacity *= 0.94;
+            
+            // 파티클 애니메이션
+            particles.forEach(particle => {
+                particle.life -= 0.02;
+                particle.position.add(particle.velocity.clone().multiplyScalar(0.02));
+                particle.velocity.y -= 3; // 중력
+                particle.material.opacity = particle.life / 1.5;
+                particle.scale.multiplyScalar(0.98);
+            });
+            
+            if (core.material.opacity > 0.01) {
+                requestAnimationFrame(animateExplosion);
+            } else {
+                this.scene.remove(explosionGroup);
+            }
+        };
+        
+        animateExplosion();
+        
+        // 폭발 사운드
+        try {
+            const explosionSound = new Audio('sounds/explosion.ogg');
+            explosionSound.volume = 0.6;
+            explosionSound.play().catch(e => {});
+        } catch (e) {}
+    }
 
     createHitEffect(position) {
         // 피격 파티클 효과 생성
@@ -2076,7 +2471,7 @@ class Game {
             this.fighter.updateBullets(this.scene, deltaTime);
             
             // 마우스 누름 상태일 때 연속 발사
-            if (this.fighter.isMouseDown && this.isStarted) {
+            if (this.fighter.isMouseDown && this.isStarted && this.fighter.currentWeapon === 'mg') {
                 const currentShootTime = Date.now();
                 if (!this.lastShootTime || currentShootTime - this.lastShootTime >= 100) { // 0.1초마다
                     this.fighter.shoot(this.scene);
@@ -2084,6 +2479,11 @@ class Game {
                 }
             }
             
+            // 미사일 락온 업데이트
+            if (this.fighter.currentWeapon === 'missile') {
+                this.fighter.updateMissileLock(this.enemies, deltaTime);
+            }
+            
             if (this.isStarted) {
                 // 적기들에게 서로의 참조 전달 (충돌 회피용)
                 this.enemies.forEach(enemy => {