Update game.js

game.js

@@ -718,729 +718,730 @@ 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 = 350; // 초기 속도 350kt와 유사하게
-       this.bullets = [];
-       this.lastShootTime = 0;
-       
-       // 개선된 AI 상태
-       this.aiState = 'patrol';
-       this.targetPosition = this.generateRandomTarget();
-       this.lastDirectionChange = Date.now();
-       this.playerFighter = null; // 플레이어 참조 저장용
-       
-       // 플레이어와 유사한 물리 속성
-       this.throttle = 0.7; // 초기 스로틀 70%
-       this.altitude = position.y;
-       this.gForce = 1.0;
-       
-       // 조종 입력 시스템 (플레이어와 유사)
-       this.pitchInput = 0;
-       this.rollInput = 0;
-       this.yawInput = 0;
-       
-       // 부드러운 회전을 위한 목표값
-       this.targetPitch = 0;
-       this.targetRoll = 0;
-       this.targetYaw = Math.atan2(this.velocity.x, this.velocity.z);
-       
-       // 스톨 시스템
-       this.stallWarning = false;
-       
-       // 다른 적기들과의 충돌 회피
-       this.nearbyEnemies = [];
-       this.separationRadius = 500; // 최소 거리 500m
-       
-       // 전투 관련 변수
-       this.isEngaged = false;
-       this.burstCount = 0;
-       this.lastBurstTime = 0;
-       this.predictedTargetPos = new THREE.Vector3();
-       
-       // 기동 패턴 변수
-       this.maneuverState = 'straight'; // straight, turning, climbing, diving, evasive
-       this.maneuverTimer = 0;
-       this.nextManeuverTime = 3 + Math.random() * 4;
-       
-       // 전투 패턴
-       this.combatPattern = 'approach'; // approach, attack, evade, reposition
-       this.combatTimer = 0;
-       this.lastAttackAngle = 0;
-       
-       // 순찰 경로점
-       this.patrolIndex = 0;
-       this.arrivalThreshold = 300; // 목표 도달 판정 거리
-   }
-   
-   generateRandomTarget() {
-       // 맵 범위 내 랜덤 목표 지점 생성
-       const mapLimit = GAME_CONSTANTS.MAP_SIZE / 2 * 0.8;
-       return new THREE.Vector3(
-           (Math.random() - 0.5) * 2 * mapLimit,
-           1500 + Math.random() * 2500, // 1500m ~ 4000m 고도
-           (Math.random() - 0.5) * 2 * mapLimit
-       );
-   }
-   
-   // 자연스러운 기동 선택
-   selectNewManeuver() {
-       if (this.aiState === 'patrol') {
-           // 순찰 중 기동
-           const maneuvers = ['straight', 'gentle_turn', 'altitude_change'];
-           const weights = [0.5, 0.3, 0.2];
-           
-           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.maneuverTimer = 2 + Math.random() * 3;
-       } else {
-           // 전투 중 기동
-           const combatManeuvers = ['aggressive_turn', 'vertical_loop', 'barrel_roll', 'split_s'];
-           this.maneuverState = combatManeuvers[Math.floor(Math.random() * combatManeuvers.length)];
-           this.maneuverTimer = 1 + Math.random() * 2;
-       }
-   }
-   
-   // 전투 패턴 선택
-   selectCombatPattern(playerPosition, distance) {
-       const angleToPlayer = this.getAngleToTarget(playerPosition);
-       const speedDiff = Math.abs(this.speed - this.playerFighter.speed);
-       
-       // 상황에 따른 전투 패턴 결정
-       if (distance > 2500) {
-           this.combatPattern = 'approach';
-       } else if (distance < 800 && angleToPlayer < Math.PI / 6) {
-           this.combatPattern = 'attack';
-       } else if (distance < 400 || (this.playerFighter && this.isPlayerBehind())) {
-           this.combatPattern = 'evade';
-       } else {
-           this.combatPattern = 'reposition';
-       }
-       
-       this.combatTimer = 0;
-   }
-   
-   // 플레이어가 뒤에 있는지 확인
-   isPlayerBehind() {
-       if (!this.playerFighter) return false;
-       
-       const toPlayer = this.playerFighter.position.clone().sub(this.position).normalize();
-       const forward = new THREE.Vector3(0, 0, 1).applyEuler(this.rotation);
-       const dot = forward.dot(toPlayer);
-       
-       return dot < -0.5; // 120도 이상 뒤에 있으면 true
-   }
-   
-   // 타겟까지의 각도 계산
-   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) {
-       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.traverse((child) => {
-               if (child.isMesh) {
-                   child.castShadow = true;
-                   child.receiveShadow = true;
-               }
-           });
-           
-           this.scene.add(this.mesh);
-           this.isLoaded = true;
-           console.log('MiG-29 적기 로딩 완료');
-       } catch (error) {
-           console.error('MiG-29 모델 로딩 실패:', error);
-           this.createFallbackModel();
-       }
-   }
+    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.bullets = [];
+        this.lastShootTime = 0;
+        
+        // 개선된 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.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;
+            }
+        }
+        
+        // 기동 지속 시간 설정
+        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;
+        }
+    }
+    
+    // 새로운 메서드: 전투 기동 패턴 선택
+    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) {
+        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.traverse((child) => {
+                if (child.isMesh) {
+                    child.castShadow = true;
+                    child.receiveShadow = true;
+                }
+            });
+            
+            this.scene.add(this.mesh);
+            this.isLoaded = true;
+            console.log('MiG-29 적기 로딩 완료');
+        } catch (error) {
+            console.error('MiG-29 모델 로딩 실패:', error);
+            this.createFallbackModel();
+        }
+    }
 
-   createFallbackModel() {
-       const group = new THREE.Group();
-       
-       const fuselageGeometry = new THREE.CylinderGeometry(0.6, 1.0, 8, 8);
-       const fuselageMaterial = new THREE.MeshLambertMaterial({ color: 0x800000 });
-       const fuselage = new THREE.Mesh(fuselageGeometry, fuselageMaterial);
-       fuselage.rotation.x = -Math.PI / 2;
-       group.add(fuselage);
-       
-       const wingGeometry = new THREE.BoxGeometry(12, 0.3, 3);
-       const wingMaterial = new THREE.MeshLambertMaterial({ color: 0x600000 });
-       const wings = new THREE.Mesh(wingGeometry, wingMaterial);
-       wings.position.z = -0.5;
-       group.add(wings);
-       
-       this.mesh = group;
-       this.mesh.position.copy(this.position);
-       this.mesh.scale.set(1.5, 1.5, 1.5);
-       this.scene.add(this.mesh);
-       this.isLoaded = true;
-       
-       console.log('Fallback 적기 모델 생성 완료');
-   }
+    createFallbackModel() {
+        const group = new THREE.Group();
+        
+        const fuselageGeometry = new THREE.CylinderGeometry(0.6, 1.0, 8, 8);
+        const fuselageMaterial = new THREE.MeshLambertMaterial({ color: 0x800000 });
+        const fuselage = new THREE.Mesh(fuselageGeometry, fuselageMaterial);
+        fuselage.rotation.x = -Math.PI / 2;
+        group.add(fuselage);
+        
+        const wingGeometry = new THREE.BoxGeometry(12, 0.3, 3);
+        const wingMaterial = new THREE.MeshLambertMaterial({ color: 0x600000 });
+        const wings = new THREE.Mesh(wingGeometry, wingMaterial);
+        wings.position.z = -0.5;
+        group.add(wings);
+        
+        this.mesh = group;
+        this.mesh.position.copy(this.position);
+        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;
-       
-       // AI 상태 업데이트
-       const distanceToPlayer = this.position.distanceTo(playerPosition);
-       
-       // 전투 거리 체크 (3000m 이내)
-       if (distanceToPlayer < 3000) {
-           if (this.aiState !== 'combat') {
-               this.aiState = 'combat';
-               this.isEngaged = true;
-               console.log('Enemy entering combat mode');
-           }
-       } else if (distanceToPlayer > 5000) {
-           if (this.aiState !== 'patrol') {
-               this.aiState = 'patrol';
-               this.isEngaged = false;
-               this.combatPattern = 'approach';
-               console.log('Enemy returning to patrol');
-           }
-       }
-       
-       // 다른 적기와의 충돌 회피
-       this.avoidOtherEnemies(deltaTime);
-       
-       // 기동 타이머 업데이트
-       this.maneuverTimer -= deltaTime;
-       if (this.maneuverTimer <= 0) {
-           this.selectNewManeuver();
-       }
-       
-       // AI 행동 실행
-       switch (this.aiState) {
-           case 'patrol':
-               this.patrol(deltaTime);
-               break;
-           case 'combat':
-               this.combat(playerPosition, deltaTime);
-               break;
-       }
-       
-       // 물리 업데이트 (플레이어와 유사)
-       this.updatePhysics(deltaTime);
-       
-       // 탄환 업데이트
-       this.updateBullets(deltaTime);
-   }
-   
-   avoidOtherEnemies(deltaTime) {
-       if (!this.nearbyEnemies) return;
-       
-       let avoidanceForce = 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 avoid = this.position.clone().sub(enemy.position).normalize();
-               const strength = (this.separationRadius - distance) / this.separationRadius;
-               avoidanceForce.add(avoid.multiplyScalar(strength));
-               tooClose = true;
-           }
-       });
-       
-       if (tooClose) {
-           // 회피 기동 실행
-           avoidanceForce.normalize();
-           const avoidAngle = Math.atan2(avoidanceForce.x, avoidanceForce.z);
-           this.targetYaw = avoidAngle;
-           
-           // 고도 분리
-           if (avoidanceForce.y > 0.5) {
-               this.targetPitch = -0.2; // 상승
-           } else if (avoidanceForce.y < -0.5) {
-               this.targetPitch = 0.2; // 하강
-           }
-       }
-   }
-   
-   patrol(deltaTime) {
-       // 목표 지점까지의 거리와 방향 계산
-       const toTarget = this.targetPosition.clone().sub(this.position);
-       const distance = toTarget.length();
-       
-       // 목표 도달 확인
-       if (distance < this.arrivalThreshold) {
-           console.log('Enemy reached patrol point, generating new target');
-           this.targetPosition = this.generateRandomTarget();
-           this.selectNewManeuver();
-       }
-       
-       // 목표를 향한 방향 조정
-       if (distance > 0) {
-           toTarget.normalize();
-           
-           // 목표 각도 계산
-           const targetYaw = Math.atan2(toTarget.x, toTarget.z);
-           const targetPitch = Math.asin(-toTarget.y);
-           
-           // 부드러운 회전
-           const yawDiff = this.normalizeAngle(targetYaw - this.rotation.y);
-           const pitchDiff = targetPitch - this.rotation.x;
-           
-           // 기동 상태에 따른 조종
-           switch (this.maneuverState) {
-               case 'straight':
-                   // 목표를 향해 직진
-                   this.targetYaw += yawDiff * deltaTime * 0.5;
-                   this.targetPitch += pitchDiff * deltaTime * 0.3;
-                   this.targetRoll *= 0.9; // 롤 복귀
-                   break;
-                   
-               case 'gentle_turn':
-                   // 부드러운 선회
-                   const turnDirection = Math.sign(yawDiff);
-                   this.targetYaw += turnDirection * deltaTime * 0.8;
-                   this.targetRoll = turnDirection * Math.PI / 6; // 30도 뱅크
-                   break;
-                   
-               case 'altitude_change':
-                   // 고도 변경
-                   if (this.position.y < this.targetPosition.y) {
-                       this.targetPitch = -0.2; // 상승
-                       this.throttle = Math.min(0.9, this.throttle + deltaTime * 0.3);
-                   } else {
-                       this.targetPitch = 0.1; // 하강
-                       this.throttle = Math.max(0.5, this.throttle - deltaTime * 0.2);
-                   }
-                   break;
-           }
-           
-           // 속도 관리
-           if (this.speed < 300) {
-               this.throttle = Math.min(1.0, this.throttle + deltaTime * 0.5);
-           } else if (this.speed > 450) {
-               this.throttle = Math.max(0.3, this.throttle - deltaTime * 0.3);
-           }
-       }
-   }
-   
-   combat(playerPosition, deltaTime) {
-       if (!this.playerFighter) return;
-       
-       const distance = this.position.distanceTo(playerPosition);
-       
-       // 전투 패턴 업���이트
-       this.selectCombatPattern(playerPosition, distance);
-       this.combatTimer += deltaTime;
-       
-       // 예측 사격을 위한 리드 계산
-       const bulletSpeed = 1200;
-       const timeToTarget = distance / bulletSpeed;
-       this.predictedTargetPos = playerPosition.clone().add(
-           this.playerFighter.velocity.clone().multiplyScalar(timeToTarget * 0.8)
-       );
-       
-       // 전투 패턴별 행동
-       switch (this.combatPattern) {
-           case 'approach':
-               this.executeApproach(this.predictedTargetPos, deltaTime);
-               break;
-               
-           case 'attack':
-               this.executeAttack(this.predictedTargetPos, deltaTime, distance);
-               break;
-               
-           case 'evade':
-               this.executeEvasive(deltaTime);
-               break;
-               
-           case 'reposition':
-               this.executeReposition(playerPosition, deltaTime);
-               break;
-       }
-       
-       // 속도 관리
-       this.updateCombatSpeed(deltaTime);
-   }
-   
-   executeApproach(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);
-           
-           const yawDiff = this.normalizeAngle(targetYaw - this.rotation.y);
-           const pitchDiff = targetPitch - this.rotation.x;
-           
-           // 공격적인 접근
-           this.targetYaw += yawDiff * deltaTime * 1.2;
-           this.targetPitch += pitchDiff * deltaTime * 0.8;
-           
-           // 뱅크 턴
-           if (Math.abs(yawDiff) > 0.1) {
-               this.targetRoll = Math.sign(yawDiff) * Math.PI / 4; // 45도 뱅크
-           } else {
-               this.targetRoll *= 0.9;
-           }
-           
-           // 최대 속도로 접근
-           this.throttle = 0.9;
-       }
-   }
-   
-   executeAttack(target, deltaTime, distance) {
-       const toTarget = target.clone().sub(this.position);
-       const angle = this.getAngleToTarget(target);
-       
-       if (distance > 0) {
-           toTarget.normalize();
-           
-           // 정밀 조준
-           const targetYaw = Math.atan2(toTarget.x, toTarget.z);
-           const targetPitch = Math.asin(-toTarget.y);
-           
-           const yawDiff = this.normalizeAngle(targetYaw - this.rotation.y);
-           const pitchDiff = targetPitch - this.rotation.x;
-           
-           // 안정적인 사격 자세
-           this.targetYaw += yawDiff * deltaTime * 1.5;
-           this.targetPitch += pitchDiff * deltaTime * 1.0;
-           this.targetRoll = -yawDiff * 0.3;
-           
-           // 사격 판단
-           if (angle < Math.PI / 12 && distance < 1500) { // 15도 이내, 1500m 이내
-               this.fireWeapon();
-           }
-           
-           // 속도 조절
-           if (distance < 600) {
-               this.throttle = 0.5; // 너무 가까우면 감속
-           } else {
-               this.throttle = 0.8;
-           }
-       }
-   }
-   
-   executeEvasive(deltaTime) {
-       // 방어적 기동
-       const evasiveType = this.combatTimer < 1.5 ? 'break_turn' : 'vertical';
-       
-       if (evasiveType === 'break_turn') {
-           // 급격한 브레이크 턴
-           const direction = Math.sign(this.rotation.z) || 1;
-           this.targetRoll = direction * Math.PI / 2; // 90도 롤
-           this.targetYaw += direction * deltaTime * 2.5;
-           this.targetPitch = 0.1;
-           this.throttle = 0.3; // 급감속
-       } else {
-           // 수직 기동 (Immelmann turn)
-           this.targetPitch = -Math.PI / 3; // 60도 상승
-           this.targetRoll = Math.PI; // 180도 롤
-           this.throttle = 1.0; // 최대 출력
-       }
-       
-       // 3초 후 패턴 변경
-       if (this.combatTimer > 3.0) {
-           this.combatPattern = 'reposition';
-           this.combatTimer = 0;
-       }
-   }
-   
-   executeReposition(playerPosition, deltaTime) {
-       // 유리한 위치 확보
-       const offset = new THREE.Vector3(
-           Math.sin(this.combatTimer) * 1000,
-           500,
-           Math.cos(this.combatTimer) * 1000
-       );
-       
-       const repositionTarget = playerPosition.clone().add(offset);
-       this.executeApproach(repositionTarget, deltaTime);
-       
-       // 에너지 회복
-       this.throttle = 0.8;
-       
-       // 5초 후 재공격
-       if (this.combatTimer > 5.0) {
-           this.combatPattern = 'approach';
-           this.combatTimer = 0;
-       }
-   }
-   
-   updateCombatSpeed(deltaTime) {
-       // 전투 중 속도 관리
-       const minCombatSpeed = 250;
-       const maxCombatSpeed = 500;
-       
-       if (this.speed < minCombatSpeed) {
-           this.throttle = Math.min(1.0, this.throttle + deltaTime * 0.5);
-       } else if (this.speed > maxCombatSpeed) {
-           this.throttle = Math.max(0.3, this.throttle - deltaTime * 0.3);
-       }
-       
-       // G-Force 제한
-       if (this.gForce > 7.0) {
-           // 과도한 G-Force 시 기동 제한
-           this.targetPitch *= 0.8;
-           this.targetRoll *= 0.8;
-       }
-   }
-   
-   fireWeapon() {
-       const now = Date.now();
-       
-       // 연발 제어
-       if (now - this.lastBurstTime > 2000) {
-           this.burstCount = 0;
-           this.lastBurstTime = now;
-       }
-       
-       if (this.burstCount < 5 && now - this.lastShootTime > 150) {
-           this.shoot();
-           this.burstCount++;
-       }
-   }
-   
-   // 각도 정규화
-   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;
-       
-       this.rotation.x = THREE.MathUtils.lerp(this.rotation.x, this.targetPitch, rotationSpeed);
-       this.rotation.y = THREE.MathUtils.lerp(this.rotation.y, this.targetYaw, rotationSpeed);
-       this.rotation.z = THREE.MathUtils.lerp(this.rotation.z, this.targetRoll, rotationSpeed * 1.5);
-       
-       // 롤에 따른 추가 요 회전 (뱅크 턴)
-       if (Math.abs(this.rotation.z) > 0.1 && !this.stallWarning) {
-           const bankAngle = this.rotation.z;
-           const turnRate = Math.sin(bankAngle) * deltaTime * 1.5;
-           this.targetYaw += turnRate;
-       }
-       
-       // 속도 계산 (플레이어와 유사한 물리)
-       const minSpeed = 200; // 최소 속도 200m/s
-       const maxSpeed = 550; // 최대 속도 550m/s
-       let targetSpeed = minSpeed + (maxSpeed - minSpeed) * this.throttle;
-       
-       // 피치 각도에 따른 속도 변화
-       const pitchAngle = this.rotation.x;
-       if (pitchAngle < -0.1) { // 상승
-           const climbFactor = Math.abs(pitchAngle) / (Math.PI / 2);
-           targetSpeed *= (1 - climbFactor * 0.3);
-       } else if (pitchAngle > 0.1) { // 하강
-           const diveFactor = pitchAngle / (Math.PI / 3);
-           targetSpeed *= (1 + diveFactor * 0.4);
-       }
-       
-       // G-Force 계산
-       const turnRate2 = Math.abs(this.targetYaw - this.rotation.y) * 10;
-       const pitchRate = Math.abs(this.targetPitch - this.rotation.x) * 10;
-       this.gForce = 1.0 + turnRate2 + pitchRate + Math.abs(this.rotation.z) * 3;
-       
-       // 스톨 체크
-       const speedKnots = this.speed * 1.94384;
-       if (speedKnots < GAME_CONSTANTS.STALL_SPEED && !this.stallWarning) {
-           this.stallWarning = true;
-       } else if (speedKnots > GAME_CONSTANTS.STALL_SPEED + 50 && this.stallWarning) {
-           this.stallWarning = false;
-       }
-       
-       // 스톨 시 비상 하강
-       if (this.stallWarning) {
-           this.targetPitch = Math.min(Math.PI / 4, this.targetPitch + deltaTime * 1.5);
-           this.rotation.x += (Math.random() - 0.5) * deltaTime * 0.3;
-           this.rotation.z += (Math.random() - 0.5) * deltaTime * 0.3;
-           
-           // 중력 가속
-           this.velocity.y -= GAME_CONSTANTS.GRAVITY * deltaTime * 2.0;
-       }
-       
-       // 속도 변화 적용
-       this.speed = THREE.MathUtils.lerp(this.speed, targetSpeed, deltaTime * 0.5);
-       
-       // 속도 벡터 계산
-       const noseDirection = new THREE.Vector3(0, 0, 1);
-       noseDirection.applyEuler(this.rotation);
-       
-       if (!this.stallWarning) {
-           this.velocity = noseDirection.multiplyScalar(this.speed);
-       } else {
-           // 스톨 시 부분적인 제어만 가능
-           this.velocity.x = noseDirection.x * this.speed * 0.3;
-           this.velocity.z = noseDirection.z * this.speed * 0.3;
-       }
-       
-       // 중력과 양력
-       if (!this.stallWarning) {
-           const gravityEffect = GAME_CONSTANTS.GRAVITY * deltaTime * 0.15;
-           this.velocity.y -= gravityEffect;
-           
-           const liftFactor = (this.speed / maxSpeed) * 0.8;
-           const lift = gravityEffect * liftFactor;
-           this.velocity.y += lift;
-       }
-       
-       // 위치 업데이트
-       this.position.add(this.velocity.clone().multiplyScalar(deltaTime));
-       
-       // 고도 제한
-       if (this.position.y < 200) {
-           this.position.y = 200;
-           this.velocity.y = Math.max(0, this.velocity.y);
-           this.targetPitch = -0.3; // 강제 상승
-       } else if (this.position.y > 10000) {
-           this.position.y = 10000;
-           this.velocity.y = Math.min(0, this.velocity.y);
-       }
-       
-       // 맵 경계 처리
-       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();
-           this.targetYaw = Math.atan2(centerDirection.x, centerDirection.z);
-           this.targetRoll = Math.sign(this.position.x) * Math.PI / 4;
-       }
-       
-       // 하드 리미트
-       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;
-       
-       // 고도 업데이트
-       this.altitude = this.position.y;
-   }
-   
-   shoot() {
-       this.lastShootTime = Date.now();
-       
-       // 직선 모양의 탄환 (100% 더 크게)
-       const bulletGeometry = new THREE.CylinderGeometry(0.8, 0.8, 12, 8);
-       const bulletMaterial = new THREE.MeshBasicMaterial({ 
-           color: 0xff0000,
-           emissive: 0xff0000,
-           emissiveIntensity: 1.0
-       });
-       const bullet = new THREE.Mesh(bulletGeometry, bulletMaterial);
-       
-       // 기수 끝에서 발사
-       const muzzleOffset = new THREE.Vector3(0, 0, 12);
-       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);
-       
-       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);
-               }
-           }
-       }
-   }
+    update(playerPosition, deltaTime) {
+        if (!this.mesh) return;
+        
+        // AI 상태 업데이트
+        const distanceToPlayer = this.position.distanceTo(playerPosition);
+        
+        // 전투 거리 체크 (3000m 이내)
+        if (distanceToPlayer < 3000) {
+            this.aiState = 'combat';
+            this.isEngaged = true;
+            this.targetPosition = playerPosition.clone();
+        } else if (distanceToPlayer > 5000) {
+            this.aiState = 'patrol';
+            this.isEngaged = false;
+            this.combatPattern = 'approach'; // 전투 패턴 리셋
+        }
+        
+        // 다른 적기와의 충돌 회피
+        this.avoidOtherEnemies(deltaTime);
+        
+        // 기동 타이머 업데이트
+        this.maneuverTimer -= deltaTime;
+        if (this.maneuverTimer <= 0 && this.aiState === 'patrol') {
+            this.selectNewManeuver();
+        }
+        
+        // AI 행동 실행
+        switch (this.aiState) {
+            case 'patrol':
+                this.patrol(deltaTime);
+                break;
+            case 'combat':
+                this.combat(playerPosition, deltaTime);
+                break;
+        }
+        
+        // 물리 업데이트
+        this.updatePhysics(deltaTime);
+        
+        // 탄환 업데이트
+        this.updateBullets(deltaTime);
+    }
+    
+    avoidOtherEnemies(deltaTime) {
+        if (!this.nearbyEnemies) return;
+        
+        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) {
+                avoidanceNeeded = true;
+                if (distance < closestDistance) {
+                    closestDistance = distance;
+                    // 반대 방향으로 회피
+                    avoidDirection = this.position.clone().sub(enemy.position).normalize();
+                }
+            }
+        });
+        
+        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;
+    }
+    
+    // 목표 지점에 도달했는지 확인
+    const distanceToTarget = this.position.distanceTo(this.targetPosition);
+    if (distanceToTarget < 500) {
+        // 새로운 목표 생성
+        this.targetPosition = this.generateRandomTarget();
+        this.selectNewManeuver();
+    }
+    
+    // 고도 조정
+    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));
+        } else {
+            this.targetRotation.x = Math.min(0.3, Math.max(0, altitudeDiff * 0.0001));
+        }
+    }
+    
+    // 속도 관리
+    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;
+        }
+        
+        // 속도 관리
+        this.updateSpeedControl(deltaTime);
+    }
+    
+    // 요격 코스 실행
+    executeInterceptCourse(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);
+        
+        // 부드러운 선회를 위한 각도 차이 계산
+        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));
+        } else {
+            this.targetRotation.z *= 0.9; // 롤 복귀
+        }
+        
+        // 목표 방향으로 회전
+        this.targetRotation.y = this.rotation.y + yawDiff * deltaTime * 1.0;
+        this.targetRotation.x = this.rotation.x + pitchDiff * deltaTime * 0.6;
+        
+        // 피치 제한
+        this.targetRotation.x = Math.max(-Math.PI / 4, Math.min(Math.PI / 4, this.targetRotation.x));
+    }
+}
+    
+    // 공격 진입
+    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);
+        
+        // 정밀 조준을 위한 작은 수정
+        const yawDiff = this.normalizeAngle(targetYaw - this.rotation.y);
+        const pitchDiff = targetPitch - this.rotation.x;
+        
+        // 안정적인 사격 자세 유지
+        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;
+        
+        // 속도 조절 - 목표와의 상대 속도 관리
+        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.throttle = 0.3;
+        }
+        
+        // G-Force 시뮬레이션
+        this.currentG = 3.0 + Math.abs(this.rotation.z) * 2;
+    }
+    
+    // 조준 정확도 계산
+    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);
+        const angle = Math.acos(Math.max(-1, Math.min(1, dotProduct)));
+        
+        return angle;
+    }
+    
+    // 무기 발사
+    fireWeapon() {
+        const now = Date.now();
+        if (now - this.lastBurstTime > 2000) {
+            this.burstCount = 0;
+            this.lastBurstTime = now;
+        }
+        
+        if (this.burstCount < 5 && now - this.lastShootTime > 200) {
+            this.shoot();
+            this.burstCount++;
+        }
+    }
+    
+    // 속도 제어
+    updateSpeedControl(deltaTime) {
+        // 목표 속도 계산
+        let targetSpeed = this.optimalSpeed * this.throttle;
+        
+        // 고도에 따른 속도 보정
+        const altitudeFactor = 1 + (this.position.y / 10000) * 0.2;
+        targetSpeed *= altitudeFactor;
+        
+        // 기동에 따른 속도 손실
+        if (this.currentG > 2.0) {
+            targetSpeed *= (1 - (this.currentG - 2.0) * 0.05);
+        }
+        
+        // 부드러운 속도 변화
+        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; // 하강
+    }
+    
+    // 맵 경계 처리 - 부드러운 회귀
+    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;
+        
+        // 경계에서 뱅크 턴
+        if (this.position.x > boundaryBuffer) {
+            this.targetRotation.z = -this.maxBankAngle;
+        } else if (this.position.x < -boundaryBuffer) {
+            this.targetRotation.z = this.maxBankAngle;
+        }
+    }
+    
+    // 하드 리미트
+    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,
+            emissive: 0xff0000,
+            emissiveIntensity: 1.0
+        });
+        const bullet = new THREE.Mesh(bulletGeometry, bulletMaterial);
+        
+        // 기수 끝에서 발사
+        const muzzleOffset = new THREE.Vector3(0, 0, 12);
+        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);
+        
+        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);
+                }
+            }
+        }
+    }
 
-   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);
-               }
-               this.scene.remove(bullet);
-               this.bullets.splice(i, 1);
-               continue;
-           }
-           
-           if (bullet.position.distanceTo(this.position) > 5000) {
-               this.scene.remove(bullet);
-               this.bullets.splice(i, 1);
-           }
-       }
-   }
+    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);
+                }
+                this.scene.remove(bullet);
+                this.bullets.splice(i, 1);
+                continue;
+            }
+            
+            if (bullet.position.distanceTo(this.position) > 5000) {
+                this.scene.remove(bullet);
+                this.bullets.splice(i, 1);
+            }
+        }
+    }
 
-   takeDamage(damage) {
-       this.health -= damage;
-       return this.health <= 0;
-   }
+    takeDamage(damage) {
+        this.health -= damage;
+        return this.health <= 0;
+    }
 
-   destroy() {
-       if (this.mesh) {
-           this.scene.remove(this.mesh);
-           this.bullets.forEach(bullet => this.scene.remove(bullet));
-           this.bullets = [];
-           this.isLoaded = false;
-       }
-   }
+    destroy() {
+        if (this.mesh) {
+            this.scene.remove(this.mesh);
+            this.bullets.forEach(bullet => this.scene.remove(bullet));
+            this.bullets = [];
+            this.isLoaded = false;
+        }
+    }
 }
 
 // 메인 게임 클래스