Update game.js

game.js

@@ -586,192 +586,94 @@ class Enemy {
     }
 
     async initialize(loader) {
-    console.log('Starting enemy tank initialization...');
-    try {
-        // Load body
-        console.log('Loading t90Body.glb...');
-        const bodyResult = await loader.loadAsync('/models/t90Body.glb');
-        console.log('t90Body.glb loaded successfully');
-        this.body = bodyResult.scene;
-        
-        // Load turret
-        console.log('Loading t90Turret.glb...');
-        const turretResult = await loader.loadAsync('/models/t90Turret.glb');
-        console.log('t90Turret.glb loaded successfully');
-        this.turret = turretResult.scene;
-        
-        console.log('Setting up turret group...');
-        this.turretGroup.position.y = 0.2;
-        this.turretGroup.add(this.turret);
-        this.body.add(this.turretGroup);
-        
-        console.log('Applying transforms...');
-        this.body.position.copy(this.position);
-        this.body.scale.set(ENEMY_SCALE, ENEMY_SCALE, ENEMY_SCALE);
-        
-        // Setup shadows
-        console.log('Setting up shadows...');
-        this.body.traverse((child) => {
-            if (child.isMesh) {
-                child.castShadow = true;
-                child.receiveShadow = true;
-                child.material.shadowSide = THREE.BackSide;
-            }
-        });
-        
-        this.turret.traverse((child) => {
-            if (child.isMesh) {
-                child.castShadow = true;
-                child.receiveShadow = true;
-                child.material.shadowSide = THREE.BackSide;
-            }
-        });
-        
-        console.log('Adding to scene...');
-        this.scene.add(this.body);
-        this.isLoaded = true;
-        console.log('Enemy tank initialization complete!');
-    } catch (error) {
-        console.error('Error loading enemy tank model:', error);
-        console.error('Error details:', {
-            message: error.message,
-            stack: error.stack,
-            name: error.name
-        });
-        this.isLoaded = false;
+        console.log('Starting enemy tank initialization...');
+        try {
+            // Load body
+            console.log('Loading t90Body.glb...');
+            const bodyResult = await loader.loadAsync('/models/t90Body.glb');
+            console.log('t90Body.glb loaded successfully');
+            this.body = bodyResult.scene;
+            
+            // Load turret
+            console.log('Loading t90Turret.glb...');
+            const turretResult = await loader.loadAsync('/models/t90Turret.glb');
+            console.log('t90Turret.glb loaded successfully');
+            this.turret = turretResult.scene;
+            
+            console.log('Setting up turret group...');
+            this.turretGroup.position.y = 0.2;
+            this.turretGroup.add(this.turret);
+            this.body.add(this.turretGroup);
+            
+            console.log('Applying transforms...');
+            this.body.position.copy(this.position);
+            this.body.scale.set(ENEMY_SCALE, ENEMY_SCALE, ENEMY_SCALE);
+            
+            // Setup shadows
+            console.log('Setting up shadows...');
+            this.body.traverse((child) => {
+                if (child.isMesh) {
+                    child.castShadow = true;
+                    child.receiveShadow = true;
+                    child.material.shadowSide = THREE.BackSide;
+                }
+            });
+            
+            this.turret.traverse((child) => {
+                if (child.isMesh) {
+                    child.castShadow = true;
+                    child.receiveShadow = true;
+                    child.material.shadowSide = THREE.BackSide;
+                }
+            });
+            
+            console.log('Adding to scene...');
+            this.scene.add(this.body);
+            this.isLoaded = true;
+            console.log('Enemy tank initialization complete!');
+        } catch (error) {
+            console.error('Error loading enemy tank model:', error);
+            console.error('Error details:', {
+                message: error.message,
+                stack: error.stack,
+                name: error.name
+            });
+            this.isLoaded = false;
+        }
     }
-}
-
-    update(playerPosition) {
+  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;
-        
-        // Store previous position
-        const previousPosition = this.body.position.clone();
+        const minDistance = 50; // 최소 거리 유지
         
+        // 최소 거리보다 멀리 있을 때만 이동
         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;
-                }
-            }
-            
-            // 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;
-                        }
-                    }
-                }
-            }
-            
-            // Check map boundaries
-            const mapBoundary = MAP_SIZE / 2;
-            if (Math.abs(newPosition.x) > mapBoundary || 
-                Math.abs(newPosition.z) > mapBoundary) {
-                hasCollision = true;
-            }
-            
-            // Handle collision response
-            if (hasCollision) {
-                this.body.position.copy(previousPosition);
-                
-                // 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 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);
-                    }
-                }
-            }
-            
-            // 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 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);
+            // 이동 방향으로 차체 회전
+            const targetRotation = Math.atan2(direction.x, direction.z);
+            this.body.rotation.y = targetRotation;
         }
 
-        // Update turret rotation to face player
+        // 포탑 회전 (항상 플레이어를 향하도록)
         const turretDirection = new THREE.Vector2(
             playerPosition.x - this.body.position.x,
             playerPosition.z - this.body.position.z
@@ -779,30 +681,16 @@ class Enemy {
         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);
-                    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;
-                    }
-                }
+        // 총알 업데이트
+        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);
             }
         }
     }
@@ -817,14 +705,14 @@ class Enemy {
 
         if (currentTime - this.lastAttackTime < attackInterval) return;
 
-        // Create bullet
-        const bulletGeometry = new THREE.SphereGeometry(this.type === 'tank' ? 0.2 : 0.3);
+        // 총알 생성
+        const bulletGeometry = new THREE.SphereGeometry(0.3);
         const bulletMaterial = new THREE.MeshBasicMaterial({ 
             color: this.type === 'tank' ? 0xff0000 : 0xff6600 
         });
         const bullet = new THREE.Mesh(bulletGeometry, bulletMaterial);
 
-        // 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();
@@ -837,6 +725,7 @@ class Enemy {
         
         bullet.position.copy(muzzlePosition);
         
+        // 발사 방향 계산
         const direction = new THREE.Vector3()
             .subVectors(playerPosition, muzzlePosition)
             .normalize();
@@ -847,6 +736,11 @@ 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;
@@ -866,6 +760,153 @@ class Enemy {
         }
     }
 }
+// 적 탱크의 발사 이펙트 생성
+    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 {