Update game.js

game.js

@@ -1,4 +1,3 @@
-// game.js
 import * as THREE from 'three';
 import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
 import { PointerLockControls } from 'three/addons/controls/PointerLockControls.js';
@@ -10,12 +9,11 @@ const HELICOPTER_HEIGHT = 50;
 const ENEMY_SCALE = 3;
 const MAX_HEALTH = 1000;
 const ENEMY_MODELS = [
-    './models/enemy1.glb',  // 실제 모델 파일 경로로 수정
+    './models/enemy1.glb',
     './models/enemy2.glb',
     './models/enemy3.glb',
     './models/enemy4.glb'
 ];
-
 const ENEMY_CONFIG = {
     ATTACK_RANGE: 100,
     ATTACK_INTERVAL: 2000,
@@ -32,28 +30,46 @@ let ammo = 30;
 let currentStage = 1;
 let isGameOver = false;
 
-// 사운드 풀 생성 함수
-const createSoundPool = (soundUrl, poolSize = 10) => {
-    const sounds = [];
-    for (let i = 0; i < poolSize; i++) {
-        const sound = new Audio(soundUrl);
-        sounds.push(sound);
+// 사운드 풀 클래스
+class SoundPool {
+    constructor(soundUrl, poolSize = 10) {
+        this.sounds = [];
+        this.currentIndex = 0;
+        this.poolSize = poolSize;
+        
+        for (let i = 0; i < poolSize; i++) {
+            const sound = new Audio(soundUrl);
+            sound.preload = 'auto';
+            this.sounds.push(sound);
+        }
     }
-    let currentIndex = 0;
-    
-    return {
-        play: function() {
-            sounds[currentIndex].currentTime = 0;
-            sounds[currentIndex].play();
-            currentIndex = (currentIndex + 1) % poolSize;
+
+    play() {
+        const sound = this.sounds[this.currentIndex];
+        
+        // 현재 재생 중인 사운드 초기화
+        sound.pause();
+        sound.currentTime = 0;
+        
+        // 새로운 Promise로 사운드 재생
+        const playPromise = sound.play();
+        
+        if (playPromise !== undefined) {
+            playPromise.catch(error => {
+                console.error("Sound play error:", error);
+                // 오류 발생 시 새로운 Audio 객체로 교체
+                this.sounds[this.currentIndex] = new Audio(sound.src);
+            });
         }
-    };
-};
+
+        this.currentIndex = (this.currentIndex + 1) % this.poolSize;
+    }
+}
 
 // 사운드 초기화
 const sounds = {
     bgm: new Audio('Music.wav'),
-    gunshot: createSoundPool('gun.wav', 10)
+    gunshot: new SoundPool('gun.wav', 20)
 };
 sounds.bgm.loop = true;
 
@@ -93,6 +109,13 @@ function init() {
     // Controls 설정
     controls = new PointerLockControls(camera, document.body);
 
+    // 디버그 헬퍼 추가
+    const axesHelper = new THREE.AxesHelper(5);
+    scene.add(axesHelper);
+
+    const gridHelper = new THREE.GridHelper(1000, 100);
+    scene.add(gridHelper);
+
     // 이벤트 리스너 설정
     document.addEventListener('click', onClick);
     document.addEventListener('keydown', onKeyDown);
@@ -102,7 +125,7 @@ function init() {
     // 지형 생성
     createTerrain();
     
-    // 적 로드
+    console.log('Starting to load enemies...');
     loadEnemies();
 }
 
@@ -130,29 +153,12 @@ function createTerrain() {
     addObstacles();
 }
 
-function addObstacles() {
-    const rockGeometry = new THREE.DodecahedronGeometry(10);
-    const rockMaterial = new THREE.MeshStandardMaterial({
-        color: 0x8B4513,
-        roughness: 0.9
-    });
-
-    for (let i = 0; i < 100; i++) {
-        const rock = new THREE.Mesh(rockGeometry, rockMaterial);
-        rock.position.set(
-            (Math.random() - 0.5) * MAP_SIZE * 0.9,
-            Math.random() * 10,
-            (Math.random() - 0.5) * MAP_SIZE * 0.9
-        );
-        rock.rotation.set(
-            Math.random() * Math.PI,
-            Math.random() * Math.PI,
-            Math.random() * Math.PI
-        );
-        rock.castShadow = true;
-        rock.receiveShadow = true;
-        scene.add(rock);
-    }
+function createTemporaryEnemy(position) {
+    const geometry = new THREE.BoxGeometry(5, 5, 5);
+    const material = new THREE.MeshPhongMaterial({ color: 0xff0000 });
+    const cube = new THREE.Mesh(geometry, material);
+    cube.position.copy(position);
+    return cube;
 }
 
 function loadEnemies() {
@@ -160,21 +166,32 @@ function loadEnemies() {
     const enemyCount = 3 + currentStage;
 
     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,
+            10,
+            Math.sin(angle) * radius
+        );
+
+        // 임시 적 생성
+        const tempEnemy = createTemporaryEnemy(position);
+        scene.add(tempEnemy);
+        enemies.push({
+            model: tempEnemy,
+            health: 100,
+            speed: 0.3 + (currentStage * 0.1),
+            lastAttackTime: 0
+        });
+
+        // GLB 모델 로드 시도
         const modelPath = ENEMY_MODELS[i % ENEMY_MODELS.length];
-        
-        loader.load(modelPath, 
+        loader.load(modelPath,
             (gltf) => {
-                console.log('Enemy model loaded successfully:', modelPath);
+                console.log('Enemy model loaded:', modelPath);
                 const enemy = gltf.scene;
                 enemy.scale.set(ENEMY_SCALE, ENEMY_SCALE, ENEMY_SCALE);
-                
-                const angle = (i / enemyCount) * Math.PI * 2;
-                const radius = 200;
-                enemy.position.set(
-                    Math.cos(angle) * radius,
-                    10,
-                    Math.sin(angle) * radius
-                );
+                enemy.position.copy(position);
 
                 enemy.traverse((node) => {
                     if (node.isMesh) {
@@ -185,13 +202,13 @@ function loadEnemies() {
                     }
                 });
 
+                // 임시 적을 실제 모델로 교체
+                scene.remove(tempEnemy);
                 scene.add(enemy);
-                enemies.push({
-                    model: enemy,
-                    health: 100,
-                    speed: 0.3 + (currentStage * 0.1),
-                    lastAttackTime: 0
-                });
+                const index = enemies.findIndex(e => e.model === tempEnemy);
+                if (index !== -1) {
+                    enemies[index].model = enemy;
+                }
             },
             (xhr) => {
                 console.log((xhr.loaded / xhr.total * 100) + '% loaded');
@@ -203,6 +220,31 @@ function loadEnemies() {
     }
 }
 
+function addObstacles() {
+    const rockGeometry = new THREE.DodecahedronGeometry(10);
+    const rockMaterial = new THREE.MeshStandardMaterial({
+        color: 0x8B4513,
+        roughness: 0.9
+    });
+
+    for (let i = 0; i < 100; i++) {
+        const rock = new THREE.Mesh(rockGeometry, rockMaterial);
+        rock.position.set(
+            (Math.random() - 0.5) * MAP_SIZE * 0.9,
+            Math.random() * 10,
+            (Math.random() - 0.5) * MAP_SIZE * 0.9
+        );
+        rock.rotation.set(
+            Math.random() * Math.PI,
+            Math.random() * Math.PI,
+            Math.random() * Math.PI
+        );
+        rock.castShadow = true;
+        rock.receiveShadow = true;
+        scene.add(rock);
+    }
+}
+
 function onClick() {
     if (!controls.isLocked) {
         controls.lock();