Update game.js

game.js

@@ -582,9 +582,17 @@ class Enemy {
         this.alternativePath = null;
         this.pathFindingTimeout = 0;
         this.lastPathUpdateTime = 0;
-        this.pathUpdateInterval = 1000; // 1초마다 경로 업데이트
+        this.pathUpdateInterval = 1000;
         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',
@@ -599,7 +607,7 @@ class Enemy {
             currentRotation: 0,
             isAiming: false,
             aimingTime: 0,
-            requiredAimTime: 1000 // 조준에 필요한 시간
+            requiredAimTime: 1000
         };
 
         // 경로 탐색 및 회피 시스템
@@ -611,9 +619,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
         };
 
         // 전투 시스템
@@ -621,18 +629,40 @@ 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)
@@ -653,277 +683,165 @@ 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;
 
-    // 전투 거리 관리
-    maintainCombatDistance(playerPosition) {
+        const currentTime = Date.now();
         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);
-            }
-        }
-
-        return moveDirection;
-    }
-
-    // 발사 조건 확인
-    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;
-    }
+        // 방향 결정 로직
+        if (!this.movement.direction || 
+            currentTime - this.movement.lastDirectionChange > this.movement.directionDuration) {
+            this.movement.direction = Math.random() < 0.5 ? 'left' : 'right';
+            this.movement.lastDirectionChange = currentTime;
+        }
 
-    // 메인 업데이트 함수
-    update(playerPosition) {
-    if (!this.mesh || !this.isLoaded) return;
+        if (hasLineOfSight && distanceToPlayer < ENEMY_CONFIG.ATTACK_RANGE) {
+            // 플레이어를 향한 방향 벡터
+            const directionToPlayer = new THREE.Vector3()
+                .subVectors(playerPosition, this.mesh.position)
+                .normalize();
 
-    // AI 상태 업데이트
-    this.updateAIState(playerPosition);
+            // 좌우 이동을 위한 수직 벡터 계산
+            const sideVector = new THREE.Vector3()
+                .crossVectors(directionToPlayer, new THREE.Vector3(0, 1, 0))
+                .normalize();
 
-    // 장애물 감지 및 시야 체크
-    const obstacles = this.detectObstacles();
-    const currentTime = Date.now();
-    const hasLineOfSight = this.checkLineOfSight(playerPosition);
-    const distanceToPlayer = this.mesh.position.distanceTo(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));
+            }
 
-    // 경로 업데이트 주기 체크
-    if (currentTime - this.lastPathUpdateTime > this.pathUpdateInterval) {
-        if (!hasLineOfSight) {
-            this.alternativePath = this.findAlternativePath(playerPosition);
+            // 플레이어를 향해 회전
+            const targetRotation = Math.atan2(directionToPlayer.x, directionToPlayer.z);
+            this.mesh.rotation.y = this.smoothRotation(this.mesh.rotation.y, targetRotation, 0.1);
         }
-        this.lastPathUpdateTime = currentTime;
-    }
 
-    // 장애물 회피 로직
-    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);
+        // 전투 거리 조정
+        const combatMove = this.maintainCombatDistance(playerPosition);
+        if (combatMove.length() > 0) {
+            this.mesh.position.add(combatMove.multiplyScalar(this.moveSpeed));
         }
-    } 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));
 
-            const targetRotation = Math.atan2(pathDirection.x, pathDirection.z);
-            this.mesh.rotation.y = this.smoothRotation(this.mesh.rotation.y, targetRotation, 0.1);
+        // 공격 처리
+        if (hasLineOfSight && distanceToPlayer <= ENEMY_CONFIG.ATTACK_RANGE && this.canShoot(playerPosition)) {
+            this.shoot(playerPosition);
         }
-    } else {
-        // 시야가 있을 때의 이동
-        this.alternativePath = null;
 
-        // 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;
+        // 총알 업데이트
+        this.updateBullets();
 
-            case 'flank':
-                const flankPosition = this.calculateFlankPosition(playerPosition);
-                this.findPathToTarget(flankPosition);
-                this.moveAlongPath();
-                break;
+        // 탱크 기울기 조정
+        this.adjustTankTilt();
+    }
 
-            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;
-        }
+    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 targetRotation = Math.atan2(directionToPlayer.x, directionToPlayer.z);
-        this.mesh.rotation.y = this.smoothRotation(this.mesh.rotation.y, targetRotation, 0.1);
-    }
-
-    // 전투 거리 조정
-    const combatMove = this.maintainCombatDistance(playerPosition);
-    if (combatMove.length() > 0) {
-        this.mesh.position.add(combatMove.multiplyScalar(this.moveSpeed));
-    }
+        const forwardDirection = new THREE.Vector3(0, 0, 1)
+            .applyQuaternion(this.mesh.quaternion)
+            .normalize();
 
-    // 공격 처리
-    if (hasLineOfSight && distanceToPlayer <= ENEMY_CONFIG.ATTACK_RANGE && this.canShoot(playerPosition)) {
-        this.shoot(playerPosition);
-    }
+        const dotProduct = forwardDirection.dot(directionToPlayer);
+        const angleToPlayer = Math.acos(dotProduct);
 
-    // 총알 업데이트
-    this.updateBullets();
+        // 일정 각도 이하일 경우에만 공격
+        const attackAngleThreshold = Math.PI / 8;
+        if (angleToPlayer > attackAngleThreshold) return;
 
-    // 탱크 기울기 조정
-    this.adjustTankTilt();
-}
-
-checkLineOfSight(targetPosition) {
-    if (!this.mesh) return false;
+        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 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();
+        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;
 
-    const raycaster = new THREE.Raycaster(startPos, direction, 0, distance);
-    const intersects = raycaster.intersectObjects(window.gameInstance.obstacles, true);
+        // 발사음 효과
+        const enemyFireSound = new Audio('sounds/mbtfire5.ogg');
+        enemyFireSound.volume = 0.3;
+        enemyFireSound.play();
+    }
 
-    return intersects.length === 0;
-}
+    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);
 
-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;
-    }
+        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 null;
-}
+        flashGroup.position.copy(muzzlePosition);
+        flashGroup.quaternion.copy(meshWorldQuaternion);
 
-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;
-}
+        this.scene.add(flashGroup);
 
-  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;
-        }
+        setTimeout(() => {
+            this.scene.remove(flashGroup);
+        }, 500);
     }
-
-   // 시야 확인 메서드 (기존 코드 수정)
+}
+// 부가 기능 메서드들
     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();
@@ -932,178 +850,37 @@ checkPathClear(start, end) {
         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();
 
-        // 좌우 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;
+    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);
+            }
         }
 
-        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;
+        return moveDirection;
     }
 
-    // 부드러운 회전 처리
     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];
@@ -1128,145 +905,6 @@ checkPathClear(start, end) {
         }
     }
 
-    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 {