Update game.js

game.js

@@ -1,21 +1,17 @@
 import * as THREE from 'three';
-import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
 import { PointerLockControls } from 'three/addons/controls/PointerLockControls.js';
 
 // 게임 상수
 const GAME_DURATION = 180;
 const MAP_SIZE = 2000;
-const HELICOPTER_HEIGHT = 30;  // 30m로 조정
+const HELICOPTER_HEIGHT = 30;
 const ENEMY_GROUND_HEIGHT = 0;
-const ENEMY_SCALE = 10;  // 크기 대폭 증가
+const ENEMY_SCALE = 10;
 const MAX_HEALTH = 1000;
 const ENEMY_MOVE_SPEED = 0.1;
-const ENEMY_MODELS = [
-    '/models/enemy1.glb',
-    '/models/enemy12.glb',
-    '/models/enemy13.glb',
-    '/models/enemy14.glb'
-];
+const ENEMY_COUNT_MAX = 5;
+const PARTICLE_COUNT = 15;
+const OBSTACLE_COUNT = 50;
 const ENEMY_CONFIG = {
     ATTACK_RANGE: 100,
     ATTACK_INTERVAL: 2000,
@@ -32,323 +28,130 @@ let ammo = 30;
 let currentStage = 1;
 let isGameOver = false;
 let lastTime = performance.now();
+let lastRender = 0;
 
-// 총소리 생성기 클래스
+// 오실레이터 기반 총소리 생성기
 class GunSoundGenerator {
-    constructor(audioContext) {
-        this.audioContext = audioContext;
+    constructor() {
+        this.audioContext = new (window.AudioContext || window.webkitAudioContext)();
     }
 
     createGunshot() {
-        // 메인 오실레이터 (총소리의 주요 주파수)
-        const mainOsc = this.audioContext.createOscillator();
-        mainOsc.type = 'square';
-        mainOsc.frequency.setValueAtTime(100, this.audioContext.currentTime);
-        mainOsc.frequency.exponentialRampToValueAtTime(1, this.audioContext.currentTime + 0.1);
-
-        // 노이즈 생성
-        const noiseBuffer = this.createNoiseBuffer();
-        const noise = this.audioContext.createBufferSource();
-        noise.buffer = noiseBuffer;
-
-        // 게인 노드들
-        const mainGain = this.audioContext.createGain();
-        const noiseGain = this.audioContext.createGain();
-
-        // 볼륨 엔벨로프 설정
-        mainGain.gain.setValueAtTime(1, this.audioContext.currentTime);
-        mainGain.gain.exponentialRampToValueAtTime(0.01, this.audioContext.currentTime + 0.1);
+        const currentTime = this.audioContext.currentTime;
         
-        noiseGain.gain.setValueAtTime(1, this.audioContext.currentTime);
-        noiseGain.gain.exponentialRampToValueAtTime(0.01, this.audioContext.currentTime + 0.05);
-
-        // 연결
-        mainOsc.connect(mainGain);
-        noise.connect(noiseGain);
-        mainGain.connect(this.audioContext.destination);
-        noiseGain.connect(this.audioContext.destination);
-
-        // 재생
-        mainOsc.start();
-        noise.start();
-        mainOsc.stop(this.audioContext.currentTime + 0.1);
-        noise.stop(this.audioContext.currentTime + 0.1);
-    }
+        // 메인 오실레이터
+        const osc = this.audioContext.createOscillator();
+        const gainNode = this.audioContext.createGain();
+        
+        osc.type = 'square';
+        osc.frequency.setValueAtTime(200, currentTime);
+        osc.frequency.exponentialRampToValueAtTime(50, currentTime + 0.1);
+        
+        gainNode.gain.setValueAtTime(0.5, currentTime);
+        gainNode.gain.exponentialRampToValueAtTime(0.01, currentTime + 0.1);
+        
+        osc.connect(gainNode);
+        gainNode.connect(this.audioContext.destination);
+        
+        osc.start(currentTime);
+        osc.stop(currentTime + 0.1);
 
-    createNoiseBuffer() {
+        // 노이즈 추가
         const bufferSize = this.audioContext.sampleRate * 0.1;
         const buffer = this.audioContext.createBuffer(1, bufferSize, this.audioContext.sampleRate);
-        const output = buffer.getChannelData(0);
-
+        const data = buffer.getChannelData(0);
+        
         for (let i = 0; i < bufferSize; i++) {
-            output[i] = Math.random() * 2 - 1;
-        }
-
-        return buffer;
-    }
-}
-
-// 사운드 시스템
-class SoundSystem {
-    constructor() {
-        this.audioContext = new (window.AudioContext || window.webkitAudioContext)();
-        this.gunSoundGenerator = new GunSoundGenerator(this.audioContext);
-        this.buffers = new Map();
-        this.pools = new Map();
-    }
-
-    async loadSound(name, url) {
-        try {
-            const response = await fetch(url);
-            const arrayBuffer = await response.arrayBuffer();
-            const audioBuffer = await this.audioContext.decodeAudioData(arrayBuffer);
-            this.buffers.set(name, audioBuffer);
-            this.createPool(name, audioBuffer);
-            console.log(`Sound loaded: ${name}`);
-        } catch (error) {
-            console.error(`Error loading sound ${name}:`, error);
-        }
-    }
-
-    createPool(name, buffer, size = 10) {
-        const pool = [];
-        for (let i = 0; i < size; i++) {
-            pool.push({
-                source: null,
-                gainNode: this.audioContext.createGain(),
-                lastPlayed: 0
-            });
+            data[i] = Math.random() * 2 - 1;
         }
-        this.pools.set(name, pool);
-    }
-
-    playGunshot() {
-        this.gunSoundGenerator.createGunshot();
+        
+        const noise = this.audioContext.createBufferSource();
+        const noiseGain = this.audioContext.createGain();
+        
+        noise.buffer = buffer;
+        noiseGain.gain.setValueAtTime(0.2, currentTime);
+        noiseGain.gain.exponentialRampToValueAtTime(0.01, currentTime + 0.05);
+        
+        noise.connect(noiseGain);
+        noiseGain.connect(this.audioContext.destination);
+        
+        noise.start(currentTime);
     }
 
-    play(name) {
-        const pool = this.pools.get(name);
-        const buffer = this.buffers.get(name);
-        if (!pool || !buffer) {
-            console.warn(`Sound not found: ${name}`);
-            return;
-        }
-
-        const now = this.audioContext.currentTime;
-        const poolItem = pool.find(item => !item.source || item.lastPlayed + buffer.duration <= now);
-        
-        if (poolItem) {
-            if (poolItem.source) {
-                poolItem.source.disconnect();
-            }
-            
-            poolItem.source = this.audioContext.createBufferSource();
-            poolItem.source.buffer = buffer;
-            poolItem.source.connect(poolItem.gainNode);
-            poolItem.gainNode.connect(this.audioContext.destination);
-            poolItem.source.start(0);
-            poolItem.lastPlayed = now;
+    resume() {
+        if (this.audioContext.state === 'suspended') {
+            this.audioContext.resume();
         }
     }
 }
 
 // 사운드 시스템 초기화
-const soundSystem = new SoundSystem();
-
-// 이동 상태
-const moveState = {
-    forward: false,
-    backward: false,
-    left: false,
-    right: false
-};
-
-async function initSounds() {
-    try {
-        await soundSystem.loadSound('explosion', 'explosion.wav');
-        console.log('All sounds loaded successfully');
-    } catch (error) {
-        console.error('Error initializing sounds:', error);
-    }
-}
+const gunSound = new GunSoundGenerator();
 
 async function init() {
-    console.log('Initializing game...');
+    document.getElementById('loading').style.display = 'block';
     
-    // Scene 초기화
-    scene = new THREE.Scene();
-    scene.background = new THREE.Color(0x87ceeb);
-    scene.fog = new THREE.Fog(0x87ceeb, 0, 1500);
-
-    // Camera 설정
-    camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 3000);
-    camera.position.set(0, HELICOPTER_HEIGHT, 0);
-
-    // Renderer 설정
-    renderer = new THREE.WebGLRenderer({ 
-        antialias: true,
-        powerPreference: "high-performance"
-    });
-    renderer.setSize(window.innerWidth, window.innerHeight);
-    renderer.shadowMap.enabled = true;
-    renderer.shadowMap.type = THREE.PCFSoftShadowMap;
-    document.body.appendChild(renderer.domElement);
+    try {
+        // Scene 초기화
+        scene = new THREE.Scene();
+        scene.background = new THREE.Color(0x87ceeb);
+        scene.fog = new THREE.Fog(0x87ceeb, 0, 1000);
+
+        // Renderer 최적화
+        renderer = new THREE.WebGLRenderer({ 
+            antialias: false,
+            powerPreference: "high-performance"
+        });
+        renderer.setSize(window.innerWidth, window.innerHeight);
+        renderer.shadowMap.enabled = true;
+        renderer.shadowMap.type = THREE.BasicShadowMap;
+        document.body.appendChild(renderer.domElement);
 
-    // 조명 설정
-    const ambientLight = new THREE.AmbientLight(0xffffff, 0.6);
-    scene.add(ambientLight);
+        // Camera 설정
+        camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
+        camera.position.set(0, HELICOPTER_HEIGHT, 0);
 
-    const dirLight = new THREE.DirectionalLight(0xffffff, 1);
-    dirLight.position.set(100, 100, 50);
-    dirLight.castShadow = true;
-    dirLight.shadow.mapSize.width = 2048;
-    dirLight.shadow.mapSize.height = 2048;
-    scene.add(dirLight);
+        // 기본 조명
+        scene.add(new THREE.AmbientLight(0xffffff, 0.6));
+        
+        const dirLight = new THREE.DirectionalLight(0xffffff, 0.8);
+        dirLight.position.set(100, 100, 50);
+        dirLight.castShadow = true;
+        dirLight.shadow.mapSize.width = 1024;  // 그림자 해상도 감소
+        dirLight.shadow.mapSize.height = 1024;
+        scene.add(dirLight);
 
-    // Controls 설정
-    controls = new PointerLockControls(camera, document.body);
+        // Controls 설정
+        controls = new PointerLockControls(camera, document.body);
 
-    // 이벤트 리스너
-    document.addEventListener('click', onClick);
-    document.addEventListener('keydown', onKeyDown);
-    document.addEventListener('keyup', onKeyUp);
-    window.addEventListener('resize', onWindowResize);
+        // 이벤트 리스너
+        setupEventListeners();
+
+        // 게임 요소 초기화
+        await Promise.all([
+            createTerrain(),
+            createEnemies()
+        ]);
 
-    try {
-        await initSounds();
-        await createTerrain();
-        await loadEnemies();
-        await testModelLoading();
-        
         document.getElementById('loading').style.display = 'none';
-        console.log('Game initialized successfully');
-        console.log('Active enemies:', enemies.length);
+        gameLoop();
     } catch (error) {
         console.error('Initialization error:', error);
+        document.getElementById('loading').textContent = 'Error loading game. Please refresh.';
     }
 }
 
-function createEnemyOutline(model) {
-    const outlineMaterial = new THREE.MeshBasicMaterial({
-        color: 0xff0000,
-        side: THREE.BackSide
-    });
-    
-    const outlineMesh = model.clone();
-    outlineMesh.traverse((node) => {
-        if (node.isMesh) {
-            node.material = outlineMaterial;
-            node.scale.multiplyScalar(1.05);
-        }
-    });
-    
-    model.add(outlineMesh);
-}
-
-async function loadEnemies() {
-    console.log('Starting enemy loading...');
-    const loader = new GLTFLoader();
-    const enemyCount = 3 + currentStage;
-    const loadPromises = [];
-
-    for (let i = 0; i < enemyCount; i++) {
-        const angle = (i / enemyCount) * Math.PI * 2;
-        const radius = 200;
-        const position = new THREE.Vector3(
-            Math.cos(angle) * radius,
-            ENEMY_GROUND_HEIGHT,
-            Math.sin(angle) * radius
-        );
-
-        console.log(`Creating enemy ${i} at position:`, position);
-
-        // 임시 적 생성
-        const tempGeometry = new THREE.BoxGeometry(5, 5, 5);
-        const tempMaterial = new THREE.MeshPhongMaterial({ 
-            color: 0xff0000,
-            transparent: true,
-            opacity: 0.8,
-            emissive: 0xff0000,
-            emissiveIntensity: 0.5
-        });
-        const tempEnemy = new THREE.Mesh(tempGeometry, tempMaterial);
-        tempEnemy.position.copy(position);
-        tempEnemy.castShadow = true;
-        tempEnemy.receiveShadow = true;
-        scene.add(tempEnemy);
-
-        // 임시 적에 빛 추가
-        const tempLight = new THREE.PointLight(0xff0000, 1, 20);
-        tempLight.position.set(0, 5, 0);
-        tempEnemy.add(tempLight);
-
-        const enemy = {
-            model: tempEnemy,
-            health: 100,
-            speed: ENEMY_MOVE_SPEED,
-            lastAttackTime: 0,
-            position: position.clone()
-        };
-        enemies.push(enemy);
-
-        // GLB 모델 로딩
-        const modelPath = ENEMY_MODELS[i % ENEMY_MODELS.length];
-        const loadPromise = new Promise((resolve, reject) => {
-            loader.load(
-                modelPath,
-                (gltf) => {
-                    console.log(`Successfully loaded model: ${modelPath}`);
-                    const model = gltf.scene;
-                    model.scale.set(ENEMY_SCALE, ENEMY_SCALE, ENEMY_SCALE);
-                    model.position.copy(position);
-
-                    model.traverse((node) => {
-                        if (node.isMesh) {
-                            node.castShadow = true;
-                            node.receiveShadow = true;
-                            node.material.metalness = 0.2;
-                            node.material.roughness = 0.8;
-                            node.material.emissive = new THREE.Color(0x444444);
-                            node.material.emissiveIntensity = 0.5;
-                        }
-                    });
-
-                    // 아웃라인 효과 추가
-                    createEnemyOutline(model);
-
-                    // 적 주변에 빛 추가
-                    const enemyLight = new THREE.PointLight(0xff0000, 1, 20);
-                    enemyLight.position.set(0, 5, 0);
-                    model.add(enemyLight);
-
-                    scene.remove(tempEnemy);
-                    scene.add(model);
-                    enemy.model = model;
-                    resolve();
-                },
-                (xhr) => {
-                    console.log(`${modelPath}: ${(xhr.loaded / xhr.total * 100)}% loaded`);
-                },
-                (error) => {
-                    console.error(`Error loading model ${modelPath}:`, error);
-                    reject(error);
-                }
-            );
-        });
-        loadPromises.push(loadPromise);
-    }
-
-    try {
-        await Promise.all(loadPromises);
-        console.log('All enemies loaded successfully');
-    } catch (error) {
-        console.error('Error loading enemies:', error);
-    }
+function setupEventListeners() {
+    document.addEventListener('click', onClick);
+    document.addEventListener('keydown', onKeyDown);
+    document.addEventListener('keyup', onKeyUp);
+    window.addEventListener('resize', onWindowResize);
 }
 
 function createTerrain() {
     return new Promise((resolve) => {
-        const geometry = new THREE.PlaneGeometry(MAP_SIZE, MAP_SIZE, 200, 200);
+        // 최적화된 지형 생성
+        const geometry = new THREE.PlaneGeometry(MAP_SIZE, MAP_SIZE, 100, 100); // 해상도 감소
         const material = new THREE.MeshStandardMaterial({
             color: 0xD2B48C,
             roughness: 0.8,
@@ -368,6 +171,7 @@ function createTerrain() {
         terrain.receiveShadow = true;
         scene.add(terrain);
 
+        // 최적화된 장애물 추가
         addObstacles();
         resolve();
     });
@@ -380,7 +184,8 @@ function addObstacles() {
         roughness: 0.9
     });
 
-    for (let i = 0; i < 100; i++) {
+    // 장애물 수 감소
+    for (let i = 0; i < OBSTACLE_COUNT; i++) {
         const rock = new THREE.Mesh(rockGeometry, rockMaterial);
         rock.position.set(
             (Math.random() - 0.5) * MAP_SIZE * 0.9,
@@ -398,19 +203,61 @@ function addObstacles() {
     }
 }
 
+function createEnemies() {
+    const enemyCount = Math.min(3 + currentStage, ENEMY_COUNT_MAX);
+    
+    for (let i = 0; i < enemyCount; i++) {
+        const angle = (i / enemyCount) * Math.PI * 2;
+        const radius = 200;
+        const position = new THREE.Vector3(
+            Math.cos(angle) * radius,
+            ENEMY_GROUND_HEIGHT,
+            Math.sin(angle) * radius
+        );
+
+        const enemy = createSimpleEnemy(position);
+        enemies.push(enemy);
+    }
+}
+
+function createSimpleEnemy(position) {
+    // 간단한 적 모델 생성
+    const geometry = new THREE.BoxGeometry(5, 10, 5);
+    const material = new THREE.MeshPhongMaterial({ 
+        color: 0xff0000,
+        emissive: 0x441111,
+        emissiveIntensity: 0.5
+    });
+    
+    const model = new THREE.Mesh(geometry, material);
+    model.position.copy(position);
+    model.castShadow = true;
+    model.receiveShadow = true;
+    
+    // 적 주변에 빛 추가
+    const light = new THREE.PointLight(0xff0000, 1, 10);
+    light.position.set(0, 5, 0);
+    model.add(light);
+    
+    scene.add(model);
+    
+    return {
+        model: model,
+        health: 100,
+        speed: ENEMY_MOVE_SPEED,
+        lastAttackTime: 0
+    };
+}
+
 function createExplosion(position) {
-    const particleCount = 30;
     const particles = [];
-
-    for (let i = 0; i < particleCount; i++) {
+    for (let i = 0; i < PARTICLE_COUNT; i++) {
         const particle = new THREE.Mesh(
             new THREE.SphereGeometry(0.3),
             new THREE.MeshBasicMaterial({ 
                 color: 0xff4400,
                 transparent: true,
-                opacity: 1,
-                emissive: 0xff4400,
-                emissiveIntensity: 1
+                opacity: 1
             })
         );
         
@@ -423,39 +270,38 @@ function createExplosion(position) {
         
         particles.push(particle);
         scene.add(particle);
-
-        // 폭발 지점에 일시적인 빛 추가
-        const explosionLight = new THREE.PointLight(0xff4400, 2, 20);
-        explosionLight.position.copy(position);
-        scene.add(explosionLight);
-        setTimeout(() => scene.remove(explosionLight), 100);
     }
 
-    function animateExplosion() {
-        particles.forEach((particle, i) => {
+    // 폭발 광원 효과
+    const explosionLight = new THREE.PointLight(0xff4400, 2, 20);
+    explosionLight.position.copy(position);
+    scene.add(explosionLight);
+
+    // 최적화된 애니메이션
+    let opacity = 1;
+    const animate = () => {
+        opacity -= 0.05;
+        if (opacity <= 0) {
+            particles.forEach(p => scene.remove(p));
+            scene.remove(explosionLight);
+            return;
+        }
+        
+        particles.forEach(particle => {
             particle.position.add(particle.velocity);
-            particle.material.opacity -= 0.02;
-            
-            if (particle.material.opacity <= 0) {
-                scene.remove(particle);
-                particles.splice(i, 1);
-            }
+            particle.material.opacity = opacity;
         });
         
-        if (particles.length > 0) {
-            requestAnimationFrame(animateExplosion);
-        }
-    }
-
-    animateExplosion();
-    soundSystem.play('explosion');
+        requestAnimationFrame(animate);
+    };
+    
+    animate();
 }
 
-// 이벤트 핸들러
 function onClick() {
     if (!controls.isLocked) {
         controls.lock();
-        soundSystem.audioContext.resume();
+        gunSound.resume();
     } else if (ammo > 0) {
         shoot();
     }
@@ -486,6 +332,14 @@ function onWindowResize() {
     renderer.setSize(window.innerWidth, window.innerHeight);
 }
 
+// 이동 상태
+const moveState = {
+    forward: false,
+    backward: false,
+    left: false,
+    right: false
+};
+
 function shoot() {
     if (ammo <= 0) return;
     
@@ -495,9 +349,9 @@ function shoot() {
     const bullet = createBullet();
     bullets.push(bullet);
     
-    soundSystem.playGunshot();
+    gunSound.createGunshot();
 
-    // 총구 화염 효과
+    // 최적화된 총구 화염 효과
     const muzzleFlash = new THREE.PointLight(0xffff00, 3, 10);
     muzzleFlash.position.copy(camera.position);
     scene.add(muzzleFlash);
@@ -505,42 +359,37 @@ function shoot() {
 }
 
 function createBullet() {
-    const bulletGeometry = new THREE.SphereGeometry(0.5);
-    const bulletMaterial = new THREE.MeshBasicMaterial({ 
-        color: 0xffff00,
-        emissive: 0xffff00,
-        emissiveIntensity: 1
-    });
-    const bullet = new THREE.Mesh(bulletGeometry, bulletMaterial);
-    
-    // 총알 광원 효과 추가
-    const bulletLight = new THREE.PointLight(0xffff00, 1, 5);
-    bullet.add(bulletLight);
+    // 최적화된 총알 생성
+    const bullet = new THREE.Mesh(
+        new THREE.SphereGeometry(0.5),
+        new THREE.MeshBasicMaterial({ 
+            color: 0xffff00,
+            emissive: 0xffff00,
+            emissiveIntensity: 1
+        })
+    );
     
     bullet.position.copy(camera.position);
     const direction = new THREE.Vector3();
     camera.getWorldDirection(direction);
-    bullet.velocity = direction.multiplyScalar(5); // 총알 속도 증가
+    bullet.velocity = direction.multiplyScalar(5);
     
     scene.add(bullet);
     return bullet;
 }
 
 function createEnemyBullet(enemy) {
-    const bulletGeometry = new THREE.SphereGeometry(0.5);
-    const bulletMaterial = new THREE.MeshBasicMaterial({ 
-        color: 0xff0000,
-        emissive: 0xff0000,
-        emissiveIntensity: 1
-    });
-    const bullet = new THREE.Mesh(bulletGeometry, bulletMaterial);
-    
-    // 적 총알 광원 효과 추가
-    const bulletLight = new THREE.PointLight(0xff0000, 1, 5);
-    bullet.add(bulletLight);
+    const bullet = new THREE.Mesh(
+        new THREE.SphereGeometry(0.5),
+        new THREE.MeshBasicMaterial({ 
+            color: 0xff0000,
+            emissive: 0xff0000,
+            emissiveIntensity: 1
+        })
+    );
     
     bullet.position.copy(enemy.model.position);
-    bullet.position.y += 5; // 총구 높이 조정
+    bullet.position.y += 5;
     
     const direction = new THREE.Vector3();
     direction.subVectors(camera.position, enemy.model.position).normalize();
@@ -573,29 +422,28 @@ function updateBullets() {
         
         bullets[i].position.add(bullets[i].velocity);
         
-        enemies.forEach(enemy => {
-            if (!enemy || !enemy.model) return;
+        // 적과의 충돌 검사
+        for (let j = enemies.length - 1; j >= 0; j--) {
+            const enemy = enemies[j];
+            if (!enemy || !enemy.model) continue;
             
-            if (bullets[i] && bullets[i].position.distanceTo(enemy.model.position) < 10) { // 충돌 범위 증가
+            if (bullets[i] && bullets[i].position.distanceTo(enemy.model.position) < 10) {
                 scene.remove(bullets[i]);
                 bullets.splice(i, 1);
                 enemy.health -= 25;
                 
-                // 피격 효과
                 createExplosion(enemy.model.position.clone());
                 
                 if (enemy.health <= 0) {
-                    // 파괴 효과
                     createExplosion(enemy.model.position.clone());
-                    createExplosion(enemy.model.position.clone().add(new THREE.Vector3(5, 0, 5)));
-                    createExplosion(enemy.model.position.clone().add(new THREE.Vector3(-5, 0, -5)));
                     scene.remove(enemy.model);
-                    enemies = enemies.filter(e => e !== enemy);
-                    console.log('Enemy destroyed, remaining enemies:', enemies.length);
+                    enemies.splice(j, 1);
                 }
+                break;
             }
-        });
+        }
 
+        // 범위 벗어난 총알 제거
         if (bullets[i] && bullets[i].position.distanceTo(camera.position) > 1000) {
             scene.remove(bullets[i]);
             bullets.splice(i, 1);
@@ -609,6 +457,7 @@ function updateEnemyBullets() {
 
         enemyBullets[i].position.add(enemyBullets[i].velocity);
         
+        // 플레이어와의 충돌 검사
         if (enemyBullets[i].position.distanceTo(camera.position) < 3) {
             playerHealth -= 10;
             updateHealthBar();
@@ -622,6 +471,7 @@ function updateEnemyBullets() {
             continue;
         }
 
+        // 범위 벗어난 총알 제거
         if (enemyBullets[i].position.distanceTo(camera.position) > 1000) {
             scene.remove(enemyBullets[i]);
             enemyBullets.splice(i, 1);
@@ -633,14 +483,12 @@ function updateEnemies() {
     const currentTime = Date.now();
     
     enemies.forEach(enemy => {
-        if (!enemy || !enemy.model) {
-            console.warn('Invalid enemy detected');
-            return;
-        }
+        if (!enemy || !enemy.model) return;
 
+        // 적 이동 로직
         const direction = new THREE.Vector3();
         direction.subVectors(camera.position, enemy.model.position);
-        direction.y = 0; // y축 이동 제한
+        direction.y = 0;
         direction.normalize();
         
         const newPosition = enemy.model.position.clone()
@@ -648,25 +496,20 @@ function updateEnemies() {
         newPosition.y = ENEMY_GROUND_HEIGHT;
         enemy.model.position.copy(newPosition);
 
+        // 적이 플레이어를 바라보도록 설정
         enemy.model.lookAt(new THREE.Vector3(
             camera.position.x,
             enemy.model.position.y,
             camera.position.z
         ));
 
+        // 공격 로직
         const distanceToPlayer = enemy.model.position.distanceTo(camera.position);
         if (distanceToPlayer < ENEMY_CONFIG.ATTACK_RANGE && 
             currentTime - enemy.lastAttackTime > ENEMY_CONFIG.ATTACK_INTERVAL) {
             
-            console.log('Enemy attacking!');
             enemyBullets.push(createEnemyBullet(enemy));
             enemy.lastAttackTime = currentTime;
-
-            // 공격 시 발광 효과
-            const attackFlash = new THREE.PointLight(0xff0000, 2, 20);
-            attackFlash.position.copy(enemy.model.position);
-            scene.add(attackFlash);
-            setTimeout(() => scene.remove(attackFlash), 100);
         }
     });
 }
@@ -687,8 +530,8 @@ function updateHealthBar() {
 }
 
 function updateHelicopterHUD() {
-    const altitude = Math.round(camera.position.y);
-    document.querySelector('#altitude-indicator span').textContent = altitude;
+    document.querySelector('#altitude-indicator span').textContent = 
+        Math.round(camera.position.y);
 
     const speed = Math.round(
         Math.sqrt(
@@ -739,21 +582,45 @@ function checkGameStatus() {
         document.getElementById('stage').textContent = `Stage ${currentStage}`;
         setTimeout(() => {
             document.getElementById('stage').style.display = 'none';
-            loadEnemies();
+            createEnemies();
         }, 2000);
     }
 }
 
+function cleanupResources() {
+    // 리소스 정리
+    bullets.forEach(bullet => scene.remove(bullet));
+    bullets = [];
+    
+    enemyBullets.forEach(bullet => scene.remove(bullet));
+    enemyBullets = [];
+    
+    enemies.forEach(enemy => {
+        if (enemy && enemy.model) {
+            scene.remove(enemy.model);
+        }
+    });
+    enemies = [];
+}
+
 function gameOver(won) {
     isGameOver = true;
     controls.unlock();
-    soundSystem.audioContext.suspend();
-    alert(won ? 'Mission Complete!' : 'Game Over!');
-    location.reload();
+    cleanupResources();
+    setTimeout(() => {
+        alert(won ? 'Mission Complete!' : 'Game Over!');
+        location.reload();
+    }, 100);
 }
 
-function gameLoop() {
+function gameLoop(timestamp) {
     requestAnimationFrame(gameLoop);
+    
+    // 프레임 제한 (60fps)
+    if (timestamp - lastRender < 16) {
+        return;
+    }
+    lastRender = timestamp;
 
     if (controls.isLocked && !isGameOver) {
         updateMovement();
@@ -767,24 +634,48 @@ function gameLoop() {
     renderer.render(scene, camera);
 }
 
+// 디버깅을 위한 전역 접근
+window.debugGame = {
+    scene,
+    camera,
+    enemies,
+    gunSound,
+    reloadEnemies: createEnemies
+};
+
 // 게임 시작
 window.addEventListener('load', async () => {
     try {
         await init();
         console.log('Game started');
         console.log('Active enemies:', enemies.length);
-        gameLoop();
+        gameLoop(performance.now());
     } catch (error) {
         console.error('Game initialization error:', error);
-        alert('Error loading game. Please check console for details.');
+        document.getElementById('loading').innerHTML = `
+            <div class="loading-text" style="color: #ff0000;">
+                Error loading game. Please refresh.
+            </div>
+        `;
     }
 });
 
-// 디버깅을 위한 전역 접근
-window.debugGame = {
-    scene,
-    camera,
-    enemies,
-    soundSystem,
-    reloadEnemies: loadEnemies
-};
+// 성능 모니터링
+let lastFpsUpdate = 0;
+let frameCount = 0;
+
+function updateFPS(timestamp) {
+    frameCount++;
+    
+    if (timestamp - lastFpsUpdate >= 1000) {
+        const fps = Math.round(frameCount * 1000 / (timestamp - lastFpsUpdate));
+        console.log('FPS:', fps);
+        
+        frameCount = 0;
+        lastFpsUpdate = timestamp;
+    }
+    
+    requestAnimationFrame(updateFPS);
+}
+
+updateFPS(performance.now());