Update game.js

game.js

@@ -691,16 +691,37 @@ class EnemyFighter {
         this.velocity = new THREE.Vector3(0, 0, 120);
         this.rotation = new THREE.Euler(0, 0, 0);
         this.health = GAME_CONSTANTS.MAX_HEALTH; // 체력 1000
-        this.speed = 120;
+        this.speed = 386; // 750kt in m/s (750 * 0.514444)
         this.bullets = [];
         this.lastShootTime = 0;
         
+        // 개선된 AI 상태
         this.aiState = 'patrol';
         this.targetPosition = position.clone();
         this.patrolCenter = position.clone();
-        this.patrolRadius = 2000;
+        this.patrolRadius = 3000;
         this.lastStateChange = 0;
         this.playerFighter = null; // 플레이어 참조 저장용
+        
+        // 현실적인 비행 물리
+        this.targetRotation = new THREE.Euler(0, 0, 0);
+        this.currentRoll = 0;
+        this.currentPitch = 0;
+        this.currentYaw = 0;
+        this.throttle = 0.75; // 기본 스로틀 75%
+        
+        // 회피 기동
+        this.evasionTimer = 0;
+        this.evasionPattern = 0;
+        
+        // 다른 적기들과의 충돌 회피
+        this.nearbyEnemies = [];
+        this.separationRadius = 300; // 최소 거리 300m
+        
+        // 공격 패턴
+        this.attackAngle = 0;
+        this.attackDistance = 0;
+        this.lastAttackTime = 0;
     }
 
     async initialize(loader) {
@@ -757,52 +778,86 @@ class EnemyFighter {
         const currentTime = Date.now();
         const distanceToPlayer = this.position.distanceTo(playerPosition);
         
-        if (distanceToPlayer < 5000) {
-            const direction = new THREE.Vector3()
-                .subVectors(playerPosition, this.position)
-                .normalize();
-            
-            this.velocity = direction.multiplyScalar(this.speed);
-            this.rotation.y = Math.atan2(direction.x, direction.z);
-            
-            if (distanceToPlayer < 2000 && currentTime - this.lastShootTime > 1500) {
-                this.shoot();
+        // AI 상태 결정
+        if (distanceToPlayer < 3000) {
+            if (this.aiState !== 'combat') {
+                this.aiState = 'combat';
+                this.lastStateChange = currentTime;
+            }
+        } else if (distanceToPlayer < 6000) {
+            if (this.aiState !== 'approach') {
+                this.aiState = 'approach';
+                this.lastStateChange = currentTime;
             }
         } else {
-            if (this.position.distanceTo(this.targetPosition) < 300) {
-                const angle = Math.random() * Math.PI * 2;
-                this.targetPosition = this.patrolCenter.clone().add(
-                    new THREE.Vector3(
-                        Math.cos(angle) * this.patrolRadius,
-                        (Math.random() - 0.5) * 1000,
-                        Math.sin(angle) * this.patrolRadius
-                    )
-                );
+            if (this.aiState !== 'patrol') {
+                this.aiState = 'patrol';
+                this.lastStateChange = currentTime;
             }
-            
-            const direction = new THREE.Vector3()
-                .subVectors(this.targetPosition, this.position)
-                .normalize();
-            
-            this.velocity = direction.multiplyScalar(this.speed * 0.7);
-            this.rotation.y = Math.atan2(direction.x, direction.z);
         }
         
+        // 상태별 행동
+        switch(this.aiState) {
+            case 'combat':
+                this.updateCombatBehavior(playerPosition, deltaTime, currentTime);
+                break;
+            case 'approach':
+                this.updateApproachBehavior(playerPosition, deltaTime);
+                break;
+            case 'patrol':
+                this.updatePatrolBehavior(deltaTime);
+                break;
+        }
+        
+        // 다른 적기와의 충돌 회피
+        this.avoidOtherEnemies(deltaTime);
+        
+        // 부드러운 회전 보간
+        this.rotation.x = THREE.MathUtils.lerp(this.rotation.x, this.targetRotation.x, deltaTime * 2.0);
+        this.rotation.y = THREE.MathUtils.lerp(this.rotation.y, this.targetRotation.y, deltaTime * 3.0);
+        this.rotation.z = THREE.MathUtils.lerp(this.rotation.z, this.targetRotation.z, deltaTime * 2.5);
+        
+        // 속도 계산 (스로틀 기반)
+        const targetSpeed = this.speed * this.throttle;
+        const currentSpeed = this.velocity.length();
+        const newSpeed = THREE.MathUtils.lerp(currentSpeed, targetSpeed, deltaTime * 0.5);
+        
+        // 방향 벡터 계산
+        const forward = new THREE.Vector3(0, 0, 1);
+        forward.applyEuler(this.rotation);
+        
+        // 중력과 양력 효과
+        const liftFactor = Math.min(1.0, newSpeed / this.speed);
+        const gravityEffect = GAME_CONSTANTS.GRAVITY * deltaTime * 0.15;
+        const lift = gravityEffect * liftFactor * 0.8;
+        
+        // 속도 벡터 업데이트
+        this.velocity = forward.multiplyScalar(newSpeed);
+        this.velocity.y += (lift - gravityEffect);
+        
+        // 위치 업데이트
         this.position.add(this.velocity.clone().multiplyScalar(deltaTime));
         
-        if (this.position.y < GAME_CONSTANTS.MIN_ALTITUDE) {
-            this.position.y = GAME_CONSTANTS.MIN_ALTITUDE;
+        // 고도 제한
+        if (this.position.y < 500) {
+            this.position.y = 500;
+            this.targetRotation.x = Math.max(this.targetRotation.x, -0.2); // 기수를 들어 상승
         }
-        if (this.position.y > GAME_CONSTANTS.MAX_ALTITUDE) {
-            this.position.y = GAME_CONSTANTS.MAX_ALTITUDE;
+        if (this.position.y > GAME_CONSTANTS.MAX_ALTITUDE - 500) {
+            this.position.y = GAME_CONSTANTS.MAX_ALTITUDE - 500;
+            this.targetRotation.x = Math.min(this.targetRotation.x, 0.2); // 기수를 내려 하강
         }
         
+        // 맵 경계 처리
         const mapLimit = GAME_CONSTANTS.MAP_SIZE / 2;
-        if (this.position.x > mapLimit) this.position.x = -mapLimit;
-        if (this.position.x < -mapLimit) this.position.x = mapLimit;
-        if (this.position.z > mapLimit) this.position.z = -mapLimit;
-        if (this.position.z < -mapLimit) this.position.z = mapLimit;
+        if (Math.abs(this.position.x) > mapLimit * 0.8 || Math.abs(this.position.z) > mapLimit * 0.8) {
+            // 맵 경계에 가까워지면 중앙으로 선회
+            const centerDirection = this.position.clone().negate().normalize();
+            const angle = Math.atan2(centerDirection.x, centerDirection.z);
+            this.targetRotation.y = angle;
+        }
         
+        // 메시 업데이트
         this.mesh.position.copy(this.position);
         this.mesh.rotation.x = this.rotation.x;
         this.mesh.rotation.y = this.rotation.y + 3 * Math.PI / 2;
@@ -810,6 +865,137 @@ class EnemyFighter {
         
         this.updateBullets(deltaTime);
     }
+    
+    updateCombatBehavior(playerPosition, deltaTime, currentTime) {
+        const toPlayer = playerPosition.clone().sub(this.position);
+        const distance = toPlayer.length();
+        toPlayer.normalize();
+        
+        // 공격 각도 계산
+        const angle = Math.atan2(toPlayer.x, toPlayer.z);
+        const pitchAngle = Math.atan2(-toPlayer.y, Math.sqrt(toPlayer.x * toPlayer.x + toPlayer.z * toPlayer.z));
+        
+        // BFM (Basic Fighter Maneuvers) 구현
+        if (distance < 1000) {
+            // 너무 가까우면 회피 기동
+            this.evasionTimer += deltaTime;
+            if (this.evasionTimer > 2.0) {
+                this.evasionTimer = 0;
+                this.evasionPattern = Math.floor(Math.random() * 3);
+            }
+            
+            switch(this.evasionPattern) {
+                case 0: // 배럴 롤
+                    this.targetRotation.z = Math.sin(this.evasionTimer * Math.PI) * 1.5;
+                    this.targetRotation.x = pitchAngle + Math.sin(this.evasionTimer * Math.PI * 2) * 0.3;
+                    break;
+                case 1: // 이멜만 턴
+                    this.targetRotation.x = -0.5 + this.evasionTimer * 0.5;
+                    this.targetRotation.z = this.evasionTimer * Math.PI;
+                    break;
+                case 2: // 스플릿 S
+                    this.targetRotation.x = 0.5 - this.evasionTimer * 0.5;
+                    this.targetRotation.z = Math.PI;
+                    break;
+            }
+            this.throttle = 1.0; // 최대 속도로 회피
+        } else if (distance < 2000) {
+            // 공격 위치 선정
+            this.targetRotation.y = angle;
+            this.targetRotation.x = pitchAngle;
+            this.targetRotation.z = 0;
+            
+            // 리드 앵글 계산 (예측 사격)
+            const playerVelocity = this.playerFighter ? this.playerFighter.velocity : new THREE.Vector3();
+            const bulletTime = distance / 1200; // 탄환 속도
+            const leadPosition = playerPosition.clone().add(playerVelocity.clone().multiplyScalar(bulletTime));
+            const leadDirection = leadPosition.sub(this.position).normalize();
+            const leadAngle = Math.atan2(leadDirection.x, leadDirection.z);
+            
+            this.targetRotation.y = leadAngle;
+            
+            // 사격
+            if (currentTime - this.lastShootTime > 800) {
+                this.shoot();
+            }
+            
+            this.throttle = 0.9;
+        } else {
+            // 추적
+            this.targetRotation.y = angle;
+            this.targetRotation.x = pitchAngle * 0.5; // 부드러운 피치 조정
+            this.targetRotation.z = 0;
+            this.throttle = 0.85;
+        }
+    }
+    
+    updateApproachBehavior(playerPosition, deltaTime) {
+        const toPlayer = playerPosition.clone().sub(this.position);
+        const angle = Math.atan2(toPlayer.x, toPlayer.z);
+        
+        // 부드러운 접근
+        this.targetRotation.y = angle;
+        this.targetRotation.x = 0;
+        this.targetRotation.z = Math.sin(Date.now() * 0.001) * 0.3; // 약간의 롤링
+        this.throttle = 0.8;
+    }
+    
+    updatePatrolBehavior(deltaTime) {
+        // 순찰 패턴
+        if (this.position.distanceTo(this.targetPosition) < 500) {
+            // 새로운 순찰 지점 설정
+            const angle = Math.random() * Math.PI * 2;
+            const distance = this.patrolRadius * (0.5 + Math.random() * 0.5);
+            this.targetPosition = this.patrolCenter.clone().add(
+                new THREE.Vector3(
+                    Math.cos(angle) * distance,
+                    (Math.random() - 0.5) * 1000,
+                    Math.sin(angle) * distance
+                )
+            );
+        }
+        
+        const toTarget = this.targetPosition.clone().sub(this.position);
+        const angle = Math.atan2(toTarget.x, toTarget.z);
+        
+        this.targetRotation.y = angle;
+        this.targetRotation.x = 0;
+        this.targetRotation.z = Math.sin(Date.now() * 0.0005) * 0.2; // 완만한 롤링
+        this.throttle = 0.7;
+    }
+    
+    avoidOtherEnemies(deltaTime) {
+        if (!this.nearbyEnemies) return;
+        
+        let avoidanceVector = new THREE.Vector3();
+        let tooClose = false;
+        
+        this.nearbyEnemies.forEach(enemy => {
+            if (enemy === this || !enemy.position) return;
+            
+            const distance = this.position.distanceTo(enemy.position);
+            if (distance < this.separationRadius && distance > 0) {
+                // 반발력 계산
+                const force = this.position.clone().sub(enemy.position).normalize();
+                const strength = 1 - (distance / this.separationRadius);
+                avoidanceVector.add(force.multiplyScalar(strength));
+                tooClose = true;
+            }
+        });
+        
+        if (tooClose) {
+            // 회피 방향으로 선회
+            const avoidAngle = Math.atan2(avoidanceVector.x, avoidanceVector.z);
+            this.targetRotation.y = THREE.MathUtils.lerp(this.targetRotation.y, avoidAngle, deltaTime * 5);
+            
+            // 고도 변경으로 추가 회피
+            if (avoidanceVector.y > 0.5) {
+                this.targetRotation.x = -0.3; // 상승
+            } else if (avoidanceVector.y < -0.5) {
+                this.targetRotation.x = 0.3; // 하강
+            }
+        }
+    }
 
     shoot() {
         this.lastShootTime = Date.now();
@@ -1861,6 +2047,11 @@ class Game {
             }
             
             if (this.isStarted) {
+                // 적기들에게 서로의 참조 전달 (충돌 회피용)
+                this.enemies.forEach(enemy => {
+                    enemy.nearbyEnemies = this.enemies;
+                });
+                
                 this.enemies.forEach(enemy => {
                     enemy.update(this.fighter.position, deltaTime);
                 });