Update game.js

game.js

@@ -825,17 +825,17 @@ class Game {
         mainLight.castShadow = true;
 
         // 그림자 품질 향상
-        mainLight.shadow.mapSize.width = 4096;  // 그림자 해상도 증가
+        mainLight.shadow.mapSize.width = 4096;
         mainLight.shadow.mapSize.height = 4096;
         mainLight.shadow.camera.near = 0.5;
-        mainLight.shadow.camera.far = MAP_SIZE * 2;  // 그림자 거리 증가
-        mainLight.shadow.camera.left = -MAP_SIZE;    // 그림자 영역 확장
+        mainLight.shadow.camera.far = MAP_SIZE * 2;
+        mainLight.shadow.camera.left = -MAP_SIZE;
         mainLight.shadow.camera.right = MAP_SIZE;
         mainLight.shadow.camera.top = MAP_SIZE;
         mainLight.shadow.camera.bottom = -MAP_SIZE;
         mainLight.shadow.bias = -0.001;
         mainLight.shadow.radius = 2;
-        mainLight.shadow.normalBias = 0.02;     // 그림자 아티팩트 감소
+        mainLight.shadow.normalBias = 0.02;
 
         this.scene.add(mainLight);
 
@@ -852,8 +852,8 @@ class Game {
         );
         this.scene.add(hemisphereLight);
 
-        // 지형 생성 수정
-        const groundGeometry = new THREE.PlaneGeometry(MAP_SIZE, MAP_SIZE, 100, 100);
+        // 지형 생성 수정 - 완전히 평평하게
+        const groundGeometry = new THREE.PlaneGeometry(MAP_SIZE, MAP_SIZE, 1, 1);
         const groundMaterial = new THREE.MeshStandardMaterial({
             color: 0xD2B48C,
             roughness: 0.8,
@@ -865,41 +865,10 @@ class Game {
         ground.rotation.x = -Math.PI / 2;
         ground.receiveShadow = true;
 
-        // 지형 높이 설정
+        // 모든 정점의 높이를 0으로 설정
         const vertices = ground.geometry.attributes.position.array;
-        const heightScale = 15;
-        const baseFrequency = 0.008;
-        
-        // 평지 영역 정의
-        const flatlandRadius = MAP_SIZE * 0.3;
-        const transitionZone = MAP_SIZE * 0.1;
-
         for (let i = 0; i < vertices.length; i += 3) {
-            const x = vertices[i];
-            const y = vertices[i + 1];
-            
-            const distanceFromCenter = Math.sqrt(x * x + y * y);
-            
-            if (distanceFromCenter < flatlandRadius) {
-                vertices[i + 2] = 0;
-            }
-            else if (distanceFromCenter < flatlandRadius + transitionZone) {
-                const transitionFactor = (distanceFromCenter - flatlandRadius) / transitionZone;
-                let height = 0;
-                
-                height += Math.sin(x * baseFrequency) * Math.cos(y * baseFrequency) * heightScale;
-                height += Math.sin(x * baseFrequency * 2) * Math.cos(y * baseFrequency * 2) * (heightScale * 0.5);
-                height += Math.sin(x * baseFrequency * 4) * Math.cos(y * baseFrequency * 4) * (heightScale * 0.25);
-                
-                vertices[i + 2] = height * transitionFactor;
-            }
-            else {
-                let height = 0;
-                height += Math.sin(x * baseFrequency) * Math.cos(y * baseFrequency) * heightScale;
-                height += Math.sin(x * baseFrequency * 2) * Math.cos(y * baseFrequency * 2) * (heightScale * 0.5);
-                height += Math.sin(x * baseFrequency * 4) * Math.cos(y * baseFrequency * 4) * (heightScale * 0.25);
-                vertices[i + 2] = height;
-            }
+            vertices[i + 2] = 0;
         }
 
         ground.geometry.attributes.position.needsUpdate = true;
@@ -907,28 +876,16 @@ class Game {
         this.ground = ground;
         this.scene.add(ground);
 
-        // 등고선 효과
-        const contourMaterial = new THREE.LineBasicMaterial({
-            color: 0x000000,
-            opacity: 0.15,
-            transparent: true
-        });
-
-        const contourLines = new THREE.LineSegments(
-            new THREE.EdgesGeometry(groundGeometry),
-            contourMaterial
-        );
-        contourLines.rotation.x = -Math.PI / 2;
-        contourLines.position.y = 0.1;
-        this.scene.add(contourLines);
-
-        // 격자 효과
-        const gridHelper = new THREE.GridHelper(flatlandRadius * 2, 50, 0x000000, 0x000000);
+        // 격자 효과 추가
+        const gridHelper = new THREE.GridHelper(MAP_SIZE, 50, 0x000000, 0x000000);
         gridHelper.material.opacity = 0.1;
         gridHelper.material.transparent = true;
         gridHelper.position.y = 0.1;
         this.scene.add(gridHelper);
 
+        // 장애물 배열 초기화
+        this.obstacles = [];
+
         // 사막 장식 추가
         await this.addDesertDecorations();
         
@@ -938,26 +895,11 @@ class Game {
             throw new Error('Tank loading failed');
         }
 
-        // 스폰 위치 검증 및 재시작 로직
+        // 스폰 위치 검증
         const spawnPos = this.findValidSpawnPosition();
-        const heightAtSpawn = this.getHeightAtPosition(spawnPos.x, spawnPos.z);
-        const slopeCheckPoints = [
-            { x: spawnPos.x + 2, z: spawnPos.z },
-            { x: spawnPos.x - 2, z: spawnPos.z },
-            { x: spawnPos.x, z: spawnPos.z + 2 },
-            { x: spawnPos.x, z: spawnPos.z - 2 }
-        ];
-
-        const slopes = slopeCheckPoints.map(point => {
-            const pointHeight = this.getHeightAtPosition(point.x, point.z);
-            return Math.abs(pointHeight - heightAtSpawn) / 2;
-        });
-
-        const maxSlope = Math.max(...slopes);
-        if (maxSlope > 0.3) {
-            location.reload();
-            return;
-        }
+        
+        // 탱크 스폰 위치 설정
+        this.tank.body.position.copy(spawnPos);
 
         // 카메라 초기 위치 설정
         const tankPosition = this.tank.getPosition();
@@ -1037,64 +979,88 @@ class Game {
     }
 
     async addDesertDecorations() {
-        // 바위 생성
-        const rockGeometries = [
-            new THREE.DodecahedronGeometry(3),
-            new THREE.DodecahedronGeometry(2),
-            new THREE.DodecahedronGeometry(4)
-        ];
+    this.obstacles = [];  // 장애물 배열 초기화
 
-        const rockMaterial = new THREE.MeshStandardMaterial({
-            color: 0x8B4513,
-            roughness: 0.9,
-            metalness: 0.1
-        });
+    // 바위 생성 (200개로 증가)
+    const rockGeometries = [
+        new THREE.DodecahedronGeometry(3),
+        new THREE.DodecahedronGeometry(2),
+        new THREE.DodecahedronGeometry(4)
+    ];
 
-        for (let i = 0; i < 100; i++) {
-            const rockGeometry = rockGeometries[Math.floor(Math.random() * rockGeometries.length)];
-            const rock = new THREE.Mesh(rockGeometry, rockMaterial);
-          rock.position.set(
-               (Math.random() - 0.5) * MAP_SIZE * 0.9,
-               Math.random() * 2,
-               (Math.random() - 0.5) * MAP_SIZE * 0.9
-           );
-           
-           rock.rotation.set(
-               Math.random() * Math.PI,
-               Math.random() * Math.PI,
-               Math.random() * Math.PI
-           );
-           
-           rock.scale.set(
-               1 + Math.random() * 0.5,
-               1 + Math.random() * 0.5,
-               1 + Math.random() * 0.5
-           );
-           
-           rock.castShadow = true;
-           rock.receiveShadow = true;
-           this.scene.add(rock);
-       }
+    const rockMaterial = new THREE.MeshStandardMaterial({
+        color: 0x8B4513,
+        roughness: 0.9,
+        metalness: 0.1
+    });
 
-       // 선인장 추가 (간단한 geometry로 표현)
-       const cactusGeometry = new THREE.CylinderGeometry(0.5, 0.7, 4, 8);
-       const cactusMaterial = new THREE.MeshStandardMaterial({
-           color: 0x2F4F2F,
-           roughness: 0.8
-       });
+    for (let i = 0; i < 200; i++) {
+        const rockGeometry = rockGeometries[Math.floor(Math.random() * rockGeometries.length)];
+        const rock = new THREE.Mesh(rockGeometry, rockMaterial);
+        
+        const position = new THREE.Vector3(
+            (Math.random() - 0.5) * MAP_SIZE * 0.9,
+            Math.random() * 2,
+            (Math.random() - 0.5) * MAP_SIZE * 0.9
+        );
+        
+        rock.position.copy(position);
+        rock.rotation.set(
+            Math.random() * Math.PI,
+            Math.random() * Math.PI,
+            Math.random() * Math.PI
+        );
+        
+        rock.scale.set(
+            1 + Math.random() * 0.5,
+            1 + Math.random() * 0.5,
+            1 + Math.random() * 0.5
+        );
+        
+        rock.castShadow = true;
+        rock.receiveShadow = true;
+
+        // 충돌 박스 생성 및 저장
+        const boundingBox = new THREE.Box3().setFromObject(rock);
+        this.obstacles.push({
+            mesh: rock,
+            boundingBox: boundingBox,
+            type: 'rock'
+        });
+        
+        this.scene.add(rock);
+    }
 
-       for (let i = 0; i < 50; i++) {
-           const cactus = new THREE.Mesh(cactusGeometry, cactusMaterial);
-           cactus.position.set(
-               (Math.random() - 0.5) * MAP_SIZE * 0.8,
-               2,
-               (Math.random() - 0.5) * MAP_SIZE * 0.8
-           );
-           cactus.castShadow = true;
-           cactus.receiveShadow = true;
-           this.scene.add(cactus);
-       }
-   }
+    // 선인장 추가 (100개로 증가)
+    const cactusGeometry = new THREE.CylinderGeometry(0.5, 0.7, 4, 8);
+    const cactusMaterial = new THREE.MeshStandardMaterial({
+        color: 0x2F4F2F,
+        roughness: 0.8
+    });
+
+    for (let i = 0; i < 100; i++) {
+        const cactus = new THREE.Mesh(cactusGeometry, cactusMaterial);
+        const position = new THREE.Vector3(
+            (Math.random() - 0.5) * MAP_SIZE * 0.8,
+            2,
+            (Math.random() - 0.5) * MAP_SIZE * 0.8
+        );
+        
+        cactus.position.copy(position);
+        cactus.castShadow = true;
+        cactus.receiveShadow = true;
+
+        // 선인장 충돌 박스 생성 및 저장
+        const boundingBox = new THREE.Box3().setFromObject(cactus);
+        this.obstacles.push({
+            mesh: cactus,
+            boundingBox: boundingBox,
+            type: 'cactus'
+        });
+        
+        this.scene.add(cactus);
+    }
+}
 
    getHeightAtPosition(x, z) {
         if (!this.ground) return 0;
@@ -1517,171 +1483,123 @@ class Game {
     const beatSounds = ['sounds/beat1.ogg', 'sounds/beat2.ogg', 'sounds/beat3.ogg'];
 
     const tankPosition = this.tank.getPosition();
-    // 적 총알과 플레이어 탱크 충돌 체크
+    const tankBoundingBox = new THREE.Box3().setFromObject(this.tank.body);
+
+    // 탱크와 장애물(바위, 선인장) 충돌 체크
+    this.obstacles.forEach(obstacle => {
+        obstacle.boundingBox.setFromObject(obstacle.mesh);
+        if (tankBoundingBox.intersectsBox(obstacle.boundingBox)) {
+            this.tank.body.position.copy(this.previousTankPosition);
+        }
+    });
+
+    // 적 총알 충돌 체크
     this.enemies.forEach(enemy => {
         if (!enemy.mesh || !enemy.isLoaded) return;
 
         enemy.bullets.forEach(bullet => {
-            const distance = bullet.position.distanceTo(tankPosition);
-            if (distance < 1) {
-                // 플레이어 피격 사운드 재생
-                const randomBeatSound = beatSounds[Math.floor(Math.random() * beatSounds.length)];
-                const beatAudio = new Audio(randomBeatSound);
-                beatAudio.play();
-
-                if (this.tank.takeDamage(250)) { // 데미지를 250으로 수정
-                    this.endGame();
+            const bulletBox = new THREE.Box3().setFromObject(bullet);
+            let bulletDestroyed = false;
+
+            // 총알과 장애물 충돌 체크
+            for (const obstacle of this.obstacles) {
+                if (bulletBox.intersectsBox(obstacle.boundingBox)) {
+                    this.createExplosion(bullet.position);
+                    this.scene.remove(bullet);
+                    enemy.bullets = enemy.bullets.filter(b => b !== bullet);
+                    bulletDestroyed = true;
+                    break;
+                }
+            }
+
+            // 총알이 장애물에 맞지 않았다면 플레이어와 충돌 체크
+            if (!bulletDestroyed) {
+                const distance = bullet.position.distanceTo(tankPosition);
+                if (distance < 1) {
+                    const randomBeatSound = beatSounds[Math.floor(Math.random() * beatSounds.length)];
+                    const beatAudio = new Audio(randomBeatSound);
+                    beatAudio.play();
+
+                    if (this.tank.takeDamage(250)) {
+                        this.endGame();
+                    }
+                    this.scene.remove(bullet);
+                    enemy.bullets = enemy.bullets.filter(b => b !== bullet);
+                    this.createExplosion(bullet.position);
+                    document.getElementById('health').style.width = 
+                        `${(this.tank.health / MAX_HEALTH) * 100}%`;
                 }
-                this.scene.remove(bullet);
-                enemy.bullets = enemy.bullets.filter(b => b !== bullet);
-                
-                this.createExplosion(bullet.position);
-                document.getElementById('health').style.width = 
-                    `${(this.tank.health / MAX_HEALTH) * 100}%`;
             }
         });
     });
 
-    // 플레이어 총알과 적 충돌 체크
+    // 플레이어 총알 충돌 체크
     this.tank.bullets.forEach((bullet, bulletIndex) => {
-        this.enemies.forEach((enemy, enemyIndex) => {
-            if (!enemy.mesh || !enemy.isLoaded) return;
+        const bulletBox = new THREE.Box3().setFromObject(bullet);
+        let bulletDestroyed = false;
 
-            const distance = bullet.position.distanceTo(enemy.mesh.position);
-            if (distance < 2) {
-                // 적 피격 사운드 재생
-                const randomHitSound = hitSounds[Math.floor(Math.random() * hitSounds.length)];
-                const hitAudio = new Audio(randomHitSound);
-                hitAudio.play();
-
-                if (enemy.takeDamage(50)) {
-                    enemy.destroy();
-                    this.enemies.splice(enemyIndex, 1);
-                    this.score += 100;
-                    document.getElementById('score').textContent = `Score: ${this.score}`;
-                }
+        // 총알과 장애물 충돌 체크
+        for (const obstacle of this.obstacles) {
+            if (bulletBox.intersectsBox(obstacle.boundingBox)) {
+                this.createExplosion(bullet.position);
                 this.scene.remove(bullet);
                 this.tank.bullets.splice(bulletIndex, 1);
-                this.createExplosion(bullet.position);
+                bulletDestroyed = true;
+                break;
             }
-        });
+        }
+
+        // 총알이 장애물에 맞지 않았다면 적과 충돌 체크
+        if (!bulletDestroyed) {
+            this.enemies.forEach((enemy, enemyIndex) => {
+                if (!enemy.mesh || !enemy.isLoaded) return;
+
+                const distance = bullet.position.distanceTo(enemy.mesh.position);
+                if (distance < 2) {
+                    const randomHitSound = hitSounds[Math.floor(Math.random() * hitSounds.length)];
+                    const hitAudio = new Audio(randomHitSound);
+                    hitAudio.play();
+
+                    if (enemy.takeDamage(50)) {
+                        enemy.destroy();
+                        this.enemies.splice(enemyIndex, 1);
+                        this.score += 100;
+                        document.getElementById('score').textContent = `Score: ${this.score}`;
+                    }
+                    this.scene.remove(bullet);
+                    this.tank.bullets.splice(bulletIndex, 1);
+                    this.createExplosion(bullet.position);
+                }
+            });
+        }
     });
 
-    // 플레이어 탱크와 적 전차 충돌 체크
-    const tankBoundingBox = new THREE.Box3().setFromObject(this.tank.body);
+    // 적 탱크의 충돌 체크
     this.enemies.forEach(enemy => {
         if (!enemy.mesh || !enemy.isLoaded) return;
         
-        const enemyBoundingBox = new THREE.Box3().setFromObject(enemy.mesh);
-        if (tankBoundingBox.intersectsBox(enemyBoundingBox)) {
+        const enemyBox = new THREE.Box3().setFromObject(enemy.mesh);
+        
+        // 적 탱크와 장애물 충돌 체크
+        for (const obstacle of this.obstacles) {
+            if (enemyBox.intersectsBox(obstacle.boundingBox)) {
+                enemy.mesh.position.copy(enemy.lastPosition || enemy.mesh.position);
+                break;
+            }
+        }
+
+        // 적 탱크와 플레이어 탱크 충돌 체크
+        if (tankBoundingBox.intersectsBox(enemyBox)) {
             this.tank.body.position.copy(this.previousTankPosition);
         }
+
+        // 적 탱크의 현재 위치 저장
+        enemy.lastPosition = enemy.mesh.position.clone();
     });
 
     // 이전 위치 저장
     this.previousTankPosition.copy(this.tank.body.position);
 }
-  endGame() {
-    if (this.isGameOver) return;
-    
-    this.isGameOver = true;
-    
-    // 사망 사운드 재생
-    const deathSounds = ['sounds/death1.ogg', 'sounds/death2.ogg'];
-    const randomDeathSound = deathSounds[Math.floor(Math.random() * deathSounds.length)];
-    const deathAudio = new Audio(randomDeathSound);
-    deathAudio.play();
-    
-    if (this.gameTimer) {
-        clearInterval(this.gameTimer);
-    }
-
-    if (this.animationFrameId) {
-        cancelAnimationFrame(this.animationFrameId);
-    }
-
-    document.exitPointerLock();
-
-    const gameOverDiv = document.createElement('div');
-    gameOverDiv.style.position = 'absolute';
-    gameOverDiv.style.top = '50%';
-    gameOverDiv.style.left = '50%';
-    gameOverDiv.style.transform = 'translate(-50%, -50%)';
-    gameOverDiv.style.color = '#0f0';
-    gameOverDiv.style.fontSize = '48px';
-    gameOverDiv.style.backgroundColor = 'rgba(0, 20, 0, 0.7)';
-    gameOverDiv.style.padding = '20px';
-    gameOverDiv.style.borderRadius = '10px';
-    gameOverDiv.style.textAlign = 'center';
-    gameOverDiv.innerHTML = `
-        Game Over<br>
-        Score: ${this.score}<br>
-        Time Survived: ${GAME_DURATION - this.gameTime}s<br>
-        <button onclick="location.reload()" 
-                style="font-size: 24px; padding: 10px; margin-top: 20px; 
-                       cursor: pointer; background: #0f0; border: none; 
-                       color: black; border-radius: 5px;">
-            Play Again
-        </button>
-    `;
-    document.body.appendChild(gameOverDiv);
-}
-
-   updateUI() {
-       if (!this.isGameOver) {
-           const healthBar = document.getElementById('health');
-           if (healthBar) {
-               healthBar.style.width = `${(this.tank.health / MAX_HEALTH) * 100}%`;
-           }
-
-           const timeElement = document.getElementById('time');
-           if (timeElement) {
-               timeElement.textContent = `Time: ${this.gameTime}s`;
-           }
-
-           const scoreElement = document.getElementById('score');
-           if (scoreElement) {
-               scoreElement.textContent = `Score: ${this.score}`;
-           }
-       }
-   }
-
-   animate() {
-       if (this.isGameOver) {
-           if (this.animationFrameId) {
-               cancelAnimationFrame(this.animationFrameId);
-           }
-           return;
-       }
-
-       this.animationFrameId = requestAnimationFrame(() => this.animate());
-
-       const currentTime = performance.now();
-       const deltaTime = (currentTime - this.lastTime) / 1000;
-       this.lastTime = currentTime;
-
-       if (!this.isLoading) {
-           this.handleMovement();
-           this.tank.update(this.mouse.x, this.mouse.y, this.scene);
-           
-           const tankPosition = this.tank.getPosition();
-           this.enemies.forEach(enemy => {
-               enemy.update(tankPosition);
-               
-               if (enemy.isLoaded && enemy.mesh.position.distanceTo(tankPosition) < ENEMY_CONFIG.ATTACK_RANGE) {
-                   enemy.shoot(tankPosition);
-               }
-           });
-
-           this.updateParticles();
-           this.checkCollisions();
-           this.updateUI();
-           this.updateRadar(); // 레이더 업데이트 추가
-       }
-       
-       this.renderer.render(this.scene, this.camera);
-   }
-}
 
 // Start game
 window.startGame = function() {