Update game.js

game.js

@@ -588,8 +588,8 @@ class Fighter {
         
         this.ammo--;
         
-        // 직선 모양의 탄환 (50% 더 크게)
-        const bulletGeometry = new THREE.CylinderGeometry(0.75, 0.75, 12, 8); // 반지름 0.5→0.75, 길이 8→12
+        // 직선 모양의 탄환 (100% 더 크게)
+        const bulletGeometry = new THREE.CylinderGeometry(1.0, 1.0, 16, 8); // 반지름 0.75→1.0, 길이 12→16
         const bulletMaterial = new THREE.MeshBasicMaterial({ 
             color: 0xffff00,
             emissive: 0xffff00,
@@ -691,7 +691,7 @@ class EnemyFighter {
         this.velocity = new THREE.Vector3(0, 0, 120);
         this.rotation = new THREE.Euler(0, 0, 0);
         this.health = GAME_CONSTANTS.MAX_HEALTH; // 체력 1000
-        this.speed = 386; // 750kt in m/s (750 * 0.514444)
+        this.speed = 514; // 1000kt in m/s (1000 * 0.514444)
         this.bullets = [];
         this.lastShootTime = 0;
         
@@ -710,6 +710,12 @@ class EnemyFighter {
         // 다른 적기들과의 충돌 회피
         this.nearbyEnemies = [];
         this.separationRadius = 300; // 최소 거리 300m
+        
+        // 전투 관련 변수
+        this.isEngaged = false; // 전투 중 상태
+        this.burstCount = 0; // 현재 연발 수
+        this.lastBurstTime = 0; // 마지막 연발 시작 시간
+        this.predictedTargetPos = new THREE.Vector3(); // 예측 사격 위치
     }
     
     generateRandomTarget() {
@@ -776,29 +782,74 @@ class EnemyFighter {
         const currentTime = Date.now();
         const distanceToPlayer = this.position.distanceTo(playerPosition);
         
-        // 플레이어 감지 및 공격
-        let shouldAttack = false;
+        // 플레이어 감지 및 전투 상태 전환
         if (distanceToPlayer < 3000) {
+            this.isEngaged = true;
+            this.aiState = 'combat';
+            
             // 플레이어가 시야각 내에 있는지 확인
             const toPlayer = playerPosition.clone().sub(this.position).normalize();
             const forward = new THREE.Vector3(0, 0, 1);
             forward.applyEuler(this.rotation);
             const angle = forward.dot(toPlayer);
             
-            if (angle > 0.5) { // 120도 시야각
-                shouldAttack = true;
-                if (distanceToPlayer < 2000 && currentTime - this.lastShootTime > 800) {
+            // 예측 사격을 위한 플레이어 속도 계산
+            if (this.playerFighter) {
+                const bulletSpeed = 1200; // 탄환 속도
+                const timeToHit = distanceToPlayer / bulletSpeed;
+                
+                // 플레이어의 예상 위치 계산
+                this.predictedTargetPos = playerPosition.clone().add(
+                    this.playerFighter.velocity.clone().multiplyScalar(timeToHit)
+                );
+            }
+            
+            // 사격 조건: 시야각 내에 있고 거리가 2000m 이내
+            if (angle > 0.7 && distanceToPlayer < 2000) { // 시야각을 좁혀서 정확도 향상
+                // 연발 사격 시스템
+                const timeSinceLastBurst = currentTime - this.lastBurstTime;
+                
+                // 2초마다 새로운 연발 시작
+                if (timeSinceLastBurst >= 2000) {
+                    this.burstCount = 0;
+                    this.lastBurstTime = currentTime;
+                }
+                
+                // 10발 연발 (0.1초 간격)
+                if (this.burstCount < 10 && currentTime - this.lastShootTime >= 100) {
                     this.shoot();
+                    this.burstCount++;
                 }
             }
+        } else {
+            this.isEngaged = false;
+            this.aiState = 'patrol';
         }
         
-        // 목표 지점 도달 또는 일정 시간마다 새로운 목표 설정
-        if (this.position.distanceTo(this.targetPosition) < 500 || 
-            currentTime - this.lastDirectionChange > 15000) { // 15초마다 방향 변경
-            this.targetPosition = this.generateRandomTarget();
-            this.lastDirectionChange = currentTime;
-            this.isTurning = false;
+        // 전투 중일 때 플레이어 추적
+        if (this.isEngaged && this.playerFighter) {
+            // 플레이어의 기동 패턴 모방
+            const playerVelocity = this.playerFighter.velocity.clone().normalize();
+            const playerRoll = this.playerFighter.rotation.z;
+            const playerPitch = this.playerFighter.rotation.x;
+            
+            // 예측된 위치로 향하도록 설정
+            this.targetPosition = this.predictedTargetPos.clone();
+            
+            // 플레이어와 비슷한 롤 적용 (약간의 지연으로)
+            this.targetRotation.z = playerRoll * 0.7;
+            
+            // 고도 차이에 따른 피치 조절 (더 공격적으로)
+            const altitudeDiff = this.targetPosition.y - this.position.y;
+            this.targetRotation.x = Math.max(-0.5, Math.min(0.5, altitudeDiff * 0.0003));
+        } else {
+            // 순찰 모드
+            if (this.position.distanceTo(this.targetPosition) < 500 || 
+                currentTime - this.lastDirectionChange > 15000) {
+                this.targetPosition = this.generateRandomTarget();
+                this.lastDirectionChange = currentTime;
+                this.isTurning = false;
+            }
         }
         
         // 목표 방향 계산
@@ -810,45 +861,42 @@ class EnemyFighter {
         while (angleDiff > Math.PI) angleDiff -= Math.PI * 2;
         while (angleDiff < -Math.PI) angleDiff += Math.PI * 2;
         
+        // 전투 중에는 더 빠른 선회
+        const turnRateMultiplier = this.isEngaged ? 2.0 : 1.0;
+        
         // 큰 각도 차이가 있으면 원형 선회
-        if (Math.abs(angleDiff) > Math.PI / 6) { // 30도 이상
+        if (Math.abs(angleDiff) > Math.PI / 6) {
             this.isTurning = true;
             this.turnDirection = angleDiff > 0 ? 1 : -1;
         }
         
         // 선회 중일 때
         if (this.isTurning) {
-            // 원형 선회 구현
-            const turnRate = (this.speed / this.turnRadius) * this.turnDirection;
+            // 원형 선회 구현 (전투 중에는 더 빠르게)
+            const turnRate = (this.speed / this.turnRadius) * this.turnDirection * turnRateMultiplier;
             this.targetRotation.y += turnRate * deltaTime;
-            this.targetRotation.z = this.turnDirection * 0.5; // 선회 시 롤
+            this.targetRotation.z = this.turnDirection * 0.5 * (this.isEngaged ? 1.5 : 1); // 전투 중 더 큰 롤
             
             // 목표 각도에 근접하면 선회 종료
             const newAngleDiff = targetAngle - this.targetRotation.y;
-            if (Math.abs(newAngleDiff) < Math.PI / 12) { // 15도 이내
+            if (Math.abs(newAngleDiff) < Math.PI / 12) {
                 this.isTurning = false;
             }
         } else {
-            // 직진 비행
-            this.targetRotation.y = THREE.MathUtils.lerp(this.targetRotation.y, targetAngle, deltaTime * 0.5);
+            // 직진 비행 (전투 중에는 더 빠른 반응)
+            const lerpSpeed = this.isEngaged ? 1.0 : 0.5;
+            this.targetRotation.y = THREE.MathUtils.lerp(this.targetRotation.y, targetAngle, deltaTime * lerpSpeed);
             this.targetRotation.z = THREE.MathUtils.lerp(this.targetRotation.z, 0, deltaTime * 2);
         }
         
-        // 고도 조절
-        const altitudeDiff = this.targetPosition.y - this.position.y;
-        if (Math.abs(altitudeDiff) > 100) {
-            this.targetRotation.x = Math.max(-0.3, Math.min(0.3, altitudeDiff * 0.0001));
-        } else {
-            this.targetRotation.x = 0;
-        }
-        
         // 다른 적기와의 충돌 회피
         this.avoidOtherEnemies(deltaTime);
         
-        // 부드러운 회전 적용
-        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 * 2.0);
-        this.rotation.z = THREE.MathUtils.lerp(this.rotation.z, this.targetRotation.z, deltaTime * 2.5);
+        // 부드러운 회전 적용 (전투 중에는 더 빠르게)
+        const rotationSpeed = this.isEngaged ? 3.0 : 2.0;
+        this.rotation.x = THREE.MathUtils.lerp(this.rotation.x, this.targetRotation.x, deltaTime * rotationSpeed);
+        this.rotation.y = THREE.MathUtils.lerp(this.rotation.y, this.targetRotation.y, deltaTime * rotationSpeed);
+        this.rotation.z = THREE.MathUtils.lerp(this.rotation.z, this.targetRotation.z, deltaTime * rotationSpeed * 1.25);
         
         // 속도 벡터 계산
         const forward = new THREE.Vector3(0, 0, 1);
@@ -928,8 +976,8 @@ class EnemyFighter {
     shoot() {
         this.lastShootTime = Date.now();
         
-        // 직선 모양의 탄환 (50% 더 크게)
-        const bulletGeometry = new THREE.CylinderGeometry(0.6, 0.6, 9, 8); // 반지름 0.4→0.6, 길이 6→9
+        // 직선 모양의 탄환 (100% 더 크게)
+        const bulletGeometry = new THREE.CylinderGeometry(0.8, 0.8, 12, 8); // 반지름 0.6→0.8, 길이 9→12
         const bulletMaterial = new THREE.MeshBasicMaterial({ 
             color: 0xff0000,
             emissive: 0xff0000,
@@ -1762,7 +1810,7 @@ class Game {
                 if (!enemy.mesh || !enemy.isLoaded) continue;
                 
                 const distance = bullet.position.distanceTo(enemy.position);
-                if (distance < 60) { // 35에서 60으로 대폭 증가 (명중 판정 확대)
+                if (distance < 90) { // 60에서 90으로 증가 (100% 확대)
                     this.scene.remove(bullet);
                     this.fighter.bullets.splice(i, 1);
                     
@@ -1784,7 +1832,7 @@ class Game {
         this.enemies.forEach(enemy => {
             enemy.bullets.forEach((bullet, index) => {
                 const distance = bullet.position.distanceTo(this.fighter.position);
-                if (distance < 65) { // 40에서 65로 대폭 증가 (명중 판정 확대)
+                if (distance < 100) { // 65에서 100으로 증가 (100% 확대)
                     this.scene.remove(bullet);
                     enemy.bullets.splice(index, 1);