Update game.js

game.js

@@ -717,158 +717,52 @@ class Fighter {
 }
 
 // 적 전투기 클래스
+// 적 전투기 클래스 - 완전히 재설계
 class EnemyFighter {
     constructor(scene, position) {
         this.mesh = null;
         this.isLoaded = false;
         this.scene = scene;
         this.position = position.clone();
-        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 = 386; // 750kt in m/s (750 * 0.514444) - 1000kt에서 750kt로 감소
+        this.rotation = new THREE.Euler(0, Math.random() * Math.PI * 2, 0);
+        
+        // 물리 속성
+        this.speed = 600; // 600kt로 시작 (500-750kt 범위)
+        this.velocity = new THREE.Vector3(0, 0, 0);
+        this.health = GAME_CONSTANTS.MAX_HEALTH;
+        
+        // AI 상태
+        this.aiState = 'patrol'; // patrol, combat, evade
+        this.targetPosition = null;
+        this.playerFighter = null;
+        
+        // 전투 시스템
         this.bullets = [];
+        this.burstCounter = 0; // 현재 연발 카운터
+        this.attackCounter = 0; // 공격 횟수 카운터
         this.lastShootTime = 0;
+        this.evadeTimer = 0;
+        this.isEvading = false;
         
-        // 개선된 AI 상태
-        this.aiState = 'patrol';
-        this.targetPosition = this.generateRandomTarget();
-        this.lastDirectionChange = Date.now();
-        this.playerFighter = null; // 플레이어 참조 저장용
-        
-        // 부드러운 선회를 위한 변수
-        this.targetRotation = new THREE.Euler(0, Math.random() * Math.PI * 2, 0);
-        this.turnRadius = 1500; // 선회 반경
-        this.isTurning = false;
-        this.turnDirection = 1; // 1: 우회전, -1: 좌회전
+        // 부드러운 회전을 위한 변수
+        this.targetRotation = this.rotation.clone();
+        this.turnSpeed = 1.5; // 초당 회전 속도 (라디안)
         
-        // 다른 적기들과의 충돌 회피
+        // 충돌 회피
         this.nearbyEnemies = [];
-        this.separationRadius = 300; // 최소 거리 300m
-        
-        // 전투 관련 변수
-        this.isEngaged = false; // 전투 중 상태
-        this.burstCount = 0; // 현재 연발 수
-        this.lastBurstTime = 0; // 마지막 연발 시작 시간
-        this.predictedTargetPos = new THREE.Vector3(); // 예측 사격 위치
-        
-        // 새로운 항공역학적 기동 변수
-        this.maneuverState = 'straight'; // straight, turning, climbing, diving, combat_turn
-        this.maneuverTimer = 0;
-        this.nextManeuverTime = 3 + Math.random() * 4; // 3-7초마다 기동 변경
-        
-        // 전투 기동 패턴
-        this.combatPattern = 'approach'; // approach, attack, evade, reposition
-        this.combatTargetOffset = new THREE.Vector3();
-        this.lastAttackPosition = new THREE.Vector3();
-        this.evasionDirection = new THREE.Vector3();
-        
-        // 물리적 제한 추가
-        this.maxBankAngle = Math.PI / 3; // 최대 60도 뱅크
-        this.maxPitchRate = 1.0; // 초당 최대 피치 변화율
-        this.maxRollRate = 2.0; // 초당 최대 롤 변화율
-        this.currentG = 1.0; // 현재 G-Force
-        
-        // 에너지 관리
-        this.throttle = 0.7; // 스로틀 제어
-        this.optimalSpeed = 386; // 최적 전투 속도
-    }
-    
-    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
-        );
-    }
-    
-    // 새로운 메서드: 자연스러운 기동 선택
-    selectNewManeuver() {
-        const maneuvers = ['straight', 'turning_left', 'turning_right', 'climbing', 'diving', 'barrel_roll'];
-        const weights = [0.3, 0.2, 0.2, 0.15, 0.1, 0.05]; // 각 기동의 확률
-        
-        let random = Math.random();
-        let accumulator = 0;
-        
-        for (let i = 0; i < maneuvers.length; i++) {
-            accumulator += weights[i];
-            if (random <= accumulator) {
-                this.maneuverState = maneuvers[i];
-                break;
-            }
-        }
+        this.avoidanceVector = new THREE.Vector3();
         
-        // 기동 지속 시간 설정
-        switch (this.maneuverState) {
-            case 'straight':
-                this.maneuverTimer = 2 + Math.random() * 3;
-                break;
-            case 'turning_left':
-            case 'turning_right':
-                this.maneuverTimer = 3 + Math.random() * 4;
-                this.turnDirection = this.maneuverState === 'turning_left' ? -1 : 1;
-                break;
-            case 'climbing':
-            case 'diving':
-                this.maneuverTimer = 2 + Math.random() * 2;
-                break;
-            case 'barrel_roll':
-                this.maneuverTimer = 4;
-                break;
-        }
+        // 초기 목표 설정
+        this.selectNewPatrolTarget();
     }
     
-    // 새로운 메서드: 전투 기동 패턴 선택
-    selectCombatPattern(playerPosition, distance) {
-        const angleToPlayer = this.getAngleToTarget(playerPosition);
-        
-        if (this.combatPattern === 'approach' && distance < 2000) {
-            // 접근 완료, 공격 패턴으로 전환
-            this.combatPattern = 'attack';
-            this.lastAttackPosition = this.position.clone();
-        } else if (this.combatPattern === 'attack' && distance < 500) {
-            // 너무 가까움, 회피 기동
-            this.combatPattern = 'evade';
-            this.evasionDirection = new THREE.Vector3(
-                Math.random() - 0.5,
-                Math.random() * 0.5,
-                Math.random() - 0.5
-            ).normalize();
-        } else if (this.combatPattern === 'evade' && distance > 1500) {
-            // 안전거리 확보, 재위치 선정
-            this.combatPattern = 'reposition';
-        } else if (this.combatPattern === 'reposition' && distance > 1000 && distance < 3000) {
-            // 재위치 완료, 다시 접근
-            this.combatPattern = 'approach';
-        }
-        
-        // 공격 위치 오프셋 계산 (플레이어 주변 300m 반경)
-        if (this.combatPattern === 'reposition' || this.combatPattern === 'approach') {
-            const offsetAngle = Math.random() * Math.PI * 2;
-            const offsetDistance = 200 + Math.random() * 100; // 200-300m
-            this.combatTargetOffset = new THREE.Vector3(
-                Math.cos(offsetAngle) * offsetDistance,
-                (Math.random() - 0.5) * 100,
-                Math.sin(offsetAngle) * offsetDistance
-            );
-        }
-    }
-    
-    // 새로운 메서드: 타겟까지의 각도 계산
-    getAngleToTarget(targetPosition) {
-        const toTarget = targetPosition.clone().sub(this.position).normalize();
-        const forward = new THREE.Vector3(0, 0, 1).applyEuler(this.rotation);
-        return Math.acos(Math.max(-1, Math.min(1, forward.dot(toTarget))));
-    }
-async initialize(loader) {
+    async initialize(loader) {
         try {
             const result = await loader.loadAsync('models/mig-29.glb');
             this.mesh = result.scene;
             this.mesh.position.copy(this.position);
             this.mesh.scale.set(1.5, 1.5, 1.5);
-            this.mesh.rotation.y = 3 * Math.PI / 2;
+            this.mesh.rotation.y = this.rotation.y + Math.PI;
             
             this.mesh.traverse((child) => {
                 if (child.isMesh) {
@@ -885,7 +779,7 @@ async initialize(loader) {
             this.createFallbackModel();
         }
     }
-
+    
     createFallbackModel() {
         const group = new THREE.Group();
         
@@ -906,43 +800,35 @@ async initialize(loader) {
         this.mesh.scale.set(1.5, 1.5, 1.5);
         this.scene.add(this.mesh);
         this.isLoaded = true;
-        
-        console.log('Fallback 적기 모델 생성 완료');
     }
-
+    
     update(playerPosition, deltaTime) {
-        if (!this.mesh) return;
+        if (!this.mesh || !this.isLoaded) return;
         
-        // AI 상태 업데이트
         const distanceToPlayer = this.position.distanceTo(playerPosition);
         
-        // 전투 거리 체크 (3000m 이내)
-        if (distanceToPlayer < 3000) {
+        // 상태 결정
+        if (distanceToPlayer <= 3000 && !this.isEvading) {
             this.aiState = 'combat';
-            this.isEngaged = true;
-            this.targetPosition = playerPosition.clone();
-        } else if (distanceToPlayer > 5000) {
+        } else if (this.isEvading) {
+            this.aiState = 'evade';
+        } else {
             this.aiState = 'patrol';
-            this.isEngaged = false;
-            this.combatPattern = 'approach'; // 전투 패턴 리셋
         }
         
-        // 다른 적기와의 충돌 회피
-        this.avoidOtherEnemies(deltaTime);
-        
-        // 기동 타이머 업데이트
-        this.maneuverTimer -= deltaTime;
-        if (this.maneuverTimer <= 0 && this.aiState === 'patrol') {
-            this.selectNewManeuver();
-        }
+        // 충돌 회피 계산
+        this.calculateAvoidance();
         
         // AI 행동 실행
         switch (this.aiState) {
             case 'patrol':
-                this.patrol(deltaTime);
+                this.executePatrol(deltaTime);
                 break;
             case 'combat':
-                this.combat(playerPosition, deltaTime);
+                this.executeCombat(playerPosition, deltaTime);
+                break;
+            case 'evade':
+                this.executeEvade(deltaTime);
                 break;
         }
         
@@ -953,411 +839,185 @@ async initialize(loader) {
         this.updateBullets(deltaTime);
     }
     
-    avoidOtherEnemies(deltaTime) {
-        if (!this.nearbyEnemies) return;
-        
-        let closestDistance = Infinity;
-        let avoidanceNeeded = false;
-        let avoidDirection = new THREE.Vector3();
+    executePatrol(deltaTime) {
+        // 목표 지점까지의 거리 확인
+        if (!this.targetPosition || this.position.distanceTo(this.targetPosition) < 500) {
+            this.selectNewPatrolTarget();
+        }
         
-        this.nearbyEnemies.forEach(enemy => {
-            if (enemy === this || !enemy.position) return;
-            
-            const distance = this.position.distanceTo(enemy.position);
-            if (distance < this.separationRadius && distance > 0) {
-                avoidanceNeeded = true;
-                if (distance < closestDistance) {
-                    closestDistance = distance;
-                    // 반대 방향으로 회피
-                    avoidDirection = this.position.clone().sub(enemy.position).normalize();
-                }
-            }
-        });
+        // 목표를 향해 부드럽게 회전
+        this.smoothTurnToTarget(this.targetPosition, deltaTime);
         
-        if (avoidanceNeeded) {
-            // 긴급 회피: 급선회
-            const avoidAngle = Math.atan2(avoidDirection.x, avoidDirection.z);
-            this.targetRotation.y = avoidAngle;
-            this.isTurning = true;
-            
-            // 고도도 변경 (더 부드럽게)
-            if (avoidDirection.y > 0) {
-                this.targetRotation.x = -0.15;
-            } else {
-                this.targetRotation.x = 0.15;
-            }
-        }
-    }
-    
-    patrol(deltaTime) {
-    // 자연스러운 기동 실행
-    switch (this.maneuverState) {
-        case 'straight':
-            // 직진 비행
-            this.targetRotation.x = 0;
-            this.targetRotation.z = 0;
-            
-            // 목표 지점을 향해 천천히 방향 조정
-            const dirToTarget = this.targetPosition.clone().sub(this.position);
-            if (dirToTarget.length() > 0) {
-                dirToTarget.normalize();
-                const targetYaw = Math.atan2(dirToTarget.x, dirToTarget.z);
-                const yawDiff = this.normalizeAngle(targetYaw - this.rotation.y);
-                this.targetRotation.y = this.rotation.y + yawDiff * deltaTime * 0.8;
-            }
-            break;
-            
-        case 'turning_left':
-        case 'turning_right':
-            // 뱅크 턴 실행
-            const bankAngle = this.turnDirection * Math.PI / 4; // 45도 뱅크
-            this.targetRotation.z = bankAngle;
-            this.targetRotation.y += this.turnDirection * deltaTime * 0.8;
-            
-            // 턴 중 약간의 기수 하강
-            this.targetRotation.x = 0.1;
-            break;
-            
-        case 'climbing':
-            // 상승
-            this.targetRotation.x = -Math.PI / 6; // 30도 상승
-            this.targetRotation.z = 0;
-            this.throttle = Math.min(1.0, this.throttle + deltaTime * 0.3);
-            break;
-            
-        case 'diving':
-            // 하강
-            this.targetRotation.x = Math.PI / 8; // 22.5도 하강
-            this.targetRotation.z = 0;
-            this.throttle = Math.max(0.5, this.throttle - deltaTime * 0.2);
-            break;
-            
-        case 'barrel_roll':
-            // 배럴 롤
-            const rollProgress = (4 - this.maneuverTimer) / 4;
-            this.targetRotation.z = Math.sin(rollProgress * Math.PI * 4) * Math.PI / 2;
-            this.targetRotation.x = Math.sin(rollProgress * Math.PI * 2) * 0.2;
-            break;
+        // 속도 유지 (500-750kt)
+        this.speed = THREE.MathUtils.clamp(this.speed, 257, 386); // m/s 변환
     }
     
-    // 목표 지점에 도달했는지 확인
-    const distanceToTarget = this.position.distanceTo(this.targetPosition);
-    if (distanceToTarget < 500) {
-        // 새로운 목표 생성
-        this.targetPosition = this.generateRandomTarget();
-        this.selectNewManeuver();
+    executeCombat(playerPosition, deltaTime) {
+        // 플레이어를 향해 회전
+        this.smoothTurnToTarget(playerPosition, deltaTime);
+        
+        // 조준 정확도 확인
+        const aimAccuracy = this.calculateAimAccuracy(playerPosition);
+        
+        // 정확한 조준 시 발사
+        if (aimAccuracy < 0.1 && this.attackCounter < 3) {
+            this.fireWeapon();
+        }
+        
+        // 3번 공격 후 회피 모드로 전환
+        if (this.attackCounter >= 3) {
+            this.isEvading = true;
+            this.evadeTimer = 3.0; // 3초 회피
+            this.attackCounter = 0;
+            this.selectEvadeTarget();
+        }
     }
     
-    // 고도 조정
-    const altitudeDiff = this.targetPosition.y - this.position.y;
-    if (Math.abs(altitudeDiff) > 200 && this.maneuverState === 'straight') {
-        if (altitudeDiff > 0) {
-            this.targetRotation.x = Math.max(-0.3, Math.min(0, altitudeDiff * 0.0001));
+    executeEvade(deltaTime) {
+        // 회피 타이머 업데이트
+        this.evadeTimer -= deltaTime;
+        
+        if (this.evadeTimer <= 0) {
+            this.isEvading = false;
+            this.selectNewPatrolTarget();
         } else {
-            this.targetRotation.x = Math.min(0.3, Math.max(0, altitudeDiff * 0.0001));
+            // 회피 목표를 향해 이동
+            this.smoothTurnToTarget(this.targetPosition, deltaTime);
         }
     }
     
-    // 속도 관리
-    this.updateSpeedControl(deltaTime);
-}
-    
-    combat(playerPosition, deltaTime) {
-        const distance = this.position.distanceTo(playerPosition);
-        
-        // 전투 패턴 업데이트
-        this.selectCombatPattern(playerPosition, distance);
-        
-        // 전투 패턴별 기동
-        switch (this.combatPattern) {
-            case 'approach':
-                // 플레이어 근처 목표점으로 접근
-                const approachTarget = playerPosition.clone().add(this.combatTargetOffset);
-                this.executeInterceptCourse(approachTarget, deltaTime);
-                
-                // 에너지 관리 - 속도 유지
-                this.throttle = 0.8;
-                break;
-                
-            case 'attack':
-                // 예측 사격을 위한 리드 계산
-                if (this.playerFighter && this.playerFighter.velocity) {
-                    const bulletTravelTime = distance / 1200;
-                    this.predictedTargetPos = playerPosition.clone().add(
-                        this.playerFighter.velocity.clone().multiplyScalar(bulletTravelTime * 0.7)
-                    );
-                } else {
-                    this.predictedTargetPos = playerPosition.clone();
-                }
-                
-                // 공격 자세 유지
-                this.executeAttackRun(this.predictedTargetPos, deltaTime);
-                
-                // 사격 판단
-                const aimAccuracy = this.calculateAimAccuracy(this.predictedTargetPos);
-                if (distance < 1500 && aimAccuracy < 0.15) {
-                    this.fireWeapon();
-                }
-                break;
-                
-            case 'evade':
-                // 회피 기동 - 브레이크 턴 또는 배럴 롤
-                this.executeEvasiveManeuver(deltaTime);
-                break;
-                
-            case 'reposition':
-                // 재위치 - 고도와 속도 이점 확보
-                const repositionTarget = playerPosition.clone();
-                repositionTarget.y += 500 + Math.random() * 1000; // 위에서 공격
-                repositionTarget.add(this.combatTargetOffset);
-                
-                this.executeInterceptCourse(repositionTarget, deltaTime);
-                
-                // 속도 회복
-                this.throttle = 0.9;
-                break;
-        }
+    smoothTurnToTarget(targetPos, deltaTime) {
+        // 타겟 방향 계산
+        const direction = targetPos.clone().sub(this.position);
+        direction.y *= 0.3; // 수직 이동을 제한
+        direction.normalize();
         
-        // 속도 관리
-        this.updateSpeedControl(deltaTime);
-    }
-    
-    // 요격 코스 실행
-    executeInterceptCourse(target, deltaTime) {
-    const toTarget = target.clone().sub(this.position);
-    const distance = toTarget.length();
-    
-    if (distance > 0) {
-        toTarget.normalize();
+        // 충돌 회피 벡터 적용
+        if (this.avoidanceVector.length() > 0) {
+            direction.add(this.avoidanceVector.multiplyScalar(0.5));
+            direction.normalize();
+        }
         
-        // 리드 턴 - 목표의 미래 위치를 예측하여 선회
-        const targetYaw = Math.atan2(toTarget.x, toTarget.z);
-        const targetPitch = Math.asin(-toTarget.y);
+        // 목표 회전 계산
+        const targetYaw = Math.atan2(direction.x, direction.z);
+        const targetPitch = Math.asin(-direction.y);
         
-        // 부드러운 선회를 위한 각도 차이 계산
+        // 부드러운 회전 (최대 회전 속도 제한)
         const yawDiff = this.normalizeAngle(targetYaw - this.rotation.y);
         const pitchDiff = targetPitch - this.rotation.x;
         
-        // 뱅크 각도를 이용한 자연스러운 선회
-        if (Math.abs(yawDiff) > 0.1) {
-            // 요 회전에 따른 롤 적용
-            this.targetRotation.z = Math.max(-this.maxBankAngle, 
-                Math.min(this.maxBankAngle, -yawDiff * 1.5));
+        const maxTurnRate = this.turnSpeed * deltaTime;
+        
+        // Yaw 회전
+        if (Math.abs(yawDiff) > maxTurnRate) {
+            this.rotation.y += Math.sign(yawDiff) * maxTurnRate;
         } else {
-            this.targetRotation.z *= 0.9; // 롤 복귀
+            this.rotation.y = targetYaw;
         }
         
-        // 목표 방향으로 회전
-        this.targetRotation.y = this.rotation.y + yawDiff * deltaTime * 1.0;
-        this.targetRotation.x = this.rotation.x + pitchDiff * deltaTime * 0.6;
+        // Pitch 회전 (제한적)
+        const maxPitchRate = maxTurnRate * 0.5;
+        if (Math.abs(pitchDiff) > maxPitchRate) {
+            this.rotation.x += Math.sign(pitchDiff) * maxPitchRate;
+        } else {
+            this.rotation.x = targetPitch;
+        }
         
-        // 피치 제한
-        this.targetRotation.x = Math.max(-Math.PI / 4, Math.min(Math.PI / 4, this.targetRotation.x));
+        // Pitch 제한
+        this.rotation.x = THREE.MathUtils.clamp(this.rotation.x, -Math.PI / 6, Math.PI / 6);
     }
-}
-    
-    // 공격 진입
-    executeAttackRun(target, deltaTime) {
-    const toTarget = target.clone().sub(this.position);
-    const distance = toTarget.length();
     
-    if (distance > 0) {
-        toTarget.normalize();
-        const targetYaw = Math.atan2(toTarget.x, toTarget.z);
-        const targetPitch = Math.asin(-toTarget.y);
+    calculateAvoidance() {
+        this.avoidanceVector.set(0, 0, 0);
         
-        // 정밀 조준을 위한 작은 수정
-        const yawDiff = this.normalizeAngle(targetYaw - this.rotation.y);
-        const pitchDiff = targetPitch - this.rotation.x;
+        if (!this.nearbyEnemies) return;
         
-        // 안정적인 사격 자세 유지
-        this.targetRotation.y = this.rotation.y + yawDiff * deltaTime * 1.5;
-        this.targetRotation.x = this.rotation.x + pitchDiff * deltaTime * 1.0;
-        this.targetRotation.z = -yawDiff * 0.3;
+        let avoidCount = 0;
         
-        // 속도 조절 - 목표와의 상대 속도 관리
-        if (distance < 800) {
-            this.throttle = 0.6; // 감속
-        } else {
-            this.throttle = 0.85;
-        }
-    }
-}
-    
-    // 회피 기동
-    executeEvasiveManeuver(deltaTime) {
-        // 브레이크 턴 또는 스플릿-S
-        const evasiveType = Math.random() > 0.5 ? 'break' : 'split_s';
-        
-        if (evasiveType === 'break') {
-            // 급격한 브레이크 턴
-            this.targetRotation.z = this.evasionDirection.x * this.maxBankAngle * 1.2;
-            this.targetRotation.y += this.evasionDirection.x * deltaTime * 3.0;
-            this.targetRotation.x = 0.2; // 약간의 기수 하강
-            this.throttle = 0.4; // 급감속
-        } else {
-            // 스플릿-S (반전 하강)
-            this.targetRotation.z += deltaTime * 4.0; // 빠른 롤
-            if (Math.abs(this.rotation.z) > Math.PI * 0.8) {
-                this.targetRotation.x = Math.PI / 3; // 급하강
+        this.nearbyEnemies.forEach(enemy => {
+            if (enemy === this || !enemy.position) return;
+            
+            const distance = this.position.distanceTo(enemy.position);
+            if (distance < 300 && distance > 0) {
+                // 반대 방향으로 회피
+                const avoidDir = this.position.clone().sub(enemy.position).normalize();
+                const strength = (300 - distance) / 300;
+                this.avoidanceVector.add(avoidDir.multiplyScalar(strength));
+                avoidCount++;
             }
-            this.throttle = 0.3;
-        }
+        });
         
-        // G-Force 시뮬레이션
-        this.currentG = 3.0 + Math.abs(this.rotation.z) * 2;
+        if (avoidCount > 0) {
+            this.avoidanceVector.divideScalar(avoidCount);
+            this.avoidanceVector.normalize();
+        }
     }
     
-    // 조준 정확도 계산
-    calculateAimAccuracy(target) {
-        const toTarget = target.clone().sub(this.position).normalize();
-        const forward = new THREE.Vector3(0, 0, 1).applyEuler(this.rotation);
+    updatePhysics(deltaTime) {
+        if (!this.mesh) return;
         
-        const dotProduct = forward.dot(toTarget);
-        const angle = Math.acos(Math.max(-1, Math.min(1, dotProduct)));
+        // 속도 벡터 계산 (항상 전진)
+        const forward = new THREE.Vector3(0, 0, 1);
+        forward.applyEuler(this.rotation);
         
-        return angle;
-    }
-    
-    // 무기 발사
-    fireWeapon() {
-        const now = Date.now();
-        if (now - this.lastBurstTime > 2000) {
-            this.burstCount = 0;
-            this.lastBurstTime = now;
-        }
+        // 속도 유지 (500-750kt, m/s로 변환)
+        this.speed = THREE.MathUtils.clamp(this.speed, 257, 386);
+        this.velocity = forward.multiplyScalar(this.speed);
         
-        if (this.burstCount < 5 && now - this.lastShootTime > 200) {
-            this.shoot();
-            this.burstCount++;
+        // 위치 업데이트
+        this.position.add(this.velocity.clone().multiplyScalar(deltaTime));
+        
+        // 고도 제한
+        if (this.position.y < 500) {
+            this.position.y = 500;
+            this.rotation.x = -0.1; // 약간 상승
+        } else if (this.position.y > 8000) {
+            this.position.y = 8000;
+            this.rotation.x = 0.1; // 약간 하강
         }
-    }
-    
-    // 속도 제어
-    updateSpeedControl(deltaTime) {
-        // 목표 속도 계산
-        let targetSpeed = this.optimalSpeed * this.throttle;
         
-        // 고도에 따른 속도 보정
-        const altitudeFactor = 1 + (this.position.y / 10000) * 0.2;
-        targetSpeed *= altitudeFactor;
+        // 맵 경계 처리
+        const mapLimit = GAME_CONSTANTS.MAP_SIZE / 2;
+        const boundaryBuffer = mapLimit * 0.9;
         
-        // 기동에 따른 속도 손실
-        if (this.currentG > 2.0) {
-            targetSpeed *= (1 - (this.currentG - 2.0) * 0.05);
+        if (Math.abs(this.position.x) > boundaryBuffer || Math.abs(this.position.z) > boundaryBuffer) {
+            // 맵 중앙을 향해 회전
+            const centerDirection = new THREE.Vector3(-this.position.x, 0, -this.position.z).normalize();
+            const targetYaw = Math.atan2(centerDirection.x, centerDirection.z);
+            this.rotation.y = targetYaw;
+            this.selectNewPatrolTarget(); // 새로운 목표 선택
         }
         
-        // 부드러운 속도 변화
-        this.speed = THREE.MathUtils.lerp(this.speed, targetSpeed, deltaTime * 0.5);
-    }
-    
-    // 각도 정규화 헬퍼 메서드
-    normalizeAngle(angle) {
-        while (angle > Math.PI) angle -= Math.PI * 2;
-        while (angle < -Math.PI) angle += Math.PI * 2;
-        return angle;
-    }
-    
-    updatePhysics(deltaTime) {
-    if (!this.mesh) return;
-    
-    // 부드러운 회전 적용 - 항공역학적 제한 적용
-    const rotationSpeed = deltaTime * 2.0;
-    const rollSpeed = deltaTime * this.maxRollRate;
-    const pitchSpeed = deltaTime * this.maxPitchRate;
-    
-    // 각 축별로 다른 속도로 회전
-    this.rotation.x = THREE.MathUtils.lerp(this.rotation.x, this.targetRotation.x, pitchSpeed);
-    this.rotation.y = THREE.MathUtils.lerp(this.rotation.y, this.targetRotation.y, rotationSpeed);
-    this.rotation.z = THREE.MathUtils.lerp(this.rotation.z, this.targetRotation.z, rollSpeed);
-    
-    // G-Force 계산
-    const turnRate = Math.abs(this.targetRotation.y - this.rotation.y) * 10;
-    const pitchRate = Math.abs(this.targetRotation.x - this.rotation.x) * 10;
-    this.currentG = 1.0 + turnRate + pitchRate + Math.abs(this.rotation.z) * 2;
-    
-    // 속도 벡터 계산 - 실제 항공기처럼 기수 방향으로
-    const forward = new THREE.Vector3(0, 0, 1);
-    forward.applyEuler(this.rotation);
-    
-    // 전진 속도 적용
-    this.velocity = forward.multiplyScalar(this.speed);
-    
-    // 뱅크 각도에 따른 선회력
-    if (Math.abs(this.rotation.z) > 0.1) {
-        const lift = new THREE.Vector3(0, 1, 0);
-        lift.applyEuler(this.rotation);
-        const turnForce = Math.sin(this.rotation.z) * this.currentG * 30;
-        this.velocity.add(lift.multiplyScalar(turnForce * deltaTime));
-    }
-    
-    // 중력 효과
-    const gravity = GAME_CONSTANTS.GRAVITY * deltaTime;
-    this.velocity.y -= gravity;
-    
-    // 양력 계산 (속도에 비례)
-    const liftFactor = (this.speed / this.optimalSpeed) * 0.8;
-    const lift = gravity * liftFactor * Math.cos(this.rotation.x);
-    this.velocity.y += lift;
-    
-    // 항력 (드래그)
-    const dragFactor = 0.02 + Math.abs(this.rotation.x) * 0.01;
-    this.velocity.multiplyScalar(1 - dragFactor * deltaTime);
-    
-    // 위치 업데이트
-    this.position.add(this.velocity.clone().multiplyScalar(deltaTime));
-    
-    // 고도 제한
-    if (this.position.y < 300) {
-        this.position.y = 300;
-        this.velocity.y = Math.max(0, this.velocity.y);
-        this.targetRotation.x = -0.3; // 강제 상승
-    } else if (this.position.y > 8000) {
-        this.position.y = 8000;
-        this.velocity.y = Math.min(0, this.velocity.y);
-        this.targetRotation.x = 0.2; // 하강
+        // 하드 리미트
+        this.position.x = THREE.MathUtils.clamp(this.position.x, -mapLimit, mapLimit);
+        this.position.z = THREE.MathUtils.clamp(this.position.z, -mapLimit, mapLimit);
+        
+        // 메시 업데이트
+        this.mesh.position.copy(this.position);
+        this.mesh.rotation.x = this.rotation.x;
+        this.mesh.rotation.y = this.rotation.y + Math.PI;
+        this.mesh.rotation.z = this.rotation.z;
     }
     
-    // 맵 경계 처리 - 부드러운 회귀
-    const mapLimit = GAME_CONSTANTS.MAP_SIZE / 2;
-    const boundaryBuffer = mapLimit * 0.9;
-    
-    if (Math.abs(this.position.x) > boundaryBuffer || Math.abs(this.position.z) > boundaryBuffer) {
-        // 맵 중앙을 향해 자연스럽게 회전
-        const centerDirection = new THREE.Vector3(-this.position.x, 0, -this.position.z).normalize();
-        const targetYaw = Math.atan2(centerDirection.x, centerDirection.z);
-        this.targetRotation.y = targetYaw;
+    fireWeapon() {
+        const now = Date.now();
         
-        // 경계에서 뱅크 턴
-        if (this.position.x > boundaryBuffer) {
-            this.targetRotation.z = -this.maxBankAngle;
-        } else if (this.position.x < -boundaryBuffer) {
-            this.targetRotation.z = this.maxBankAngle;
+        // 0.1초에 1발씩, 10발 연발
+        if (now - this.lastShootTime >= 100 && this.burstCounter < 10) {
+            this.shoot();
+            this.lastShootTime = now;
+            this.burstCounter++;
+            
+            // 10발 발사 완료 시
+            if (this.burstCounter >= 10) {
+                this.burstCounter = 0;
+                this.attackCounter++;
+            }
         }
     }
     
-    // 하드 리미트
-    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;
-    
-    // 메시 업데이트
-    this.mesh.position.copy(this.position);
-    this.mesh.rotation.x = this.rotation.x;
-    this.mesh.rotation.y = this.rotation.y + Math.PI;
-    this.mesh.rotation.z = this.rotation.z;
-    
-    // 자동 롤 복귀 (전투 중이 아닐 때)
-    if (!this.isEngaged && Math.abs(this.targetRotation.z) > 0.01) {
-        this.targetRotation.z *= 0.95;
-    }
-}
-    
     shoot() {
-        this.lastShootTime = Date.now();
-        
-        // 직선 모양의 탄환 (100% 더 크게)
+        // 탄환 생성
         const bulletGeometry = new THREE.CylinderGeometry(0.8, 0.8, 12, 8);
         const bulletMaterial = new THREE.MeshBasicMaterial({ 
             color: 0xff0000,
@@ -1371,10 +1031,11 @@ async initialize(loader) {
         muzzleOffset.applyEuler(this.rotation);
         bullet.position.copy(this.position).add(muzzleOffset);
         
-        // 탄환을 발사 방향으로 회전
+        // 탄환 회전
         bullet.rotation.copy(this.rotation);
         bullet.rotateX(Math.PI / 2);
         
+        // 탄환 속도
         const direction = new THREE.Vector3(0, 0, 1);
         direction.applyEuler(this.rotation);
         bullet.velocity = direction.multiplyScalar(1200);
@@ -1382,38 +1043,27 @@ async initialize(loader) {
         this.scene.add(bullet);
         this.bullets.push(bullet);
         
-        // MGLAUNCH.ogg 소리 재생 - 플레이어가 3000m 이내에 있을 때만
+        // 사운드 재생
         if (this.playerFighter) {
             const distanceToPlayer = this.position.distanceTo(this.playerFighter.position);
             if (distanceToPlayer < 3000) {
                 try {
                     const audio = new Audio('sounds/MGLAUNCH.ogg');
-                    audio.volume = 0.5;
-                    
-                    // 거리에 따른 음량 조절
                     const volumeMultiplier = 1 - (distanceToPlayer / 3000);
                     audio.volume = 0.5 * volumeMultiplier;
-                    
-                    audio.play().catch(e => console.log('Enemy gunfire sound failed to play'));
-                    
-                    audio.addEventListener('ended', () => {
-                        audio.remove();
-                    });
-                } catch (e) {
-                    console.log('Audio error:', e);
-                }
+                    audio.play().catch(e => {});
+                } catch (e) {}
             }
         }
     }
-
+    
     updateBullets(deltaTime) {
         for (let i = this.bullets.length - 1; i >= 0; i--) {
             const bullet = this.bullets[i];
             bullet.position.add(bullet.velocity.clone().multiplyScalar(deltaTime));
             
-            // 지면 충돌 체크
+            // 지면 충돌
             if (bullet.position.y <= 0) {
-                // 크고 화려한 지면 충돌 효과
                 if (window.gameInstance) {
                     window.gameInstance.createGroundImpactEffect(bullet.position);
                 }
@@ -1422,18 +1072,59 @@ async initialize(loader) {
                 continue;
             }
             
+            // 거리 제한
             if (bullet.position.distanceTo(this.position) > 5000) {
                 this.scene.remove(bullet);
                 this.bullets.splice(i, 1);
             }
         }
     }
-
+    
+    calculateAimAccuracy(target) {
+        const toTarget = target.clone().sub(this.position).normalize();
+        const forward = new THREE.Vector3(0, 0, 1).applyEuler(this.rotation);
+        const dotProduct = forward.dot(toTarget);
+        return Math.acos(Math.max(-1, Math.min(1, dotProduct)));
+    }
+    
+    selectNewPatrolTarget() {
+        const mapLimit = GAME_CONSTANTS.MAP_SIZE / 2 * 0.7;
+        this.targetPosition = new THREE.Vector3(
+            (Math.random() - 0.5) * 2 * mapLimit,
+            2000 + Math.random() * 2000, // 2000-4000m 고도
+            (Math.random() - 0.5) * 2 * mapLimit
+        );
+    }
+    
+    selectEvadeTarget() {
+        // 현재 위치에서 랜덤 방향으로 회피
+        const evadeDistance = 1000 + Math.random() * 1000;
+        const evadeAngle = Math.random() * Math.PI * 2;
+        
+        this.targetPosition = new THREE.Vector3(
+            this.position.x + Math.cos(evadeAngle) * evadeDistance,
+            this.position.y + (Math.random() - 0.5) * 500,
+            this.position.z + Math.sin(evadeAngle) * evadeDistance
+        );
+        
+        // 맵 경계 확인
+        const mapLimit = GAME_CONSTANTS.MAP_SIZE / 2 * 0.8;
+        this.targetPosition.x = THREE.MathUtils.clamp(this.targetPosition.x, -mapLimit, mapLimit);
+        this.targetPosition.z = THREE.MathUtils.clamp(this.targetPosition.z, -mapLimit, mapLimit);
+        this.targetPosition.y = THREE.MathUtils.clamp(this.targetPosition.y, 1000, 6000);
+    }
+    
+    normalizeAngle(angle) {
+        while (angle > Math.PI) angle -= Math.PI * 2;
+        while (angle < -Math.PI) angle += Math.PI * 2;
+        return angle;
+    }
+    
     takeDamage(damage) {
         this.health -= damage;
         return this.health <= 0;
     }
-
+    
     destroy() {
         if (this.mesh) {
             this.scene.remove(this.mesh);