Update game.js

game.js

@@ -1382,15 +1382,6 @@ 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) {
@@ -1439,11 +1430,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) {
@@ -1453,39 +1444,7 @@ 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) {
@@ -1516,48 +1475,31 @@ 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();
-    }
     
-    // 목표를 향해 부드럽게 회전
-    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);
-    
-    // 무기 선택 로직
-    if (distance > 1500 && distance < 5000 && this.aim9Missiles > 0) {
-        // 중거리에서 AIM-9 사용
-        this.currentWeapon = 'AIM9';
-    } else {
-        // 근거리 또는 미사일 없을 때 MG 사용
-        this.currentWeapon = 'MG';
+    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(playerPosition, deltaTime);
-    
-    if (this.currentWeapon === 'MG') {
+    executeCombat(playerPosition, deltaTime) {
+        const distance = this.position.distanceTo(playerPosition);
+        
+        
+        // 플레이어를 향해 회전
+        this.smoothTurnToTarget(playerPosition, deltaTime);
+        
         // 조준 정확도 확인
         const aimAccuracy = this.calculateAimAccuracy(playerPosition);
         
@@ -1576,74 +1518,122 @@ executeCombat(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에서 처리)
-    
-    // 거리에 따라 기동 결정
-    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;
-    
-    // 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;
+    // 새로운 메서드: 충돌 예측
+    checkCollisionPrediction(deltaTime) {
+        if (!this.nearbyEnemies) 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);
+        // 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));
         
-        // 150m 이내로 접근 예상 시 사전 회피
-        if (predictedDistance < 150) {
-            // 예방적 회피 방향 설정
-            const avoidDir = this.predictedPosition.clone().sub(enemyPredicted).normalize();
+        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));
             
-            // 수직 분리 추가
-            if (this.position.y > enemy.position.y) {
-                avoidDir.y += 0.3;
+            // 예상 거리
+            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));
+            }
+        });
+    }
+    
+    // 새로운 메서드: 긴급 회피 실행
+    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 {
-                avoidDir.y -= 0.3;
+                this.rotation.y = targetYaw;
             }
             
-            this.avoidanceVector.add(avoidDir.multiplyScalar(1.5));
+            // 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도 상승
         }
-    });
-}
-
-// 새로운 메서드: 긴급 회피 실행
-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; // 피치는 절반만
+        // 회피 중에는 최대 속도
+        this.speed = this.maxSpeed;
+    }
+    
+    smoothTurnToTarget(targetPos, deltaTime, isEmergency = false) {
         
-        // 빠른 회전 속도
-        const emergencyTurnSpeed = this.turnSpeed * 2.0;
-        const maxTurnRate = emergencyTurnSpeed * deltaTime;
+        
+        // 기존 로직 (후퇴가 아닐 때)
+        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);
@@ -1653,181 +1643,132 @@ executeEmergencyEvade(deltaTime) {
             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;
+        // 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;
         }
         
-        // 급선회 시 약간의 롤 추가
-        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;
-}
-
-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);
+        // 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;
+    calculateAvoidance() {
+        this.avoidanceVector.set(0, 0, 0);
+        
+        if (!this.nearbyEnemies) return;
         
-        const distance = this.position.distanceTo(enemy.position);
+        let avoidCount = 0;
+        let criticalAvoidance = false;
         
-        // 100m 미만: 긴급 회피
-        if (distance < 100 && distance > 0) {
-            criticalAvoidance = true;
+        this.nearbyEnemies.forEach(enemy => {
+            if (enemy === this || !enemy.position) return;
             
-            // 강한 반발력
-            const avoidDir = this.position.clone().sub(enemy.position).normalize();
-            const strength = 2.0; // 매우 강한 회피
-            this.avoidanceVector.add(avoidDir.multiplyScalar(strength));
+            const distance = this.position.distanceTo(enemy.position);
             
-            // 고도 차이 추가 (위/아래로 분산)
-            if (this.position.y > enemy.position.y) {
-                this.avoidanceVector.y += 0.5; // 위로
-            } else {
-                this.avoidanceVector.y -= 0.5; // 아래로
+            // 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 (avoidCount > 0) {
+            this.avoidanceVector.divideScalar(avoidCount);
+            this.avoidanceVector.normalize();
             
-            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 (avoidCount > 0) {
-        this.avoidanceVector.divideScalar(avoidCount);
-        this.avoidanceVector.normalize();
-        
-        // 긴급 회피 시 더 강한 회피력 적용
-        if (criticalAvoidance) {
-            this.avoidanceVector.multiplyScalar(2.0);
-            // 일시적으로 전투 상태 해제
-            this.temporaryEvadeMode = true;
-            this.evadeTimer = 2.0; // 2초 동안 회피 우선
+            // 긴급 회피 시 더 강한 회피력 적용
+            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;
-    }
-    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; // 하강
-    }
-    
-    // 맵 경계 처리
-    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(); // 새로운 목표 선택
+    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; // 하강
+        }
+        
+        // 맵 경계 처리
+        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;
     }
     
-    // 하드 리미트
-    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') {
+    fireWeapon() {
         const now = Date.now();
         
         // 0.1초에 1발씩, 10발 연발
@@ -1849,227 +1790,119 @@ fireWeapon() {
             }
         }
     }
-    // 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);
-    
-    // 기수 끝에서만 발사 - 정확히 전방 중앙에서
-    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;
-        }
+    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축 방향을 향하도록
         
-        // 거리 제한 (플레이어와 동일하게 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);
+        // 탄환 초기 위치 저장
+        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) {}
+            }
         }
     }
-}
-
-// 적기용 AIM-9 락온 시스템
-updateLockOn(deltaTime) {
-    if (!this.playerFighter || this.currentWeapon !== 'AIM9') {
-        this.lockTarget = null;
-        this.lockProgress = 0;
-        return;
-    }
-    
-    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;
-                
+    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.onEnemyLockStart(this);
+                    window.gameInstance.createGroundImpactEffect(bullet.position);
                 }
+                this.scene.remove(bullet);
+                this.bullets.splice(i, 1);
+                continue;
             }
-        } else {
-            // 타겟 잃음
-            if (this.lockTarget && window.gameInstance) {
-                window.gameInstance.onEnemyLockLost(this);
+            
+            // 거리 제한 (플레이어와 동일하게 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);
             }
-            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;
-    
-    const now = Date.now();
-    // 미사일 발사 간격 최소 5초
-    if (now - this.lastMissileFireTime < 5000) return;
-    
-    this.aim9Missiles--;
-    this.lastMissileFireTime = now;
     
-    // 날개 위치에서 발사
-    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);
-    
-    // 락온 초기화
-    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)));
     }
-}
-
-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;
     
-    // 더 다양한 고도 선택
-    const minAltitude = 1000;
-    const maxAltitude = 6000;
+    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.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;
+    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);
+    }
     
-    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
-    );
+    normalizeAngle(angle) {
+        while (angle > Math.PI) angle -= Math.PI * 2;
+        while (angle < -Math.PI) angle += Math.PI * 2;
+        return angle;
+    }
     
-    // 맵 경계 확인
-    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) {
+   takeDamage(damage) {
     console.log(`Enemy taking damage: ${damage}, Current health: ${this.health}`);
     this.health -= damage;
     console.log(`Enemy health after damage: ${this.health}`);
@@ -2077,22 +1910,14 @@ takeDamage(damage) {
     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.firedMissiles.forEach(missile => {
-            if (missile.destroy) {
-                missile.destroy();
-            }
-        });
-        this.firedMissiles = [];
-        
-        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;
+        }
     }
 }