Update game.js

game.js

@@ -579,6 +579,10 @@ class Enemy {
         this.lastAttackTime = 0;
         this.bullets = [];
         this.isLoaded = false;
+        this.alternativePath = null;
+        this.pathFindingTimeout = 0;
+        this.lastPathUpdateTime = 0;
+        this.pathUpdateInterval = 1000; // 1초마다 경로 업데이트
         this.moveSpeed = type === 'tank' ? ENEMY_MOVE_SPEED : ENEMY_MOVE_SPEED * 0.7;
         
         // AI 상태 관리
@@ -735,6 +739,57 @@ class Enemy {
 
         // 장애물 감지
         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) {
+            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);
+            }
+        } else {
+            this.alternativePath = null;
+
+            // 거리에 따른 행동 결정
+            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));
+            } else 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));
+            }
+
+            // 플레이어 방향으로 회전
+            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);
+
+            // 공격 조건 확인
+            if (hasLineOfSight && distanceToPlayer <= ENEMY_CONFIG.ATTACK_RANGE) {
+                this.shoot(playerPosition);
+            }
+        }
+    }
+}
+
         
         // 이동 및 회피 로직
         if (obstacles.length > 0 && !this.pathfinding.isAvoidingObstacle) {
@@ -789,6 +844,65 @@ class Enemy {
         // 탱크 기울기 조정
         this.adjustTankTilt();
     }
+    checkLineOfSight(targetPosition) {
+    if (!this.mesh) return false;
+
+    const startPos = this.mesh.position.clone();
+    startPos.y += 2; // 포탑 높이
+    const direction = new THREE.Vector3()
+        .subVectors(targetPosition, startPos)
+        .normalize();
+    const distance = startPos.distanceTo(targetPosition);
+
+    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;
+    }
+
+    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';
@@ -812,20 +926,79 @@ class Enemy {
         }
     }
 
+   // 시야 확인 메서드 (기존 코드 수정)
     checkLineOfSight(playerPosition) {
         if (!this.mesh) return false;
 
         const startPos = this.mesh.position.clone();
-        startPos.y += 2;
-        const direction = new THREE.Vector3().subVectors(playerPosition, startPos).normalize();
+        startPos.y += 2; // 포탑 높이
+        const direction = new THREE.Vector3()
+            .subVectors(playerPosition, startPos)
+            .normalize();
         const distance = startPos.distanceTo(playerPosition);
 
         const raycaster = new THREE.Raycaster(startPos, direction, 0, distance);
         const intersects = raycaster.intersectObjects(window.gameInstance.obstacles, true);
 
+        // 장애물과의 충돌이 있는지 확인
+        return intersects.length === 0;
+    }
+    // 대체 경로 찾기 메서드
+    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;
     }
 
+    // 부드러운 회전 처리
+    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);