Update game.js

game.js

@@ -641,7 +641,7 @@ class Fighter {
         }
     }
 
-    updateBullets(scene, deltaTime) {
+    updateBullets(scene, deltaTime, gameInstance) {
         for (let i = this.bullets.length - 1; i >= 0; i--) {
             const bullet = this.bullets[i];
             bullet.position.add(bullet.velocity.clone().multiplyScalar(deltaTime));
@@ -651,9 +651,17 @@ class Fighter {
             const angle = Math.atan2(direction.x, direction.z);
             bullet.rotation.y = angle;
             
-            // 6000m 이상 날아가면 제거
+            // 지면 충돌 체크 추가
+            if (bullet.position.y <= 0) {
+                // 크고 화려한 지면 충돌 효과
+                gameInstance.createGroundImpactEffect(bullet.position);
+                scene.remove(bullet);
+                this.bullets.splice(i, 1);
+                continue;
+            }
+            
+            // 6000m 이상 날아가거나 높이 제한 초과 시 제거
             if (bullet.position.distanceTo(bullet.startPosition) > 6000 || 
-                bullet.position.y < 0 || 
                 bullet.position.y > GAME_CONSTANTS.MAX_ALTITUDE + 500) {
                 scene.remove(bullet);
                 this.bullets.splice(i, 1);
@@ -695,7 +703,7 @@ class EnemyFighter {
         this.velocity = new THREE.Vector3(0, 0, 120);
         this.rotation = new THREE.Euler(0, 0, 0);
         this.health = GAME_CONSTANTS.MAX_HEALTH; // 체력 1000
-        this.speed = 514; // 1000kt in m/s (1000 * 0.514444)
+        this.speed = 386; // 750kt in m/s (750 * 0.514444) - 1000kt에서 750kt로 감소
         this.bullets = [];
         this.lastShootTime = 0;
         
@@ -1034,8 +1042,18 @@ class EnemyFighter {
             const bullet = this.bullets[i];
             bullet.position.add(bullet.velocity.clone().multiplyScalar(deltaTime));
             
-            if (bullet.position.distanceTo(this.position) > 5000 || 
-                bullet.position.y < 0) {
+            // 지면 충돌 체크 추가
+            if (bullet.position.y <= 0) {
+                // 크고 화려한 지면 충돌 효과 - Game 인스턴스를 통해 호출
+                if (window.gameInstance) {
+                    window.gameInstance.createGroundImpactEffect(bullet.position);
+                }
+                this.scene.remove(bullet);
+                this.bullets.splice(i, 1);
+                continue;
+            }
+            
+            if (bullet.position.distanceTo(this.position) > 5000) {
                 this.scene.remove(bullet);
                 this.bullets.splice(i, 1);
             }
@@ -1866,6 +1884,292 @@ class Game {
         });
     }
 
+    // 새로운 메서드: 크고 화려한 지면 충돌 효과
+    createGroundImpactEffect(position) {
+        // 메인 폭발 플래시
+        const flashGeometry = new THREE.SphereGeometry(15, 16, 16);
+        const flashMaterial = new THREE.MeshBasicMaterial({
+            color: 0xffaa00,
+            emissive: 0xffaa00,
+            emissiveIntensity: 3.0,
+            transparent: true,
+            opacity: 1.0
+        });
+        
+        const flash = new THREE.Mesh(flashGeometry, flashMaterial);
+        flash.position.copy(position);
+        flash.position.y = 2; // 지면에서 약간 위
+        this.scene.add(flash);
+        
+        // 충격파 링
+        const ringGeometry = new THREE.RingGeometry(1, 15, 32);
+        const ringMaterial = new THREE.MeshBasicMaterial({
+            color: 0xff6600,
+            side: THREE.DoubleSide,
+            transparent: true,
+            opacity: 0.8
+        });
+        
+        const shockwaveRing = new THREE.Mesh(ringGeometry, ringMaterial);
+        shockwaveRing.position.copy(position);
+        shockwaveRing.position.y = 1;
+        shockwaveRing.rotation.x = -Math.PI / 2;
+        this.scene.add(shockwaveRing);
+        
+        // 파편 파티클 (더 많이, 더 크게)
+        const particleCount = 30;
+        const particles = [];
+        const debris = [];
+        
+        for (let i = 0; i < particleCount; i++) {
+            // 불꽃 파티클
+            const particleGeometry = new THREE.SphereGeometry(1 + Math.random(), 6, 6);
+            const particleMaterial = new THREE.MeshBasicMaterial({
+                color: Math.random() > 0.3 ? 0xffaa00 : 0xff0000,
+                emissive: 0xffaa00,
+                emissiveIntensity: 2.0,
+                transparent: true,
+                opacity: 1.0
+            });
+            
+            const particle = new THREE.Mesh(particleGeometry, particleMaterial);
+            particle.position.copy(position);
+            particle.position.y = 1;
+            
+            // 더 강력한 폭발 속도
+            const angle = Math.random() * Math.PI * 2;
+            const speed = 50 + Math.random() * 150;
+            const upSpeed = 30 + Math.random() * 100;
+            
+            particle.velocity = new THREE.Vector3(
+                Math.cos(angle) * speed,
+                upSpeed,
+                Math.sin(angle) * speed
+            );
+            
+            particle.life = 1.5; // 더 오래 지속
+            
+            this.scene.add(particle);
+            particles.push(particle);
+            
+            // 흙 파편
+            if (i % 3 === 0) {
+                const debrisGeometry = new THREE.BoxGeometry(
+                    2 + Math.random() * 3,
+                    2 + Math.random() * 3,
+                    2 + Math.random() * 3
+                );
+                const debrisMaterial = new THREE.MeshLambertMaterial({
+                    color: 0x4a3c28, // 흙색
+                    transparent: true,
+                    opacity: 1.0
+                });
+                
+                const debrisPiece = new THREE.Mesh(debrisGeometry, debrisMaterial);
+                debrisPiece.position.copy(position);
+                debrisPiece.position.y = 1;
+                
+                // 회전 추가
+                debrisPiece.rotation.set(
+                    Math.random() * Math.PI,
+                    Math.random() * Math.PI,
+                    Math.random() * Math.PI
+                );
+                
+                // 파편 속도
+                const debrisAngle = Math.random() * Math.PI * 2;
+                const debrisSpeed = 30 + Math.random() * 70;
+                
+                debrisPiece.velocity = new THREE.Vector3(
+                    Math.cos(debrisAngle) * debrisSpeed,
+                    20 + Math.random() * 50,
+                    Math.sin(debrisAngle) * debrisSpeed
+                );
+                
+                debrisPiece.angularVelocity = new THREE.Vector3(
+                    (Math.random() - 0.5) * 10,
+                    (Math.random() - 0.5) * 10,
+                    (Math.random() - 0.5) * 10
+                );
+                
+                debrisPiece.life = 2.0;
+                
+                this.scene.add(debrisPiece);
+                debris.push(debrisPiece);
+            }
+        }
+        
+        // 연기 효과
+        const smokeCount = 8;
+        const smokes = [];
+        
+        for (let i = 0; i < smokeCount; i++) {
+            const smokeGeometry = new THREE.SphereGeometry(5 + Math.random() * 5, 8, 8);
+            const smokeMaterial = new THREE.MeshBasicMaterial({
+                color: 0x222222,
+                transparent: true,
+                opacity: 0.6
+            });
+            
+            const smoke = new THREE.Mesh(smokeGeometry, smokeMaterial);
+            smoke.position.copy(position);
+            smoke.position.y = 2 + Math.random() * 5;
+            smoke.position.x += (Math.random() - 0.5) * 10;
+            smoke.position.z += (Math.random() - 0.5) * 10;
+            
+            smoke.velocity = new THREE.Vector3(
+                (Math.random() - 0.5) * 10,
+                5 + Math.random() * 15,
+                (Math.random() - 0.5) * 10
+            );
+            
+            smoke.life = 3.0;
+            
+            this.scene.add(smoke);
+            smokes.push(smoke);
+        }
+        
+        // 지면 크레이터 (임시 효과)
+        const craterGeometry = new THREE.RingGeometry(5, 20, 16);
+        const craterMaterial = new THREE.MeshBasicMaterial({
+            color: 0x2a2a2a,
+            side: THREE.DoubleSide,
+            transparent: true,
+            opacity: 0.7
+        });
+        
+        const crater = new THREE.Mesh(craterGeometry, craterMaterial);
+        crater.position.copy(position);
+        crater.position.y = 0.1;
+        crater.rotation.x = -Math.PI / 2;
+        this.scene.add(crater);
+        
+        // 애니메이션
+        const animateExplosion = () => {
+            let allDead = true;
+            
+            // 메인 플래시
+            if (flash.material.opacity > 0) {
+                flash.material.opacity -= 0.03;
+                flash.scale.multiplyScalar(1.15);
+                allDead = false;
+            } else if (flash.parent) {
+                this.scene.remove(flash);
+            }
+            
+            // 충격파 링
+            if (shockwaveRing.material.opacity > 0) {
+                shockwaveRing.material.opacity -= 0.02;
+                shockwaveRing.scale.x += 0.5;
+                shockwaveRing.scale.y += 0.5;
+                allDead = false;
+            } else if (shockwaveRing.parent) {
+                this.scene.remove(shockwaveRing);
+            }
+            
+            // 파티클 업데이트
+            particles.forEach((particle, index) => {
+                if (particle.life > 0) {
+                    allDead = false;
+                    particle.life -= 0.02;
+                    
+                    // 위치 업데이트
+                    particle.position.add(particle.velocity.clone().multiplyScalar(0.02));
+                    
+                    // 중력
+                    particle.velocity.y -= 3;
+                    
+                    // 공기 저항
+                    particle.velocity.multiplyScalar(0.98);
+                    
+                    // 페이드 아웃
+                    particle.material.opacity = particle.life;
+                    
+                    // 크기 감소
+                    const scale = particle.life * 0.8 + 0.2;
+                    particle.scale.set(scale, scale, scale);
+                } else if (particle.parent) {
+                    this.scene.remove(particle);
+                }
+            });
+            
+            // 파편 업데이트
+            debris.forEach(piece => {
+                if (piece.life > 0) {
+                    allDead = false;
+                    piece.life -= 0.02;
+                    
+                    // 위치 업데이트
+                    piece.position.add(piece.velocity.clone().multiplyScalar(0.02));
+                    
+                    // 회전
+                    piece.rotation.x += piece.angularVelocity.x * 0.02;
+                    piece.rotation.y += piece.angularVelocity.y * 0.02;
+                    piece.rotation.z += piece.angularVelocity.z * 0.02;
+                    
+                    // 중력
+                    piece.velocity.y -= 5;
+                    
+                    // 지면 충돌
+                    if (piece.position.y <= 0) {
+                        piece.position.y = 0;
+                        piece.velocity.y *= -0.3;
+                        piece.velocity.x *= 0.7;
+                        piece.velocity.z *= 0.7;
+                    }
+                    
+                    // 페이드 아웃
+                    piece.material.opacity = piece.life / 2;
+                } else if (piece.parent) {
+                    this.scene.remove(piece);
+                }
+            });
+            
+            // 연기 업데이트
+            smokes.forEach(smoke => {
+                if (smoke.life > 0) {
+                    allDead = false;
+                    smoke.life -= 0.015;
+                    
+                    // 위치 업데이트
+                    smoke.position.add(smoke.velocity.clone().multiplyScalar(0.02));
+                    
+                    // 상승
+                    smoke.velocity.y *= 0.98;
+                    
+                    // 확산
+                    smoke.scale.multiplyScalar(1.02);
+                    
+                    // 페이드 아웃
+                    smoke.material.opacity = smoke.life / 5;
+                } else if (smoke.parent) {
+                    this.scene.remove(smoke);
+                }
+            });
+            
+            // 크레이터 페이드
+            if (crater.material.opacity > 0) {
+                crater.material.opacity -= 0.005;
+                allDead = false;
+            } else if (crater.parent) {
+                this.scene.remove(crater);
+            }
+            
+            if (!allDead) {
+                requestAnimationFrame(animateExplosion);
+            }
+        };
+        
+        animateExplosion();
+        
+        // 충돌 사운드 재생
+        try {
+            const impactSound = new Audio('sounds/explode.ogg');
+            impactSound.volume = 0.4;
+            impactSound.play().catch(e => {});
+        } catch (e) {}
+    }
+
     checkCollisions() {
         // 플레이어 탄환 vs 적기 충돌
         for (let i = this.fighter.bullets.length - 1; i >= 0; i--) {
@@ -2073,7 +2377,7 @@ class Game {
             
             this.fighter.updateControls(this.keys, deltaTime);
             this.fighter.updatePhysics(deltaTime);
-            this.fighter.updateBullets(this.scene, deltaTime);
+            this.fighter.updateBullets(this.scene, deltaTime, this); // this 추가
             
             // 마우스 누름 상태일 때 연속 발사
             if (this.fighter.isMouseDown && this.isStarted) {