Update game.js

game.js

@@ -570,7 +570,6 @@ startReload() {
 // Enemy 클래스
 class Enemy {
     constructor(scene, position, type = 'tank') {
-        // 기본 속성
         this.scene = scene;
         this.position = position;
         this.mesh = null;
@@ -591,25 +590,22 @@ class Enemy {
             canSeePlayer: false,
             lastKnownPlayerPosition: null,
             searchStartTime: null,
-            targetRotation: 0,
-            currentRotation: 0,
-            isAiming: false,
-            aimingTime: 0,
-            requiredAimTime: 1000 // 조준에 필요한 시간
+            pathfindingAttempts: 0,
+            maxPathfindingAttempts: 5,
+            alternativePath: null
         };
 
-        // 경로 탐색 및 회피 시스템
+        // 경로 탐색 시스템
         this.pathfinding = {
             currentPath: [],
             pathUpdateInterval: 1000,
             lastPathUpdate: 0,
             isAvoidingObstacle: false,
             avoidanceDirection: null,
-            obstacleCheckDistance: 10,
-            avoidanceTime: 0,
-            maxAvoidanceTime: 3000, // 최대 회피 시간
-            sensorAngles: [-45, 0, 45], // 전방 감지 각도
-            sensorDistance: 15 // 감지 거리
+            obstacleCheckDistance: 15,
+            sensorAngles: [-45, -30, -15, 0, 15, 30, 45],
+            sensorDistance: 20,
+            alternativeRoutes: []
         };
 
         // 전투 시스템
@@ -617,473 +613,503 @@ class Enemy {
             minEngagementRange: 30,
             maxEngagementRange: 150,
             optimalRange: 80,
-            aimThreshold: 0.1, // 조준 정확도 임계값
+            aimThreshold: 0.1,
             lastShotAccuracy: 0,
-            consecutiveHits: 0,
-            maxConsecutiveHits: 3
+            turretRotation: 0,
+            targetTurretRotation: 0,
+            turretRotationSpeed: 0.05
         };
     }
 
-    // 장애물 감지 시스템
-    detectObstacles() {
-        const obstacles = [];
-        const position = this.mesh.position.clone();
-        position.y += 1; // 센서 높이 조정
+    checkLineOfSight(playerPosition) {
+        if (!this.mesh) return false;
 
-        this.pathfinding.sensorAngles.forEach(angle => {
-            const direction = new THREE.Vector3(0, 0, 1)
-                .applyQuaternion(this.mesh.quaternion)
-                .applyAxisAngle(new THREE.Vector3(0, 1, 0), angle * Math.PI / 180);
+        const startPos = this.mesh.position.clone();
+        startPos.y += 2; // 포탑 높이에서 시작
+        const direction = new THREE.Vector3()
+            .subVectors(playerPosition, startPos)
+            .normalize();
+        const distance = startPos.distanceTo(playerPosition);
 
-            const raycaster = new THREE.Raycaster(position, direction, 0, this.pathfinding.sensorDistance);
-            const intersects = raycaster.intersectObjects(window.gameInstance.obstacles, true);
+        const raycaster = new THREE.Raycaster(startPos, direction, 0, distance);
+        const intersects = raycaster.intersectObjects(window.gameInstance.obstacles, true);
 
-            if (intersects.length > 0) {
-                obstacles.push({
-                    angle: angle,
-                    distance: intersects[0].distance,
-                    point: intersects[0].point
-                });
-            }
-        });
+        // 장애물과의 거리 확인
+        if (intersects.length > 0) {
+            const obstacleDistance = intersects[0].distance;
+            return obstacleDistance > distance; // 장애물이 플레이어보다 멀리 있으면 true
+        }
 
-        return obstacles;
+        return true; // 장애물이 없으면 시야가 확보된 것
     }
 
-    // 회피 방향 계산
-    calculateAvoidanceDirection(obstacles) {
-        if (obstacles.length === 0) return null;
+    findAlternativePath(playerPosition) {
+        if (!this.mesh) return null;
 
-        // 모든 장애물의 방향을 고려하여 최적의 회피 방향 계산
-        const avoidanceVector = new THREE.Vector3();
-        obstacles.forEach(obstacle => {
-            const avoidDir = new THREE.Vector3()
-                .subVectors(this.mesh.position, obstacle.point)
-                .normalize()
-                .multiplyScalar(1 / obstacle.distance); // 거리에 반비례하는 가중치
-            avoidanceVector.add(avoidDir);
-        });
-
-        return avoidanceVector.normalize();
-    }
-
-    // 조준 시스템
-    updateAiming(playerPosition) {
-        const targetDirection = new THREE.Vector3()
-            .subVectors(playerPosition, this.mesh.position)
-            .normalize();
+        const currentPos = this.mesh.position.clone();
+        const possibleRoutes = [];
 
-        // 목표 회전각 계산
-        this.aiState.targetRotation = Math.atan2(targetDirection.x, targetDirection.z);
+        // 여러 각도로 경로 탐색
+        for (let angle = 0; angle < 360; angle += 45) {
+            const radians = angle * Math.PI / 180;
+            const checkDistance = 30; // 탐색 거리
 
-        // 현재 회전각 부드럽게 조정
-        const rotationDiff = this.aiState.targetRotation - this.aiState.currentRotation;
-        let rotationStep = Math.sign(rotationDiff) * Math.min(Math.abs(rotationDiff), 0.05);
-        this.aiState.currentRotation += rotationStep;
-
-        // 메시 회전 적용
-        this.mesh.rotation.y = this.aiState.currentRotation;
+            const testPoint = new THREE.Vector3(
+                currentPos.x + Math.cos(radians) * checkDistance,
+                currentPos.y,
+                currentPos.z + Math.sin(radians) * checkDistance
+            );
 
-        // 조준 정확도 계산
-        const aimAccuracy = 1 - Math.abs(rotationDiff) / Math.PI;
-        return aimAccuracy > this.combat.aimThreshold;
-    }
+            // 해당 지점까지의 경로 장애물 체크
+            const direction = new THREE.Vector3()
+                .subVectors(testPoint, currentPos)
+                .normalize();
+            const raycaster = new THREE.Raycaster(currentPos, direction, 0, checkDistance);
+            const intersects = raycaster.intersectObjects(window.gameInstance.obstacles, true);
 
-    // 전투 거리 관리
-    maintainCombatDistance(playerPosition) {
-        const distanceToPlayer = this.mesh.position.distanceTo(playerPosition);
-        let moveDirection = new THREE.Vector3();
-
-        if (distanceToPlayer < this.combat.minEngagementRange) {
-            // 너무 가까우면 후진
-            moveDirection.subVectors(this.mesh.position, playerPosition).normalize();
-        } else if (distanceToPlayer > this.combat.maxEngagementRange) {
-            // 너무 멀면 전진
-            moveDirection.subVectors(playerPosition, this.mesh.position).normalize();
-        } else if (Math.abs(distanceToPlayer - this.combat.optimalRange) > 10) {
-            // 최적 거리로 조정
-            const targetDistance = this.combat.optimalRange;
-            moveDirection.subVectors(playerPosition, this.mesh.position).normalize();
-            if (distanceToPlayer > targetDistance) {
-                moveDirection.multiplyScalar(1);
-            } else {
-                moveDirection.multiplyScalar(-1);
+            if (intersects.length === 0) {
+                // 해당 지점에서 플레이어까지의 시야 체크
+                const toPlayerDirection = new THREE.Vector3()
+                    .subVectors(playerPosition, testPoint)
+                    .normalize();
+                const toPlayerRaycaster = new THREE.Raycaster(testPoint, toPlayerDirection);
+                const playerIntersects = toPlayerRaycaster.intersectObjects(window.gameInstance.obstacles, true);
+
+                if (playerIntersects.length === 0) {
+                    possibleRoutes.push({
+                        point: testPoint,
+                        distance: testPoint.distanceTo(playerPosition)
+                    });
+                }
             }
         }
 
-        return moveDirection;
-    }
+        // 가장 효율적인 경로 선택
+        if (possibleRoutes.length > 0) {
+            possibleRoutes.sort((a, b) => a.distance - b.distance);
+            return possibleRoutes[0].point;
+        }
 
-    // 발사 조건 확인
-    canShoot(playerPosition) {
-        const distance = this.mesh.position.distanceTo(playerPosition);
-        const hasLineOfSight = this.checkLineOfSight(playerPosition);
-        const isAimed = this.updateAiming(playerPosition);
-
-        return distance <= this.combat.maxEngagementRange && 
-               distance >= this.combat.minEngagementRange && 
-               hasLineOfSight && 
-               isAimed;
+        return null;
     }
 
-    // 메인 업데이트 함수
     update(playerPosition) {
         if (!this.mesh || !this.isLoaded) return;
 
-        // AI 상태 업데이트
-        this.updateAIState(playerPosition);
+        const currentTime = Date.now();
+        const distanceToPlayer = this.mesh.position.distanceTo(playerPosition);
 
-        // 장애물 감지
-        const obstacles = this.detectObstacles();
-        
-        // 이동 및 회피 로직
-        if (obstacles.length > 0 && !this.pathfinding.isAvoidingObstacle) {
-            this.pathfinding.isAvoidingObstacle = true;
-            this.pathfinding.avoidanceDirection = this.calculateAvoidanceDirection(obstacles);
-            this.pathfinding.avoidanceTime = 0;
+        // 시야 체크
+        if (currentTime - this.aiState.lastVisibilityCheck > this.aiState.visibilityCheckInterval) {
+            this.aiState.canSeePlayer = this.checkLineOfSight(playerPosition);
+            this.aiState.lastVisibilityCheck = currentTime;
+
+            if (this.aiState.canSeePlayer) {
+                this.aiState.lastKnownPlayerPosition = playerPosition.clone();
+                this.aiState.pathfindingAttempts = 0;
+                this.aiState.alternativePath = null;
+            }
         }
 
-        // 회피 동작 수행
-        if (this.pathfinding.isAvoidingObstacle) {
-            this.pathfinding.avoidanceTime += 16; // 약 16ms per frame
-            if (this.pathfinding.avoidanceTime >= this.pathfinding.maxAvoidanceTime) {
-                this.pathfinding.isAvoidingObstacle = false;
+        // AI 상태 업데이트
+        if (currentTime - this.aiState.lastStateChange > this.aiState.stateChangeCooldown) {
+            if (!this.aiState.canSeePlayer) {
+                if (!this.aiState.alternativePath) {
+                    this.aiState.alternativePath = this.findAlternativePath(playerPosition);
+                    this.aiState.pathfindingAttempts++;
+                }
             } else {
-                const avoidMove = this.pathfinding.avoidanceDirection.multiplyScalar(this.moveSpeed);
-                this.mesh.position.add(avoidMove);
+                if (distanceToPlayer < this.combat.minEngagementRange) {
+                    this.aiState.mode = 'retreat';
+                } else if (distanceToPlayer > this.combat.maxEngagementRange) {
+                    this.aiState.mode = 'pursue';
+                } else {
+                    this.aiState.mode = 'engage';
+                }
             }
-        } else {
-            // 일반 이동 로직
+            this.aiState.lastStateChange = currentTime;
+        }
+
+        // 이동 및 전투 로직
+        if (this.aiState.canSeePlayer) {
+            // 정상적인 전투 행동
             switch (this.aiState.mode) {
                 case 'pursue':
-                    this.findPathToTarget(playerPosition);
-                    this.moveAlongPath();
-                    break;
-                case 'flank':
-                    const flankPosition = this.calculateFlankPosition(playerPosition);
-                    this.findPathToTarget(flankPosition);
-                    this.moveAlongPath();
+                    this.moveTowards(playerPosition);
                     break;
                 case 'retreat':
-                    const retreatPosition = this.calculateRetreatPosition(playerPosition);
-                    this.findPathToTarget(retreatPosition);
-                    this.moveAlongPath();
+                    this.moveAway(playerPosition);
                     break;
+                case 'engage':
+                    this.engageTarget(playerPosition);
+                    break;
+            }
+        } else {
+            // 우회 경로로 이동
+            if (this.aiState.alternativePath) {
+                this.moveTowards(this.aiState.alternativePath);
+                if (this.mesh.position.distanceTo(this.aiState.alternativePath) < 5) {
+                    this.aiState.alternativePath = null;
+                }
+            } else if (this.aiState.pathfindingAttempts < this.aiState.maxPathfindingAttempts) {
+                this.aiState.alternativePath = this.findAlternativePath(playerPosition);
+                this.aiState.pathfindingAttempts++;
             }
         }
 
-        // 전투 거리 조정
-        const combatMove = this.maintainCombatDistance(playerPosition);
-        if (combatMove.length() > 0) {
-            this.mesh.position.add(combatMove.multiplyScalar(this.moveSpeed));
-        }
+        // 포탑 회전 업데이트
+        this.updateTurretRotation(playerPosition);
 
-        // 발사 처리
+        // 발사 가능 여부 확인 및 발사
         if (this.canShoot(playerPosition)) {
             this.shoot(playerPosition);
         }
 
         // 총알 업데이트
         this.updateBullets();
-
-        // 탱크 기울기 조정
-        this.adjustTankTilt();
-    }
-  async initialize(loader) {
-        try {
-            const modelPath = this.type === 'tank' ? '/models/t90.glb' : '/models/t90.glb';
-            const result = await loader.loadAsync(modelPath);
-            this.mesh = result.scene;
-            this.mesh.position.copy(this.position);
-            this.mesh.scale.set(ENEMY_SCALE, ENEMY_SCALE, ENEMY_SCALE);
-            
-            this.mesh.traverse((child) => {
-                if (child.isMesh) {
-                    child.castShadow = true;
-                    child.receiveShadow = true;
-                }
-            });
-            
-            this.scene.add(this.mesh);
-            this.isLoaded = true;
-        } catch (error) {
-            console.error('Error loading enemy model:', error);
-            this.isLoaded = false;
-        }
     }
 
-    checkLineOfSight(playerPosition) {
-        if (!this.mesh) return false;
-
-        const startPos = this.mesh.position.clone();
-        startPos.y += 2;
-        const direction = new THREE.Vector3().subVectors(playerPosition, startPos).normalize();
-        const distance = startPos.distanceTo(playerPosition);
-
-        const raycaster = new THREE.Raycaster(startPos, direction, 0, distance);
-        const intersects = raycaster.intersectObjects(window.gameInstance.obstacles, true);
-
-        return intersects.length === 0;
-    }
-
-    updateAIState(playerPosition) {
-        const currentTime = Date.now();
-        const distanceToPlayer = this.mesh.position.distanceTo(playerPosition);
+    moveTowards(target) {
+        if (!this.mesh) return;
 
-        if (currentTime - this.aiState.lastVisibilityCheck > this.aiState.visibilityCheckInterval) {
-            this.aiState.canSeePlayer = this.checkLineOfSight(playerPosition);
-            this.aiState.lastVisibilityCheck = currentTime;
+        const direction = new THREE.Vector3()
+            .subVectors(target, this.mesh.position)
+            .normalize();
 
-            if (this.aiState.canSeePlayer) {
-                this.aiState.lastKnownPlayerPosition = playerPosition.clone();
-                this.aiState.searchStartTime = null;
+        // 장애물 감지
+        const obstacles = this.detectObstacles();
+        if (obstacles.length > 0) {
+            // 회피 방향 계산
+            const avoidanceDirection = this.calculateAvoidanceDirection(obstacles);
+            if (avoidanceDirection) {
+                direction.add(avoidanceDirection).normalize();
             }
         }
 
-        if (currentTime - this.aiState.lastStateChange > this.aiState.stateChangeCooldown) {
-            if (this.health < 30) {
-                this.aiState.mode = 'retreat';
-            } else if (distanceToPlayer < 30 && this.aiState.canSeePlayer) {
-                this.aiState.mode = 'flank';
-            } else {
-                this.aiState.mode = 'pursue';
-            }
-            this.aiState.lastStateChange = currentTime;
-        }
+        // 이동 적용
+        this.mesh.position.add(direction.multiplyScalar(this.moveSpeed));
+        
+        // 이동 방향으로 차체 회전
+        const targetRotation = Math.atan2(direction.x, direction.z);
+        this.mesh.rotation.y = this.smoothRotation(this.mesh.rotation.y, targetRotation, 0.1);
     }
 
-    findPathToTarget(targetPosition) {
-        const currentTime = Date.now();
-        if (currentTime - this.pathfinding.lastPathUpdate < this.pathfinding.pathUpdateInterval) {
-            return;
-        }
+    moveAway(target) {
+        if (!this.mesh) return;
 
-        this.pathfinding.currentPath = this.generatePathPoints(this.mesh.position.clone(), targetPosition);
-        this.pathfinding.lastPathUpdate = currentTime;
+        const direction = new THREE.Vector3()
+            .subVectors(this.mesh.position, target)
+            .normalize();
+        this.mesh.position.add(direction.multiplyScalar(this.moveSpeed));
     }
 
-    generatePathPoints(start, end) {
-        const points = [];
-        const direction = new THREE.Vector3().subVectors(end, start).normalize();
-        const distance = start.distanceTo(end);
-        const steps = Math.ceil(distance / 10);
+    engageTarget(playerPosition) {
+        if (!this.mesh) return;
 
-        for (let i = 0; i <= steps; i++) {
-            const point = start.clone().add(direction.multiplyScalar(i * 10));
-            points.push(point);
+        // 최적 전투 거리 유지
+        const distanceToPlayer = this.mesh.position.distanceTo(playerPosition);
+        const optimalRange = this.combat.optimalRange;
+        
+        if (Math.abs(distanceToPlayer - optimalRange) > 5) {
+            if (distanceToPlayer < optimalRange) {
+                this.moveAway(playerPosition);
+            } else {
+                this.moveTowards(playerPosition);
+            }
         }
-
-        return points;
     }
 
-    moveAlongPath() {
-        if (this.pathfinding.currentPath.length === 0) return;
+    updateTurretRotation(playerPosition) {
+        if (!this.mesh) return;
 
-        const targetPoint = this.pathfinding.currentPath[0];
         const direction = new THREE.Vector3()
-            .subVectors(targetPoint, this.mesh.position)
-            .normalize();
-
-        const moveVector = direction.multiplyScalar(this.moveSpeed);
-        this.mesh.position.add(moveVector);
+            .subVectors(playerPosition, this.mesh.position);
+        this.combat.targetTurretRotation = Math.atan2(direction.x, direction.z);
+
+        // 부드러운 포탑 회전
+        this.combat.turretRotation = this.smoothRotation(
+            this.combat.turretRotation,
+            this.combat.targetTurretRotation,
+            this.combat.turretRotationSpeed
+        );
 
-        if (this.mesh.position.distanceTo(targetPoint) < 2) {
-            this.pathfinding.currentPath.shift();
+        // 포탑 메시가 있다면 회전 적용
+        if (this.mesh.getObjectByName('turret')) {
+            this.mesh.getObjectByName('turret').rotation.y = this.combat.turretRotation;
         }
     }
 
-    calculateFlankPosition(playerPosition) {
-        const angle = Math.random() * Math.PI * 2;
-        const radius = 40;
-        return new THREE.Vector3(
-            playerPosition.x + Math.cos(angle) * radius,
-            playerPosition.y,
-            playerPosition.z + Math.sin(angle) * radius
-        );
+    smoothRotation(current, target, speed) {
+        let difference = target - current;
+        
+        // 각도 차이를 -PI에서 PI 사이로 정규화
+        while (difference > Math.PI) difference -= Math.PI * 2;
+        while (difference < -Math.PI) difference += Math.PI * 2;
+        
+        return current + difference * speed;
     }
 
-    calculateRetreatPosition(playerPosition) {
-        const direction = new THREE.Vector3()
-            .subVectors(this.mesh.position, playerPosition)
-            .normalize();
-        return this.mesh.position.clone().add(direction.multiplyScalar(50));
-    }
+    canShoot(playerPosition) {
+        if (!this.mesh) return false;
 
-    adjustTankTilt() {
-        const forwardVector = new THREE.Vector3(0, 0, 1).applyQuaternion(this.mesh.quaternion);
-        const rightVector = new THREE.Vector3(1, 0, 0).applyQuaternion(this.mesh.quaternion);
-        
-        const frontHeight = window.gameInstance.getHeightAtPosition(
-            this.mesh.position.x + forwardVector.x,
-            this.mesh.position.z + forwardVector.z
-        );
-        const backHeight = window.gameInstance.getHeightAtPosition(
-            this.mesh.position.x - forwardVector.x,
-            this.mesh.position.z - forwardVector.z
-        );
-        const rightHeight = window.gameInstance.getHeightAtPosition(
-            this.mesh.position.x + rightVector.x,
-            this.mesh.position.z + rightVector.z
-        );
-        const leftHeight = window.gameInstance.getHeightAtPosition(
-            this.mesh.position.x - rightVector.x,
-            this.mesh.position.z - rightVector.z
+        const currentTime = Date.now();
+        const timeSinceLastShot = currentTime - this.lastAttackTime;
+        const distanceToPlayer = this.mesh.position.distanceTo(playerPosition);
+
+        return (
+            this.aiState.canSeePlayer &&
+            timeSinceLastShot >= ENEMY_CONFIG.ATTACK_INTERVAL &&
+            distanceToPlayer <= this.combat.maxEngagementRange &&
+            distanceToPlayer >= this.combat.minEngagementRange &&
+            Math.abs(this.combat.turretRotation - this.combat.targetTurretRotation) < this.combat.aimThreshold
         );
-        
-        const pitch = Math.atan2(frontHeight - backHeight, 2);
-        const roll = Math.atan2(rightHeight - leftHeight, 2);
-        
-        const currentRotation = this.mesh.rotation.y;
-        this.mesh.rotation.set(pitch, currentRotation, roll);
     }
 
-    updateBullets() {
-        for (let i = this.bullets.length - 1; i >= 0; i--) {
-            const bullet = this.bullets[i];
-            bullet.position.add(bullet.velocity);
-            
-            if (Math.abs(bullet.position.x) > MAP_SIZE / 2 || 
-                Math.abs(bullet.position.z) > MAP_SIZE / 2) {
-                this.scene.remove(bullet);
-                this.bullets.splice(i, 1);
-                continue;
-            }
-            
-            const bulletBox = new THREE.Box3().setFromObject(bullet);
-            for (const obstacle of window.gameInstance.obstacles) {
-                const obstacleBox = new THREE.Box3().setFromObject(obstacle);
-                if (bulletBox.intersectsBox(obstacleBox)) {
-                    this.scene.remove(bullet);
-                    this.bullets.splice(i, 1);
-                    break;
-                }
-            }
-        }
-    }
+    detectObstacles() {
+        const obstacles = [];
+        const position = this.mesh.position.clone();
+        position.y += 1;
 
-    createMuzzleFlash() {
-        if (!this.mesh) return;
-        
-        const flashGroup = new THREE.Group();
-        
-        const flameGeometry = new THREE.SphereGeometry(1.0, 8, 8);
-        const flameMaterial = new THREE.MeshBasicMaterial({
-            color: 0xffa500,
-            transparent: true,
-            opacity: 0.8
-        });
-        const flame = new THREE.Mesh(flameGeometry, flameMaterial);
-        flame.scale.set(2, 2, 3);
-        flashGroup.add(flame);
+        this.pathfinding.sensorAngles.forEach(angle => {
+            const direction = new THREE.Vector3(0, 0, 1)
+                .applyAxisAngle(new THREE.Vector3(0, 1, 0), angle * Math.PI / 180)
+                .applyQuaternion(this.mesh.quaternion);
 
-        const smokeGeometry = new THREE.SphereGeometry(0.8, 8, 8);
-        const smokeMaterial = new THREE.MeshBasicMaterial({
-            color: 0x555555,
-            transparent: true,
-            opacity: 0.5
+            const raycaster = new THREE.Raycaster(position, direction, 0, this.pathfinding.sensorDistance);
+            const intersects = raycaster.intersectObjects(window.gameInstance.obstacles, true);
+
+            if (intersects.length > 0) {
+                obstacles.push({
+                    angle: angle,
+                    distance: intersects[0].distance,
+                    point: intersects[0].point
+                });
+            }
         });
-        
-        for (let i = 0; i < 5; i++) {
-            const smoke = new THREE.Mesh(smokeGeometry, smokeMaterial);
-            smoke.position.set(
-                Math.random() * 1 - 0.5,
-                Math.random() * 1 - 0.5,
-                -1 - Math.random()
-            );
-            smoke.scale.set(1.5, 1.5, 1.5);
-            flashGroup.add(smoke);
-        }
 
-        const muzzleOffset = new THREE.Vector3(0, 0.5, 4);
-        const muzzlePosition = new THREE.Vector3();
-        const meshWorldQuaternion = new THREE.Quaternion();
-        
-        this.mesh.getWorldPosition(muzzlePosition);
-        this.mesh.getWorldQuaternion(meshWorldQuaternion);
-        
-        muzzleOffset.applyQuaternion(meshWorldQuaternion);
-        muzzlePosition.add(muzzleOffset);
+        return obstacles;
+    }
 
-        flashGroup.position.copy(muzzlePosition);
-        flashGroup.quaternion.copy(meshWorldQuaternion);
+    calculateAvoidanceDirection(obstacles) {
+        if (obstacles.length === 0) return null;
 
-        this.scene.add(flashGroup);
+        const avoidanceVector = new THREE.Vector3();
+        obstacles.forEach(obstacle => {
+            const avoidDir = new THREE.Vector3()
+                .subVectors(this.mesh.position, obstacle.point)
+                .normalize()
+                .multiplyScalar(1 / obstacle.distance);
+            avoidanceVector.add(avoidDir);
+        });
 
-        setTimeout(() => {
-            this.scene.remove(flashGroup);
-        }, 500);
+        return avoidanceVector.normalize();
     }
 
     shoot(playerPosition) {
-        const currentTime = Date.now();
-        const attackInterval = this.type === 'tank' ? 
-            ENEMY_CONFIG.ATTACK_INTERVAL : 
-            ENEMY_CONFIG.ATTACK_INTERVAL * 1.5;
+    const currentTime = Date.now();
+    const attackInterval = this.type === 'tank' ? 
+        ENEMY_CONFIG.ATTACK_INTERVAL : 
+        ENEMY_CONFIG.ATTACK_INTERVAL * 1.5;
+
+    if (currentTime - this.lastAttackTime < attackInterval) return;
+
+    this.createMuzzleFlash();
 
-        if (currentTime - this.lastAttackTime < attackInterval) return;
+    const enemyFireSound = new Audio('sounds/mbtfire5.ogg');
+    enemyFireSound.volume = 0.3;
+    enemyFireSound.play();
 
-        this.createMuzzleFlash();
+    const bulletGeometry = new THREE.CylinderGeometry(0.2, 0.2, 2, 8);
+    const bulletMaterial = new THREE.MeshBasicMaterial({ 
+        color: 0xff0000,
+        emissive: 0xff0000,
+        emissiveIntensity: 0.5
+    });
+    const bullet = new THREE.Mesh(bulletGeometry, bulletMaterial);
 
-        const enemyFireSound = new Audio('sounds/mbtfire5.ogg');
-        enemyFireSound.volume = 0.3;
-        enemyFireSound.play();
+    const muzzleOffset = new THREE.Vector3(0, 0.5, 4);
+    const muzzlePosition = new THREE.Vector3();
+    this.mesh.getWorldPosition(muzzlePosition);
+    muzzleOffset.applyQuaternion(this.mesh.quaternion);
+    muzzlePosition.add(muzzleOffset);
+    
+    bullet.position.copy(muzzlePosition);
+    bullet.quaternion.copy(this.mesh.quaternion);
+    
+    const direction = new THREE.Vector3()
+        .subVectors(playerPosition, muzzlePosition)
+        .normalize();
+    
+    const bulletSpeed = this.type === 'tank' ? 
+        ENEMY_CONFIG.BULLET_SPEED : 
+        ENEMY_CONFIG.BULLET_SPEED * 0.8;
+    
+    bullet.velocity = direction.multiplyScalar(bulletSpeed);
+    
+    const trailGeometry = new THREE.CylinderGeometry(0.1, 0.1, 1, 8);
+    const trailMaterial = new THREE.MeshBasicMaterial({
+        color: 0xff4444,
+        transparent: true,
+        opacity: 0.5
+    });
+    
+    const trail = new THREE.Mesh(trailGeometry, trailMaterial);
+    trail.position.z = -1;
+    bullet.add(trail);
+    
+    this.scene.add(bullet);
+    this.bullets.push(bullet);
+    this.lastAttackTime = currentTime;
+}
 
-        const bulletGeometry = new THREE.CylinderGeometry(0.2, 0.2, 2, 8);
-        const bulletMaterial = new THREE.MeshBasicMaterial({ 
+takeDamage(damage) {
+    this.health -= damage;
+    
+    // 피격 효과 생성
+    if (this.mesh) {
+        const flashMaterial = new THREE.MeshBasicMaterial({
             color: 0xff0000,
-            emissive: 0xff0000,
-            emissiveIntensity: 0.5
+            transparent: true,
+            opacity: 0.5
         });
-        const bullet = new THREE.Mesh(bulletGeometry, bulletMaterial);
-
-        const muzzleOffset = new THREE.Vector3(0, 0.5, 4);
-        const muzzlePosition = new THREE.Vector3();
-        this.mesh.getWorldPosition(muzzlePosition);
-        muzzleOffset.applyQuaternion(this.mesh.quaternion);
-        muzzlePosition.add(muzzleOffset);
-        
-        bullet.position.copy(muzzlePosition);
-        bullet.quaternion.copy(this.mesh.quaternion);
-        
-        const direction = new THREE.Vector3()
-            .subVectors(playerPosition, muzzlePosition)
-            .normalize();
-        
-        const bulletSpeed = this.type === 'tank' ? 
-            ENEMY_CONFIG.BULLET_SPEED : 
-            ENEMY_CONFIG.BULLET_SPEED * 0.8;
         
-        bullet.velocity = direction.multiplyScalar(bulletSpeed);
+        this.mesh.traverse((child) => {
+            if (child.isMesh) {
+                child.originalMaterial = child.material;
+                child.material = flashMaterial;
+            }
+        });
         
-        const trailGeometry = new THREE.CylinderGeometry(0.1, 0.1, 1, 8);
-        const trailMaterial = new THREE.MeshBasicMaterial({
-            color: 0xff4444,
+        // 0.1초 후 원래 재질로 복구
+        setTimeout(() => {
+            this.mesh.traverse((child) => {
+                if (child.isMesh && child.originalMaterial) {
+                    child.material = child.originalMaterial;
+                }
+            });
+        }, 100);
+    }
+    
+    return this.health <= 0;
+}
+
+destroy() {
+    if (this.mesh) {
+        // 폭발 효과 생성
+        const explosionGeometry = new THREE.SphereGeometry(2, 32, 32);
+        const explosionMaterial = new THREE.MeshBasicMaterial({
+            color: 0xff4500,
             transparent: true,
-            opacity: 0.5
+            opacity: 0.8
         });
+        const explosion = new THREE.Mesh(explosionGeometry, explosionMaterial);
+        explosion.position.copy(this.mesh.position);
+        this.scene.add(explosion);
+        
+        // 폭발 파티클 생성
+        for (let i = 0; i < 20; i++) {
+            const particleGeometry = new THREE.SphereGeometry(0.2, 8, 8);
+            const particleMaterial = new THREE.MeshBasicMaterial({
+                color: Math.random() < 0.5 ? 0xff4500 : 0xff8c00,
+                transparent: true,
+                opacity: 1
+            });
+            const particle = new THREE.Mesh(particleGeometry, particleMaterial);
+            particle.position.copy(this.mesh.position);
+            
+            // 랜덤 방향으로 튀어나가는 효과
+            const angle = Math.random() * Math.PI * 2;
+            const speed = Math.random() * 0.5 + 0.5;
+            particle.velocity = new THREE.Vector3(
+                Math.cos(angle) * speed,
+                Math.random() * speed,
+                Math.sin(angle) * speed
+            );
+            
+            this.scene.add(particle);
+            window.gameInstance.particles.push({
+                mesh: particle,
+                velocity: particle.velocity,
+                life: Math.random() * 60 + 60
+            });
+        }
+        
+        // 폭발음 재생
+        const explosionSound = new Audio('sounds/explosion.ogg');
+        explosionSound.volume = 0.4;
+        explosionSound.play();
         
-        const trail = new THREE.Mesh(trailGeometry, trailMaterial);
-        trail.position.z = -1;
-        bullet.add(trail);
+        // 메시와 총알 제거
+        this.scene.remove(this.mesh);
+        this.bullets.forEach(bullet => this.scene.remove(bullet));
+        this.bullets = [];
+        this.isLoaded = false;
         
-        this.scene.add(bullet);
-        this.bullets.push(bullet);
-        this.lastAttackTime = currentTime;
+        // 0.5초 후 폭발 효과 제거
+        setTimeout(() => {
+            this.scene.remove(explosion);
+        }, 500);
     }
+}
 
-    takeDamage(damage) {
-        this.health -= damage;
-        return this.health <= 0;
+// 추가 유틸리티 메서드들
+createMuzzleFlash() {
+    if (!this.mesh) return;
+    
+    const flashGroup = new THREE.Group();
+    
+    const flameGeometry = new THREE.SphereGeometry(0.5, 8, 8);
+    const flameMaterial = new THREE.MeshBasicMaterial({
+        color: 0xffa500,
+        transparent: true,
+        opacity: 0.8
+    });
+    const flame = new THREE.Mesh(flameGeometry, flameMaterial);
+    flashGroup.add(flame);
+    
+    const smokeGeometry = new THREE.SphereGeometry(0.3, 8, 8);
+    const smokeMaterial = new THREE.MeshBasicMaterial({
+        color: 0x555555,
+        transparent: true,
+        opacity: 0.5
+    });
+    
+    for (let i = 0; i < 3; i++) {
+        const smoke = new THREE.Mesh(smokeGeometry, smokeMaterial);
+        smoke.position.z = -0.5 - Math.random();
+        flashGroup.add(smoke);
     }
+    
+    const muzzleOffset = new THREE.Vector3(0, 0.5, 4);
+    const muzzlePosition = new THREE.Vector3();
+    this.mesh.getWorldPosition(muzzlePosition);
+    muzzleOffset.applyQuaternion(this.mesh.quaternion);
+    muzzlePosition.add(muzzleOffset);
+    
+    flashGroup.position.copy(muzzlePosition);
+    flashGroup.quaternion.copy(this.mesh.quaternion);
+    
+    this.scene.add(flashGroup);
+    
+    setTimeout(() => {
+        this.scene.remove(flashGroup);
+    }, 100);
+}
 
-    destroy() {
-        if (this.mesh) {
-            this.scene.remove(this.mesh);
-            this.bullets.forEach(bullet => this.scene.remove(bullet));
-            this.bullets = [];
-            this.isLoaded = false;
-        }
-    }
+checkLineOfSight(playerPosition) {
+    if (!this.mesh) return false;
+    
+    const startPos = this.mesh.position.clone();
+    startPos.y += 1;
+    const direction = new THREE.Vector3()
+        .subVectors(playerPosition, startPos)
+        .normalize();
+    
+    const raycaster = new THREE.Raycaster(startPos, direction);
+    const intersects = raycaster.intersectObjects(window.gameInstance.obstacles, true);
+    
+    return intersects.length === 0;
+}
 }
 
 // Particle 클래스