Update game.js

game.js

@@ -792,7 +792,7 @@ class Fighter {
    }
 }
 
-// 적 전투기 클래스 - 폭발 처리 수정
+// 적 전투기 클래스 - 완전히 재설계
 class EnemyFighter {
     constructor(scene, position) {
         this.mesh = null;
@@ -838,9 +838,6 @@ class EnemyFighter {
         this.nearbyEnemies = [];
         this.avoidanceVector = new THREE.Vector3();
         
-        // 파괴 상태 추가
-        this.isDestroyed = false;
-        
         // 초기 목표 설정
         this.selectNewPatrolTarget();
     }
@@ -892,7 +889,7 @@ class EnemyFighter {
     }
     
     update(playerPosition, deltaTime) {
-        if (!this.mesh || !this.isLoaded || this.isDestroyed) return;
+        if (!this.mesh || !this.isLoaded) return;
         
         // 회피 타이머 업데이트
         if (this.temporaryEvadeMode && this.evadeTimer > 0) {
@@ -908,6 +905,7 @@ class EnemyFighter {
         if (distanceToPlayer < 100) {
             this.isRetreating = true;
             this.aiState = 'retreat';
+            // 후퇴 시작 시 로그
             console.log(`Enemy retreating! Distance: ${distanceToPlayer.toFixed(1)}m`);
         }
         
@@ -920,6 +918,7 @@ class EnemyFighter {
         // 상태 결정 - 후퇴가 최우선
         if (this.isRetreating) {
             this.aiState = 'retreat';
+            // 후퇴 중에는 다른 상태로 변경 불가
         } else if (this.temporaryEvadeMode) {
             this.aiState = 'evade';
         } else if (distanceToPlayer <= 3000) {
@@ -957,6 +956,7 @@ class EnemyFighter {
         this.updateBullets(deltaTime);
     }
     
+    // 새로운 메서드: 후퇴 실행
     executeRetreat(playerPosition, deltaTime) {
         // 플레이어로부터 멀어지는 방향 계산
         const retreatDirection = this.position.clone().sub(playerPosition).normalize();
@@ -1294,7 +1294,7 @@ class EnemyFighter {
     }
     
     updatePhysics(deltaTime) {
-        if (!this.mesh || this.isDestroyed) return;
+        if (!this.mesh) return;
         
         // 속도 벡터 계산 (항상 전진)
         const forward = new THREE.Vector3(0, 0, 1);
@@ -1482,330 +1482,17 @@ class EnemyFighter {
     
     takeDamage(damage) {
         this.health -= damage;
-        
-        // 체력이 0 이하가 되면 true 반환 (파괴됨)
-        if (this.health <= 0) {
-            this.isDestroyed = true;
-            return true;
-        }
-        return false;
+        return this.health <= 0;
     }
     
     destroy() {
-    console.log('EnemyFighter destroy() called');
-    
-    if (this.isDestroyed) {
-        console.log('Already destroyed, skipping');
-        return;
-    }
-    
-    // 파괴 상태 설정
-    this.isDestroyed = true;
-    
-    // 메시가 있는지 확인하고 제거
-    if (this.mesh) {
-        console.log('Removing enemy mesh from scene');
-        
-        // GLB 모델은 복잡한 구조를 가질 수 있으므로 전체 계층구조를 순회하며 제거
-        this.mesh.traverse((child) => {
-            if (child.isMesh) {
-                console.log('Disposing mesh:', child.name || 'unnamed');
-                
-                // geometry 제거
-                if (child.geometry) {
-                    child.geometry.dispose();
-                }
-                
-                // material 제거
-                if (child.material) {
-                    if (Array.isArray(child.material)) {
-                        child.material.forEach(mat => {
-                            if (mat.dispose) mat.dispose();
-                        });
-                    } else {
-                        if (child.material.dispose) child.material.dispose();
-                    }
-                }
-            }
-        });
-        
-        // 씬에서 메시 제거 - 여러 방법 시도
-        if (this.scene) {
+        if (this.mesh) {
             this.scene.remove(this.mesh);
-        }
-        
-        // parent가 있다면 parent에서도 제거
-        if (this.mesh.parent) {
-            console.log('Mesh still has parent, forcing removal from parent');
-            this.mesh.parent.remove(this.mesh);
-        }
-        
-        // 메시를 비활성화
-        this.mesh.visible = false;
-        
-        // 메시 참조 완전히 제거
-        this.mesh = null;
-    }
-    
-    // 남은 탄환들 제거
-    console.log(`Removing ${this.bullets.length} enemy bullets`);
-    this.bullets.forEach(bullet => {
-        // 탄환의 geometry와 material도 정리
-        if (bullet.geometry) bullet.geometry.dispose();
-        if (bullet.material) bullet.material.dispose();
-        
-        this.scene.remove(bullet);
-        
-        // 탄환이 실제로 제거되었는지 확인
-        if (bullet.parent) {
-            bullet.parent.remove(bullet);
-        }
-    });
-    this.bullets = [];
-    
-    this.isLoaded = false;
-    console.log('EnemyFighter destroyed successfully');
-}
-
-// Game 클래스의 checkCollisions 메서드 수정
-checkCollisions() {
-    // 플레이어 탄환 vs 적기 충돌
-    for (let i = this.fighter.bullets.length - 1; i >= 0; i--) {
-        const bullet = this.fighter.bullets[i];
-        
-        for (let j = this.enemies.length - 1; j >= 0; j--) {
-            const enemy = this.enemies[j];
-            
-            // 이미 파괴된 적은 건너뛰기
-            if (!enemy.mesh || !enemy.isLoaded || enemy.isDestroyed) continue;
-            
-            const distance = bullet.position.distanceTo(enemy.position);
-            if (distance < 90) {
-                console.log(`Hit detected! Distance: ${distance}, Enemy health: ${enemy.health}`);
-                
-                // 히트 표시 추가
-                this.showHitMarker(enemy.position);
-                // 피격 이펙트 추가
-                this.createHitEffect(enemy.position);
-                
-                // 탄환 제거
-                this.scene.remove(bullet);
-                this.fighter.bullets.splice(i, 1);
-                
-                // 적기에 데미지 입히기
-                const isDestroyed = enemy.takeDamage(GAME_CONSTANTS.BULLET_DAMAGE);
-                console.log(`Enemy damaged. New health: ${enemy.health}, Destroyed: ${isDestroyed}`);
-                
-                if (isDestroyed) {
-                    console.log('Enemy destroyed! Creating explosion effect...');
-                    
-                    // 폭발 효과 생성 - 위치를 복사해서 전달
-                    const explosionPosition = enemy.position.clone();
-                    console.log('Explosion position:', explosionPosition);
-                    
-                    // 폭발 효과 즉시 생성
-                    this.createExplosionEffect(explosionPosition);
-                    
-                    // 적기 메시를 먼저 숨기기
-                    if (enemy.mesh) {
-                        enemy.mesh.visible = false;
-                    }
-                    
-                    // 적기 제거
-                    enemy.destroy();
-                    
-                    // 배열에서 제거
-                    this.enemies.splice(j, 1);
-                    this.score += 100;
-                    
-                    console.log(`Enemy removed. Remaining enemies: ${this.enemies.length}`);
-                }
-                break;
-            }
-        }
-    }
-    
-    // 적 탄환 vs 플레이어 충돌
-    this.enemies.forEach(enemy => {
-        // 파괴된 적은 처리하지 않음
-        if (enemy.isDestroyed) return;
-        
-        for (let index = enemy.bullets.length - 1; index >= 0; index--) {
-            const bullet = enemy.bullets[index];
-            const distance = bullet.position.distanceTo(this.fighter.position);
-            if (distance < 100) {
-                // 플레이어 피격 이펙트
-                this.createHitEffect(this.fighter.position);
-                
-                // 탄환 제거
-                this.scene.remove(bullet);
-                enemy.bullets.splice(index, 1);
-                
-                if (this.fighter.takeDamage(GAME_CONSTANTS.BULLET_DAMAGE)) {
-                    // 플레이어 파괴 시 폭발 효과 추가
-                    this.createExplosionEffect(this.fighter.position);
-                    
-                    this.endGame(false);
-                }
-            }
-        }
-    });
-}
-
-// EnemyFighter의 update 메서드에도 추가 보호 장치
-update(playerPosition, deltaTime) {
-    // 파괴되었거나 메시가 없으면 아무것도 하지 않음
-    if (!this.mesh || !this.isLoaded || this.isDestroyed || !this.mesh.visible) return;
-    
-    // ... 나머지 update 로직
-    
-    // 회피 타이머 업데이트
-    if (this.temporaryEvadeMode && this.evadeTimer > 0) {
-        this.evadeTimer -= deltaTime;
-        if (this.evadeTimer <= 0) {
-            this.temporaryEvadeMode = false;
-        }
-    }
-    
-    const distanceToPlayer = this.position.distanceTo(playerPosition);
-    
-    // 100m 이내면 즉시 후퇴 모드 활성화
-    if (distanceToPlayer < 100) {
-        this.isRetreating = true;
-        this.aiState = 'retreat';
-        console.log(`Enemy retreating! Distance: ${distanceToPlayer.toFixed(1)}m`);
-    }
-    
-    // 250m 이상 떨어지면 후퇴 모드 해제
-    if (this.isRetreating && distanceToPlayer >= this.retreatTargetDistance) {
-        this.isRetreating = false;
-        console.log(`Enemy retreat complete. Distance: ${distanceToPlayer.toFixed(1)}m`);
-    }
-    
-    // 상태 결정 - 후퇴가 최우선
-    if (this.isRetreating) {
-        this.aiState = 'retreat';
-    } else if (this.temporaryEvadeMode) {
-        this.aiState = 'evade';
-    } else if (distanceToPlayer <= 3000) {
-        this.aiState = 'combat';
-    } else {
-        this.aiState = 'patrol';
-    }
-    
-    // 충돌 회피 계산 (후퇴 중이 아닐 때만)
-    if (!this.isRetreating) {
-        this.calculateAvoidance();
-        this.checkCollisionPrediction(deltaTime);
-    }
-    
-    // AI 행동 실행
-    switch (this.aiState) {
-        case 'patrol':
-            this.executePatrol(deltaTime);
-            break;
-        case 'combat':
-            this.executeCombat(playerPosition, deltaTime);
-            break;
-        case 'evade':
-            this.executeEmergencyEvade(deltaTime);
-            break;
-        case 'retreat':
-            this.executeRetreat(playerPosition, deltaTime);
-            break;
-    }
-    
-    // 물리 업데이트
-    this.updatePhysics(deltaTime);
-    
-    // 탄환 업데이트
-    this.updateBullets(deltaTime);
-}
-
-// Game 클래스의 checkCollisions 메서드도 약간 수정
-checkCollisions() {
-    // 플레이어 탄환 vs 적기 충돌
-    for (let i = this.fighter.bullets.length - 1; i >= 0; i--) {
-        const bullet = this.fighter.bullets[i];
-        
-        for (let j = this.enemies.length - 1; j >= 0; j--) {
-            const enemy = this.enemies[j];
-            
-            // 이미 파괴된 적은 건너뛰기
-            if (!enemy.mesh || !enemy.isLoaded || enemy.isDestroyed) continue;
-            
-            const distance = bullet.position.distanceTo(enemy.position);
-            if (distance < 90) {
-                console.log(`Hit detected! Distance: ${distance}, Enemy health: ${enemy.health}`);
-                
-                // 히트 표시 추가
-                this.showHitMarker(enemy.position);
-                // 피격 이펙트 추가
-                this.createHitEffect(enemy.position);
-                
-                // 탄환 제거
-                this.scene.remove(bullet);
-                this.fighter.bullets.splice(i, 1);
-                
-                // 적기에 데미지 입히기
-                const isDestroyed = enemy.takeDamage(GAME_CONSTANTS.BULLET_DAMAGE);
-                console.log(`Enemy damaged. New health: ${enemy.health}, Destroyed: ${isDestroyed}`);
-                
-                if (isDestroyed) {
-                    console.log('Enemy destroyed! Creating explosion effect...');
-                    
-                    // 폭발 효과 생성 - 위치를 복사해서 전달
-                    const explosionPosition = enemy.position.clone();
-                    console.log('Explosion position:', explosionPosition);
-                    
-                    // 폭발 효과 즉시 생성
-                    this.createExplosionEffect(explosionPosition);
-                    
-                    // 적기 메시 제거 (destroy 호출 전에 명시적으로 제거)
-                    if (enemy.mesh && enemy.mesh.parent) {
-                        console.log('Explicitly removing enemy mesh before destroy');
-                        enemy.mesh.parent.remove(enemy.mesh);
-                    }
-                    
-                    // 적기 제거
-                    enemy.destroy();
-                    
-                    // 배열에서 제거
-                    this.enemies.splice(j, 1);
-                    this.score += 100;
-                    
-                    console.log(`Enemy removed. Remaining enemies: ${this.enemies.length}`);
-                }
-                break;
-            }
+            this.bullets.forEach(bullet => this.scene.remove(bullet));
+            this.bullets = [];
+            this.isLoaded = false;
         }
     }
-    
-    // 적 탄환 vs 플레이어 충돌
-    this.enemies.forEach(enemy => {
-        // 파괴된 적은 처리하지 않음
-        if (enemy.isDestroyed) return;
-        
-        for (let index = enemy.bullets.length - 1; index >= 0; index--) {
-            const bullet = enemy.bullets[index];
-            const distance = bullet.position.distanceTo(this.fighter.position);
-            if (distance < 100) {
-                // 플레이어 피격 이펙트
-                this.createHitEffect(this.fighter.position);
-                
-                // 탄환 제거
-                this.scene.remove(bullet);
-                enemy.bullets.splice(index, 1);
-                
-                if (this.fighter.takeDamage(GAME_CONSTANTS.BULLET_DAMAGE)) {
-                    // 플레이어 파괴 시 폭발 효과 추가
-                    this.createExplosionEffect(this.fighter.position);
-                    
-                    this.endGame(false);
-                }
-            }
-        }
-    });
 }
 
 // 메인 게임 클래스
@@ -2070,78 +1757,82 @@ class Game {
     }
 
     setupEventListeners() {
-        document.addEventListener('keydown', (event) => {
-            if (this.isGameOver) return;
-            
-            if (!this.isStarted) return;
-            
-            switch(event.code) {
-                case 'KeyW': 
-                    this.keys.w = true; 
-                    console.log('W key pressed - Accelerating');
-                    break;
-                case 'KeyA': 
-                    this.keys.a = true; 
-                    console.log('A key pressed - Turning left');
-                    break;
-                case 'KeyS': 
-                    this.keys.s = true; 
-                    console.log('S key pressed - Decelerating');
-                    break;
-                case 'KeyD': 
-                    this.keys.d = true; 
-                    console.log('D key pressed - Turning right');
-                    break;
-                case 'KeyF': 
-                    this.keys.f = true; 
-                    break;
-            }
-        });
+    document.addEventListener('keydown', (event) => {
+        if (this.isGameOver) return;
+        
+        // gameStarted 대신 this.isStarted 사용
+        if (!this.isStarted) return;
+        
+        switch(event.code) {
+            case 'KeyW': 
+                this.keys.w = true; 
+                console.log('W key pressed - Accelerating');
+                break;
+            case 'KeyA': 
+                this.keys.a = true; 
+                console.log('A key pressed - Turning left');
+                break;
+            case 'KeyS': 
+                this.keys.s = true; 
+                console.log('S key pressed - Decelerating');
+                break;
+            case 'KeyD': 
+                this.keys.d = true; 
+                console.log('D key pressed - Turning right');
+                break;
+            case 'KeyF': 
+                this.keys.f = true; 
+                break;
+        }
+    });
 
-        document.addEventListener('keyup', (event) => {
-            if (this.isGameOver) return;
-            
-            if (!this.isStarted) return;
-            
-            switch(event.code) {
-                case 'KeyW': this.keys.w = false; break;
-                case 'KeyA': this.keys.a = false; break;
-                case 'KeyS': this.keys.s = false; break;
-                case 'KeyD': this.keys.d = false; break;
-                case 'KeyF': this.keys.f = false; break;
-            }
-        });
+    document.addEventListener('keyup', (event) => {
+        if (this.isGameOver) return;
+        
+        // gameStarted 대신 this.isStarted 사용
+        if (!this.isStarted) return;
+        
+        switch(event.code) {
+            case 'KeyW': this.keys.w = false; break;
+            case 'KeyA': this.keys.a = false; break;
+            case 'KeyS': this.keys.s = false; break;
+            case 'KeyD': this.keys.d = false; break;
+            case 'KeyF': this.keys.f = false; break;
+        }
+    });
 
-        document.addEventListener('mousemove', (event) => {
-            if (!document.pointerLockElement || this.isGameOver || !this.isStarted) return;
-            
-            const deltaX = event.movementX || 0;
-            const deltaY = event.movementY || 0;
-            
-            this.fighter.updateMouseInput(deltaX, deltaY);
-        });
+    document.addEventListener('mousemove', (event) => {
+        // 여기도 gameStarted를 this.isStarted로 변경
+        if (!document.pointerLockElement || this.isGameOver || !this.isStarted) return;
+        
+        const deltaX = event.movementX || 0;
+        const deltaY = event.movementY || 0;
+        
+        this.fighter.updateMouseInput(deltaX, deltaY);
+    });
 
-        document.addEventListener('mousedown', (event) => {
-            if (!document.pointerLockElement || this.isGameOver || !this.isStarted) return;
-            
-            if (event.button === 0) {
-                this.fighter.isMouseDown = true;
-                this.lastShootTime = 0;
-            }
-        });
+    document.addEventListener('mousedown', (event) => {
+        // 여기도 gameStarted를 this.isStarted로 변경
+        if (!document.pointerLockElement || this.isGameOver || !this.isStarted) return;
+        
+        if (event.button === 0) {
+            this.fighter.isMouseDown = true;
+            this.lastShootTime = 0;
+        }
+    });
 
-        document.addEventListener('mouseup', (event) => {
-            if (event.button === 0) {
-                this.fighter.isMouseDown = false;
-            }
-        });
+    document.addEventListener('mouseup', (event) => {
+        if (event.button === 0) {
+            this.fighter.isMouseDown = false;
+        }
+    });
 
-        window.addEventListener('resize', () => {
-            this.camera.aspect = window.innerWidth / window.innerHeight;
-            this.camera.updateProjectionMatrix();
-            this.renderer.setSize(window.innerWidth, window.innerHeight);
-        });
-    }
+    window.addEventListener('resize', () => {
+        this.camera.aspect = window.innerWidth / window.innerHeight;
+        this.camera.updateProjectionMatrix();
+        this.renderer.setSize(window.innerWidth, window.innerHeight);
+    });
+}
 
     startGame() {
         if (!this.isLoaded) {
@@ -2806,88 +2497,72 @@ class Game {
         animateImpact();
         
         // 작은 충돌음
-        try {
-            const impactSound = new Audio('sounds/hit.ogg');
-            impactSound.volume = 0.2;
-            impactSound.play().catch(e => {
-                console.log('Impact sound not found or failed to play');
-            });
-        } catch (e) {
-            console.log('Impact sound error:', e);
-        }
+    try {
+        const impactSound = new Audio('sounds/hit.ogg');
+        impactSound.volume = 0.2;
+        impactSound.play().catch(e => {
+            console.log('Impact sound not found or failed to play');
+        });
+    } catch (e) {
+        console.log('Impact sound error:', e);
     }
-
+}
     checkCollisions() {
-        // 플레이어 탄환 vs 적기 충돌
-        for (let i = this.fighter.bullets.length - 1; i >= 0; i--) {
-            const bullet = this.fighter.bullets[i];
+    // 플레이어 탄환 vs 적기 충돌
+    for (let i = this.fighter.bullets.length - 1; i >= 0; i--) {
+        const bullet = this.fighter.bullets[i];
+        
+        for (let j = this.enemies.length - 1; j >= 0; j--) {
+            const enemy = this.enemies[j];
+            if (!enemy.mesh || !enemy.isLoaded) continue;
             
-            for (let j = this.enemies.length - 1; j >= 0; j--) {
-                const enemy = this.enemies[j];
-                if (!enemy.mesh || !enemy.isLoaded) continue;
+            const distance = bullet.position.distanceTo(enemy.position);
+            if (distance < 90) {
+                // 히트 표시 추가
+                this.showHitMarker(enemy.position);
+                // 피격 이펙트 추가
+                this.createHitEffect(enemy.position);
                 
-                const distance = bullet.position.distanceTo(enemy.position);
-                if (distance < 90) {
-                    console.log(`Hit detected! Distance: ${distance}, Enemy health: ${enemy.health}`);
-                    
-                    // 히트 표시 추가
-                    this.showHitMarker(enemy.position);
-                    // 피격 이펙트 추가
-                    this.createHitEffect(enemy.position);
-                    
-                    // 탄환 제거
-                    this.scene.remove(bullet);
-                    this.fighter.bullets.splice(i, 1);
-                    
-                    // 적기에 데미지 입히기
-                    const isDestroyed = enemy.takeDamage(GAME_CONSTANTS.BULLET_DAMAGE);
-                    console.log(`Enemy damaged. New health: ${enemy.health}, Destroyed: ${isDestroyed}`);
+                // 탄환 제거는 이펙트 생성 후에
+                this.scene.remove(bullet);
+                this.fighter.bullets.splice(i, 1);
+                
+                if (enemy.takeDamage(GAME_CONSTANTS.BULLET_DAMAGE)) {
+                    // 적기 파괴 시 폭발 효과 추가 - 위치 확인
+                    this.createExplosionEffect(enemy.position);
                     
-                    if (isDestroyed) {
-                        console.log('Enemy destroyed! Creating explosion effect...');
-                        
-                        // 폭발 효과 생성 - 위치를 복사해서 전달
-                        const explosionPosition = enemy.position.clone();
-                        console.log('Explosion position:', explosionPosition);
-                        
-                        // 폭발 효과 즉시 생성
-                        this.createExplosionEffect(explosionPosition);
-                        
-                        // 적기 제거
-                        enemy.destroy();
-                        this.enemies.splice(j, 1);
-                        this.score += 100;
-                        
-                        console.log(`Enemy removed. Remaining enemies: ${this.enemies.length}`);
-                    }
-                    break;
+                    enemy.destroy();
+                    this.enemies.splice(j, 1);
+                    this.score += 100;
                 }
+                break;
             }
         }
-        
-        // 적 탄환 vs 플레이어 충돌
-        this.enemies.forEach(enemy => {
-            for (let index = enemy.bullets.length - 1; index >= 0; index--) {
-                const bullet = enemy.bullets[index];
-                const distance = bullet.position.distanceTo(this.fighter.position);
-                if (distance < 100) {
-                    // 플레이어 피격 이펙트
-                    this.createHitEffect(this.fighter.position);
-                    
-                    // 탄환 제거
-                    this.scene.remove(bullet);
-                    enemy.bullets.splice(index, 1);
+    }
+    
+    // 적 탄환 vs 플레이어 충돌
+    this.enemies.forEach(enemy => {
+        for (let index = enemy.bullets.length - 1; index >= 0; index--) {
+            const bullet = enemy.bullets[index];
+            const distance = bullet.position.distanceTo(this.fighter.position);
+            if (distance < 100) {
+                // 플레이어 피격 이펙트
+                this.createHitEffect(this.fighter.position);
+                
+                // 탄환 제거
+                this.scene.remove(bullet);
+                enemy.bullets.splice(index, 1);
+                
+                if (this.fighter.takeDamage(GAME_CONSTANTS.BULLET_DAMAGE)) {
+                    // 플레이어 파괴 시 폭발 효과 추가
+                    this.createExplosionEffect(this.fighter.position);
                     
-                    if (this.fighter.takeDamage(GAME_CONSTANTS.BULLET_DAMAGE)) {
-                        // 플레이어 파괴 시 폭발 효과 추가
-                        this.createExplosionEffect(this.fighter.position);
-                        
-                        this.endGame(false);
-                    }
+                    this.endGame(false);
                 }
             }
-        });
-    }
+        }
+    });
+}
 
     createHitEffect(position) {
         // 피격 파티클 효과 생성
@@ -2988,192 +2663,169 @@ class Game {
     }
     
     createExplosionEffect(position) {
-        console.log('createExplosionEffect called with position:', position);
-        
-        // 위치가 유효한지 확인
-        if (!position || typeof position.x === 'undefined') {
-            console.error('Invalid position for explosion effect');
-            return;
-        }
+    // 폭발음을 가장 먼저 재생 (시각효과보다 우선)
+    try {
+        const explosionSound = new Audio('sounds/bang.ogg');
+        explosionSound.volume = 1.0; // 최대 음량
         
-        // 폭발음을 가장 먼저 재생 (시각효과보다 우선)
-        try {
-            const explosionSound = new Audio('sounds/bang.ogg');
-            explosionSound.volume = 1.0; // 최대 음량
-            
-            // 플레이어와의 거리에 따른 볼륨 조정
-            if (this.fighter && this.fighter.position) {
-                const distanceToPlayer = position.distanceTo(this.fighter.position);
-                const maxAudibleDistance = 5000;
-                if (distanceToPlayer < maxAudibleDistance) {
-                    explosionSound.volume = Math.max(0.3, 1.0 - (distanceToPlayer / maxAudibleDistance));
-                    console.log(`Explosion sound volume: ${explosionSound.volume} (distance: ${distanceToPlayer})`);
-                }
-            }
-            
-            // 즉시 재생 시도
-            const playPromise = explosionSound.play();
-            if (playPromise !== undefined) {
-                playPromise
-                    .then(() => console.log('Explosion sound played successfully'))
-                    .catch(e => console.error('Explosion sound failed:', e));
-            }
-        } catch (e) {
-            console.error('Explosion sound error:', e);
+        // 즉시 재생 시도
+        const playPromise = explosionSound.play();
+        if (playPromise !== undefined) {
+            playPromise.catch(e => console.log('Explosion sound failed:', e));
         }
-        
-        // 메인 폭발 플래시
-        const explosionGeometry = new THREE.SphereGeometry(50, 16, 16);
-        const explosionMaterial = new THREE.MeshBasicMaterial({
-            color: 0xffaa00,
-            emissive: 0xffaa00,
-            emissiveIntensity: 3.0,
+    } catch (e) {
+        console.log('Explosion sound error:', e);
+    }
+    
+    // 메인 폭발 플래시
+    const explosionGeometry = new THREE.SphereGeometry(50, 16, 16);
+    const explosionMaterial = new THREE.MeshBasicMaterial({
+        color: 0xffaa00,
+        emissive: 0xffaa00,
+        emissiveIntensity: 3.0,
+        transparent: true,
+        opacity: 1.0
+    });
+    
+    const explosion = new THREE.Mesh(explosionGeometry, explosionMaterial);
+    explosion.position.copy(position);
+    this.scene.add(explosion);
+    
+    // 폭발 파편들
+    const debrisCount = 30;
+    const debris = [];
+    
+    for (let i = 0; i < debrisCount; i++) {
+        const debrisGeometry = new THREE.BoxGeometry(
+            2 + Math.random() * 4,
+            2 + Math.random() * 4,
+            2 + Math.random() * 4
+        );
+        const debrisMaterial = new THREE.MeshBasicMaterial({
+            color: Math.random() > 0.5 ? 0xff6600 : 0x333333,
             transparent: true,
             opacity: 1.0
         });
         
-        const explosion = new THREE.Mesh(explosionGeometry, explosionMaterial);
-        explosion.position.copy(position);
-        this.scene.add(explosion);
-        console.log('Explosion mesh added to scene');
-        
-        // 폭발 파편들
-        const debrisCount = 30;
-        const debris = [];
-        
-        for (let i = 0; i < debrisCount; i++) {
-            const debrisGeometry = new THREE.BoxGeometry(
-                2 + Math.random() * 4,
-                2 + Math.random() * 4,
-                2 + Math.random() * 4
-            );
-            const debrisMaterial = new THREE.MeshBasicMaterial({
-                color: Math.random() > 0.5 ? 0xff6600 : 0x333333,
-                transparent: true,
-                opacity: 1.0
-            });
-            
-            const debrisPiece = new THREE.Mesh(debrisGeometry, debrisMaterial);
-            debrisPiece.position.copy(position);
-            
-            // 랜덤 속도와 회전
-            debrisPiece.velocity = new THREE.Vector3(
-                (Math.random() - 0.5) * 200,
-                (Math.random() - 0.5) * 200,
-                (Math.random() - 0.5) * 200
-            );
-            debrisPiece.rotationSpeed = new THREE.Vector3(
-                Math.random() * 10,
-                Math.random() * 10,
-                Math.random() * 10
-            );
-            debrisPiece.life = 2.0;
-            
-            this.scene.add(debrisPiece);
-            debris.push(debrisPiece);
-        }
+        const debrisPiece = new THREE.Mesh(debrisGeometry, debrisMaterial);
+        debrisPiece.position.copy(position);
         
-        // 연기 효과
-        const smokeCount = 10;
-        const smoke = [];
+        // 랜덤 속도와 회전
+        debrisPiece.velocity = new THREE.Vector3(
+            (Math.random() - 0.5) * 200,
+            (Math.random() - 0.5) * 200,
+            (Math.random() - 0.5) * 200
+        );
+        debrisPiece.rotationSpeed = new THREE.Vector3(
+            Math.random() * 10,
+            Math.random() * 10,
+            Math.random() * 10
+        );
+        debrisPiece.life = 2.0;
         
-        for (let i = 0; i < smokeCount; i++) {
-            const smokeGeometry = new THREE.SphereGeometry(10 + Math.random() * 20, 8, 8);
-            const smokeMaterial = new THREE.MeshBasicMaterial({
-                color: 0x222222,
-                transparent: true,
-                opacity: 0.8
-            });
-            
-            const smokePuff = new THREE.Mesh(smokeGeometry, smokeMaterial);
-            smokePuff.position.copy(position);
-            smokePuff.position.add(new THREE.Vector3(
-                (Math.random() - 0.5) * 20,
-                (Math.random() - 0.5) * 20,
-                (Math.random() - 0.5) * 20
-            ));
-            
-            smokePuff.velocity = new THREE.Vector3(
-                (Math.random() - 0.5) * 50,
-                Math.random() * 50 + 20,
-                (Math.random() - 0.5) * 50
-            );
-            smokePuff.life = 3.0;
-            
-            this.scene.add(smokePuff);
-            smoke.push(smokePuff);
-        }
+        this.scene.add(debrisPiece);
+        debris.push(debrisPiece);
+    }
+    
+    // 연기 효과
+    const smokeCount = 10;
+    const smoke = [];
+    
+    for (let i = 0; i < smokeCount; i++) {
+        const smokeGeometry = new THREE.SphereGeometry(10 + Math.random() * 20, 8, 8);
+        const smokeMaterial = new THREE.MeshBasicMaterial({
+            color: 0x222222,
+            transparent: true,
+            opacity: 0.8
+        });
         
-        console.log(`Explosion effect created with ${debrisCount} debris and ${smokeCount} smoke particles`);
+        const smokePuff = new THREE.Mesh(smokeGeometry, smokeMaterial);
+        smokePuff.position.copy(position);
+        smokePuff.position.add(new THREE.Vector3(
+            (Math.random() - 0.5) * 20,
+            (Math.random() - 0.5) * 20,
+            (Math.random() - 0.5) * 20
+        ));
+        
+        smokePuff.velocity = new THREE.Vector3(
+            (Math.random() - 0.5) * 50,
+            Math.random() * 50 + 20,
+            (Math.random() - 0.5) * 50
+        );
+        smokePuff.life = 3.0;
         
-        // 애니메이션
-        const animateExplosion = () => {
-            let allDead = true;
-            
-            // 메인 폭발 애니메이션
-            if (explosion.material.opacity > 0) {
-                explosion.material.opacity -= 0.02;
-                explosion.scale.multiplyScalar(1.08);
+        this.scene.add(smokePuff);
+        smoke.push(smokePuff);
+    }
+    
+    // 애니메이션
+    const animateExplosion = () => {
+        let allDead = true;
+        
+        // 메인 폭발 애니메이션
+        if (explosion.material.opacity > 0) {
+            explosion.material.opacity -= 0.02;
+            explosion.scale.multiplyScalar(1.08);
+            allDead = false;
+        } else if (explosion.parent) {
+            this.scene.remove(explosion);
+        }
+        
+        // 파편 애니메이션
+        debris.forEach(piece => {
+            if (piece.life > 0) {
                 allDead = false;
-            } else if (explosion.parent) {
-                this.scene.remove(explosion);
+                piece.life -= 0.02;
+                
+                // 위치 업데이트
+                piece.position.add(piece.velocity.clone().multiplyScalar(0.02));
+                
+                // 중력
+                piece.velocity.y -= 3;
+                
+                // 회전
+                piece.rotation.x += piece.rotationSpeed.x * 0.02;
+                piece.rotation.y += piece.rotationSpeed.y * 0.02;
+                piece.rotation.z += piece.rotationSpeed.z * 0.02;
+                
+                // 페이드 아웃
+                piece.material.opacity = piece.life / 2;
+            } else if (piece.parent) {
+                this.scene.remove(piece);
             }
-            
-            // 파편 애니메이션
-            debris.forEach(piece => {
-                if (piece.life > 0) {
-                    allDead = false;
-                    piece.life -= 0.02;
-                    
-                    // 위치 업데이트
-                    piece.position.add(piece.velocity.clone().multiplyScalar(0.02));
-                    
-                    // 중력
-                    piece.velocity.y -= 3;
-                    
-                    // 회전
-                    piece.rotation.x += piece.rotationSpeed.x * 0.02;
-                    piece.rotation.y += piece.rotationSpeed.y * 0.02;
-                    piece.rotation.z += piece.rotationSpeed.z * 0.02;
-                    
-                    // 페이드 아웃
-                    piece.material.opacity = piece.life / 2;
-                } else if (piece.parent) {
-                    this.scene.remove(piece);
-                }
-            });
-            
-            // 연기 애니메이션
-            smoke.forEach(puff => {
-                if (puff.life > 0) {
-                    allDead = false;
-                    puff.life -= 0.02;
-                    
-                    // 위치 업데이트
-                    puff.position.add(puff.velocity.clone().multiplyScalar(0.02));
-                    
-                    // 상승 감속
-                    puff.velocity.y *= 0.98;
-                    puff.velocity.x *= 0.98;
-                    puff.velocity.z *= 0.98;
-                    
-                    // 확산
-                    puff.scale.multiplyScalar(1.02);
-                    
-                    // 페이드 아웃
-                    puff.material.opacity = (puff.life / 3) * 0.8;
-                } else if (puff.parent) {
-                    this.scene.remove(puff);
-                }
-            });
-            
-            if (!allDead) {
-                requestAnimationFrame(animateExplosion);
+        });
+        
+        // 연기 애니메이션
+        smoke.forEach(puff => {
+            if (puff.life > 0) {
+                allDead = false;
+                puff.life -= 0.02;
+                
+                // 위치 업데이트
+                puff.position.add(puff.velocity.clone().multiplyScalar(0.02));
+                
+                // 상승 감속
+                puff.velocity.y *= 0.98;
+                puff.velocity.x *= 0.98;
+                puff.velocity.z *= 0.98;
+                
+                // 확산
+                puff.scale.multiplyScalar(1.02);
+                
+                // 페이드 아웃
+                puff.material.opacity = (puff.life / 3) * 0.8;
+            } else if (puff.parent) {
+                this.scene.remove(puff);
             }
-        };
+        });
         
-        animateExplosion();
-    }
+        if (!allDead) {
+            requestAnimationFrame(animateExplosion);
+        }
+    };
+    
+    animateExplosion();
+}
 
     showHitMarker(position) {
         // 히트 마커 div 생성
@@ -3226,101 +2878,101 @@ class Game {
     }
 
     animate() {
-        if (this.isGameOver) return;
+    if (this.isGameOver) return;
+    
+    this.animationFrameId = requestAnimationFrame(() => this.animate());
+    
+    const currentTime = performance.now();
+    const deltaTime = Math.min((currentTime - this.lastTime) / 1000, 0.1);
+    this.lastTime = currentTime;
+    
+    if (this.isLoaded && this.fighter.isLoaded && this.isStarted) {
+        // 키 상태 디버깅
+        if (this.keys.w || this.keys.s || this.keys.a || this.keys.d) {
+            console.log('animate() - Keys state:', this.keys);
+        }
         
-        this.animationFrameId = requestAnimationFrame(() => this.animate());
+        // F키 상태를 Fighter에 전달
+        this.fighter.escapeKeyPressed = this.keys.f;
         
-        const currentTime = performance.now();
-        const deltaTime = Math.min((currentTime - this.lastTime) / 1000, 0.1);
-        this.lastTime = currentTime;
+        // 컨트롤 업데이트 - 반드시 물리 업데이트 전에 호출
+        this.fighter.updateControls(this.keys, deltaTime);
         
-        if (this.isLoaded && this.fighter.isLoaded && this.isStarted) {
-            // 키 상태 디버깅
-            if (this.keys.w || this.keys.s || this.keys.a || this.keys.d) {
-                console.log('animate() - Keys state:', this.keys);
-            }
-            
-            // F키 상태를 Fighter에 전달
-            this.fighter.escapeKeyPressed = this.keys.f;
-            
-            // 컨트롤 업데이트 - 반드시 물리 업데이트 전에 호출
-            this.fighter.updateControls(this.keys, deltaTime);
-            
-            // 물리 업데이트
-            this.fighter.updatePhysics(deltaTime);
-            
-            // 탄환 업데이트
-            this.fighter.updateBullets(this.scene, deltaTime, this);
-            
-            // 마우스 누름 상태일 때 연속 발사
-            if (this.fighter.isMouseDown) {
-                const currentShootTime = Date.now();
-                if (!this.lastShootTime || currentShootTime - this.lastShootTime >= 100) {
-                    this.fighter.shoot(this.scene);
-                    this.lastShootTime = currentShootTime;
-                }
-            }
-            
-            // 적기 업데이트
-            this.enemies.forEach(enemy => {
-                enemy.nearbyEnemies = this.enemies;
-            });
-            
-            this.enemies.forEach(enemy => {
-                enemy.update(this.fighter.position, deltaTime);
-            });
-            
-            // 충돌 체크
-            this.checkCollisions();
-            
-            // 게임 종료 조건 체크
-            if (this.fighter.health <= 0) {
-                if (this.fighter.position.y <= 0) {
-                    this.endGame(false, "GROUND COLLISION");
-                } else {
-                    this.endGame(false);
-                }
-                return;
+        // 물리 업데이트
+        this.fighter.updatePhysics(deltaTime);
+        
+        // 탄환 업데이트
+        this.fighter.updateBullets(this.scene, deltaTime, this);
+        
+        // 마우스 누름 상태일 때 연속 발사
+        if (this.fighter.isMouseDown) {
+            const currentShootTime = Date.now();
+            if (!this.lastShootTime || currentShootTime - this.lastShootTime >= 100) {
+                this.fighter.shoot(this.scene);
+                this.lastShootTime = currentShootTime;
             }
-            
-            // UI 업데이트
-            this.updateUI();
-            this.updateRadar();
-            
-            // 적이 모두 제거되었는지 체크
-            if (this.enemies.length === 0) {
-                this.endGame(true);
+        }
+        
+        // 적기 업데이트
+        this.enemies.forEach(enemy => {
+            enemy.nearbyEnemies = this.enemies;
+        });
+        
+        this.enemies.forEach(enemy => {
+            enemy.update(this.fighter.position, deltaTime);
+        });
+        
+        // 충돌 체크
+        this.checkCollisions();
+        
+        // 게임 종료 조건 체크
+        if (this.fighter.health <= 0) {
+            if (this.fighter.position.y <= 0) {
+                this.endGame(false, "GROUND COLLISION");
+            } else {
+                this.endGame(false);
             }
-        } else if (this.isLoaded && this.fighter.isLoaded) {
-            // 게임이 시작되지 않았을 때도 물리는 업데이트 (카메라 움직임을 위해)
-            this.fighter.updatePhysics(deltaTime);
-        }
-        
-        // 구름 애니메이션
-        if (this.clouds) {
-            this.clouds.forEach(cloud => {
-                cloud.userData.time += deltaTime;
-                cloud.position.x += cloud.userData.driftSpeed;
-                cloud.position.y = cloud.userData.initialY + 
-                    Math.sin(cloud.userData.time * cloud.userData.floatSpeed) * 20;
-                
-                const mapLimit = GAME_CONSTANTS.MAP_SIZE / 2;
-                if (cloud.position.x > mapLimit) cloud.position.x = -mapLimit;
-                if (cloud.position.x < -mapLimit) cloud.position.x = mapLimit;
-            });
+            return;
         }
         
-        // 카메라 업데이트
-        if (this.fighter.isLoaded) {
-            const targetCameraPos = this.fighter.getCameraPosition();
-            const targetCameraTarget = this.fighter.getCameraTarget();
-            
-            this.camera.position.lerp(targetCameraPos, this.fighter.cameraLag);
-            this.camera.lookAt(targetCameraTarget);
+        // UI 업데이트
+        this.updateUI();
+        this.updateRadar();
+        
+        // 적이 모두 제거되었는지 체크
+        if (this.enemies.length === 0) {
+            this.endGame(true);
         }
+    } else if (this.isLoaded && this.fighter.isLoaded) {
+        // 게임이 시작되지 않았을 때도 물리는 업데이트 (카메라 움직임을 위해)
+        this.fighter.updatePhysics(deltaTime);
+    }
+    
+    // 구름 애니메이션
+    if (this.clouds) {
+        this.clouds.forEach(cloud => {
+            cloud.userData.time += deltaTime;
+            cloud.position.x += cloud.userData.driftSpeed;
+            cloud.position.y = cloud.userData.initialY + 
+                Math.sin(cloud.userData.time * cloud.userData.floatSpeed) * 20;
+            
+            const mapLimit = GAME_CONSTANTS.MAP_SIZE / 2;
+            if (cloud.position.x > mapLimit) cloud.position.x = -mapLimit;
+            if (cloud.position.x < -mapLimit) cloud.position.x = mapLimit;
+        });
+    }
+    
+    // 카메라 업데이트
+    if (this.fighter.isLoaded) {
+        const targetCameraPos = this.fighter.getCameraPosition();
+        const targetCameraTarget = this.fighter.getCameraTarget();
         
-        this.renderer.render(this.scene, this.camera);
+        this.camera.position.lerp(targetCameraPos, this.fighter.cameraLag);
+        this.camera.lookAt(targetCameraTarget);
     }
+    
+    this.renderer.render(this.scene, this.camera);
+}
 
     endGame(victory = false, reason = "") {
         this.isGameOver = true;