Update game.js

game.js

@@ -1382,6 +1382,15 @@ class EnemyFighter {
         
         // 초기 목표 설정
         this.selectNewPatrolTarget();
+        // AIM-9 미사일 시스템
+        this.aim9Missiles = 4; // 적은 4발의 AIM-9 보유
+        this.firedMissiles = [];
+        this.currentWeapon = 'MG'; // 기본 무기
+        this.lockTarget = null;
+        this.lockProgress = 0;
+        this.lastLockTime = 0;
+        this.lastMissileFireTime = 0; // 마지막 미사일 발사 시간
+}
     }
     
     async initialize(loader) {
@@ -1430,11 +1439,11 @@ class EnemyFighter {
         this.isLoaded = true;
     }
     
-    // EnemyFighter 클래스의 update 메서드에서 미사일 회피 로직 제거
+    // EnemyFighter 클래스의 update 메서드 - 미사일 기능 추가
 update(playerPosition, deltaTime) {
     if (!this.mesh || !this.isLoaded) return;
     
-    // 회피 타이머 업데이트 (미사일 회피 제외)
+    // 회피 타이머 업데이트
     if (this.temporaryEvadeMode && this.evadeTimer > 0) {
         this.evadeTimer -= deltaTime;
         if (this.evadeTimer <= 0) {
@@ -1444,7 +1453,39 @@ update(playerPosition, deltaTime) {
     
     const distanceToPlayer = this.position.distanceTo(playerPosition);
     
-    // 상태 결정 (미사일 탐지 제거)
+    // 플레이어의 AIM-9 미사일 감지 및 회피
+    if (this.playerFighter && this.playerFighter.firedMissiles) {
+        for (const missile of this.playerFighter.firedMissiles) {
+            if (!missile || !missile.target) continue;
+            
+            // 이 적기를 타겟으로 하는 미사일 감지
+            if (missile.target === this && missile.position) {
+                const missileDistance = this.position.distanceTo(missile.position);
+                
+                // 1500m 이내의 미사일 감지 시 긴급 회피
+                if (missileDistance < 1500) {
+                    this.aiState = 'evade';
+                    this.temporaryEvadeMode = true;
+                    this.evadeTimer = 3.0; // 3초간 회피 기동
+                    
+                    // 미사일 반대 방향으로 회피
+                    const evadeDirection = this.position.clone().sub(missile.position).normalize();
+                    this.targetPosition = this.position.clone().add(evadeDirection.multiplyScalar(2000));
+                    
+                    // 고도 변화 추가
+                    if (this.position.y > 3000) {
+                        this.targetPosition.y -= 1000; // 급하강
+                    } else {
+                        this.targetPosition.y += 1000; // 급상승
+                    }
+                    
+                    break; // 하나의 미사일만 회피
+                }
+            }
+        }
+    }
+    
+    // 상태 결정
     if (this.temporaryEvadeMode) {
         this.aiState = 'evade';
     } else if (distanceToPlayer <= 3000) {
@@ -1475,31 +1516,48 @@ update(playerPosition, deltaTime) {
     
     // 탄환 업데이트
     this.updateBullets(deltaTime);
+    
+    // AIM-9 미사일 업데이트
+    this.updateMissiles(deltaTime);
+    
+    // 락온 업데이트 (전투 상태에서만)
+    if (this.aiState === 'combat' && this.playerFighter) {
+        this.updateLockOn(deltaTime);
+    }
 }
+
+executePatrol(deltaTime) {
+    // 목표 지점까지의 거리 확인
+    if (!this.targetPosition || this.position.distanceTo(this.targetPosition) < 500) {
+        this.selectNewPatrolTarget();
+    }
     
-    executePatrol(deltaTime) {
-        // 목표 지점까지의 거리 확인
-        if (!this.targetPosition || this.position.distanceTo(this.targetPosition) < 500) {
-            this.selectNewPatrolTarget();
-        }
-        
-        // 목표를 향해 부드럽게 회전
-        this.smoothTurnToTarget(this.targetPosition, deltaTime);
-        
-        // 속도 유지 (500-750kt) - 항상 최소 속도 이상 유지
-        if (this.speed < this.minSpeed) {
-            this.speed = this.minSpeed;
-        }
-        this.speed = THREE.MathUtils.clamp(this.speed, this.minSpeed, this.maxSpeed);
+    // 목표를 향해 부드럽게 회전
+    this.smoothTurnToTarget(this.targetPosition, deltaTime);
+    
+    // 속도 유지 (500-750kt) - 항상 최소 속도 이상 유지
+    if (this.speed < this.minSpeed) {
+        this.speed = this.minSpeed;
     }
+    this.speed = THREE.MathUtils.clamp(this.speed, this.minSpeed, this.maxSpeed);
+}
+
+executeCombat(playerPosition, deltaTime) {
+    const distance = this.position.distanceTo(playerPosition);
     
-    executeCombat(playerPosition, deltaTime) {
-        const distance = this.position.distanceTo(playerPosition);
-        
-        
-        // 플레이어를 향해 회전
-        this.smoothTurnToTarget(playerPosition, deltaTime);
-        
+    // 무기 선택 로직
+    if (distance > 1500 && distance < 5000 && this.aim9Missiles > 0) {
+        // 중거리에서 AIM-9 사용
+        this.currentWeapon = 'AIM9';
+    } else {
+        // 근거리 또는 미사일 없을 때 MG 사용
+        this.currentWeapon = 'MG';
+    }
+    
+    // 플레이어를 향해 회전
+    this.smoothTurnToTarget(playerPosition, deltaTime);
+    
+    if (this.currentWeapon === 'MG') {
         // 조준 정확도 확인
         const aimAccuracy = this.calculateAimAccuracy(playerPosition);
         
@@ -1518,122 +1576,74 @@ update(playerPosition, deltaTime) {
             // 발사할 수 없으면 연발 카운터 리셋
             this.burstCounter = 0;
         }
-        
-        // 거리에 따라 기동 결정
-        if (distance < 150) {
-            // 150m 이내면 회피 기동 시작
-            this.selectEvadeTarget();
-            // 일시적 회피 모드 활성화
-            this.temporaryEvadeMode = true;
-            this.evadeTimer = 1.0;
-        } else if (distance < 500) {
-            // 500m 이내면 측면 회피
-            this.selectEvadeTarget();
-        } else if (distance > 2000) {
-            // 멀면 접근
-            this.targetPosition = playerPosition.clone();
-        }
     }
+    // AIM-9 모드에서는 락온만 시도 (발사는 updateLockOn에서 처리)
     
-    // 새로운 메서드: 충돌 예측
-    checkCollisionPrediction(deltaTime) {
-        if (!this.nearbyEnemies) return;
-        
-        // 2초 후 예상 위치 계산
-        const predictTime = 2.0;
-        const forward = new THREE.Vector3(0, 0, 1).applyEuler(this.rotation);
-        this.predictedPosition.copy(this.position).add(forward.multiplyScalar(this.speed * predictTime));
-        
-        this.nearbyEnemies.forEach(enemy => {
-            if (enemy === this || !enemy.position) return;
-            
-            // 다른 적기의 예상 위치
-            const enemyForward = new THREE.Vector3(0, 0, 1).applyEuler(enemy.rotation);
-            const enemyPredicted = enemy.position.clone().add(enemyForward.multiplyScalar(enemy.speed * predictTime));
-            
-            // 예상 거리
-            const predictedDistance = this.predictedPosition.distanceTo(enemyPredicted);
-            
-            // 150m 이내로 접근 예상 시 사전 회피
-            if (predictedDistance < 150) {
-                // 예방적 회피 방향 설정
-                const avoidDir = this.predictedPosition.clone().sub(enemyPredicted).normalize();
-                
-                // 수직 분리 추가
-                if (this.position.y > enemy.position.y) {
-                    avoidDir.y += 0.3;
-                } else {
-                    avoidDir.y -= 0.3;
-                }
-                
-                this.avoidanceVector.add(avoidDir.multiplyScalar(1.5));
-            }
-        });
+    // 거리에 따라 기동 결정
+    if (distance < 150) {
+        // 150m 이내면 회피 기동 시작
+        this.selectEvadeTarget();
+        // 일시적 회피 모드 활성화
+        this.temporaryEvadeMode = true;
+        this.evadeTimer = 1.0;
+    } else if (distance < 500) {
+        // 500m 이내면 측면 회피
+        this.selectEvadeTarget();
+    } else if (distance > 2000 && this.currentWeapon === 'MG') {
+        // MG 모드에서만 접근
+        this.targetPosition = playerPosition.clone();
     }
+}
+
+// 새로운 메서드: 충돌 예측
+checkCollisionPrediction(deltaTime) {
+    if (!this.nearbyEnemies) return;
     
-    // 새로운 메서드: 긴급 회피 실행
-    executeEmergencyEvade(deltaTime) {
-        // 회피 벡터가 있으면 그 방향으로, 없으면 급상승
-        if (this.avoidanceVector.length() > 0) {
-            const evadeDirection = this.avoidanceVector.clone().normalize();
-            
-            // 급선회
-            const targetYaw = Math.atan2(evadeDirection.x, evadeDirection.z);
-            const targetPitch = Math.asin(-evadeDirection.y) * 0.5; // 피치는 절반만
-            
-            // 빠른 회전 속도
-            const emergencyTurnSpeed = this.turnSpeed * 2.0;
-            const maxTurnRate = emergencyTurnSpeed * deltaTime;
-            
-            // Yaw 회전
-            const yawDiff = this.normalizeAngle(targetYaw - this.rotation.y);
-            if (Math.abs(yawDiff) > maxTurnRate) {
-                this.rotation.y += Math.sign(yawDiff) * maxTurnRate;
-            } else {
-                this.rotation.y = targetYaw;
-            }
-            
-            // Pitch 회전
-            const pitchDiff = targetPitch - this.rotation.x;
-            if (Math.abs(pitchDiff) > maxTurnRate * 0.7) {
-                this.rotation.x += Math.sign(pitchDiff) * maxTurnRate * 0.7;
-            } else {
-                this.rotation.x = targetPitch;
-            }
-            
-            // 급선회 시 약간의 롤 추가
-            this.rotation.z = Math.sign(yawDiff) * Math.min(Math.abs(yawDiff), Math.PI / 6);
-        } else {
-            // 기본 회피: 급상승
-            this.rotation.x = -Math.PI / 6; // 30도 상승
-        }
-        
-        // 회피 중에는 최대 속도
-        this.speed = this.maxSpeed;
-    }
+    // 2초 후 예상 위치 계산
+    const predictTime = 2.0;
+    const forward = new THREE.Vector3(0, 0, 1).applyEuler(this.rotation);
+    this.predictedPosition.copy(this.position).add(forward.multiplyScalar(this.speed * predictTime));
     
-    smoothTurnToTarget(targetPos, deltaTime, isEmergency = false) {
+    this.nearbyEnemies.forEach(enemy => {
+        if (enemy === this || !enemy.position) return;
         
+        // 다른 적기의 예상 위치
+        const enemyForward = new THREE.Vector3(0, 0, 1).applyEuler(enemy.rotation);
+        const enemyPredicted = enemy.position.clone().add(enemyForward.multiplyScalar(enemy.speed * predictTime));
         
-        // 기존 로직 (후퇴가 아닐 때)
-        const direction = targetPos.clone().sub(this.position);
-        direction.y *= 0.5;
-        direction.normalize();
+        // 예상 거리
+        const predictedDistance = this.predictedPosition.distanceTo(enemyPredicted);
         
-        // 충돌 회피 벡터 적용 (회피가 우선)
-        if (this.avoidanceVector.length() > 0) {
-            const avoidanceStrength = this.temporaryEvadeMode ? 1.0 : 0.5;
-            direction.add(this.avoidanceVector.multiplyScalar(avoidanceStrength));
-            direction.normalize();
+        // 150m 이내로 접근 예상 시 사전 회피
+        if (predictedDistance < 150) {
+            // 예방적 회피 방향 설정
+            const avoidDir = this.predictedPosition.clone().sub(enemyPredicted).normalize();
+            
+            // 수직 분리 추가
+            if (this.position.y > enemy.position.y) {
+                avoidDir.y += 0.3;
+            } else {
+                avoidDir.y -= 0.3;
+            }
+            
+            this.avoidanceVector.add(avoidDir.multiplyScalar(1.5));
         }
+    });
+}
+
+// 새로운 메서드: 긴급 회피 실행
+executeEmergencyEvade(deltaTime) {
+    // 회피 벡터가 있으면 그 방향으로, 없으면 급상승
+    if (this.avoidanceVector.length() > 0) {
+        const evadeDirection = this.avoidanceVector.clone().normalize();
         
-        // 목표 회전 계산
-        const targetYaw = Math.atan2(direction.x, direction.z);
-        const targetPitch = Math.asin(-direction.y);
+        // 급선회
+        const targetYaw = Math.atan2(evadeDirection.x, evadeDirection.z);
+        const targetPitch = Math.asin(-evadeDirection.y) * 0.5; // 피치는 절반만
         
-        // 부드러운 회전 (최대 회전 속도 제한)
-        const turnSpeed = isEmergency ? this.turnSpeed * 2.0 : (this.temporaryEvadeMode ? this.turnSpeed * 1.5 : this.turnSpeed);
-        const maxTurnRate = turnSpeed * deltaTime;
+        // 빠른 회전 속도
+        const emergencyTurnSpeed = this.turnSpeed * 2.0;
+        const maxTurnRate = emergencyTurnSpeed * deltaTime;
         
         // Yaw 회전
         const yawDiff = this.normalizeAngle(targetYaw - this.rotation.y);
@@ -1643,132 +1653,181 @@ update(playerPosition, deltaTime) {
             this.rotation.y = targetYaw;
         }
         
-        // Pitch 회전 (제한적)
-        const maxPitchRate = maxTurnRate * 0.7;
-        if (Math.abs(targetPitch - this.rotation.x) > maxPitchRate) {
-            this.rotation.x += Math.sign(targetPitch - this.rotation.x) * maxPitchRate;
+        // Pitch 회전
+        const pitchDiff = targetPitch - this.rotation.x;
+        if (Math.abs(pitchDiff) > maxTurnRate * 0.7) {
+            this.rotation.x += Math.sign(pitchDiff) * maxTurnRate * 0.7;
         } else {
             this.rotation.x = targetPitch;
         }
         
-        // Pitch 제한 (±40도)
-        const maxPitchAngle = Math.PI * 40 / 180;
-        this.rotation.x = THREE.MathUtils.clamp(this.rotation.x, -maxPitchAngle, maxPitchAngle);
-        
-        // 롤 자동 계산 (선회 시)
-        if (!this.temporaryEvadeMode) {
-            this.rotation.z = -yawDiff * 0.5;
-            this.rotation.z = THREE.MathUtils.clamp(this.rotation.z, -Math.PI / 4, Math.PI / 4);
-        }
+        // 급선회 시 약간의 롤 추가
+        this.rotation.z = Math.sign(yawDiff) * Math.min(Math.abs(yawDiff), Math.PI / 6);
+    } else {
+        // 기본 회피: 급상승
+        this.rotation.x = -Math.PI / 6; // 30도 상승
     }
     
-    calculateAvoidance() {
-        this.avoidanceVector.set(0, 0, 0);
-        
-        if (!this.nearbyEnemies) return;
+    // 회피 중에는 최대 속도
+    this.speed = this.maxSpeed;
+}
+
+smoothTurnToTarget(targetPos, deltaTime, isEmergency = false) {
+    // 기존 로직 (후퇴가 아닐 때)
+    const direction = targetPos.clone().sub(this.position);
+    direction.y *= 0.5;
+    direction.normalize();
+    
+    // 충돌 회피 벡터 적용 (회피가 우선)
+    if (this.avoidanceVector.length() > 0) {
+        const avoidanceStrength = this.temporaryEvadeMode ? 1.0 : 0.5;
+        direction.add(this.avoidanceVector.multiplyScalar(avoidanceStrength));
+        direction.normalize();
+    }
+    
+    // 목표 회전 계산
+    const targetYaw = Math.atan2(direction.x, direction.z);
+    const targetPitch = Math.asin(-direction.y);
+    
+    // 부드러운 회전 (최대 회전 속도 제한)
+    const turnSpeed = isEmergency ? this.turnSpeed * 2.0 : (this.temporaryEvadeMode ? this.turnSpeed * 1.5 : this.turnSpeed);
+    const maxTurnRate = turnSpeed * deltaTime;
+    
+    // Yaw 회전
+    const yawDiff = this.normalizeAngle(targetYaw - this.rotation.y);
+    if (Math.abs(yawDiff) > maxTurnRate) {
+        this.rotation.y += Math.sign(yawDiff) * maxTurnRate;
+    } else {
+        this.rotation.y = targetYaw;
+    }
+    
+    // Pitch 회전 (제한적)
+    const maxPitchRate = maxTurnRate * 0.7;
+    if (Math.abs(targetPitch - this.rotation.x) > maxPitchRate) {
+        this.rotation.x += Math.sign(targetPitch - this.rotation.x) * maxPitchRate;
+    } else {
+        this.rotation.x = targetPitch;
+    }
+    
+    // Pitch 제한 (±40도)
+    const maxPitchAngle = Math.PI * 40 / 180;
+    this.rotation.x = THREE.MathUtils.clamp(this.rotation.x, -maxPitchAngle, maxPitchAngle);
+    
+    // 롤 자동 계산 (선회 시)
+    if (!this.temporaryEvadeMode) {
+        this.rotation.z = -yawDiff * 0.5;
+        this.rotation.z = THREE.MathUtils.clamp(this.rotation.z, -Math.PI / 4, Math.PI / 4);
+    }
+}
+
+calculateAvoidance() {
+    this.avoidanceVector.set(0, 0, 0);
+    
+    if (!this.nearbyEnemies) return;
+    
+    let avoidCount = 0;
+    let criticalAvoidance = false;
+    
+    this.nearbyEnemies.forEach(enemy => {
+        if (enemy === this || !enemy.position) return;
         
-        let avoidCount = 0;
-        let criticalAvoidance = false;
+        const distance = this.position.distanceTo(enemy.position);
         
-        this.nearbyEnemies.forEach(enemy => {
-            if (enemy === this || !enemy.position) return;
+        // 100m 미만: 긴급 회피
+        if (distance < 100 && distance > 0) {
+            criticalAvoidance = true;
             
-            const distance = this.position.distanceTo(enemy.position);
+            // 강한 반발력
+            const avoidDir = this.position.clone().sub(enemy.position).normalize();
+            const strength = 2.0; // 매우 강한 회피
+            this.avoidanceVector.add(avoidDir.multiplyScalar(strength));
             
-            // 100m 미만: 긴급 회피
-            if (distance < 100 && distance > 0) {
-                criticalAvoidance = true;
-                
-                // 강한 반발력
-                const avoidDir = this.position.clone().sub(enemy.position).normalize();
-                const strength = 2.0; // 매우 강한 회피
-                this.avoidanceVector.add(avoidDir.multiplyScalar(strength));
-                
-                // 고도 차이 추가 (위/아래로 분산)
-                if (this.position.y > enemy.position.y) {
-                    this.avoidanceVector.y += 0.5; // 위로
-                } else {
-                    this.avoidanceVector.y -= 0.5; // 아래로
-                }
-                
-                avoidCount++;
-            }
-            // 100-300m: 예방적 회피
-            else if (distance < 300) {
-                // 반대 방향으로 회피
-                const avoidDir = this.position.clone().sub(enemy.position).normalize();
-                const strength = (300 - distance) / 200; // 100-300m 범위에서 강도 계산
-                this.avoidanceVector.add(avoidDir.multiplyScalar(strength));
-                avoidCount++;
+            // 고도 차이 추가 (위/아래로 분산)
+            if (this.position.y > enemy.position.y) {
+                this.avoidanceVector.y += 0.5; // 위로
+            } else {
+                this.avoidanceVector.y -= 0.5; // 아래로
             }
-        });
-        
-        if (avoidCount > 0) {
-            this.avoidanceVector.divideScalar(avoidCount);
-            this.avoidanceVector.normalize();
             
-            // 긴급 회피 시 더 강한 회피력 적용
-            if (criticalAvoidance) {
-                this.avoidanceVector.multiplyScalar(2.0);
-                // 일시적으로 전투 상태 해제
-                this.temporaryEvadeMode = true;
-                this.evadeTimer = 2.0; // 2초 동안 회피 우선
-            }
-        }
-    }
-    
-    updatePhysics(deltaTime) {
-        if (!this.mesh) return;
-        
-        // 속도 벡터 계산 (항상 전진)
-        const forward = new THREE.Vector3(0, 0, 1);
-        forward.applyEuler(this.rotation);
-        
-        // 속도 유지 (500-750kt, m/s로 변환) - 강제로 최소 속도 유지
-        if (this.speed < this.minSpeed) {
-            this.speed = this.minSpeed;
+            avoidCount++;
         }
-        this.speed = THREE.MathUtils.clamp(this.speed, this.minSpeed, this.maxSpeed);
-        
-        // 속도 벡터 생성 - 항상 전진
-        this.velocity = forward.multiplyScalar(this.speed);
-        
-        // 위치 업데이트 - 항상 이동
-        this.position.add(this.velocity.clone().multiplyScalar(deltaTime));
-        
-        // 고도 제한
-        if (this.position.y < 500) {
-            this.position.y = 500;
-            this.rotation.x = -0.2; // 상승
-        } else if (this.position.y > 8000) {
-            this.position.y = 8000;
-            this.rotation.x = 0.2; // 하강
+        // 100-300m: 예방적 회피
+        else if (distance < 300) {
+            // 반대 방향으로 회피
+            const avoidDir = this.position.clone().sub(enemy.position).normalize();
+            const strength = (300 - distance) / 200; // 100-300m 범위에서 강도 계산
+            this.avoidanceVector.add(avoidDir.multiplyScalar(strength));
+            avoidCount++;
         }
-        
-        // 맵 경계 처리
-        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.rotation.y = targetYaw;
-            this.selectNewPatrolTarget(); // 새로운 목표 선택
+    });
+    
+    if (avoidCount > 0) {
+        this.avoidanceVector.divideScalar(avoidCount);
+        this.avoidanceVector.normalize();
+        
+        // 긴급 회피 시 더 강한 회피력 적용
+        if (criticalAvoidance) {
+            this.avoidanceVector.multiplyScalar(2.0);
+            // 일시적으로 전투 상태 해제
+            this.temporaryEvadeMode = true;
+            this.evadeTimer = 2.0; // 2초 동안 회피 우선
         }
-        
-        // 하드 리미트
-        this.position.x = THREE.MathUtils.clamp(this.position.x, -mapLimit, mapLimit);
-        this.position.z = THREE.MathUtils.clamp(this.position.z, -mapLimit, mapLimit);
-        
-        // 메시 업데이트
-        this.mesh.position.copy(this.position);
-        this.mesh.rotation.x = this.rotation.x;
-        this.mesh.rotation.y = this.rotation.y + 3 * Math.PI / 2; // 플레이어와 동일한 회전 오프셋
-        this.mesh.rotation.z = this.rotation.z;
+    }
+}
+
+updatePhysics(deltaTime) {
+    if (!this.mesh) return;
+    
+    // 속도 벡터 계산 (항상 전진)
+    const forward = new THREE.Vector3(0, 0, 1);
+    forward.applyEuler(this.rotation);
+    
+    // 속도 유지 (500-750kt, m/s로 변환) - 강제로 최소 속도 유지
+    if (this.speed < this.minSpeed) {
+        this.speed = this.minSpeed;
+    }
+    this.speed = THREE.MathUtils.clamp(this.speed, this.minSpeed, this.maxSpeed);
+    
+    // 속도 벡터 생성 - 항상 전진
+    this.velocity = forward.multiplyScalar(this.speed);
+    
+    // 위치 업데이트 - 항상 이동
+    this.position.add(this.velocity.clone().multiplyScalar(deltaTime));
+    
+    // 고도 제한
+    if (this.position.y < 500) {
+        this.position.y = 500;
+        this.rotation.x = -0.2; // 상승
+    } else if (this.position.y > 8000) {
+        this.position.y = 8000;
+        this.rotation.x = 0.2; // 하강
     }
     
-    fireWeapon() {
+    // 맵 경계 처리
+    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.rotation.y = targetYaw;
+        this.selectNewPatrolTarget(); // 새로운 목표 선택
+    }
+    
+    // 하드 리미트
+    this.position.x = THREE.MathUtils.clamp(this.position.x, -mapLimit, mapLimit);
+    this.position.z = THREE.MathUtils.clamp(this.position.z, -mapLimit, mapLimit);
+    
+    // 메시 업데이트
+    this.mesh.position.copy(this.position);
+    this.mesh.rotation.x = this.rotation.x;
+    this.mesh.rotation.y = this.rotation.y + 3 * Math.PI / 2; // 플레이어와 동일한 회전 오프셋
+    this.mesh.rotation.z = this.rotation.z;
+}
+
+fireWeapon() {
+    if (this.currentWeapon === 'MG') {
         const now = Date.now();
         
         // 0.1초에 1발씩, 10발 연발
@@ -1790,119 +1849,227 @@ update(playerPosition, deltaTime) {
             }
         }
     }
+    // AIM-9는 updateLockOn에서 자동 발사
+}
+
+shoot() {
+    // 탄환 생성 (플레이어와 동일한 크기)
+    const bulletGeometry = new THREE.CylinderGeometry(1.0, 1.0, 16, 8);
+    const bulletMaterial = new THREE.MeshBasicMaterial({ 
+        color: 0xff0000,
+    });
+    const bullet = new THREE.Mesh(bulletGeometry, bulletMaterial);
     
-    shoot() {
-        // 탄환 생성 (플레이어와 동일한 크기)
-        const bulletGeometry = new THREE.CylinderGeometry(1.0, 1.0, 16, 8);
-        const bulletMaterial = new THREE.MeshBasicMaterial({ 
-            color: 0xff0000,
-        });
-        const bullet = new THREE.Mesh(bulletGeometry, bulletMaterial);
-        
-        // 기수 끝에서만 발사 - 정확히 전방 중앙에서
-        const muzzleOffset = new THREE.Vector3(0, 0, 10); // X=0, Y=0으로 중앙 고정
-        muzzleOffset.applyEuler(this.rotation);
-        bullet.position.copy(this.position).add(muzzleOffset);
-        
-        // 탄환을 발사 방향으로 회전
-        bullet.rotation.copy(this.rotation);
-        bullet.rotateX(Math.PI / 2); // 실린더가 Z축 방향을 향하도록
-        
-        // 탄환 초기 위치 저장
-        bullet.startPosition = bullet.position.clone();
-        
-        // 탄환 속도 (플레이어와 동일하게 1500) - 정확히 전방으로
-        const direction = new THREE.Vector3(0, 0, 1);
-        direction.applyEuler(this.rotation);
-        bullet.velocity = direction.multiplyScalar(1500);
-        
-        this.scene.add(bullet);
-        this.bullets.push(bullet);
-        
-        // 사운드 재생
-        if (this.playerFighter) {
-            const distanceToPlayer = this.position.distanceTo(this.playerFighter.position);
-            if (distanceToPlayer < 3000) {
-                try {
-                    const audio = new Audio('sounds/MGLAUNCH.ogg');
-                    const volumeMultiplier = 1 - (distanceToPlayer / 3000);
-                    audio.volume = 0.5 * volumeMultiplier;
-                    audio.play().catch(e => {});
-                } catch (e) {}
+    // 기수 끝에서만 발사 - 정확히 전방 중앙에서
+    const muzzleOffset = new THREE.Vector3(0, 0, 10); // X=0, Y=0으로 중앙 고정
+    muzzleOffset.applyEuler(this.rotation);
+    bullet.position.copy(this.position).add(muzzleOffset);
+    
+    // 탄환을 발사 방향으로 회전
+    bullet.rotation.copy(this.rotation);
+    bullet.rotateX(Math.PI / 2); // 실린더가 Z축 방향을 향하도록
+    
+    // 탄환 초기 위치 저장
+    bullet.startPosition = bullet.position.clone();
+    
+    // 탄환 속도 (플레이어와 동일하게 1500) - 정확히 전방으로
+    const direction = new THREE.Vector3(0, 0, 1);
+    direction.applyEuler(this.rotation);
+    bullet.velocity = direction.multiplyScalar(1500);
+    
+    this.scene.add(bullet);
+    this.bullets.push(bullet);
+    
+    // 사운드 재생
+    if (this.playerFighter) {
+        const distanceToPlayer = this.position.distanceTo(this.playerFighter.position);
+        if (distanceToPlayer < 3000) {
+            try {
+                const audio = new Audio('sounds/MGLAUNCH.ogg');
+                const volumeMultiplier = 1 - (distanceToPlayer / 3000);
+                audio.volume = 0.5 * volumeMultiplier;
+                audio.play().catch(e => {});
+            } catch (e) {}
+        }
+    }
+}
+
+updateBullets(deltaTime) {
+    for (let i = this.bullets.length - 1; i >= 0; i--) {
+        const bullet = this.bullets[i];
+        bullet.position.add(bullet.velocity.clone().multiplyScalar(deltaTime));
+        
+        // 지면 충돌
+        if (bullet.position.y <= 0) {
+            if (window.gameInstance) {
+                window.gameInstance.createGroundImpactEffect(bullet.position);
             }
+            this.scene.remove(bullet);
+            this.bullets.splice(i, 1);
+            continue;
+        }
+        
+        // 거리 제한 (플레이어와 동일하게 6000m)
+        if (bullet.position.distanceTo(bullet.startPosition) > 6000 || 
+            bullet.position.y > GAME_CONSTANTS.MAX_ALTITUDE + 500) {
+            this.scene.remove(bullet);
+            this.bullets.splice(i, 1);
         }
     }
+}
+
+// 적기용 AIM-9 락온 시스템
+updateLockOn(deltaTime) {
+    if (!this.playerFighter || this.currentWeapon !== 'AIM9') {
+        this.lockTarget = null;
+        this.lockProgress = 0;
+        return;
+    }
     
-    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) {
+    const now = Date.now();
+    if (now - this.lastLockTime < 1000) return;
+    
+    const distance = this.position.distanceTo(this.playerFighter.position);
+    
+    // 거리와 각도 체크
+    if (distance < GAME_CONSTANTS.AIM9_LOCK_RANGE) {
+        const toPlayer = this.playerFighter.position.clone().sub(this.position).normalize();
+        const forward = new THREE.Vector3(0, 0, 1).applyEuler(this.rotation);
+        const dotProduct = forward.dot(toPlayer);
+        const angle = Math.acos(Math.max(-1, Math.min(1, dotProduct)));
+        
+        // 15도 이내에 있으면 락온
+        if (angle < Math.PI / 12) {
+            if (this.lockTarget === this.playerFighter) {
+                this.lockProgress++;
+                this.lastLockTime = now;
+                
+                // 락온 시작 시 플레이어에게 경고
+                if (this.lockProgress === 1 && window.gameInstance) {
+                    window.gameInstance.onEnemyLockStart(this);
+                }
+                
+                // 락온 완료 시 미사일 발사
+                if (this.lockProgress >= GAME_CONSTANTS.AIM9_LOCK_REQUIRED) {
+                    this.fireMissile();
+                }
+            } else {
+                // 새로운 락온 시작
+                this.lockTarget = this.playerFighter;
+                this.lockProgress = 1;
+                this.lastLockTime = now;
+                
                 if (window.gameInstance) {
-                    window.gameInstance.createGroundImpactEffect(bullet.position);
+                    window.gameInstance.onEnemyLockStart(this);
                 }
-                this.scene.remove(bullet);
-                this.bullets.splice(i, 1);
-                continue;
             }
-            
-            // 거리 제한 (플레이어와 동일하게 6000m)
-            if (bullet.position.distanceTo(bullet.startPosition) > 6000 || 
-                bullet.position.y > GAME_CONSTANTS.MAX_ALTITUDE + 500) {
-                this.scene.remove(bullet);
-                this.bullets.splice(i, 1);
+        } else {
+            // 타겟 잃음
+            if (this.lockTarget && window.gameInstance) {
+                window.gameInstance.onEnemyLockLost(this);
             }
+            this.lockTarget = null;
+            this.lockProgress = 0;
         }
+    } else {
+        // 범위 밖
+        if (this.lockTarget && window.gameInstance) {
+            window.gameInstance.onEnemyLockLost(this);
+        }
+        this.lockTarget = null;
+        this.lockProgress = 0;
     }
+}
+
+// 적기 미사일 발사
+fireMissile() {
+    if (this.aim9Missiles <= 0 || !this.lockTarget) return;
     
-    calculateAimAccuracy(target) {
-        const toTarget = target.clone().sub(this.position).normalize();
-        const forward = new THREE.Vector3(0, 0, 1).applyEuler(this.rotation);
-        const dotProduct = forward.dot(toTarget);
-        return Math.acos(Math.max(-1, Math.min(1, dotProduct)));
-    }
+    const now = Date.now();
+    // 미사일 발사 간격 최소 5초
+    if (now - this.lastMissileFireTime < 5000) return;
     
-    selectNewPatrolTarget() {
-        const mapLimit = GAME_CONSTANTS.MAP_SIZE / 2 * 0.7;
-        
-        // 더 다양한 고도 선택
-        const minAltitude = 1000;
-        const maxAltitude = 6000;
-        
-        this.targetPosition = new THREE.Vector3(
-            (Math.random() - 0.5) * 2 * mapLimit,
-            minAltitude + Math.random() * (maxAltitude - minAltitude),
-            (Math.random() - 0.5) * 2 * mapLimit
-        );
-    }
+    this.aim9Missiles--;
+    this.lastMissileFireTime = now;
     
-    selectEvadeTarget() {
-        // 현재 위치에서 랜덤 방향으로 회피
-        const evadeDistance = 1000 + Math.random() * 1000;
-        const evadeAngle = Math.random() * Math.PI * 2;
-        
-        this.targetPosition = new THREE.Vector3(
-            this.position.x + Math.cos(evadeAngle) * evadeDistance,
-            this.position.y + (Math.random() - 0.5) * 500,
-            this.position.z + Math.sin(evadeAngle) * evadeDistance
-        );
-        
-        // 맵 경계 확인
-        const mapLimit = GAME_CONSTANTS.MAP_SIZE / 2 * 0.8;
-        this.targetPosition.x = THREE.MathUtils.clamp(this.targetPosition.x, -mapLimit, mapLimit);
-        this.targetPosition.z = THREE.MathUtils.clamp(this.targetPosition.z, -mapLimit, mapLimit);
-        this.targetPosition.y = THREE.MathUtils.clamp(this.targetPosition.y, 1000, 6000);
-    }
+    // 날개 위치에서 발사
+    const isLeftWing = Math.random() < 0.5;
+    const wingOffset = new THREE.Vector3(isLeftWing ? -6 : 6, -0.5, 1);
+    wingOffset.applyEuler(this.rotation);
+    const missileStartPos = this.position.clone().add(wingOffset);
+    
+    // 적기용 AIM-9 미사일 생성
+    const missile = new EnemyAIM9Missile(this.scene, missileStartPos, this.lockTarget, this.rotation.clone());
+    this.firedMissiles.push(missile);
     
-    normalizeAngle(angle) {
-        while (angle > Math.PI) angle -= Math.PI * 2;
-        while (angle < -Math.PI) angle += Math.PI * 2;
-        return angle;
+    // 락온 초기화
+    this.lockTarget = null;
+    this.lockProgress = 0;
+    
+    // 플레이어에게 미사일 발사 경고
+    if (window.gameInstance) {
+        window.gameInstance.onEnemyMissileLaunch(this, missile);
+    }
+}
+
+// 미사일 업데이트
+updateMissiles(deltaTime) {
+    for (let i = this.firedMissiles.length - 1; i >= 0; i--) {
+        const missile = this.firedMissiles[i];
+        const result = missile.update(deltaTime, this.position);
+        
+        if (result === 'hit' || result === 'expired') {
+            this.firedMissiles.splice(i, 1);
+        }
     }
+}
+
+calculateAimAccuracy(target) {
+    const toTarget = target.clone().sub(this.position).normalize();
+    const forward = new THREE.Vector3(0, 0, 1).applyEuler(this.rotation);
+    const dotProduct = forward.dot(toTarget);
+    return Math.acos(Math.max(-1, Math.min(1, dotProduct)));
+}
+
+selectNewPatrolTarget() {
+    const mapLimit = GAME_CONSTANTS.MAP_SIZE / 2 * 0.7;
     
-   takeDamage(damage) {
+    // 더 다양한 고도 선택
+    const minAltitude = 1000;
+    const maxAltitude = 6000;
+    
+    this.targetPosition = new THREE.Vector3(
+        (Math.random() - 0.5) * 2 * mapLimit,
+        minAltitude + Math.random() * (maxAltitude - minAltitude),
+        (Math.random() - 0.5) * 2 * mapLimit
+    );
+}
+
+selectEvadeTarget() {
+    // 현재 위치에서 랜덤 방향으로 회피
+    const evadeDistance = 1000 + Math.random() * 1000;
+    const evadeAngle = Math.random() * Math.PI * 2;
+    
+    this.targetPosition = new THREE.Vector3(
+        this.position.x + Math.cos(evadeAngle) * evadeDistance,
+        this.position.y + (Math.random() - 0.5) * 500,
+        this.position.z + Math.sin(evadeAngle) * evadeDistance
+    );
+    
+    // 맵 경계 확인
+    const mapLimit = GAME_CONSTANTS.MAP_SIZE / 2 * 0.8;
+    this.targetPosition.x = THREE.MathUtils.clamp(this.targetPosition.x, -mapLimit, mapLimit);
+    this.targetPosition.z = THREE.MathUtils.clamp(this.targetPosition.z, -mapLimit, mapLimit);
+    this.targetPosition.y = THREE.MathUtils.clamp(this.targetPosition.y, 1000, 6000);
+}
+
+normalizeAngle(angle) {
+    while (angle > Math.PI) angle -= Math.PI * 2;
+    while (angle < -Math.PI) angle += Math.PI * 2;
+    return angle;
+}
+
+takeDamage(damage) {
     console.log(`Enemy taking damage: ${damage}, Current health: ${this.health}`);
     this.health -= damage;
     console.log(`Enemy health after damage: ${this.health}`);
@@ -1910,14 +2077,22 @@ update(playerPosition, deltaTime) {
     console.log(`Enemy is dead: ${isDead}`);
     return isDead;
 }
-    
-    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.firedMissiles.forEach(missile => {
+            if (missile.destroy) {
+                missile.destroy();
+            }
+        });
+        this.firedMissiles = [];
+        
+        this.isLoaded = false;
     }
 }