Update game.js

game.js

@@ -572,200 +572,230 @@ 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 modelPath = this.type === 'tank' ? '/models/enemy1.glb' : '/models/enemy4.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);
+            // Load body and turret separately
+            const bodyResult = await loader.loadAsync('/models/t90Body.glb');
+            this.body = bodyResult.scene;
+            
+            const turretResult = await loader.loadAsync('/models/t90Turret.glb');
+            this.turret = turretResult.scene;
+            
+            // Set up turret group
+            this.turretGroup.position.y = 0.2;
+            this.turretGroup.add(this.turret);
+            this.body.add(this.turretGroup);
+            
+            // Apply transforms to body
+            this.body.position.copy(this.position);
+            this.body.scale.set(ENEMY_SCALE, ENEMY_SCALE, ENEMY_SCALE);
+            
+            // Set up shadows for both body and turret
+            this.body.traverse((child) => {
+                if (child.isMesh) {
+                    child.castShadow = true;
+                    child.receiveShadow = true;
+                    child.material.shadowSide = THREE.BackSide;
+                }
+            });
             
-            this.mesh.traverse((child) => {
+            this.turret.traverse((child) => {
                 if (child.isMesh) {
                     child.castShadow = true;
                     child.receiveShadow = true;
+                    child.material.shadowSide = THREE.BackSide;
                 }
             });
             
-            this.scene.add(this.mesh);
+            this.scene.add(this.body);
             this.isLoaded = true;
         } catch (error) {
-            console.error('Error loading enemy model:', error);
+            console.error('Error loading enemy tank model:', error);
             this.isLoaded = false;
         }
     }
 
     update(playerPosition) {
-    if (!this.mesh || !this.isLoaded) return;
+        if (!this.body || !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;
+        const direction = new THREE.Vector3()
+            .subVectors(playerPosition, this.body.position)
+            .normalize();
         
-        // 임시로 위치 이동하여 충돌 체크
-        const originalPosition = this.mesh.position.clone();
-        this.mesh.position.copy(newPosition);
+        const distanceToPlayer = this.body.position.distanceTo(playerPosition);
+        const minDistance = 50;
         
-        // 장애물과 충돌 체크
-        const enemyBox = new THREE.Box3().setFromObject(this.mesh);
-        let hasCollision = false;
+        // Store previous position
+        const previousPosition = this.body.position.clone();
         
-        // 모든 장애물에 대해 충돌 검사
-        for (const obstacle of window.gameInstance.obstacles) {
-            const obstacleBox = new THREE.Box3().setFromObject(obstacle);
-            if (enemyBox.intersectsBox(obstacleBox)) {
-                hasCollision = true;
-                break;
+        if (distanceToPlayer > minDistance) {
+            const moveVector = direction.multiplyScalar(this.moveSpeed);
+            const newPosition = this.body.position.clone().add(moveVector);
+            
+            // Get terrain height
+            const heightAtNewPos = window.gameInstance.getHeightAtPosition(
+                newPosition.x,
+                newPosition.z
+            );
+            newPosition.y = heightAtNewPos + TANK_HEIGHT;
+            
+            // Move tank body
+            const originalPosition = this.body.position.clone();
+            this.body.position.copy(newPosition);
+            
+            // Collision checks
+            const enemyBox = new THREE.Box3().setFromObject(this.body);
+            let hasCollision = false;
+            
+            // Check collisions with obstacles
+            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;
+            
+            // Check collisions with other enemies
+            if (!hasCollision) {
+                for (const otherEnemy of window.gameInstance.enemies) {
+                    if (otherEnemy !== this && otherEnemy.body) {
+                        const otherEnemyBox = new THREE.Box3().setFromObject(otherEnemy.body);
+                        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도 회전
-            ];
+            // Check map boundaries
+            const mapBoundary = MAP_SIZE / 2;
+            if (Math.abs(newPosition.x) > mapBoundary || 
+                Math.abs(newPosition.z) > mapBoundary) {
+                hasCollision = true;
+            }
             
-            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);
+            // Handle collision response
+            if (hasCollision) {
+                this.body.position.copy(previousPosition);
                 
-                let altHasCollision = false;
+                // Try alternate paths when collision occurs
+                const alternateDirections = [
+                    new THREE.Vector3(-direction.z, 0, direction.x), // Left 90 degrees
+                    new THREE.Vector3(direction.z, 0, -direction.x), // Right 90 degrees
+                    new THREE.Vector3(-direction.x, 0, -direction.z)  // 180 degrees
+                ];
                 
-                // 새로운 방향에 대한 충돌 검사
-                for (const obstacle of window.gameInstance.obstacles) {
-                    const obstacleBox = new THREE.Box3().setFromObject(obstacle);
-                    if (altEnemyBox.intersectsBox(obstacleBox)) {
-                        altHasCollision = true;
+                for (const altDirection of alternateDirections) {
+                    const altMoveVector = altDirection.multiplyScalar(this.moveSpeed);
+                    const altNewPosition = previousPosition.clone().add(altMoveVector);
+                    
+                    this.body.position.copy(altNewPosition);
+                    const altEnemyBox = new THREE.Box3().setFromObject(this.body);
+                    
+                    let altHasCollision = false;
+                    
+                    // Check alternate path collisions
+                    for (const obstacle of window.gameInstance.obstacles) {
+                        const obstacleBox = new THREE.Box3().setFromObject(obstacle);
+                        if (altEnemyBox.intersectsBox(obstacleBox)) {
+                            altHasCollision = true;
+                            break;
+                        }
+                    }
+                    
+                    if (!altHasCollision) {
+                        // Use alternate path if no collision
                         break;
+                    } else {
+                        // Revert to previous position if alternate path also collides
+                        this.body.position.copy(previousPosition);
                     }
                 }
-                
-                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 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;
-            }
+            // Adjust tank orientation based on terrain
+            const forwardVector = new THREE.Vector3(0, 0, 1).applyQuaternion(this.body.quaternion);
+            const rightVector = new THREE.Vector3(1, 0, 0).applyQuaternion(this.body.quaternion);
             
-            // 총알과 장애물 충돌 체크
-            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)) {
+            const frontHeight = window.gameInstance.getHeightAtPosition(
+                this.body.position.x + forwardVector.x,
+                this.body.position.z + forwardVector.z
+            );
+            const backHeight = window.gameInstance.getHeightAtPosition(
+                this.body.position.x - forwardVector.x,
+                this.body.position.z - forwardVector.z
+            );
+            const rightHeight = window.gameInstance.getHeightAtPosition(
+                this.body.position.x + rightVector.x,
+                this.body.position.z + rightVector.z
+            );
+            const leftHeight = window.gameInstance.getHeightAtPosition(
+                this.body.position.x - rightVector.x,
+                this.body.position.z - rightVector.z
+            );
+            
+            const pitch = Math.atan2(frontHeight - backHeight, 2);
+            const roll = Math.atan2(rightHeight - leftHeight, 2);
+            
+            // Apply rotation while maintaining current heading
+            const currentRotation = this.body.rotation.y;
+            this.body.rotation.set(pitch, currentRotation, roll);
+        }
+
+        // Update turret rotation to face player
+        const turretDirection = new THREE.Vector2(
+            playerPosition.x - this.body.position.x,
+            playerPosition.z - this.body.position.z
+        );
+        const turretAngle = Math.atan2(turretDirection.x, turretDirection.y);
+        this.turretGroup.rotation.y = turretAngle - this.body.rotation.y;
+
+        // Update bullets
+        if (this.bullets) {
+            for (let i = this.bullets.length - 1; i >= 0; i--) {
+                const bullet = this.bullets[i];
+                bullet.position.add(bullet.velocity);
+                
+                // Check bullet bounds and collisions
+                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);
-                    break;
+                    continue;
+                }
+                
+                // Check bullet collisions with obstacles
+                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 : 
@@ -773,16 +803,28 @@ class Enemy {
 
         if (currentTime - this.lastAttackTime < attackInterval) return;
 
+        // Create bullet
         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);
 
-        bullet.position.copy(this.mesh.position);
+        // Get turret world position for bullet spawn
+        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);
         
         const direction = new THREE.Vector3()
-            .subVectors(playerPosition, this.mesh.position)
+            .subVectors(playerPosition, muzzlePosition)
             .normalize();
         
         const bulletSpeed = this.type === 'tank' ? 
@@ -802,8 +844,8 @@ class Enemy {
     }
 
     destroy() {
-        if (this.mesh) {
-            this.scene.remove(this.mesh);
+        if (this.body) {
+            this.scene.remove(this.body);
             this.bullets.forEach(bullet => this.scene.remove(bullet));
             this.bullets = [];
             this.isLoaded = false;