Update game.js

game.js

@@ -572,115 +572,200 @@ class Enemy {
     constructor(scene, position, type = 'tank') {
         this.scene = scene;
         this.position = position;
+        this.mesh = null;
         this.type = type;
         this.health = type === 'tank' ? 100 : 200;
         this.lastAttackTime = 0;
         this.bullets = [];
         this.isLoaded = false;
         this.moveSpeed = type === 'tank' ? ENEMY_MOVE_SPEED : ENEMY_MOVE_SPEED * 0.7;
-        
-        // Add new properties for body and turret
-        this.body = null;
-        this.turret = null;
-        this.turretGroup = new THREE.Group();
     }
 
     async initialize(loader) {
-    try {
-        const bodyResult = await loader.loadAsync('/models/t90Body.glb');
-        this.body = bodyResult.scene;
-        
-        const turretResult = await loader.loadAsync('/models/t90Turret.glb');
-        this.turret = turretResult.scene;
+        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;
+        }
+    }
+
+    update(playerPosition) {
+    if (!this.mesh || !this.isLoaded) return;
+
+    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;
         
-        this.turretGroup.position.y = 0.2;
-        this.turretGroup.add(this.turret);
-        this.body.add(this.turretGroup);
+        // 임시로 위치 이동하여 충돌 체크
+        const originalPosition = this.mesh.position.clone();
+        this.mesh.position.copy(newPosition);
         
-        this.body.position.copy(this.position);
-        this.body.scale.set(ENEMY_SCALE, ENEMY_SCALE, ENEMY_SCALE);
+        // 장애물과 충돌 체크
+        const enemyBox = new THREE.Box3().setFromObject(this.mesh);
+        let hasCollision = false;
         
-        // 그림자 설정 최적화
-        this.body.traverse((child) => {
-            if (child.isMesh) {
-                child.castShadow = true;
-                child.receiveShadow = false; // 그림자 받기 비활성화
-                child.material.shadowSide = THREE.FrontSide; // 그림자 최적화
+        // 모든 장애물에 대해 충돌 검사
+        for (const obstacle of window.gameInstance.obstacles) {
+            const obstacleBox = new THREE.Box3().setFromObject(obstacle);
+            if (enemyBox.intersectsBox(obstacleBox)) {
+                hasCollision = true;
+                break;
             }
-        });
+        }
         
-        this.turret.traverse((child) => {
-            if (child.isMesh) {
-                child.castShadow = true;
-                child.receiveShadow = false; // 그림자 받기 비활성화
-                child.material.shadowSide = THREE.FrontSide; // 그림자 최적화
+        // 다른 적 탱크와의 충돌 검사
+        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;
+                    }
+                }
             }
-        });
-        
-        this.scene.add(this.body);
-        this.isLoaded = true;
-    } catch (error) {
-        console.error('Error loading enemy tank model:', error);
-        this.isLoaded = false;
-    }
-}
-  update(playerPosition) {
-        if (!this.body || !this.isLoaded) return;
-
-        // 플레이어 방향으로 이동 벡터 계산
-        const direction = new THREE.Vector3()
-            .subVectors(playerPosition, this.body.position)
-            .normalize();
+        }
         
-        // 플레이어와의 거리 계산
-        const distanceToPlayer = this.body.position.distanceTo(playerPosition);
-        const minDistance = 50; // 최소 거리 유지
+        // 맵 경계 체크
+        const mapBoundary = MAP_SIZE / 2;
+        if (Math.abs(newPosition.x) > mapBoundary || 
+            Math.abs(newPosition.z) > mapBoundary) {
+            hasCollision = true;
+        }
         
-        // 최소 거리보다 멀리 있을 때만 이동
-        if (distanceToPlayer > minDistance) {
-            const moveVector = direction.multiplyScalar(this.moveSpeed);
-            const newPosition = this.body.position.clone().add(moveVector);
+        // 충돌이 있으면 이전 위치로 복귀, 없으면 새 위치 유지
+        if (hasCollision) {
+            this.mesh.position.copy(previousPosition);
             
-            // 지형 높이에 맞춰 위치 조정
-            const heightAtNewPos = window.gameInstance.getHeightAtPosition(
-                newPosition.x,
-                newPosition.z
-            );
-            newPosition.y = heightAtNewPos + TANK_HEIGHT;
-            
-            // 차체 이동
-            this.body.position.copy(newPosition);
+            // 충돌 시 우회 경로 시도
+            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도 회전
+            ];
             
-            // 이동 방향으로 차체 회전
-            const targetRotation = Math.atan2(direction.x, direction.z);
-            this.body.rotation.y = targetRotation;
+            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 turretDirection = new THREE.Vector2(
-            playerPosition.x - this.body.position.x,
-            playerPosition.z - this.body.position.z
+        
+        // 지형에 따른 기울기 조정
+        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 turretAngle = Math.atan2(turretDirection.x, turretDirection.y);
-        this.turretGroup.rotation.y = turretAngle - this.body.rotation.y;
-
-        // 총알 업데이트
+        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 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;
+                }
             }
         }
     }
+}
+
 
     shoot(playerPosition) {
-        if (!this.turret) return;
-        
         const currentTime = Date.now();
         const attackInterval = this.type === 'tank' ? 
             ENEMY_CONFIG.ATTACK_INTERVAL : 
@@ -688,29 +773,16 @@ class Enemy {
 
         if (currentTime - this.lastAttackTime < attackInterval) return;
 
-        // 총알 생성
-        const bulletGeometry = new THREE.SphereGeometry(0.3);
+        const bulletGeometry = new THREE.SphereGeometry(this.type === 'tank' ? 0.2 : 0.3);
         const bulletMaterial = new THREE.MeshBasicMaterial({ 
             color: this.type === 'tank' ? 0xff0000 : 0xff6600 
         });
         const bullet = new THREE.Mesh(bulletGeometry, bulletMaterial);
 
-        // 포구 위치 계산
-        const muzzleOffset = new THREE.Vector3(0, 0.5, 4);
-        const muzzlePosition = new THREE.Vector3();
-        const turretWorldQuaternion = new THREE.Quaternion();
-        
-        this.turret.getWorldPosition(muzzlePosition);
-        this.turret.getWorldQuaternion(turretWorldQuaternion);
-        
-        muzzleOffset.applyQuaternion(turretWorldQuaternion);
-        muzzlePosition.add(muzzleOffset);
-        
-        bullet.position.copy(muzzlePosition);
+        bullet.position.copy(this.mesh.position);
         
-        // 발사 방향 계산
         const direction = new THREE.Vector3()
-            .subVectors(playerPosition, muzzlePosition)
+            .subVectors(playerPosition, this.mesh.position)
             .normalize();
         
         const bulletSpeed = this.type === 'tank' ? 
@@ -719,11 +791,6 @@ class Enemy {
         
         bullet.velocity = direction.multiplyScalar(bulletSpeed);
         
-        // 발사음 효과
-        const shootSound = new Audio('sounds/enemyfire.ogg');
-        shootSound.volume = 0.3;
-        shootSound.play();
-
         this.scene.add(bullet);
         this.bullets.push(bullet);
         this.lastAttackTime = currentTime;
@@ -735,161 +802,14 @@ class Enemy {
     }
 
     destroy() {
-        if (this.body) {
-            this.scene.remove(this.body);
+        if (this.mesh) {
+            this.scene.remove(this.mesh);
             this.bullets.forEach(bullet => this.scene.remove(bullet));
             this.bullets = [];
             this.isLoaded = false;
         }
     }
 }
-// 적 탱크의 발사 이펙트 생성
-    createMuzzleFlash() {
-        if (!this.turret) return;
-        
-        const flashGroup = new THREE.Group();
-        
-        // 화염 효과
-        const flameGeometry = new THREE.SphereGeometry(0.8);
-        const flameMaterial = new THREE.MeshBasicMaterial({
-            color: 0xff4500,
-            transparent: true,
-            opacity: 0.8
-        });
-        const flame = new THREE.Mesh(flameGeometry, flameMaterial);
-        flame.scale.set(1.5, 1.5, 2);
-        flashGroup.add(flame);
-
-        // 연기 효과
-        const smokeGeometry = new THREE.SphereGeometry(0.6);
-        const smokeMaterial = new THREE.MeshBasicMaterial({
-            color: 0x666666,
-            transparent: true,
-            opacity: 0.4
-        });
-        
-        for (let i = 0; i < 3; i++) {
-            const smoke = new THREE.Mesh(smokeGeometry, smokeMaterial);
-            smoke.position.set(
-                Math.random() * 0.5 - 0.25,
-                Math.random() * 0.5 - 0.25,
-                -0.5 - Math.random()
-            );
-            smoke.scale.set(1.2, 1.2, 1.2);
-            flashGroup.add(smoke);
-        }
-
-        // 포구 위치 계산
-        const muzzleOffset = new THREE.Vector3(0, 0.5, 4);
-        const muzzlePosition = new THREE.Vector3();
-        const turretWorldQuaternion = new THREE.Quaternion();
-        
-        this.turret.getWorldPosition(muzzlePosition);
-        this.turret.getWorldQuaternion(turretWorldQuaternion);
-        
-        muzzleOffset.applyQuaternion(turretWorldQuaternion);
-        muzzlePosition.add(muzzleOffset);
-
-        flashGroup.position.copy(muzzlePosition);
-        flashGroup.quaternion.copy(turretWorldQuaternion);
-
-        this.scene.add(flashGroup);
-
-        // 이펙트 제거
-        setTimeout(() => {
-            this.scene.remove(flashGroup);
-        }, 100);
-    }
-
-    // 피격 효과 생성
-    createHitEffect(position) {
-        const particleCount = 10;
-        const particles = [];
-
-        for (let i = 0; i < particleCount; i++) {
-            const geometry = new THREE.SphereGeometry(0.1);
-            const material = new THREE.MeshBasicMaterial({
-                color: 0xff6600,
-                transparent: true,
-                opacity: 1
-            });
-            const particle = new THREE.Mesh(geometry, material);
-            
-            particle.position.copy(position);
-            
-            const speed = Math.random() * 0.2 + 0.1;
-            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;
-
-            this.scene.add(particle);
-            particles.push(particle);
-        }
-
-        // 파티클 업데이트 및 제거
-        const updateParticles = () => {
-            for (let i = particles.length - 1; i >= 0; i--) {
-                const particle = particles[i];
-                particle.velocity.y += particle.gravity;
-                particle.position.add(particle.velocity);
-                particle.material.opacity -= particle.fadeRate;
-
-                if (particle.material.opacity <= 0) {
-                    this.scene.remove(particle);
-                    particles.splice(i, 1);
-                }
-            }
-
-            if (particles.length > 0) {
-                requestAnimationFrame(updateParticles);
-            }
-        };
-
-        updateParticles();
-    }
-
-    // 적 탱크 AI 업데이트
-    updateAI(playerPosition, obstacles) {
-        if (!this.isLoaded || !this.body) return;
-
-        // 장애물 회피 로직
-        const avoidanceForce = new THREE.Vector3();
-        const avoidanceRadius = 20;
-
-        obstacles.forEach(obstacle => {
-            if (obstacle.userData.isCollidable) {
-                const toObstacle = new THREE.Vector3()
-                    .subVectors(obstacle.position, this.body.position);
-                const distance = toObstacle.length();
-
-                if (distance < avoidanceRadius) {
-                    avoidanceForce.add(
-                        toObstacle.normalize().multiplyScalar(-1 * (avoidanceRadius - distance))
-                    );
-                }
-            }
-        });
-
-        // 최종 이동 방향 계산
-        const targetDirection = new THREE.Vector3()
-            .subVectors(playerPosition, this.body.position)
-            .normalize();
-        
-        targetDirection.add(avoidanceForce.multiplyScalar(0.5));
-        targetDirection.normalize();
-
-        return targetDirection;
-    }
-}
 
 // Particle 클래스
 class Particle {
@@ -1158,56 +1078,56 @@ class Game {
 
     // 레이더 업데이트 메서드 추가
     updateRadar() {
-    const currentTime = Date.now();
-    if (currentTime - this.lastRadarUpdate < this.radarUpdateInterval) return;
-    
-    const radar = document.getElementById('radar');
-    const radarRect = radar.getBoundingClientRect();
-    const radarCenter = {
-        x: radarRect.width / 2,
-        y: radarRect.height / 2
-    };
+        const currentTime = Date.now();
+        if (currentTime - this.lastRadarUpdate < this.radarUpdateInterval) return;
+        
+        const radar = document.getElementById('radar');
+        const radarRect = radar.getBoundingClientRect();
+        const radarCenter = {
+            x: radarRect.width / 2,
+            y: radarRect.height / 2
+        };
 
-    // 기존 적 도트 제거
-    const oldDots = radar.getElementsByClassName('enemy-dot');
-    while (oldDots[0]) {
-        oldDots[0].remove();
-    }
+        // 기존 적 도트 제거
+        const oldDots = radar.getElementsByClassName('enemy-dot');
+        while (oldDots[0]) {
+            oldDots[0].remove();
+        }
 
-    // 탱크 위치 가져오기
-    const tankPos = this.tank.getPosition();
+        // 탱크 위치 가져오기
+        const tankPos = this.tank.getPosition();
 
-    // 모든 적에 대해 레이더에 표시
-    this.enemies.forEach(enemy => {
-        if (!enemy.isLoaded || !enemy.body) return;
+        // 모든 적에 대해 레이더에 표시
+        this.enemies.forEach(enemy => {
+            if (!enemy.mesh || !enemy.isLoaded) return;
 
-        const enemyPos = enemy.body.position;
-        const distance = tankPos.distanceTo(enemyPos);
+            const enemyPos = enemy.mesh.position;
+            const distance = tankPos.distanceTo(enemyPos);
 
-        // 레이더 범위 내에 있는 경우만 표시
-        if (distance <= this.radarRange) {
-            // 탱크 기준 상대 각도 계산
-            const angle = Math.atan2(
-                enemyPos.x - tankPos.x,
-                enemyPos.z - tankPos.z
-            );
+            // 레이더 범위 내에 있는 경우만 표시
+            if (distance <= this.radarRange) {
+                // 탱크 기준 상대 각도 계산
+                const angle = Math.atan2(
+                    enemyPos.x - tankPos.x,
+                    enemyPos.z - tankPos.z
+                );
 
-            // 상대 거리를 레이더 크기에 맞게 스케일링
-            const relativeDistance = distance / this.radarRange;
-            const dotX = radarCenter.x + Math.sin(angle) * (radarCenter.x * relativeDistance);
-            const dotY = radarCenter.y + Math.cos(angle) * (radarCenter.y * relativeDistance);
-
-            // 적 도트 생성 및 추가
-            const dot = document.createElement('div');
-            dot.className = 'enemy-dot';
-            dot.style.left = `${dotX}px`;
-            dot.style.top = `${dotY}px`;
-            radar.appendChild(dot);
-        }
-    });
+                // 상대 거리를 레이더 크기에 맞게 스케일링
+                const relativeDistance = distance / this.radarRange;
+                const dotX = radarCenter.x + Math.sin(angle) * (radarCenter.x * relativeDistance);
+                const dotY = radarCenter.y + Math.cos(angle) * (radarCenter.y * relativeDistance);
+
+                // 적 도트 생성 및 추가
+                const dot = document.createElement('div');
+                dot.className = 'enemy-dot';
+                dot.style.left = `${dotX}px`;
+                dot.style.top = `${dotY}px`;
+                radar.appendChild(dot);
+            }
+        });
 
-    this.lastRadarUpdate = currentTime;
-}
+        this.lastRadarUpdate = currentTime;
+    }
 
     async addDesertDecorations() {
           if (!this.obstacles) {
@@ -1919,47 +1839,45 @@ this.enemies.forEach(enemy => {
    }
 
    animate() {
-    if (this.isGameOver) {
-        if (this.animationFrameId) {
-            cancelAnimationFrame(this.animationFrameId);
-        }
-        return;
-    }
+       if (this.isGameOver) {
+           if (this.animationFrameId) {
+               cancelAnimationFrame(this.animationFrameId);
+           }
+           return;
+       }
 
-    this.animationFrameId = requestAnimationFrame(() => this.animate());
-    // 게임이 시작되지 않았으면 렌더링만 수행
-    if (!this.isStarted) {
-        this.renderer.render(this.scene, this.camera);
-        return;
-    }
+       this.animationFrameId = requestAnimationFrame(() => this.animate());
+           // 게임이 시작되지 않았으면 렌더링만 수행
+        if (!this.isStarted) {
+            this.renderer.render(this.scene, this.camera);
+            return;
+        }
 
-    const currentTime = performance.now();
-    const deltaTime = (currentTime - this.lastTime) / 1000;
-    this.lastTime = currentTime;
+       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 => {
-            if (enemy && enemy.isLoaded && enemy.body) {  // body 존재 여부 확인
-                enemy.update(tankPosition);
-                
-                const distanceToPlayer = enemy.body.position.distanceTo(tankPosition);
-                if (distanceToPlayer < ENEMY_CONFIG.ATTACK_RANGE) {
-                    enemy.shoot(tankPosition);
-                }
-            }
-        });
+       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);
+           this.updateParticles();
+           this.checkCollisions();
+           this.updateUI();
+           this.updateRadar(); // 레이더 업데이트 추가
+       }
+       
+       this.renderer.render(this.scene, this.camera);
+   }
 }
 
 // Start game