Update game.js

game.js

@@ -5,16 +5,16 @@ import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
 const GAME_CONSTANTS = {
     MISSION_DURATION: 180,
     MAP_SIZE: 15000,
-    MAX_ALTITUDE: 10000,
-    MIN_ALTITUDE: 50,
-    MAX_SPEED: 600,
-    STALL_SPEED: 100,
+    MAX_ALTITUDE: 12000,
+    MIN_ALTITUDE: 100,
+    MAX_SPEED: 800,
+    STALL_SPEED: 120,
     GRAVITY: 9.8,
-    MOUSE_SENSITIVITY: 0.003,
+    MOUSE_SENSITIVITY: 0.002,
     MAX_G_FORCE: 12.0,
-    ENEMY_COUNT: 3,
-    MISSILE_COUNT: 4,
-    AMMO_COUNT: 200
+    ENEMY_COUNT: 4,
+    MISSILE_COUNT: 6,
+    AMMO_COUNT: 300
 };
 
 // 전투기 클래스
@@ -25,28 +25,29 @@ class Fighter {
         
         // 물리 속성
         this.position = new THREE.Vector3(0, 2000, 0);
-        this.velocity = new THREE.Vector3(0, 0, 150); // 초기 속도
+        this.velocity = new THREE.Vector3(0, 0, 200); // 초기 속도 증가
         this.acceleration = new THREE.Vector3(0, 0, 0);
         this.rotation = new THREE.Euler(0, 0, 0);
         this.angularVelocity = new THREE.Vector3(0, 0, 0);
         
         // 비행 제어
-        this.throttle = 0.5;
-        this.speed = 150; // m/s
+        this.throttle = 0.6; // 초기 스로틀 증가
+        this.speed = 200;
         this.altitude = 2000;
         this.gForce = 1.0;
         this.health = 100;
         
-        // 조종 입력
+        // 조종 입력 (워썬더 스타일)
         this.controlInput = {
-            pitch: 0,    // 마우스 Y
-            yaw: 0,      // 러더 (A/D)
-            roll: 0,     // 마우스 X
-            throttle: 0.5
+            pitch: 0,    // 마우스 Y (상하)
+            yaw: 0,      // 러더 (A/D) 
+            roll: 0,     // 마우스 X (좌우 기울기)
+            elevatorTrim: 0
         };
         
-        // 목표 회전각
+        // 부드러운 회전을 위한 목표값
         this.targetRotation = new THREE.Euler(0, 0, 0);
+        this.rotationSpeed = 2.5; // 회전 반응성
         
         // 무기
         this.missiles = GAME_CONSTANTS.MISSILE_COUNT;
@@ -54,9 +55,11 @@ class Fighter {
         this.bullets = [];
         this.lastShootTime = 0;
         
-        // 카메라
-        this.cameraOffset = new THREE.Vector3(0, 5, -25);
-        this.cameraLag = 0.1;
+        // 카메라 (탱크와 유사한 시스템)
+        this.cameraDistance = 35;
+        this.cameraHeight = 8;
+        this.cameraAngle = 0; // 마우스로 제어되는 카메라 각도
+        this.cameraPitch = 0.1; // 약간 위에서 내려다보는 각도
     }
 
     async initialize(scene, loader) {
@@ -64,7 +67,7 @@ class Fighter {
             const result = await loader.loadAsync('models/f-15.glb');
             this.mesh = result.scene;
             this.mesh.position.copy(this.position);
-            this.mesh.scale.set(2, 2, 2);
+            this.mesh.scale.set(3, 3, 3); // 크기 증가
             
             // 그림자 설정
             this.mesh.traverse((child) => {
@@ -85,109 +88,133 @@ class Fighter {
     }
 
     createFallbackModel(scene) {
-        // 모델 로딩 실패 시 기본 모양 생성
         const group = new THREE.Group();
         
-        // 동체
-        const fuselageGeometry = new THREE.CylinderGeometry(0.5, 1, 8, 8);
-        const fuselageMaterial = new THREE.MeshLambertMaterial({ color: 0x808080 });
+        // 동체 (더 큰 크기)
+        const fuselageGeometry = new THREE.CylinderGeometry(1, 2, 16, 8);
+        const fuselageMaterial = new THREE.MeshLambertMaterial({ color: 0x606060 });
         const fuselage = new THREE.Mesh(fuselageGeometry, fuselageMaterial);
         fuselage.rotation.x = Math.PI / 2;
         group.add(fuselage);
         
         // 주익
-        const wingGeometry = new THREE.BoxGeometry(12, 0.2, 3);
-        const wingMaterial = new THREE.MeshLambertMaterial({ color: 0x606060 });
+        const wingGeometry = new THREE.BoxGeometry(20, 0.5, 6);
+        const wingMaterial = new THREE.MeshLambertMaterial({ color: 0x404040 });
         const wings = new THREE.Mesh(wingGeometry, wingMaterial);
-        wings.position.z = -1;
+        wings.position.z = -2;
         group.add(wings);
         
         // 수직 안정판
-        const tailGeometry = new THREE.BoxGeometry(0.2, 3, 2);
-        const tailMaterial = new THREE.MeshLambertMaterial({ color: 0x606060 });
+        const tailGeometry = new THREE.BoxGeometry(0.5, 6, 4);
+        const tailMaterial = new THREE.MeshLambertMaterial({ color: 0x404040 });
         const tail = new THREE.Mesh(tailGeometry, tailMaterial);
-        tail.position.z = -3;
-        tail.position.y = 1;
+        tail.position.z = -6;
+        tail.position.y = 2;
         group.add(tail);
         
+        // 수평 안정판
+        const horizontalTailGeometry = new THREE.BoxGeometry(8, 0.3, 3);
+        const horizontalTail = new THREE.Mesh(horizontalTailGeometry, tailMaterial);
+        horizontalTail.position.z = -6;
+        horizontalTail.position.y = 1;
+        group.add(horizontalTail);
+        
         this.mesh = group;
         this.mesh.position.copy(this.position);
-        this.mesh.scale.set(2, 2, 2);
+        this.mesh.scale.set(3, 3, 3);
         scene.add(this.mesh);
         this.isLoaded = true;
         
         console.log('Fallback 전투기 모델 생성 완료');
     }
 
+    // 워썬더 스타일 마우스 입력
     updateMouseInput(deltaX, deltaY) {
-        // 마우스 입력을 조종 입력으로 변환
+        // 마우스 X는 에일러론 (롤), Y는 엘리베이터 (피치)
         this.controlInput.roll += deltaX * GAME_CONSTANTS.MOUSE_SENSITIVITY;
         this.controlInput.pitch += deltaY * GAME_CONSTANTS.MOUSE_SENSITIVITY;
         
-        // 제한
+        // 입력 제한
         this.controlInput.roll = Math.max(-1, Math.min(1, this.controlInput.roll));
         this.controlInput.pitch = Math.max(-1, Math.min(1, this.controlInput.pitch));
+        
+        // 카메라 각도도 마우스로 제어 (탱크 게임 방식)
+        this.cameraAngle += deltaX * GAME_CONSTANTS.MOUSE_SENSITIVITY * 0.5;
     }
 
     updateControls(keys, deltaTime) {
-        // 스로틀 (W/S)
-        if (keys.w) this.throttle = Math.min(1, this.throttle + deltaTime * 0.8);
-        if (keys.s) this.throttle = Math.max(0, this.throttle - deltaTime * 0.8);
+        // 스로틀 제어 (W/S)
+        if (keys.w) this.throttle = Math.min(1, this.throttle + deltaTime * 1.2);
+        if (keys.s) this.throttle = Math.max(0, this.throttle - deltaTime * 1.2);
         
-        // 러더 (A/D)
+        // 러더 제어 (A/D)
         this.controlInput.yaw = 0;
         if (keys.a) this.controlInput.yaw = -1;
         if (keys.d) this.controlInput.yaw = 1;
         
-        // 목표 회전각 계산 (더 민감한 조종)
-        const maxPitchAngle = Math.PI / 3; // 60도
-        const maxRollAngle = Math.PI / 2;  // 90도
+        // 목표 회전각 계산 (더 현실적인 범위)
+        const maxPitchAngle = Math.PI / 4; // 45도
+        const maxRollAngle = Math.PI / 3;  // 60도
+        const maxYawRate = deltaTime * 1.5;
         
+        // 목표 회전 설정
         this.targetRotation.x = this.controlInput.pitch * maxPitchAngle;
         this.targetRotation.z = this.controlInput.roll * maxRollAngle;
-        this.targetRotation.y += this.controlInput.yaw * deltaTime * 2;
+        this.targetRotation.y += this.controlInput.yaw * maxYawRate;
         
-        // 입력 감쇠
-        this.controlInput.roll *= 0.92;
-        this.controlInput.pitch *= 0.92;
+        // 입력 감쇠 (워썬더와 유사)
+        this.controlInput.roll *= 0.88;
+        this.controlInput.pitch *= 0.88;
     }
 
     updatePhysics(deltaTime) {
         if (!this.mesh) return;
         
-        // 현재 회전을 목표 회전으로 부드럽게 보간
-        const rotationSpeed = deltaTime * 3.5; // 더 빠른 응답
-        this.rotation.x = THREE.MathUtils.lerp(this.rotation.x, this.targetRotation.x, rotationSpeed);
-        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, rotationSpeed);
+        // 부드러운 회전 보간 (더 현실적)
+        const rotationLerpFactor = deltaTime * this.rotationSpeed;
+        this.rotation.x = THREE.MathUtils.lerp(this.rotation.x, this.targetRotation.x, rotationLerpFactor);
+        this.rotation.y = THREE.MathUtils.lerp(this.rotation.y, this.targetRotation.y, rotationLerpFactor);
+        this.rotation.z = THREE.MathUtils.lerp(this.rotation.z, this.targetRotation.z, rotationLerpFactor);
+        
+        // 엔진 추력 계산 (F-15 기준)
+        const maxThrust = 250000; // 뉴턴
+        const mass = 28000; // kg
+        const currentThrust = this.throttle * maxThrust;
         
-        // 엔진 추력 계산
-        const maxThrust = 200000; // 뉴턴
-        const mass = 30000; // kg
-        const thrust = this.throttle * maxThrust;
+        // 공기역학적 힘 계산
+        const airDensity = Math.max(0.3, 1.225 * Math.exp(-this.position.y / 8000)); // 고도에 따른 공기밀도
+        const velocity = this.velocity.length();
         
         // 전진 방향 벡터
         const forward = new THREE.Vector3(0, 0, 1);
         forward.applyEuler(this.rotation);
         
-        // 양력 계산 (단순화)
-        const lift = this.speed * this.speed * 0.001 * Math.cos(this.rotation.x);
-        const liftVector = new THREE.Vector3(0, 1, 0);
-        liftVector.applyEuler(this.rotation);
-        liftVector.multiplyScalar(lift);
+        // 상승 방향 벡터
+        const up = new THREE.Vector3(0, 1, 0);
+        up.applyEuler(this.rotation);
         
-        // 추력 가속도
-        const thrustAccel = forward.multiplyScalar(thrust / mass);
+        // 양력 계산 (더 현실적)
+        const angleOfAttack = Math.asin(Math.max(-1, Math.min(1, this.velocity.clone().normalize().dot(up))));
+        const liftCoeff = Math.sin(2 * angleOfAttack) * 1.5;
+        const lift = 0.5 * airDensity * velocity * velocity * liftCoeff * 50; // 날개면적 고려
+        const liftVector = up.multiplyScalar(lift / mass);
+        
+        // 추력 방향
+        const thrustVector = forward.multiplyScalar(currentThrust / mass);
         
         // 중력
         const gravity = new THREE.Vector3(0, -GAME_CONSTANTS.GRAVITY, 0);
         
-        // 항력
-        const dragCoeff = 0.15;
-        const drag = this.velocity.clone().multiplyScalar(-dragCoeff * this.velocity.length());
+        // 항력 (속도의 제곱에 비례)
+        const dragCoeff = 0.02 + Math.abs(angleOfAttack) * 0.1; // 받음각에 따른 항력 증가
+        const drag = this.velocity.clone().multiplyScalar(-dragCoeff * velocity * airDensity / mass);
         
         // 총 가속도
-        this.acceleration = thrustAccel.add(gravity).add(drag).add(liftVector);
+        this.acceleration = new THREE.Vector3()
+            .add(thrustVector)
+            .add(liftVector)
+            .add(gravity)
+            .add(drag);
         
         // G-Force 계산
         this.gForce = this.acceleration.length() / GAME_CONSTANTS.GRAVITY;
@@ -198,12 +225,11 @@ class Fighter {
         // 위치 업데이트
         this.position.add(this.velocity.clone().multiplyScalar(deltaTime));
         
-        // 고도 제한
+        // 고도 제한 및 지면 충돌
         if (this.position.y < GAME_CONSTANTS.MIN_ALTITUDE) {
             this.position.y = GAME_CONSTANTS.MIN_ALTITUDE;
             this.velocity.y = Math.max(0, this.velocity.y);
-            // 지면 충돌 시 피해
-            this.takeDamage(50);
+            this.takeDamage(30); // 지면 근접 피해
         }
         
         if (this.position.y > GAME_CONSTANTS.MAX_ALTITUDE) {
@@ -211,49 +237,52 @@ class Fighter {
             this.velocity.y = Math.min(0, this.velocity.y);
         }
         
-        // 맵 경계 제한
+        // 맵 경계 순환 (무한 맵 효과)
         const mapLimit = GAME_CONSTANTS.MAP_SIZE / 2;
-        this.position.x = Math.max(-mapLimit, Math.min(mapLimit, this.position.x));
-        this.position.z = Math.max(-mapLimit, Math.min(mapLimit, this.position.z));
+        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.copy(this.rotation);
         
-        // 속도와 고도 계산
-        this.speed = this.velocity.length();
+        // 속도와 고도 갱신
+        this.speed = velocity;
         this.altitude = this.position.y;
         
-        // 실속 체크
+        // 실속 체크 및 처리
         if (this.speed < GAME_CONSTANTS.STALL_SPEED) {
-            // 실속 시 제어력 감소
-            this.acceleration.y -= 20;
+            // 실속 시 급격한 하강
+            this.acceleration.y -= 15;
+            this.targetRotation.x = Math.max(this.targetRotation.x, -Math.PI / 6); // 기수 하강
         }
     }
 
     shoot(scene) {
         const currentTime = Date.now();
-        if (currentTime - this.lastShootTime < 100 || this.ammo <= 0) return;
+        if (currentTime - this.lastShootTime < 80 || this.ammo <= 0) return;
         
         this.lastShootTime = currentTime;
         this.ammo--;
         
-        // 기관총 발사
-        const bulletGeometry = new THREE.SphereGeometry(0.2);
+        // 기관총 발사 (30mm 기준)
+        const bulletGeometry = new THREE.SphereGeometry(0.3);
         const bulletMaterial = new THREE.MeshBasicMaterial({ 
             color: 0xffff00,
             emissive: 0xffff00,
-            emissiveIntensity: 0.5
+            emissiveIntensity: 0.8
         });
         const bullet = new THREE.Mesh(bulletGeometry, bulletMaterial);
         
-        // 총구 위치 계산
-        const muzzleOffset = new THREE.Vector3(0, 0, 8);
+        // 총구 위치 계산 (전투기 기수)
+        const muzzleOffset = new THREE.Vector3(0, 0, 12);
         muzzleOffset.applyEuler(this.rotation);
         bullet.position.copy(this.position).add(muzzleOffset);
         
-        // 탄속 계산
-        const bulletSpeed = 1200; // m/s
+        // 탄속 계산 (실제 속도 + 전투기 속도)
+        const bulletSpeed = 1500; // m/s
         const direction = new THREE.Vector3(0, 0, 1);
         direction.applyEuler(this.rotation);
         bullet.velocity = direction.multiplyScalar(bulletSpeed).add(this.velocity);
@@ -264,10 +293,10 @@ class Fighter {
         scene.add(bullet);
         this.bullets.push(bullet);
         
-        // 발사음 (예시)
+        // 발사음
         try {
             const audio = new Audio('sounds/gunfire.ogg');
-            audio.volume = 0.3;
+            audio.volume = 0.4;
             audio.play();
         } catch (e) {
             console.log('Sound file not found');
@@ -275,20 +304,43 @@ class Fighter {
     }
 
     createMuzzleFlash(scene, position) {
-        const flashGeometry = new THREE.SphereGeometry(2);
+        const flashGroup = new THREE.Group();
+        
+        // 주 화염
+        const flashGeometry = new THREE.SphereGeometry(3);
         const flashMaterial = new THREE.MeshBasicMaterial({
             color: 0xffa500,
             transparent: true,
-            opacity: 0.8
+            opacity: 0.9
         });
         const flash = new THREE.Mesh(flashGeometry, flashMaterial);
-        flash.position.copy(position);
+        flash.scale.set(2, 2, 4);
+        flashGroup.add(flash);
+        
+        // 연기 효과
+        for (let i = 0; i < 8; i++) {
+            const smokeGeometry = new THREE.SphereGeometry(1.5);
+            const smokeMaterial = new THREE.MeshBasicMaterial({
+                color: 0x666666,
+                transparent: true,
+                opacity: 0.6
+            });
+            const smoke = new THREE.Mesh(smokeGeometry, smokeMaterial);
+            smoke.position.set(
+                (Math.random() - 0.5) * 2,
+                (Math.random() - 0.5) * 2,
+                -Math.random() * 3
+            );
+            flashGroup.add(smoke);
+        }
         
-        scene.add(flash);
+        flashGroup.position.copy(position);
+        flashGroup.quaternion.setFromEuler(this.rotation);
+        scene.add(flashGroup);
         
         setTimeout(() => {
-            scene.remove(flash);
-        }, 100);
+            scene.remove(flashGroup);
+        }, 150);
     }
 
     updateBullets(scene, deltaTime) {
@@ -297,9 +349,9 @@ class Fighter {
             bullet.position.add(bullet.velocity.clone().multiplyScalar(deltaTime));
             
             // 총알 제거 조건
-            if (bullet.position.distanceTo(this.position) > 8000 || 
+            if (bullet.position.distanceTo(this.position) > 12000 || 
                 bullet.position.y < 0 || 
-                bullet.position.y > GAME_CONSTANTS.MAX_ALTITUDE) {
+                bullet.position.y > GAME_CONSTANTS.MAX_ALTITUDE + 1000) {
                 scene.remove(bullet);
                 this.bullets.splice(i, 1);
             }
@@ -311,41 +363,49 @@ class Fighter {
         return this.health <= 0;
     }
 
+    // 탱크 게임과 유사한 카메라 시스템
     getCameraPosition() {
-        // 전투기 뒤쪽 카메라 위치
-        const offset = this.cameraOffset.clone();
-        offset.applyEuler(this.rotation);
+        // 전투기 뒤쪽에서 추적하는 카메라
+        const offset = new THREE.Vector3(
+            Math.sin(this.cameraAngle) * this.cameraDistance,
+            this.cameraHeight,
+            Math.cos(this.cameraAngle) * this.cameraDistance
+        );
+        
+        // 전투기의 회전 적용
+        offset.applyEuler(new THREE.Euler(0, this.rotation.y, 0));
+        
         return this.position.clone().add(offset);
     }
 
     getCameraTarget() {
-        // 카메라가 바라볼 위치
-        const target = new THREE.Vector3(0, 0, 10);
-        target.applyEuler(this.rotation);
-        return this.position.clone().add(target);
+        // 전투기를 중심으로 한 타겟
+        return this.position.clone().add(new THREE.Vector3(0, 2, 0));
     }
 }
 
-// 적 전투기 클래스
+// 적 전투기 클래스 (개선됨)
 class EnemyFighter {
     constructor(scene, position) {
         this.mesh = null;
         this.isLoaded = false;
         this.scene = scene;
         this.position = position.clone();
-        this.velocity = new THREE.Vector3(0, 0, 120);
+        this.velocity = new THREE.Vector3(0, 0, 180);
         this.rotation = new THREE.Euler(0, 0, 0);
-        this.health = 100;
-        this.speed = 150;
+        this.health = 120;
+        this.speed = 180;
         this.bullets = [];
         this.lastShootTime = 0;
         
-        // AI 상태
+        // 고급 AI 상태
         this.aiState = 'patrol';
         this.targetPosition = position.clone();
         this.patrolCenter = position.clone();
-        this.patrolRadius = 2000;
+        this.patrolRadius = 3000;
         this.lastStateChange = 0;
+        this.pursuitMode = false;
+        this.evasionTimer = 0;
     }
 
     async initialize(loader) {
@@ -353,7 +413,7 @@ class EnemyFighter {
             const result = await loader.loadAsync('models/mig-29.glb');
             this.mesh = result.scene;
             this.mesh.position.copy(this.position);
-            this.mesh.scale.set(2, 2, 2);
+            this.mesh.scale.set(2.5, 2.5, 2.5);
             
             this.mesh.traverse((child) => {
                 if (child.isMesh) {
@@ -373,24 +433,23 @@ class EnemyFighter {
     }
 
     createFallbackModel() {
-        // 모델 로딩 실패 시 기본 모양 생성
         const group = new THREE.Group();
         
-        const fuselageGeometry = new THREE.CylinderGeometry(0.4, 0.8, 6, 8);
-        const fuselageMaterial = new THREE.MeshLambertMaterial({ color: 0x800000 });
+        const fuselageGeometry = new THREE.CylinderGeometry(0.8, 1.2, 12, 8);
+        const fuselageMaterial = new THREE.MeshLambertMaterial({ color: 0x600000 });
         const fuselage = new THREE.Mesh(fuselageGeometry, fuselageMaterial);
         fuselage.rotation.x = Math.PI / 2;
         group.add(fuselage);
         
-        const wingGeometry = new THREE.BoxGeometry(8, 0.2, 2);
-        const wingMaterial = new THREE.MeshLambertMaterial({ color: 0x600000 });
+        const wingGeometry = new THREE.BoxGeometry(16, 0.4, 4);
+        const wingMaterial = new THREE.MeshLambertMaterial({ color: 0x400000 });
         const wings = new THREE.Mesh(wingGeometry, wingMaterial);
-        wings.position.z = -0.5;
+        wings.position.z = -1;
         group.add(wings);
         
         this.mesh = group;
         this.mesh.position.copy(this.position);
-        this.mesh.scale.set(2, 2, 2);
+        this.mesh.scale.set(2.5, 2.5, 2.5);
         this.scene.add(this.mesh);
         this.isLoaded = true;
         
@@ -403,57 +462,91 @@ class EnemyFighter {
         const currentTime = Date.now();
         const distanceToPlayer = this.position.distanceTo(playerPosition);
         
-        // AI 상태 업데이트
-        if (currentTime - this.lastStateChange > 5000) {
-            if (distanceToPlayer < 3000) {
+        // AI 상태 결정
+        if (currentTime - this.lastStateChange > 3000) {
+            if (distanceToPlayer < 4000) {
                 this.aiState = 'attack';
+            } else if (distanceToPlayer < 8000) {
+                this.aiState = 'intercept';
             } else {
                 this.aiState = 'patrol';
             }
             this.lastStateChange = currentTime;
         }
         
-        // AI 행동
-        if (this.aiState === 'attack' && distanceToPlayer < 4000) {
-            // 플레이어 추적
-            const direction = new THREE.Vector3()
-                .subVectors(playerPosition, this.position)
-                .normalize();
-            
-            this.velocity = direction.multiplyScalar(this.speed);
-            
-            // 회전 계산
-            this.rotation.y = Math.atan2(direction.x, direction.z);
-            this.rotation.x = Math.atan2(-direction.y, 
-                Math.sqrt(direction.x * direction.x + direction.z * direction.z));
-                
-            // 공격
-            if (distanceToPlayer < 2000 && currentTime - this.lastShootTime > 1500) {
-                this.shoot();
-            }
-        } else {
-            // 순찰 모드
-            if (this.position.distanceTo(this.targetPosition) < 200) {
-                // 새로운 순찰 지점 설정
-                const angle = Math.random() * Math.PI * 2;
-                this.targetPosition = this.patrolCenter.clone().add(
-                    new THREE.Vector3(
-                        Math.cos(angle) * this.patrolRadius,
-                        (Math.random() - 0.5) * 1000,
-                        Math.sin(angle) * this.patrolRadius
-                    )
-                );
-            }
-            
-            const direction = new THREE.Vector3()
-                .subVectors(this.targetPosition, this.position)
-                .normalize();
-            
-            this.velocity = direction.multiplyScalar(this.speed * 0.7);
-            this.rotation.y = Math.atan2(direction.x, direction.z);
+        // AI 행동 실행
+        switch (this.aiState) {
+            case 'attack':
+                this.attackBehavior(playerPosition, deltaTime);
+                break;
+            case 'intercept':
+                this.interceptBehavior(playerPosition, deltaTime);
+                break;
+            default:
+                this.patrolBehavior(deltaTime);
         }
         
         // 물리 업데이트
+        this.updatePhysics(deltaTime);
+        
+        // 공격 시도
+        if (distanceToPlayer < 3000 && currentTime - this.lastShootTime > 1200) {
+            this.shoot();
+        }
+        
+        // 총알 업데이트
+        this.updateBullets(deltaTime);
+    }
+
+    attackBehavior(playerPosition, deltaTime) {
+        // 플레이어를 향한 인터셉트 코스 계산
+        const playerVelocity = new THREE.Vector3(); // 플레이어 속도 추정
+        const interceptPoint = playerPosition.clone().add(playerVelocity.multiplyScalar(2));
+        
+        const direction = new THREE.Vector3()
+            .subVectors(interceptPoint, this.position)
+            .normalize();
+        
+        this.velocity = direction.multiplyScalar(this.speed * 1.2); // 공격 시 속도 증가
+        
+        // 회전 계산
+        this.rotation.y = Math.atan2(direction.x, direction.z);
+        this.rotation.x = Math.atan2(-direction.y, 
+            Math.sqrt(direction.x * direction.x + direction.z * direction.z));
+    }
+
+    interceptBehavior(playerPosition, deltaTime) {
+        const direction = new THREE.Vector3()
+            .subVectors(playerPosition, this.position)
+            .normalize();
+        
+        this.velocity = direction.multiplyScalar(this.speed);
+        this.rotation.y = Math.atan2(direction.x, direction.z);
+    }
+
+    patrolBehavior(deltaTime) {
+        if (this.position.distanceTo(this.targetPosition) < 500) {
+            // 새로운 순찰 지점 설정
+            const angle = Math.random() * Math.PI * 2;
+            this.targetPosition = this.patrolCenter.clone().add(
+                new THREE.Vector3(
+                    Math.cos(angle) * this.patrolRadius,
+                    (Math.random() - 0.5) * 2000,
+                    Math.sin(angle) * this.patrolRadius
+                )
+            );
+        }
+        
+        const direction = new THREE.Vector3()
+            .subVectors(this.targetPosition, this.position)
+            .normalize();
+        
+        this.velocity = direction.multiplyScalar(this.speed * 0.8);
+        this.rotation.y = Math.atan2(direction.x, direction.z);
+    }
+
+    updatePhysics(deltaTime) {
+        // 간단한 물리 업데이트
         this.position.add(this.velocity.clone().multiplyScalar(deltaTime));
         
         // 고도 제한
@@ -466,41 +559,36 @@ class EnemyFighter {
             this.velocity.y = -Math.abs(this.velocity.y);
         }
         
-        // 맵 경계 제한
+        // 맵 경계 순환
         const mapLimit = GAME_CONSTANTS.MAP_SIZE / 2;
-        if (Math.abs(this.position.x) > mapLimit || Math.abs(this.position.z) > mapLimit) {
-            // 맵 중앙을 향하도록
-            const centerDirection = new THREE.Vector3(0, this.position.y, 0)
-                .sub(this.position).normalize();
-            this.velocity = centerDirection.multiplyScalar(this.speed);
-        }
+        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.copy(this.rotation);
-        
-        // 총알 업데이트
-        this.updateBullets(deltaTime);
     }
 
     shoot() {
         this.lastShootTime = Date.now();
         
-        const bulletGeometry = new THREE.SphereGeometry(0.15);
+        const bulletGeometry = new THREE.SphereGeometry(0.25);
         const bulletMaterial = new THREE.MeshBasicMaterial({ 
             color: 0xff0000,
             emissive: 0xff0000,
-            emissiveIntensity: 0.5
+            emissiveIntensity: 0.7
         });
         const bullet = new THREE.Mesh(bulletGeometry, bulletMaterial);
         
-        const muzzleOffset = new THREE.Vector3(0, 0, 6);
+        const muzzleOffset = new THREE.Vector3(0, 0, 10);
         muzzleOffset.applyEuler(this.rotation);
         bullet.position.copy(this.position).add(muzzleOffset);
         
         const direction = new THREE.Vector3(0, 0, 1);
         direction.applyEuler(this.rotation);
-        bullet.velocity = direction.multiplyScalar(1000);
+        bullet.velocity = direction.multiplyScalar(1200);
         
         this.scene.add(bullet);
         this.bullets.push(bullet);
@@ -511,7 +599,7 @@ class EnemyFighter {
             const bullet = this.bullets[i];
             bullet.position.add(bullet.velocity.clone().multiplyScalar(deltaTime));
             
-            if (bullet.position.distanceTo(this.position) > 5000 || 
+            if (bullet.position.distanceTo(this.position) > 8000 || 
                 bullet.position.y < 0) {
                 this.scene.remove(bullet);
                 this.bullets.splice(i, 1);
@@ -534,16 +622,17 @@ class EnemyFighter {
     }
 }
 
-// 게임 클래스
+// 메인 게임 클래스
 class Game {
     constructor() {
         this.scene = new THREE.Scene();
-        this.camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 50000);
+        this.camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 100000);
         this.renderer = new THREE.WebGLRenderer({ antialias: true });
         this.renderer.setSize(window.innerWidth, window.innerHeight);
         this.renderer.shadowMap.enabled = true;
         this.renderer.shadowMap.type = THREE.PCFSoftShadowMap;
         this.renderer.setClearColor(0x87CEEB);
+        this.renderer.setPixelRatio(window.devicePixelRatio);
         
         document.getElementById('gameContainer').appendChild(this.renderer.domElement);
         
@@ -556,122 +645,131 @@ class Game {
         this.score = 0;
         this.lastTime = performance.now();
         this.gameTimer = null;
+        this.animationFrameId = null;
+        
+        // 오디오 시스템
+        this.bgm = null;
+        this.bgmPlaying = false;
         
         // 입력 상태
         this.keys = { w: false, a: false, s: false, d: false };
         this.isStarted = false;
         
-        this.setupEventListeners();
+        // 기본 초기화
         this.setupScene();
+        this.setupEventListeners();
+        this.preloadGame(); // 게임 사전 로딩
     }
 
-    async initialize() {
+    async preloadGame() {
         try {
-            document.getElementById('loading').style.display = 'block';
+            console.log('게임 리소스 사전 로딩 중...');
             
-            // 전투기 초기화
+            // 전투기 사전 로딩
             await this.fighter.initialize(this.scene, this.loader);
             
             if (!this.fighter.isLoaded) {
                 throw new Error('전투기 로딩 실패');
             }
             
-            // 적 생성
-            await this.spawnEnemies();
+            // 적 생성 (사전 로딩)
+            await this.preloadEnemies();
             
             this.isLoaded = true;
+            console.log('게임 리소스 로딩 완료');
+            
+            // 로딩 화면 숨기기
             document.getElementById('loading').style.display = 'none';
             
-            // 게임 시작
-            this.startGameTimer();
+            // 렌더링 시작 (게임 시작 전)
             this.animate();
             
         } catch (error) {
-            console.error('게임 초기화 실패:', error);
+            console.error('게임 사전 로딩 실패:', error);
             document.getElementById('loading').innerHTML = 
-                '<div class="loading-text" style="color: red;">로딩 실패</div>';
+                '<div class="loading-text" style="color: red;">로딩 실패. 페이지를 새로고침해주세요.</div>';
+        }
+    }
+
+    async preloadEnemies() {
+        for (let i = 0; i < GAME_CONSTANTS.ENEMY_COUNT; i++) {
+            const angle = (i / GAME_CONSTANTS.ENEMY_COUNT) * Math.PI * 2;
+            const distance = 8000 + Math.random() * 4000;
+            
+            const position = new THREE.Vector3(
+                Math.cos(angle) * distance,
+                3000 + Math.random() * 3000,
+                Math.sin(angle) * distance
+            );
+            
+            const enemy = new EnemyFighter(this.scene, position);
+            await enemy.initialize(this.loader);
+            this.enemies.push(enemy);
         }
     }
 
     setupScene() {
-        // 하늘 배경
+        // 하늘 그라데이션
         this.scene.background = new THREE.Color(0x87CEEB);
-        this.scene.fog = new THREE.Fog(0x87CEEB, 1000, 20000);
+        this.scene.fog = new THREE.Fog(0x87CEEB, 2000, 50000);
         
-        // 조명
-        const ambientLight = new THREE.AmbientLight(0xffffff, 0.6);
+        // 조명 시스템
+        const ambientLight = new THREE.AmbientLight(0xffffff, 0.7);
         this.scene.add(ambientLight);
         
-        const directionalLight = new THREE.DirectionalLight(0xffffff, 1.0);
-        directionalLight.position.set(5000, 8000, 5000);
+        const directionalLight = new THREE.DirectionalLight(0xffffff, 1.2);
+        directionalLight.position.set(10000, 15000, 10000);
         directionalLight.castShadow = true;
-        directionalLight.shadow.mapSize.width = 2048;
-        directionalLight.shadow.mapSize.height = 2048;
+        directionalLight.shadow.mapSize.width = 4096;
+        directionalLight.shadow.mapSize.height = 4096;
         directionalLight.shadow.camera.near = 0.5;
-        directionalLight.shadow.camera.far = 15000;
-        directionalLight.shadow.camera.left = -8000;
-        directionalLight.shadow.camera.right = 8000;
-        directionalLight.shadow.camera.top = 8000;
-        directionalLight.shadow.camera.bottom = -8000;
+        directionalLight.shadow.camera.far = 30000;
+        directionalLight.shadow.camera.left = -15000;
+        directionalLight.shadow.camera.right = 15000;
+        directionalLight.shadow.camera.top = 15000;
+        directionalLight.shadow.camera.bottom = -15000;
         this.scene.add(directionalLight);
         
-        // 지형
-        const groundGeometry = new THREE.PlaneGeometry(GAME_CONSTANTS.MAP_SIZE, GAME_CONSTANTS.MAP_SIZE);
+        // 지형 (큰 평면)
+        const groundGeometry = new THREE.PlaneGeometry(GAME_CONSTANTS.MAP_SIZE * 2, GAME_CONSTANTS.MAP_SIZE * 2);
         const groundMaterial = new THREE.MeshLambertMaterial({ 
             color: 0x8FBC8F,
             transparent: true,
-            opacity: 0.8
+            opacity: 0.9
         });
         const ground = new THREE.Mesh(groundGeometry, groundMaterial);
         ground.rotation.x = -Math.PI / 2;
         ground.receiveShadow = true;
         this.scene.add(ground);
         
-        // 구름 추가
+        // 구름 추가 (더 많이)
         this.addClouds();
     }
 
     addClouds() {
-        const cloudGeometry = new THREE.SphereGeometry(150, 8, 6);
+        const cloudGeometry = new THREE.SphereGeometry(200, 8, 6);
         const cloudMaterial = new THREE.MeshLambertMaterial({ 
             color: 0xffffff, 
             transparent: true, 
             opacity: 0.6 
         });
         
-        for (let i = 0; i < 100; i++) {
+        for (let i = 0; i < 200; i++) {
             const cloud = new THREE.Mesh(cloudGeometry, cloudMaterial);
             cloud.position.set(
-                (Math.random() - 0.5) * GAME_CONSTANTS.MAP_SIZE,
-                Math.random() * 4000 + 1000,
-                (Math.random() - 0.5) * GAME_CONSTANTS.MAP_SIZE
+                (Math.random() - 0.5) * GAME_CONSTANTS.MAP_SIZE * 2,
+                Math.random() * 6000 + 1500,
+                (Math.random() - 0.5) * GAME_CONSTANTS.MAP_SIZE * 2
             );
             cloud.scale.set(
-                Math.random() * 3 + 1,
-                Math.random() * 2 + 0.5,
-                Math.random() * 3 + 1
+                Math.random() * 4 + 1,
+                Math.random() * 3 + 0.5,
+                Math.random() * 4 + 1
             );
             this.scene.add(cloud);
         }
     }
 
-    async spawnEnemies() {
-        for (let i = 0; i < GAME_CONSTANTS.ENEMY_COUNT; i++) {
-            const angle = (i / GAME_CONSTANTS.ENEMY_COUNT) * Math.PI * 2;
-            const distance = 5000 + Math.random() * 3000;
-            
-            const position = new THREE.Vector3(
-                Math.cos(angle) * distance,
-                2000 + Math.random() * 2000,
-                Math.sin(angle) * distance
-            );
-            
-            const enemy = new EnemyFighter(this.scene, position);
-            await enemy.initialize(this.loader);
-            this.enemies.push(enemy);
-        }
-    }
-
     setupEventListeners() {
         // 키보드 이벤트
         document.addEventListener('keydown', (event) => {
@@ -694,7 +792,7 @@ class Game {
             }
         });
 
-        // 마우스 이벤트
+        // 마우스 이벤트 (탱크 게임과 유사)
         document.addEventListener('mousemove', (event) => {
             if (!document.pointerLockElement || !this.isStarted || this.isGameOver) return;
             
@@ -722,6 +820,38 @@ class Game {
         });
     }
 
+    startGame() {
+        if (!this.isLoaded) {
+            console.log('게임이 아직 로딩 중입니다...');
+            return;
+        }
+        
+        this.isStarted = true;
+        
+        // BGM 시작
+        this.startBGM();
+        
+        // 게임 타이머 시작
+        this.startGameTimer();
+        
+        console.log('게임 시작!');
+    }
+
+    startBGM() {
+        if (this.bgmPlaying) return;
+        
+        try {
+            this.bgm = new Audio('sounds/main_bgm.ogg');
+            this.bgm.volume = 0.6;
+            this.bgm.loop = true;
+            this.bgm.play();
+            this.bgmPlaying = true;
+            console.log('BGM 재생 시작');
+        } catch (error) {
+            console.log('BGM 파일을 찾을 수 없습니다:', error);
+        }
+    }
+
     startGameTimer() {
         this.gameTimer = setInterval(() => {
             if (!this.isGameOver) {
@@ -745,21 +875,25 @@ class Game {
             document.getElementById('health').style.width = `${this.fighter.health}%`;
             document.getElementById('ammoDisplay').textContent = `AMMO: ${this.fighter.ammo}`;
             
-            // 새로운 정보 추가
+            // 상세 정보 표시
             const gameStats = document.getElementById('gameStats');
-            gameStats.innerHTML = `
-                <div>Score: ${this.score}</div>
-                <div>Time: ${this.gameTime}s</div>
-                <div>Speed: ${speedKnots} KT</div>
-                <div>Alt: ${altitudeFeet} FT</div>
-                <div>G-Force: ${this.fighter.gForce.toFixed(1)}</div>
-                <div>Targets: ${this.enemies.length}</div>
-            `;
+            if (gameStats) {
+                gameStats.innerHTML = `
+                    <div>Score: ${this.score}</div>
+                    <div>Time: ${this.gameTime}s</div>
+                    <div>Speed: ${speedKnots} KT</div>
+                    <div>Alt: ${altitudeFeet} FT</div>
+                    <div>Throttle: ${Math.round(this.fighter.throttle * 100)}%</div>
+                    <div>G-Force: ${this.fighter.gForce.toFixed(1)}</div>
+                    <div>Targets: ${this.enemies.length}</div>
+                `;
+            }
         }
     }
 
     updateRadar() {
         const radar = document.getElementById('radar');
+        if (!radar) return;
         
         // 기존 적 도트 제거
         const oldDots = radar.getElementsByClassName('enemy-dot');
@@ -768,8 +902,8 @@ class Game {
         }
         
         // 레이더 중심
-        const radarCenter = { x: 100, y: 100 }; // 200px / 2
-        const radarRange = 8000; // 감지 범위
+        const radarCenter = { x: 100, y: 100 };
+        const radarRange = 15000; // 감지 범위
         
         this.enemies.forEach(enemy => {
             if (!enemy.mesh || !enemy.isLoaded) return;
@@ -802,15 +936,15 @@ class Game {
                 if (!enemy.mesh || !enemy.isLoaded) continue;
                 
                 const distance = bullet.position.distanceTo(enemy.position);
-                if (distance < 20) {
+                if (distance < 30) {
                     // 명중!
                     this.scene.remove(bullet);
                     this.fighter.bullets.splice(i, 1);
                     
-                    if (enemy.takeDamage(25)) {
+                    if (enemy.takeDamage(40)) {
                         enemy.destroy();
                         this.enemies.splice(j, 1);
-                        this.score += 100;
+                        this.score += 150;
                     }
                     break;
                 }
@@ -821,12 +955,12 @@ class Game {
         this.enemies.forEach(enemy => {
             enemy.bullets.forEach((bullet, index) => {
                 const distance = bullet.position.distanceTo(this.fighter.position);
-                if (distance < 25) {
+                if (distance < 35) {
                     // 피격!
                     this.scene.remove(bullet);
                     enemy.bullets.splice(index, 1);
                     
-                    if (this.fighter.takeDamage(20)) {
+                    if (this.fighter.takeDamage(25)) {
                         this.endGame(false);
                     }
                 }
@@ -837,40 +971,42 @@ class Game {
     animate() {
         if (this.isGameOver) return;
         
-        requestAnimationFrame(() => this.animate());
+        this.animationFrameId = requestAnimationFrame(() => this.animate());
         
         const currentTime = performance.now();
         const deltaTime = Math.min((currentTime - this.lastTime) / 1000, 0.1);
         this.lastTime = currentTime;
         
-        if (this.isLoaded && this.fighter.isLoaded && this.isStarted) {
-            // 전투기 업데이트
-            this.fighter.updateControls(this.keys, deltaTime);
-            this.fighter.updatePhysics(deltaTime);
-            this.fighter.updateBullets(this.scene, deltaTime);
+        if (this.isLoaded && this.fighter.isLoaded) {
+            if (this.isStarted) {
+                // 전투기 업데이트
+                this.fighter.updateControls(this.keys, deltaTime);
+                this.fighter.updatePhysics(deltaTime);
+                this.fighter.updateBullets(this.scene, deltaTime);
+                
+                // 적 업데이트
+                this.enemies.forEach(enemy => {
+                    enemy.update(this.fighter.position, deltaTime);
+                });
+                
+                // 충돌 검사
+                this.checkCollisions();
+                
+                // UI 업데이트
+                this.updateUI();
+                this.updateRadar();
+                
+                // 승리 조건 확인
+                if (this.enemies.length === 0) {
+                    this.endGame(true);
+                }
+            }
             
-            // 카메라 업데이트
+            // 카메라 업데이트 (탱크 게임과 유사)
             const cameraPos = this.fighter.getCameraPosition();
             const cameraTarget = this.fighter.getCameraTarget();
-            this.camera.position.lerp(cameraPos, 0.1);
+            this.camera.position.lerp(cameraPos, 0.15);
             this.camera.lookAt(cameraTarget);
-            
-            // 적 업데이트
-            this.enemies.forEach(enemy => {
-                enemy.update(this.fighter.position, deltaTime);
-            });
-            
-            // 충돌 검사
-            this.checkCollisions();
-            
-            // UI 업데이트
-            this.updateUI();
-            this.updateRadar();
-            
-            // 승리 조건 확인
-            if (this.enemies.length === 0) {
-                this.endGame(true);
-            }
         }
         
         this.renderer.render(this.scene, this.camera);
@@ -879,6 +1015,13 @@ class Game {
     endGame(victory = false) {
         this.isGameOver = true;
         
+        // BGM 정지
+        if (this.bgm) {
+            this.bgm.pause();
+            this.bgm = null;
+            this.bgmPlaying = false;
+        }
+        
         if (this.gameTimer) {
             clearInterval(this.gameTimer);
         }
@@ -892,9 +1035,11 @@ class Game {
                 ${victory ? 'MISSION ACCOMPLISHED!' : 'SHOT DOWN!'}
             </h1>
             <div style="color: #0f0; font-size: 24px; margin: 20px 0;">
-                Score: ${this.score}<br>
+                Final Score: ${this.score}<br>
                 Enemies Destroyed: ${GAME_CONSTANTS.ENEMY_COUNT - this.enemies.length}<br>
-                Mission Time: ${GAME_CONSTANTS.MISSION_DURATION - this.gameTime}s
+                Mission Time: ${GAME_CONSTANTS.MISSION_DURATION - this.gameTime}s<br>
+                Max Speed: ${Math.round(this.fighter.speed * 1.94384)} KT<br>
+                Max G-Force: ${this.fighter.gForce.toFixed(1)}
             </div>
             <button class="start-button" onclick="location.reload()">
                 New Mission
@@ -908,20 +1053,20 @@ class Game {
 // 게임 인스턴스
 let gameInstance = null;
 
-// 전역 함수
+// 전역 함수 (HTML에서 호출)
 window.startGame = function() {
     document.getElementById('startScreen').style.display = 'none';
     document.body.requestPointerLock();
     
-    if (!gameInstance) {
-        gameInstance = new Game();
+    if (gameInstance && gameInstance.isLoaded) {
+        gameInstance.startGame();
+    } else {
+        console.log('게임이 아직 준비되지 않았습니다...');
     }
-    
-    gameInstance.isStarted = true;
-    gameInstance.initialize();
 };
 
-// 게임 초기화
+// 게임 초기화 (페이지 로드 시)
 document.addEventListener('DOMContentLoaded', () => {
-    console.log('전투기 시뮬레이터 준비 완료');
+    console.log('전투기 시뮬레이터 초기화 중...');
+    gameInstance = new Game();
 });