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;
@@ -582,28 +583,213 @@ class Enemy {
         
         // AI 상태 관리
         this.aiState = {
-            mode: 'pursue', // 'pursue', 'flank', 'retreat'
+            mode: 'pursue',
             lastStateChange: 0,
             stateChangeCooldown: 3000,
             lastVisibilityCheck: 0,
             visibilityCheckInterval: 500,
             canSeePlayer: false,
             lastKnownPlayerPosition: null,
-            searchStartTime: null
+            searchStartTime: null,
+            targetRotation: 0,
+            currentRotation: 0,
+            isAiming: false,
+            aimingTime: 0,
+            requiredAimTime: 1000 // 조준에 필요한 시간
         };
 
-        // 경로 탐색 상태
+        // 경로 탐색 및 회피 시스템
         this.pathfinding = {
             currentPath: [],
             pathUpdateInterval: 1000,
             lastPathUpdate: 0,
             isAvoidingObstacle: false,
             avoidanceDirection: null,
-            obstacleCheckDistance: 10
+            obstacleCheckDistance: 10,
+            avoidanceTime: 0,
+            maxAvoidanceTime: 3000, // 최대 회피 시간
+            sensorAngles: [-45, 0, 45], // 전방 감지 각도
+            sensorDistance: 15 // 감지 거리
         };
+
+        // 전투 시스템
+        this.combat = {
+            minEngagementRange: 30,
+            maxEngagementRange: 150,
+            optimalRange: 80,
+            aimThreshold: 0.1, // 조준 정확도 임계값
+            lastShotAccuracy: 0,
+            consecutiveHits: 0,
+            maxConsecutiveHits: 3
+        };
+    }
+
+    // 장애물 감지 시스템
+    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)
+                .applyQuaternion(this.mesh.quaternion)
+                .applyAxisAngle(new THREE.Vector3(0, 1, 0), angle * Math.PI / 180);
+
+            const raycaster = new THREE.Raycaster(position, direction, 0, this.pathfinding.sensorDistance);
+            const intersects = raycaster.intersectObjects(window.gameInstance.obstacles, true);
+
+            if (intersects.length > 0) {
+                obstacles.push({
+                    angle: angle,
+                    distance: intersects[0].distance,
+                    point: intersects[0].point
+                });
+            }
+        });
+
+        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);
+        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);
+            }
+        }
+
+        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;
     }
 
-    async initialize(loader) {
+    // 메인 업데이트 함수
+    update(playerPosition) {
+        if (!this.mesh || !this.isLoaded) return;
+
+        // AI 상태 업데이트
+        this.updateAIState(playerPosition);
+
+        // 장애물 감지
+        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;
+        }
+
+        // 회피 동작 수행
+        if (this.pathfinding.isAvoidingObstacle) {
+            this.pathfinding.avoidanceTime += 16; // 약 16ms per frame
+            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 {
+            // 일반 이동 로직
+            switch (this.aiState.mode) {
+                case 'pursue':
+                    this.findPathToTarget(playerPosition);
+                    this.moveAlongPath();
+                    break;
+                case 'flank':
+                    const flankPosition = this.calculateFlankPosition(playerPosition);
+                    this.findPathToTarget(flankPosition);
+                    this.moveAlongPath();
+                    break;
+                case 'retreat':
+                    const retreatPosition = this.calculateRetreatPosition(playerPosition);
+                    this.findPathToTarget(retreatPosition);
+                    this.moveAlongPath();
+                    break;
+            }
+        }
+
+        // 전투 거리 조정
+        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);
@@ -630,7 +816,7 @@ class Enemy {
         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();
         const distance = startPos.distanceTo(playerPosition);
 
@@ -644,7 +830,6 @@ class Enemy {
         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;
@@ -655,7 +840,6 @@ class Enemy {
             }
         }
 
-        // AI 상태 업데이트
         if (currentTime - this.aiState.lastStateChange > this.aiState.stateChangeCooldown) {
             if (this.health < 30) {
                 this.aiState.mode = 'retreat';
@@ -674,12 +858,7 @@ class Enemy {
             return;
         }
 
-        // 간단한 A* 경로 찾기 구현
-        const start = this.mesh.position.clone();
-        const end = targetPosition.clone();
-        
-        // 장애물을 고려한 경로점 생성
-        this.pathfinding.currentPath = this.generatePathPoints(start, end);
+        this.pathfinding.currentPath = this.generatePathPoints(this.mesh.position.clone(), targetPosition);
         this.pathfinding.lastPathUpdate = currentTime;
     }
 
@@ -705,92 +884,14 @@ class Enemy {
             .subVectors(targetPoint, this.mesh.position)
             .normalize();
 
-        // 장애물 감지 및 회피
-        if (this.detectObstacle(direction)) {
-            if (!this.pathfinding.isAvoidingObstacle) {
-                this.pathfinding.isAvoidingObstacle = true;
-                this.pathfinding.avoidanceDirection = this.calculateAvoidanceDirection(direction);
-            }
-            direction.copy(this.pathfinding.avoidanceDirection);
-        } else {
-            this.pathfinding.isAvoidingObstacle = false;
-        }
-
-        // 이동 적용
         const moveVector = direction.multiplyScalar(this.moveSpeed);
         this.mesh.position.add(moveVector);
 
-        // 경로점에 도달했는지 확인
         if (this.mesh.position.distanceTo(targetPoint) < 2) {
             this.pathfinding.currentPath.shift();
         }
     }
 
-    detectObstacle(direction) {
-        const raycaster = new THREE.Raycaster(
-            this.mesh.position,
-            direction,
-            0,
-            this.pathfinding.obstacleCheckDistance
-        );
-        const intersects = raycaster.intersectObjects(window.gameInstance.obstacles, true);
-        return intersects.length > 0;
-    }
-
-    calculateAvoidanceDirection(currentDirection) {
-        const left = new THREE.Vector3(-currentDirection.z, 0, currentDirection.x);
-        const right = new THREE.Vector3(currentDirection.z, 0, -currentDirection.x);
-
-        // 왼쪽과 오른쪽 방향 중 장애물이 없는 방향 선택
-        if (!this.detectObstacle(left)) return left;
-        if (!this.detectObstacle(right)) return right;
-        
-        // 둘 다 막혀있으면 뒤로
-        return currentDirection.multiplyScalar(-1);
-    }
-
-    update(playerPosition) {
-        if (!this.mesh || !this.isLoaded) return;
-
-        this.updateAIState(playerPosition);
-        
-        let targetPosition = playerPosition;
-        if (!this.aiState.canSeePlayer && this.aiState.lastKnownPlayerPosition) {
-            targetPosition = this.aiState.lastKnownPlayerPosition;
-        }
-
-        // AI 모드에 따른 행동
-        switch (this.aiState.mode) {
-            case 'pursue':
-                this.findPathToTarget(targetPosition);
-                this.moveAlongPath();
-                break;
-
-            case 'flank':
-                const flankPosition = this.calculateFlankPosition(playerPosition);
-                this.findPathToTarget(flankPosition);
-                this.moveAlongPath();
-                break;
-
-            case 'retreat':
-                const retreatPosition = this.calculateRetreatPosition(playerPosition);
-                this.findPathToTarget(retreatPosition);
-                this.moveAlongPath();
-                break;
-        }
-
-        // 총알 업데이트
-        this.updateBullets();
-
-        // 플레이어가 시야에 있으면 발사
-        if (this.aiState.canSeePlayer) {
-            this.shoot(playerPosition);
-        }
-
-        // 지형에 따른 탱크 기울기 조정
-        this.adjustTankTilt();
-    }
-
     calculateFlankPosition(playerPosition) {
         const angle = Math.random() * Math.PI * 2;
         const radius = 40;