Update game.js

game.js

@@ -441,11 +441,11 @@ class Fighter {
             
             // 1.5초 이상 Over-G 상태일 경우 시야 흐림 시작
             if (this.overGTimer > 1.5) {
-                // 속도 급격히 감소 (1.75초부터)
-                if (this.overGTimer > 1.75) {
-                    targetSpeed *= Math.max(0, 1 - (this.overGTimer - 1.75) * 0.5);
+                // 속도 급격히 감소 (2.5초부터)
+                if (this.overGTimer > 2.5) {
+                    targetSpeed *= Math.max(0.3, 1 - (this.overGTimer - 2.5) * 0.3);
                 }
-                // 시야 흐림 효과는 UI에서 처리 (1초부터)
+                // 시야 흐림 효과는 UI에서 처리 (1.5초부터)
             }
         } else {
             this.overGTimer = 0; // Over-G 상태가 아니면 타이머 리셋
@@ -697,31 +697,29 @@ class EnemyFighter {
         
         // 개선된 AI 상태
         this.aiState = 'patrol';
-        this.targetPosition = position.clone();
-        this.patrolCenter = position.clone();
-        this.patrolRadius = 3000;
-        this.lastStateChange = 0;
+        this.targetPosition = this.generateRandomTarget();
+        this.lastDirectionChange = Date.now();
         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.targetRotation = new THREE.Euler(0, Math.random() * Math.PI * 2, 0);
+        this.turnRadius = 1500; // 선회 반경
+        this.isTurning = false;
+        this.turnDirection = 1; // 1: 우회전, -1: 좌회전
         
         // 다른 적기들과의 충돌 회피
         this.nearbyEnemies = [];
         this.separationRadius = 300; // 최소 거리 300m
-        
-        // 공격 패턴
-        this.attackAngle = 0;
-        this.attackDistance = 0;
-        this.lastAttackTime = 0;
+    }
+    
+    generateRandomTarget() {
+        // 맵 범위 내 랜덤 목표 지점 생성
+        const mapLimit = GAME_CONSTANTS.MAP_SIZE / 2 * 0.8;
+        return new THREE.Vector3(
+            (Math.random() - 0.5) * 2 * mapLimit,
+            1000 + Math.random() * 3000, // 1000m ~ 4000m 고도
+            (Math.random() - 0.5) * 2 * mapLimit
+        );
     }
 
     async initialize(loader) {
@@ -778,62 +776,84 @@ class EnemyFighter {
         const currentTime = Date.now();
         const distanceToPlayer = this.position.distanceTo(playerPosition);
         
-        // AI 상태 결정
+        // 플레이어 감지 및 공격
+        let shouldAttack = false;
         if (distanceToPlayer < 3000) {
-            if (this.aiState !== 'combat') {
-                this.aiState = 'combat';
-                this.lastStateChange = currentTime;
+            // 플레이어가 시야각 내에 있는지 확인
+            const toPlayer = playerPosition.clone().sub(this.position).normalize();
+            const forward = new THREE.Vector3(0, 0, 1);
+            forward.applyEuler(this.rotation);
+            const angle = forward.dot(toPlayer);
+            
+            if (angle > 0.5) { // 120도 시야각
+                shouldAttack = true;
+                if (distanceToPlayer < 2000 && currentTime - this.lastShootTime > 800) {
+                    this.shoot();
+                }
             }
-        } else if (distanceToPlayer < 6000) {
-            if (this.aiState !== 'approach') {
-                this.aiState = 'approach';
-                this.lastStateChange = currentTime;
+        }
+        
+        // 목표 지점 도달 또는 일정 시간마다 새로운 목표 설정
+        if (this.position.distanceTo(this.targetPosition) < 500 || 
+            currentTime - this.lastDirectionChange > 15000) { // 15초마다 방향 변경
+            this.targetPosition = this.generateRandomTarget();
+            this.lastDirectionChange = currentTime;
+            this.isTurning = false;
+        }
+        
+        // 목표 방향 계산
+        const toTarget = this.targetPosition.clone().sub(this.position);
+        const targetAngle = Math.atan2(toTarget.x, toTarget.z);
+        let angleDiff = targetAngle - this.rotation.y;
+        
+        // 각도 차이를 -PI ~ PI 범위로 정규화
+        while (angleDiff > Math.PI) angleDiff -= Math.PI * 2;
+        while (angleDiff < -Math.PI) angleDiff += Math.PI * 2;
+        
+        // 큰 각도 차이가 있으면 원형 선회
+        if (Math.abs(angleDiff) > Math.PI / 6) { // 30도 이상
+            this.isTurning = true;
+            this.turnDirection = angleDiff > 0 ? 1 : -1;
+        }
+        
+        // 선회 중일 때
+        if (this.isTurning) {
+            // 원형 선회 구현
+            const turnRate = (this.speed / this.turnRadius) * this.turnDirection;
+            this.targetRotation.y += turnRate * deltaTime;
+            this.targetRotation.z = this.turnDirection * 0.5; // 선회 시 롤
+            
+            // 목표 각도에 근접하면 선회 종료
+            const newAngleDiff = targetAngle - this.targetRotation.y;
+            if (Math.abs(newAngleDiff) < Math.PI / 12) { // 15도 이내
+                this.isTurning = false;
             }
         } else {
-            if (this.aiState !== 'patrol') {
-                this.aiState = 'patrol';
-                this.lastStateChange = currentTime;
-            }
+            // 직진 비행
+            this.targetRotation.y = THREE.MathUtils.lerp(this.targetRotation.y, targetAngle, deltaTime * 0.5);
+            this.targetRotation.z = THREE.MathUtils.lerp(this.targetRotation.z, 0, deltaTime * 2);
         }
         
-        // 상태별 행동
-        switch(this.aiState) {
-            case 'combat':
-                this.updateCombatBehavior(playerPosition, deltaTime, currentTime);
-                break;
-            case 'approach':
-                this.updateApproachBehavior(playerPosition, deltaTime);
-                break;
-            case 'patrol':
-                this.updatePatrolBehavior(deltaTime);
-                break;
+        // 고도 조절
+        const altitudeDiff = this.targetPosition.y - this.position.y;
+        if (Math.abs(altitudeDiff) > 100) {
+            this.targetRotation.x = Math.max(-0.3, Math.min(0.3, altitudeDiff * 0.0001));
+        } else {
+            this.targetRotation.x = 0;
         }
         
         // 다른 적기와의 충돌 회피
         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.y = THREE.MathUtils.lerp(this.rotation.y, this.targetRotation.y, deltaTime * 2.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.velocity = forward.multiplyScalar(this.speed);
         
         // 위치 업데이트
         this.position.add(this.velocity.clone().multiplyScalar(deltaTime));
@@ -841,20 +861,23 @@ class EnemyFighter {
         // 고도 제한
         if (this.position.y < 500) {
             this.position.y = 500;
-            this.targetRotation.x = Math.max(this.targetRotation.x, -0.2); // 기수를 들어 상승
+            this.targetRotation.x = -0.2; // 상승
         }
         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); // 기수를 내려 하강
+            this.targetRotation.x = 0.2; // 하강
         }
         
         // 맵 경계 처리
         const mapLimit = GAME_CONSTANTS.MAP_SIZE / 2;
-        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;
+        if (Math.abs(this.position.x) > mapLimit * 0.9 || Math.abs(this.position.z) > mapLimit * 0.9) {
+            // 맵 경계에 가까워지면 중앙으로 향하는 새 목표 설정
+            this.targetPosition = new THREE.Vector3(
+                (Math.random() - 0.5) * mapLimit * 0.5,
+                1000 + Math.random() * 3000,
+                (Math.random() - 0.5) * mapLimit * 0.5
+            );
+            this.lastDirectionChange = currentTime;
         }
         
         // 메시 업데이트
@@ -866,132 +889,37 @@ 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;
+        let closestDistance = Infinity;
+        let avoidanceNeeded = false;
+        let avoidDirection = new THREE.Vector3();
         
         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;
+                avoidanceNeeded = true;
+                if (distance < closestDistance) {
+                    closestDistance = distance;
+                    // 반대 방향��로 회피
+                    avoidDirection = this.position.clone().sub(enemy.position).normalize();
+                }
             }
         });
         
-        if (tooClose) {
-            // 회피 방향으로 선회
-            const avoidAngle = Math.atan2(avoidanceVector.x, avoidanceVector.z);
-            this.targetRotation.y = THREE.MathUtils.lerp(this.targetRotation.y, avoidAngle, deltaTime * 5);
+        if (avoidanceNeeded) {
+            // 긴급 회피: 급선회
+            const avoidAngle = Math.atan2(avoidDirection.x, avoidDirection.z);
+            this.targetRotation.y = avoidAngle;
+            this.isTurning = true;
             
-            // 고도 변경으로 추가 회피
-            if (avoidanceVector.y > 0.5) {
+            // 고도도 변경
+            if (avoidDirection.y > 0) {
                 this.targetRotation.x = -0.3; // 상승
-            } else if (avoidanceVector.y < -0.5) {
+            } else {
                 this.targetRotation.x = 0.3; // 하강
             }
         }
@@ -1734,7 +1662,7 @@ class Game {
         }
         
         // Over-G 시야 효과 - 수정된 부분
-        if (this.fighter.overG && this.fighter.overGTimer > 0) {
+        if (this.fighter.overG && this.fighter.overGTimer > 1.5) {
             let blurEffect = document.getElementById('overGBlurEffect');
             if (!blurEffect) {
                 blurEffect = document.createElement('div');
@@ -1743,19 +1671,17 @@ class Game {
             }
             
             // Over-G 지속 시간에 따라 점진적으로 어두워짐
-            // 0초: 효과 없음
-            // 1초: 거의 완전히 어두워짐
-            const darknessFactor = Math.min(this.fighter.overGTimer, 1.0); // 0~1 범위로 제한
+            // 1.5초부터 시작하여 서서히 진행
+            const adjustedTimer = Math.max(0, this.fighter.overGTimer - 1.5); // 1.5초 이후부터 카운트
+            const darknessFactor = Math.min(adjustedTimer / 2.0, 0.7); // 2초에 걸쳐 최대 70%까지만 어두워짐
             
             // 시야 가장자리부터 어두워지는 효과
             // 중앙은 상대적으로 늦게 어두워짐
-            const centerTransparency = Math.max(0, 1 - darknessFactor * 1.2); // 중앙 투명도
-            const midTransparency = Math.max(0, 1 - darknessFactor * 0.8); // 중간 투명도
-            const edgeOpacity = Math.min(0.95, darknessFactor * 0.95); // 가장자리 불투명도
-            
-            // 붉은 색조 추가 (혈액 순환 문제를 시각화) - 약화된 버전
-            const redTint = Math.min(darknessFactor * 0.1, 0.1); // 0.3에서 0.1로 감소
+            const centerTransparency = Math.max(0.3, 1 - darknessFactor * 0.8); // 중앙은 최소 30% 투명도 유지
+            const midTransparency = Math.max(0.2, 1 - darknessFactor * 0.6); // 중간 투명도
+            const edgeOpacity = Math.min(0.8, darknessFactor * 0.8); // 가장자리 최대 80% 불투명
             
+            // 붉은 색조 제거, 검은색만 사용
             blurEffect.style.cssText = `
                 position: fixed;
                 top: 0;
@@ -1763,24 +1689,21 @@ class Game {
                 width: 100%;
                 height: 100%;
                 background: radial-gradient(ellipse at center, 
-                    rgba(${Math.floor(255 * redTint)}, 0, 0, ${1 - centerTransparency}) 0%, 
-                    rgba(${Math.floor(150 * redTint)}, 0, 0, ${1 - midTransparency}) 40%, 
-                    rgba(0, 0, 0, ${edgeOpacity}) 70%, 
-                    rgba(0, 0, 0, ${Math.min(0.98, edgeOpacity + 0.05)}) 100%);
+                    rgba(0, 0, 0, ${1 - centerTransparency}) 0%, 
+                    rgba(0, 0, 0, ${1 - midTransparency}) 50%, 
+                    rgba(0, 0, 0, ${edgeOpacity}) 80%, 
+                    rgba(0, 0, 0, ${Math.min(0.85, edgeOpacity + 0.05)}) 100%);
                 pointer-events: none;
                 z-index: 1400;
-                transition: background 0.1s ease-out;
+                transition: background 0.3s ease-out;
             `;
             
-            // 심한 Over-G 상태에서 화면 흔들림 효과
-            if (darknessFactor > 0.7) {
-                const shake = (1 - Math.random() * 2) * 2;
+            // 심한 Over-G 상태에서 약간의 화면 흔들림 효과
+            if (darknessFactor > 0.5) {
+                const shake = (1 - Math.random() * 2) * 1;
                 blurEffect.style.transform = `translate(${shake}px, ${shake}px)`;
             }
             
-            // 디버그 정보 (선택사항)
-            // console.log(`Over-G Timer: ${this.fighter.overGTimer.toFixed(2)}s, Darkness: ${(darknessFactor * 100).toFixed(0)}%`);
-            
         } else {
             // Over-G 상태가 아니면 효과 제거
             const blurEffect = document.getElementById('overGBlurEffect');