Update game.js

game.js

@@ -1506,44 +1506,44 @@ class EnemyFighter {
     if (this.mesh) {
         console.log('Removing enemy mesh from scene');
         
-        // 메시가 그룹인 경우 모든 자식 요소도 제거
-        if (this.mesh.children && this.mesh.children.length > 0) {
-            while (this.mesh.children.length > 0) {
-                const child = this.mesh.children[0];
-                this.mesh.remove(child);
+        // GLB 모델은 복잡한 구조를 가질 수 있으므로 전체 계층구조를 순회하며 제거
+        this.mesh.traverse((child) => {
+            if (child.isMesh) {
+                console.log('Disposing mesh:', child.name || 'unnamed');
                 
-                // 자식 요소의 geometry와 material도 정리
-                if (child.geometry) child.geometry.dispose();
+                // geometry 제거
+                if (child.geometry) {
+                    child.geometry.dispose();
+                }
+                
+                // material 제거
                 if (child.material) {
                     if (Array.isArray(child.material)) {
-                        child.material.forEach(mat => mat.dispose());
+                        child.material.forEach(mat => {
+                            if (mat.dispose) mat.dispose();
+                        });
                     } else {
-                        child.material.dispose();
+                        if (child.material.dispose) child.material.dispose();
                     }
                 }
             }
-        }
+        });
         
-        // 메시 자체의 geometry와 material 정리
-        if (this.mesh.geometry) this.mesh.geometry.dispose();
-        if (this.mesh.material) {
-            if (Array.isArray(this.mesh.material)) {
-                this.mesh.material.forEach(mat => mat.dispose());
-            } else {
-                this.mesh.material.dispose();
-            }
+        // 씬에서 메시 제거 - 여러 방법 시도
+        if (this.scene) {
+            this.scene.remove(this.mesh);
         }
         
-        // 씬에서 메시 제거
-        this.scene.remove(this.mesh);
-        
-        // 메시가 실제로 제거되었는지 확인
+        // parent가 있다면 parent에서도 제거
         if (this.mesh.parent) {
-            console.log('Mesh still has parent, forcing removal');
+            console.log('Mesh still has parent, forcing removal from parent');
             this.mesh.parent.remove(this.mesh);
         }
         
-        // 메시 참조 제거
+        // 메시를 비활성화
+        this.mesh.visible = false;
+        
+        // 메시 참조 완전히 제거
         this.mesh = null;
     }
     
@@ -1567,6 +1567,161 @@ class EnemyFighter {
     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 적기 충돌