Update game.js

game.js

@@ -737,6 +737,13 @@ class EnemyFighter {
         this.targetPosition = null;
         this.playerFighter = null;
         
+        // 회피 시스템
+        this.temporaryEvadeMode = false;
+        this.evadeTimer = 0;
+        
+        // 충돌 예측
+        this.predictedPosition = new THREE.Vector3();
+        
         // 전투 시스템
         this.bullets = [];
         this.burstCounter = 0; // 현재 연발 카운터
@@ -804,18 +811,31 @@ class EnemyFighter {
     update(playerPosition, deltaTime) {
         if (!this.mesh || !this.isLoaded) return;
         
+        // 회피 타이머 업데이트
+        if (this.temporaryEvadeMode && this.evadeTimer > 0) {
+            this.evadeTimer -= deltaTime;
+            if (this.evadeTimer <= 0) {
+                this.temporaryEvadeMode = false;
+            }
+        }
+        
         const distanceToPlayer = this.position.distanceTo(playerPosition);
         
-        // 상태 결정 - 단순화
-        if (distanceToPlayer <= 3000) {
+        // 상태 결정 - 일시적 회피 모드가 우선
+        if (this.temporaryEvadeMode) {
+            this.aiState = 'evade';
+        } else if (distanceToPlayer <= 3000) {
             this.aiState = 'combat';
         } else {
             this.aiState = 'patrol';
         }
         
-        // 충돌 회피 계산
+        // 충돌 회피 계산 (항상 실행)
         this.calculateAvoidance();
         
+        // 충돌 예측 검사
+        this.checkCollisionPrediction(deltaTime);
+        
         // AI 행동 실행
         switch (this.aiState) {
             case 'patrol':
@@ -824,6 +844,9 @@ class EnemyFighter {
             case 'combat':
                 this.executeCombat(playerPosition, deltaTime);
                 break;
+            case 'evade':
+                this.executeEmergencyEvade(deltaTime);
+                break;
         }
         
         // 물리 업데이트
@@ -883,7 +906,82 @@ class EnemyFighter {
         }
     }
     
-    // AI 상태 (회피 관련 로직 제거, patrol과 combat만 유지)
+    // 새로운 메서드: 충돌 예측
+    checkCollisionPrediction(deltaTime) {
+        if (!this.nearbyEnemies) return;
+        
+        // 2초 후 예상 위치 계산
+        const predictTime = 2.0;
+        const forward = new THREE.Vector3(0, 0, 1).applyEuler(this.rotation);
+        this.predictedPosition.copy(this.position).add(forward.multiplyScalar(this.speed * predictTime));
+        
+        this.nearbyEnemies.forEach(enemy => {
+            if (enemy === this || !enemy.position) return;
+            
+            // 다른 적기의 예상 위치
+            const enemyForward = new THREE.Vector3(0, 0, 1).applyEuler(enemy.rotation);
+            const enemyPredicted = enemy.position.clone().add(enemyForward.multiplyScalar(enemy.speed * predictTime));
+            
+            // 예상 거리
+            const predictedDistance = this.predictedPosition.distanceTo(enemyPredicted);
+            
+            // 150m 이내로 접근 예상 시 사전 회피
+            if (predictedDistance < 150) {
+                // 예방적 회피 방향 설정
+                const avoidDir = this.predictedPosition.clone().sub(enemyPredicted).normalize();
+                
+                // 수직 분리 추가
+                if (this.position.y > enemy.position.y) {
+                    avoidDir.y += 0.3;
+                } else {
+                    avoidDir.y -= 0.3;
+                }
+                
+                this.avoidanceVector.add(avoidDir.multiplyScalar(1.5));
+            }
+        });
+    }
+    
+    // 새로운 메서드: 긴급 회피 실행
+    executeEmergencyEvade(deltaTime) {
+        // 회피 벡터가 있으면 그 방향으로, 없으면 급상승
+        if (this.avoidanceVector.length() > 0) {
+            const evadeDirection = this.avoidanceVector.clone().normalize();
+            
+            // 급선회
+            const targetYaw = Math.atan2(evadeDirection.x, evadeDirection.z);
+            const targetPitch = Math.asin(-evadeDirection.y) * 0.5; // 피치는 절반만
+            
+            // 빠른 회전 속도
+            const emergencyTurnSpeed = this.turnSpeed * 2.0;
+            const maxTurnRate = emergencyTurnSpeed * deltaTime;
+            
+            // Yaw 회전
+            const yawDiff = this.normalizeAngle(targetYaw - this.rotation.y);
+            if (Math.abs(yawDiff) > maxTurnRate) {
+                this.rotation.y += Math.sign(yawDiff) * maxTurnRate;
+            } else {
+                this.rotation.y = targetYaw;
+            }
+            
+            // Pitch 회전
+            const pitchDiff = targetPitch - this.rotation.x;
+            if (Math.abs(pitchDiff) > maxTurnRate * 0.7) {
+                this.rotation.x += Math.sign(pitchDiff) * maxTurnRate * 0.7;
+            } else {
+                this.rotation.x = targetPitch;
+            }
+            
+            // 급선회 시 약간의 롤 추가
+            this.rotation.z = Math.sign(yawDiff) * Math.min(Math.abs(yawDiff), Math.PI / 6);
+        } else {
+            // 기본 회피: 급상승
+            this.rotation.x = -Math.PI / 6; // 30도 상승
+        }
+        
+        // 회피 중에는 최대 속도
+        this.speed = this.maxSpeed;
+    }
     
     smoothTurnToTarget(targetPos, deltaTime) {
         // 타겟 방향 계산
@@ -891,9 +989,11 @@ class EnemyFighter {
         direction.y *= 0.5; // 수직 이동을 덜 제한적으로
         direction.normalize();
         
-        // 충돌 회피 벡터 적용
+        // 충돌 회피 벡터 적용 (회피가 우선)
         if (this.avoidanceVector.length() > 0) {
-            direction.add(this.avoidanceVector.multiplyScalar(0.5));
+            // 회피 모드에서는 회피 벡터의 영향을 크게
+            const avoidanceStrength = this.temporaryEvadeMode ? 1.0 : 0.5;
+            direction.add(this.avoidanceVector.multiplyScalar(avoidanceStrength));
             direction.normalize();
         }
         
@@ -902,12 +1002,11 @@ class EnemyFighter {
         const targetPitch = Math.asin(-direction.y);
         
         // 부드러운 회전 (최대 회전 속도 제한)
-        const yawDiff = this.normalizeAngle(targetYaw - this.rotation.y);
-        const pitchDiff = targetPitch - this.rotation.x;
-        
-        const maxTurnRate = this.turnSpeed * deltaTime;
+        const turnSpeed = this.temporaryEvadeMode ? this.turnSpeed * 1.5 : this.turnSpeed;
+        const maxTurnRate = turnSpeed * deltaTime;
         
         // Yaw 회전
+        const yawDiff = this.normalizeAngle(targetYaw - this.rotation.y);
         if (Math.abs(yawDiff) > maxTurnRate) {
             this.rotation.y += Math.sign(yawDiff) * maxTurnRate;
         } else {
@@ -916,8 +1015,8 @@ class EnemyFighter {
         
         // Pitch 회전 (제한적)
         const maxPitchRate = maxTurnRate * 0.7; // 피치는 조금 더 빠르게
-        if (Math.abs(pitchDiff) > maxPitchRate) {
-            this.rotation.x += Math.sign(pitchDiff) * maxPitchRate;
+        if (Math.abs(targetPitch - this.rotation.x) > maxPitchRate) {
+            this.rotation.x += Math.sign(targetPitch - this.rotation.x) * maxPitchRate;
         } else {
             this.rotation.x = targetPitch;
         }
@@ -925,6 +1024,12 @@ class EnemyFighter {
         // Pitch 제한 (±40도)
         const maxPitchAngle = Math.PI * 40 / 180; // 40도를 라디안으로
         this.rotation.x = THREE.MathUtils.clamp(this.rotation.x, -maxPitchAngle, maxPitchAngle);
+        
+        // 롤 자동 계산 (선회 시)
+        if (!this.temporaryEvadeMode) {
+            this.rotation.z = -yawDiff * 0.5; // 선회 방향으로 기울기
+            this.rotation.z = THREE.MathUtils.clamp(this.rotation.z, -Math.PI / 4, Math.PI / 4);
+        }
     }
     
     calculateAvoidance() {
@@ -933,15 +1038,36 @@ class EnemyFighter {
         if (!this.nearbyEnemies) return;
         
         let avoidCount = 0;
+        let criticalAvoidance = false;
         
         this.nearbyEnemies.forEach(enemy => {
             if (enemy === this || !enemy.position) return;
             
             const distance = this.position.distanceTo(enemy.position);
-            if (distance < 300 && distance > 0) {
+            
+            // 100m 미만: 긴급 회피
+            if (distance < 100 && distance > 0) {
+                criticalAvoidance = true;
+                
+                // 강한 반발력
+                const avoidDir = this.position.clone().sub(enemy.position).normalize();
+                const strength = 2.0; // 매우 강한 회피
+                this.avoidanceVector.add(avoidDir.multiplyScalar(strength));
+                
+                // 고도 차이 추가 (위/아래로 분산)
+                if (this.position.y > enemy.position.y) {
+                    this.avoidanceVector.y += 0.5; // 위로
+                } else {
+                    this.avoidanceVector.y -= 0.5; // 아래로
+                }
+                
+                avoidCount++;
+            }
+            // 100-300m: 예방적 회피
+            else if (distance < 300) {
                 // 반대 방향으로 회피
                 const avoidDir = this.position.clone().sub(enemy.position).normalize();
-                const strength = (300 - distance) / 300;
+                const strength = (300 - distance) / 200; // 100-300m 범위에서 강도 계산
                 this.avoidanceVector.add(avoidDir.multiplyScalar(strength));
                 avoidCount++;
             }
@@ -950,6 +1076,14 @@ class EnemyFighter {
         if (avoidCount > 0) {
             this.avoidanceVector.divideScalar(avoidCount);
             this.avoidanceVector.normalize();
+            
+            // 긴급 회피 시 더 강한 회피력 적용
+            if (criticalAvoidance) {
+                this.avoidanceVector.multiplyScalar(2.0);
+                // 일시적으로 전투 상태 해제
+                this.temporaryEvadeMode = true;
+                this.evadeTimer = 2.0; // 2초 동��� 회피 우선
+            }
         }
     }