Update game.js

game.js

@@ -1779,82 +1779,78 @@ class Game {
     }
 
     setupEventListeners() {
-    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('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('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('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('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('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('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('mousedown', (event) => {
+            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) {
@@ -2519,72 +2515,88 @@ 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];
-        
-        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);
-                
-                // 탄환 제거는 이펙트 생성 후에
-                this.scene.remove(bullet);
-                this.fighter.bullets.splice(i, 1);
+        // 플레이어 탄환 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;
                 
-                if (enemy.takeDamage(GAME_CONSTANTS.BULLET_DAMAGE)) {
-                    // 적기 파괴 시 폭발 효과 추가 - 위치 확인
-                    this.createExplosionEffect(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);
                     
-                    enemy.destroy();
-                    this.enemies.splice(j, 1);
-                    this.score += 100;
+                    // 탄환 제거
+                    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);
+                        
+                        // 적기 제거
+                        enemy.destroy();
+                        this.enemies.splice(j, 1);
+                        this.score += 100;
+                        
+                        console.log(`Enemy removed. Remaining enemies: ${this.enemies.length}`);
+                    }
+                    break;
                 }
-                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);
-                
-                if (this.fighter.takeDamage(GAME_CONSTANTS.BULLET_DAMAGE)) {
-                    // 플레이어 파괴 시 폭발 효과 추가
-                    this.createExplosionEffect(this.fighter.position);
+        
+        // 적 탄환 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.endGame(false);
+                    // 탄환 제거
+                    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);
+                    }
                 }
             }
-        }
-    });
-}
+        });
+    }
 
     createHitEffect(position) {
         // 피격 파티클 효과 생성
@@ -2685,169 +2697,192 @@ class Game {
     }
     
     createExplosionEffect(position) {
-    // 폭발음을 가장 먼저 재생 (시각효과보다 우선)
-    try {
-        const explosionSound = new Audio('sounds/bang.ogg');
-        explosionSound.volume = 1.0; // 최대 음량
+        console.log('createExplosionEffect called with position:', position);
         
-        // 즉시 재생 시도
-        const playPromise = explosionSound.play();
-        if (playPromise !== undefined) {
-            playPromise.catch(e => console.log('Explosion sound failed:', e));
+        // 위치가 유효한지 확인
+        if (!position || typeof position.x === 'undefined') {
+            console.error('Invalid position for explosion effect');
+            return;
         }
-    } 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,
+        
+        // 폭발음을 가장 먼저 재생 (시각효과보다 우선)
+        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 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 debrisPiece = new THREE.Mesh(debrisGeometry, debrisMaterial);
-        debrisPiece.position.copy(position);
+        const explosion = new THREE.Mesh(explosionGeometry, explosionMaterial);
+        explosion.position.copy(position);
+        this.scene.add(explosion);
+        console.log('Explosion mesh added to scene');
         
-        // 랜덤 속도와 회전
-        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;
+        // 폭발 파편들
+        const debrisCount = 30;
+        const debris = [];
         
-        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
-        });
+        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 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 smokeCount = 10;
+        const smoke = [];
         
-        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;
-                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);
-            }
-        });
+        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);
+        }
+        
+        console.log(`Explosion effect created with ${debrisCount} debris and ${smokeCount} smoke particles`);
         
-        // 연기 애니메이션
-        smoke.forEach(puff => {
-            if (puff.life > 0) {
+        // 애니메이션
+        const animateExplosion = () => {
+            let allDead = true;
+            
+            // 메인 폭발 애니메이션
+            if (explosion.material.opacity > 0) {
+                explosion.material.opacity -= 0.02;
+                explosion.scale.multiplyScalar(1.08);
                 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);
+            } else if (explosion.parent) {
+                this.scene.remove(explosion);
             }
-        });
+            
+            // 파편 애니메이션
+            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);
+            }
+        };
         
-        if (!allDead) {
-            requestAnimationFrame(animateExplosion);
-        }
-    };
-    
-    animateExplosion();
-}
+        animateExplosion();
+    }
 
     showHitMarker(position) {
         // 히트 마커 div 생성
@@ -2900,101 +2935,101 @@ class Game {
     }
 
     animate() {
-    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);
-        }
-        
-        // F키 상태를 Fighter에 전달
-        this.fighter.escapeKeyPressed = this.keys.f;
+        if (this.isGameOver) return;
         
-        // 컨트롤 업데이트 - 반드시 물리 업데이트 전에 호출
-        this.fighter.updateControls(this.keys, deltaTime);
+        this.animationFrameId = requestAnimationFrame(() => this.animate());
         
-        // 물리 업데이트
-        this.fighter.updatePhysics(deltaTime);
+        const currentTime = performance.now();
+        const deltaTime = Math.min((currentTime - this.lastTime) / 1000, 0.1);
+        this.lastTime = currentTime;
         
-        // 탄환 업데이트
-        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;
+        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.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);
+            
+            // 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;
+                }
             }
-            return;
+            
+            // 적기 업데이트
+            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;
+            }
+            
+            // 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;
+            });
         }
         
-        // UI 업데이트
-        this.updateUI();
-        this.updateRadar();
-        
-        // 적이 모두 제거되었는지 체크
-        if (this.enemies.length === 0) {
-            this.endGame(true);
+        // 카메라 업데이트
+        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);
         }
-    } 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.camera.position.lerp(targetCameraPos, this.fighter.cameraLag);
-        this.camera.lookAt(targetCameraTarget);
+        this.renderer.render(this.scene, this.camera);
     }
-    
-    this.renderer.render(this.scene, this.camera);
-}
 
     endGame(victory = false, reason = "") {
         this.isGameOver = true;