Update game.js

game.js

@@ -461,230 +461,23 @@ class Fighter {
             this.stallEscapeProgress = 0; // 스톨 진입 시 진행도 초기화
         }
         
-        // Uncaught SyntaxError 해결을 위해 함수 끝 부분 수정
-        } else if (this.stallWarning && !this.escapeKeyPressed) {
-            // F키를 놓으면 진행도 감소
-            this.stallEscapeProgress = Math.max(0, this.stallEscapeProgress - deltaTime * 2);
-        }
-        
-        // 속도 변화 적용
+        // 스톨 탈출 조건
         if (this.stallWarning) {
-            // 스톨 상태에서의 속도 변화
-            if (pitchAngle > 0.1) { // 기수가 아래를 향할 때
-                // 다이빙으로 인한 속도 증가
-                const diveSpeedGain = Math.min(pitchAngle * 300, 200); // 최대 200m/s 증가
-                this.speed = Math.min(maxSpeed, this.speed + diveSpeedGain * deltaTime);
+            if (this.escapeKeyPressed) {
+                // F키를 누르고 있으면 진행도 증가
+                this.stallEscapeProgress += deltaTime;
+                
+                // 2초 이상 누르면 스톨에서 탈출
+                if (this.stallEscapeProgress >= 2.0 && speedKnots >= 350) {
+                    this.stallWarning = false;
+                    this.stallEscapeProgress = 0;
+                    // 스톨에서 벗어나면 자세를 약간 안정화
+                    this.targetPitch = Math.max(-0.2, Math.min(0.2, this.targetPitch));
+                }
             } else {
-                // 기수가 위를 향하거나 수평일 때는 속도 감소
-                this.speed = Math.max(0, this.speed - deltaTime * 100);
+                // F키를 놓으면 진행도 감소
+                this.stallEscapeProgress = Math.max(0, this.stallEscapeProgress - deltaTime * 2);
             }
-        } else {
-            // 정상 비행 시 속도 변화
-            this.speed = THREE.MathUtils.lerp(this.speed, targetSpeed, deltaTime * 0.5);
-        }
-        
-        // 스톨 상태에서의 물리 효과
-        if (this.stallWarning) {
-            // 바닥으로 추락하며 가속도가 빠르게 붙음
-            this.targetPitch = Math.min(Math.PI / 2.5, this.targetPitch + deltaTime * 2.5); // 기수가 더 극단적으로 아래로 (72도까지)
-            
-            // 조종 불능 상태 - 더 심한 흔들림
-            this.rotation.x += (Math.random() - 0.5) * deltaTime * 0.8;
-            this.rotation.z += (Math.random() - 0.5) * deltaTime * 0.8;
-            
-            // 중력에 의한 가속
-            const gravityAcceleration = GAME_CONSTANTS.GRAVITY * deltaTime * 3.0; // 3배 중력
-            this.velocity.y -= gravityAcceleration;
-        }
-        
-        // 속도 벡터 계산
-        const noseDirection = new THREE.Vector3(0, 0, 1);
-        noseDirection.applyEuler(this.rotation);
-        
-        if (!this.stallWarning) {
-            // 정상 비행 시
-            this.velocity = noseDirection.multiplyScalar(this.speed);
-        } else {
-            // 스톨 시에는 중력이 주도적이지만 다이빙 속도도 반영
-            this.velocity.x = noseDirection.x * this.speed * 0.5; // 전방 속도 증가
-            this.velocity.z = noseDirection.z * this.speed * 0.5;
-            // y 속도는 위에서 중력으로 처리됨
-        }
-        
-        // 정상 비행 시 중력 효과
-        if (!this.stallWarning) {
-            const gravityEffect = GAME_CONSTANTS.GRAVITY * deltaTime * 0.15;
-            this.velocity.y -= gravityEffect;
-            
-            // 양력 효과 (속도에 비례)
-            const liftFactor = (this.speed / maxSpeed) * 0.8;
-            const lift = gravityEffect * liftFactor;
-            this.velocity.y += lift;
-        }
-        
-        // 위치 업데이트
-        this.position.add(this.velocity.clone().multiplyScalar(deltaTime));
-        
-        // 지형 충돌 감지 (Game 클래스에서 처리하도록 수정)
-        
-        // 지면 충돌
-        if (this.position.y <= GAME_CONSTANTS.MIN_ALTITUDE) {
-            this.position.y = GAME_CONSTANTS.MIN_ALTITUDE;
-            this.health = 0;
-            return;
-        }
-        
-        // 최대 고도 제한
-        if (this.position.y > GAME_CONSTANTS.MAX_ALTITUDE) {
-            this.position.y = GAME_CONSTANTS.MAX_ALTITUDE;
-            this.altitudeWarning = true;
-            if (this.velocity.y > 0) this.velocity.y = 0;
-        } else {
-            this.altitudeWarning = false;
-        }
-        
-        // 맵 경계 처리
-        const mapLimit = GAME_CONSTANTS.MAP_SIZE / 2;
-        if (this.position.x > mapLimit) this.position.x = -mapLimit;
-        if (this.position.x < -mapLimit) this.position.x = mapLimit;
-        if (this.position.z > mapLimit) this.position.z = -mapLimit;
-        if (this.position.z < -mapLimit) this.position.z = mapLimit;
-        
-        // 메시 위치 및 회전 업데이트
-        this.mesh.position.copy(this.position);
-        this.mesh.rotation.x = this.rotation.x;
-        this.mesh.rotation.y = this.rotation.y + 3 * Math.PI / 2;
-        this.mesh.rotation.z = this.rotation.z;
-        
-        // 경고 깜빡임 타이머
-        this.warningBlinkTimer += deltaTime;
-        if (this.warningBlinkTimer >= 1.0) {
-            this.warningBlinkTimer = 0;
-            this.warningBlinkState = !this.warningBlinkState;
-        }
-        
-        // 고도 계산
-        this.altitude = this.position.y;
-        
-        // 경고음 업데이트 (엔진 소리는 계속 유지)
-        this.updateWarningAudios();
-        
-        // 엔진 소리 볼륨을 스로틀에 연동
-        if (this.warningAudios.normal && !this.warningAudios.normal.paused) {
-            this.warningAudios.normal.volume = 0.3 + this.throttle * 0.4; // 0.3~0.7
-        }
-    } F키를 놓으면 진행도 감소
-            this.stallEscapeProgress = Math.max(0, this.stallEscapeProgress - deltaTime * 2);
-        }
-        
-        // 속도 변화 적용
-        if (this.stallWarning) {
-            // 스톨 상태에서의 속도 변화
-            if (pitchAngle > 0.1) { // 기수가 아래를 향할 때
-                // 다이빙으로 인한 속도 증가
-                const diveSpeedGain = Math.min(pitchAngle * 300, 200); // 최대 200m/s 증가
-                this.speed = Math.min(maxSpeed, this.speed + diveSpeedGain * deltaTime);
-            } else {
-                // 기수가 위를 향하거나 수평일 때는 속도 감소
-                this.speed = Math.max(0, this.speed - deltaTime * 100);
-            }
-        } else {
-            // 정상 비행 시 속도 변화
-            this.speed = THREE.MathUtils.lerp(this.speed, targetSpeed, deltaTime * 0.5);
-        }
-        
-        // 스톨 상태에서의 물리 효과
-        if (this.stallWarning) {
-            // 바닥으로 추락하며 가속도가 빠르게 붙음
-            this.targetPitch = Math.min(Math.PI / 2.5, this.targetPitch + deltaTime * 2.5); // 기수가 더 극단적으로 아래로 (72도까지)
-            
-            // 조종 불능 상태 - 더 심한 흔들림
-            this.rotation.x += (Math.random() - 0.5) * deltaTime * 0.8;
-            this.rotation.z += (Math.random() - 0.5) * deltaTime * 0.8;
-            
-            // 중력에 의한 가속
-            const gravityAcceleration = GAME_CONSTANTS.GRAVITY * deltaTime * 3.0; // 3배 중력
-            this.velocity.y -= gravityAcceleration;
-        }
-        
-        // 속도 벡터 계산
-        const noseDirection = new THREE.Vector3(0, 0, 1);
-        noseDirection.applyEuler(this.rotation);
-        
-        if (!this.stallWarning) {
-            // 정상 비행 시
-            this.velocity = noseDirection.multiplyScalar(this.speed);
-        } else {
-            // 스톨 시에는 중력이 주도적이지만 다이빙 속도도 반영
-            this.velocity.x = noseDirection.x * this.speed * 0.5; // 전방 속도 증가
-            this.velocity.z = noseDirection.z * this.speed * 0.5;
-            // y 속도는 위에서 중력으로 처리됨
-        }
-        
-        // 정상 비행 시 중력 효과
-        if (!this.stallWarning) {
-            const gravityEffect = GAME_CONSTANTS.GRAVITY * deltaTime * 0.15;
-            this.velocity.y -= gravityEffect;
-            
-            // 양력 효과 (속도에 비례)
-            const liftFactor = (this.speed / maxSpeed) * 0.8;
-            const lift = gravityEffect * liftFactor;
-            this.velocity.y += lift;
-        }
-        
-        // 위치 업데이트
-        this.position.add(this.velocity.clone().multiplyScalar(deltaTime));
-        
-        // 지형 충돌 감지 (Game 클래스에서 처리하도록 수정)
-        
-        // 지면 충돌
-        if (this.position.y <= GAME_CONSTANTS.MIN_ALTITUDE) {
-            this.position.y = GAME_CONSTANTS.MIN_ALTITUDE;
-            this.health = 0;
-            return;
-        }
-        
-        // 최대 고도 제한
-        if (this.position.y > GAME_CONSTANTS.MAX_ALTITUDE) {
-            this.position.y = GAME_CONSTANTS.MAX_ALTITUDE;
-            this.altitudeWarning = true;
-            if (this.velocity.y > 0) this.velocity.y = 0;
-        } else {
-            this.altitudeWarning = false;
-        }
-        
-        // 맵 경계 처리
-        const mapLimit = GAME_CONSTANTS.MAP_SIZE / 2;
-        if (this.position.x > mapLimit) this.position.x = -mapLimit;
-        if (this.position.x < -mapLimit) this.position.x = mapLimit;
-        if (this.position.z > mapLimit) this.position.z = -mapLimit;
-        if (this.position.z < -mapLimit) this.position.z = mapLimit;
-        
-        // 메시 위치 및 회전 업데이트
-        this.mesh.position.copy(this.position);
-        this.mesh.rotation.x = this.rotation.x;
-        this.mesh.rotation.y = this.rotation.y + 3 * Math.PI / 2;
-        this.mesh.rotation.z = this.rotation.z;
-        
-        // 경고 깜빡임 타이머
-        this.warningBlinkTimer += deltaTime;
-        if (this.warningBlinkTimer >= 1.0) {
-            this.warningBlinkTimer = 0;
-            this.warningBlinkState = !this.warningBlinkState;
-        }
-        
-        // 고도 계산
-        this.altitude = this.position.y;
-        
-        // 경고음 업데이트 (엔진 소리는 계속 유지)
-        this.updateWarningAudios();
-        
-        // 엔진 소리 볼륨을 스로틀에 연동
-        if (this.warningAudios.normal && !this.warningAudios.normal.paused) {
-            this.warningAudios.normal.volume = 0.3 + this.throttle * 0.4; // 0.3~0.7
-        }
-    } F키를 놓으면 진행도 감소
-            this.stallEscapeProgress = Math.max(0, this.stallEscapeProgress - deltaTime * 2);
         }
         
         // 속도 변화 적용
@@ -1440,362 +1233,6 @@ class Game {
         // 개선된 구름 추가
         this.addClouds();
     }
-    
-    createProceduralTerrain() {
-        // 지형 생성을 위한 세그먼트
-        const segments = 100;
-        const terrainGeometry = new THREE.PlaneGeometry(
-            GAME_CONSTANTS.MAP_SIZE, 
-            GAME_CONSTANTS.MAP_SIZE, 
-            segments, 
-            segments
-        );
-        
-        // 버텍스에 노이즈 추가하여 언덕 효과
-        const vertices = terrainGeometry.attributes.position.array;
-        const heightMap = [];
-        
-        for (let i = 0; i < vertices.length; i += 3) {
-            const x = vertices[i];
-            const y = vertices[i + 1];
-            
-            // 다중 스케일 노이즈로 자연스러운 지형 생성
-            let height = 0;
-            
-            // 큰 스케일 언덕 (주요 지형)
-            height += Math.sin(x * 0.0001) * Math.cos(y * 0.0001) * 300;
-            
-            // 중간 스케일 언덕
-            height += Math.sin(x * 0.0003) * Math.cos(y * 0.0003) * 150;
-            
-            // 작은 스케일 디테일
-            height += Math.sin(x * 0.001) * Math.cos(y * 0.001) * 50;
-            
-            // 랜덤 노이즈
-            height += (Math.random() - 0.5) * 20;
-            
-            // 맵 가장자리로 갈수록 높이 감소 (경계 부드럽게)
-            const distanceFromCenter = Math.sqrt(x * x + y * y);
-            const maxDistance = GAME_CONSTANTS.MAP_SIZE * 0.4;
-            if (distanceFromCenter > maxDistance) {
-                const fade = 1 - (distanceFromCenter - maxDistance) / (GAME_CONSTANTS.MAP_SIZE * 0.1);
-                height *= Math.max(0, fade);
-            }
-            
-            vertices[i + 2] = height;
-            heightMap.push(height);
-        }
-        
-        terrainGeometry.computeVertexNormals();
-        
-        // 단순한 초록색 지형 머티리얼
-        const terrainMaterial = new THREE.MeshLambertMaterial({
-            color: 0x8FBC8F,
-            flatShading: false
-        });
-        
-        const terrain = new THREE.Mesh(terrainGeometry, terrainMaterial);
-        terrain.rotation.x = -Math.PI / 2;
-        terrain.receiveShadow = true;
-        
-        // 지형 정보 저장 (초목 배치 및 충돌 판정용)
-        this.terrain = terrain;
-        this.terrainGeometry = terrainGeometry;
-        this.heightMap = heightMap;
-        this.terrainSegments = segments;
-        
-        this.scene.add(terrain);
-    }
-    
-    addVegetation() {
-        if (!this.terrain || !this.heightMap) return;
-        
-        // 간단한 나무 배치
-        const treeCount = 300;
-        
-        for (let i = 0; i < treeCount; i++) {
-            // 랜덤 위치 선택
-            const x = (Math.random() - 0.5) * GAME_CONSTANTS.MAP_SIZE * 0.8;
-            const z = (Math.random() - 0.5) * GAME_CONSTANTS.MAP_SIZE * 0.8;
-            
-            // 해당 위치의 지형 높이 계산
-            const terrainHeight = this.getTerrainHeightAt(x, z);
-            
-            // 너무 높은 곳에는 나무를 배치하지 않음
-            if (terrainHeight > 200) continue;
-            
-            // 간단한 나무 생성
-            const tree = new THREE.Group();
-            
-            // 몸통
-            const trunkGeometry = new THREE.CylinderGeometry(1, 1.5, 15, 6);
-            const trunkMaterial = new THREE.MeshLambertMaterial({ 
-                color: 0x4a3c28 
-            });
-            const trunk = new THREE.Mesh(trunkGeometry, trunkMaterial);
-            trunk.position.y = 7.5;
-            trunk.castShadow = true;
-            trunk.receiveShadow = true;
-            tree.add(trunk);
-            
-            // 잎
-            const leavesGeometry = new THREE.SphereGeometry(8, 6, 5);
-            const leavesMaterial = new THREE.MeshLambertMaterial({ 
-                color: 0x2d5016 
-            });
-            const leaves = new THREE.Mesh(leavesGeometry, leavesMaterial);
-            leaves.position.y = 20;
-            leaves.castShadow = true;
-            leaves.receiveShadow = true;
-            tree.add(leaves);
-            
-            // 나무 위치 및 크기 설정
-            tree.position.set(x, terrainHeight, z);
-            
-            // 크기 변화
-            const scale = 0.8 + Math.random() * 0.4;
-            tree.scale.set(scale, scale, scale);
-            
-            // 랜덤 회전
-            tree.rotation.y = Math.random() * Math.PI * 2;
-            
-            this.scene.add(tree);
-        }
-        
-        // 간단한 관목 추가
-        const bushCount = 200;
-        
-        for (let i = 0; i < bushCount; i++) {
-            const x = (Math.random() - 0.5) * GAME_CONSTANTS.MAP_SIZE * 0.8;
-            const z = (Math.random() - 0.5) * GAME_CONSTANTS.MAP_SIZE * 0.8;
-            const terrainHeight = this.getTerrainHeightAt(x, z);
-            
-            if (terrainHeight > 150) continue;
-            
-            const bushGeometry = new THREE.SphereGeometry(3, 5, 4);
-            const bushMaterial = new THREE.MeshLambertMaterial({ 
-                color: 0x3a5f3a 
-            });
-            const bush = new THREE.Mesh(bushGeometry, bushMaterial);
-            
-            bush.position.set(x, terrainHeight + 1.5, z);
-            bush.scale.set(
-                1 + Math.random() * 0.5,
-                0.6 + Math.random() * 0.3,
-                1 + Math.random() * 0.5
-            );
-            
-            bush.castShadow = true;
-            bush.receiveShadow = true;
-            
-            this.scene.add(bush);
-        }
-    }
-    
-    getTerrainHeightAt(x, z) {
-        if (!this.terrainGeometry || !this.heightMap) return 0;
-        
-        // 지형 좌표를 정규화
-        const normalizedX = (x + GAME_CONSTANTS.MAP_SIZE / 2) / GAME_CONSTANTS.MAP_SIZE;
-        const normalizedZ = (z + GAME_CONSTANTS.MAP_SIZE / 2) / GAME_CONSTANTS.MAP_SIZE;
-        
-        // 가장 가까운 버텍스 인덱스 찾기
-        const segments = this.terrainSegments || 100; // terrainSegments가 없으면 기본값 사용
-        const gridX = Math.floor(normalizedX * (segments - 1));
-        const gridZ = Math.floor(normalizedZ * (segments - 1));
-        
-        if (gridX < 0 || gridX >= segments - 1 || gridZ < 0 || gridZ >= segments - 1) {
-            return 0;
-        }
-        
-        const index = gridZ * segments + gridX;
-        return this.heightMap[index] || 0;
-    }
-    
-    addAtmosphericEffects() {
-        // 개선된 산 지형 시스템
-        this.createMountainRanges();
-    }
-    
-    createMountainRanges() {
-        // 산맥 생성을 위한 설정
-        const mountainRanges = [
-            { 
-                distance: GAME_CONSTANTS.MAP_SIZE * 0.6,
-                count: 25,
-                heightRange: { min: 2000, max: 5000 },
-                widthRange: { min: 1500, max: 3000 },
-                color: 0x5a6b7a
-            },
-            { 
-                distance: GAME_CONSTANTS.MAP_SIZE * 0.8,
-                count: 20,
-                heightRange: { min: 3000, max: 7000 },
-                widthRange: { min: 2000, max: 4000 },
-                color: 0x4a5b6a
-            },
-            { 
-                distance: GAME_CONSTANTS.MAP_SIZE * 1.0,
-                count: 15,
-                heightRange: { min: 4000, max: 9000 },
-                widthRange: { min: 3000, max: 5000 },
-                color: 0x3a4b5a
-            }
-        ];
-        
-        mountainRanges.forEach(range => {
-            for (let i = 0; i < range.count; i++) {
-                const angle = (i / range.count) * Math.PI * 2 + (Math.random() - 0.5) * 0.3;
-                const distance = range.distance + (Math.random() - 0.5) * 1000;
-                
-                // 산 그룹 생성 (여러 봉우리로 구성)
-                const mountainGroup = new THREE.Group();
-                
-                // 메인 봉우리
-                const mainPeakHeight = range.heightRange.min + Math.random() * (range.heightRange.max - range.heightRange.min);
-                const mainPeakWidth = range.widthRange.min + Math.random() * (range.widthRange.max - range.widthRange.min);
-                
-                // 개선된 산 형태 (팔각뿔 대신 더 자연스러운 형태)
-                const mainPeakGeometry = new THREE.ConeGeometry(mainPeakWidth, mainPeakHeight, 12);
-                const vertices = mainPeakGeometry.attributes.position.array;
-                
-                // 정점 변형으로 더 자연스러운 산 형태 만들기
-                for (let j = 0; j < vertices.length; j += 3) {
-                    const x = vertices[j];
-                    const y = vertices[j + 1];
-                    const z = vertices[j + 2];
-                    
-                    // 높이에 따른 랜덤 변형
-                    const heightFactor = (y + mainPeakHeight * 0.5) / mainPeakHeight;
-                    const noise = (Math.random() - 0.5) * mainPeakWidth * 0.3 * (1 - heightFactor);
-                    
-                    vertices[j] += noise;
-                    vertices[j + 2] += noise;
-                }
-                
-                mainPeakGeometry.computeVertexNormals();
-                
-                const mainPeakMaterial = new THREE.MeshLambertMaterial({
-                    color: range.color,
-                    flatShading: true,
-                    fog: true
-                });
-                
-                const mainPeak = new THREE.Mesh(mainPeakGeometry, mainPeakMaterial);
-                mountainGroup.add(mainPeak);
-                
-                // 주변 작은 봉우리들 추가
-                const subPeakCount = 2 + Math.floor(Math.random() * 3);
-                for (let j = 0; j < subPeakCount; j++) {
-                    const subPeakHeight = mainPeakHeight * (0.5 + Math.random() * 0.3);
-                    const subPeakWidth = mainPeakWidth * (0.6 + Math.random() * 0.3);
-                    
-                    const subPeakGeometry = new THREE.ConeGeometry(subPeakWidth, subPeakHeight, 8);
-                    const subPeak = new THREE.Mesh(subPeakGeometry, mainPeakMaterial);
-                    
-                    // 메인 봉우리 주변에 배치
-                    const offsetAngle = (j / subPeakCount) * Math.PI * 2;
-                    const offsetDistance = mainPeakWidth * (0.6 + Math.random() * 0.4);
-                    
-                    subPeak.position.set(
-                        Math.cos(offsetAngle) * offsetDistance,
-                        -mainPeakHeight * 0.3,
-                        Math.sin(offsetAngle) * offsetDistance
-                    );
-                    
-                    mountainGroup.add(subPeak);
-                }
-                
-                // 산 기반부 (더 자연스러운 경사)
-                const baseGeometry = new THREE.CylinderGeometry(
-                    mainPeakWidth * 1.5,
-                    mainPeakWidth * 2.5,
-                    mainPeakHeight * 0.3,
-                    12
-                );
-                const baseMaterial = new THREE.MeshLambertMaterial({
-                    color: new THREE.Color(range.color).multiplyScalar(0.8),
-                    flatShading: true,
-                    fog: true
-                });
-                const base = new THREE.Mesh(baseGeometry, baseMaterial);
-                base.position.y = -mainPeakHeight * 0.35;
-                mountainGroup.add(base);
-                
-                // 산 그룹 위치 설정
-                mountainGroup.position.set(
-                    Math.cos(angle) * distance,
-                    mainPeakHeight * 0.5,
-                    Math.sin(angle) * distance
-                );
-                
-                // 약간의 랜덤 회전
-                mountainGroup.rotation.y = Math.random() * Math.PI;
-                
-                // 거리별 색상: 멀리 있는 산일수록 더 푸른색으로 보이도록 설정
-                mountainGroup.layers.set(0);
-                
-                this.scene.add(mountainGroup);
-            }
-        });
-        
-        // 가장 먼 거리에 거대한 산맥 실루엣 추가
-        this.createDistantMountainSilhouette();
-    }
-    
-    createDistantMountainSilhouette() {
-        // 원거리 산맥 실루엣 (2D 평면)
-        const silhouetteDistance = GAME_CONSTANTS.MAP_SIZE * 1.2;
-        const segments = 50;
-        
-        for (let side = 0; side < 4; side++) {
-            const curve = new THREE.CatmullRomCurve3([]);
-            
-            // 산맥 실루엣 곡선 생성
-            for (let i = 0; i <= segments; i++) {
-                const t = i / segments;
-                const x = (t - 0.5) * GAME_CONSTANTS.MAP_SIZE;
-                const baseHeight = 3000;
-                const variation = Math.sin(t * Math.PI * 3) * 2000 + 
-                                Math.sin(t * Math.PI * 7) * 1000 +
-                                Math.sin(t * Math.PI * 13) * 500;
-                const y = baseHeight + variation + Math.random() * 500;
-                
-                curve.points.push(new THREE.Vector3(x, y, 0));
-            }
-            
-            // 실루엣 메시 생성
-            const points = curve.getPoints(100);
-            const shape = new THREE.Shape();
-            
-            shape.moveTo(points[0].x, 0);
-            points.forEach(p => shape.lineTo(p.x, p.y));
-            shape.lineTo(points[points.length - 1].x, 0);
-            shape.lineTo(points[0].x, 0);
-            
-            const silhouetteGeometry = new THREE.ShapeGeometry(shape);
-            const silhouetteMaterial = new THREE.MeshBasicMaterial({
-                color: 0x2a3b4a,
-                side: THREE.DoubleSide,
-                fog: true,
-                transparent: true,
-                opacity: 0.7
-            });
-            
-            const silhouette = new THREE.Mesh(silhouetteGeometry, silhouetteMaterial);
-            
-            // 각 면에 배치
-            const angle = (side / 4) * Math.PI * 2;
-            silhouette.position.set(
-                Math.cos(angle) * silhouetteDistance,
-                0,
-                Math.sin(angle) * silhouetteDistance
-            );
-            silhouette.lookAt(0, 0, 0);
-            
-            this.scene.add(silhouette);
-        }
-    }
 
     addClouds() {
         // 다층 구름 시스템
@@ -2051,11 +1488,11 @@ class Game {
         const rollDegrees = this.fighter.rotation.z * (180 / Math.PI);
         hudElement.style.transform = `translate(-50%, -50%) rotate(${-rollDegrees}deg)`;
         
-        // 피치 래더 업데이트 - 수정된 부분
+        // 피치 래더 업데이트
         const pitchLadder = document.getElementById('pitchLadder');
         if (pitchLadder) {
             const pitchDegrees = this.fighter.rotation.x * (180 / Math.PI);
-            // 수정: 음수를 곱해서 반대 방향으로, 10도당 20픽셀
+            // 음수를 곱해서 반대 방향으로, 10도당 20픽셀
             const pitchOffset = -pitchDegrees * 2;
             pitchLadder.style.transform = `translateY(${pitchOffset}px)`;
         }
@@ -2164,7 +1601,6 @@ class Game {
         return { x, y };
     }
 
-    // Game 클래스의 updateWarnings 메서드 수정
     updateWarnings() {
         // 기존 경고 메시지 제거
         const existingWarnings = document.querySelectorAll('.warning-message');