Update game.js

game.js

@@ -582,17 +582,9 @@ class Enemy {
         this.alternativePath = null;
         this.pathFindingTimeout = 0;
         this.lastPathUpdateTime = 0;
-        this.pathUpdateInterval = 1000;
+        this.pathUpdateInterval = 1000; // 1초마다 경로 업데이트
         this.moveSpeed = type === 'tank' ? ENEMY_MOVE_SPEED : ENEMY_MOVE_SPEED * 0.7;
         
-        // 좌우 이동 관련 속성 추가
-        this.movement = {
-            direction: null,              // 'left' 또는 'right'
-            lastDirectionChange: 0,       // 마지막 방향 변경 시간
-            directionDuration: 3000,      // 방향 유지 시간 (3초)
-            strafeSpeed: 0.15            // 좌우 이동 속도
-        };
-        
         // AI 상태 관리
         this.aiState = {
             mode: 'pursue',
@@ -607,7 +599,7 @@ class Enemy {
             currentRotation: 0,
             isAiming: false,
             aimingTime: 0,
-            requiredAimTime: 1000
+            requiredAimTime: 1000 // 조준에 필요한 시간
         };
 
         // 경로 탐색 및 회피 시스템
@@ -619,9 +611,9 @@ class Enemy {
             avoidanceDirection: null,
             obstacleCheckDistance: 10,
             avoidanceTime: 0,
-            maxAvoidanceTime: 3000,
-            sensorAngles: [-45, 0, 45],
-            sensorDistance: 15
+            maxAvoidanceTime: 3000, // 최대 회피 시간
+            sensorAngles: [-45, 0, 45], // 전방 감지 각도
+            sensorDistance: 15 // 감지 거리
         };
 
         // 전투 시스템
@@ -629,40 +621,18 @@ class Enemy {
             minEngagementRange: 30,
             maxEngagementRange: 150,
             optimalRange: 80,
-            aimThreshold: 0.1,
+            aimThreshold: 0.1, // 조준 정확도 임계값
             lastShotAccuracy: 0,
             consecutiveHits: 0,
             maxConsecutiveHits: 3
         };
     }
 
-    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;
-        }
-    }
-
+    // 장애물 감지 시스템
     detectObstacles() {
         const obstacles = [];
         const position = this.mesh.position.clone();
-        position.y += 1;
+        position.y += 1; // 센서 높이 조정
 
         this.pathfinding.sensorAngles.forEach(angle => {
             const direction = new THREE.Vector3(0, 0, 1)
@@ -683,165 +653,277 @@ class Enemy {
 
         return obstacles;
     }
+
+    // 회피 방향 계산
+    calculateAvoidanceDirection(obstacles) {
+        if (obstacles.length === 0) 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();
+
+    // 목표 회전각 계산
+    this.aiState.targetRotation = Math.atan2(targetDirection.x, targetDirection.z);
+
+    // 현재 회전각 부드럽게 조정 - 선회 속도를 느리게 하기 위해 조정
+    const rotationDiff = this.aiState.targetRotation - this.aiState.currentRotation;
+    let rotationStep = Math.sign(rotationDiff) * Math.min(Math.abs(rotationDiff), 0.05); // 기존 0.02에서 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;
 }
-// 메인 업데이트 메서드
-    update(playerPosition) {
-        if (!this.mesh || !this.isLoaded) return;
 
-        const currentTime = Date.now();
+    // 전투 거리 관리
+    maintainCombatDistance(playerPosition) {
         const distanceToPlayer = this.mesh.position.distanceTo(playerPosition);
-        const hasLineOfSight = this.checkLineOfSight(playerPosition);
+        let moveDirection = new THREE.Vector3();
 
-        // 방향 결정 로직
-        if (!this.movement.direction || 
-            currentTime - this.movement.lastDirectionChange > this.movement.directionDuration) {
-            this.movement.direction = Math.random() < 0.5 ? 'left' : 'right';
-            this.movement.lastDirectionChange = currentTime;
+        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 (hasLineOfSight && distanceToPlayer < ENEMY_CONFIG.ATTACK_RANGE) {
-            // 플레이어를 향한 방향 벡터
-            const directionToPlayer = new THREE.Vector3()
-                .subVectors(playerPosition, this.mesh.position)
-                .normalize();
+        return moveDirection;
+    }
 
-            // 좌우 이동을 위한 수직 벡터 계산
-            const sideVector = new THREE.Vector3()
-                .crossVectors(directionToPlayer, new THREE.Vector3(0, 1, 0))
-                .normalize();
+    // 발사 조건 확인
+    canShoot(playerPosition) {
+        const distance = this.mesh.position.distanceTo(playerPosition);
+        const hasLineOfSight = this.checkLineOfSight(playerPosition);
+        const isAimed = this.updateAiming(playerPosition);
 
-            // 선택된 방향으로 이동
-            if (this.movement.direction === 'left') {
-                this.mesh.position.add(sideVector.multiplyScalar(this.movement.strafeSpeed));
-            } else {
-                this.mesh.position.add(sideVector.multiplyScalar(-this.movement.strafeSpeed));
-            }
+        return distance <= this.combat.maxEngagementRange && 
+               distance >= this.combat.minEngagementRange && 
+               hasLineOfSight && 
+               isAimed;
+    }
 
-            // 플레이어를 향해 회전
-            const targetRotation = Math.atan2(directionToPlayer.x, directionToPlayer.z);
-            this.mesh.rotation.y = this.smoothRotation(this.mesh.rotation.y, targetRotation, 0.1);
-        }
+    // 메인 업데이트 함수
+    update(playerPosition) {
+    if (!this.mesh || !this.isLoaded) return;
+
+    // AI 상태 업데이트
+    this.updateAIState(playerPosition);
 
-        // 전투 거리 조정
-        const combatMove = this.maintainCombatDistance(playerPosition);
-        if (combatMove.length() > 0) {
-            this.mesh.position.add(combatMove.multiplyScalar(this.moveSpeed));
+    // 장애물 감지 및 시야 체크
+    const obstacles = this.detectObstacles();
+    const currentTime = Date.now();
+    const hasLineOfSight = this.checkLineOfSight(playerPosition);
+    const distanceToPlayer = this.mesh.position.distanceTo(playerPosition);
+
+    // 경로 업데이트 주기 체크
+    if (currentTime - this.lastPathUpdateTime > this.pathUpdateInterval) {
+        if (!hasLineOfSight) {
+            this.alternativePath = this.findAlternativePath(playerPosition);
         }
+        this.lastPathUpdateTime = currentTime;
+    }
 
-        // 공격 처리
-        if (hasLineOfSight && distanceToPlayer <= ENEMY_CONFIG.ATTACK_RANGE && this.canShoot(playerPosition)) {
-            this.shoot(playerPosition);
+    // 장애물 회피 로직
+    if (obstacles.length > 0 && !this.pathfinding.isAvoidingObstacle) {
+        this.pathfinding.isAvoidingObstacle = true;
+        this.pathfinding.avoidanceDirection = this.calculateAvoidanceDirection(obstacles);
+        this.pathfinding.avoidanceTime = 0;
+    }
+
+    // 이동 로직 실행
+    if (this.pathfinding.isAvoidingObstacle) {
+        // 회피 동작
+        this.pathfinding.avoidanceTime += 16;
+        if (this.pathfinding.avoidanceTime >= this.pathfinding.maxAvoidanceTime) {
+            this.pathfinding.isAvoidingObstacle = false;
+        } else {
+            const avoidMove = this.pathfinding.avoidanceDirection.multiplyScalar(this.moveSpeed);
+            this.mesh.position.add(avoidMove);
         }
+    } else if (!hasLineOfSight) {
+        // 시야가 없을 때의 이동
+        if (this.alternativePath) {
+            const pathDirection = new THREE.Vector3()
+                .subVectors(this.alternativePath, this.mesh.position)
+                .normalize();
+            this.mesh.position.add(pathDirection.multiplyScalar(this.moveSpeed));
 
-        // 총알 업데이트
-        this.updateBullets();
+            const targetRotation = Math.atan2(pathDirection.x, pathDirection.z);
+            this.mesh.rotation.y = this.smoothRotation(this.mesh.rotation.y, targetRotation, 0.1);
+        }
+    } else {
+        // 시야가 있을 때의 이동
+        this.alternativePath = null;
 
-        // 탱크 기울기 조정
-        this.adjustTankTilt();
-    }
+        // AI 상태에 따른 이동
+        switch (this.aiState.mode) {
+            case 'pursue':
+                if (distanceToPlayer > ENEMY_CONFIG.ATTACK_RANGE * 0.7) {
+                    const moveDirection = new THREE.Vector3()
+                        .subVectors(playerPosition, this.mesh.position)
+                        .normalize();
+                    this.mesh.position.add(moveDirection.multiplyScalar(this.moveSpeed));
+                }
+                break;
 
-    shoot(playerPosition) {
-        const currentTime = Date.now();
-        const attackInterval = this.type === 'tank' ? 
-            ENEMY_CONFIG.ATTACK_INTERVAL : 
-            ENEMY_CONFIG.ATTACK_INTERVAL * 1.5;
+            case 'flank':
+                const flankPosition = this.calculateFlankPosition(playerPosition);
+                this.findPathToTarget(flankPosition);
+                this.moveAlongPath();
+                break;
 
-        if (currentTime - this.lastAttackTime < attackInterval) return;
+            case 'retreat':
+                if (distanceToPlayer < ENEMY_CONFIG.ATTACK_RANGE * 0.3) {
+                    const retreatDirection = new THREE.Vector3()
+                        .subVectors(this.mesh.position, playerPosition)
+                        .normalize();
+                    this.mesh.position.add(retreatDirection.multiplyScalar(this.moveSpeed));
+                }
+                break;
+        }
 
-        // 플레이어와의 방향 차이 계산
+        // 플레이어 방향으로 회전
         const directionToPlayer = new THREE.Vector3()
             .subVectors(playerPosition, this.mesh.position)
             .normalize();
-        const forwardDirection = new THREE.Vector3(0, 0, 1)
-            .applyQuaternion(this.mesh.quaternion)
-            .normalize();
+        const targetRotation = Math.atan2(directionToPlayer.x, directionToPlayer.z);
+        this.mesh.rotation.y = this.smoothRotation(this.mesh.rotation.y, targetRotation, 0.1);
+    }
 
-        const dotProduct = forwardDirection.dot(directionToPlayer);
-        const angleToPlayer = Math.acos(dotProduct);
+    // 전투 거리 조정
+    const combatMove = this.maintainCombatDistance(playerPosition);
+    if (combatMove.length() > 0) {
+        this.mesh.position.add(combatMove.multiplyScalar(this.moveSpeed));
+    }
 
-        // 일정 각도 이하일 경우에만 공격
-        const attackAngleThreshold = Math.PI / 8;
-        if (angleToPlayer > attackAngleThreshold) return;
+    // 공격 처리
+    if (hasLineOfSight && distanceToPlayer <= ENEMY_CONFIG.ATTACK_RANGE && this.canShoot(playerPosition)) {
+        this.shoot(playerPosition);
+    }
 
-        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);
+    // 총알 업데이트
+    this.updateBullets();
 
-        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.scene.add(bullet);
-        this.bullets.push(bullet);
-        this.lastAttackTime = currentTime;
+    // 탱크 기울기 조정
+    this.adjustTankTilt();
+}
 
-        // 발사음 효과
-        const enemyFireSound = new Audio('sounds/mbtfire5.ogg');
-        enemyFireSound.volume = 0.3;
-        enemyFireSound.play();
-    }
+checkLineOfSight(targetPosition) {
+    if (!this.mesh) return false;
 
-    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);
+    const startPos = this.mesh.position.clone();
+    startPos.y += 2; // 포탑 높이
+    const direction = new THREE.Vector3()
+        .subVectors(targetPosition, startPos)
+        .normalize();
+    const distance = startPos.distanceTo(targetPosition);
 
-        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);
-
-        flashGroup.position.copy(muzzlePosition);
-        flashGroup.quaternion.copy(meshWorldQuaternion);
+    const raycaster = new THREE.Raycaster(startPos, direction, 0, distance);
+    const intersects = raycaster.intersectObjects(window.gameInstance.obstacles, true);
 
-        this.scene.add(flashGroup);
+    return intersects.length === 0;
+}
 
-        setTimeout(() => {
-            this.scene.remove(flashGroup);
-        }, 500);
+findAlternativePath(playerPosition) {
+    const currentPos = this.mesh.position.clone();
+    const directionToPlayer = new THREE.Vector3()
+        .subVectors(playerPosition, currentPos)
+        .normalize();
+
+    // 좌우 90도 방향 계산
+    const leftDirection = new THREE.Vector3()
+        .copy(directionToPlayer)
+        .applyAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI / 2);
+    const rightDirection = new THREE.Vector3()
+        .copy(directionToPlayer)
+        .applyAxisAngle(new THREE.Vector3(0, 1, 0), -Math.PI / 2);
+
+    // 좌우 30미터 지점 확인
+    const checkDistance = 30;
+    const leftPoint = currentPos.clone().add(leftDirection.multiplyScalar(checkDistance));
+    const rightPoint = currentPos.clone().add(rightDirection.multiplyScalar(checkDistance));
+
+    // 각 방향의 장애물 체크
+    const leftClear = this.checkPathClear(currentPos, leftPoint);
+    const rightClear = this.checkPathClear(currentPos, rightPoint);
+
+    if (leftClear && rightClear) {
+        // 둘 다 가능하면 랜덤 선택
+        return Math.random() < 0.5 ? leftPoint : rightPoint;
+    } else if (leftClear) {
+        return leftPoint;
+    } else if (rightClear) {
+        return rightPoint;
     }
+
+    return null;
+}
+
+checkPathClear(start, end) {
+    const direction = new THREE.Vector3().subVectors(end, start).normalize();
+    const distance = start.distanceTo(end);
+    const raycaster = new THREE.Raycaster(start, direction, 0, distance);
+    const intersects = raycaster.intersectObjects(window.gameInstance.obstacles, true);
+    return intersects.length === 0;
 }
-// 부가 기능 메서드들
+
+  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;
+        startPos.y += 2; // 포탑 높이
         const direction = new THREE.Vector3()
             .subVectors(playerPosition, startPos)
             .normalize();
@@ -850,37 +932,178 @@ class Enemy {
         const raycaster = new THREE.Raycaster(startPos, direction, 0, distance);
         const intersects = raycaster.intersectObjects(window.gameInstance.obstacles, true);
 
+        // 장애물과의 충돌이 있는지 확인
         return intersects.length === 0;
     }
+    // 대체 경로 찾기 메서드
+    findAlternativePath(playerPosition) {
+        const currentPos = this.mesh.position.clone();
+        const directionToPlayer = new THREE.Vector3()
+            .subVectors(playerPosition, currentPos)
+            .normalize();
 
-    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);
-            }
+        // 좌우 90도 방향 계산
+        const leftDirection = new THREE.Vector3()
+            .copy(directionToPlayer)
+            .applyAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI / 2);
+        const rightDirection = new THREE.Vector3()
+            .copy(directionToPlayer)
+            .applyAxisAngle(new THREE.Vector3(0, 1, 0), -Math.PI / 2);
+
+        // 좌우 30미터 지점 확인
+        const checkDistance = 30;
+        const leftPoint = currentPos.clone().add(leftDirection.multiplyScalar(checkDistance));
+        const rightPoint = currentPos.clone().add(rightDirection.multiplyScalar(checkDistance));
+
+        // 각 방향의 장애물 체크
+        const leftClear = this.checkPathClear(currentPos, leftPoint);
+        const rightClear = this.checkPathClear(currentPos, rightPoint);
+
+        if (leftClear && rightClear) {
+            // 둘 다 가능하면 랜덤 선택
+            return Math.random() < 0.5 ? leftPoint : rightPoint;
+        } else if (leftClear) {
+            return leftPoint;
+        } else if (rightClear) {
+            return rightPoint;
         }
 
-        return moveDirection;
+        return null;
+    }
+    // 경로 유효성 확인
+    checkPathClear(start, end) {
+        const direction = new THREE.Vector3().subVectors(end, start).normalize();
+        const distance = start.distanceTo(end);
+        const raycaster = new THREE.Raycaster(start, direction, 0, distance);
+        const intersects = raycaster.intersectObjects(window.gameInstance.obstacles, true);
+        return intersects.length === 0;
     }
 
+    // 부드러운 회전 처리
     smoothRotation(current, target, factor) {
         let delta = target - current;
+        
+        // 각도 차이를 -PI에서 PI 사이로 정규화
         while (delta > Math.PI) delta -= Math.PI * 2;
         while (delta < -Math.PI) delta += Math.PI * 2;
+        
         return current + delta * factor;
     }
 
+
+    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;
+            }
+        }
+        // 상태 변경 쿨다운을 2초로 설정
+        const stateChangeCooldown = 2000;
+
+        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;
+        }
+    }
+
+    findPathToTarget(targetPosition) {
+        const currentTime = Date.now();
+        if (currentTime - this.pathfinding.lastPathUpdate < this.pathfinding.pathUpdateInterval) {
+            return;
+        }
+
+        this.pathfinding.currentPath = this.generatePathPoints(this.mesh.position.clone(), targetPosition);
+        this.pathfinding.lastPathUpdate = currentTime;
+    }
+
+    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);
+
+        for (let i = 0; i <= steps; i++) {
+            const point = start.clone().add(direction.multiplyScalar(i * 10));
+            points.push(point);
+        }
+
+        return points;
+    }
+
+    moveAlongPath() {
+        if (this.pathfinding.currentPath.length === 0) 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);
+
+        if (this.mesh.position.distanceTo(targetPoint) < 2) {
+            this.pathfinding.currentPath.shift();
+        }
+    }
+
+    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
+        );
+    }
+
+    calculateRetreatPosition(playerPosition) {
+        const direction = new THREE.Vector3()
+            .subVectors(this.mesh.position, playerPosition)
+            .normalize();
+        return this.mesh.position.clone().add(direction.multiplyScalar(50));
+    }
+
+    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);
+    }
+
     updateBullets() {
         for (let i = this.bullets.length - 1; i >= 0; i--) {
             const bullet = this.bullets[i];
@@ -905,6 +1128,145 @@ class Enemy {
         }
     }
 
+    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);
+
+        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);
+        }
+
+        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);
+
+        flashGroup.position.copy(muzzlePosition);
+        flashGroup.quaternion.copy(meshWorldQuaternion);
+
+        this.scene.add(flashGroup);
+
+        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;
+
+    // 플레이어와의 방향 차이 계산
+    const directionToPlayer = new THREE.Vector3()
+        .subVectors(playerPosition, this.mesh.position)
+        .normalize();
+    const forwardDirection = new THREE.Vector3(0, 0, 1)
+        .applyQuaternion(this.mesh.quaternion)
+        .normalize();
+
+    const dotProduct = forwardDirection.dot(directionToPlayer);
+    const angleToPlayer = Math.acos(dotProduct);
+
+    // 일정 각도 이하일 경우에만 공격
+    const attackAngleThreshold = Math.PI / 8; // 약 22.5도
+    if (angleToPlayer > attackAngleThreshold) return;
+
+    this.createMuzzleFlash();
+
+    const enemyFireSound = new Audio('sounds/mbtfire5.ogg');
+    enemyFireSound.volume = 0.3;
+    enemyFireSound.play();
+
+    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 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;
+}
+
+    takeDamage(damage) {
+        this.health -= damage;
+        return this.health <= 0;
+    }
+
+    destroy() {
+        if (this.mesh) {
+            this.scene.remove(this.mesh);
+            this.bullets.forEach(bullet => this.scene.remove(bullet));
+            this.bullets = [];
+            this.isLoaded = false;
+        }
+    }
+}
 
 // Particle 클래스
 class Particle {