Spaces:

Duplicated from cutechicken/3D-Airforce-Simulator

openfree
/

3D-Airforce-Simulator

Running

App Files Files Community

3D-Airforce-Simulator / game.js

cutechicken's picture

Update game.js

42dc3ed verified 5 months ago

65.7 kB

	<!DOCTYPE html>
	<html>
	<head>
	<meta charset="utf-8">
	<meta name="viewport" content="width=device-width, initial-scale=1.0">
	<script src="https://cdnjs.cloudflare.com/ajax/libs/stats.js/r17/Stats.min.js"></script>
	<title>JET FIGHT SIMULATER - FPS Mode</title>
	<style>
	body {
	margin: 0;
	overflow: hidden;
	background: #000;
	font-family: 'Courier New', monospace;
	}
	#enemyLabels {
	position: absolute;
	top: 0;
	left: 0;
	width: 100%;
	height: 100%;
	pointer-events: none;
	}

	.enemy-label {
	position: absolute;
	background-color: rgba(255, 0, 0, 0.7);
	color: white;
	padding: 2px 6px;
	border-radius: 3px;
	font-size: 12px;
	font-family: Arial, sans-serif;
	transform: translate(-50%, -50%);
	white-space: nowrap;
	}
	#loading {
	position: fixed;
	top: 50%;
	left: 50%;
	transform: translate(-50%, -50%);
	background: rgba(0,0,0,0.8);
	padding: 20px;
	border-radius: 10px;
	z-index: 2000;
	text-align: center;
	}

	.loading-spinner {
	width: 50px;
	height: 50px;
	border: 5px solid #0f0;
	border-top: 5px solid transparent;
	border-radius: 50%;
	animation: spin 1s linear infinite;
	margin: 0 auto 20px;
	}

	@keyframes spin {
	0% { transform: rotate(0deg); }
	100% { transform: rotate(360deg); }
	}

	.loading-text {
	color: #0f0;
	font-size: 24px;
	text-align: center;
	}

	#gameContainer {
	position: relative;
	width: 100vw;
	height: 100vh;
	cursor: crosshair;
	}

	#info {
	position: absolute;
	top: 10px;
	left: 10px;
	color: #0f0;
	background: rgba(0,20,0,0.7);
	padding: 10px;
	font-size: 14px;
	z-index: 1001;
	border: 1px solid #0f0;
	border-radius: 5px;
	user-select: none;
	}

	#crosshair {
	position: fixed;
	top: 25%;
	left: 50%;
	transform: translate(-50%, -50%);
	width: 40px;
	height: 40px;
	border: 2px solid #00ff00;
	border-radius: 50%;
	z-index: 1001;
	pointer-events: none;
	transition: all 0.2s ease;
	}

	/* 물체가 감지되었을 때의 스타일 */
	#crosshair.target-detected {
	border-color: #ff0000;
	border-width: 3px;
	box-shadow: 0 0 10px rgba(255, 0, 0, 0.5);
	}

	#crosshair::before,
	#crosshair::after {
	content: '';
	position: absolute;
	background: #00ff00;
	transition: all 0.2s ease;
	}

	#crosshair::before {
	top: 50%;
	left: -10px;
	right: -10px;
	height: 2px;
	transform: translateY(-50%);
	}

	#crosshair::after {
	left: 50%;
	top: -10px;
	bottom: -10px;
	width: 2px;
	transform: translateX(-50%);
	}

	/* 물체가 감지되었을 때의 크로스 라인 스타일 */
	#crosshair.target-detected::before,
	#crosshair.target-detected::after {
	background: #ff0000;
	}

	#healthBar {
	position: absolute;
	bottom: 20px;
	left: 20px;
	width: 200px;
	height: 20px;
	background: rgba(0,20,0,0.7);
	border: 2px solid #0f0;
	z-index: 1001;
	border-radius: 10px;
	overflow: hidden;
	}

	#health {
	width: 100%;
	height: 100%;
	background: linear-gradient(90deg, #0f0, #00ff00);
	transition: width 0.3s;
	}

	#ammo {
	position: absolute;
	bottom: 20px;
	right: 20px;
	color: #0f0;
	background: rgba(0,20,0,0.7);
	padding: 10px;
	font-size: 20px;
	z-index: 1001;
	border: 1px solid #0f0;
	border-radius: 5px;
	}


	#gameTitle {
	position: absolute;
	top: 10px;
	left: 50%;
	transform: translateX(-50%);
	color: #0f0;
	background: rgba(0,20,0,0.7);
	padding: 10px 20px;
	font-size: 20px;
	z-index: 1001;
	border: 1px solid #0f0;
	border-radius: 5px;
	text-transform: uppercase;
	letter-spacing: 2px;
	}
	#ammoDisplay {
	position: absolute;
	bottom: 20px;
	right: 20px;
	color: #0f0;
	background: rgba(0,20,0,0.7);
	padding: 10px;
	font-size: 20px;
	z-index: 1001;
	border: 1px solid #0f0;
	border-radius: 5px;
	}

	#reloadingText {
	position: absolute;
	top: 50%;
	left: 50%;
	transform: translate(-50%, -50%);
	color: #ff0000;
	font-size: 24px;
	font-weight: bold;
	display: none;
	z-index: 1002;
	}

	#radar {
	position: absolute;
	bottom: 60px; /* 체력바 위로 이동 */
	left: 20px;
	width: 200px;
	height: 200px;
	background: rgba(0,20,0,0.3);
	border: 2px solid #0f0;
	border-radius: 50%;
	z-index: 1001;
	overflow: hidden;
	}

	#mission {
	position: absolute;
	top: 10px;
	left: 10px;
	color: #0f0;
	background: rgba(0,20,0,0.7);
	padding: 10px;
	font-size: 16px;
	z-index: 1001;
	border: 1px solid #0f0;
	border-radius: 5px;
	}

	#radarLine {
	position: absolute;
	top: 50%;
	left: 50%;
	width: 50%;
	height: 2px;
	background: #0f0;
	transform-origin: left center;
	animation: radar-sweep 4s infinite linear;
	}

	.enemy-dot {
	position: absolute;
	width: 6px;
	height: 6px;
	background: #ff0000;
	border-radius: 50%;
	transform: translate(-50%, -50%);
	}

	@keyframes radar-sweep {
	from {
	transform: rotate(0deg);
	}
	to {
	transform: rotate(360deg);
	}
	}

	#gameStats {
	position: absolute;
	top: 10px;
	right: 20px;
	color: #0f0;
	background: rgba(0,20,0,0.7);
	padding: 10px;
	font-size: 16px;
	z-index: 1001;
	border: 1px solid #0f0;
	border-radius: 5px;
	text-align: right;
	}

	.start-screen {
	position: fixed;
	top: 0;
	left: 0;
	width: 100%;
	height: 100%;
	background: rgba(0,0,0,0.8);
	display: none; /* 초기에는 숨김 */
	justify-content: center;
	align-items: center;
	flex-direction: column;
	z-index: 2000;
	}

	.start-button {
	padding: 15px 30px;
	font-size: 24px;
	background: #0f0;
	color: #000;
	border: none;
	border-radius: 5px;
	cursor: pointer;
	margin-top: 20px;
	transition: transform 0.2s;
	}

	.start-button:hover {
	transform: scale(1.1);
	}

	#minimap {
	position: absolute;
	bottom: 20px;
	right: 20px;
	width: 200px;
	height: 200px;
	background: rgba(0,20,0,0.7);
	border: 2px solid #0f0;
	border-radius: 5px;
	z-index: 1001;
	}
	</style>
	</head>
	<body>
	<!-- 로딩 화면 (처음에 표시됨) -->
	<div id="loading">
	<div class="loading-spinner"></div>
	<div class="loading-text">Loading Fighter Resources...</div>
	<div style="color: #0f0; font-size: 16px; margin-top: 10px;">
	<p>Loading Aircraft Models...</p>
	<p>Loading Audio Assets...</p>
	<p>Preparing Game Environment...</p>
	</div>
	</div>

	<!-- 게임 시작 화면 (로딩 완료 후 표시됨) -->
	<div class="start-screen" id="startScreen">
	<h1 style="color: #0f0; font-size: 48px; margin-bottom: 20px;">JET FIGHT SIMULATER</h1>
	<button class="start-button" onclick="startGame()">Start Game</button>
	<div style="color: #0f0; margin-top: 20px; text-align: center;">
	<p>Controls:</p>
	<p>W/S - Throttle Control</p>
	<p>A/D - Rudder Control</p>
	<p>Mouse - Aircraft Control</p>
	<p>Left Click - Fire</p>
	</div>
	</div>

	<!-- 게임 화면 -->
	<div id="gameContainer">
	<div id="gameTitle">JET FIGHT SIMULATER</div>
	<div id="mission">MISSION: DESTROY ENEMY JET</div>
	<div id="gameStats">
	<div id="score">Score: 0</div>
	<div id="time">Time: 180s</div>
	</div>
	<div id="crosshair"></div>
	<div id="detected" style="position: absolute; top: 55%; left: 50%; transform: translate(-50%, -50%); color: red; font-size: 16px; display: none;">DETECTED</div>
	<div id="enemyLabels"></div>

	<!-- 체력바 -->
	<div id="healthBar">
	<div id="health"></div>
	</div>

	<!-- 탄약 표시 -->
	<div id="ammoDisplay">AMMO: 300</div>

	<!-- 리로딩 텍스트 -->
	<div id="reloadingText">RELOADING...</div>

	<!-- 레이더 -->
	<div id="radar">
	<div id="radarLine"></div>
	</div>
	</div>

	<script type="importmap">
	{
	"imports": {
	"three": "https://unpkg.com/[email protected]/build/three.module.js",
	"three/addons/": "https://unpkg.com/[email protected]/examples/jsm/"
	}
	}
	</script>
	<script>
	// 게임 상태 추적 변수
	let gameCanStart = false;
	let gameStarted = false;

	function startGame() {
	// 게임과 BGM이 모두 준비되었는지 확인
	if (!gameInstance \|\| !gameInstance.isLoaded \|\| !gameInstance.isBGMReady) {
	console.log('게임이 아직 준비되지 않았습니다...');
	return;
	}

	gameStarted = true;
	document.getElementById('startScreen').style.display = 'none';

	// 게임이 시작될 때만 포인터 락 요청
	document.body.requestPointerLock();

	// 즉시 BGM 재생 시도 (사용자 클릭 시점)
	gameInstance.startBGM();
	gameInstance.startGame();
	}

	// 포인터 락 이벤트 처리
	document.addEventListener('pointerlockchange', () => {
	if (document.pointerLockElement === document.body) {
	console.log('Pointer locked');
	} else {
	console.log('Pointer unlocked');
	// 게임이 시작된 상태에서 포인터 락이 해제되면 알림 표시
	if (gameStarted && gameInstance && !gameInstance.isGameOver) {
	console.log('게임 중 포인터 락 해제됨 - 클릭하여 다시 잠그세요');
	// 간단한 알림 표시 (선택사항)
	showPointerLockNotification();
	}
	}
	});

	// 포인터 락 해제 알림 함수
	function showPointerLockNotification() {
	// 기존 알림이 있다면 제거
	const existingNotification = document.getElementById('pointerLockNotification');
	if (existingNotification) {
	existingNotification.remove();
	}

	const notification = document.createElement('div');
	notification.id = 'pointerLockNotification';
	notification.innerHTML = 'Click to resume control';
	notification.style.cssText = `
	position: fixed;
	top: 50%;
	left: 50%;
	transform: translate(-50%, -50%);
	background: rgba(0, 0, 0, 0.8);
	color: #00ff00;
	padding: 20px;
	border: 2px solid #00ff00;
	border-radius: 10px;
	font-size: 18px;
	z-index: 2001;
	text-align: center;
	pointer-events: none;
	`;

	document.body.appendChild(notification);

	// 포인터 락이 다시 활성화되면 알림 제거
	const removeNotification = () => {
	if (document.pointerLockElement) {
	notification.remove();
	document.removeEventListener('pointerlockchange', removeNotification);
	}
	};
	document.addEventListener('pointerlockchange', removeNotification);
	}

	// 전역 클릭 이벤트 리스너 - 게임 시작 전에는 포인터 락을 하지 않음
	document.addEventListener('click', (event) => {
	// Start Game 버튼이 아니고, 게임이 아직 시작되지 않았다면 포인터 락 방지
	if (!gameStarted && !event.target.classList.contains('start-button')) {
	event.preventDefault();
	event.stopPropagation();
	return false;
	}

	// 게임이 시작된 후의 클릭 처리
	if (gameStarted && gameInstance && !gameInstance.isGameOver) {
	// 포인터가 잠기지 않은 상태라면 다시 잠그기 시도
	if (!document.pointerLockElement) {
	console.log('게임 중 클릭 - 포인터 락 재요청');
	document.body.requestPointerLock();
	}
	// 포인터가 잠긴 상태라면 총 발사
	else if (gameInstance.fighter.isLoaded) {
	gameInstance.fighter.shoot(gameInstance.scene);
	}
	}
	}, true); // 캡처 단계에서 이벤트 처리

	// 게임 인스턴스가 준비되었을 때 상태 업데이트
	window.addEventListener('gameReady', () => {
	gameCanStart = true;
	});
	</script>
	<script type="module">
	import * as THREE from 'three';
	import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';

	// 게임 상수
	const GAME_CONSTANTS = {
	MISSION_DURATION: 180,
	MAP_SIZE: 15000,
	MAX_ALTITUDE: 15000, // 15km로 변경
	MIN_ALTITUDE: 0, // 0m로 변경
	MAX_SPEED: 800,
	STALL_SPEED: 120,
	GRAVITY: 9.8,
	MOUSE_SENSITIVITY: 0.001,
	MAX_G_FORCE: 12.0,
	ENEMY_COUNT: 4,
	MISSILE_COUNT: 6,
	AMMO_COUNT: 300
	};

	// 전투기 클래스
	class Fighter {
	constructor() {
	this.mesh = null;
	this.isLoaded = false;

	// 물리 속성
	this.position = new THREE.Vector3(0, 2000, 0);
	this.velocity = new THREE.Vector3(0, 0, 150);
	this.acceleration = new THREE.Vector3(0, 0, 0);
	this.rotation = new THREE.Euler(0, 0, 0);

	// 비행 제어
	this.baseSpeed = 150;
	this.throttle = 0.5;
	this.speed = 150;
	this.altitude = 2000;
	this.gForce = 1.0;
	this.health = 100;

	// 조종 입력 시스템
	this.pitchInput = 0;
	this.rollInput = 0;
	this.yawInput = 0;

	// 마우스 누적 입력
	this.mousePitch = 0;
	this.mouseRoll = 0;

	// 부드러운 회전을 위한 목표값
	this.targetPitch = 0;
	this.targetRoll = 0;
	this.targetYaw = 0;

	// 무기
	this.missiles = GAME_CONSTANTS.MISSILE_COUNT;
	this.ammo = GAME_CONSTANTS.AMMO_COUNT;
	this.bullets = [];
	this.lastShootTime = 0;

	// 카메라 설정
	this.cameraDistance = 250; // 적절한 거리
	this.cameraHeight = 30; // 약간 위쪽에서
	this.cameraLag = 0.06; // 더 빠른 추적

	// 경고 시스템
	this.altitudeWarning = false;
	this.stallWarning = false;
	this.warningBlinkTimer = 0;
	this.warningBlinkState = false;
	}

	async initialize(scene, loader) {
	try {
	const result = await loader.loadAsync('models/f-15.glb');
	this.mesh = result.scene;
	this.mesh.position.copy(this.position);
	this.mesh.scale.set(2, 2, 2);

	// 모델 방향 조정 (45도 회전)
	this.mesh.rotation.y = Math.PI / 4; // 45도 회전

	// 그림자 설정
	this.mesh.traverse((child) => {
	if (child.isMesh) {
	child.castShadow = true;
	child.receiveShadow = true;
	}
	});

	scene.add(this.mesh);
	this.isLoaded = true;

	console.log('F-15 전투기 로딩 완료');
	} catch (error) {
	console.error('F-15 모델 로딩 실패:', error);
	this.createFallbackModel(scene);
	}
	}

	createFallbackModel(scene) {
	const group = new THREE.Group();

	// 동체 - Z축 방향으로 생성하여 앞을 향하게 함
	const fuselageGeometry = new THREE.CylinderGeometry(0.8, 1.5, 12, 8);
	const fuselageMaterial = new THREE.MeshLambertMaterial({ color: 0x606060 });
	const fuselage = new THREE.Mesh(fuselageGeometry, fuselageMaterial);
	fuselage.rotation.x = Math.PI / 2; // X축으로 90도 회전하여 머리가 앞을 향하게 함
	group.add(fuselage);

	// 주익
	const wingGeometry = new THREE.BoxGeometry(16, 0.3, 4);
	const wingMaterial = new THREE.MeshLambertMaterial({ color: 0x404040 });
	const wings = new THREE.Mesh(wingGeometry, wingMaterial);
	wings.position.z = -1;
	group.add(wings);

	// 수직 안정판
	const tailGeometry = new THREE.BoxGeometry(0.3, 4, 3);
	const tailMaterial = new THREE.MeshLambertMaterial({ color: 0x404040 });
	const tail = new THREE.Mesh(tailGeometry, tailMaterial);
	tail.position.z = -5;
	tail.position.y = 1.5;
	group.add(tail);

	// 수평 안정판
	const horizontalTailGeometry = new THREE.BoxGeometry(6, 0.2, 2);
	const horizontalTail = new THREE.Mesh(horizontalTailGeometry, tailMaterial);
	horizontalTail.position.z = -5;
	horizontalTail.position.y = 0.5;
	group.add(horizontalTail);

	this.mesh = group;
	this.mesh.position.copy(this.position);
	this.mesh.scale.set(2, 2, 2);
	scene.add(this.mesh);
	this.isLoaded = true;

	console.log('Fallback 전투기 모델 생성 완료');
	}

	updateMouseInput(deltaX, deltaY) {
	// 마우스 감도 조정
	const sensitivity = GAME_CONSTANTS.MOUSE_SENSITIVITY * 2.0;

	// 마우스 움직임을 직접 회전 각도에 누적 적용 (상대적 입력)
	// X축 (좌/우) -> 롤 변화량
	this.targetRoll += deltaX * sensitivity;

	// Y축 (위/아래) -> 피치 변화량 (반전: 마우스 아래 = 기수 위로)
	this.targetPitch -= deltaY * sensitivity;

	// 엄격한 각도 제한 (워썬더 현실성)
	const maxPitchAngle = Math.PI / 3.5; // 약 51도 (매우 제한적)
	const maxRollAngle = Math.PI; // 180도 (배럴롤 가능)

	this.targetPitch = Math.max(-maxPitchAngle, Math.min(maxPitchAngle, this.targetPitch));
	this.targetRoll = Math.max(-maxRollAngle, Math.min(maxRollAngle, this.targetRoll));

	// 롤 각도 정규화 (360도 회전 시 0도로 리셋)
	if (this.targetRoll > Math.PI) {
	this.targetRoll -= 2 * Math.PI;
	} else if (this.targetRoll < -Math.PI) {
	this.targetRoll += 2 * Math.PI;
	}
	}

	updateControls(keys, deltaTime) {
	// 스로틀 제어
	if (keys.w) {
	this.throttle = Math.min(1.0, this.throttle + deltaTime * 0.8);
	}
	if (keys.s) {
	this.throttle = Math.max(0.1, this.throttle - deltaTime * 0.8);
	}

	// 러더 제어 (키보드 A/D) - 순수 요 회전만
	if (keys.a) {
	this.targetYaw -= deltaTime * 0.8; // 왼쪽 러더
	}
	if (keys.d) {
	this.targetYaw += deltaTime * 0.8; // 오른쪽 러더
	}

	// 마우스 입력 변수들 초기화 (사용하지 않음)
	this.pitchInput = 0;
	this.rollInput = 0;
	this.yawInput = 0;
	this.mousePitch = 0;
	this.mouseRoll = 0;
	}

	updatePhysics(deltaTime) {
	if (!this.mesh) return;

	// 부드러운 회전 보간
	const rotationSpeed = deltaTime * 3.0;
	this.rotation.x = THREE.MathUtils.lerp(this.rotation.x, this.targetPitch, rotationSpeed);
	this.rotation.y = THREE.MathUtils.lerp(this.rotation.y, this.targetYaw, rotationSpeed);
	this.rotation.z = THREE.MathUtils.lerp(this.rotation.z, this.targetRoll, rotationSpeed);

	// 기본 속도 계산
	const minSpeed = 100;
	const maxSpeed = 300;
	let targetSpeed = minSpeed + (maxSpeed - minSpeed) * this.throttle;

	// 강화된 스톨 시스템: 높은 받음각에서 급격한 속도 감소
	const pitchAngle = Math.abs(this.rotation.x);
	if (pitchAngle > Math.PI / 6) { // 30도 이상부터 속도 감소 시작
	const stallFactor = Math.max(0.2, 1 - (pitchAngle - Math.PI / 6) * 3);
	targetSpeed *= stallFactor;
	}

	// 수직에 가까울수록 더 큰 속도 감소
	if (pitchAngle > Math.PI / 4) { // 45도 이상에서 더 큰 패널티
	const severeStallFactor = Math.max(0.1, 1 - (pitchAngle - Math.PI / 4) * 4);
	targetSpeed *= severeStallFactor;
	}

	this.speed = THREE.MathUtils.lerp(this.speed, targetSpeed, deltaTime * 3); // 더 빠른 속도 변화

	// 스톨 경고 (속도 60% 이하로 강화)
	const normalSpeed = minSpeed + (maxSpeed - minSpeed) * this.throttle;
	this.stallWarning = (this.speed / normalSpeed) < 0.6;

	// 워썬더 스타일: 롤에 따른 자연스러운 방향 전환
	// 롤이 있을 때만 자연스러운 선회 발생
	const rollAngle = Math.abs(this.rotation.z);

	if (rollAngle > 0.1 && pitchAngle < Math.PI / 4) { // 45도 이하에서만 정상 선회
	const rollEffect = Math.sin(this.rotation.z);
	const turnRate = rollEffect * deltaTime * 0.3; // 선회율 감소
	this.targetYaw += turnRate;
	}

	// 핵심: 전투기는 기수가 향하는 방향으로 직접 이동
	const noseDirection = new THREE.Vector3(0, 0, 1);
	noseDirection.applyEuler(this.rotation);

	// 기수 방향으로 속도 벡터 설정
	this.velocity = noseDirection.multiplyScalar(this.speed);

	// 강화된 중력 효과 (급기동 시 더 큰 영향)
	let gravityEffect = GAME_CONSTANTS.GRAVITY * deltaTime * 0.05;
	if (pitchAngle > Math.PI / 6) {
	gravityEffect = (1 + pitchAngle 2); // 급기동 시 중력 영향 증가
	}
	this.velocity.y -= gravityEffect;

	// 위치 업데이트
	this.position.add(this.velocity.clone().multiplyScalar(deltaTime));

	// 지면 충돌 (0m에서 폭발)
	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;
	}

	// 고도 및 G-Force 계산
	this.altitude = this.position.y;
	this.gForce = 1.0 + (Math.abs(this.rotation.x) + Math.abs(this.rotation.z)) * 3;
	}

	shoot(scene) {
	const currentTime = Date.now();
	if (currentTime - this.lastShootTime < 100 \|\| this.ammo <= 0) return;

	this.lastShootTime = currentTime;
	this.ammo--;

	const bulletGeometry = new THREE.SphereGeometry(0.2);
	const bulletMaterial = new THREE.MeshBasicMaterial({
	color: 0xffff00,
	emissive: 0xffff00,
	emissiveIntensity: 0.7
	});
	const bullet = new THREE.Mesh(bulletGeometry, bulletMaterial);

	// 총구 위치 계산 (전투기 앞쪽)
	const muzzleOffset = new THREE.Vector3(0, 0, 8);
	muzzleOffset.applyEuler(this.rotation);
	bullet.position.copy(this.position).add(muzzleOffset);

	const bulletSpeed = 1000;
	const direction = new THREE.Vector3(0, 0, 1);
	direction.applyEuler(this.rotation);
	bullet.velocity = direction.multiplyScalar(bulletSpeed).add(this.velocity);

	scene.add(bullet);
	this.bullets.push(bullet);

	// 발사음 (에러 방지)
	try {
	const audio = new Audio('sounds/gunfire.ogg');
	if (audio) {
	audio.volume = 0.3;
	audio.play().catch(e => console.log('Gunfire sound failed to play'));
	}
	} catch (e) {
	// 조용히 무시
	}
	}

	updateBullets(scene, deltaTime) {
	for (let i = this.bullets.length - 1; i >= 0; i--) {
	const bullet = this.bullets[i];
	bullet.position.add(bullet.velocity.clone().multiplyScalar(deltaTime));

	if (bullet.position.distanceTo(this.position) > 8000 \|\|
	bullet.position.y < 0 \|\|
	bullet.position.y > GAME_CONSTANTS.MAX_ALTITUDE + 500) {
	scene.remove(bullet);
	this.bullets.splice(i, 1);
	}
	}
	}

	takeDamage(damage) {
	this.health -= damage;
	return this.health <= 0;
	}

	// 매우 안정화된 카메라 시스템 (극단적 상황 완전 방지)
	getCameraPosition() {
	// 전투기의 현재 방향 벡터들
	const backward = new THREE.Vector3(0, 0, -1);
	let up = new THREE.Vector3(0, 1, 0);

	// 피치 각도 체크
	const pitchAngle = Math.abs(this.rotation.x);

	// 극단적인 피치에서 카메라 강제 안정화
	if (pitchAngle > Math.PI / 6) { // 30도 이상에서 안정화 시작
	// 월드 업 벡터를 강제로 사용하여 카메라 뒤집힘 방지
	const worldUp = new THREE.Vector3(0, 1, 0);
	const stabilizeFactor = Math.min((pitchAngle - Math.PI / 6) / (Math.PI / 12), 0.9);
	up = up.clone().applyEuler(this.rotation).lerp(worldUp, stabilizeFactor);
	} else {
	// 정상 범위에서는 전투기 방향 따라가기
	up.applyEuler(this.rotation);
	}

	// 백워드 벡터는 항상 전투기 방향 적용
	backward.applyEuler(this.rotation);

	// 카메라 위치 계산 (더 멀리, 더 높게)
	const cameraPosition = this.position.clone()
	.add(backward.multiplyScalar(this.cameraDistance))
	.add(up.multiplyScalar(this.cameraHeight));

	return cameraPosition;
	}

	getCameraTarget() {
	// 전투기 중심점을 안정적으로 바라보기
	return this.position.clone();
	}
	}

	// 적 전투기 클래스
	class EnemyFighter {
	constructor(scene, position) {
	this.mesh = null;
	this.isLoaded = false;
	this.scene = scene;
	this.position = position.clone();
	this.velocity = new THREE.Vector3(0, 0, 120);
	this.rotation = new THREE.Euler(0, 0, 0);
	this.health = 100;
	this.speed = 120;
	this.bullets = [];
	this.lastShootTime = 0;

	this.aiState = 'patrol';
	this.targetPosition = position.clone();
	this.patrolCenter = position.clone();
	this.patrolRadius = 2000;
	this.lastStateChange = 0;
	}

	async initialize(loader) {
	try {
	const result = await loader.loadAsync('models/mig-29.glb');
	this.mesh = result.scene;
	this.mesh.position.copy(this.position);
	this.mesh.scale.set(1.5, 1.5, 1.5);

	// 적 전투기도 270도 회전
	this.mesh.rotation.y = 3 * Math.PI / 2;

	this.mesh.traverse((child) => {
	if (child.isMesh) {
	child.castShadow = true;
	child.receiveShadow = true;
	}
	});

	this.scene.add(this.mesh);
	this.isLoaded = true;

	console.log('MiG-29 적기 로딩 완료');
	} catch (error) {
	console.error('MiG-29 모델 로딩 실패:', error);
	this.createFallbackModel();
	}
	}

	createFallbackModel() {
	const group = new THREE.Group();

	const fuselageGeometry = new THREE.CylinderGeometry(0.6, 1.0, 8, 8);
	const fuselageMaterial = new THREE.MeshLambertMaterial({ color: 0x800000 });
	const fuselage = new THREE.Mesh(fuselageGeometry, fuselageMaterial);
	fuselage.rotation.x = -Math.PI / 2; // 동일한 방향 조정
	group.add(fuselage);

	const wingGeometry = new THREE.BoxGeometry(12, 0.3, 3);
	const wingMaterial = new THREE.MeshLambertMaterial({ color: 0x600000 });
	const wings = new THREE.Mesh(wingGeometry, wingMaterial);
	wings.position.z = -0.5;
	group.add(wings);

	this.mesh = group;
	this.mesh.position.copy(this.position);
	this.mesh.scale.set(1.5, 1.5, 1.5);
	this.scene.add(this.mesh);
	this.isLoaded = true;

	console.log('Fallback 적기 모델 생성 완료');
	}

	update(playerPosition, deltaTime) {
	if (!this.mesh \|\| !this.isLoaded) return;

	const currentTime = Date.now();
	const distanceToPlayer = this.position.distanceTo(playerPosition);

	if (distanceToPlayer < 5000) {
	const direction = new THREE.Vector3()
	.subVectors(playerPosition, this.position)
	.normalize();

	this.velocity = direction.multiplyScalar(this.speed);
	this.rotation.y = Math.atan2(direction.x, direction.z);

	if (distanceToPlayer < 2000 && currentTime - this.lastShootTime > 1500) {
	this.shoot();
	}
	} else {
	if (this.position.distanceTo(this.targetPosition) < 300) {
	const angle = Math.random() * Math.PI * 2;
	this.targetPosition = this.patrolCenter.clone().add(
	new THREE.Vector3(
	Math.cos(angle) * this.patrolRadius,
	(Math.random() - 0.5) * 1000,
	Math.sin(angle) * this.patrolRadius
	)
	);
	}

	const direction = new THREE.Vector3()
	.subVectors(this.targetPosition, this.position)
	.normalize();

	this.velocity = direction.multiplyScalar(this.speed * 0.7);
	this.rotation.y = Math.atan2(direction.x, direction.z);
	}

	this.position.add(this.velocity.clone().multiplyScalar(deltaTime));

	if (this.position.y < GAME_CONSTANTS.MIN_ALTITUDE) {
	this.position.y = GAME_CONSTANTS.MIN_ALTITUDE;
	}
	if (this.position.y > GAME_CONSTANTS.MAX_ALTITUDE) {
	this.position.y = GAME_CONSTANTS.MAX_ALTITUDE;
	}

	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; // 기본 270도 회전 유지
	this.mesh.rotation.z = this.rotation.z;

	this.updateBullets(deltaTime);
	}

	shoot() {
	this.lastShootTime = Date.now();

	const bulletGeometry = new THREE.SphereGeometry(0.15);
	const bulletMaterial = new THREE.MeshBasicMaterial({
	color: 0xff0000,
	emissive: 0xff0000,
	emissiveIntensity: 0.5
	});
	const bullet = new THREE.Mesh(bulletGeometry, bulletMaterial);

	const muzzleOffset = new THREE.Vector3(0, 0, 6);
	muzzleOffset.applyEuler(this.rotation);
	bullet.position.copy(this.position).add(muzzleOffset);

	const direction = new THREE.Vector3(0, 0, 1);
	direction.applyEuler(this.rotation);
	bullet.velocity = direction.multiplyScalar(800);

	this.scene.add(bullet);
	this.bullets.push(bullet);
	}

	updateBullets(deltaTime) {
	for (let i = this.bullets.length - 1; i >= 0; i--) {
	const bullet = this.bullets[i];
	bullet.position.add(bullet.velocity.clone().multiplyScalar(deltaTime));

	if (bullet.position.distanceTo(this.position) > 5000 \|\|
	bullet.position.y < 0) {
	this.scene.remove(bullet);
	this.bullets.splice(i, 1);
	}
	}
	}

	takeDamage(damage) {
	this.health -= damage;
	return this.health <= 0;
	}

	destroy() {
	if (this.mesh) {
	this.scene.remove(this.mesh);
	this.bullets.forEach(bullet => this.scene.remove(bullet));
	this.bullets = [];
	this.isLoaded = false;
	}
	}
	}

	// 메인 게임 클래스
	class Game {
	constructor() {
	this.scene = new THREE.Scene();
	this.camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 50000);
	this.renderer = new THREE.WebGLRenderer({ antialias: true });
	this.renderer.setSize(window.innerWidth, window.innerHeight);
	this.renderer.shadowMap.enabled = true;
	this.renderer.shadowMap.type = THREE.PCFSoftShadowMap;
	this.renderer.setClearColor(0x87CEEB);
	this.renderer.setPixelRatio(window.devicePixelRatio);

	document.getElementById('gameContainer').appendChild(this.renderer.domElement);

	this.loader = new GLTFLoader();
	this.fighter = new Fighter();
	this.enemies = [];
	this.isLoaded = false;
	this.isBGMReady = false;
	this.isGameOver = false;
	this.gameTime = GAME_CONSTANTS.MISSION_DURATION;
	this.score = 0;
	this.lastTime = performance.now();
	this.gameTimer = null;
	this.animationFrameId = null;

	this.bgm = null;
	this.bgmPlaying = false;

	this.keys = { w: false, a: false, s: false, d: false };
	this.isStarted = false;

	this.setupScene();
	this.setupEventListeners();
	this.preloadGame();
	}

	async preloadGame() {
	try {
	console.log('게임 리소스 사전 로딩 중...');

	await this.fighter.initialize(this.scene, this.loader);

	if (!this.fighter.isLoaded) {
	throw new Error('전투기 로딩 실패');
	}

	await this.preloadEnemies();

	this.isLoaded = true;
	console.log('게임 리소스 로딩 완료');

	// BGM 사전 로딩
	await this.preloadBGM();

	// 모든 리소스 로딩 완료 후 UI 업데이트
	this.showStartScreen();

	this.animate();

	} catch (error) {
	console.error('게임 사전 로딩 실패:', error);
	document.getElementById('loading').innerHTML =
	'<div class="loading-text" style="color: red;">로딩 실패. 페이지를 새로고침해주세요.</div>';
	}
	}

	showStartScreen() {
	if (this.isLoaded && this.isBGMReady) {
	// 로딩 화면 숨기기
	const loadingElement = document.getElementById('loading');
	if (loadingElement) {
	loadingElement.style.display = 'none';
	}

	// Start Game 화면 표시
	const startScreen = document.getElementById('startScreen');
	if (startScreen) {
	startScreen.style.display = 'flex';
	}

	// 게임 준비 완료 이벤트 발생
	window.dispatchEvent(new Event('gameReady'));

	console.log('모든 리소스 준비 완료 - Start Game 버튼 표시');
	}
	}

	async preloadBGM() {
	console.log('BGM 사전 로딩...');

	return new Promise((resolve) => {
	try {
	this.bgm = new Audio('sounds/main.ogg');
	this.bgm.volume = 0.5;
	this.bgm.loop = true;

	// BGM 로딩 완료 이벤트
	this.bgm.addEventListener('canplaythrough', () => {
	console.log('BGM 재생 준비 완료');
	this.isBGMReady = true;
	resolve();
	});

	this.bgm.addEventListener('error', (e) => {
	console.log('BGM 에러:', e);
	this.isBGMReady = true; // 에러가 나더라도 게임은 시작할 수 있게
	resolve();
	});

	// 파일 사전 로딩
	this.bgm.load();

	// 타임아웃 설정 (3초 후에도 로딩이 안되면 강제로 완료)
	setTimeout(() => {
	if (!this.isBGMReady) {
	console.log('BGM 로딩 타임아웃 - 게임 진행');
	this.isBGMReady = true;
	resolve();
	}
	}, 3000);

	} catch (error) {
	console.log('BGM 사전 로딩 실패:', error);
	this.isBGMReady = true; // 에러가 나더라도 게임은 시작할 수 있게
	resolve();
	}
	});
	}

	async preloadEnemies() {
	for (let i = 0; i < GAME_CONSTANTS.ENEMY_COUNT; i++) {
	const angle = (i / GAME_CONSTANTS.ENEMY_COUNT) * Math.PI * 2;
	const distance = 6000 + Math.random() * 3000;

	const position = new THREE.Vector3(
	Math.cos(angle) * distance,
	2500 + Math.random() * 2000,
	Math.sin(angle) * distance
	);

	const enemy = new EnemyFighter(this.scene, position);
	await enemy.initialize(this.loader);
	this.enemies.push(enemy);
	}
	}

	setupScene() {
	this.scene.background = new THREE.Color(0x87CEEB);
	this.scene.fog = new THREE.Fog(0x87CEEB, 1000, 30000);

	const ambientLight = new THREE.AmbientLight(0xffffff, 0.6);
	this.scene.add(ambientLight);

	const directionalLight = new THREE.DirectionalLight(0xffffff, 1.0);
	directionalLight.position.set(8000, 10000, 8000);
	directionalLight.castShadow = true;
	directionalLight.shadow.mapSize.width = 2048;
	directionalLight.shadow.mapSize.height = 2048;
	directionalLight.shadow.camera.near = 0.5;
	directionalLight.shadow.camera.far = 20000;
	directionalLight.shadow.camera.left = -10000;
	directionalLight.shadow.camera.right = 10000;
	directionalLight.shadow.camera.top = 10000;
	directionalLight.shadow.camera.bottom = -10000;
	this.scene.add(directionalLight);

	const groundGeometry = new THREE.PlaneGeometry(GAME_CONSTANTS.MAP_SIZE, GAME_CONSTANTS.MAP_SIZE);
	const groundMaterial = new THREE.MeshLambertMaterial({
	color: 0x8FBC8F,
	transparent: true,
	opacity: 0.8
	});
	const ground = new THREE.Mesh(groundGeometry, groundMaterial);
	ground.rotation.x = -Math.PI / 2;
	ground.receiveShadow = true;
	this.scene.add(ground);

	this.addClouds();
	}

	addClouds() {
	const cloudGeometry = new THREE.SphereGeometry(100, 8, 6);
	const cloudMaterial = new THREE.MeshLambertMaterial({
	color: 0xffffff,
	transparent: true,
	opacity: 0.5
	});

	for (let i = 0; i < 100; i++) {
	const cloud = new THREE.Mesh(cloudGeometry, cloudMaterial);
	cloud.position.set(
	(Math.random() - 0.5) * GAME_CONSTANTS.MAP_SIZE,
	Math.random() * 4000 + 1000,
	(Math.random() - 0.5) * GAME_CONSTANTS.MAP_SIZE
	);
	cloud.scale.set(
	Math.random() * 3 + 1,
	Math.random() * 2 + 0.5,
	Math.random() * 3 + 1
	);
	this.scene.add(cloud);
	}
	}

	setupEventListeners() {
	document.addEventListener('keydown', (event) => {
	if (this.isGameOver \|\| !gameStarted) return;

	switch(event.code) {
	case 'KeyW': this.keys.w = true; break;
	case 'KeyA': this.keys.a = true; break;
	case 'KeyS': this.keys.s = true; break;
	case 'KeyD': this.keys.d = true; break;
	}
	});

	document.addEventListener('keyup', (event) => {
	if (this.isGameOver \|\| !gameStarted) 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;
	}
	});

	document.addEventListener('mousemove', (event) => {
	if (!document.pointerLockElement \|\| this.isGameOver \|\| !gameStarted) return;

	const deltaX = event.movementX \|\| 0;
	const deltaY = event.movementY \|\| 0;

	this.fighter.updateMouseInput(deltaX, deltaY);
	});

	window.addEventListener('resize', () => {
	this.camera.aspect = window.innerWidth / window.innerHeight;
	this.camera.updateProjectionMatrix();
	this.renderer.setSize(window.innerWidth, window.innerHeight);
	});
	}

	startGame() {
	if (!this.isLoaded) {
	console.log('게임이 아직 로딩 중입니다...');
	return;
	}

	this.isStarted = true;
	this.startGameTimer();

	console.log('게임 시작!');
	}

	startBGM() {
	if (this.bgmPlaying \|\| !this.bgm) return;

	console.log('BGM 재생 시도...');

	// 즉시 재생 시도
	const playPromise = this.bgm.play();

	if (playPromise !== undefined) {
	playPromise.then(() => {
	this.bgmPlaying = true;
	console.log('BGM 재생 시작 성공!');
	}).catch(error => {
	console.log('자동 재생이 차단됨:', error);
	console.log('클릭 후 재생 시도 대기 중...');

	// 사용자 상호작용 후 재생 재시도
	const tryPlayOnInteraction = () => {
	if (!this.bgmPlaying && this.bgm) {
	console.log('사용자 상호작용으로 BGM 재생 시도...');
	this.bgm.play().then(() => {
	this.bgmPlaying = true;
	console.log('BGM 재생 시작 성공 (클릭 후)!');
	// 이벤트 리스너 제거
	document.removeEventListener('click', tryPlayOnInteraction);
	document.removeEventListener('keydown', tryPlayOnInteraction);
	}).catch(e => console.log('BGM 재생 실패:', e));
	}
	};

	// 클릭이나 키보드 입력 시 재생 시도
	document.addEventListener('click', tryPlayOnInteraction);
	document.addEventListener('keydown', tryPlayOnInteraction);
	});
	}
	}

	startGameTimer() {
	this.gameTimer = setInterval(() => {
	if (!this.isGameOver) {
	this.gameTime--;

	if (this.gameTime <= 0) {
	this.endGame(true);
	}
	}
	}, 1000);
	}

	updateUI() {
	if (this.fighter.isLoaded) {
	const speedKnots = Math.round(this.fighter.speed * 1.94384);
	const altitudeFeet = Math.round(this.fighter.altitude * 3.28084);
	const altitudeMeters = Math.round(this.fighter.altitude);

	// 안전한 DOM 요소 업데이트
	const scoreElement = document.getElementById('score');
	const timeElement = document.getElementById('time');
	const healthElement = document.getElementById('health');
	const ammoElement = document.getElementById('ammoDisplay');
	const gameStatsElement = document.getElementById('gameStats');

	if (scoreElement) scoreElement.textContent = `Score: ${this.score}`;
	if (timeElement) timeElement.textContent = `Time: ${this.gameTime}s`;
	if (healthElement) healthElement.style.width = `${this.fighter.health}%`;
	if (ammoElement) ammoElement.textContent = `AMMO: ${this.fighter.ammo}`;

	if (gameStatsElement) {
	gameStatsElement.innerHTML = `
	<div>Score: ${this.score}</div>
	<div>Time: ${this.gameTime}s</div>
	<div>Speed: ${speedKnots} KT</div>
	<div>Alt: ${altitudeMeters}m (${altitudeFeet} FT)</div>
	<div>Throttle: ${Math.round(this.fighter.throttle * 100)}%</div>
	<div>G-Force: ${this.fighter.gForce.toFixed(1)}</div>
	<div>Targets: ${this.enemies.length}</div>
	`;
	}

	// 경고 시스템 UI 업데이트
	this.updateWarnings();
	}
	}

	updateWarnings() {
	// 기존 경고 제거
	const existingWarnings = document.querySelectorAll('.warning-message');
	existingWarnings.forEach(w => w.remove());

	// 깜빡임 상태일 때만 경고 표시
	if (this.fighter.warningBlinkState) {
	const warningContainer = document.createElement('div');
	warningContainer.className = 'warning-message';
	warningContainer.style.cssText = `
	position: fixed;
	top: 30%;
	left: 50%;
	transform: translateX(-50%);
	color: #ff0000;
	font-size: 24px;
	font-weight: bold;
	text-shadow: 2px 2px 4px rgba(0,0,0,0.8);
	z-index: 1500;
	text-align: center;
	`;

	let warningText = '';
	if (this.fighter.altitudeWarning) {
	warningText += 'ALTITUDE WARNING\n';
	}
	if (this.fighter.stallWarning) {
	warningText += 'STALL WARNING\n';
	}

	if (warningText) {
	warningContainer.innerHTML = warningText.replace(/\n/g, '<br>');
	document.body.appendChild(warningContainer);
	}
	}
	}

	updateRadar() {
	const radar = document.getElementById('radar');
	if (!radar) return;

	const oldDots = radar.getElementsByClassName('enemy-dot');
	while (oldDots[0]) {
	oldDots[0].remove();
	}

	const radarCenter = { x: 100, y: 100 };
	const radarRange = 10000;

	this.enemies.forEach(enemy => {
	if (!enemy.mesh \|\| !enemy.isLoaded) return;

	const distance = this.fighter.position.distanceTo(enemy.position);
	if (distance <= radarRange) {
	const relativePos = enemy.position.clone().sub(this.fighter.position);
	const angle = Math.atan2(relativePos.x, relativePos.z);
	const relativeDistance = distance / radarRange;

	const dotX = radarCenter.x + Math.sin(angle) * (radarCenter.x * relativeDistance);
	const dotY = radarCenter.y + Math.cos(angle) * (radarCenter.y * relativeDistance);

	const dot = document.createElement('div');
	dot.className = 'enemy-dot';
	dot.style.left = `${dotX}px`;
	dot.style.top = `${dotY}px`;
	radar.appendChild(dot);
	}
	});
	}

	checkCollisions() {
	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 < 25) {
	this.scene.remove(bullet);
	this.fighter.bullets.splice(i, 1);

	if (enemy.takeDamage(30)) {
	enemy.destroy();
	this.enemies.splice(j, 1);
	this.score += 100;
	}
	break;
	}
	}
	}

	this.enemies.forEach(enemy => {
	enemy.bullets.forEach((bullet, index) => {
	const distance = bullet.position.distanceTo(this.fighter.position);
	if (distance < 30) {
	this.scene.remove(bullet);
	enemy.bullets.splice(index, 1);

	if (this.fighter.takeDamage(20)) {
	this.endGame(false);
	}
	}
	});
	});
	}

	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.fighter.updateControls(this.keys, deltaTime);
	this.fighter.updatePhysics(deltaTime);
	this.fighter.updateBullets(this.scene, deltaTime);

	if (this.isStarted) {
	this.enemies.forEach(enemy => {
	enemy.update(this.fighter.position, deltaTime);
	});

	this.checkCollisions();

	// 지면 충돌 체크 (0m에서 폭발)
	if (this.fighter.health <= 0 && this.fighter.position.y <= 0) {
	this.endGame(false, "GROUND COLLISION");
	return;
	}

	this.updateUI();
	this.updateRadar();

	if (this.enemies.length === 0) {
	this.endGame(true);
	}
	}

	// 카메라 업데이트 (전투기 꼬리 정확 추적)
	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.fighter.isLoaded) {
	const initialCameraPos = this.fighter.getCameraPosition();
	const initialTarget = this.fighter.getCameraTarget();
	this.camera.position.copy(initialCameraPos);
	this.camera.lookAt(initialTarget);
	}
	}

	this.renderer.render(this.scene, this.camera);
	}

	endGame(victory = false, reason = "") {
	this.isGameOver = true;

	if (this.bgm) {
	this.bgm.pause();
	this.bgm = null;
	this.bgmPlaying = false;
	}

	if (this.gameTimer) {
	clearInterval(this.gameTimer);
	}

	document.exitPointerLock();

	// 기존 경고 메시지 제거
	const existingWarnings = document.querySelectorAll('.warning-message');
	existingWarnings.forEach(w => w.remove());

	const gameOverDiv = document.createElement('div');
	gameOverDiv.className = 'start-screen';
	gameOverDiv.innerHTML = `
	<h1 style="color: ${victory ? '#0f0' : '#f00'}; font-size: 48px;">
	${victory ? 'MISSION ACCOMPLISHED!' : 'SHOT DOWN!'}
	</h1>
	${reason ? `<div style="color: #ff0000; font-size: 20px; margin: 10px 0;">${reason}</div>` : ''}
	<div style="color: #0f0; font-size: 24px; margin: 20px 0;">
	Final Score: ${this.score}<br>
	Enemies Destroyed: ${GAME_CONSTANTS.ENEMY_COUNT - this.enemies.length}<br>
	Mission Time: ${GAME_CONSTANTS.MISSION_DURATION - this.gameTime}s
	</div>
	<button class="start-button" onclick="location.reload()">
	New Mission
	</button>
	`;

	document.body.appendChild(gameOverDiv);
	}
	}

	// 게임 인스턴스
	window.gameInstance = null;

	// 게임 초기화
	document.addEventListener('DOMContentLoaded', () => {
	console.log('전투기 시뮬레이터 초기화 중...');
	window.gameInstance = new Game();
	});
	</script>
	</body>
	</html>