Update game.js

game.js

@@ -43,21 +43,6 @@ 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) {
     // 폭발 중심 플래시
@@ -185,7 +170,7 @@ class TankPlayer {
         this.turretGroup.add(this.turret);
         this.body.add(this.turretGroup);
         
-        // 그림자 설정
+        // 그림자 설정은 그대로 유지
         this.body.traverse((child) => {
             if (child.isMesh) {
                 child.castShadow = true;
@@ -215,15 +200,57 @@ 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),
-            TANK_HEIGHT,
+            (Math.random() - 0.5) * (MAP_SIZE * 0.8), // MAP_SIZE의 80%만 사용
+            TANK_HEIGHT, // 고정된 높이 사용
             (Math.random() - 0.5) * (MAP_SIZE * 0.8)
         );
         
         this.body.position.copy(spawnPosition);
-        this.createCollisionBox();
+
+        // 폭발 이펙트 메서드 추가
+        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();
+        };
+
         scene.add(this.body);
         this.isLoaded = true;
         this.updateAmmoDisplay();
@@ -553,14 +580,80 @@ class Enemy {
         this.isLoaded = false;
         this.moveSpeed = type === 'tank' ? ENEMY_MOVE_SPEED : ENEMY_MOVE_SPEED * 0.7;
     }
+    createMuzzleFlash() {
+    if (!this.mesh) return;
+    
+    const flashGroup = new THREE.Group();
+    
+    // 화염 크기 증가 및 색상 변경
+    const flameGeometry = new THREE.SphereGeometry(1.0, 8, 8);
+    const flameMaterial = new THREE.MeshBasicMaterial({
+        color: 0xffa500, // 노란색으로 변경
+        transparent: true,
+        opacity: 0.8
+    });
+    const flame = new THREE.Mesh(flameGeometry, flameMaterial);
+    flame.scale.set(2, 2, 3);
+    flashGroup.add(flame);
+
+    // 연기 효과 크기 증가
+    const smokeGeometry = new THREE.SphereGeometry(0.8, 8, 8);
+    const smokeMaterial = new THREE.MeshBasicMaterial({
+        color: 0x555555,
+        transparent: true,
+        opacity: 0.5
+    });
+    
+    for (let i = 0; i < 5; i++) {
+        const smoke = new THREE.Mesh(smokeGeometry, smokeMaterial);
+        smoke.position.set(
+            Math.random() * 1 - 0.5,
+            Math.random() * 1 - 0.5,
+            -1 - Math.random()
+        );
+        smoke.scale.set(1.5, 1.5, 1.5);
+        flashGroup.add(smoke);
+    }
+
+    // 포구 위치 계산
+    const muzzleOffset = new THREE.Vector3(0, 0.5, 4);
+    const muzzlePosition = new THREE.Vector3();
+    const meshWorldQuaternion = new THREE.Quaternion();
+    
+    this.mesh.getWorldPosition(muzzlePosition);
+    this.mesh.getWorldQuaternion(meshWorldQuaternion);
+    
+    muzzleOffset.applyQuaternion(meshWorldQuaternion);
+    muzzlePosition.add(muzzleOffset);
+
+    flashGroup.position.copy(muzzlePosition);
+    flashGroup.quaternion.copy(meshWorldQuaternion);
+
+    this.scene.add(flashGroup);
+
+    // 이펙트 지속 시간 증가
+    setTimeout(() => {
+        this.scene.remove(flashGroup);
+    }, 500);
+}
+
 
     async initialize(loader) {
         try {
-            const result = await loader.loadAsync('/models/t90.glb');
+            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.setupMesh();
+            
+            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);
@@ -568,82 +661,230 @@ class Enemy {
         }
     }
 
-    setupMesh() {
-        this.mesh.traverse(child => {
-            if (child.isMesh) {
-                child.castShadow = true;
-                child.receiveShadow = true;
-            }
-        });
-        this.createCollisionBox();
-        this.scene.add(this.mesh);
-    }
-
-    createCollisionBox() {
-        const geometry = new THREE.BoxGeometry(4, 2, 7);
-        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, 1, 0);
-    }
-
     update(playerPosition) {
-        if (!this.isLoaded) return;
-        this.moveTowardsPlayer(playerPosition);
-        this.updateBullets();
-    }
+    if (!this.mesh || !this.isLoaded) return;
 
-    moveTowardsPlayer(playerPosition) {
-        const direction = new THREE.Vector3()
-            .subVectors(playerPosition, this.mesh.position)
-            .normalize();
+    const direction = new THREE.Vector3()
+        .subVectors(playerPosition, this.mesh.position)
+        .normalize();
+    
+    const distanceToPlayer = this.mesh.position.distanceTo(playerPosition);
+    const minDistance = 50;
+    
+    // 이전 위치 저장
+    const previousPosition = this.mesh.position.clone();
+    
+    if (distanceToPlayer > minDistance) {
+        const moveVector = direction.multiplyScalar(this.moveSpeed);
+        const newPosition = this.mesh.position.clone().add(moveVector);
+        
+        // 지형 높이 가져오기
+        const heightAtNewPos = window.gameInstance.getHeightAtPosition(
+            newPosition.x,
+            newPosition.z
+        );
+        newPosition.y = heightAtNewPos + TANK_HEIGHT;
+        
+        // 임시로 위치 이동하여 충돌 체크
+        const originalPosition = this.mesh.position.clone();
+        this.mesh.position.copy(newPosition);
+        
+        // 장애물과 충돌 체크
+        const enemyBox = new THREE.Box3().setFromObject(this.mesh);
+        let hasCollision = false;
+        
+        // 모든 장애물에 대해 충돌 검사
+        for (const obstacle of window.gameInstance.obstacles) {
+            const obstacleBox = new THREE.Box3().setFromObject(obstacle);
+            if (enemyBox.intersectsBox(obstacleBox)) {
+                hasCollision = true;
+                break;
+            }
+        }
+        
+        // 다른 적 탱크와의 충돌 검사
+        if (!hasCollision) {
+            for (const otherEnemy of window.gameInstance.enemies) {
+                if (otherEnemy !== this && otherEnemy.mesh) {
+                    const otherEnemyBox = new THREE.Box3().setFromObject(otherEnemy.mesh);
+                    if (enemyBox.intersectsBox(otherEnemyBox)) {
+                        hasCollision = true;
+                        break;
+                    }
+                }
+            }
+        }
+        
+        // 맵 경계 체크
+        const mapBoundary = MAP_SIZE / 2;
+        if (Math.abs(newPosition.x) > mapBoundary || 
+            Math.abs(newPosition.z) > mapBoundary) {
+            hasCollision = true;
+        }
+        
+        // 충돌이 있으면 이전 위치로 복귀, 없으면 새 위치 유지
+        if (hasCollision) {
+            this.mesh.position.copy(previousPosition);
+            
+            // 충돌 시 우회 경로 ���도
+            const alternateDirections = [
+                new THREE.Vector3(-direction.z, 0, direction.x), // 왼쪽으로 90도
+                new THREE.Vector3(direction.z, 0, -direction.x), // 오른쪽으로 90도
+                new THREE.Vector3(-direction.x, 0, -direction.z)  // 180도 회전
+            ];
+            
+            for (const altDirection of alternateDirections) {
+                const altMoveVector = altDirection.multiplyScalar(this.moveSpeed);
+                const altNewPosition = previousPosition.clone().add(altMoveVector);
+                
+                this.mesh.position.copy(altNewPosition);
+                const altEnemyBox = new THREE.Box3().setFromObject(this.mesh);
+                
+                let altHasCollision = false;
+                
+                // 새로운 방향에 대한 충돌 검사
+                for (const obstacle of window.gameInstance.obstacles) {
+                    const obstacleBox = new THREE.Box3().setFromObject(obstacle);
+                    if (altEnemyBox.intersectsBox(obstacleBox)) {
+                        altHasCollision = true;
+                        break;
+                    }
+                }
+                
+                if (!altHasCollision) {
+                    // 우회 경로가 가능하면 그 방향으로 이동
+                    break;
+                } else {
+                    // 우회도 불가능하면 이전 위치로 복귀
+                    this.mesh.position.copy(previousPosition);
+                }
+            }
+        }
+        
+        // 지형에 따른 기울기 조정
+        const forwardVector = new THREE.Vector3(0, 0, 1).applyQuaternion(this.mesh.quaternion);
+        const rightVector = new THREE.Vector3(1, 0, 0).applyQuaternion(this.mesh.quaternion);
+        
+        const frontHeight = window.gameInstance.getHeightAtPosition(
+            this.mesh.position.x + forwardVector.x,
+            this.mesh.position.z + forwardVector.z
+        );
+        const backHeight = window.gameInstance.getHeightAtPosition(
+            this.mesh.position.x - forwardVector.x,
+            this.mesh.position.z - forwardVector.z
+        );
+        const rightHeight = window.gameInstance.getHeightAtPosition(
+            this.mesh.position.x + rightVector.x,
+            this.mesh.position.z + rightVector.z
+        );
+        const leftHeight = window.gameInstance.getHeightAtPosition(
+            this.mesh.position.x - rightVector.x,
+            this.mesh.position.z - rightVector.z
+        );
         
-        const distanceToPlayer = this.mesh.position.distanceTo(playerPosition);
-        if (distanceToPlayer > 50) {
-            this.tryMove(direction);
+        const pitch = Math.atan2(frontHeight - backHeight, 2);
+        const roll = Math.atan2(rightHeight - leftHeight, 2);
+        
+        // 현재 회전 유지하면서 기울기만 적용
+        const currentRotation = this.mesh.rotation.y;
+        this.mesh.rotation.set(pitch, currentRotation, roll);
+    }
+    
+    // 플레이어를 향해 포탑 회전
+    this.mesh.lookAt(playerPosition);
+    
+    // 총알 업데이트
+    if (this.bullets) {
+        for (let i = this.bullets.length - 1; i >= 0; i--) {
+            const bullet = this.bullets[i];
+            bullet.position.add(bullet.velocity);
+            
+            // 총알이 맵 밖으로 나가거나 장애물과 충돌하면 제거
+            if (Math.abs(bullet.position.x) > MAP_SIZE / 2 || 
+                Math.abs(bullet.position.z) > MAP_SIZE / 2) {
+                this.scene.remove(bullet);
+                this.bullets.splice(i, 1);
+                continue;
+            }
+            
+            // 총알과 장애물 충돌 체크
+            const bulletBox = new THREE.Box3().setFromObject(bullet);
+            for (const obstacle of window.gameInstance.obstacles) {
+                const obstacleBox = new THREE.Box3().setFromObject(obstacle);
+                if (bulletBox.intersectsBox(obstacleBox)) {
+                    this.scene.remove(bullet);
+                    this.bullets.splice(i, 1);
+                    break;
+                }
+            }
         }
-        this.mesh.lookAt(playerPosition);
     }
+}
+
 
     shoot(playerPosition) {
-        if (Date.now() - this.lastAttackTime < ENEMY_CONFIG.ATTACK_INTERVAL) return;
+    const currentTime = Date.now();
+    const attackInterval = this.type === 'tank' ? 
+        ENEMY_CONFIG.ATTACK_INTERVAL : 
+        ENEMY_CONFIG.ATTACK_INTERVAL * 1.5;
 
-        const bullet = this.createBullet(playerPosition);
-        this.scene.add(bullet);
-        this.bullets.push(bullet);
-        this.lastAttackTime = Date.now();
+    if (currentTime - this.lastAttackTime < attackInterval) return;
 
-        new Audio('sounds/mbtfire5.ogg').play();
-    }
+    // 발사 이펙트 생성
+    this.createMuzzleFlash();
 
-    createBullet(targetPosition) {
-        const bullet = new THREE.Mesh(
-            new THREE.CylinderGeometry(0.2, 0.2, 2, 8),
-            new THREE.MeshBasicMaterial({ color: 0xff0000 })
-        );
+    // 발사 사운드 재생
+    const enemyFireSound = new Audio('sounds/mbtfire5.ogg');
+    enemyFireSound.volume = 0.3;
+    enemyFireSound.play();
 
-        const muzzlePosition = this.getMuzzlePosition();
-        bullet.position.copy(muzzlePosition);
-        
-        const direction = new THREE.Vector3()
-            .subVectors(targetPosition, muzzlePosition)
-            .normalize();
-        
-        bullet.velocity = direction.multiplyScalar(ENEMY_CONFIG.BULLET_SPEED);
-        return bullet;
-    }
+    // 포탄 생성 (플레이어와 유사하게 수정)
+    const bulletGeometry = new THREE.CylinderGeometry(0.2, 0.2, 2, 8);
+    const bulletMaterial = new THREE.MeshBasicMaterial({ 
+        color: 0xff0000,  // 빨간색 포탄
+        emissive: 0xff0000,
+        emissiveIntensity: 0.5
+    });
+    const bullet = new THREE.Mesh(bulletGeometry, bulletMaterial);
 
-    getMuzzlePosition() {
-        const muzzleOffset = new THREE.Vector3(0, 0.5, 4);
-        const position = new THREE.Vector3();
-        this.mesh.getWorldPosition(position);
-        muzzleOffset.applyQuaternion(this.mesh.quaternion);
-        return position.add(muzzleOffset);
-    }
+    // 포구 위치에서 발사
+    const muzzleOffset = new THREE.Vector3(0, 0.5, 4);
+    const muzzlePosition = new THREE.Vector3();
+    this.mesh.getWorldPosition(muzzlePosition);
+    muzzleOffset.applyQuaternion(this.mesh.quaternion);
+    muzzlePosition.add(muzzleOffset);
+    
+    bullet.position.copy(muzzlePosition);
+    
+    // 포탄 회전 설정
+    bullet.quaternion.copy(this.mesh.quaternion);
+    
+    const direction = new THREE.Vector3()
+        .subVectors(playerPosition, muzzlePosition)
+        .normalize();
+    
+    const bulletSpeed = this.type === 'tank' ? 
+        ENEMY_CONFIG.BULLET_SPEED : 
+        ENEMY_CONFIG.BULLET_SPEED * 0.8;
+    
+    bullet.velocity = direction.multiplyScalar(bulletSpeed);
+    
+    // 포탄 트레일 효과 추가
+    const trailGeometry = new THREE.CylinderGeometry(0.1, 0.1, 1, 8);
+    const trailMaterial = new THREE.MeshBasicMaterial({
+        color: 0xff4444,
+        transparent: true,
+        opacity: 0.5
+    });
+    
+    const trail = new THREE.Mesh(trailGeometry, trailMaterial);
+    trail.position.z = -1;
+    bullet.add(trail);
+    
+    this.scene.add(bullet);
+    this.bullets.push(bullet);
+    this.lastAttackTime = currentTime;
+}
 
     takeDamage(damage) {
         this.health -= damage;
@@ -1477,71 +1718,37 @@ 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 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
-        )
-    );
-
-    // 탱크와 장애물 충돌 체크
+    const tankBoundingBox = new THREE.Box3().setFromObject(this.tank.body);
+
+    // 탱크와 장애물 충돌 체크 (개선)
     this.obstacles.forEach(obstacle => {
-        if (obstacle.userData.isCollidable) {
-            const obstacleBox = new THREE.Box3().setFromObject(obstacle);
-            if (customTankBox.intersectsBox(obstacleBox)) {
-                this.tank.body.position.copy(this.previousTankPosition);
-            }
+    if (obstacle.userData.isCollidable) { // 충돌 가능한 객체만 검사
+        const obstacleBoundingBox = new THREE.Box3().setFromObject(obstacle);
+        if (tankBoundingBox.intersectsBox(obstacleBoundingBox)) {
+            this.tank.body.position.copy(this.previousTankPosition);
         }
-    });
-
-    // 적 탱크와 장애물 충돌 체크
+    }
+});
+        // 적 탱크와 장애물 충돌 체크 (추가)
     this.enemies.forEach(enemy => {
         if (!enemy.mesh || !enemy.isLoaded) return;
         
-        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 enemyBoundingBox = new THREE.Box3().setFromObject(enemy.mesh);
         const enemyPreviousPosition = enemy.mesh.position.clone();
         
         this.obstacles.forEach(obstacle => {
-            const obstacleBox = new THREE.Box3().setFromObject(obstacle);
-            if (customEnemyBox.intersectsBox(obstacleBox)) {
+            const obstacleBoundingBox = new THREE.Box3().setFromObject(obstacle);
+            if (enemyBoundingBox.intersectsBox(obstacleBoundingBox)) {
                 enemy.mesh.position.copy(enemyPreviousPosition);
             }
         });
@@ -1552,8 +1759,9 @@ class Game {
         if (!enemy.mesh || !enemy.isLoaded) return;
 
         enemy.bullets.forEach((bullet, bulletIndex) => {
-            const bulletBox = new THREE.Box3().setFromObject(bullet);
-            if (bulletBox.intersectsBox(customTankBox)) {
+            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();
@@ -1562,102 +1770,102 @@ class Game {
                     this.endGame();
                 }
                 this.scene.remove(bullet);
-                enemy.bullets.splice(bulletIndex, 1);
+                enemy.bullets.splice(bulletIndex, 1); // filter 대신 splice 사용
                 
-                this.tank.createExplosionEffect(this.scene, bullet.position);
+                this.createExplosion(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;
             }
         }
     }
+}
 
-    // 플레이어 총알과 적 충돌 체크
-    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);
+    // 적 탱크와 장애물 충돌 체크
+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();
+            }
             
-            // 적 전차 충돌 박스 조정
-            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
-                )
-            );
+            // 기존의 createExplosion 대신 createExplosionEffect 사용
+            this.tank.createExplosionEffect(this.scene, bullet.position);
+            
+            this.scene.remove(bullet);
+            enemy.bullets.splice(bulletIndex, 1);
+            
+            document.getElementById('health').style.width = 
+                `${(this.tank.health / MAX_HEALTH) * 100}%`;
+        }
+    });
+});
 
-            if (bulletBox.intersectsBox(customEnemyBox)) {
-                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}`;
-                }
-                
-                this.tank.createExplosionEffect(this.scene, bullet.position);
-                this.scene.remove(bullet);
-                this.tank.bullets.splice(i, 1);
-                break;
+    // 플레이어 총알과 적 충돌 체크
+    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}`;
             }
+            
+            // 여기도 동일하게 수정
+            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 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)) {
+        const enemyBoundingBox = new THREE.Box3().setFromObject(enemy.mesh);
+        if (tankBoundingBox.intersectsBox(enemyBoundingBox)) {
             this.tank.body.position.copy(this.previousTankPosition);
         }
     });