Update game.js

game.js

@@ -43,6 +43,21 @@ class TankPlayer {
         this.camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
         this.renderer = new THREE.WebGLRenderer({ antialias: true });
     }
+        createCollisionBox() {
+            // 탱크 몸체에 맞는 충돌 박스 생성
+            const dimensions = new THREE.Vector3(4, 2, 7); // 탱크의 대략적인 크기
+            const geometry = new THREE.BoxGeometry(dimensions.x, dimensions.y, dimensions.z);
+            const material = new THREE.MeshBasicMaterial({
+                color: 0xff0000,
+                wireframe: true,
+                visible: false // 디버깅시 true로 변경
+            });
+            
+            this.collisionBox = new THREE.Mesh(geometry, material);
+            this.body.add(this.collisionBox);
+            this.collisionBox.position.set(0, dimensions.y / 2, 0);
+        }
+
      // 별도의 메서드로 분리
     createExplosionEffect(scene, position) {
     // 폭발 중심 플래시
@@ -170,7 +185,7 @@ class TankPlayer {
         this.turretGroup.add(this.turret);
         this.body.add(this.turretGroup);
         
-        // 그림자 설정은 그대로 유지
+        // 그림자 설정
         this.body.traverse((child) => {
             if (child.isMesh) {
                 child.castShadow = true;
@@ -200,57 +215,15 @@ class TankPlayer {
         this.shadowPlane.position.y = 0.1;
         this.body.add(this.shadowPlane);
 
-        // 간단한 스폰 위치 설정
+        // 스폰 위치 설정
         const spawnPosition = new THREE.Vector3(
-            (Math.random() - 0.5) * (MAP_SIZE * 0.8), // MAP_SIZE의 80%만 사용
-            TANK_HEIGHT, // 고정된 높이 사용
+            (Math.random() - 0.5) * (MAP_SIZE * 0.8),
+            TANK_HEIGHT,
             (Math.random() - 0.5) * (MAP_SIZE * 0.8)
         );
         
         this.body.position.copy(spawnPosition);
-
-        // 폭발 이펙트 메서드 추가
-        this.createExplosionEffect = (scene, position) => {
-            // 폭발 파티클
-            for (let i = 0; i < 15; i++) {
-                const size = Math.random() * 0.2 + 0.1;
-                const geometry = new THREE.SphereGeometry(size);
-                const material = new THREE.MeshBasicMaterial({
-                    color: Math.random() < 0.5 ? 0xff4500 : 0xff8c00
-                });
-                const particle = new THREE.Mesh(geometry, material);
-                particle.position.copy(position);
-
-                const speed = Math.random() * 0.3 + 0.2;
-                const angle = Math.random() * Math.PI * 2;
-                const elevation = Math.random() * Math.PI - Math.PI / 2;
-
-                particle.velocity = new THREE.Vector3(
-                    Math.cos(angle) * Math.cos(elevation) * speed,
-                    Math.sin(elevation) * speed,
-                    Math.sin(angle) * Math.cos(elevation) * speed
-                );
-
-                particle.gravity = -0.01;
-                particle.life = Math.random() * 20 + 20;
-                particle.fadeRate = 1 / particle.life;
-
-                scene.add(particle);
-                window.gameInstance.particles.push({
-                    mesh: particle,
-                    velocity: particle.velocity,
-                    gravity: particle.gravity,
-                    life: particle.life,
-                    fadeRate: particle.fadeRate
-                });
-            }
-
-            // 충돌 사운드 재생
-            const explosionSound = new Audio('sounds/explosion.ogg');
-            explosionSound.volume = 0.3;
-            explosionSound.play();
-        };
-
+        this.createCollisionBox();
         scene.add(this.body);
         this.isLoaded = true;
         this.updateAmmoDisplay();
@@ -580,6 +553,25 @@ class Enemy {
         this.isLoaded = false;
         this.moveSpeed = type === 'tank' ? ENEMY_MOVE_SPEED : ENEMY_MOVE_SPEED * 0.7;
     }
+    createCollisionBox() {
+        const dimensions = new THREE.Vector3(4, 2, 7);
+        const geometry = new THREE.BoxGeometry(dimensions.x, dimensions.y, dimensions.z);
+        const material = new THREE.MeshBasicMaterial({
+            color: 0xff0000,
+            wireframe: true,
+            visible: false
+        });
+        
+        this.collisionBox = new THREE.Mesh(geometry, material);
+        this.mesh.add(this.collisionBox);
+        this.collisionBox.position.set(0, dimensions.y / 2, 0);
+    }
+
+    async initialize(loader) {
+        await super.initialize(loader);
+        this.createCollisionBox();
+    }
+}
     createMuzzleFlash() {
     if (!this.mesh) return;
     
@@ -637,29 +629,29 @@ class Enemy {
     }, 500);
 }
 
-
     async initialize(loader) {
-        try {
-            const modelPath = this.type === 'tank' ? '/models/t90.glb' : '/models/t90.glb';
-            const result = await loader.loadAsync(modelPath);
-            this.mesh = result.scene;
-            this.mesh.position.copy(this.position);
-            this.mesh.scale.set(ENEMY_SCALE, ENEMY_SCALE, ENEMY_SCALE);
-            
-            this.mesh.traverse((child) => {
-                if (child.isMesh) {
-                    child.castShadow = true;
-                    child.receiveShadow = true;
-                }
-            });
-            
-            this.scene.add(this.mesh);
-            this.isLoaded = true;
-        } catch (error) {
-            console.error('Error loading enemy model:', error);
-            this.isLoaded = false;
-        }
+    try {
+        const modelPath = this.type === 'tank' ? '/models/t90.glb' : '/models/t90.glb';
+        const result = await loader.loadAsync(modelPath);
+        this.mesh = result.scene;
+        this.mesh.position.copy(this.position);
+        this.mesh.scale.set(ENEMY_SCALE, ENEMY_SCALE, ENEMY_SCALE);
+        
+        this.mesh.traverse((child) => {
+            if (child.isMesh) {
+                child.castShadow = true;
+                child.receiveShadow = true;
+            }
+        });
+        
+        this.createCollisionBox();
+        this.scene.add(this.mesh);
+        this.isLoaded = true;
+    } catch (error) {
+        console.error('Error loading enemy model:', error);
+        this.isLoaded = false;
     }
+}
 
     update(playerPosition) {
     if (!this.mesh || !this.isLoaded) return;
@@ -1718,37 +1710,71 @@ class Game {
    checkCollisions() {
     if (this.isLoading || !this.tank.isLoaded) return;
      
-    // 명중 사운드 배열 정의
     const hitSounds = [
         'sounds/hit1.ogg', 'sounds/hit2.ogg', 'sounds/hit3.ogg',
         'sounds/hit4.ogg', 'sounds/hit5.ogg', 'sounds/hit6.ogg', 'sounds/hit7.ogg'
     ];
     
-    // 피격 사운드 배열 정의
     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);
-
-    // 탱크와 장애물 충돌 체크 (개선)
+    
+    // 전차 충돌 박스 크기 조정
+    const tankBox = new THREE.Box3().setFromObject(this.tank.body);
+    const tankSize = new THREE.Vector3();
+    tankBox.getSize(tankSize);
+    
+    // 전차 충돌 박스 크기 수동 조정
+    const customTankBox = new THREE.Box3(
+        new THREE.Vector3(
+            tankPosition.x - tankSize.x * 0.4, // 너비 20% 감소
+            tankPosition.y - tankSize.y * 0.3, // 높이 40% 감소
+            tankPosition.z - tankSize.z * 0.4  // 길이 20% 감소
+        ),
+        new THREE.Vector3(
+            tankPosition.x + tankSize.x * 0.4,
+            tankPosition.y + tankSize.y * 0.3,
+            tankPosition.z + tankSize.z * 0.4
+        )
+    );
+
+    // 탱크와 장애물 충돌 체크
     this.obstacles.forEach(obstacle => {
-    if (obstacle.userData.isCollidable) { // 충돌 가능한 객체만 검사
-        const obstacleBoundingBox = new THREE.Box3().setFromObject(obstacle);
-        if (tankBoundingBox.intersectsBox(obstacleBoundingBox)) {
-            this.tank.body.position.copy(this.previousTankPosition);
+        if (obstacle.userData.isCollidable) {
+            const obstacleBox = new THREE.Box3().setFromObject(obstacle);
+            if (customTankBox.intersectsBox(obstacleBox)) {
+                this.tank.body.position.copy(this.previousTankPosition);
+            }
         }
-    }
-});
-        // 적 탱크와 장애물 충돌 체크 (추가)
+    });
+
+    // 적 탱크와 장애물 충돌 체크
     this.enemies.forEach(enemy => {
         if (!enemy.mesh || !enemy.isLoaded) return;
         
-        const enemyBoundingBox = new THREE.Box3().setFromObject(enemy.mesh);
+        const enemyBox = new THREE.Box3().setFromObject(enemy.mesh);
+        const enemySize = new THREE.Vector3();
+        enemyBox.getSize(enemySize);
+        
+        // 적 전차 충돌 박스 크기 수동 조정
+        const customEnemyBox = new THREE.Box3(
+            new THREE.Vector3(
+                enemy.mesh.position.x - enemySize.x * 0.4,
+                enemy.mesh.position.y - enemySize.y * 0.3,
+                enemy.mesh.position.z - enemySize.z * 0.4
+            ),
+            new THREE.Vector3(
+                enemy.mesh.position.x + enemySize.x * 0.4,
+                enemy.mesh.position.y + enemySize.y * 0.3,
+                enemy.mesh.position.z + enemySize.z * 0.4
+            )
+        );
+        
         const enemyPreviousPosition = enemy.mesh.position.clone();
         
         this.obstacles.forEach(obstacle => {
-            const obstacleBoundingBox = new THREE.Box3().setFromObject(obstacle);
-            if (enemyBoundingBox.intersectsBox(obstacleBoundingBox)) {
+            const obstacleBox = new THREE.Box3().setFromObject(obstacle);
+            if (customEnemyBox.intersectsBox(obstacleBox)) {
                 enemy.mesh.position.copy(enemyPreviousPosition);
             }
         });
@@ -1759,9 +1785,8 @@ class Game {
         if (!enemy.mesh || !enemy.isLoaded) return;
 
         enemy.bullets.forEach((bullet, bulletIndex) => {
-            const distance = bullet.position.distanceTo(tankPosition);
-            if (distance < 1) {
-                // 플레이어 피격 사운드 재생
+            const bulletBox = new THREE.Box3().setFromObject(bullet);
+            if (bulletBox.intersectsBox(customTankBox)) {
                 const randomBeatSound = beatSounds[Math.floor(Math.random() * beatSounds.length)];
                 const beatAudio = new Audio(randomBeatSound);
                 beatAudio.play();
@@ -1770,102 +1795,102 @@ class Game {
                     this.endGame();
                 }
                 this.scene.remove(bullet);
-                enemy.bullets.splice(bulletIndex, 1); // filter 대신 splice 사용
+                enemy.bullets.splice(bulletIndex, 1);
                 
-                this.createExplosion(bullet.position);
+                this.tank.createExplosionEffect(this.scene, bullet.position);
                 document.getElementById('health').style.width = 
                     `${(this.tank.health / MAX_HEALTH) * 100}%`;
             }
         });
     });
 
-    // 플레이어 포탄
-    // 포탄과 장애물 충돌 체크
-for (let i = this.tank.bullets.length - 1; i >= 0; i--) {
-    const bullet = this.tank.bullets[i];
-    const bulletBox = new THREE.Box3().setFromObject(bullet);
+    // 플레이어 포탄과 장애물 충돌 체크
+    for (let i = this.tank.bullets.length - 1; i >= 0; i--) {
+        const bullet = this.tank.bullets[i];
+        const bulletBox = new THREE.Box3().setFromObject(bullet);
 
-    for (const obstacle of this.obstacles) {
-        if (obstacle.userData.isCollidable) { // 충돌 가능한 객체만 검사
-            const obstacleBox = new THREE.Box3().setFromObject(obstacle);
-            if (bulletBox.intersectsBox(obstacleBox)) {
-                // 폭발 이펙트 생성
-                this.tank.createExplosionEffect(this.scene, bullet.position);
-                
-                // 포탄 제거
-                this.scene.remove(bullet);
-                this.tank.bullets.splice(i, 1);
-                break;
+        for (const obstacle of this.obstacles) {
+            if (obstacle.userData.isCollidable) {
+                const obstacleBox = new THREE.Box3().setFromObject(obstacle);
+                if (bulletBox.intersectsBox(obstacleBox)) {
+                    this.tank.createExplosionEffect(this.scene, bullet.position);
+                    this.scene.remove(bullet);
+                    this.tank.bullets.splice(i, 1);
+                    break;
+                }
             }
         }
     }
-}
 
-    // 적 탱크와 장애물 충돌 체크
-this.enemies.forEach(enemy => {
-    if (!enemy.mesh || !enemy.isLoaded) return;
-
-    enemy.bullets.forEach((bullet, bulletIndex) => {
-        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();
-            }
-            
-            // 기존의 createExplosion 대신 createExplosionEffect 사용
-            this.tank.createExplosionEffect(this.scene, bullet.position);
-            
-            this.scene.remove(bullet);
-            enemy.bullets.splice(bulletIndex, 1);
+    // 플레이어 총알과 적 충돌 체크
+    for (let i = this.tank.bullets.length - 1; i >= 0; i--) {
+        const bullet = this.tank.bullets[i];
+        const bulletBox = new THREE.Box3().setFromObject(bullet);
+        
+        for (let j = this.enemies.length - 1; j >= 0; j--) {
+            const enemy = this.enemies[j];
+            if (!enemy.mesh || !enemy.isLoaded) continue;
+
+            const enemyBox = new THREE.Box3().setFromObject(enemy.mesh);
+            const enemySize = new THREE.Vector3();
+            enemyBox.getSize(enemySize);
             
-            document.getElementById('health').style.width = 
-                `${(this.tank.health / MAX_HEALTH) * 100}%`;
-        }
-    });
-});
+            // 적 전차 충돌 박스 조정
+            const customEnemyBox = new THREE.Box3(
+                new THREE.Vector3(
+                    enemy.mesh.position.x - enemySize.x * 0.4,
+                    enemy.mesh.position.y - enemySize.y * 0.3,
+                    enemy.mesh.position.z - enemySize.z * 0.4
+                ),
+                new THREE.Vector3(
+                    enemy.mesh.position.x + enemySize.x * 0.4,
+                    enemy.mesh.position.y + enemySize.y * 0.3,
+                    enemy.mesh.position.z + enemySize.z * 0.4
+                )
+            );
 
+            if (bulletBox.intersectsBox(customEnemyBox)) {
+                const randomHitSound = hitSounds[Math.floor(Math.random() * hitSounds.length)];
+                const hitAudio = new Audio(randomHitSound);
+                hitAudio.play();
 
-    // 플레이어 총알과 적 충돌 체크
-    for (let i = this.tank.bullets.length - 1; i >= 0; i--) {
-    const bullet = this.tank.bullets[i];
-    for (let j = this.enemies.length - 1; j >= 0; j--) {
-        const enemy = this.enemies[j];
-        if (!enemy.mesh || !enemy.isLoaded) continue;
-
-        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(j, 1);
-                this.score += 100;
-                document.getElementById('score').textContent = `Score: ${this.score}`;
+                if (enemy.takeDamage(50)) {
+                    enemy.destroy();
+                    this.enemies.splice(j, 1);
+                    this.score += 100;
+                    document.getElementById('score').textContent = `Score: ${this.score}`;
+                }
+                
+                this.tank.createExplosionEffect(this.scene, bullet.position);
+                this.scene.remove(bullet);
+                this.tank.bullets.splice(i, 1);
+                break;
             }
-            
-            // 여기도 동일하게 수정
-            this.tank.createExplosionEffect(this.scene, bullet.position);
-            
-            this.scene.remove(bullet);
-            this.tank.bullets.splice(i, 1);
-            break;
         }
     }
-}
 
     // 플레이어 탱크와 적 전차 충돌 체크
     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);
+        const enemySize = new THREE.Vector3();
+        enemyBox.getSize(enemySize);
+        
+        const customEnemyBox = new THREE.Box3(
+            new THREE.Vector3(
+                enemy.mesh.position.x - enemySize.x * 0.4,
+                enemy.mesh.position.y - enemySize.y * 0.3,
+                enemy.mesh.position.z - enemySize.z * 0.4
+            ),
+            new THREE.Vector3(
+                enemy.mesh.position.x + enemySize.x * 0.4,
+                enemy.mesh.position.y + enemySize.y * 0.3,
+                enemy.mesh.position.z + enemySize.z * 0.4
+            )
+        );
+
+        if (customTankBox.intersectsBox(customEnemyBox)) {
             this.tank.body.position.copy(this.previousTankPosition);
         }
     });