Update game.js

game.js

@@ -5,7 +5,7 @@ import { PointerLockControls } from 'three/addons/controls/PointerLockControls.j
 // 게임 상수
 const GAME_DURATION = 180;
 const MAP_SIZE = 2000;
-const TANK_HEIGHT = 2.0;  // 전차 높이로 변경
+const TANK_HEIGHT = 0.5;  // 포탑 높이 조정
 const ENEMY_GROUND_HEIGHT = 0;
 const ENEMY_SCALE = 10;
 const MAX_HEALTH = 1000;
@@ -22,13 +22,14 @@ const ENEMY_CONFIG = {
 // TankPlayer 클래스 정의
 class TankPlayer {
     constructor() {
-        this.body = null;     // 전차 몸체
-        this.turret = null;   // 전차 포탑
+        this.body = null;
+        this.turret = null;
         this.position = new THREE.Vector3(0, 0, 0);
         this.rotation = new THREE.Euler(0, 0, 0);
         this.turretRotation = 0;
         this.moveSpeed = 0.5;
         this.turnSpeed = 0.03;
+        this.turretGroup = new THREE.Group(); // 포탑 그룹 추가
     }
 
     async initialize(scene, loader) {
@@ -42,8 +43,10 @@ class TankPlayer {
             const turretResult = await loader.loadAsync('/models/abramsTurret.glb');
             this.turret = turretResult.scene;
             
-            // 포탑 위치 조정 (몸체 위에 올림)
-            this.turret.position.y = TANK_HEIGHT;
+            // 포탑 그룹 설정
+            this.turretGroup.position.y = TANK_HEIGHT;
+            this.turretGroup.add(this.turret);
+            this.body.add(this.turretGroup);
             
             // 그림자 설정
             this.body.traverse((child) => {
@@ -60,8 +63,6 @@ class TankPlayer {
                 }
             });
 
-            // 씬에 추가
-            this.body.add(this.turret);
             scene.add(this.body);
             
         } catch (error) {
@@ -70,16 +71,15 @@ class TankPlayer {
     }
 
     update(mouseX, mouseY) {
-        if (!this.body || !this.turret) return;
+        if (!this.body || !this.turretGroup) return;
         
         // 마우스 위치를 이용한 포탑 회전 계산
-        const mousePosition = new THREE.Vector2(mouseX, mouseY);
-        const targetAngle = Math.atan2(mousePosition.x, mousePosition.y);
+        const targetAngle = Math.atan2(mouseX, mouseY);
         
         // 포탑 부드러운 회전
-        const currentRotation = this.turret.rotation.y;
+        const currentRotation = this.turretGroup.rotation.y;
         const rotationDiff = targetAngle - currentRotation;
-        this.turret.rotation.y += rotationDiff * 0.1;
+        this.turretGroup.rotation.y += rotationDiff * 0.1;
     }
 
     move(direction) {
@@ -98,731 +98,479 @@ class TankPlayer {
         this.body.rotation.y += angle * this.turnSpeed;
     }
 }
-
-// 게임 변수
-let scene, camera, renderer, controls;
-let player; // 전차 플레이어 인스턴스
-let enemies = [];
-let bullets = [];
-let enemyBullets = [];
-let playerHealth = MAX_HEALTH;
-let ammo = 30;
-let currentStage = 1;
-let isGameOver = false;
-let lastTime = performance.now();
-let lastRender = 0;
-// 오실레이터 기반 총소리 생성기
-class GunSoundGenerator {
+// TankPlayer 클래스 수정
+class TankPlayer {
     constructor() {
-        this.audioContext = new (window.AudioContext || window.webkitAudioContext)();
+        this.body = null;
+        this.turret = null;
+        this.position = new THREE.Vector3(0, 0, 0);
+        this.rotation = new THREE.Euler(0, 0, 0);
+        this.turretRotation = 0;
+        this.moveSpeed = 0.5;
+        this.turnSpeed = 0.03;
+        this.turretGroup = new THREE.Group();
+        this.health = MAX_HEALTH;
     }
 
-    createGunshot() {
-        const currentTime = this.audioContext.currentTime;
-        
-        // 메인 오실레이터
-        const osc = this.audioContext.createOscillator();
-        const gainNode = this.audioContext.createGain();
-        
-        osc.type = 'square';
-        osc.frequency.setValueAtTime(200, currentTime);
-        osc.frequency.exponentialRampToValueAtTime(50, currentTime + 0.1);
-        
-        gainNode.gain.setValueAtTime(0.5, currentTime);
-        gainNode.gain.exponentialRampToValueAtTime(0.01, currentTime + 0.1);
-        
-        osc.connect(gainNode);
-        gainNode.connect(this.audioContext.destination);
-        
-        osc.start(currentTime);
-        osc.stop(currentTime + 0.1);
+    async initialize(scene, loader) {
+        try {
+            const bodyResult = await loader.loadAsync('/models/abramsBody.glb');
+            this.body = bodyResult.scene;
+            this.body.position.copy(this.position);
+            
+            const turretResult = await loader.loadAsync('/models/abramsTurret.glb');
+            this.turret = turretResult.scene;
+            
+            // 포탑 위치 조정
+            this.turretGroup.position.y = 0.2; // 포탑 높이 조정
+            this.turretGroup.add(this.turret);
+            this.body.add(this.turretGroup);
+            
+            this.body.traverse((child) => {
+                if (child.isMesh) {
+                    child.castShadow = true;
+                    child.receiveShadow = true;
+                }
+            });
+            
+            this.turret.traverse((child) => {
+                if (child.isMesh) {
+                    child.castShadow = true;
+                    child.receiveShadow = true;
+                }
+            });
 
-        // 노이즈 추가
-        const bufferSize = this.audioContext.sampleRate * 0.1;
-        const buffer = this.audioContext.createBuffer(1, bufferSize, this.audioContext.sampleRate);
-        const data = buffer.getChannelData(0);
-        
-        for (let i = 0; i < bufferSize; i++) {
-            data[i] = Math.random() * 2 - 1;
+            scene.add(this.body);
+            
+        } catch (error) {
+            console.error('Error loading tank models:', error);
         }
+    }
+
+    update(mouseX, mouseY) {
+        if (!this.body || !this.turretGroup) return;
         
-        const noise = this.audioContext.createBufferSource();
-        const noiseGain = this.audioContext.createGain();
-        
-        noise.buffer = buffer;
-        noiseGain.gain.setValueAtTime(0.2, currentTime);
-        noiseGain.gain.exponentialRampToValueAtTime(0.01, currentTime + 0.05);
+        const targetAngle = Math.atan2(mouseX, mouseY);
+        const currentRotation = this.turretGroup.rotation.y;
+        const rotationDiff = targetAngle - currentRotation;
         
-        noise.connect(noiseGain);
-        noiseGain.connect(this.audioContext.destination);
+        // 포탑 회전 각도 정규화
+        let normalizedDiff = rotationDiff;
+        while (normalizedDiff > Math.PI) normalizedDiff -= Math.PI * 2;
+        while (normalizedDiff < -Math.PI) normalizedDiff += Math.PI * 2;
         
-        noise.start(currentTime);
-    }
-
-    resume() {
-        if (this.audioContext.state === 'suspended') {
-            this.audioContext.resume();
-        }
+        this.turretGroup.rotation.y += normalizedDiff * 0.1;
     }
-}
-
-// 사운드 시스템 초기화
-const gunSound = new GunSoundGenerator();
-
-async function init() {
-    document.getElementById('loading').style.display = 'block';
-    
-    try {
-        // Scene 초기화
-        scene = new THREE.Scene();
-        scene.background = new THREE.Color(0x87ceeb);
-        scene.fog = new THREE.Fog(0x87ceeb, 0, 1000);
-
-        // Renderer 최적화
-        renderer = new THREE.WebGLRenderer({ 
-            antialias: false,
-            powerPreference: "high-performance"
-        });
-        renderer.setSize(window.innerWidth, window.innerHeight);
-        renderer.shadowMap.enabled = true;
-        renderer.shadowMap.type = THREE.BasicShadowMap;
-        document.body.appendChild(renderer.domElement);
-
-        // Camera 설정
-        camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
-        camera.position.set(0, TANK_HEIGHT + 5, -10); // 카메라 위치 전차에 맞게 조정
 
-        // 기본 조명
-        scene.add(new THREE.AmbientLight(0xffffff, 0.6));
+    move(direction) {
+        if (!this.body) return;
         
-        const dirLight = new THREE.DirectionalLight(0xffffff, 0.8);
-        dirLight.position.set(100, 100, 50);
-        dirLight.castShadow = true;
-        dirLight.shadow.mapSize.width = 1024;
-        dirLight.shadow.mapSize.height = 1024;
-        scene.add(dirLight);
-
-        // Controls 설정
-        controls = new PointerLockControls(camera, document.body);
-
-        // 이벤트 리스너
-        setupEventListeners();
-
-        // 플레이어 초기화
-        player = new TankPlayer();
-        await player.initialize(scene, new GLTFLoader());
-
-        // 게임 요소 초기화
-        await Promise.all([
-            createTerrain(),
-            createEnemies()
-        ]);
-
-        document.getElementById('loading').style.display = 'none';
-        console.log('Game initialized successfully');
-    } catch (error) {
-        console.error('Initialization error:', error);
-        document.getElementById('loading').innerHTML = `
-            <div class="loading-text" style="color: #ff0000;">
-                Error loading models. Please check console and file paths.
-            </div>
-        `;
-        throw error;
+        const moveVector = new THREE.Vector3();
+        moveVector.x = direction.x * this.moveSpeed;
+        moveVector.z = direction.z * this.moveSpeed;
+        
+        moveVector.applyEuler(this.body.rotation);
+        this.body.position.add(moveVector);
     }
-}
 
-function setupEventListeners() {
-    document.addEventListener('click', onClick);
-    document.addEventListener('keydown', onKeyDown);
-    document.addEventListener('keyup', onKeyUp);
-    document.addEventListener('mousemove', onMouseMove);
-    window.addEventListener('resize', onWindowResize);
-}
+    rotate(angle) {
+        if (!this.body) return;
+        this.body.rotation.y += angle * this.turnSpeed;
+    }
 
-// 마우스 이동 이벤트 핸들러 추가
-function onMouseMove(event) {
-    if (controls.isLocked && player) {
-        const mouseX = (event.clientX / window.innerWidth) * 2 - 1;
-        const mouseY = -(event.clientY / window.innerHeight) * 2 + 1;
-        player.update(mouseX, mouseY);
+    getPosition() {
+        return this.body ? this.body.position : new THREE.Vector3();
     }
-}
-async function testModelLoading() {
-    const loader = new GLTFLoader();
-    try {
-        const modelPath = 'models/enemy1.glb';
-        console.log('Testing model loading:', modelPath);
-        const gltf = await loader.loadAsync(modelPath);
-        console.log('Test model loaded successfully:', gltf);
-    } catch (error) {
-        console.error('Test model loading failed:', error);
-        throw error;
+
+    takeDamage(damage) {
+        this.health -= damage;
+        return this.health <= 0;
     }
 }
 
-function createTerrain() {
-    return new Promise((resolve) => {
-        const geometry = new THREE.PlaneGeometry(MAP_SIZE, MAP_SIZE, 100, 100);
-        const material = new THREE.MeshStandardMaterial({
-            color: 0xD2B48C,
-            roughness: 0.8,
-            metalness: 0.2
-        });
+// Enemy 클래스 정의
+class Enemy {
+    constructor(scene, position) {
+        this.scene = scene;
+        this.position = position;
+        this.mesh = null;
+        this.health = 100;
+        this.lastAttackTime = 0;
+        this.bullets = [];
+    }
 
-        const vertices = geometry.attributes.position.array;
-        for (let i = 0; i < vertices.length; i += 3) {
-            vertices[i + 2] = Math.sin(vertices[i] * 0.01) * Math.cos(vertices[i + 1] * 0.01) * 20;
+    async initialize(loader) {
+        try {
+            const result = await loader.loadAsync('/models/enemy.glb');
+            this.mesh = result.scene;
+            this.mesh.position.copy(this.position);
+            this.mesh.scale.set(ENEMY_SCALE, ENEMY_SCALE, ENEMY_SCALE);
+            
+            this.mesh.traverse((child) => {
+                if (child.isMesh) {
+                    child.castShadow = true;
+                    child.receiveShadow = true;
+                }
+            });
+            
+            this.scene.add(this.mesh);
+        } catch (error) {
+            console.error('Error loading enemy model:', error);
         }
+    }
 
-        geometry.attributes.position.needsUpdate = true;
-        geometry.computeVertexNormals();
+    update(playerPosition) {
+        if (!this.mesh) return;
 
-        const terrain = new THREE.Mesh(geometry, material);
-        terrain.rotation.x = -Math.PI / 2;
-        terrain.receiveShadow = true;
-        scene.add(terrain);
+        // 플레이어 방향으로 회전
+        const direction = new THREE.Vector3()
+            .subVectors(playerPosition, this.mesh.position)
+            .normalize();
+        
+        this.mesh.lookAt(playerPosition);
 
-        addObstacles();
-        resolve();
-    });
-}
+        // 플레이어 방향으로 이동
+        this.mesh.position.add(direction.multiplyScalar(ENEMY_MOVE_SPEED));
 
-function addObstacles() {
-    const rockGeometry = new THREE.DodecahedronGeometry(10);
-    const rockMaterial = new THREE.MeshStandardMaterial({
-        color: 0x8B4513,
-        roughness: 0.9
-    });
-
-    for (let i = 0; i < OBSTACLE_COUNT; i++) {
-        const rock = new THREE.Mesh(rockGeometry, rockMaterial);
-        rock.position.set(
-            (Math.random() - 0.5) * MAP_SIZE * 0.9,
-            Math.random() * 10,
-            (Math.random() - 0.5) * MAP_SIZE * 0.9
-        );
-        rock.rotation.set(
-            Math.random() * Math.PI,
-            Math.random() * Math.PI,
-            Math.random() * Math.PI
-        );
-        rock.castShadow = true;
-        rock.receiveShadow = true;
-        scene.add(rock);
-    }
-}
+        // 총알 업데이트
+        for (let i = this.bullets.length - 1; i >= 0; i--) {
+            const bullet = this.bullets[i];
+            bullet.position.add(bullet.velocity);
 
-async function createEnemies() {
-    console.log('Creating enemies...');
-    const loader = new GLTFLoader();
-    const enemyCount = Math.min(3 + currentStage, ENEMY_COUNT_MAX);
-    
-    for (let i = 0; i < enemyCount; i++) {
-        const angle = (i / enemyCount) * Math.PI * 2;
-        const radius = 200;
-        const position = new THREE.Vector3(
-            Math.cos(angle) * radius,
-            ENEMY_GROUND_HEIGHT,
-            Math.sin(angle) * radius
-        );
+            // 총알이 맵 밖으로 나가면 제거
+            if (Math.abs(bullet.position.x) > MAP_SIZE || 
+                Math.abs(bullet.position.z) > MAP_SIZE) {
+                this.scene.remove(bullet);
+                this.bullets.splice(i, 1);
+            }
+        }
+    }
 
-        // 임시 적 생성
-        const tempEnemy = createTemporaryEnemy(position);
-        scene.add(tempEnemy.model);
-        enemies.push(tempEnemy);
+    shoot(playerPosition) {
+        const currentTime = Date.now();
+        if (currentTime - this.lastAttackTime < ENEMY_CONFIG.ATTACK_INTERVAL) return;
 
-        try {
-            const modelIndex = i % 4 + 1;
-            const modelPath = `models/enemy${modelIndex}.glb`;
-            console.log(`Loading model: ${modelPath}`);
+        const bulletGeometry = new THREE.SphereGeometry(0.2);
+        const bulletMaterial = new THREE.MeshBasicMaterial({ color: 0xff0000 });
+        const bullet = new THREE.Mesh(bulletGeometry, bulletMaterial);
 
-            const gltf = await loader.loadAsync(modelPath);
-            const model = gltf.scene;
-            
-            model.scale.set(ENEMY_SCALE, ENEMY_SCALE, ENEMY_SCALE);
-            model.position.copy(position);
-            
-            model.traverse((node) => {
-                if (node.isMesh) {
-                    node.castShadow = true;
-                    node.receiveShadow = true;
-                    node.material.metalness = 0.2;
-                    node.material.roughness = 0.8;
-                }
-            });
+        bullet.position.copy(this.mesh.position);
+        
+        const direction = new THREE.Vector3()
+            .subVectors(playerPosition, this.mesh.position)
+            .normalize();
+        
+        bullet.velocity = direction.multiplyScalar(ENEMY_CONFIG.BULLET_SPEED);
+        
+        this.scene.add(bullet);
+        this.bullets.push(bullet);
+        this.lastAttackTime = currentTime;
+    }
 
-            scene.remove(tempEnemy.model);
-            scene.add(model);
-            enemies[enemies.indexOf(tempEnemy)].model = model;
+    takeDamage(damage) {
+        this.health -= damage;
+        return this.health <= 0;
+    }
 
-            console.log(`Successfully loaded enemy model ${modelIndex}`);
-        } catch (error) {
-            console.error(`Error loading enemy model:`, error);
+    destroy() {
+        if (this.mesh) {
+            this.scene.remove(this.mesh);
+            this.bullets.forEach(bullet => this.scene.remove(bullet));
+            this.bullets = [];
         }
     }
 }
 
-function createTemporaryEnemy(position) {
-    const geometry = new THREE.BoxGeometry(5, 10, 5);
-    const material = new THREE.MeshPhongMaterial({ 
-        color: 0xff0000,
-        transparent: true,
-        opacity: 0.8
-    });
-    
-    const model = new THREE.Mesh(geometry, material);
-    model.position.copy(position);
-    model.castShadow = true;
-    model.receiveShadow = true;
-
-    return {
-        model: model,
-        health: 100,
-        speed: ENEMY_MOVE_SPEED,
-        lastAttackTime: 0
-    };
-}
-function createExplosion(position) {
-    const particles = [];
-    for (let i = 0; i < PARTICLE_COUNT; i++) {
-        const particle = new THREE.Mesh(
-            new THREE.SphereGeometry(0.3),
-            new THREE.MeshBasicMaterial({ 
-                color: 0xff4400,
-                transparent: true,
-                opacity: 1
-            })
-        );
+// Particle 클래스 정의
+class Particle {
+    constructor(scene, position) {
+        const geometry = new THREE.SphereGeometry(0.1);
+        const material = new THREE.MeshBasicMaterial({ color: 0xff0000 });
+        this.mesh = new THREE.Mesh(geometry, material);
+        this.mesh.position.copy(position);
         
-        particle.position.copy(position);
-        particle.velocity = new THREE.Vector3(
-            (Math.random() - 0.5) * 2,
-            Math.random() * 2,
-            (Math.random() - 0.5) * 2
+        this.velocity = new THREE.Vector3(
+            (Math.random() - 0.5) * 0.3,
+            Math.random() * 0.2,
+            (Math.random() - 0.5) * 0.3
         );
         
-        particles.push(particle);
-        scene.add(particle);
-    }
-
-    // 폭발 광원 효과
-    const explosionLight = new THREE.PointLight(0xff4400, 2, 20);
-    explosionLight.position.copy(position);
-    scene.add(explosionLight);
-
-    let opacity = 1;
-    const animate = () => {
-        opacity -= 0.05;
-        if (opacity <= 0) {
-            particles.forEach(p => scene.remove(p));
-            scene.remove(explosionLight);
-            return;
-        }
-        
-        particles.forEach(particle => {
-            particle.position.add(particle.velocity);
-            particle.material.opacity = opacity;
-        });
+        this.gravity = -0.01;
+        this.lifetime = 60;
+        this.age = 0;
         
-        requestAnimationFrame(animate);
-    };
-    
-    animate();
-}
+        scene.add(this.mesh);
+    }
 
-function onClick() {
-    if (!controls.isLocked) {
-        controls.lock();
-        gunSound.resume();
-    } else if (ammo > 0) {
-        shoot();
+    update() {
+        this.velocity.y += this.gravity;
+        this.mesh.position.add(this.velocity);
+        this.age++;
+        return this.age < this.lifetime;
     }
-}
 
-function onKeyDown(event) {
-    if (!player) return;
-    
-    switch(event.code) {
-        case 'KeyW': 
-            moveState.forward = true; 
-            const forwardDir = new THREE.Vector3(0, 0, -1);
-            player.move(forwardDir);
-            break;
-        case 'KeyS': 
-            moveState.backward = true; 
-            const backwardDir = new THREE.Vector3(0, 0, 1);
-            player.move(backwardDir);
-            break;
-        case 'KeyA': 
-            moveState.left = true; 
-            player.rotate(1);
-            break;
-        case 'KeyD': 
-            moveState.right = true; 
-            player.rotate(-1);
-            break;
-        case 'KeyR': reload(); break;
+    destroy(scene) {
+        scene.remove(this.mesh);
     }
 }
+// Game 클래스 정의
+class Game {
+    constructor() {
+        // 기본 Three.js 설정
+        this.scene = new THREE.Scene();
+        this.camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
+        this.renderer = new THREE.WebGLRenderer({ antialias: true });
+        this.renderer.setSize(window.innerWidth, window.innerHeight);
+        this.renderer.shadowMap.enabled = true;
+        document.body.appendChild(this.renderer.domElement);
 
-function onKeyUp(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;
+        // 게임 요소 초기화
+        this.tank = new TankPlayer();
+        this.enemies = [];
+        this.particles = [];
+        this.obstacles = [];
+        this.loader = new GLTFLoader();
+        this.controls = null;
+        this.gameTime = GAME_DURATION;
+        this.score = 0;
+        this.isGameOver = false;
+
+        // 마우스 상태
+        this.mouse = {
+            x: 0,
+            y: 0
+        };
+
+        // 키보드 상태
+        this.keys = {
+            forward: false,
+            backward: false,
+            left: false,
+            right: false
+        };
+
+        // 이벤트 리스너 설정
+        this.setupEventListeners();
+        
+        // 게임 초기화
+        this.initialize();
     }
-}
 
-function onWindowResize() {
-    camera.aspect = window.innerWidth / window.innerHeight;
-    camera.updateProjectionMatrix();
-    renderer.setSize(window.innerWidth, window.innerHeight);
-}
+    async initialize() {
+        // 조명 설정
+        const ambientLight = new THREE.AmbientLight(0xffffff, 0.5);
+        this.scene.add(ambientLight);
 
-// 이동 상태
-const moveState = {
-    forward: false,
-    backward: false,
-    left: false,
-    right: false
-};
+        const directionalLight = new THREE.DirectionalLight(0xffffff, 0.8);
+        directionalLight.position.set(50, 50, 50);
+        directionalLight.castShadow = true;
+        this.scene.add(directionalLight);
 
-function shoot() {
-    if (ammo <= 0 || !player || !player.turret) return;
-    
-    ammo--;
-    updateAmmoDisplay();
-    
-    const bullet = createBullet();
-    bullets.push(bullet);
-    
-    gunSound.createGunshot();
-
-    // 총구 화염 효과
-    const muzzleFlash = new THREE.PointLight(0xffff00, 3, 10);
-    muzzleFlash.position.copy(player.turret.position);
-    scene.add(muzzleFlash);
-    setTimeout(() => scene.remove(muzzleFlash), 50);
-}
+        // 바닥 생성
+        const groundGeometry = new THREE.PlaneGeometry(MAP_SIZE, MAP_SIZE);
+        const groundMaterial = new THREE.MeshStandardMaterial({ 
+            color: 0x808080,
+            roughness: 0.8,
+            metalness: 0.2
+        });
+        const ground = new THREE.Mesh(groundGeometry, groundMaterial);
+        ground.rotation.x = -Math.PI / 2;
+        ground.receiveShadow = true;
+        this.scene.add(ground);
 
-function createBullet() {
-    const bullet = new THREE.Mesh(
-        new THREE.SphereGeometry(0.5),
-        new THREE.MeshBasicMaterial({ 
-            color: 0xffff00,
-            emissive: 0xffff00,
-            emissiveIntensity: 1
-        })
-    );
-    
-    // 포탑 위치에서 총알 발사
-    bullet.position.copy(player.turret.position);
-    const direction = new THREE.Vector3(0, 0, -1);
-    direction.applyQuaternion(player.turret.quaternion);
-    bullet.velocity = direction.multiplyScalar(5);
-    
-    scene.add(bullet);
-    return bullet;
-}
-function createEnemyBullet(enemy) {
-    const bullet = new THREE.Mesh(
-        new THREE.SphereGeometry(0.5),
-        new THREE.MeshBasicMaterial({ 
-            color: 0xff0000,
-            emissive: 0xff0000,
-            emissiveIntensity: 1
-        })
-    );
-    
-    bullet.position.copy(enemy.model.position);
-    bullet.position.y += 5;
-    
-    const direction = new THREE.Vector3();
-    direction.subVectors(player.body.position, enemy.model.position).normalize();
-    bullet.velocity = direction.multiplyScalar(ENEMY_CONFIG.BULLET_SPEED);
-    
-    scene.add(bullet);
-    return bullet;
-}
+        // 탱크 초기화
+        await this.tank.initialize(this.scene, this.loader);
 
-function updateMovement() {
-    if (controls.isLocked && !isGameOver && player) {
-        // 카메라 위치 업데이트
-        const cameraOffset = new THREE.Vector3(0, TANK_HEIGHT + 5, -15);
-        cameraOffset.applyQuaternion(player.body.quaternion);
-        camera.position.copy(player.body.position).add(cameraOffset);
-        
-        // 카메라가 플레이어를 바라보도록 설정
-        camera.lookAt(player.body.position);
-    }
-}
+        // 장애물 생성
+        this.createObstacles();
 
-function updateBullets() {
-    for (let i = bullets.length - 1; i >= 0; i--) {
-        if (!bullets[i]) continue;
-        
-        bullets[i].position.add(bullets[i].velocity);
-        
-        // 적과의 충돌 검사
-        for (let j = enemies.length - 1; j >= 0; j--) {
-            const enemy = enemies[j];
-            if (!enemy || !enemy.model) continue;
-            
-            if (bullets[i] && bullets[i].position.distanceTo(enemy.model.position) < 10) {
-                scene.remove(bullets[i]);
-                bullets.splice(i, 1);
-                enemy.health -= 25;
-                
-                createExplosion(enemy.model.position.clone());
-                
-                if (enemy.health <= 0) {
-                    createExplosion(enemy.model.position.clone());
-                    scene.remove(enemy.model);
-                    enemies.splice(j, 1);
-                }
-                break;
-            }
-        }
+        // 카메라 위치 설정
+        this.camera.position.set(0, 10, -10);
+        this.camera.lookAt(0, 0, 0);
 
-        // 범위 벗어난 총알 제거
-        if (bullets[i] && bullets[i].position.distanceTo(player.body.position) > 1000) {
-            scene.remove(bullets[i]);
-            bullets.splice(i, 1);
-        }
-    }
-}
+        // 포인터 락 컨트롤 설정
+        this.controls = new PointerLockControls(this.camera, document.body);
 
-function updateEnemyBullets() {
-    for (let i = enemyBullets.length - 1; i >= 0; i--) {
-        if (!enemyBullets[i]) continue;
+        // 게임 시작
+        this.animate();
+        this.spawnEnemies();
+        this.startGameTimer();
+    }
 
-        enemyBullets[i].position.add(enemyBullets[i].velocity);
-        
-        if (enemyBullets[i].position.distanceTo(player.body.position) < 3) {
-            playerHealth -= 10;
-            updateHealthBar();
-            createExplosion(enemyBullets[i].position.clone());
-            scene.remove(enemyBullets[i]);
-            enemyBullets.splice(i, 1);
+    createObstacles() {
+        for (let i = 0; i < OBSTACLE_COUNT; i++) {
+            const geometry = new THREE.BoxGeometry(2, 2, 2);
+            const material = new THREE.MeshStandardMaterial({ color: 0x808080 });
+            const obstacle = new THREE.Mesh(geometry, material);
             
-            if (playerHealth <= 0) {
-                gameOver(false);
-            }
-            continue;
-        }
-
-        if (enemyBullets[i].position.distanceTo(player.body.position) > 1000) {
-            scene.remove(enemyBullets[i]);
-            enemyBullets.splice(i, 1);
+            obstacle.position.x = (Math.random() - 0.5) * MAP_SIZE;
+            obstacle.position.z = (Math.random() - 0.5) * MAP_SIZE;
+            obstacle.position.y = 1;
+            
+            obstacle.castShadow = true;
+            obstacle.receiveShadow = true;
+            
+            this.obstacles.push(obstacle);
+            this.scene.add(obstacle);
         }
     }
-}
 
-function updateEnemies() {
-    const currentTime = Date.now();
-    
-    enemies.forEach(enemy => {
-        if (!enemy || !enemy.model) return;
-
-        // 적 이동 로직
-        const direction = new THREE.Vector3();
-        direction.subVectors(player.body.position, enemy.model.position);
-        direction.y = 0;
-        direction.normalize();
+    spawnEnemies() {
+        const spawnEnemy = () => {
+            if (this.enemies.length < ENEMY_COUNT_MAX && !this.isGameOver) {
+                const position = new THREE.Vector3(
+                    (Math.random() - 0.5) * MAP_SIZE,
+                    ENEMY_GROUND_HEIGHT,
+                    (Math.random() - 0.5) * MAP_SIZE
+                );
+                
+                const enemy = new Enemy(this.scene, position);
+                enemy.initialize(this.loader);
+                this.enemies.push(enemy);
+            }
+            setTimeout(spawnEnemy, 3000);
+        };
         
-        const newPosition = enemy.model.position.clone()
-            .add(direction.multiplyScalar(enemy.speed));
-        newPosition.y = ENEMY_GROUND_HEIGHT;
-        enemy.model.position.copy(newPosition);
-
-        // 적이 플레이어를 바라보도록 설정
-        enemy.model.lookAt(new THREE.Vector3(
-            player.body.position.x,
-            enemy.model.position.y,
-            player.body.position.z
-        ));
-
-        // 공격 로직
-        const distanceToPlayer = enemy.model.position.distanceTo(player.body.position);
-        if (distanceToPlayer < ENEMY_CONFIG.ATTACK_RANGE && 
-            currentTime - enemy.lastAttackTime > ENEMY_CONFIG.ATTACK_INTERVAL) {
-            
-            enemyBullets.push(createEnemyBullet(enemy));
-            enemy.lastAttackTime = currentTime;
-
-            // 공격 시 발광 효과
-            const attackFlash = new THREE.PointLight(0xff0000, 2, 20);
-            attackFlash.position.copy(enemy.model.position);
-            scene.add(attackFlash);
-            setTimeout(() => scene.remove(attackFlash), 100);
-        }
-    });
-}
-function reload() {
-    ammo = 30;
-    updateAmmoDisplay();
-}
-
-function updateAmmoDisplay() {
-    document.getElementById('ammo').textContent = `Ammo: ${ammo}/30`;
-}
-
-function updateHealthBar() {
-    const healthElement = document.getElementById('health');
-    const healthPercentage = (playerHealth / MAX_HEALTH) * 100;
-    healthElement.style.width = `${healthPercentage}%`;
-}
-
-function updateTankHUD() {
-    if (!player || !player.body) return;
-
-    document.querySelector('#altitude-indicator span').textContent = 
-        Math.round(player.body.position.y);
+        spawnEnemy();
+    }
 
-    const speed = Math.round(
-        Math.sqrt(
-            moveState.forward * moveState.forward +
-            moveState.right * moveState.right
-        ) * 100
-    );
-    document.querySelector('#speed-indicator span').textContent = speed;
+    startGameTimer() {
+        const timer = setInterval(() => {
+            this.gameTime--;
+            if (this.gameTime <= 0 || this.isGameOver) {
+                clearInterval(timer);
+                this.endGame();
+            }
+        }, 1000);
+    }
 
-    const heading = Math.round(
-        (player.body.rotation.y * (180 / Math.PI) + 360) % 360
-    );
-    document.querySelector('#compass span').textContent = heading;
+    setupEventListeners() {
+        // 키보드 이벤트
+        document.addEventListener('keydown', (event) => {
+            switch(event.code) {
+                case 'KeyW': this.keys.forward = true; break;
+                case 'KeyS': this.keys.backward = true; break;
+                case 'KeyA': this.keys.left = true; break;
+                case 'KeyD': this.keys.right = true; break;
+            }
+        });
 
-    updateRadar();
-}
+        document.addEventListener('keyup', (event) => {
+            switch(event.code) {
+                case 'KeyW': this.keys.forward = false; break;
+                case 'KeyS': this.keys.backward = false; break;
+                case 'KeyA': this.keys.left = false; break;
+                case 'KeyD': this.keys.right = false; break;
+            }
+        });
 
-function updateRadar() {
-    if (!player || !player.body) return;
-    
-    const radarTargets = document.querySelector('.radar-targets');
-    radarTargets.innerHTML = '';
+        // 마우스 이벤트
+        document.addEventListener('mousemove', (event) => {
+            this.mouse.x = (event.clientX / window.innerWidth) * 2 - 1;
+            this.mouse.y = -(event.clientY / window.innerHeight) * 2 + 1;
+        });
 
-    enemies.forEach(enemy => {
-        if (!enemy || !enemy.model) return;
+        // 창 크기 변경 이벤트
+        window.addEventListener('resize', () => {
+            this.camera.aspect = window.innerWidth / window.innerHeight;
+            this.camera.updateProjectionMatrix();
+            this.renderer.setSize(window.innerWidth, window.innerHeight);
+        });
+    }
 
-        const relativePos = enemy.model.position.clone().sub(player.body.position);
-        const distance = relativePos.length();
+    handleMovement() {
+        const direction = new THREE.Vector3();
         
-        if (distance < 500) {
-            const playerAngle = player.body.rotation.y;
-            const enemyAngle = Math.atan2(relativePos.x, relativePos.z);
-            const relativeAngle = enemyAngle - playerAngle;
-            
-            const normalizedDistance = distance / 500;
-            
-            const dot = document.createElement('div');
-            dot.className = 'radar-dot';
-            dot.style.left = `${50 + Math.sin(relativeAngle) * normalizedDistance * 45}%`;
-            dot.style.top = `${50 + Math.cos(relativeAngle) * normalizedDistance * 45}%`;
-            radarTargets.appendChild(dot);
+        if (this.keys.forward) direction.z += 1;
+        if (this.keys.backward) direction.z -= 1;
+        if (this.keys.left) this.tank.rotate(-1);
+        if (this.keys.right) this.tank.rotate(1);
+        
+        if (direction.length() > 0) {
+            direction.normalize();
+            this.tank.move(direction);
         }
-    });
-}
-
-function checkGameStatus() {
-    if (enemies.length === 0 && currentStage < 5) {
-        currentStage++;
-        document.getElementById('stage').style.display = 'block';
-        document.getElementById('stage').textContent = `Stage ${currentStage}`;
-        setTimeout(() => {
-            document.getElementById('stage').style.display = 'none';
-            createEnemies();
-        }, 2000);
     }
-}
 
-function cleanupResources() {
-    bullets.forEach(bullet => scene.remove(bullet));
-    bullets = [];
-    
-    enemyBullets.forEach(bullet => scene.remove(bullet));
-    enemyBullets = [];
-    
-    enemies.forEach(enemy => {
-        if (enemy && enemy.model) {
-            scene.remove(enemy.model);
+    updateParticles() {
+        for (let i = this.particles.length - 1; i >= 0; i--) {
+            const particle = this.particles[i];
+            if (!particle.update()) {
+                particle.destroy(this.scene);
+                this.particles.splice(i, 1);
+            }
         }
-    });
-    enemies = [];
-}
+    }
 
-function gameOver(won) {
-    isGameOver = true;
-    controls.unlock();
-    cleanupResources();
-    setTimeout(() => {
-        alert(won ? 'Mission Complete!' : 'Game Over!');
-        location.reload();
-    }, 100);
-}
+    createExplosion(position) {
+        for (let i = 0; i < PARTICLE_COUNT; i++) {
+            this.particles.push(new Particle(this.scene, position));
+        }
+    }
 
-function gameLoop(timestamp) {
-    requestAnimationFrame(gameLoop);
-    
-    if (timestamp - lastRender < 16) {
-        return;
+    checkCollisions() {
+        const tankPosition = this.tank.getPosition();
+
+        // 적과의 충돌 체크
+        this.enemies.forEach(enemy => {
+            if (!enemy.mesh) return;
+
+            enemy.bullets.forEach(bullet => {
+                const distance = bullet.position.distanceTo(tankPosition);
+                if (distance < 1) {
+                    if (this.tank.takeDamage(10)) {
+                        this.endGame();
+                    }
+                    this.scene.remove(bullet);
+                    enemy.bullets = enemy.bullets.filter(b => b !== bullet);
+                }
+            });
+        });
     }
-    lastRender = timestamp;
 
-    if (controls.isLocked && !isGameOver) {
-        updateMovement();
-        updateBullets();
-        updateEnemies();
-        updateEnemyBullets();
-        updateTankHUD();
-        checkGameStatus();
+    endGame() {
+        this.isGameOver = true;
+        // 게임 오버 UI 표시
+        const gameOverDiv = document.createElement('div');
+        gameOverDiv.style.position = 'absolute';
+        gameOverDiv.style.top = '50%';
+        gameOverDiv.style.left = '50%';
+        gameOverDiv.style.transform = 'translate(-50%, -50%)';
+        gameOverDiv.style.color = 'white';
+        gameOverDiv.style.fontSize = '48px';
+        gameOverDiv.innerHTML = `Game Over<br>Score: ${this.score}`;
+        document.body.appendChild(gameOverDiv);
     }
 
-    renderer.render(scene, camera);
-}
+    animate() {
+        if (this.isGameOver) return;
 
-// 성능 모니터링
-let lastFpsUpdate = 0;
-let frameCount = 0;
+        requestAnimationFrame(() => this.animate());
 
-function updateFPS(timestamp) {
-    frameCount++;
-    
-    if (timestamp - lastFpsUpdate >= 1000) {
-        const fps = Math.round(frameCount * 1000 / (timestamp - lastFpsUpdate));
-        console.log('FPS:', fps);
-        
-        frameCount = 0;
-        lastFpsUpdate = timestamp;
+        // 탱크 업데이트
+        this.tank.update(this.mouse.x, this.mouse.y);
+        this.handleMovement();
+
+        // 적 업데이트
+        const tankPosition = this.tank.getPosition();
+        this.enemies.forEach(enemy => {
+            enemy.update(tankPosition);
+            const distance = enemy.mesh?.position.distanceTo(tankPosition) || Infinity;
+            if (distance < ENEMY_CONFIG.ATTACK_RANGE) {
+                enemy.shoot(tankPosition);
+            }
+        });
+
+        // 파티클 업데이트
+        this.updateParticles();
+
+        // 충돌 체크
+        this.checkCollisions();
+
+        // 렌더링
+        this.renderer.render(this.scene, this.camera);
     }
-    
-    requestAnimationFrame(updateFPS);
 }
 
 // 게임 시작
-window.addEventListener('load', async () => {
-    try {
-        await init();
-        console.log('Game started');
-        console.log('Active enemies:', enemies.length);
-        gameLoop(performance.now());
-        updateFPS(performance.now());
-    } catch (error) {
-        console.error('Game initialization error:', error);
-        document.getElementById('loading').innerHTML = `
-            <div class="loading-text" style="color: #ff0000;">
-                Error loading game. Please check console and file paths.
-            </div>
-        `;
-    }
-});
-
-// 디버깅을 위한 전역 접근
-window.debugGame = {
-    scene,
-    camera,
-    enemies,
-    gunSound,
-    player,
-    reloadEnemies: createEnemies
-};
+const game = new Game();