Update game.js

game.js

@@ -71,6 +71,11 @@ class Fighter {
        this.lastShootTime = 0;
        this.isMouseDown = false; // 마우스 누름 상태 추적
        this.gunfireAudios = []; // 기관총 소리 배열 (최대 5개)
+
+       // 플레어 시스템
+      this.flareCount = 3; // 플레어 3회 사용 가능
+      this.deployedFlares = []; // 배치된 플레어 배열
+      this.lastFlareTime = 0; // 마지막 플레어 사용 시간
        
        // AIM-9 미사일 시스템
        this.aim9Missiles = GAME_CONSTANTS.AIM9_COUNT;
@@ -537,7 +542,7 @@ class Fighter {
            this.targetRoll *= 0.95;
        }
        
-       // 워썬더 스타일: 요 회전이 주도적, 롤은 보조적
+       // 요 회전이 주도적, 롤은 보조적
        let bankTurnRate = 0;
        if (Math.abs(this.rotation.z) > 0.3) { // 롤이 충분히 클 때만
            const bankAngle = this.rotation.z;
@@ -850,10 +855,18 @@ class Fighter {
        this.updateWarningAudios();
        
        // 엔진 소리 볼륨을 스로틀에 연동
-       if (this.warningAudios.normal && !this.warningAudios.normal.paused) {
-           this.warningAudios.normal.volume = 0.3 + this.throttle * 0.4; // 0.3~0.7
-       }
-   }
+    if (this.warningAudios.normal && !this.warningAudios.normal.paused) {
+        this.warningAudios.normal.volume = 0.3 + this.throttle * 0.4; // 0.3~0.7
+    }
+    
+    // 플레어 업데이트
+    for (let i = this.deployedFlares.length - 1; i >= 0; i--) {
+        const flare = this.deployedFlares[i];
+        if (!flare.update(deltaTime)) {
+            this.deployedFlares.splice(i, 1);
+        }
+    }
+}
 
    shoot(scene) {
     if (this.currentWeapon === 'MG') {
@@ -977,6 +990,65 @@ class Fighter {
         }
     }
 }
+  deployFlares() {
+    if (this.flareCount <= 0) return;
+    
+    const now = Date.now();
+    if (now - this.lastFlareTime < 2000) return; // 2초 쿨다운
+    
+    this.flareCount--;
+    this.lastFlareTime = now;
+    
+    // 꼬리 부분 위치 계산
+    const tailOffset = new THREE.Vector3(0, 0, -15);
+    const quaternion = new THREE.Quaternion();
+    const pitchQuat = new THREE.Quaternion();
+    const yawQuat = new THREE.Quaternion();
+    const rollQuat = new THREE.Quaternion();
+    
+    pitchQuat.setFromAxisAngle(new THREE.Vector3(1, 0, 0), this.rotation.x);
+    yawQuat.setFromAxisAngle(new THREE.Vector3(0, 1, 0), this.rotation.y);
+    rollQuat.setFromAxisAngle(new THREE.Vector3(0, 0, 1), this.rotation.z);
+    
+    quaternion.multiply(rollQuat);
+    quaternion.multiply(pitchQuat);
+    quaternion.multiply(yawQuat);
+    
+    tailOffset.applyQuaternion(quaternion);
+    const flareStartPos = this.position.clone().add(tailOffset);
+    
+    // 후방 방향
+    const backwardDirection = new THREE.Vector3(0, 0, -1);
+    backwardDirection.applyQuaternion(quaternion);
+    
+    // 양쪽으로 2개씩, 총 4개 플레어 발사
+    for (let i = 0; i < 4; i++) {
+        const isLeftSide = i < 2;
+        const flare = new Flare(window.gameInstance.scene, flareStartPos, backwardDirection, isLeftSide);
+        this.deployedFlares.push(flare);
+        
+        // 모든 미사일에게 플레어 알림
+        if (window.gameInstance) {
+            window.gameInstance.notifyMissilesOfFlare(flare);
+        }
+    }
+    
+    // 플레어 발사음
+    try {
+        const flareSound = new Audio('sounds/flare.ogg');
+        flareSound.volume = 0.6;
+        flareSound.play().catch(e => {
+            console.log('Flare sound not found, using alternative');
+            // 대체 소리 (기존 사운드 활용)
+            const altSound = new Audio('sounds/missile.ogg');
+            altSound.volume = 0.3;
+            altSound.playbackRate = 2.0; // 빠르게 재생
+            altSound.play().catch(e => {});
+        });
+    } catch (e) {}
+    
+    console.log(`Flares deployed! Remaining: ${this.flareCount}`);
+}
 
    updateBullets(scene, deltaTime, gameInstance) {
        for (let i = this.bullets.length - 1; i >= 0; i--) {
@@ -1059,6 +1131,162 @@ class Fighter {
    }
 }
 
+// 플레어 클래스
+class Flare {
+    constructor(scene, position, direction, isLeftSide) {
+        this.scene = scene;
+        this.position = position.clone();
+        this.velocity = direction.clone().multiplyScalar(200); // 200m/s 속도
+        
+        // 좌우로 분산
+        const sideOffset = isLeftSide ? -1 : 1;
+        const perpendicular = new THREE.Vector3(sideOffset * 50, -20, (Math.random() - 0.5) * 30);
+        this.velocity.add(perpendicular);
+        
+        this.lifeTime = 5.0; // 5초 지속
+        this.mesh = null;
+        this.createFlare();
+        
+        // 열 추적 특성
+        this.heatSignature = 1.0; // 초기 열 신호
+    }
+    
+    createFlare() {
+        // 플레어 메인 몸체
+        const group = new THREE.Group();
+        
+        // 밝은 중심부
+        const coreGeometry = new THREE.SphereGeometry(0.5, 6, 6);
+        const coreMaterial = new THREE.MeshBasicMaterial({
+            color: 0xffffff,
+            transparent: true,
+            opacity: 1.0
+        });
+        const core = new THREE.Mesh(coreGeometry, coreMaterial);
+        group.add(core);
+        
+        // 열 광원 효과
+        const glowGeometry = new THREE.SphereGeometry(2, 8, 8);
+        const glowMaterial = new THREE.MeshBasicMaterial({
+            color: 0xff6600,
+            transparent: true,
+            opacity: 0.6
+        });
+        const glow = new THREE.Mesh(glowGeometry, glowMaterial);
+        group.add(glow);
+        
+        // 외부 광원
+        const outerGlowGeometry = new THREE.SphereGeometry(4, 8, 8);
+        const outerGlowMaterial = new THREE.MeshBasicMaterial({
+            color: 0xff3300,
+            transparent: true,
+            opacity: 0.3
+        });
+        const outerGlow = new THREE.Mesh(outerGlowGeometry, outerGlowMaterial);
+        group.add(outerGlow);
+        
+        this.mesh = group;
+        this.mesh.position.copy(this.position);
+        this.scene.add(this.mesh);
+        
+        // 연기 트레일
+        this.smokeTrail = [];
+        this.smokeEmitTime = 0;
+    }
+    
+    update(deltaTime) {
+        this.lifeTime -= deltaTime;
+        if (this.lifeTime <= 0) {
+            this.destroy();
+            return false;
+        }
+        
+        // 열 신호 감소
+        this.heatSignature = Math.max(0, this.heatSignature - deltaTime * 0.15);
+        
+        // 중력 효과
+        this.velocity.y -= 50 * deltaTime; // 중력 가속도
+        
+        // 위치 업데이트
+        this.position.add(this.velocity.clone().multiplyScalar(deltaTime));
+        this.mesh.position.copy(this.position);
+        
+        // 밝기 감소
+        const fadeRatio = this.lifeTime / 5.0;
+        this.mesh.children[0].material.opacity = fadeRatio;
+        this.mesh.children[1].material.opacity = fadeRatio * 0.6;
+        this.mesh.children[2].material.opacity = fadeRatio * 0.3;
+        
+        // 연기 생성
+        this.smokeEmitTime += deltaTime;
+        if (this.smokeEmitTime >= 0.05) {
+            this.smokeEmitTime = 0;
+            this.createSmoke();
+        }
+        
+        // 연기 업데이트
+        for (let i = this.smokeTrail.length - 1; i >= 0; i--) {
+            const smoke = this.smokeTrail[i];
+            smoke.life -= deltaTime;
+            
+            if (smoke.life <= 0) {
+                this.scene.remove(smoke.mesh);
+                this.smokeTrail.splice(i, 1);
+            } else {
+                smoke.mesh.scale.multiplyScalar(1.05);
+                smoke.mesh.material.opacity = smoke.life / 2.0 * 0.5;
+            }
+        }
+        
+        // 지면 충돌
+        if (this.position.y <= 0) {
+            this.destroy();
+            return false;
+        }
+        
+        return true;
+    }
+    
+    createSmoke() {
+        const smokeGeometry = new THREE.SphereGeometry(1 + Math.random() * 1, 6, 6);
+        const smokeMaterial = new THREE.MeshBasicMaterial({
+            color: 0xcccccc,
+            transparent: true,
+            opacity: 0.5
+        });
+        
+        const smoke = new THREE.Mesh(smokeGeometry, smokeMaterial);
+        smoke.position.copy(this.position);
+        smoke.position.add(new THREE.Vector3(
+            (Math.random() - 0.5) * 2,
+            (Math.random() - 0.5) * 2,
+            (Math.random() - 0.5) * 2
+        ));
+        
+        this.scene.add(smoke);
+        this.smokeTrail.push({
+            mesh: smoke,
+            life: 2.0
+        });
+        
+        // 연기 제한
+        if (this.smokeTrail.length > 30) {
+            const oldSmoke = this.smokeTrail.shift();
+            this.scene.remove(oldSmoke.mesh);
+        }
+    }
+    
+    destroy() {
+        if (this.mesh) {
+            this.scene.remove(this.mesh);
+        }
+        this.smokeTrail.forEach(smoke => {
+            this.scene.remove(smoke.mesh);
+        });
+        this.smokeTrail = [];
+    }
+}
+
 // AIM-9 미사일 클래스
 class AIM9Missile {
    constructor(scene, position, target, rotation) {
@@ -1179,17 +1407,70 @@ class AIM9Missile {
        group.add(flame);
        
        this.mesh = group;
-       this.mesh.scale.set(2.25, 2.25, 2.25); // 50% 더 크게 (1.5 -> 2.25)
+        this.mesh.scale.set(3.375, 3.375, 3.375); // 50% 더 크게 (1.5 -> 2.25)
        this.isLoaded = true;
    }
    
-   // AIM-9 미사일 클래스 - update 메서드 수정
+  // AIM-9 미사일 클래스 - update 메서드 수정
 update(deltaTime, playerPosition) {
     if (!this.mesh || !this.target || !this.target.position) {
         this.destroy();
         return 'expired';
     }
     
+    // *** 플레어 탐지 로직 추가 시작 ***
+    // 플레어 탐지 및 목표 변경
+    if (window.gameInstance && !this.isTargetingFlare) {
+        const nearestFlare = window.gameInstance.findNearestFlare(this.position);
+        if (nearestFlare) {
+            const flareDistance = this.position.distanceTo(nearestFlare.position);
+            if (flareDistance < 500 && nearestFlare.heatSignature > 0.3) {
+                // 플레어로 목표 변경
+                console.log('Missile redirected to flare!');
+                this.target = nearestFlare;
+                this.isTargetingFlare = true;
+            }
+        }
+    }
+    
+    // 플레어를 추적 중이고 플레어가 소멸했다면
+    if (this.isTargetingFlare && (!this.target.mesh || this.target.lifeTime <= 0)) {
+        // 직선으로 계속 비행
+        this.position.add(this.velocity.clone().multiplyScalar(deltaTime));
+        this.mesh.position.copy(this.position);
+        
+        this.lifeTime -= deltaTime;
+        if (this.lifeTime <= 0 || this.position.y <= 0) {
+            this.destroy();
+            return 'expired';
+        }
+        
+        // 연기는 계속 생성
+        this.smokeEmitTime += deltaTime;
+        if (this.smokeEmitTime >= 0.02) {
+            this.smokeEmitTime = 0;
+            this.createSmokeParticle();
+        }
+        
+        // 연기 파티클 업데이트
+        for (let i = this.smokeTrail.length - 1; i >= 0; i--) {
+            const smoke = this.smokeTrail[i];
+            smoke.life -= deltaTime;
+            
+            if (smoke.life <= 0) {
+                this.scene.remove(smoke.mesh);
+                this.smokeTrail.splice(i, 1);
+            } else {
+                smoke.mesh.scale.multiplyScalar(1.02);
+                smoke.mesh.material.opacity = smoke.life / 3.0;
+                smoke.mesh.position.y += deltaTime * 2;
+            }
+        }
+        
+        return 'flying';
+    }
+    // *** 플레어 탐지 로직 추가 끝 ***
+    
     this.lifeTime -= deltaTime;
     if (this.lifeTime <= 0) {
         this.destroy();
@@ -1298,7 +1579,7 @@ update(deltaTime, playerPosition) {
        
        // 하얀 연기 파티클 생성
        const smokeGeometry = new THREE.SphereGeometry(
-           1 + Math.random() * 2.5, // 크기 변화
+           1 + Math.random() * 3.5, // 크기 변화
            6, 
            6
        );
@@ -1469,7 +1750,7 @@ class EnemyAIM9Missile {
         group.add(flame);
         
         this.mesh = group;
-        this.mesh.scale.set(2.25, 2.25, 2.25);
+        this.mesh.scale.set(3.375, 3.375, 3.375);
         this.mesh.position.copy(this.position);
         this.scene.add(this.mesh);
         this.isLoaded = true;
@@ -1561,7 +1842,7 @@ class EnemyAIM9Missile {
         
         // 하얀 연기 파티클 생성
         const smokeGeometry = new THREE.SphereGeometry(
-            1 + Math.random() * 2.5,
+            1 + Math.random() * 3.5,
             6, 
             6
         );
@@ -1623,6 +1904,7 @@ class EnemyAIM9Missile {
 }
 
 
+// 적 전투기 클래스 - 완전히 재설계
 // 적 전투기 클래스 - 완전히 재설계
 class EnemyFighter {
     constructor(scene, position) {
@@ -1674,6 +1956,12 @@ class EnemyFighter {
         this.lastMissileFireTime = 0;
         this.isLocking = false;
         
+        // 플레어 시스템
+        this.flareCount = 1; // 플레어 1회만 사용 가능
+        this.deployedFlares = [];
+        this.lastFlareTime = 0;
+        this.hasUsedFlare = false;
+        
         // 초기 목표 설정
         this.selectNewPatrolTarget();
     }
@@ -1724,61 +2012,82 @@ class EnemyFighter {
         this.isLoaded = true;
     }
     
-    // EnemyFighter 클래스의 update 메서드에서 미사일 회피 로직 제거
-update(playerPosition, deltaTime) {
-    if (!this.mesh || !this.isLoaded) return;
-    
-    // 회피 타이머 업데이트 (미사일 회피 제외)
-    if (this.temporaryEvadeMode && this.evadeTimer > 0) {
-        this.evadeTimer -= deltaTime;
-        if (this.evadeTimer <= 0) {
-            this.temporaryEvadeMode = false;
+    update(playerPosition, deltaTime) {
+        if (!this.mesh || !this.isLoaded) return;
+        
+        // 플레어 업데이트 추가
+        for (let i = this.deployedFlares.length - 1; i >= 0; i--) {
+            const flare = this.deployedFlares[i];
+            if (!flare.update(deltaTime)) {
+                this.deployedFlares.splice(i, 1);
+            }
+        }
+        
+        // 미사일 위협 감지 및 플레어 사용
+        if (!this.hasUsedFlare && this.flareCount > 0 && window.gameInstance) {
+            const incomingMissiles = window.gameInstance.findIncomingMissilesForEnemy(this);
+            if (incomingMissiles.length > 0) {
+                const nearestMissile = incomingMissiles[0];
+                const missileDistance = this.position.distanceTo(nearestMissile.position);
+                
+                if (missileDistance < 500) {
+                    this.deployFlares();
+                    this.hasUsedFlare = true;
+                }
+            }
+        }
+        
+        // 회피 타이머 업데이트 (미사일 회피 제외)
+        if (this.temporaryEvadeMode && this.evadeTimer > 0) {
+            this.evadeTimer -= deltaTime;
+            if (this.evadeTimer <= 0) {
+                this.temporaryEvadeMode = false;
+            }
+        }
+        
+        const distanceToPlayer = this.position.distanceTo(playerPosition);
+        
+        // 상태 결정 (미사일 탐지 제거)
+        if (this.temporaryEvadeMode) {
+            this.aiState = 'evade';
+        } else if (distanceToPlayer <= 3000) {
+            this.aiState = 'combat';
+        } else {
+            this.aiState = 'patrol';
+        }
+        
+        // 충돌 회피 계산 (다른 적기와의 충돌만)
+        this.calculateAvoidance();
+        this.checkCollisionPrediction(deltaTime);
+        
+        // AI 행동 실행
+        switch (this.aiState) {
+            case 'patrol':
+                this.executePatrol(deltaTime);
+                break;
+            case 'combat':
+                this.executeCombat(playerPosition, deltaTime);
+                break;
+            case 'evade':
+                this.executeEmergencyEvade(deltaTime);
+                break;
+        }
+        
+        // 물리 업데이트
+        this.updatePhysics(deltaTime);
+        
+        // 탄환 업데이트
+        this.updateBullets(deltaTime);
+        
+        // 미사일 업데이트
+        this.updateMissiles(deltaTime);
+        
+        // 락온 시스템 업데이트
+        if (this.playerFighter) {
+            this.updateLockOn(deltaTime);
         }
     }
     
-    const distanceToPlayer = this.position.distanceTo(playerPosition);
-    
-    // 상태 결정 (미사일 탐지 제거)
-    if (this.temporaryEvadeMode) {
-        this.aiState = 'evade';
-    } else if (distanceToPlayer <= 3000) {
-        this.aiState = 'combat';
-    } else {
-        this.aiState = 'patrol';
-    }
-    
-    // 충돌 회피 계산 (다른 적기와의 충돌만)
-    this.calculateAvoidance();
-    this.checkCollisionPrediction(deltaTime);
-    
-    // AI 행동 실행
-    switch (this.aiState) {
-        case 'patrol':
-            this.executePatrol(deltaTime);
-            break;
-        case 'combat':
-            this.executeCombat(playerPosition, deltaTime);
-            break;
-        case 'evade':
-            this.executeEmergencyEvade(deltaTime);
-            break;
-    }
-    
-    // 물리 업데이트
-    this.updatePhysics(deltaTime);
-    
-    // 탄환 업데이트
-    this.updateBullets(deltaTime);
-    
-    // 미사일 업데이트
-    this.updateMissiles(deltaTime);
-    
-    // 락온 시스템 업데이트
-    if (this.playerFighter) {
-        this.updateLockOn(deltaTime);
-    }
-}
-    
     executePatrol(deltaTime) {
         // 목표 지점까지의 거리 확인
         if (!this.targetPosition || this.position.distanceTo(this.targetPosition) < 500) {
@@ -1914,8 +2223,6 @@ update(playerPosition, deltaTime) {
     }
     
     smoothTurnToTarget(targetPos, deltaTime, isEmergency = false) {
-        
-        
         // 기존 로직 (후퇴가 아닐 때)
         const direction = targetPos.clone().sub(this.position);
         direction.y *= 0.5;
@@ -2288,6 +2595,35 @@ update(playerPosition, deltaTime) {
         }
     }
     
+    // 적기용 플레어 배치 메서드 추가
+    deployFlares() {
+        if (this.flareCount <= 0) return;
+        
+        this.flareCount--;
+        
+        // 꼬리 부분 위치 계산
+        const tailOffset = new THREE.Vector3(0, 0, -10);
+        tailOffset.applyEuler(this.rotation);
+        const flareStartPos = this.position.clone().add(tailOffset);
+        
+        // 후방 방향
+        const backwardDirection = new THREE.Vector3(0, 0, -1);
+        backwardDirection.applyEuler(this.rotation);
+        
+        // 4개 플레어 발사
+        for (let i = 0; i < 4; i++) {
+            const isLeftSide = i < 2;
+            const flare = new Flare(this.scene, flareStartPos, backwardDirection, isLeftSide);
+            this.deployedFlares.push(flare);
+            
+            if (window.gameInstance) {
+                window.gameInstance.notifyMissilesOfFlare(flare);
+            }
+        }
+        
+        console.log('Enemy deployed flares!');
+    }
+    
     calculateAimAccuracy(target) {
         const toTarget = target.clone().sub(this.position).normalize();
         const forward = new THREE.Vector3(0, 0, 1).applyEuler(this.rotation);
@@ -2333,14 +2669,14 @@ update(playerPosition, deltaTime) {
         return angle;
     }
     
-   takeDamage(damage) {
-    console.log(`Enemy taking damage: ${damage}, Current health: ${this.health}`);
-    this.health -= damage;
-    console.log(`Enemy health after damage: ${this.health}`);
-    const isDead = this.health <= 0;
-    console.log(`Enemy is dead: ${isDead}`);
-    return isDead;
-}
+    takeDamage(damage) {
+        console.log(`Enemy taking damage: ${damage}, Current health: ${this.health}`);
+        this.health -= damage;
+        console.log(`Enemy health after damage: ${this.health}`);
+        const isDead = this.health <= 0;
+        console.log(`Enemy is dead: ${isDead}`);
+        return isDead;
+    }
     
     destroy() {
         if (this.mesh) {
@@ -2349,6 +2685,8 @@ update(playerPosition, deltaTime) {
             this.bullets = [];
             this.firedMissiles.forEach(missile => missile.destroy());
             this.firedMissiles = [];
+            this.deployedFlares.forEach(flare => flare.destroy());
+            this.deployedFlares = [];
             this.isLoaded = false;
         }
     }
@@ -2643,6 +2981,10 @@ class Game {
                     break;
                 case 'KeyF': 
                     this.keys.f = true; 
+                    // F키 누를 때 플레어 발사
+                    if (!event.repeat && this.fighter) {
+                        this.fighter.deployFlares();
+                    }
                     break;
                 case 'KeyR': 
                     if (!event.repeat) { // 키를 누르고 있을 때 반복 방지
@@ -2805,7 +3147,84 @@ class Game {
         // 경고음 업데이트
         this.fighter.updateWarningAudios();
     }
+    notifyMissilesOfFlare(flare) {
+        // 모든 활성 미사일에게 플레어 존재 알림
+        const allMissiles = [];
+        
+        // 플레이어 미사일
+        this.fighter.firedMissiles.forEach(missile => {
+            allMissiles.push(missile);
+        });
+        
+        // 적 미사일
+        this.enemies.forEach(enemy => {
+            enemy.firedMissiles.forEach(missile => {
+                allMissiles.push(missile);
+            });
+        });
+        
+        // 각 미사일이 플레어를 감지하도록
+        allMissiles.forEach(missile => {
+            if (missile && missile.position) {
+                const distance = missile.position.distanceTo(flare.position);
+                if (distance < 500) {
+                    // 미사일이 플레어를 감지
+                    missile.detectedFlare = flare;
+                }
+            }
+        });
+    }
 
+    findNearestFlare(position) {
+        let nearestFlare = null;
+        let nearestDistance = Infinity;
+        
+        // 플레이어 플레어
+        this.fighter.deployedFlares.forEach(flare => {
+            if (flare.heatSignature > 0.3) {
+                const distance = position.distanceTo(flare.position);
+                if (distance < nearestDistance) {
+                    nearestDistance = distance;
+                    nearestFlare = flare;
+                }
+            }
+        });
+        
+        // 적 플레어
+        this.enemies.forEach(enemy => {
+            enemy.deployedFlares.forEach(flare => {
+                if (flare.heatSignature > 0.3) {
+                    const distance = position.distanceTo(flare.position);
+                    if (distance < nearestDistance) {
+                        nearestDistance = distance;
+                        nearestFlare = flare;
+                    }
+                }
+            });
+        });
+        
+        return nearestFlare;
+    }
+
+    findIncomingMissilesForEnemy(enemy) {
+        const incomingMissiles = [];
+        
+        // 플레이어가 발사한 미사일 중 이 적을 추적하는 것
+        this.fighter.firedMissiles.forEach(missile => {
+            if (missile.target === enemy) {
+                incomingMissiles.push(missile);
+            }
+        });
+        
+        // 거리순으로 정렬
+        incomingMissiles.sort((a, b) => {
+            const distA = enemy.position.distanceTo(a.position);
+            const distB = enemy.position.distanceTo(b.position);
+            return distA - distB;
+        });
+        
+        return incomingMissiles;
+    }
     updateUI() {
         if (this.fighter.isLoaded) {
             const speedKnots = Math.round(this.fighter.speed * 1.94384);
@@ -2833,21 +3252,21 @@ class Game {
             if (timeElement) timeElement.textContent = `Time: ${this.gameTime}s`;
             
             // 무기 표시 업데이트
-            if (ammoElement) {
-                if (this.fighter.currentWeapon === 'MG') {
-                    ammoElement.textContent = `20MM MG: ${this.fighter.ammo}`;
-                    ammoElement.style.color = '#0f0';
-                } else {
-                    ammoElement.textContent = `AIM-9: ${this.fighter.aim9Missiles}`;
-                    ammoElement.style.color = '#ff0000';
-                    
-                    // 락온 상태 표시
-                    if (this.fighter.lockTarget && this.fighter.lockProgress > 0) {
-                        const lockStatus = this.fighter.lockProgress >= GAME_CONSTANTS.AIM9_LOCK_REQUIRED ? 'LOCKED' : `LOCKING ${this.fighter.lockProgress}/3`;
-                        ammoElement.textContent += ` [${lockStatus}]`;
-                    }
-                }
-            }
+if (ammoElement) {
+    if (this.fighter.currentWeapon === 'MG') {
+        ammoElement.innerHTML = `20MM MG: ${this.fighter.ammo}<br>FLARES: ${this.fighter.flareCount}`;
+        ammoElement.style.color = '#0f0';
+    } else {
+        ammoElement.innerHTML = `AIM-9: ${this.fighter.aim9Missiles}<br>FLARES: ${this.fighter.flareCount}`;
+        ammoElement.style.color = '#ff0000';
+        
+        // 락온 상태 표시
+        if (this.fighter.lockTarget && this.fighter.lockProgress > 0) {
+            const lockStatus = this.fighter.lockProgress >= GAME_CONSTANTS.AIM9_LOCK_REQUIRED ? 'LOCKED' : `LOCKING ${this.fighter.lockProgress}/3`;
+            ammoElement.innerHTML = `AIM-9: ${this.fighter.aim9Missiles}<br>FLARES: ${this.fighter.flareCount}<br>[${lockStatus}]`;
+        }
+    }
+}
             
             if (gameStatsElement) {
                 gameStatsElement.innerHTML = `