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, 1, 1);
+        // 지형 생성 수정
+        const groundGeometry = new THREE.PlaneGeometry(MAP_SIZE, MAP_SIZE, 100, 100);
         const groundMaterial = new THREE.MeshStandardMaterial({
             color: 0xD2B48C,
             roughness: 0.8,
@@ -865,10 +865,41 @@ 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) {
-            vertices[i + 2] = 0;
+            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;
+            }
         }
 
         ground.geometry.attributes.position.needsUpdate = true;
@@ -876,16 +907,28 @@ class Game {
         this.ground = ground;
         this.scene.add(ground);
 
-        // 격자 효과 추가
-        const gridHelper = new THREE.GridHelper(MAP_SIZE, 50, 0x000000, 0x000000);
+        // 등고선 효과
+        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);
         gridHelper.material.opacity = 0.1;
         gridHelper.material.transparent = true;
         gridHelper.position.y = 0.1;
         this.scene.add(gridHelper);
 
-        // 장애물 배열 초기화
-        this.obstacles = [];
-
         // 사막 장식 추가
         await this.addDesertDecorations();
         
@@ -895,11 +938,26 @@ class Game {
             throw new Error('Tank loading failed');
         }
 
-        // 스폰 위치 검증
+        // 스폰 위치 검증 및 재시작 로직
         const spawnPos = this.findValidSpawnPosition();
-        
-        // 탱크 스폰 위치 설정
-        this.tank.body.position.copy(spawnPos);
+        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;
+        }
 
         // 카메라 초기 위치 설정
         const tankPosition = this.tank.getPosition();
@@ -979,88 +1037,64 @@ class Game {
     }
 
     async addDesertDecorations() {
-    this.obstacles = [];  // 장애물 배열 초기화
-
-    // 바위 생성 (200개로 증가)
-    const rockGeometries = [
-        new THREE.DodecahedronGeometry(3),
-        new THREE.DodecahedronGeometry(2),
-        new THREE.DodecahedronGeometry(4)
-    ];
-
-    const rockMaterial = new THREE.MeshStandardMaterial({
-        color: 0x8B4513,
-        roughness: 0.9,
-        metalness: 0.1
-    });
+        // 바위 생성
+        const rockGeometries = [
+            new THREE.DodecahedronGeometry(3),
+            new THREE.DodecahedronGeometry(2),
+            new THREE.DodecahedronGeometry(4)
+        ];
 
-    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'
+        const rockMaterial = new THREE.MeshStandardMaterial({
+            color: 0x8B4513,
+            roughness: 0.9,
+            metalness: 0.1
         });
-        
-        this.scene.add(rock);
-    }
 
-    // 선인장 추가 (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 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);
+       }
 
-    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);
-    }
-}
+       // 선인장 추가 (간단한 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 < 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);
+       }
+   }
 
    getHeightAtPosition(x, z) {
         if (!this.ground) return 0;
@@ -1483,123 +1517,171 @@ 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 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}%`;
+            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();
                 }
+                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) => {
-        const bulletBox = new THREE.Box3().setFromObject(bullet);
-        let bulletDestroyed = false;
+        this.enemies.forEach((enemy, enemyIndex) => {
+            if (!enemy.mesh || !enemy.isLoaded) return;
 
-        // 총알과 장애물 충돌 체크
-        for (const obstacle of this.obstacles) {
-            if (bulletBox.intersectsBox(obstacle.boundingBox)) {
-                this.createExplosion(bullet.position);
+            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);
-                bulletDestroyed = true;
-                break;
+                this.createExplosion(bullet.position);
             }
-        }
-
-        // 총알이 장애물에 맞지 않았다면 적과 충돌 체크
-        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 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)) {
+        const enemyBoundingBox = new THREE.Box3().setFromObject(enemy.mesh);
+        if (tankBoundingBox.intersectsBox(enemyBoundingBox)) {
             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() {