Spaces:

gunship999
/

Gunship-3D-FPS

Running

App Files Files Community

gini1 commited on 4 days ago

Commit

bafb03c

•

1 Parent(s): cdd12f9

Update index.html

Browse files

Files changed (1) hide show

index.html +203 -286

index.html CHANGED Viewed

@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html>
 <head>
-    <title>Helicopter Combat Game</title>
     <meta charset="utf-8">
     <style>
         body {
@@ -100,6 +100,15 @@
             z-index: 100;
             border-radius: 5px;
         }
     </style>
 </head>
 <body>
@@ -117,6 +126,7 @@
     <div id="healthBar"><div id="health"></div></div>
     <div id="ammo">Ammo: 30/30</div>
     <div id="stage">Stage 1</div>
     <script async src="https://unpkg.com/es-module-shims@1.6.3/dist/es-module-shims.js"></script>
@@ -138,9 +148,10 @@
         const GAME_DURATION = 180; // 3분
         const MAX_STAGES = 5;
         const ENEMY_MODELS = ['1.GLB', '2.GLB', '3.GLB', '4.GLB'];
-        const HELICOPTER_HEIGHT = 30; // 헬기 높이
-        const ENEMY_SCALE = 2.5; // 적 크기
-        const MAX_HEALTH = 1000; // 증가된 체력
         // 게임 변수
         let scene, camera, renderer, controls;
@@ -165,10 +176,10 @@
         // Scene 초기화
         function initScene() {
             scene = new THREE.Scene();
-            scene.background = new THREE.Color(0x87ceeb);
-            scene.fog = new THREE.Fog(0x87ceeb, 0, 500);
-            camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
             camera.position.set(0, HELICOPTER_HEIGHT, 0);
             renderer = new THREE.WebGLRenderer({ antialias: true });
@@ -178,25 +189,45 @@
             document.body.appendChild(renderer.domElement);
             // 조명
-            const ambientLight = new THREE.AmbientLight(0xffffff, 1.2);
             scene.add(ambientLight);
-            const dirLight = new THREE.DirectionalLight(0xffffff, 1.5);
-            dirLight.position.set(50, 50, 0);
             dirLight.castShadow = true;
             dirLight.shadow.mapSize.width = 4096;
             dirLight.shadow.mapSize.height = 4096;
-            dirLight.shadow.camera.far = 300;
             scene.add(dirLight);
-            // 반사광
-            const hemiLight = new THREE.HemisphereLight(0xffffff, 0x444444, 0.8);
-            scene.add(hemiLight);
         }
         // 총알 생성
         function createBullet(isEnemy = false) {
-            const bulletGeometry = new THREE.SphereGeometry(0.2, 8, 8);
             const bulletMaterial = new THREE.MeshBasicMaterial({
                 color: isEnemy ? 0xff0000 : 0xffff00,
                 emissive: isEnemy ? 0xff0000 : 0xffff00,
@@ -208,7 +239,7 @@
                 bullet.position.copy(camera.position);
                 const direction = new THREE.Vector3();
                 camera.getWorldDirection(direction);
-                bullet.velocity = direction.multiplyScalar(2);
                 sounds.gunshot.currentTime = 0;
                 sounds.gunshot.play();
             }
@@ -217,197 +248,149 @@
             return bullet;
         }
-        // 발사
-        function shoot() {
-            if (ammo <= 0) return;
-            ammo--;
-            updateAmmoDisplay();
-            const bullet = createBullet();
-            bullets.push(bullet);
-        }
-        // 적 발사
-        function enemyShoot(enemy) {
-            if (Math.random() > getFireRate()) return;
-            const bullet = createBullet(true);
-            bullet.position.copy(enemy.model.position);
-            const direction = new THREE.Vector3();
-            direction.subVectors(camera.position, enemy.model.position);
-            direction.normalize();
-            bullet.velocity = direction.multiplyScalar(1.5);
-            enemyBullets.push(bullet);
-        }
-        // 스테이지별 발사 확률
-        function getFireRate() {
-            const baseRate = 0.01;
-            return baseRate * (1 + (currentStage - 1) * 0.5);
-        }
-        // 총알 업데이트
-        function updateBullets() {
-            // 플레이어 총알
-            for (let i = bullets.length - 1; i >= 0; i--) {
-                bullets[i].position.add(bullets[i].velocity);
-                // 적과의 충돌 체크
-                enemies.forEach(enemy => {
-                    if (bullets[i].position.distanceTo(enemy.model.position) < 4) {
-                        scene.remove(bullets[i]);
-                        bullets.splice(i, 1);
-                        enemy.health -= 25;
-                        if (enemy.health <= 0) {
-                            scene.remove(enemy.model);
-                            enemies = enemies.filter(e => e !== enemy);
-                            checkStageCompletion();
-                        }
-                        return;
-                    }
-                });
-                // 수명 제한
-                if (bullets[i] && bullets[i].position.distanceTo(camera.position) > 200) {
-                    scene.remove(bullets[i]);
-                    bullets.splice(i, 1);
-                }
-            }
-            // 적 총알
-            for (let i = enemyBullets.length - 1; i >= 0; i--) {
-                enemyBullets[i].position.add(enemyBullets[i].velocity);
-                // 플레이어와의 충돌 체크
-                if (enemyBullets[i].position.distanceTo(camera.position) < 3) {
-                    scene.remove(enemyBullets[i]);
-                    enemyBullets.splice(i, 1);
-                    playerHealth -= 20;
-                    updateHealthBar();
-                    if (playerHealth <= 0) {
-                        gameOver(false);
-                    }
-                    continue;
-                }
-                // 수명 제한
-                if (enemyBullets[i] && enemyBullets[i].position.distanceTo(camera.position) > 200) {
-                    scene.remove(enemyBullets[i]);
-                    enemyBullets.splice(i, 1);
-                }
-            }
-        }
-        // 스테이지 완료 체크
-        function checkStageCompletion() {
-            if (enemies.length === 0 && currentStage < MAX_STAGES) {
-                currentStage++;
-                showStageMessage();
-                loadEnemies();
             }
-        }
-        // 스테이지 메시지 표시
-        function showStageMessage() {
-            const stageDiv = document.getElementById('stage');
-            stageDiv.textContent = `Stage ${currentStage}`;
-            stageDiv.style.display = 'block';
-            setTimeout(() => {
-                stageDiv.style.display = 'none';
-            }, 3000);
-        }
-        // UI 업데이트
-        function updateHealthBar() {
-            const healthBar = document.getElementById('health');
-            healthBar.style.width = `${(playerHealth / MAX_HEALTH) * 100}%`;
-        }
-        function updateAmmoDisplay() {
-            document.getElementById('ammo').textContent = `Ammo: ${ammo}/${maxAmmo}`;
         }
-        function updateGameTimer() {
-            if (!gameStartTime) return;
-            const elapsed = Math.floor((Date.now() - gameStartTime) / 1000);
-            const remaining = GAME_DURATION - elapsed;
-            if (remaining <= 0) {
-                gameOver(true);
-                return;
             }
-            const minutes = Math.floor(remaining / 60);
-            const seconds = remaining % 60;
-            document.getElementById('gameTimer').textContent =
-                `Time: ${minutes}:${seconds.toString().padStart(2, '0')}`;
-        }
-        // 재장전
-        function reload() {
-            ammo = maxAmmo;
-            updateAmmoDisplay();
         }
-        // 지형 생성
-        function createTerrain() {
-            const geometry = new THREE.PlaneGeometry(500, 500, 100, 100);
-            const material = new THREE.MeshStandardMaterial({
-                color: 0x3a8c3a,
-                roughness: 0.6,
-                metalness: 0.1
             });
-            const vertices = geometry.attributes.position.array;
-            for (let i = 0; i < vertices.length; i += 3) {
-                vertices[i + 2] = Math.cos(vertices[i] * 0.02) * Math.sin(vertices[i + 1] * 0.02) * 5;
-            }
-            geometry.attributes.position.needsUpdate = true;
-            geometry.computeVertexNormals();
-            const terrain = new THREE.Mesh(geometry, material);
-            terrain.rotation.x = -Math.PI / 2;
-            terrain.receiveShadow = true;
-            scene.add(terrain);
         }
         // 적 로드
         function loadEnemies() {
             const loader = new GLTFLoader();
             const enemiesCount = 3 + currentStage;
             for (let i = 0; i < enemiesCount; i++) {
                 const modelPath = ENEMY_MODELS[i % ENEMY_MODELS.length];
                 loader.load(modelPath, (gltf) => {
                     const enemy = gltf.scene;
                     enemy.scale.set(ENEMY_SCALE, ENEMY_SCALE, ENEMY_SCALE);
-                    const angle = (i / enemiesCount) * Math.PI * 2;
-                    const radius = 100;
-                    enemy.position.set(
-                        Math.cos(angle) * radius,
-                        5,
-                        Math.sin(angle) * radius
-                    );
                     enemy.traverse((node) => {
                         if (node.isMesh) {
                             node.material = node.material.clone();
                             node.material.metalness = 0.3;
                             node.material.roughness = 0.5;
                             node.castShadow = true;
-                            node
-node.material.emissive = new THREE.Color(0x444444);
-                            node.material.emissiveIntensity = 0.2;
                         }
                     });
@@ -415,116 +398,93 @@ node.material.emissive = new THREE.Color(0x444444);
                     enemies.push({
                         model: enemy,
                         health: 100,
-                        speed: 0.2 + (currentStage * 0.05),
                         velocity: new THREE.Vector3(),
                         lastShot: 0,
-                        moveTarget: new THREE.Vector3()
                     });
                     updateMoveTarget(enemies[enemies.length - 1]);
                 });
             }
         }
         // 적의 새로운 이동 목표점 설정
         function updateMoveTarget(enemy) {
             enemy.moveTarget.set(
-                (Math.random() - 0.5) * 400,
-                5,
-                (Math.random() - 0.5) * 400
             );
         }
-        // 컨트롤 초기화
-        function initControls() {
-            controls = new PointerLockControls(camera, document.body);
-            const moveState = {
-                forward: false,
-                backward: false,
-                left: false,
-                right: false
-            };
-            document.addEventListener('keydown', (event) => {
-                switch(event.code) {
-                    case 'KeyW': moveState.forward = true; break;
-                    case 'KeyS': moveState.backward = true; break;
-                    case 'KeyA': moveState.left = true; break;
-                    case 'KeyD': moveState.right = true; break;
-                    case 'KeyR': reload(); break;
-                }
-            });
-            document.addEventListener('keyup', (event) => {
-                switch(event.code) {
-                    case 'KeyW': moveState.forward = false; break;
-                    case 'KeyS': moveState.backward = false; break;
-                    case 'KeyA': moveState.left = false; break;
-                    case 'KeyD': moveState.right = false; break;
-                }
-            });
-            document.addEventListener('click', () => {
-                if (controls.isLocked) {
-                    shoot();
-                } else {
-                    controls.lock();
-                    if (!gameStartTime) {
-                        gameStartTime = Date.now();
-                        sounds.bgm.play();
-                    }
-                }
-            });
-            controls.addEventListener('lock', () => {
-                document.getElementById('info').style.display = 'none';
-            });
-            controls.addEventListener('unlock', () => {
-                document.getElementById('info').style.display = 'block';
-            });
-            return moveState;
-        }
         // 적 업데이트
         function updateEnemies() {
             if (!isSafePeriod) {
                 enemies.forEach(enemy => {
-                    // 목표점까지의 방향 계산
                     const toTarget = new THREE.Vector3();
                     toTarget.subVectors(enemy.moveTarget, enemy.model.position);
-                    // 목표점에 거의 도달했으면 새 목표점 설정
-                    if (toTarget.length() < 5) {
                         updateMoveTarget(enemy);
                     }
-                    // 이동 방향 결정 (목표점 80%, 플레이어 방향 20%)
                     const toPlayer = new THREE.Vector3();
                     toPlayer.subVectors(camera.position, enemy.model.position);
                     const direction = new THREE.Vector3();
-                    direction.addScaledVector(toTarget.normalize(), 0.8);
-                    direction.addScaledVector(toPlayer.normalize(), 0.2);
                     direction.normalize();
-                    // 속도 적용
-                    enemy.velocity.lerp(direction.multiplyScalar(enemy.speed), 0.02);
                     enemy.model.position.add(enemy.velocity);
-                    // 회전
                     enemy.model.lookAt(camera.position);
                     // 발사 로직
                     const now = Date.now();
-                    const fireInterval = 2000 - (currentStage * 200); // 스테이지가 올라갈수록 발사 간격 감소
                     if (now - enemy.lastShot > fireInterval) {
                         enemyShoot(enemy);
                         enemy.lastShot = now;
                     }
                 });
             }
         }
@@ -535,57 +495,14 @@ node.material.emissive = new THREE.Color(0x444444);
                 controls.unlock();
                 sounds.bgm.pause();
                 setTimeout(() => {
-                    alert(won ? 'Mission Accomplished! You survived!' : 'Game Over! You were eliminated!');
                     location.reload();
                 }, 100);
             }
         }
-        // 게임 초기화
-        function init() {
-            initScene();
-            createTerrain();
-            loadEnemies();
-            const moveState = initControls();
-            showStageMessage();
-            // 게임 루프
-            function animate() {
-                requestAnimationFrame(animate);
-                if (controls.isLocked && !isGameOver) {
-                    // 이동 처리
-                    const speed = 0.5;
-                    if (moveState.forward) controls.moveForward(speed);
-                    if (moveState.backward) controls.moveForward(-speed);
-                    if (moveState.left) controls.moveRight(-speed);
-                    if (moveState.right) controls.moveRight(speed);
-                    // 총알 업데이트
-                    updateBullets();
-                    // 적 업데이트
-                    updateEnemies();
-                    // 게임 타이머 업데이트
-                    updateGameTimer();
-                }
-                renderer.render(scene, camera);
-            }
-            // 화면 크기 조절 처리
-            window.addEventListener('resize', () => {
-                camera.aspect = window.innerWidth / window.innerHeight;
-                camera.updateProjectionMatrix();
-                renderer.setSize(window.innerWidth, window.innerHeight);
-            });
-            animate();
-        }
-        // 게임 시작
         init();
     </script>
 </body>
-</html>

 <!DOCTYPE html>
 <html>
 <head>
+    <title>Desert Combat Game</title>
     <meta charset="utf-8">
     <style>
         body {
             z-index: 100;
             border-radius: 5px;
         }
+        #debug {
+            position: absolute;
+            bottom: 60px;
+            left: 20px;
+            color: white;
+            font-family: Arial;
+            font-size: 12px;
+            z-index: 100;
+        }
     </style>
 </head>
 <body>
     <div id="healthBar"><div id="health"></div></div>
     <div id="ammo">Ammo: 30/30</div>
     <div id="stage">Stage 1</div>
+    <div id="debug"></div>
     <script async src="https://unpkg.com/es-module-shims@1.6.3/dist/es-module-shims.js"></script>
         const GAME_DURATION = 180; // 3분
         const MAX_STAGES = 5;
         const ENEMY_MODELS = ['1.GLB', '2.GLB', '3.GLB', '4.GLB'];
+        const HELICOPTER_HEIGHT = 50; // 증가된 헬기 높이
+        const ENEMY_SCALE = 3; // 증가된 적 크기
+        const MAX_HEALTH = 1000;
+        const MAP_SIZE = 2000; // 증가된 맵 크기
         // 게임 변수
         let scene, camera, renderer, controls;
         // Scene 초기화
         function initScene() {
             scene = new THREE.Scene();
+            scene.background = new THREE.Color(0xffd700); // 사막 하늘색
+            scene.fog = new THREE.Fog(0xffd700, 0, 1500);
+            camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 3000);
             camera.position.set(0, HELICOPTER_HEIGHT, 0);
             renderer = new THREE.WebGLRenderer({ antialias: true });
             document.body.appendChild(renderer.domElement);
             // 조명
+            const ambientLight = new THREE.AmbientLight(0xffffff, 1.5);
             scene.add(ambientLight);
+            const dirLight = new THREE.DirectionalLight(0xffffff, 2);
+            dirLight.position.set(100, 100, 50);
             dirLight.castShadow = true;
             dirLight.shadow.mapSize.width = 4096;
             dirLight.shadow.mapSize.height = 4096;
+            dirLight.shadow.camera.far = 1000;
+            dirLight.shadow.camera.left = -500;
+            dirLight.shadow.camera.right = 500;
+            dirLight.shadow.camera.top = 500;
+            dirLight.shadow.camera.bottom = -500;
             scene.add(dirLight);
+            // 사막 햇빛 효과
+            const sunLight = new THREE.DirectionalLight(0xfdb813, 1);
+            sunLight.position.set(-100, 200, -100);
+            scene.add(sunLight);
+        }
+        // 디버그 정보 업데이트
+        function updateDebugInfo() {
+            const debugDiv = document.getElementById('debug');
+            debugDiv.innerHTML = `
+                Enemies: ${enemies.length}<br>
+                Stage: ${currentStage}<br>
+                Enemy Positions:<br>
+                ${enemies.map((e, i) =>
+                    `Enemy ${i}: x=${e.model.position.x.toFixed(1)},
+                     y=${e.model.position.y.toFixed(1)},
+                     z=${e.model.position.z.toFixed(1)}`
+                ).join('<br>')}
+            `;
         }
         // 총알 생성
         function createBullet(isEnemy = false) {
+            const bulletGeometry = new THREE.SphereGeometry(0.5, 8, 8);
             const bulletMaterial = new THREE.MeshBasicMaterial({
                 color: isEnemy ? 0xff0000 : 0xffff00,
                 emissive: isEnemy ? 0xff0000 : 0xffff00,
                 bullet.position.copy(camera.position);
                 const direction = new THREE.Vector3();
                 camera.getWorldDirection(direction);
+                bullet.velocity = direction.multiplyScalar(3);
                 sounds.gunshot.currentTime = 0;
                 sounds.gunshot.play();
             }
             return bullet;
         }
+// 사막 지형 생성
+        function createTerrain() {
+            // 사막 텍스처 생성
+            const textureLoader = new THREE.TextureLoader();
+            const sandTexture = textureLoader.load('https://threejs.org/examples/textures/terrain/grasslight-big.jpg');
+            sandTexture.wrapS = sandTexture.wrapT = THREE.RepeatWrapping;
+            sandTexture.repeat.set(25, 25);
+            const geometry = new THREE.PlaneGeometry(MAP_SIZE, MAP_SIZE, 200, 200);
+            const material = new THREE.MeshStandardMaterial({
+                color: 0xd2b48c,
+                map: sandTexture,
+                roughness: 0.8,
+                metalness: 0.2,
+                bumpScale: 0.5,
+            });
+            // 모래 언덕 생성
+            const vertices = geometry.attributes.position.array;
+            for (let i = 0; i < vertices.length; i += 3) {
+                const x = vertices[i];
+                const y = vertices[i + 1];
+                vertices[i + 2] = Math.sin(x * 0.01) * Math.cos(y * 0.01) * 20 +
+                                Math.random() * 5 +
+                                Math.sin(x * 0.02 + y * 0.02) * 10;
             }
+            geometry.attributes.position.needsUpdate = true;
+            geometry.computeVertexNormals();
+            const terrain = new THREE.Mesh(geometry, material);
+            terrain.rotation.x = -Math.PI / 2;
+            terrain.receiveShadow = true;
+            scene.add(terrain);
+            // 사막 바위 추가
+            addDesertRocks();
+            // 선인장 추가
+            addCacti();
         }
+        // 사막 바위 추가
+        function addDesertRocks() {
+            const rockGeometry = new THREE.DodecahedronGeometry(10);
+            const rockMaterial = new THREE.MeshStandardMaterial({
+                color: 0x8b4513,
+                roughness: 0.8,
+                metalness: 0.2
+            });
+            for (let i = 0; i < 50; i++) {
+                const rock = new THREE.Mesh(rockGeometry, rockMaterial);
+                rock.position.set(
+                    (Math.random() - 0.5) * MAP_SIZE * 0.9,
+                    Math.random() * 10 + 5,
+                    (Math.random() - 0.5) * MAP_SIZE * 0.9
+                );
+                rock.rotation.set(
+                    Math.random() * Math.PI,
+                    Math.random() * Math.PI,
+                    Math.random() * Math.PI
+                );
+                rock.scale.set(
+                    Math.random() * 2 + 1,
+                    Math.random() * 2 + 1,
+                    Math.random() * 2 + 1
+                );
+                rock.castShadow = true;
+                rock.receiveShadow = true;
+                scene.add(rock);
             }
         }
+        // 선인장 추가
+        function addCacti() {
+            const trunkGeometry = new THREE.CylinderGeometry(2, 2, 15, 8);
+            const armGeometry = new THREE.CylinderGeometry(1.5, 1.5, 10, 8);
+            const cactusMaterial = new THREE.MeshStandardMaterial({
+                color: 0x2f4f2f,
+                roughness: 0.8
             });
+            for (let i = 0; i < 100; i++) {
+                const cactusGroup = new THREE.Group();
+                // 몸통
+                const trunk = new THREE.Mesh(trunkGeometry, cactusMaterial);
+                cactusGroup.add(trunk);
+                // 팔 추가
+                const armsCount = Math.floor(Math.random() * 3) + 1;
+                for (let j = 0; j < armsCount; j++) {
+                    const arm = new THREE.Mesh(armGeometry, cactusMaterial);
+                    arm.position.y = Math.random() * 5;
+                    arm.rotation.z = Math.PI / 2 * (Math.random() > 0.5 ? 1 : -1);
+                    arm.position.x = (Math.random() > 0.5 ? 1 : -1) * 3;
+                    cactusGroup.add(arm);
+                }
+                cactusGroup.position.set(
+                    (Math.random() - 0.5) * MAP_SIZE * 0.9,
+                    7.5,
+                    (Math.random() - 0.5) * MAP_SIZE * 0.9
+                );
+                cactusGroup.castShadow = true;
+                cactusGroup.receiveShadow = true;
+                scene.add(cactusGroup);
+            }
         }
         // 적 로드
         function loadEnemies() {
+            console.log('Loading enemies...');
             const loader = new GLTFLoader();
             const enemiesCount = 3 + currentStage;
             for (let i = 0; i < enemiesCount; i++) {
                 const modelPath = ENEMY_MODELS[i % ENEMY_MODELS.length];
+                console.log(`Loading enemy model: ${modelPath}`);
                 loader.load(modelPath, (gltf) => {
                     const enemy = gltf.scene;
                     enemy.scale.set(ENEMY_SCALE, ENEMY_SCALE, ENEMY_SCALE);
+                    // 랜덤 위치에 스폰하되, 플레이어로부터 최소 거리 유지
+                    let position = getRandomSpawnPosition();
+                    while (position.distanceTo(camera.position) < 100) {
+                        position = getRandomSpawnPosition();
+                    }
+                    enemy.position.copy(position);
+                    // 밝기 개선을 위한 재질 설정
                     enemy.traverse((node) => {
                         if (node.isMesh) {
                             node.material = node.material.clone();
                             node.material.metalness = 0.3;
                             node.material.roughness = 0.5;
+                            node.material.emissive = new THREE.Color(0x666666);
+                            node.material.emissiveIntensity = 0.3;
                             node.castShadow = true;
+                            node.receiveShadow = true;
                         }
                     });
                     enemies.push({
                         model: enemy,
                         health: 100,
+                        speed: 0.3 + (currentStage * 0.05),
                         velocity: new THREE.Vector3(),
                         lastShot: 0,
+                        moveTarget: new THREE.Vector3(),
+                        type: modelPath
                     });
+                    console.log(`Enemy loaded: ${modelPath}, Position:`, position);
+                    updateDebugInfo();
                     updateMoveTarget(enemies[enemies.length - 1]);
+                },
+                (xhr) => {
+                    console.log(`${modelPath}: ${(xhr.loaded / xhr.total) * 100}% loaded`);
+                },
+                (error) => {
+                    console.error(`Error loading ${modelPath}:`, error);
                 });
             }
         }
+        // 랜덤 스폰 위치 생성
+        function getRandomSpawnPosition() {
+            const angle = Math.random() * Math.PI * 2;
+            const radius = Math.random() * (MAP_SIZE * 0.4) + 100;
+            return new THREE.Vector3(
+                Math.cos(angle) * radius,
+                10,
+                Math.sin(angle) * radius
+            );
+        }
         // 적의 새로운 이동 목표점 설정
         function updateMoveTarget(enemy) {
+            const angle = Math.random() * Math.PI * 2;
+            const radius = Math.random() * (MAP_SIZE * 0.4);
             enemy.moveTarget.set(
+                Math.cos(angle) * radius,
+                10,
+                Math.sin(angle) * radius
             );
         }
         // 적 업데이트
         function updateEnemies() {
             if (!isSafePeriod) {
                 enemies.forEach(enemy => {
+                    // AI 이동 로직
                     const toTarget = new THREE.Vector3();
                     toTarget.subVectors(enemy.moveTarget, enemy.model.position);
+                    if (toTarget.length() < 10) {
                         updateMoveTarget(enemy);
                     }
+                    // 플레이어 방향 가중치 계산
                     const toPlayer = new THREE.Vector3();
                     toPlayer.subVectors(camera.position, enemy.model.position);
+                    const distanceToPlayer = toPlayer.length();
+                    // 거리에 따른 가중치 조정
+                    const playerWeight = Math.min(1, 100 / distanceToPlayer);
                     const direction = new THREE.Vector3();
+                    direction.addScaledVector(toTarget.normalize(), 1 - playerWeight);
+                    direction.addScaledVector(toPlayer.normalize(), playerWeight);
                     direction.normalize();
+                    // 속도 및 위치 업데이트
+                    enemy.velocity.lerp(direction.multiplyScalar(enemy.speed), 0.05);
                     enemy.model.position.add(enemy.velocity);
+                    // 적 회전
                     enemy.model.lookAt(camera.position);
                     // 발사 로직
                     const now = Date.now();
+                    const baseInterval = 3000 - (currentStage * 300); // 기본 발사 간격
+                    const distanceModifier = Math.max(0.5, Math.min(1.5, distanceToPlayer / 100));
+                    const fireInterval = baseInterval * distanceModifier;
                     if (now - enemy.lastShot > fireInterval) {
                         enemyShoot(enemy);
                         enemy.lastShot = now;
                     }
                 });
+                updateDebugInfo();
             }
         }
                 controls.unlock();
                 sounds.bgm.pause();
                 setTimeout(() => {
+                    alert(won ? 'Mission Accomplished! You survived in the desert!' : 'Game Over! You were eliminated!');
                     location.reload();
                 }, 100);
             }
         }
+        // 게임 초기화 및 시작
         init();
     </script>
 </body>
+</html>