Update game.js

game.js

@@ -570,6 +570,7 @@ startReload() {
 // Enemy 클래스
 class Enemy {
     constructor(scene, position, type = 'tank') {
+        // 기본 속성
         this.scene = scene;
         this.position = position;
         this.mesh = null;
@@ -590,22 +591,25 @@ class Enemy {
             canSeePlayer: false,
             lastKnownPlayerPosition: null,
             searchStartTime: null,
-            pathfindingAttempts: 0,
-            maxPathfindingAttempts: 5,
-            alternativePath: null
+            targetRotation: 0,
+            currentRotation: 0,
+            isAiming: false,
+            aimingTime: 0,
+            requiredAimTime: 1000 // 조준에 필요한 시간
         };
 
-        // 경로 탐색 시스템
+        // 경로 탐색 및 회피 시스템
         this.pathfinding = {
             currentPath: [],
             pathUpdateInterval: 1000,
             lastPathUpdate: 0,
             isAvoidingObstacle: false,
             avoidanceDirection: null,
-            obstacleCheckDistance: 15,
-            sensorAngles: [-45, -30, -15, 0, 15, 30, 45],
-            sensorDistance: 20,
-            alternativeRoutes: []
+            obstacleCheckDistance: 10,
+            avoidanceTime: 0,
+            maxAvoidanceTime: 3000, // 최대 회피 시간
+            sensorAngles: [-45, 0, 45], // 전방 감지 각도
+            sensorDistance: 15 // 감지 거리
         };
 
         // 전투 시스템
@@ -613,503 +617,473 @@ class Enemy {
             minEngagementRange: 30,
             maxEngagementRange: 150,
             optimalRange: 80,
-            aimThreshold: 0.1,
+            aimThreshold: 0.1, // 조준 정확도 임계값
             lastShotAccuracy: 0,
-            turretRotation: 0,
-            targetTurretRotation: 0,
-            turretRotationSpeed: 0.05
+            consecutiveHits: 0,
+            maxConsecutiveHits: 3
         };
     }
 
-    checkLineOfSight(playerPosition) {
-        if (!this.mesh) return false;
+    // 장애물 감지 시스템
+    detectObstacles() {
+        const obstacles = [];
+        const position = this.mesh.position.clone();
+        position.y += 1; // 센서 높이 조정
 
-        const startPos = this.mesh.position.clone();
-        startPos.y += 2; // 포탑 높이에서 시작
-        const direction = new THREE.Vector3()
-            .subVectors(playerPosition, startPos)
-            .normalize();
-        const distance = startPos.distanceTo(playerPosition);
+        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 raycaster = new THREE.Raycaster(startPos, direction, 0, distance);
-        const intersects = raycaster.intersectObjects(window.gameInstance.obstacles, true);
+            const raycaster = new THREE.Raycaster(position, direction, 0, this.pathfinding.sensorDistance);
+            const intersects = raycaster.intersectObjects(window.gameInstance.obstacles, true);
 
-        // 장애물과의 거리 확인
-        if (intersects.length > 0) {
-            const obstacleDistance = intersects[0].distance;
-            return obstacleDistance > distance; // 장애물이 플레이어보다 멀리 있으면 true
-        }
+            if (intersects.length > 0) {
+                obstacles.push({
+                    angle: angle,
+                    distance: intersects[0].distance,
+                    point: intersects[0].point
+                });
+            }
+        });
 
-        return true; // 장애물이 없으면 시야가 확보된 것
+        return obstacles;
     }
 
-    findAlternativePath(playerPosition) {
-        if (!this.mesh) return null;
+    // 회피 방향 계산
+    calculateAvoidanceDirection(obstacles) {
+        if (obstacles.length === 0) return null;
 
-        const currentPos = this.mesh.position.clone();
-        const possibleRoutes = [];
+        // 모든 장애물의 방향을 고려하여 최적의 회피 방향 계산
+        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);
+        });
 
-        // 여러 각도로 경로 탐색
-        for (let angle = 0; angle < 360; angle += 45) {
-            const radians = angle * Math.PI / 180;
-            const checkDistance = 30; // 탐색 거리
+        return avoidanceVector.normalize();
+    }
 
-            const testPoint = new THREE.Vector3(
-                currentPos.x + Math.cos(radians) * checkDistance,
-                currentPos.y,
-                currentPos.z + Math.sin(radians) * checkDistance
-            );
+    // 조준 시스템
+    updateAiming(playerPosition) {
+        const targetDirection = new THREE.Vector3()
+            .subVectors(playerPosition, this.mesh.position)
+            .normalize();
 
-            // 해당 지점까지의 경로 장애물 체크
-            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);
+        // 목표 회전각 계산
+        this.aiState.targetRotation = Math.atan2(targetDirection.x, targetDirection.z);
 
-            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)
-                    });
-                }
+        // 현재 회전각 부드럽게 조정
+        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 aimAccuracy = 1 - Math.abs(rotationDiff) / Math.PI;
+        return aimAccuracy > this.combat.aimThreshold;
+    }
+
+    // 전투 거리 관리
+    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 (possibleRoutes.length > 0) {
-            possibleRoutes.sort((a, b) => a.distance - b.distance);
-            return possibleRoutes[0].point;
-        }
+        return moveDirection;
+    }
 
-        return null;
+    // 발사 조건 확인
+    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;
     }
 
+    // 메인 업데이트 함수
     update(playerPosition) {
         if (!this.mesh || !this.isLoaded) return;
 
-        const currentTime = Date.now();
-        const distanceToPlayer = this.mesh.position.distanceTo(playerPosition);
-
-        // 시야 체크
-        if (currentTime - this.aiState.lastVisibilityCheck > this.aiState.visibilityCheckInterval) {
-            this.aiState.canSeePlayer = this.checkLineOfSight(playerPosition);
-            this.aiState.lastVisibilityCheck = currentTime;
+        // AI 상태 업데이트
+        this.updateAIState(playerPosition);
 
-            if (this.aiState.canSeePlayer) {
-                this.aiState.lastKnownPlayerPosition = playerPosition.clone();
-                this.aiState.pathfindingAttempts = 0;
-                this.aiState.alternativePath = null;
-            }
+        // 장애물 감지
+        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;
         }
 
-        // 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++;
-                }
+        // 회피 동작 수행
+        if (this.pathfinding.isAvoidingObstacle) {
+            this.pathfinding.avoidanceTime += 16; // 약 16ms per frame
+            if (this.pathfinding.avoidanceTime >= this.pathfinding.maxAvoidanceTime) {
+                this.pathfinding.isAvoidingObstacle = false;
             } else {
-                if (distanceToPlayer < this.combat.minEngagementRange) {
-                    this.aiState.mode = 'retreat';
-                } else if (distanceToPlayer > this.combat.maxEngagementRange) {
-                    this.aiState.mode = 'pursue';
-                } else {
-                    this.aiState.mode = 'engage';
-                }
+                const avoidMove = this.pathfinding.avoidanceDirection.multiplyScalar(this.moveSpeed);
+                this.mesh.position.add(avoidMove);
             }
-            this.aiState.lastStateChange = currentTime;
-        }
-
-        // 이동 및 전투 로직
-        if (this.aiState.canSeePlayer) {
-            // 정상적인 전투 행동
+        } else {
+            // 일반 이동 로직
             switch (this.aiState.mode) {
                 case 'pursue':
-                    this.moveTowards(playerPosition);
+                    this.findPathToTarget(playerPosition);
+                    this.moveAlongPath();
                     break;
-                case 'retreat':
-                    this.moveAway(playerPosition);
+                case 'flank':
+                    const flankPosition = this.calculateFlankPosition(playerPosition);
+                    this.findPathToTarget(flankPosition);
+                    this.moveAlongPath();
                     break;
-                case 'engage':
-                    this.engageTarget(playerPosition);
+                case 'retreat':
+                    const retreatPosition = this.calculateRetreatPosition(playerPosition);
+                    this.findPathToTarget(retreatPosition);
+                    this.moveAlongPath();
                     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++;
-            }
         }
 
-        // 포탑 회전 업데이트
-        this.updateTurretRotation(playerPosition);
+        // 전투 거리 조정
+        const combatMove = this.maintainCombatDistance(playerPosition);
+        if (combatMove.length() > 0) {
+            this.mesh.position.add(combatMove.multiplyScalar(this.moveSpeed));
+        }
 
-        // 발사 가능 여부 확인 및 발사
+        // 발사 처리
         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;
+        }
     }
 
-    moveTowards(target) {
-        if (!this.mesh) return;
+    checkLineOfSight(playerPosition) {
+        if (!this.mesh) return false;
 
-        const direction = new THREE.Vector3()
-            .subVectors(target, this.mesh.position)
-            .normalize();
+        const startPos = this.mesh.position.clone();
+        startPos.y += 2;
+        const direction = new THREE.Vector3().subVectors(playerPosition, startPos).normalize();
+        const distance = startPos.distanceTo(playerPosition);
 
-        // 장애물 감지
-        const obstacles = this.detectObstacles();
-        if (obstacles.length > 0) {
-            // 회피 방향 계산
-            const avoidanceDirection = this.calculateAvoidanceDirection(obstacles);
-            if (avoidanceDirection) {
-                direction.add(avoidanceDirection).normalize();
+        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);
+
+        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.searchStartTime = null;
             }
         }
 
-        // 이동 적용
-        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);
+        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;
+        }
     }
 
-    moveAway(target) {
-        if (!this.mesh) return;
+    findPathToTarget(targetPosition) {
+        const currentTime = Date.now();
+        if (currentTime - this.pathfinding.lastPathUpdate < this.pathfinding.pathUpdateInterval) {
+            return;
+        }
 
-        const direction = new THREE.Vector3()
-            .subVectors(this.mesh.position, target)
-            .normalize();
-        this.mesh.position.add(direction.multiplyScalar(this.moveSpeed));
+        this.pathfinding.currentPath = this.generatePathPoints(this.mesh.position.clone(), targetPosition);
+        this.pathfinding.lastPathUpdate = currentTime;
     }
 
-    engageTarget(playerPosition) {
-        if (!this.mesh) return;
+    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);
 
-        // 최적 전투 거리 유지
-        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);
-            }
+        for (let i = 0; i <= steps; i++) {
+            const point = start.clone().add(direction.multiplyScalar(i * 10));
+            points.push(point);
         }
+
+        return points;
     }
 
-    updateTurretRotation(playerPosition) {
-        if (!this.mesh) return;
+    moveAlongPath() {
+        if (this.pathfinding.currentPath.length === 0) return;
 
+        const targetPoint = this.pathfinding.currentPath[0];
         const direction = new THREE.Vector3()
-            .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
-        );
+            .subVectors(targetPoint, this.mesh.position)
+            .normalize();
 
-        // 포탑 메시가 있다면 회전 적용
-        if (this.mesh.getObjectByName('turret')) {
-            this.mesh.getObjectByName('turret').rotation.y = this.combat.turretRotation;
+        const moveVector = direction.multiplyScalar(this.moveSpeed);
+        this.mesh.position.add(moveVector);
+
+        if (this.mesh.position.distanceTo(targetPoint) < 2) {
+            this.pathfinding.currentPath.shift();
         }
     }
 
-    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;
+    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
+        );
     }
 
-    canShoot(playerPosition) {
-        if (!this.mesh) return false;
-
-        const currentTime = Date.now();
-        const timeSinceLastShot = currentTime - this.lastAttackTime;
-        const distanceToPlayer = this.mesh.position.distanceTo(playerPosition);
+    calculateRetreatPosition(playerPosition) {
+        const direction = new THREE.Vector3()
+            .subVectors(this.mesh.position, playerPosition)
+            .normalize();
+        return this.mesh.position.clone().add(direction.multiplyScalar(50));
+    }
 
-        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
+    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 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);
     }
 
-    detectObstacles() {
-        const obstacles = [];
-        const position = this.mesh.position.clone();
-        position.y += 1;
-
-        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);
+    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;
+                }
+            }
+        }
+    }
 
-            const raycaster = new THREE.Raycaster(position, direction, 0, this.pathfinding.sensorDistance);
-            const intersects = raycaster.intersectObjects(window.gameInstance.obstacles, true);
+    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);
 
-            if (intersects.length > 0) {
-                obstacles.push({
-                    angle: angle,
-                    distance: intersects[0].distance,
-                    point: intersects[0].point
-                });
-            }
+        const smokeGeometry = new THREE.SphereGeometry(0.8, 8, 8);
+        const smokeMaterial = new THREE.MeshBasicMaterial({
+            color: 0x555555,
+            transparent: true,
+            opacity: 0.5
         });
+        
+        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);
+        }
 
-        return obstacles;
-    }
+        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);
 
-    calculateAvoidanceDirection(obstacles) {
-        if (obstacles.length === 0) return null;
+        flashGroup.position.copy(muzzlePosition);
+        flashGroup.quaternion.copy(meshWorldQuaternion);
 
-        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);
-        });
+        this.scene.add(flashGroup);
 
-        return avoidanceVector.normalize();
+        setTimeout(() => {
+            this.scene.remove(flashGroup);
+        }, 500);
     }
 
     shoot(playerPosition) {
-    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();
+        const currentTime = Date.now();
+        const attackInterval = this.type === 'tank' ? 
+            ENEMY_CONFIG.ATTACK_INTERVAL : 
+            ENEMY_CONFIG.ATTACK_INTERVAL * 1.5;
 
-    const enemyFireSound = new Audio('sounds/mbtfire5.ogg');
-    enemyFireSound.volume = 0.3;
-    enemyFireSound.play();
+        if (currentTime - this.lastAttackTime < attackInterval) return;
 
-    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);
+        this.createMuzzleFlash();
 
-    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 enemyFireSound = new Audio('sounds/mbtfire5.ogg');
+        enemyFireSound.volume = 0.3;
+        enemyFireSound.play();
 
-takeDamage(damage) {
-    this.health -= damage;
-    
-    // 피격 효과 생성
-    if (this.mesh) {
-        const flashMaterial = new THREE.MeshBasicMaterial({
+        const bulletGeometry = new THREE.CylinderGeometry(0.2, 0.2, 2, 8);
+        const bulletMaterial = new THREE.MeshBasicMaterial({ 
             color: 0xff0000,
-            transparent: true,
-            opacity: 0.5
+            emissive: 0xff0000,
+            emissiveIntensity: 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);
         
-        this.mesh.traverse((child) => {
-            if (child.isMesh) {
-                child.originalMaterial = child.material;
-                child.material = flashMaterial;
-            }
-        });
+        bullet.position.copy(muzzlePosition);
+        bullet.quaternion.copy(this.mesh.quaternion);
         
-        // 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,
+        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.8
+            opacity: 0.5
         });
-        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();
         
-        // 메시와 총알 제거
-        this.scene.remove(this.mesh);
-        this.bullets.forEach(bullet => this.scene.remove(bullet));
-        this.bullets = [];
-        this.isLoaded = false;
+        const trail = new THREE.Mesh(trailGeometry, trailMaterial);
+        trail.position.z = -1;
+        bullet.add(trail);
         
-        // 0.5초 후 폭발 효과 제거
-        setTimeout(() => {
-            this.scene.remove(explosion);
-        }, 500);
+        this.scene.add(bullet);
+        this.bullets.push(bullet);
+        this.lastAttackTime = currentTime;
     }
-}
 
-// 추가 유틸리티 메서드들
-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);
+    takeDamage(damage) {
+        this.health -= damage;
+        return this.health <= 0;
     }
-    
-    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);
-}
 
-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;
-}
+    destroy() {
+        if (this.mesh) {
+            this.scene.remove(this.mesh);
+            this.bullets.forEach(bullet => this.scene.remove(bullet));
+            this.bullets = [];
+            this.isLoaded = false;
+        }
+    }
 }
 
 // Particle 클래스