Update game.js

game.js

@@ -734,6 +734,27 @@ class EnemyFighter {
         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() {
@@ -745,8 +766,86 @@ class EnemyFighter {
             (Math.random() - 0.5) * 2 * mapLimit
         );
     }
-
-    async initialize(loader) {
+    
+    // 새로운 메서드: 자연스러운 기동 선택
+    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;
@@ -808,11 +907,18 @@ class EnemyFighter {
         } 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':
@@ -859,130 +965,371 @@ class EnemyFighter {
             
             // 고도도 변경 (더 부드럽게)
             if (avoidDirection.y > 0) {
-                this.targetRotation.x = -0.15; // 기존 -0.3 → -0.15 (50% 감소)
+                this.targetRotation.x = -0.15;
             } else {
-                this.targetRotation.x = 0.15; // 기존 0.3 → 0.15 (50% 감소)
+                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).normalize();
+                const targetYaw = Math.atan2(dirToTarget.x, dirToTarget.z);
+                const yawDiff = this.normalizeAngle(targetYaw - this.rotation.y);
+                this.targetRotation.y += yawDiff * deltaTime * 0.3;
+                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 direction = this.targetPosition.clone().sub(this.position).normalize();
-        const targetYaw = Math.atan2(direction.x, direction.z);
+        // 고도 조정
+        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));
+            }
+        }
         
-        // 부드러운 선회
-        const yawDiff = targetYaw - this.rotation.y;
-        const normalizedYawDiff = ((yawDiff + Math.PI) % (2 * Math.PI)) - Math.PI;
+        // 속도 관리
+        this.updateSpeedControl(deltaTime);
+    }
+    
+    combat(playerPosition, deltaTime) {
+        const distance = this.position.distanceTo(playerPosition);
         
-        this.targetRotation.y += normalizedYawDiff * deltaTime * 0.5;
+        // 전투 패턴 업데이트
+        this.selectCombatPattern(playerPosition, distance);
         
-        // 고도 조정
-        const altitudeDiff = this.targetPosition.y - this.position.y;
-        if (Math.abs(altitudeDiff) > 50) {
-            this.targetRotation.x = Math.max(-0.3, Math.min(0.3, altitudeDiff * 0.0001));
+        // 전투 패턴별 기동
+        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();
+        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 * 2));
+        } else {
+            this.targetRotation.z *= 0.9; // 롤 복귀
+        }
+        
+        // 목표 방향으로 회전
+        this.targetRotation.y += yawDiff * deltaTime * 1.2;
+        this.targetRotation.x += pitchDiff * deltaTime * 0.8;
+        
+        // 피치 제한
+        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).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 += yawDiff * deltaTime * 2.0;
+        this.targetRotation.x += pitchDiff * deltaTime * 1.5;
+        this.targetRotation.z = -yawDiff * 0.5; // 약간의 뱅크만 적용
+        
+        // 속도 조절 - 목표와의 상대 속도 관리
+        const distance = this.position.distanceTo(target);
+        if (distance < 800) {
+            this.throttle = 0.6; // 감속
         } else {
-            this.targetRotation.x = 0;
+            this.throttle = 0.85;
         }
     }
     
-    combat(playerPosition, deltaTime) {
-        // 플레이어 위치 예측
-        if (this.playerFighter && this.playerFighter.velocity) {
-            const bulletTravelTime = this.position.distanceTo(playerPosition) / 1200; // 탄환 속도
-            this.predictedTargetPos = playerPosition.clone().add(
-                this.playerFighter.velocity.clone().multiplyScalar(bulletTravelTime)
-            );
+    // 회피 기동
+    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 {
-            this.predictedTargetPos = playerPosition.clone();
+            // 스플릿-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;
         }
         
-        // 예측 위치를 향해 조준
-        const aimDirection = this.predictedTargetPos.clone().sub(this.position).normalize();
-        const targetYaw = Math.atan2(aimDirection.x, aimDirection.z);
-        const targetPitch = Math.asin(-aimDirection.y);
+        // 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 yawDiff = targetYaw - this.rotation.y;
-        const normalizedYawDiff = ((yawDiff + Math.PI) % (2 * Math.PI)) - Math.PI;
+        const dotProduct = forward.dot(toTarget);
+        const angle = Math.acos(Math.max(-1, Math.min(1, dotProduct)));
         
-        this.targetRotation.y += normalizedYawDiff * deltaTime * 1.0;
-        this.targetRotation.x = THREE.MathUtils.lerp(this.targetRotation.x, targetPitch, deltaTime * 2.0);
+        return angle;
+    }
+    
+    // 무기 발사
+    fireWeapon() {
+        const now = Date.now();
+        if (now - this.lastBurstTime > 2000) {
+            this.burstCount = 0;
+            this.lastBurstTime = now;
+        }
         
-        // 사격 판단
-        const distanceToPlayer = this.position.distanceTo(playerPosition);
-        const aimAccuracy = Math.abs(normalizedYawDiff) + Math.abs(targetPitch - this.rotation.x);
-        
-        if (distanceToPlayer < 1500 && aimAccuracy < 0.1) {
-            // 연발 사격 시스템
-            const now = Date.now();
-            if (now - this.lastBurstTime > 2000) { // 2초마다 연발
-                this.burstCount = 0;
-                this.lastBurstTime = now;
-            }
-            
-            if (this.burstCount < 5 && now - this.lastShootTime > 200) { // 0.2초 간격으로 5발
-                this.shoot();
-                this.burstCount++;
-            }
+        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 (distanceToPlayer < 500) {
-            // 너무 가까우면 급선회
-            this.targetRotation.z = Math.sin(Date.now() * 0.001) * 0.5;
-            this.targetRotation.y += deltaTime * 2.0 * (Math.random() > 0.5 ? 1 : -1);
+        // 기동에 따른 속도 손실
+        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;
         
-        // 부드러운 회전 적용
-        this.rotation.x = THREE.MathUtils.lerp(this.rotation.x, this.targetRotation.x, deltaTime * 2.0);
-        this.rotation.y = THREE.MathUtils.lerp(this.rotation.y, this.targetRotation.y, deltaTime * 1.5);
-        this.rotation.z = THREE.MathUtils.lerp(this.rotation.z, this.targetRotation.z, deltaTime * 3.0);
+        // 부드러운 회전 적용 - 항공역학적 제한 적용
+        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 * 50;
+            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);
+        
+        // 전진 추력
+        const thrust = forward.multiplyScalar(this.speed);
+        this.velocity = this.velocity.multiplyScalar(0.95).add(thrust.multiplyScalar(0.05));
+        
+        // 속도 제한
+        const currentSpeed = this.velocity.length();
+        if (currentSpeed > this.speed * 1.2) {
+            this.velocity.normalize().multiplyScalar(this.speed * 1.2);
+        }
         
         // 위치 업데이트
         this.position.add(this.velocity.clone().multiplyScalar(deltaTime));
         
         // 고도 제한
-        if (this.position.y < 500) {
-            this.position.y = 500;
-            this.targetRotation.x = -0.2; // 상승
+        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;
-        if (Math.abs(this.position.x) > mapLimit * 0.9 || Math.abs(this.position.z) > mapLimit * 0.9) {
-            // 맵 중앙을 향해 회전
-            const centerDirection = new THREE.Vector3(0, this.position.y, 0).sub(this.position).normalize();
-            this.targetRotation.y = Math.atan2(centerDirection.x, centerDirection.z);
+        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 (Math.abs(this.targetRotation.z) > 0.01) {
+        // 자동 롤 복귀 (전투 중이 아닐 때)
+        if (!this.isEngaged && Math.abs(this.targetRotation.z) > 0.01) {
             this.targetRotation.z *= 0.95;
         }
     }
@@ -999,8 +1346,8 @@ class EnemyFighter {
         });
         const bullet = new THREE.Mesh(bulletGeometry, bulletMaterial);
         
-        // 기수 끝에서 발사 (8 → 12로 증가)
-        const muzzleOffset = new THREE.Vector3(0, 0, 12); // 기존 8에서 12로 변경
+        // 기수 끝에서 발사
+        const muzzleOffset = new THREE.Vector3(0, 0, 12);
         muzzleOffset.applyEuler(this.rotation);
         bullet.position.copy(this.position).add(muzzleOffset);
         
@@ -1023,13 +1370,12 @@ class EnemyFighter {
                     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();
                     });
@@ -1045,9 +1391,9 @@ class EnemyFighter {
             const bullet = this.bullets[i];
             bullet.position.add(bullet.velocity.clone().multiplyScalar(deltaTime));
             
-            // 지면 충돌 체크 추가
+            // 지면 충돌 체크
             if (bullet.position.y <= 0) {
-                // 크고 화려한 지면 충돌 효과 - Game 인스턴스를 통해 호출
+                // 크고 화려한 지면 충돌 효과
                 if (window.gameInstance) {
                     window.gameInstance.createGroundImpactEffect(bullet.position);
                 }