Update game.js

game.js

@@ -731,7 +731,7 @@ class Enemy {
     }
 
     // 메인 업데이트 함수
-    update(playerPosition) {
+   update(playerPosition) {
     if (!this.mesh || !this.isLoaded) return;
 
     // AI 상태 업데이트
@@ -743,24 +743,8 @@ class Enemy {
     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 (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;
@@ -769,15 +753,35 @@ class Enemy {
             this.mesh.position.add(avoidMove);
         }
     } else if (!hasLineOfSight) {
-        // 시야가 없을 때의 이동
+        // 시야가 없을 때의 이동 로직 추가
+        if (!this.alternativePath || this.mesh.position.distanceTo(this.alternativePath) < 2) {
+            this.alternativePath = this.findAlternativePath(playerPosition);
+        }
+        
         if (this.alternativePath) {
             const pathDirection = new THREE.Vector3()
                 .subVectors(this.alternativePath, this.mesh.position)
                 .normalize();
-            this.mesh.position.add(pathDirection.multiplyScalar(this.moveSpeed));
+            
+            // 이동 전 장애물 체크
+            const nextPosition = this.mesh.position.clone()
+                .add(pathDirection.multiplyScalar(this.moveSpeed));
+            
+            if (!this.checkCollisionAtPosition(nextPosition)) {
+                this.mesh.position.copy(nextPosition);
+            } else {
+                // 장애물이 있을 경우 새로운 경로 탐색
+                this.alternativePath = null;
+                this.lastAvoidanceDirection = null;
+            }
 
+            // 이동 방향으로 부드럽게 회전
             const targetRotation = Math.atan2(pathDirection.x, pathDirection.z);
-            this.mesh.rotation.y = this.smoothRotation(this.mesh.rotation.y, targetRotation, 0.1);
+            this.mesh.rotation.y = this.smoothRotation(
+                this.mesh.rotation.y, 
+                targetRotation, 
+                0.1
+            );
         }
     } else {
         // 시야가 있을 때의 이동
@@ -817,8 +821,7 @@ class Enemy {
         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));
@@ -836,6 +839,7 @@ class Enemy {
     this.adjustTankTilt();
 }
 
+// 시야 확인 메서드
 checkLineOfSight(targetPosition) {
     if (!this.mesh) return false;
 
@@ -852,12 +856,43 @@ checkLineOfSight(targetPosition) {
     return intersects.length === 0;
 }
 
+// 장애물 충돌 체크
+checkCollisionAtPosition(position) {
+    const testBox = new THREE.Box3();
+    const tankSize = new THREE.Vector3(3, 3, 3); // 탱크 크기에 맞게 조정
+    
+    testBox.setFromCenterAndSize(
+        position,
+        tankSize
+    );
+
+    return window.gameInstance.obstacles.some(obstacle => {
+        if (obstacle.userData.isCollidable) {
+            const obstacleBox = new THREE.Box3().setFromObject(obstacle);
+            return testBox.intersectsBox(obstacleBox);
+        }
+        return false;
+    });
+}
+
+// 대체 경로 찾기
 findAlternativePath(playerPosition) {
     const currentPos = this.mesh.position.clone();
     const directionToPlayer = new THREE.Vector3()
         .subVectors(playerPosition, currentPos)
         .normalize();
 
+    // 이전에 선택한 우회 방향이 있다면 그 방향을 유지
+    if (this.lastAvoidanceDirection) {
+        const checkPoint = currentPos.clone().add(
+            this.lastAvoidanceDirection.multiplyScalar(30)
+        );
+        
+        if (this.checkPathClear(currentPos, checkPoint)) {
+            return checkPoint;
+        }
+    }
+
     // 좌우 90도 방향 계산
     const leftDirection = new THREE.Vector3()
         .copy(directionToPlayer)
@@ -866,7 +901,7 @@ findAlternativePath(playerPosition) {
         .copy(directionToPlayer)
         .applyAxisAngle(new THREE.Vector3(0, 1, 0), -Math.PI / 2);
 
-    // 좌우 30미터 지점 확인
+    // 체크 거리를 30미터로 설정
     const checkDistance = 30;
     const leftPoint = currentPos.clone().add(leftDirection.multiplyScalar(checkDistance));
     const rightPoint = currentPos.clone().add(rightDirection.multiplyScalar(checkDistance));
@@ -875,18 +910,36 @@ findAlternativePath(playerPosition) {
     const leftClear = this.checkPathClear(currentPos, leftPoint);
     const rightClear = this.checkPathClear(currentPos, rightPoint);
 
+    // 새로운 방향 결정 로직
+    let targetPoint = null;
     if (leftClear && rightClear) {
-        // 둘 다 가능하면 랜덤 선택
-        return Math.random() < 0.5 ? leftPoint : rightPoint;
+        // 플레이어와의 각도를 고려하여 더 효율적인 방향 선택
+        const leftAngle = Math.abs(this.calculateAngleToPlayer(leftPoint, playerPosition));
+        const rightAngle = Math.abs(this.calculateAngleToPlayer(rightPoint, playerPosition));
+        
+        if (leftAngle < rightAngle) {
+            targetPoint = leftPoint;
+            this.lastAvoidanceDirection = leftDirection;
+        } else {
+            targetPoint = rightPoint;
+            this.lastAvoidanceDirection = rightDirection;
+        }
     } else if (leftClear) {
-        return leftPoint;
+        targetPoint = leftPoint;
+        this.lastAvoidanceDirection = leftDirection;
     } else if (rightClear) {
-        return rightPoint;
+        targetPoint = rightPoint;
+        this.lastAvoidanceDirection = rightDirection;
+    } else {
+        // 양쪽 다 막혀있을 경우 후진
+        const backDirection = directionToPlayer.multiplyScalar(-1);
+        targetPoint = currentPos.clone().add(backDirection.multiplyScalar(checkDistance));
+        this.lastAvoidanceDirection = backDirection;
     }
 
-    return null;
+    return targetPoint;
 }
-
+  // 경로 유효성 확인
 checkPathClear(start, end) {
     const direction = new THREE.Vector3().subVectors(end, start).normalize();
     const distance = start.distanceTo(end);
@@ -895,214 +948,54 @@ checkPathClear(start, end) {
     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; // 포탑 높이
-        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);
-
-        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
-        );
-    }
+// 플레이어와의 각도 계산
+calculateAngleToPlayer(position, playerPosition) {
+    const dirToPlayer = new THREE.Vector3()
+        .subVectors(playerPosition, position)
+        .normalize();
+    const forward = new THREE.Vector3(0, 0, 1);
+    return Math.atan2(dirToPlayer.x, dirToPlayer.z);
+}
 
-    calculateRetreatPosition(playerPosition) {
-        const direction = new THREE.Vector3()
-            .subVectors(this.mesh.position, playerPosition)
-            .normalize();
-        return this.mesh.position.clone().add(direction.multiplyScalar(50));
-    }
+// 부드러운 회전 처리
+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;
+}
 
-    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);
-    }
+// 탱크 기울기 조정
+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--) {