Update game.js

game.js

@@ -20,7 +20,12 @@ const GAME_CONSTANTS = {
     MISSILE_COUNT: 6,
     AMMO_COUNT: 940,  // 940발로 변경
     BULLET_DAMAGE: 50, // 발당 50 데미지
-    MAX_HEALTH: 1000  // 체력 1000
+    MAX_HEALTH: 1000,  // 체력 1000
+    AIM9_COUNT: 8,     // AIM-9 미사일 8발
+    AIM9_DAMAGE: 500,  // AIM-9 미사일 피해 500
+    AIM9_SPEED: 514.4, // 1000kt를 m/s로 변환
+    AIM9_LOCK_RANGE: 6000, // 락온 거리 6000m
+    AIM9_LOCK_REQUIRED: 3  // 3번 락온 필요
 };
 
 // 전투기 클래스
@@ -64,6 +69,19 @@ class Fighter {
        this.isMouseDown = false; // 마우스 누름 상태 추적
        this.gunfireAudios = []; // 기관총 소리 배열 (최대 5개)
        
+       // AIM-9 미사일 시스템
+       this.aim9Missiles = GAME_CONSTANTS.AIM9_COUNT;
+       this.firedMissiles = []; // 발사된 미사일 배열
+       this.currentWeapon = 'MG'; // 'MG' 또는 'AIM9'
+       this.lockTarget = null; // 현재 락온 중인 타겟
+       this.lockProgress = 0; // 락온 진행도 (0~3)
+       this.lastLockTime = 0; // 마지막 락온 시도 시간
+       this.lockAudios = {
+           locking: null,
+           locked: null
+       };
+       this.initializeLockAudios();
+       
        // 스톨 탈출을 위한 F키 상태
        this.escapeKeyPressed = false;
        this.stallEscapeProgress = 0; // 스톨 탈출 진행도 (0~2초)
@@ -142,6 +160,19 @@ class Fighter {
        }
    }
    
+   initializeLockAudios() {
+       try {
+           this.lockAudios.locking = new Audio('sounds/lockon.ogg');
+           this.lockAudios.locking.volume = 0.5;
+           this.lockAudios.locking.loop = true;
+           
+           this.lockAudios.locked = new Audio('sounds/lockondone.ogg');
+           this.lockAudios.locked.volume = 0.7;
+       } catch (e) {
+           console.log('Lock audio initialization failed:', e);
+       }
+   }
+   
    startEngineSound() {
        // 엔진 소리 시작
        if (this.warningAudios.normal) {
@@ -190,6 +221,12 @@ class Fighter {
                audio.currentTime = 0;
            }
        });
+       
+       // 락온 소리도 정지
+       if (this.lockAudios.locking && !this.lockAudios.locking.paused) {
+           this.lockAudios.locking.pause();
+           this.lockAudios.locking.currentTime = 0;
+       }
    }
 
    async initialize(scene, loader) {
@@ -252,6 +289,127 @@ class Fighter {
        
        console.log('Fallback 전투기 모델 생성 완료');
    }
+   
+   switchWeapon() {
+       if (this.currentWeapon === 'MG') {
+           this.currentWeapon = 'AIM9';
+           // 무기 전환 시 락온 초기화
+           this.lockTarget = null;
+           this.lockProgress = 0;
+           if (this.lockAudios.locking && !this.lockAudios.locking.paused) {
+               this.lockAudios.locking.pause();
+               this.lockAudios.locking.currentTime = 0;
+           }
+       } else {
+           this.currentWeapon = 'MG';
+           // MG로 전환 시 락온 해제
+           this.lockTarget = null;
+           this.lockProgress = 0;
+           if (this.lockAudios.locking && !this.lockAudios.locking.paused) {
+               this.lockAudios.locking.pause();
+               this.lockAudios.locking.currentTime = 0;
+           }
+       }
+   }
+
+   updateLockOn(enemies, deltaTime) {
+       // AIM-9 모드가 아니면 락온 하지 않음
+       if (this.currentWeapon !== 'AIM9') {
+           this.lockTarget = null;
+           this.lockProgress = 0;
+           return;
+       }
+       
+       const now = Date.now();
+       
+       // 1초에 한 번씩 락온 처리
+       if (now - this.lastLockTime < 1000) {
+           return;
+       }
+       
+       // 현재 크로스헤어 내의 적 찾기
+       let closestEnemy = null;
+       let closestDistance = GAME_CONSTANTS.AIM9_LOCK_RANGE;
+       
+       enemies.forEach(enemy => {
+           if (!enemy.mesh || !enemy.isLoaded) return;
+           
+           const distance = this.position.distanceTo(enemy.position);
+           if (distance > GAME_CONSTANTS.AIM9_LOCK_RANGE) return;
+           
+           // 적이 크로스헤어 내에 있는지 확인
+           const toEnemy = enemy.position.clone().sub(this.position).normalize();
+           const forward = new THREE.Vector3(0, 0, 1);
+           
+           // 쿼터니언을 사용하여 전방 벡터 계산
+           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);
+           
+           forward.applyQuaternion(quaternion);
+           
+           const dotProduct = forward.dot(toEnemy);
+           const angle = Math.acos(Math.max(-1, Math.min(1, dotProduct)));
+           
+           // 크로스헤어 범위 내 (약 10도)
+           if (angle < Math.PI / 18 && distance < closestDistance) {
+               closestEnemy = enemy;
+               closestDistance = distance;
+           }
+       });
+       
+       // 락온 대상 업데이트
+       if (closestEnemy) {
+           if (this.lockTarget === closestEnemy) {
+               // 같은 타겟에 계속 락온 중
+               this.lockProgress++;
+               this.lastLockTime = now;
+               
+               // 락온 소리 재생
+               if (this.lockProgress < GAME_CONSTANTS.AIM9_LOCK_REQUIRED) {
+                   if (this.lockAudios.locking && this.lockAudios.locking.paused) {
+                       this.lockAudios.locking.play().catch(e => {});
+                   }
+               } else {
+                   // 락온 완료
+                   if (this.lockAudios.locking && !this.lockAudios.locking.paused) {
+                       this.lockAudios.locking.pause();
+                       this.lockAudios.locking.currentTime = 0;
+                   }
+                   if (this.lockAudios.locked) {
+                       this.lockAudios.locked.play().catch(e => {});
+                   }
+               }
+           } else {
+               // 새로운 타겟
+               this.lockTarget = closestEnemy;
+               this.lockProgress = 1;
+               this.lastLockTime = now;
+               
+               // 락온 소리 시작
+               if (this.lockAudios.locking && this.lockAudios.locking.paused) {
+                   this.lockAudios.locking.play().catch(e => {});
+               }
+           }
+       } else {
+           // 타겟 잃음
+           this.lockTarget = null;
+           this.lockProgress = 0;
+           if (this.lockAudios.locking && !this.lockAudios.locking.paused) {
+               this.lockAudios.locking.pause();
+               this.lockAudios.locking.currentTime = 0;
+           }
+       }
+   }
 
    updateMouseInput(deltaX, deltaY) {
        // Over-G 상태에서 스톨이 해제되지 않았으면 피치 조작 불가
@@ -649,73 +807,104 @@ class Fighter {
    }
 
    shoot(scene) {
-       // 탄약이 없으면 발사하지 않음
-       if (this.ammo <= 0) return;
-       
-       this.ammo--;
-       
-       // 직선 모양의 탄환 (100% 더 크게)
-       const bulletGeometry = new THREE.CylinderGeometry(1.0, 1.0, 16, 8); // 반지름 0.75→1.0, 길이 12→16
-       const bulletMaterial = new THREE.MeshBasicMaterial({ 
-           color: 0xffff00,
-       });
-       const bullet = new THREE.Mesh(bulletGeometry, bulletMaterial);
-       
-       // 기수 끝에서 발사 (쿼터니언 사용)
-       const muzzleOffset = new THREE.Vector3(0, 0, 10);
-       
-       // 전투기와 동일한 쿼터니언 생성
-       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);
-       
-       muzzleOffset.applyQuaternion(quaternion);
-       bullet.position.copy(this.position).add(muzzleOffset);
-       
-       // 탄환을 발사 방향으로 회전
-       bullet.quaternion.copy(quaternion);
-       // 실린더가 Z축 방향을 향하도록 추가 회전
-       const cylinderRotation = new THREE.Quaternion();
-       cylinderRotation.setFromAxisAngle(new THREE.Vector3(1, 0, 0), Math.PI / 2);
-       bullet.quaternion.multiply(cylinderRotation);
-       
-       // 탄환 초기 위치 저장
-       bullet.startPosition = bullet.position.clone();
-       
-       const bulletSpeed = 1500; // 1000에서 1500으로 증가 (50% 빠르게)
-       const direction = new THREE.Vector3(0, 0, 1);
-       direction.applyQuaternion(quaternion);
-       bullet.velocity = direction.multiplyScalar(bulletSpeed);
-       
-       scene.add(bullet);
-       this.bullets.push(bullet);
-       
-       // m134.ogg 소리 재생 - 중첩 제한 해제, 랜덤 피치
-       try {
-           const audio = new Audio('sounds/m134.ogg');
-           audio.volume = 0.15; // 0.3에서 0.15로 감소 (50% 줄임)
-           
-           // -2 ~ +2 사이의 랜덤 피치 (playbackRate로 시뮬레이션)
-           const randomPitch = 0.8 + Math.random() * 0.4; // 0.8 ~ 1.2 범위
-           audio.playbackRate = randomPitch;
+       if (this.currentWeapon === 'MG') {
+           // 기존 MG 발사 로직
+           // 탄약이 없으면 발사하지 않음
+           if (this.ammo <= 0) return;
            
-           audio.play().catch(e => console.log('Gunfire sound failed to play'));
+           this.ammo--;
            
-           // 재생 완료 시 메모리 정리를 위해 참조 제거
-           audio.addEventListener('ended', () => {
-               audio.remove();
+           // 직선 모양의 탄환 (100% 더 크게)
+           const bulletGeometry = new THREE.CylinderGeometry(1.0, 1.0, 16, 8); // 반지름 0.75→1.0, 길이 12→16
+           const bulletMaterial = new THREE.MeshBasicMaterial({ 
+               color: 0xffff00,
            });
-       } catch (e) {
-           console.log('Audio error:', e);
+           const bullet = new THREE.Mesh(bulletGeometry, bulletMaterial);
+           
+           // 기수 끝에서 발사 (쿼터니언 사용)
+           const muzzleOffset = new THREE.Vector3(0, 0, 10);
+           
+           // 전투기와 동일한 쿼터니언 생성
+           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);
+           
+           muzzleOffset.applyQuaternion(quaternion);
+           bullet.position.copy(this.position).add(muzzleOffset);
+           
+           // 탄환을 발사 방향으로 회전
+           bullet.quaternion.copy(quaternion);
+           // 실린더가 Z축 방향을 향하도록 추가 회전
+           const cylinderRotation = new THREE.Quaternion();
+           cylinderRotation.setFromAxisAngle(new THREE.Vector3(1, 0, 0), Math.PI / 2);
+           bullet.quaternion.multiply(cylinderRotation);
+           
+           // 탄환 초기 위치 저장
+           bullet.startPosition = bullet.position.clone();
+           
+           const bulletSpeed = 1500; // 1000에서 1500으로 증가 (50% 빠르게)
+           const direction = new THREE.Vector3(0, 0, 1);
+           direction.applyQuaternion(quaternion);
+           bullet.velocity = direction.multiplyScalar(bulletSpeed);
+           
+           scene.add(bullet);
+           this.bullets.push(bullet);
+           
+           // m134.ogg 소리 재생 - 중첩 제한 해제, 랜덤 피치
+           try {
+               const audio = new Audio('sounds/m134.ogg');
+               audio.volume = 0.15; // 0.3에서 0.15로 감소 (50% 줄임)
+               
+               // -2 ~ +2 사이의 랜덤 피치 (playbackRate로 시뮬레이션)
+               const randomPitch = 0.8 + Math.random() * 0.4; // 0.8 ~ 1.2 범위
+               audio.playbackRate = randomPitch;
+               
+               audio.play().catch(e => console.log('Gunfire sound failed to play'));
+               
+               // 재생 완료 시 메모리 정리를 위해 참조 제거
+               audio.addEventListener('ended', () => {
+                   audio.remove();
+               });
+           } catch (e) {
+               console.log('Audio error:', e);
+           }
+       } else if (this.currentWeapon === 'AIM9') {
+           // AIM-9 미사일 발사
+           if (this.aim9Missiles <= 0) return;
+           if (this.lockProgress < GAME_CONSTANTS.AIM9_LOCK_REQUIRED) return;
+           if (!this.lockTarget) return;
+           
+           this.aim9Missiles--;
+           
+           // 미사일 생성
+           const missile = new AIM9Missile(scene, this.position.clone(), this.lockTarget, this.rotation.clone());
+           this.firedMissiles.push(missile);
+           
+           // 락온 초기화
+           this.lockTarget = null;
+           this.lockProgress = 0;
+           if (this.lockAudios.locking && !this.lockAudios.locking.paused) {
+               this.lockAudios.locking.pause();
+               this.lockAudios.locking.currentTime = 0;
+           }
+           
+           // 발사음
+           try {
+               const missileSound = new Audio('sounds/missile.ogg');
+               missileSound.volume = 0.7;
+               missileSound.play().catch(e => {});
+           } catch (e) {
+               console.log('Missile sound failed:', e);
+           }
        }
    }
 
@@ -745,6 +934,16 @@ class Fighter {
                this.bullets.splice(i, 1);
            }
        }
+       
+       // 미사일 업데이트
+       for (let i = this.firedMissiles.length - 1; i >= 0; i--) {
+           const missile = this.firedMissiles[i];
+           const result = missile.update(deltaTime, this.position);
+           
+           if (result === 'hit' || result === 'expired') {
+               this.firedMissiles.splice(i, 1);
+           }
+       }
    }
 
    takeDamage(damage) {
@@ -790,6 +989,216 @@ class Fighter {
    }
 }
 
+// AIM-9 미사일 클래스
+class AIM9Missile {
+    constructor(scene, position, target, rotation) {
+        this.scene = scene;
+        this.position = position.clone();
+        this.target = target;
+        this.rotation = rotation.clone();
+        this.speed = GAME_CONSTANTS.AIM9_SPEED;
+        this.mesh = null;
+        this.isLoaded = false;
+        this.lifeTime = 20; // 20초 후 자폭
+        this.turnRate = 3.0; // 초당 회전 속도 (라디안)
+        this.startPosition = position.clone();
+        
+        // 미사일 발사 방향 설정
+        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);
+        
+        const initialDirection = new THREE.Vector3(0, 0, 1);
+        initialDirection.applyQuaternion(quaternion);
+        this.velocity = initialDirection.multiplyScalar(this.speed);
+        
+        // 미사일 소리
+        this.swingAudio = null;
+        this.initializeAudio();
+        
+        this.createMissile();
+    }
+    
+    initializeAudio() {
+        try {
+            this.swingAudio = new Audio('sounds/missileswing.ogg');
+            this.swingAudio.volume = 0.3;
+            this.swingAudio.loop = true;
+            this.swingAudio.play().catch(e => {});
+        } catch (e) {
+            console.log('Missile swing audio failed:', e);
+        }
+    }
+    
+    async createMissile() {
+        try {
+            // GLB 모델 로드 시도
+            const loader = new GLTFLoader();
+            const result = await loader.loadAsync('models/aim-9.glb');
+            this.mesh = result.scene;
+            this.mesh.scale.set(0.5, 0.5, 0.5);
+            this.isLoaded = true;
+        } catch (error) {
+            console.log('AIM-9 model not found, using fallback');
+            this.createFallbackMissile();
+        }
+        
+        this.mesh.position.copy(this.position);
+        this.scene.add(this.mesh);
+    }
+    
+    createFallbackMissile() {
+        // 폴백 미사일 모델
+        const group = new THREE.Group();
+        
+        // 미사일 본체
+        const bodyGeometry = new THREE.CylinderGeometry(0.3, 0.4, 4, 8);
+        const bodyMaterial = new THREE.MeshLambertMaterial({ color: 0x808080 });
+        const body = new THREE.Mesh(bodyGeometry, bodyMaterial);
+        body.rotation.x = Math.PI / 2;
+        group.add(body);
+        
+        // 탄두
+        const noseGeometry = new THREE.ConeGeometry(0.3, 1, 8);
+        const noseMaterial = new THREE.MeshLambertMaterial({ color: 0x404040 });
+        const nose = new THREE.Mesh(noseGeometry, noseMaterial);
+        nose.position.z = 2.5;
+        nose.rotation.x = -Math.PI / 2;
+        group.add(nose);
+        
+        // 날개
+        const finGeometry = new THREE.BoxGeometry(2, 0.1, 0.5);
+        const finMaterial = new THREE.MeshLambertMaterial({ color: 0x606060 });
+        
+        for (let i = 0; i < 4; i++) {
+            const fin = new THREE.Mesh(finGeometry, finMaterial);
+            fin.position.z = -1.5;
+            fin.rotation.z = (Math.PI / 2) * i;
+            group.add(fin);
+        }
+        
+        // 불꽃 효과
+        const flameGeometry = new THREE.ConeGeometry(0.4, 1.5, 8);
+        const flameMaterial = new THREE.MeshBasicMaterial({ 
+            color: 0xff4400,
+            transparent: true,
+            opacity: 0.8
+        });
+        const flame = new THREE.Mesh(flameGeometry, flameMaterial);
+        flame.position.z = -2.5;
+        flame.rotation.x = Math.PI / 2;
+        group.add(flame);
+        
+        this.mesh = group;
+        this.mesh.scale.set(1.5, 1.5, 1.5);
+        this.isLoaded = true;
+    }
+    
+    update(deltaTime, playerPosition) {
+        if (!this.mesh || !this.target || !this.target.position) {
+            this.destroy();
+            return 'expired';
+        }
+        
+        this.lifeTime -= deltaTime;
+        if (this.lifeTime <= 0) {
+            this.destroy();
+            return 'expired';
+        }
+        
+        // 타겟 추적
+        const toTarget = this.target.position.clone().sub(this.position);
+        const distance = toTarget.length();
+        
+        // 명중 체크
+        if (distance < 30) {
+            // 명중!
+            this.onHit();
+            return 'hit';
+        }
+        
+        // 호밍 로직
+        toTarget.normalize();
+        const currentDirection = this.velocity.clone().normalize();
+        
+        // 부드러운 방향 전환
+        const newDirection = new THREE.Vector3();
+        newDirection.lerpVectors(currentDirection, toTarget, deltaTime * this.turnRate);
+        newDirection.normalize();
+        
+        this.velocity = newDirection.multiplyScalar(this.speed);
+        
+        // 위치 업데이트
+        this.position.add(this.velocity.clone().multiplyScalar(deltaTime));
+        this.mesh.position.copy(this.position);
+        
+        // 미사일 회전
+        const lookAtTarget = this.position.clone().add(this.velocity);
+        this.mesh.lookAt(lookAtTarget);
+        
+        // 사운드 볼륨 조정 (플레이어와의 거리에 따라)
+        if (this.swingAudio && playerPosition) {
+            const distanceToPlayer = this.position.distanceTo(playerPosition);
+            if (distanceToPlayer < 200) {
+                this.swingAudio.volume = 0.3 * (1 - distanceToPlayer / 200);
+            } else {
+                this.swingAudio.volume = 0;
+            }
+        }
+        
+        // 지면 충돌
+        if (this.position.y <= 0) {
+            this.destroy();
+            return 'expired';
+        }
+        
+        return 'flying';
+    }
+    
+    onHit() {
+        // 명중 효과
+        if (window.gameInstance) {
+            window.gameInstance.createExplosionEffect(this.position);
+        }
+        
+        // 명중음
+        try {
+            const hitSound = new Audio('sounds/missilehit.ogg');
+            hitSound.volume = 0.8;
+            hitSound.play().catch(e => {});
+        } catch (e) {
+            console.log('Missile hit sound failed:', e);
+        }
+        
+        // 타겟에게 피해
+        if (this.target.takeDamage) {
+            this.target.takeDamage(GAME_CONSTANTS.AIM9_DAMAGE);
+        }
+        
+        this.destroy();
+    }
+    
+    destroy() {
+        if (this.mesh) {
+            this.scene.remove(this.mesh);
+        }
+        
+        if (this.swingAudio) {
+            this.swingAudio.pause();
+            this.swingAudio = null;
+        }
+    }
+}
+
 // 적 전투기 클래스 - 완전히 재설계
 class EnemyFighter {
     constructor(scene, position) {
@@ -1402,7 +1811,7 @@ class Game {
         this.bgm = null;
         this.bgmPlaying = false;
         
-        this.keys = { w: false, a: false, s: false, d: false, f: false };
+        this.keys = { w: false, a: false, s: false, d: false, f: false, r: false };
         this.isStarted = false;
         
         this.setupScene();
@@ -1634,82 +2043,89 @@ class Game {
     }
 
     setupEventListeners() {
-    document.addEventListener('keydown', (event) => {
-        if (this.isGameOver) return;
-        
-        // gameStarted 대신 this.isStarted 사용
-        if (!this.isStarted) return;
-        
-        switch(event.code) {
-            case 'KeyW': 
-                this.keys.w = true; 
-                console.log('W key pressed - Accelerating');
-                break;
-            case 'KeyA': 
-                this.keys.a = true; 
-                console.log('A key pressed - Turning left');
-                break;
-            case 'KeyS': 
-                this.keys.s = true; 
-                console.log('S key pressed - Decelerating');
-                break;
-            case 'KeyD': 
-                this.keys.d = true; 
-                console.log('D key pressed - Turning right');
-                break;
-            case 'KeyF': 
-                this.keys.f = true; 
-                break;
-        }
-    });
+        document.addEventListener('keydown', (event) => {
+            if (this.isGameOver) return;
+            
+            // gameStarted 대신 this.isStarted 사용
+            if (!this.isStarted) return;
+            
+            switch(event.code) {
+                case 'KeyW': 
+                    this.keys.w = true; 
+                    console.log('W key pressed - Accelerating');
+                    break;
+                case 'KeyA': 
+                    this.keys.a = true; 
+                    console.log('A key pressed - Turning left');
+                    break;
+                case 'KeyS': 
+                    this.keys.s = true; 
+                    console.log('S key pressed - Decelerating');
+                    break;
+                case 'KeyD': 
+                    this.keys.d = true; 
+                    console.log('D key pressed - Turning right');
+                    break;
+                case 'KeyF': 
+                    this.keys.f = true; 
+                    break;
+                case 'KeyR': 
+                    if (!event.repeat) { // 키를 누르고 있을 때 반복 방지
+                        this.fighter.switchWeapon();
+                        console.log('R key pressed - Switching weapon to', this.fighter.currentWeapon);
+                    }
+                    break;
+            }
+        });
 
-    document.addEventListener('keyup', (event) => {
-        if (this.isGameOver) return;
-        
-        // gameStarted 대신 this.isStarted 사용
-        if (!this.isStarted) return;
-        
-        switch(event.code) {
-            case 'KeyW': this.keys.w = false; break;
-            case 'KeyA': this.keys.a = false; break;
-            case 'KeyS': this.keys.s = false; break;
-            case 'KeyD': this.keys.d = false; break;
-            case 'KeyF': this.keys.f = false; break;
-        }
-    });
+        document.addEventListener('keyup', (event) => {
+            if (this.isGameOver) return;
+            
+            // gameStarted 대신 this.isStarted 사용
+            if (!this.isStarted) return;
+            
+            switch(event.code) {
+                case 'KeyW': this.keys.w = false; break;
+                case 'KeyA': this.keys.a = false; break;
+                case 'KeyS': this.keys.s = false; break;
+                case 'KeyD': this.keys.d = false; break;
+                case 'KeyF': this.keys.f = false; break;
+                case 'KeyR': this.keys.r = false; break;
+            }
+        });
 
-    document.addEventListener('mousemove', (event) => {
-        // 여기도 gameStarted를 this.isStarted로 변경
-        if (!document.pointerLockElement || this.isGameOver || !this.isStarted) return;
-        
-        const deltaX = event.movementX || 0;
-        const deltaY = event.movementY || 0;
-        
-        this.fighter.updateMouseInput(deltaX, deltaY);
-    });
+        document.addEventListener('mousemove', (event) => {
+            // 여기도 gameStarted를 this.isStarted로 변경
+            if (!document.pointerLockElement || this.isGameOver || !this.isStarted) return;
+            
+            const deltaX = event.movementX || 0;
+            const deltaY = event.movementY || 0;
+            
+            this.fighter.updateMouseInput(deltaX, deltaY);
+        });
 
-    document.addEventListener('mousedown', (event) => {
-        // 여기도 gameStarted를 this.isStarted로 변경
-        if (!document.pointerLockElement || this.isGameOver || !this.isStarted) return;
-        
-        if (event.button === 0) {
-            this.fighter.isMouseDown = true;
-            this.lastShootTime = 0;
-        }
-    });
+        document.addEventListener('mousedown', (event) => {
+            // 여기도 gameStarted를 this.isStarted로 변경
+            if (!document.pointerLockElement || this.isGameOver || !this.isStarted) return;
+            
+            if (event.button === 0) {
+                this.fighter.isMouseDown = true;
+                this.lastShootTime = 0;
+            }
+        });
 
-    document.addEventListener('mouseup', (event) => {
-        if (event.button === 0) {
-            this.fighter.isMouseDown = false;
-        }
-    });
+        document.addEventListener('mouseup', (event) => {
+            if (event.button === 0) {
+                this.fighter.isMouseDown = false;
+            }
+        });
 
-    window.addEventListener('resize', () => {
-        this.camera.aspect = window.innerWidth / window.innerHeight;
-        this.camera.updateProjectionMatrix();
-        this.renderer.setSize(window.innerWidth, window.innerHeight);
-    });
-}
+        window.addEventListener('resize', () => {
+            this.camera.aspect = window.innerWidth / window.innerHeight;
+            this.camera.updateProjectionMatrix();
+            this.renderer.setSize(window.innerWidth, window.innerHeight);
+        });
+    }
 
     startGame() {
         if (!this.isLoaded) {
@@ -1796,7 +2212,23 @@ class Game {
             
             if (scoreElement) scoreElement.textContent = `Score: ${this.score}`;
             if (timeElement) timeElement.textContent = `Time: ${this.gameTime}s`;
-            if (ammoElement) ammoElement.textContent = `20MM MG: ${this.fighter.ammo}`;
+            
+            // 무기 표시 업데이트
+            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 (gameStatsElement) {
                 gameStatsElement.innerHTML = `
@@ -1898,8 +2330,21 @@ class Game {
                 if (isInCrosshair) {
                     marker.classList.add('in-crosshair');
                     
-                    // 2000m 이내면 락온
-                    if (distance < 2000) {
+                    // AIM-9 모드에서 락온 표시
+                    if (this.fighter.currentWeapon === 'AIM9' && distance < GAME_CONSTANTS.AIM9_LOCK_RANGE) {
+                        if (this.fighter.lockTarget === enemy) {
+                            if (this.fighter.lockProgress >= GAME_CONSTANTS.AIM9_LOCK_REQUIRED) {
+                                marker.classList.add('locked');
+                                marker.style.border = '2px solid #ff0000';
+                                marker.style.boxShadow = '0 0 20px #ff0000';
+                            } else {
+                                // 락온 중
+                                marker.style.border = '2px solid #ffff00';
+                                marker.style.boxShadow = '0 0 10px #ffff00';
+                                marker.style.animation = `target-pulse ${1.0 / this.fighter.lockProgress}s infinite`;
+                            }
+                        }
+                    } else if (distance < 2000) {
                         marker.classList.add('locked');
                     }
                     
@@ -1912,6 +2357,18 @@ class Game {
                     const targetInfo = document.createElement('div');
                     targetInfo.className = 'target-info';
                     targetInfo.textContent = `${Math.round(distance)}m`;
+                    
+                    // AIM-9 모드에서 락온 정보 추가
+                    if (this.fighter.currentWeapon === 'AIM9' && this.fighter.lockTarget === enemy) {
+                        if (this.fighter.lockProgress >= GAME_CONSTANTS.AIM9_LOCK_REQUIRED) {
+                            targetInfo.textContent += ' LOCKED';
+                            targetInfo.style.color = '#ff0000';
+                        } else {
+                            targetInfo.textContent += ` LOCK ${this.fighter.lockProgress}/3`;
+                            targetInfo.style.color = '#ffff00';
+                        }
+                    }
+                    
                     marker.appendChild(targetInfo);
                 }
                 
@@ -2370,146 +2827,147 @@ class Game {
         animateImpact();
         
         // 작은 충돌음
-    try {
-        const impactSound = new Audio('sounds/hit.ogg');
-        impactSound.volume = 0.2;
-        impactSound.play().catch(e => {
-            console.log('Impact sound not found or failed to play');
-        });
-    } catch (e) {
-        console.log('Impact sound error:', e);
-    }
-}
-    checkCollisions() {
-    // 플레이어와 적기의 직접 충돌 체크 (최우선)
-    for (let i = this.enemies.length - 1; i >= 0; i--) {
-        const enemy = this.enemies[i];
-        if (!enemy.mesh || !enemy.isLoaded) continue;
-        
-        const distance = this.fighter.position.distanceTo(enemy.position);
-        // 직접 충돌 판정 (80m 이내)
-        if (distance < 80) {
-            console.log('Direct collision detected! Distance:', distance);
-            
-            // 양쪽 모두의 위치 저장 (충돌 중간 지점)
-            const collisionPoint = this.fighter.position.clone().add(enemy.position).divideScalar(2);
-            const playerExplosionPos = this.fighter.position.clone();
-            const enemyExplosionPos = enemy.position.clone();
-            
-            // 더 큰 폭발음 재생 (시각 효과보다 먼저)
-            try {
-                const collisionSound = new Audio('sounds/bang.ogg');
-                collisionSound.volume = 1.0;
-                collisionSound.play().catch(e => {});
-                
-                // 두 번째 폭발음 (약간의 딜레이)
-                setTimeout(() => {
-                    const secondExplosion = new Audio('sounds/bang.ogg');
-                    secondExplosion.volume = 0.8;
-                    secondExplosion.play().catch(e => {});
-                }, 100);
-            } catch (e) {}
-            
-            // 1. 충돌 지점에 큰 폭발 효과
-            this.createExplosionEffect(collisionPoint);
-            
-            // 2. 양쪽 위치에도 폭발 효과
-            setTimeout(() => {
-                this.createExplosionEffect(playerExplosionPos);
-                this.createExplosionEffect(enemyExplosionPos);
-            }, 50);
-            
-            // 3. 적기 제거
-            enemy.destroy();
-            this.enemies.splice(i, 1);
-            this.score += 200; // 충돌 킬은 보너스 점수
-            
-            // 4. 플레이어 파괴
-            this.fighter.health = 0;
-            
-            // 5. 게임 종료
-            setTimeout(() => {
-                this.endGame(false, "COLLISION WITH ENEMY");
-            }, 100); // 폭발 효과가 보이도록 약간의 딜레이
-            
-            return; // 충돌 처리 후 즉시 종료
+        try {
+            const impactSound = new Audio('sounds/hit.ogg');
+            impactSound.volume = 0.2;
+            impactSound.play().catch(e => {
+                console.log('Impact sound not found or failed to play');
+            });
+        } catch (e) {
+            console.log('Impact sound error:', e);
         }
     }
     
-    // 플레이어 탄환 vs 적기 충돌
-    for (let i = this.fighter.bullets.length - 1; i >= 0; i--) {
-        const bullet = this.fighter.bullets[i];
-        
-        for (let j = this.enemies.length - 1; j >= 0; j--) {
-            const enemy = this.enemies[j];
+    checkCollisions() {
+        // 플레이어와 적기의 직접 충돌 체크 (최우선)
+        for (let i = this.enemies.length - 1; i >= 0; i--) {
+            const enemy = this.enemies[i];
             if (!enemy.mesh || !enemy.isLoaded) continue;
             
-            const distance = bullet.position.distanceTo(enemy.position);
-            if (distance < 90) {
-                // 적기 위치를 미리 저장 (중요!)
-                const explosionPosition = enemy.position.clone();
+            const distance = this.fighter.position.distanceTo(enemy.position);
+            // 직접 충돌 판정 (80m 이내)
+            if (distance < 80) {
+                console.log('Direct collision detected! Distance:', distance);
                 
-                // 히트 표시 추가
-                this.showHitMarker(explosionPosition);
-                // 피격 이펙트 추가
-                this.createHitEffect(explosionPosition);
+                // 양쪽 모두의 위치 저장 (충돌 중간 지점)
+                const collisionPoint = this.fighter.position.clone().add(enemy.position).divideScalar(2);
+                const playerExplosionPos = this.fighter.position.clone();
+                const enemyExplosionPos = enemy.position.clone();
                 
-                // 탄환 제거
-                this.scene.remove(bullet);
-                this.fighter.bullets.splice(i, 1);
+                // 더 큰 폭발음 재생 (시각 효과보다 먼저)
+                try {
+                    const collisionSound = new Audio('sounds/bang.ogg');
+                    collisionSound.volume = 1.0;
+                    collisionSound.play().catch(e => {});
+                    
+                    // 두 번째 폭발음 (약간의 딜레이)
+                    setTimeout(() => {
+                        const secondExplosion = new Audio('sounds/bang.ogg');
+                        secondExplosion.volume = 0.8;
+                        secondExplosion.play().catch(e => {});
+                    }, 100);
+                } catch (e) {}
+                
+                // 1. 충돌 지점에 큰 폭발 효과
+                this.createExplosionEffect(collisionPoint);
                 
-                // 데미지 적용 및 파괴 확인
-                if (enemy.takeDamage(GAME_CONSTANTS.BULLET_DAMAGE)) {
-                    // 디버깅용 로그 추가
-                    console.log('Enemy destroyed! Creating explosion at:', explosionPosition);
+                // 2. 양쪽 위치에도 폭발 효과
+                setTimeout(() => {
+                    this.createExplosionEffect(playerExplosionPos);
+                    this.createExplosionEffect(enemyExplosionPos);
+                }, 50);
+                
+                // 3. 적기 제거
+                enemy.destroy();
+                this.enemies.splice(i, 1);
+                this.score += 200; // 충돌 킬은 보너스 점수
+                
+                // 4. 플레이어 파괴
+                this.fighter.health = 0;
+                
+                // 5. 게임 종료
+                setTimeout(() => {
+                    this.endGame(false, "COLLISION WITH ENEMY");
+                }, 100); // 폭발 효과가 보이도록 약간의 딜레이
+                
+                return; // 충돌 처리 후 즉시 종료
+            }
+        }
+        
+        // 플레이어 탄환 vs 적기 충돌
+        for (let i = this.fighter.bullets.length - 1; i >= 0; i--) {
+            const bullet = this.fighter.bullets[i];
+            
+            for (let j = this.enemies.length - 1; j >= 0; j--) {
+                const enemy = this.enemies[j];
+                if (!enemy.mesh || !enemy.isLoaded) continue;
+                
+                const distance = bullet.position.distanceTo(enemy.position);
+                if (distance < 90) {
+                    // 적기 위치를 미리 저장 (중요!)
+                    const explosionPosition = enemy.position.clone();
                     
-                    // 적기 파괴 시 폭발 효과 추가 - 저장된 위치 사용
-                    this.createExplosionEffect(explosionPosition);
+                    // 히트 표시 추가
+                    this.showHitMarker(explosionPosition);
+                    // 피격 이펙트 추가
+                    this.createHitEffect(explosionPosition);
                     
-                    // 적기 제거 - 체력이 0 이하일 때만 제거
-                    enemy.destroy();
-                    this.enemies.splice(j, 1);
-                    this.score += 100;
+                    // 탄환 제거
+                    this.scene.remove(bullet);
+                    this.fighter.bullets.splice(i, 1);
                     
-                    // 추가 디버깅
-                    console.log('Enemies remaining:', this.enemies.length);
+                    // 데미지 적용 및 파괴 확인
+                    if (enemy.takeDamage(GAME_CONSTANTS.BULLET_DAMAGE)) {
+                        // 디버깅용 로그 추가
+                        console.log('Enemy destroyed! Creating explosion at:', explosionPosition);
+                        
+                        // 적기 파괴 시 폭발 효과 추가 - 저장된 위치 사용
+                        this.createExplosionEffect(explosionPosition);
+                        
+                        // 적기 제거 - 체력이 0 이하일 때만 제거
+                        enemy.destroy();
+                        this.enemies.splice(j, 1);
+                        this.score += 100;
+                        
+                        // 추가 디버깅
+                        console.log('Enemies remaining:', this.enemies.length);
+                    }
+                    // else 블록 제거 - 적이 파괴되지 않았으면 아무것도 하지 않음
+                    
+                    break; // 하나의 탄환은 하나의 적만 맞출 수 있음
                 }
-                // else 블록 제거 - 적이 파괴되지 않았으면 아무것도 하지 않음
-                
-                break; // 하나의 탄환은 하나의 적만 맞출 수 있음
             }
         }
-    }
-    
-    // 적 탄환 vs 플레이어 충돌
-    this.enemies.forEach(enemy => {
-        for (let index = enemy.bullets.length - 1; index >= 0; index--) {
-            const bullet = enemy.bullets[index];
-            const distance = bullet.position.distanceTo(this.fighter.position);
-            if (distance < 100) {
-                // 플레이어 위치 저장
-                const playerPosition = this.fighter.position.clone();
-                
-                // 플레이어 피격 이펙트
-                this.createHitEffect(playerPosition);
-                
-                // 탄환 제거
-                this.scene.remove(bullet);
-                enemy.bullets.splice(index, 1);
-                
-                if (this.fighter.takeDamage(GAME_CONSTANTS.BULLET_DAMAGE)) {
-                    console.log('Player destroyed! Creating explosion');
-                    // 플레이어 파괴 시 폭발 효과 추가
-                    this.createExplosionEffect(playerPosition);
+        
+        // 적 탄환 vs 플레이어 충돌
+        this.enemies.forEach(enemy => {
+            for (let index = enemy.bullets.length - 1; index >= 0; index--) {
+                const bullet = enemy.bullets[index];
+                const distance = bullet.position.distanceTo(this.fighter.position);
+                if (distance < 100) {
+                    // 플레이어 위치 저장
+                    const playerPosition = this.fighter.position.clone();
                     
-                    this.endGame(false);
+                    // 플레이어 피격 이펙트
+                    this.createHitEffect(playerPosition);
+                    
+                    // 탄환 제거
+                    this.scene.remove(bullet);
+                    enemy.bullets.splice(index, 1);
+                    
+                    if (this.fighter.takeDamage(GAME_CONSTANTS.BULLET_DAMAGE)) {
+                        console.log('Player destroyed! Creating explosion');
+                        // 플레이어 파괴 시 폭발 효과 추가
+                        this.createExplosionEffect(playerPosition);
+                        
+                        this.endGame(false);
+                    }
                 }
             }
-        }
-    });
-}
+        });
+    }
 
-createHitEffect(position) {
+    createHitEffect(position) {
         // 피격 파티클 효과 생성
         const particleCount = 15;
         const particles = [];
@@ -2830,101 +3288,104 @@ createHitEffect(position) {
     }
 
     animate() {
-    if (this.isGameOver) return;
-    
-    this.animationFrameId = requestAnimationFrame(() => this.animate());
-    
-    const currentTime = performance.now();
-    const deltaTime = Math.min((currentTime - this.lastTime) / 1000, 0.1);
-    this.lastTime = currentTime;
-    
-    if (this.isLoaded && this.fighter.isLoaded && this.isStarted) {
-        // 키 상태 디버깅
-        if (this.keys.w || this.keys.s || this.keys.a || this.keys.d) {
-            console.log('animate() - Keys state:', this.keys);
-        }
-        
-        // F키 상태를 Fighter에 전달
-        this.fighter.escapeKeyPressed = this.keys.f;
+        if (this.isGameOver) return;
         
-        // 컨트롤 업데이트 - 반드시 물리 업데이트 전에 호출
-        this.fighter.updateControls(this.keys, deltaTime);
+        this.animationFrameId = requestAnimationFrame(() => this.animate());
         
-        // 물리 업데이트
-        this.fighter.updatePhysics(deltaTime);
+        const currentTime = performance.now();
+        const deltaTime = Math.min((currentTime - this.lastTime) / 1000, 0.1);
+        this.lastTime = currentTime;
         
-        // 탄환 업데이트
-        this.fighter.updateBullets(this.scene, deltaTime, this);
-        
-        // 마우스 누름 상태일 때 연속 발사
-        if (this.fighter.isMouseDown) {
-            const currentShootTime = Date.now();
-            if (!this.lastShootTime || currentShootTime - this.lastShootTime >= 100) {
-                this.fighter.shoot(this.scene);
-                this.lastShootTime = currentShootTime;
+        if (this.isLoaded && this.fighter.isLoaded && this.isStarted) {
+            // 키 상태 디버깅
+            if (this.keys.w || this.keys.s || this.keys.a || this.keys.d) {
+                console.log('animate() - Keys state:', this.keys);
             }
-        }
-        
-        // 적기 업데이트
-        this.enemies.forEach(enemy => {
-            enemy.nearbyEnemies = this.enemies;
-        });
-        
-        this.enemies.forEach(enemy => {
-            enemy.update(this.fighter.position, deltaTime);
-        });
-        
-        // 충돌 체크
-        this.checkCollisions();
-        
-        // 게임 종료 조건 체크
-        if (this.fighter.health <= 0) {
-            if (this.fighter.position.y <= 0) {
-                this.endGame(false, "GROUND COLLISION");
-            } else {
-                this.endGame(false);
+            
+            // F키 상태를 Fighter에 전달
+            this.fighter.escapeKeyPressed = this.keys.f;
+            
+            // 컨트롤 업데이트 - 반드시 물리 업데이트 전에 호출
+            this.fighter.updateControls(this.keys, deltaTime);
+            
+            // 락온 업데이트 (AIM-9 모드일 때만)
+            this.fighter.updateLockOn(this.enemies, deltaTime);
+            
+            // 물리 업데이트
+            this.fighter.updatePhysics(deltaTime);
+            
+            // 탄환 업데이트
+            this.fighter.updateBullets(this.scene, deltaTime, this);
+            
+            // 마우스 누름 상태일 때 연속 발사
+            if (this.fighter.isMouseDown) {
+                const currentShootTime = Date.now();
+                if (!this.lastShootTime || currentShootTime - this.lastShootTime >= 100) {
+                    this.fighter.shoot(this.scene);
+                    this.lastShootTime = currentShootTime;
+                }
             }
-            return;
+            
+            // 적기 업데이트
+            this.enemies.forEach(enemy => {
+                enemy.nearbyEnemies = this.enemies;
+            });
+            
+            this.enemies.forEach(enemy => {
+                enemy.update(this.fighter.position, deltaTime);
+            });
+            
+            // 충돌 체크
+            this.checkCollisions();
+            
+            // 게임 종료 조건 체크
+            if (this.fighter.health <= 0) {
+                if (this.fighter.position.y <= 0) {
+                    this.endGame(false, "GROUND COLLISION");
+                } else {
+                    this.endGame(false);
+                }
+                return;
+            }
+            
+            // UI 업데이트
+            this.updateUI();
+            this.updateRadar();
+            
+            // 적이 모두 제거되었는지 체크
+            if (this.enemies.length === 0) {
+                this.endGame(true);
+            }
+        } else if (this.isLoaded && this.fighter.isLoaded) {
+            // 게임이 시작되지 않았을 때도 물리는 업데이트 (카메라 움직임을 위해)
+            this.fighter.updatePhysics(deltaTime);
         }
         
-        // UI 업데이트
-        this.updateUI();
-        this.updateRadar();
+        // 구름 애니메이션
+        if (this.clouds) {
+            this.clouds.forEach(cloud => {
+                cloud.userData.time += deltaTime;
+                cloud.position.x += cloud.userData.driftSpeed;
+                cloud.position.y = cloud.userData.initialY + 
+                    Math.sin(cloud.userData.time * cloud.userData.floatSpeed) * 20;
+                
+                const mapLimit = GAME_CONSTANTS.MAP_SIZE / 2;
+                if (cloud.position.x > mapLimit) cloud.position.x = -mapLimit;
+                if (cloud.position.x < -mapLimit) cloud.position.x = mapLimit;
+            });
+        }
         
-        // 적이 모두 제거되었는지 체크
-        if (this.enemies.length === 0) {
-            this.endGame(true);
+        // 카메라 업데이트
+        if (this.fighter.isLoaded) {
+            const targetCameraPos = this.fighter.getCameraPosition();
+            const targetCameraTarget = this.fighter.getCameraTarget();
+            
+            this.camera.position.lerp(targetCameraPos, this.fighter.cameraLag);
+            this.camera.lookAt(targetCameraTarget);
         }
-    } else if (this.isLoaded && this.fighter.isLoaded) {
-        // 게임이 시작되지 않았을 때도 물리는 업데��트 (카메라 움직임을 위해)
-        this.fighter.updatePhysics(deltaTime);
-    }
-    
-    // 구름 애니메이션
-    if (this.clouds) {
-        this.clouds.forEach(cloud => {
-            cloud.userData.time += deltaTime;
-            cloud.position.x += cloud.userData.driftSpeed;
-            cloud.position.y = cloud.userData.initialY + 
-                Math.sin(cloud.userData.time * cloud.userData.floatSpeed) * 20;
-            
-            const mapLimit = GAME_CONSTANTS.MAP_SIZE / 2;
-            if (cloud.position.x > mapLimit) cloud.position.x = -mapLimit;
-            if (cloud.position.x < -mapLimit) cloud.position.x = mapLimit;
-        });
-    }
-    
-    // 카메라 업데이트
-    if (this.fighter.isLoaded) {
-        const targetCameraPos = this.fighter.getCameraPosition();
-        const targetCameraTarget = this.fighter.getCameraTarget();
         
-        this.camera.position.lerp(targetCameraPos, this.fighter.cameraLag);
-        this.camera.lookAt(targetCameraTarget);
+        this.renderer.render(this.scene, this.camera);
     }
-    
-    this.renderer.render(this.scene, this.camera);
-}
 
     endGame(victory = false, reason = "") {
         this.isGameOver = true;