Update game.js

game.js

@@ -718,730 +718,729 @@ 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.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();
-        }
-    }
+   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();
+       }
+   }
 
-    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) {
-            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);
-                }
-            }
-        }
-    }
+   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);
+               }
+           }
+       }
+   }
 
-    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;
+       }
+   }
 }
 
 // 메인 게임 클래스