Update game.js

game.js

@@ -10,7 +10,7 @@ const GAME_CONSTANTS = {
     MAX_SPEED: 800,
     STALL_SPEED: 120,
     GRAVITY: 9.8,
-    MOUSE_SENSITIVITY: 0.002,
+    MOUSE_SENSITIVITY: 0.001, // 마우스 감도 낮춤
     MAX_G_FORCE: 12.0,
     ENEMY_COUNT: 4,
     MISSILE_COUNT: 6,
@@ -25,29 +25,31 @@ class Fighter {
         
         // 물리 속성
         this.position = new THREE.Vector3(0, 2000, 0);
-        this.velocity = new THREE.Vector3(0, 0, 200); // 초기 속도 증가
+        this.velocity = new THREE.Vector3(0, 0, 150); // 초기 전진 속도
         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.6; // 초기 스로틀 증가
-        this.speed = 200;
+        // 비행 제어 (워썬더 스타일)
+        this.baseSpeed = 150; // 기본 속도
+        this.throttle = 0.5;  // 기본 스로틀 50%
+        this.speed = 150;
         this.altitude = 2000;
         this.gForce = 1.0;
         this.health = 100;
         
-        // 조종 입력 (워썬더 스타일)
-        this.controlInput = {
-            pitch: 0,    // 마우스 Y (상하)
-            yaw: 0,      // 러더 (A/D) 
-            roll: 0,     // 마우스 X (좌우 기울기)
-            elevatorTrim: 0
-        };
+        // 조종 입력 시스템
+        this.pitchInput = 0;   // 마우스 Y -> 기수 상하
+        this.rollInput = 0;    // 마우스 X -> 좌우 회전 (롤)
+        this.yawInput = 0;     // A/D 키 -> 러더
+        
+        // 마우스 누적 입력
+        this.mousePitch = 0;
+        this.mouseRoll = 0;
         
         // 부드러운 회전을 위한 목표값
-        this.targetRotation = new THREE.Euler(0, 0, 0);
-        this.rotationSpeed = 2.5; // 회전 반응성
+        this.targetPitch = 0;
+        this.targetRoll = 0;
+        this.targetYaw = 0;
         
         // 무기
         this.missiles = GAME_CONSTANTS.MISSILE_COUNT;
@@ -55,11 +57,10 @@ class Fighter {
         this.bullets = [];
         this.lastShootTime = 0;
         
-        // 카메라
-        this.cameraDistance = 50;  // 거리 증가
-        this.cameraHeight = 15;    // 높이 증가
-        this.cameraAngle = 0;      // 마우스로 제어되는 카메라 각도
-        this.cameraPitch = 0.1;    // 약간 위에서 내려다보는 각도
+        // 카메라 설정
+        this.cameraDistance = 40;
+        this.cameraHeight = 10;
+        this.cameraLag = 0.08; // 카메라 따라오는 속도
     }
 
     async initialize(scene, loader) {
@@ -67,7 +68,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(3, 3, 3); // 크기 증가
+            this.mesh.scale.set(2, 2, 2);
             
             // 그림자 설정
             this.mesh.traverse((child) => {
@@ -90,154 +91,128 @@ class Fighter {
     createFallbackModel(scene) {
         const group = new THREE.Group();
         
-        // 동체 (더 큰 크기)
-        const fuselageGeometry = new THREE.CylinderGeometry(1, 2, 16, 8);
+        // 동체
+        const fuselageGeometry = new THREE.CylinderGeometry(0.8, 1.5, 12, 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(20, 0.5, 6);
+        const wingGeometry = new THREE.BoxGeometry(16, 0.3, 4);
         const wingMaterial = new THREE.MeshLambertMaterial({ color: 0x404040 });
         const wings = new THREE.Mesh(wingGeometry, wingMaterial);
-        wings.position.z = -2;
+        wings.position.z = -1;
         group.add(wings);
         
         // 수직 안정판
-        const tailGeometry = new THREE.BoxGeometry(0.5, 6, 4);
+        const tailGeometry = new THREE.BoxGeometry(0.3, 4, 3);
         const tailMaterial = new THREE.MeshLambertMaterial({ color: 0x404040 });
         const tail = new THREE.Mesh(tailGeometry, tailMaterial);
-        tail.position.z = -6;
-        tail.position.y = 2;
+        tail.position.z = -5;
+        tail.position.y = 1.5;
         group.add(tail);
         
         // 수평 안정판
-        const horizontalTailGeometry = new THREE.BoxGeometry(8, 0.3, 3);
+        const horizontalTailGeometry = new THREE.BoxGeometry(6, 0.2, 2);
         const horizontalTail = new THREE.Mesh(horizontalTailGeometry, tailMaterial);
-        horizontalTail.position.z = -6;
-        horizontalTail.position.y = 1;
+        horizontalTail.position.z = -5;
+        horizontalTail.position.y = 0.5;
         group.add(horizontalTail);
         
         this.mesh = group;
         this.mesh.position.copy(this.position);
-        this.mesh.scale.set(3, 3, 3);
+        this.mesh.scale.set(2, 2, 2);
         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));
+        // 마우스 X = 롤 (좌우 기울기)
+        // 마우스 Y = 피치 (기수 상하)
+        this.mouseRoll += deltaX * GAME_CONSTANTS.MOUSE_SENSITIVITY;
+        this.mousePitch += deltaY * GAME_CONSTANTS.MOUSE_SENSITIVITY;
         
-        // 카메라 각도도 마우스로 제어 (탱크 게임 방식)
-        this.cameraAngle += deltaX * GAME_CONSTANTS.MOUSE_SENSITIVITY * 0.5;
+        // 입력 제한 (±1)
+        this.mouseRoll = Math.max(-1, Math.min(1, this.mouseRoll));
+        this.mousePitch = Math.max(-1, Math.min(1, this.mousePitch));
     }
 
+    // 키보드 입력 처리
     updateControls(keys, deltaTime) {
-        // 스로틀 제어 (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)
-        this.controlInput.yaw = 0;
-        if (keys.a) this.controlInput.yaw = -1;
-        if (keys.d) this.controlInput.yaw = 1;
-        
-        // 목표 회전각 계산 (더 현실적인 범위)
-        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 * maxYawRate;
-        
-        // 입력 감쇠 (워썬더와 유사)
-        this.controlInput.roll *= 0.88;
-        this.controlInput.pitch *= 0.88;
+        // W/S: 스로틀 조절
+        if (keys.w) {
+            this.throttle = Math.min(1.0, this.throttle + deltaTime * 0.8);
+        }
+        if (keys.s) {
+            this.throttle = Math.max(0.1, this.throttle - deltaTime * 0.8);
+        }
+        
+        // A/D: 러더 (요 회전)
+        this.yawInput = 0;
+        if (keys.a) this.yawInput = -0.5;
+        if (keys.d) this.yawInput = 0.5;
+        
+        // 현재 입력을 조종 입력으로 설정
+        this.pitchInput = this.mousePitch;
+        this.rollInput = this.mouseRoll;
+        
+        // 목표 회전각 계산 (부드러운 제어)
+        const maxPitchAngle = Math.PI / 6; // 30도
+        const maxRollAngle = Math.PI / 4;  // 45도
+        
+        this.targetPitch = this.pitchInput * maxPitchAngle;
+        this.targetRoll = this.rollInput * maxRollAngle;
+        this.targetYaw += this.yawInput * deltaTime * 1.5;
+        
+        // 마우스 입력 자연스럽게 감쇠
+        this.mouseRoll *= 0.95;
+        this.mousePitch *= 0.95;
     }
 
+    // 물리 시뮬레이션
     updatePhysics(deltaTime) {
         if (!this.mesh) return;
         
-        // 부드러운 회전 보간 (더 현실적)
-        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);
+        // 회전 부드럽게 보간
+        const rotationSpeed = deltaTime * 3.0;
+        this.rotation.x = THREE.MathUtils.lerp(this.rotation.x, this.targetPitch, rotationSpeed);
+        this.rotation.y = THREE.MathUtils.lerp(this.rotation.y, this.targetYaw, rotationSpeed);
+        this.rotation.z = THREE.MathUtils.lerp(this.rotation.z, this.targetRoll, rotationSpeed);
         
-        // 엔진 추력 계산 (F-15 기준)
-        const maxThrust = 250000; // 뉴턴
-        const mass = 28000; // kg
-        const currentThrust = this.throttle * maxThrust;
+        // 스로틀에 따른 속도 계산
+        const minSpeed = 100;  // 최소 속도
+        const maxSpeed = 300;  // 최대 속도
+        const targetSpeed = minSpeed + (maxSpeed - minSpeed) * this.throttle;
         
-        // 공기역학적 힘 계산
-        const airDensity = Math.max(0.3, 1.225 * Math.exp(-this.position.y / 8000)); // 고도에 따른 공기밀도
-        const velocity = this.velocity.length();
+        // 속도 부드럽게 변화
+        this.speed = THREE.MathUtils.lerp(this.speed, targetSpeed, deltaTime * 2);
         
-        // 전진 방향 벡터
+        // 전진 방향 벡터 계산
         const forward = new THREE.Vector3(0, 0, 1);
         forward.applyEuler(this.rotation);
         
-        // 상승 방향 벡터
-        const up = new THREE.Vector3(0, 1, 0);
-        up.applyEuler(this.rotation);
-        
-        // 양력 계산 (더 현실적)
-        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.02 + Math.abs(angleOfAttack) * 0.1; // 받음각에 따른 항력 증가
-        const drag = this.velocity.clone().multiplyScalar(-dragCoeff * velocity * airDensity / mass);
-        
-        // 총 가속도
-        this.acceleration = new THREE.Vector3()
-            .add(thrustVector)
-            .add(liftVector)
-            .add(gravity)
-            .add(drag);
-        
-        // G-Force 계산
-        this.gForce = this.acceleration.length() / GAME_CONSTANTS.GRAVITY;
-        
-        // 속도 업데이트
-        this.velocity.add(this.acceleration.clone().multiplyScalar(deltaTime));
+        // 속도 벡터 설정 (항상 전진)
+        this.velocity = forward.multiplyScalar(this.speed);
         
         // 위치 업데이트
         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(30); // 지면 근접 피해
+            if (this.velocity.y < 0) this.velocity.y = 0;
         }
         
         if (this.position.y > GAME_CONSTANTS.MAX_ALTITUDE) {
             this.position.y = GAME_CONSTANTS.MAX_ALTITUDE;
-            this.velocity.y = Math.min(0, this.velocity.y);
+            if (this.velocity.y > 0) this.velocity.y = 0;
         }
         
-        // 맵 경계 순환 (무한 맵 효과)
+        // 맵 경계 순환 (무한 맵)
         const mapLimit = GAME_CONSTANTS.MAP_SIZE / 2;
         if (this.position.x > mapLimit) this.position.x = -mapLimit;
         if (this.position.x < -mapLimit) this.position.x = mapLimit;
@@ -248,176 +223,117 @@ class Fighter {
         this.mesh.position.copy(this.position);
         this.mesh.rotation.copy(this.rotation);
         
-        // 속도와 고도 갱신
-        this.speed = velocity;
+        // 현재 값 업데이트
         this.altitude = this.position.y;
         
-        // 실속 체크 및 처리
-        if (this.speed < GAME_CONSTANTS.STALL_SPEED) {
-            // 실속 시 급격한 하강
-            this.acceleration.y -= 15;
-            this.targetRotation.x = Math.max(this.targetRotation.x, -Math.PI / 6); // 기수 하강
-        }
+        // G-Force 계산 (회전 강도에 따라)
+        const rotationIntensity = Math.abs(this.targetPitch) + Math.abs(this.targetRoll);
+        this.gForce = 1.0 + rotationIntensity * 3;
     }
 
+    // 발사 시스템
     shoot(scene) {
         const currentTime = Date.now();
-        if (currentTime - this.lastShootTime < 80 || this.ammo <= 0) return;
+        if (currentTime - this.lastShootTime < 100 || this.ammo <= 0) return;
         
         this.lastShootTime = currentTime;
         this.ammo--;
         
-        // 기관총 발사 (30mm 기준)
-        const bulletGeometry = new THREE.SphereGeometry(0.3);
+        // 총알 생성
+        const bulletGeometry = new THREE.SphereGeometry(0.2);
         const bulletMaterial = new THREE.MeshBasicMaterial({ 
             color: 0xffff00,
             emissive: 0xffff00,
-            emissiveIntensity: 0.8
+            emissiveIntensity: 0.7
         });
         const bullet = new THREE.Mesh(bulletGeometry, bulletMaterial);
         
-        // 총구 위치 계산 (전투기 기수)
-        const muzzleOffset = new THREE.Vector3(0, 0, 12);
+        // 총구 위치 (전투기 앞쪽)
+        const muzzleOffset = new THREE.Vector3(0, 0, 8);
         muzzleOffset.applyEuler(this.rotation);
         bullet.position.copy(this.position).add(muzzleOffset);
         
-        // 탄속 계산 (실제 속도 + 전투기 속도)
-        const bulletSpeed = 1500; // m/s
+        // 총알 속도 (전투기 속도 + 총알 속도)
+        const bulletSpeed = 1000;
         const direction = new THREE.Vector3(0, 0, 1);
         direction.applyEuler(this.rotation);
         bullet.velocity = direction.multiplyScalar(bulletSpeed).add(this.velocity);
         
-        // 총구 화염 효과
-        this.createMuzzleFlash(scene, bullet.position);
-        
         scene.add(bullet);
         this.bullets.push(bullet);
         
         // 발사음
         try {
             const audio = new Audio('sounds/gunfire.ogg');
-            audio.volume = 0.4;
+            audio.volume = 0.3;
             audio.play();
         } catch (e) {
             console.log('Sound file not found');
         }
     }
 
-    createMuzzleFlash(scene, position) {
-        const flashGroup = new THREE.Group();
-        
-        // 주 화염
-        const flashGeometry = new THREE.SphereGeometry(3);
-        const flashMaterial = new THREE.MeshBasicMaterial({
-            color: 0xffa500,
-            transparent: true,
-            opacity: 0.9
-        });
-        const flash = new THREE.Mesh(flashGeometry, flashMaterial);
-        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);
-        }
-        
-        flashGroup.position.copy(position);
-        flashGroup.quaternion.setFromEuler(this.rotation);
-        scene.add(flashGroup);
-        
-        setTimeout(() => {
-            scene.remove(flashGroup);
-        }, 150);
-    }
-
+    // 총알 업데이트
     updateBullets(scene, 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.distanceTo(this.position) > 12000 || 
+            if (bullet.position.distanceTo(this.position) > 8000 || 
                 bullet.position.y < 0 || 
-                bullet.position.y > GAME_CONSTANTS.MAX_ALTITUDE + 1000) {
+                bullet.position.y > GAME_CONSTANTS.MAX_ALTITUDE + 500) {
                 scene.remove(bullet);
                 this.bullets.splice(i, 1);
             }
         }
     }
 
+    // 피해 시스템
     takeDamage(damage) {
         this.health -= damage;
         return this.health <= 0;
     }
 
-    // 탱크 게임과 유사한 카메라 시스템
+    // 카메라 위치 계산 (전투기 뒤쪽에서 추적)
     getCameraPosition() {
-        // 전투기 뒤쪽에서 추적하는 카메라 (더 멀리)
-        const cameraDistance = 50; // 거리 증가
-        const cameraHeight = 15;   // 높이 증가
-        
         // 전투기 뒤쪽 방향 계산
-        const backwardDirection = new THREE.Vector3(0, 0, -1); // 뒤쪽
-        backwardDirection.applyEuler(this.rotation);
+        const backward = new THREE.Vector3(0, 0, -1);
+        backward.applyEuler(this.rotation);
         
-        // 카메라 위치 = 전투기 위치 + (뒤쪽 방향 * 거리) + 높이
-        const cameraPosition = this.position.clone()
-            .add(backwardDirection.multiplyScalar(cameraDistance))
-            .add(new THREE.Vector3(0, cameraHeight, 0));
+        // 카메라 위치 = 전투기 위치 + 뒤쪽 방향 * 거리 + 높이
+        const cameraPos = this.position.clone()
+            .add(backward.multiplyScalar(this.cameraDistance))
+            .add(new THREE.Vector3(0, this.cameraHeight, 0));
             
-        // 마우스로 카메라 각도 조정
-        const mouseOffset = new THREE.Vector3(
-            Math.sin(this.cameraAngle) * 20,
-            0,
-            Math.cos(this.cameraAngle) * 20
-        );
-        
-        return cameraPosition.add(mouseOffset);
+        return cameraPos;
     }
 
+    // 카메라 타겟 (전투기를 바라봄)
     getCameraTarget() {
-        // 전투기를 바라보는 타겟 (약간 앞쪽)
-        const targetOffset = new THREE.Vector3(0, 0, 10);
-        targetOffset.applyEuler(this.rotation);
-        return this.position.clone().add(targetOffset);
+        return this.position.clone().add(new THREE.Vector3(0, 0, 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, 180);
+        this.velocity = new THREE.Vector3(0, 0, 120);
         this.rotation = new THREE.Euler(0, 0, 0);
-        this.health = 120;
-        this.speed = 180;
+        this.health = 100;
+        this.speed = 120;
         this.bullets = [];
         this.lastShootTime = 0;
         
-        // 고급 AI 상태
+        // AI 상태
         this.aiState = 'patrol';
         this.targetPosition = position.clone();
         this.patrolCenter = position.clone();
-        this.patrolRadius = 3000;
+        this.patrolRadius = 2000;
         this.lastStateChange = 0;
-        this.pursuitMode = false;
-        this.evasionTimer = 0;
     }
 
     async initialize(loader) {
@@ -425,7 +341,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.5, 2.5, 2.5);
+            this.mesh.scale.set(1.5, 1.5, 1.5);
             
             this.mesh.traverse((child) => {
                 if (child.isMesh) {
@@ -447,21 +363,21 @@ class EnemyFighter {
     createFallbackModel() {
         const group = new THREE.Group();
         
-        const fuselageGeometry = new THREE.CylinderGeometry(0.8, 1.2, 12, 8);
-        const fuselageMaterial = new THREE.MeshLambertMaterial({ color: 0x600000 });
+        const fuselageGeometry = new THREE.CylinderGeometry(0.6, 1.0, 8, 8);
+        const fuselageMaterial = new THREE.MeshLambertMaterial({ color: 0x800000 });
         const fuselage = new THREE.Mesh(fuselageGeometry, fuselageMaterial);
         fuselage.rotation.x = Math.PI / 2;
         group.add(fuselage);
         
-        const wingGeometry = new THREE.BoxGeometry(16, 0.4, 4);
-        const wingMaterial = new THREE.MeshLambertMaterial({ color: 0x400000 });
+        const wingGeometry = new THREE.BoxGeometry(12, 0.3, 3);
+        const wingMaterial = new THREE.MeshLambertMaterial({ color: 0x600000 });
         const wings = new THREE.Mesh(wingGeometry, wingMaterial);
-        wings.position.z = -1;
+        wings.position.z = -0.5;
         group.add(wings);
         
         this.mesh = group;
         this.mesh.position.copy(this.position);
-        this.mesh.scale.set(2.5, 2.5, 2.5);
+        this.mesh.scale.set(1.5, 1.5, 1.5);
         this.scene.add(this.mesh);
         this.isLoaded = true;
         
@@ -474,101 +390,49 @@ class EnemyFighter {
         const currentTime = Date.now();
         const distanceToPlayer = this.position.distanceTo(playerPosition);
         
-        // AI 상태 결정
-        if (currentTime - this.lastStateChange > 3000) {
-            if (distanceToPlayer < 4000) {
-                this.aiState = 'attack';
-            } else if (distanceToPlayer < 8000) {
-                this.aiState = 'intercept';
-            } else {
-                this.aiState = 'patrol';
+        // 간단한 AI: 플레이어 추적
+        if (distanceToPlayer < 5000) {
+            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);
+            
+            // 공격
+            if (distanceToPlayer < 2000 && currentTime - this.lastShootTime > 1500) {
+                this.shoot();
             }
-            this.lastStateChange = currentTime;
-        }
-        
-        // 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
-                )
-            );
+        } else {
+            // 순찰
+            if (this.position.distanceTo(this.targetPosition) < 300) {
+                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);
         }
         
-        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));
         
         // 고도 제한
         if (this.position.y < GAME_CONSTANTS.MIN_ALTITUDE) {
             this.position.y = GAME_CONSTANTS.MIN_ALTITUDE;
-            this.velocity.y = Math.abs(this.velocity.y);
         }
         if (this.position.y > GAME_CONSTANTS.MAX_ALTITUDE) {
             this.position.y = GAME_CONSTANTS.MAX_ALTITUDE;
-            this.velocity.y = -Math.abs(this.velocity.y);
         }
         
         // 맵 경계 순환
@@ -581,26 +445,29 @@ class EnemyFighter {
         // 메시 업데이트
         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.25);
+        const bulletGeometry = new THREE.SphereGeometry(0.15);
         const bulletMaterial = new THREE.MeshBasicMaterial({ 
             color: 0xff0000,
             emissive: 0xff0000,
-            emissiveIntensity: 0.7
+            emissiveIntensity: 0.5
         });
         const bullet = new THREE.Mesh(bulletGeometry, bulletMaterial);
         
-        const muzzleOffset = new THREE.Vector3(0, 0, 10);
+        const muzzleOffset = new THREE.Vector3(0, 0, 6);
         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(1200);
+        bullet.velocity = direction.multiplyScalar(800);
         
         this.scene.add(bullet);
         this.bullets.push(bullet);
@@ -611,7 +478,7 @@ class EnemyFighter {
             const bullet = this.bullets[i];
             bullet.position.add(bullet.velocity.clone().multiplyScalar(deltaTime));
             
-            if (bullet.position.distanceTo(this.position) > 8000 || 
+            if (bullet.position.distanceTo(this.position) > 5000 || 
                 bullet.position.y < 0) {
                 this.scene.remove(bullet);
                 this.bullets.splice(i, 1);
@@ -638,7 +505,7 @@ class EnemyFighter {
 class Game {
     constructor() {
         this.scene = new THREE.Scene();
-        this.camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 100000);
+        this.camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 50000);
         this.renderer = new THREE.WebGLRenderer({ antialias: true });
         this.renderer.setSize(window.innerWidth, window.innerHeight);
         this.renderer.shadowMap.enabled = true;
@@ -670,7 +537,7 @@ class Game {
         // 기본 초기화
         this.setupScene();
         this.setupEventListeners();
-        this.preloadGame(); // 게임 사전 로딩
+        this.preloadGame();
     }
 
     async preloadGame() {
@@ -684,12 +551,12 @@ class Game {
                 throw new Error('전투기 로딩 실패');
             }
             
-            // 초기 카메라 위치 설정 (전투기 뒤쪽)
-            const initialCameraPos = new THREE.Vector3(0, 2020, -60);
+            // 초기 카메라 위치 설정
+            const initialCameraPos = this.fighter.getCameraPosition();
             this.camera.position.copy(initialCameraPos);
             this.camera.lookAt(this.fighter.position);
             
-            // 적 생성 (사전 로딩)
+            // 적 생성
             await this.preloadEnemies();
             
             this.isLoaded = true;
@@ -698,7 +565,7 @@ class Game {
             // 로딩 화면 숨기기
             document.getElementById('loading').style.display = 'none';
             
-            // 렌더링 시작 (게임 시작 전)
+            // 렌더링 시작
             this.animate();
             
         } catch (error) {
@@ -711,11 +578,11 @@ class Game {
     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 distance = 6000 + Math.random() * 3000;
             
             const position = new THREE.Vector3(
                 Math.cos(angle) * distance,
-                3000 + Math.random() * 3000,
+                2500 + Math.random() * 2000,
                 Math.sin(angle) * distance
             );
             
@@ -726,62 +593,62 @@ class Game {
     }
 
     setupScene() {
-        // 하늘 그라데이션
+        // 하늘 배경
         this.scene.background = new THREE.Color(0x87CEEB);
-        this.scene.fog = new THREE.Fog(0x87CEEB, 2000, 50000);
+        this.scene.fog = new THREE.Fog(0x87CEEB, 1000, 30000);
         
-        // 조명 시스템
-        const ambientLight = new THREE.AmbientLight(0xffffff, 0.7);
+        // 조명
+        const ambientLight = new THREE.AmbientLight(0xffffff, 0.6);
         this.scene.add(ambientLight);
         
-        const directionalLight = new THREE.DirectionalLight(0xffffff, 1.2);
-        directionalLight.position.set(10000, 15000, 10000);
+        const directionalLight = new THREE.DirectionalLight(0xffffff, 1.0);
+        directionalLight.position.set(8000, 10000, 8000);
         directionalLight.castShadow = true;
-        directionalLight.shadow.mapSize.width = 4096;
-        directionalLight.shadow.mapSize.height = 4096;
+        directionalLight.shadow.mapSize.width = 2048;
+        directionalLight.shadow.mapSize.height = 2048;
         directionalLight.shadow.camera.near = 0.5;
-        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;
+        directionalLight.shadow.camera.far = 20000;
+        directionalLight.shadow.camera.left = -10000;
+        directionalLight.shadow.camera.right = 10000;
+        directionalLight.shadow.camera.top = 10000;
+        directionalLight.shadow.camera.bottom = -10000;
         this.scene.add(directionalLight);
         
-        // 지형 (큰 평면)
-        const groundGeometry = new THREE.PlaneGeometry(GAME_CONSTANTS.MAP_SIZE * 2, GAME_CONSTANTS.MAP_SIZE * 2);
+        // 지형
+        const groundGeometry = new THREE.PlaneGeometry(GAME_CONSTANTS.MAP_SIZE, GAME_CONSTANTS.MAP_SIZE);
         const groundMaterial = new THREE.MeshLambertMaterial({ 
             color: 0x8FBC8F,
             transparent: true,
-            opacity: 0.9
+            opacity: 0.8
         });
         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(200, 8, 6);
+        const cloudGeometry = new THREE.SphereGeometry(100, 8, 6);
         const cloudMaterial = new THREE.MeshLambertMaterial({ 
             color: 0xffffff, 
             transparent: true, 
-            opacity: 0.6 
+            opacity: 0.5 
         });
         
-        for (let i = 0; i < 200; i++) {
+        for (let i = 0; i < 100; i++) {
             const cloud = new THREE.Mesh(cloudGeometry, cloudMaterial);
             cloud.position.set(
-                (Math.random() - 0.5) * GAME_CONSTANTS.MAP_SIZE * 2,
-                Math.random() * 6000 + 1500,
-                (Math.random() - 0.5) * GAME_CONSTANTS.MAP_SIZE * 2
+                (Math.random() - 0.5) * GAME_CONSTANTS.MAP_SIZE,
+                Math.random() * 4000 + 1000,
+                (Math.random() - 0.5) * GAME_CONSTANTS.MAP_SIZE
             );
             cloud.scale.set(
-                Math.random() * 4 + 1,
-                Math.random() * 3 + 0.5,
-                Math.random() * 4 + 1
+                Math.random() * 3 + 1,
+                Math.random() * 2 + 0.5,
+                Math.random() * 3 + 1
             );
             this.scene.add(cloud);
         }
@@ -809,7 +676,7 @@ class Game {
             }
         });
 
-        // 마우스 이벤트 (탱크 게임과 유사)
+        // 마우스 이벤트
         document.addEventListener('mousemove', (event) => {
             if (!document.pointerLockElement || !this.isStarted || this.isGameOver) return;
             
@@ -844,11 +711,7 @@ class Game {
         }
         
         this.isStarted = true;
-        
-        // BGM 시작
         this.startBGM();
-        
-        // 게임 타이머 시작
         this.startGameTimer();
         
         console.log('게임 시작!');
@@ -859,7 +722,7 @@ class Game {
         
         try {
             this.bgm = new Audio('sounds/main_bgm.ogg');
-            this.bgm.volume = 0.6;
+            this.bgm.volume = 0.5;
             this.bgm.loop = true;
             this.bgm.play();
             this.bgmPlaying = true;
@@ -875,7 +738,7 @@ class Game {
                 this.gameTime--;
                 
                 if (this.gameTime <= 0) {
-                    this.endGame(true); // 시간 종료 시 승리
+                    this.endGame(true);
                 }
             }
         }, 1000);
@@ -883,7 +746,6 @@ class Game {
 
     updateUI() {
         if (this.fighter.isLoaded) {
-            // 속도를 노트 단위로 변환
             const speedKnots = Math.round(this.fighter.speed * 1.94384);
             const altitudeFeet = Math.round(this.fighter.altitude * 3.28084);
             
@@ -892,7 +754,6 @@ class Game {
             document.getElementById('health').style.width = `${this.fighter.health}%`;
             document.getElementById('ammoDisplay').textContent = `AMMO: ${this.fighter.ammo}`;
             
-            // 상세 정보 표시
             const gameStats = document.getElementById('gameStats');
             if (gameStats) {
                 gameStats.innerHTML = `
@@ -912,15 +773,13 @@ class Game {
         const radar = document.getElementById('radar');
         if (!radar) return;
         
-        // 기존 적 도트 제거
         const oldDots = radar.getElementsByClassName('enemy-dot');
         while (oldDots[0]) {
             oldDots[0].remove();
         }
         
-        // 레이더 중심
         const radarCenter = { x: 100, y: 100 };
-        const radarRange = 15000; // 감지 범위
+        const radarRange = 10000;
         
         this.enemies.forEach(enemy => {
             if (!enemy.mesh || !enemy.isLoaded) return;
@@ -953,15 +812,14 @@ class Game {
                 if (!enemy.mesh || !enemy.isLoaded) continue;
                 
                 const distance = bullet.position.distanceTo(enemy.position);
-                if (distance < 30) {
-                    // 명중!
+                if (distance < 25) {
                     this.scene.remove(bullet);
                     this.fighter.bullets.splice(i, 1);
                     
-                    if (enemy.takeDamage(40)) {
+                    if (enemy.takeDamage(30)) {
                         enemy.destroy();
                         this.enemies.splice(j, 1);
-                        this.score += 150;
+                        this.score += 100;
                     }
                     break;
                 }
@@ -972,12 +830,11 @@ class Game {
         this.enemies.forEach(enemy => {
             enemy.bullets.forEach((bullet, index) => {
                 const distance = bullet.position.distanceTo(this.fighter.position);
-                if (distance < 35) {
-                    // 피격!
+                if (distance < 30) {
                     this.scene.remove(bullet);
                     enemy.bullets.splice(index, 1);
                     
-                    if (this.fighter.takeDamage(25)) {
+                    if (this.fighter.takeDamage(20)) {
                         this.endGame(false);
                     }
                 }
@@ -1019,13 +876,12 @@ class Game {
                 }
             }
             
-            // 카메라 업데이트 (탱크 게임과 유사)
-            const cameraPos = this.fighter.getCameraPosition();
-            const cameraTarget = this.fighter.getCameraTarget();
+            // 카메라 업데이트 (부드럽게 따라가기)
+            const targetCameraPos = this.fighter.getCameraPosition();
+            const targetCameraTarget = this.fighter.getCameraTarget();
             
-            // 부드러운 카메라 이동
-            this.camera.position.lerp(cameraPos, 0.1);
-            this.camera.lookAt(cameraTarget);
+            this.camera.position.lerp(targetCameraPos, this.fighter.cameraLag);
+            this.camera.lookAt(targetCameraTarget);
         }
         
         this.renderer.render(this.scene, this.camera);
@@ -1034,7 +890,6 @@ class Game {
     endGame(victory = false) {
         this.isGameOver = true;
         
-        // BGM 정지
         if (this.bgm) {
             this.bgm.pause();
             this.bgm = null;
@@ -1056,9 +911,7 @@ class Game {
             <div style="color: #0f0; font-size: 24px; margin: 20px 0;">
                 Final Score: ${this.score}<br>
                 Enemies Destroyed: ${GAME_CONSTANTS.ENEMY_COUNT - this.enemies.length}<br>
-                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)}
+                Mission Time: ${GAME_CONSTANTS.MISSION_DURATION - this.gameTime}s
             </div>
             <button class="start-button" onclick="location.reload()">
                 New Mission
@@ -1072,7 +925,7 @@ class Game {
 // 게임 인스턴스
 let gameInstance = null;
 
-// 전역 함수 (HTML에서 호출)
+// 전역 함수
 window.startGame = function() {
     document.getElementById('startScreen').style.display = 'none';
     document.body.requestPointerLock();
@@ -1084,7 +937,7 @@ window.startGame = function() {
     }
 };
 
-// 게임 초기화 (페이지 로드 시)
+// 게임 초기화
 document.addEventListener('DOMContentLoaded', () => {
     console.log('전투기 시뮬레이터 초기화 중...');
     gameInstance = new Game();