Update game.js

game.js

@@ -2,128 +2,72 @@ import * as THREE from 'three';
 import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
 import { PointerLockControls } from 'three/addons/controls/PointerLockControls.js';
 
+
 // 게임 상수
 const GAME_DURATION = 180;
 const MAP_SIZE = 2000;
-const TANK_HEIGHT = 0.5;  // 포탑 높이 조정
+const TANK_HEIGHT = 0.5;
 const ENEMY_GROUND_HEIGHT = 0;
 const ENEMY_SCALE = 10;
 const MAX_HEALTH = 1000;
 const ENEMY_MOVE_SPEED = 0.1;
 const ENEMY_COUNT_MAX = 5;
 const PARTICLE_COUNT = 15;
-const OBSTACLE_COUNT = 50;
+const BUILDING_COUNT = 30;  // 건물 수 추가
 const ENEMY_CONFIG = {
-    ATTACK_RANGE: 100,
-    ATTACK_INTERVAL: 2000,
-    BULLET_SPEED: 2
-};
-
-
-// TankPlayer 클래스 수정
-class TankPlayer {
-    constructor() {
-        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;
-    }
-
-    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;
-                }
-            });
-
-            scene.add(this.body);
-            
-        } catch (error) {
-            console.error('Error loading tank models:', error);
-        }
-    }
-
-    update(mouseX, mouseY) {
-        if (!this.body || !this.turretGroup) return;
-        
-        const targetAngle = Math.atan2(mouseX, mouseY);
-        const currentRotation = this.turretGroup.rotation.y;
-        const rotationDiff = targetAngle - currentRotation;
-        
-        // 포탑 회전 각도 정규화
-        let normalizedDiff = rotationDiff;
-        while (normalizedDiff > Math.PI) normalizedDiff -= Math.PI * 2;
-        while (normalizedDiff < -Math.PI) normalizedDiff += Math.PI * 2;
-        
-        this.turretGroup.rotation.y += normalizedDiff * 0.1;
-    }
-
-    move(direction) {
-        if (!this.body) return;
-        
-        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);
-    }
-
-    rotate(angle) {
-        if (!this.body) return;
-        this.body.rotation.y += angle * this.turnSpeed;
-    }
-
-    getPosition() {
-        return this.body ? this.body.position : new THREE.Vector3();
+    TANK: {
+        MODEL: '/models/enemy1.glb',
+        HEALTH: 120,
+        SPEED: 0.1,
+        ATTACK_RANGE: 100,
+        ATTACK_INTERVAL: 2000,
+        BULLET_SPEED: 2
+    },
+    HEAVY_TANK: {
+        MODEL: '/models/enemy4.glb',
+        HEALTH: 200,
+        SPEED: 0.05,
+        ATTACK_RANGE: 150,
+        ATTACK_INTERVAL: 3000,
+        BULLET_SPEED: 1.5
     }
+};
 
-    takeDamage(damage) {
-        this.health -= damage;
-        return this.health <= 0;
+// Building 클래스 추가
+class Building {
+    constructor(scene, position, size) {
+        const geometry = new THREE.BoxGeometry(size.width, size.height, size.depth);
+        const material = new THREE.MeshStandardMaterial({
+            color: 0x808080,
+            roughness: 0.7,
+            metalness: 0.3
+        });
+        this.mesh = new THREE.Mesh(geometry, material);
+        this.mesh.position.copy(position);
+        this.mesh.position.y = size.height / 2;
+        this.mesh.castShadow = true;
+        this.mesh.receiveShadow = true;
+        scene.add(this.mesh);
     }
 }
 
-// Enemy 클래스 정의
+// Enemy 클래스 수정
 class Enemy {
-    constructor(scene, position) {
+    constructor(scene, position, type) {
         this.scene = scene;
         this.position = position;
+        this.type = type;
         this.mesh = null;
-        this.health = 100;
+        this.health = type === 'TANK' ? ENEMY_CONFIG.TANK.HEALTH : ENEMY_CONFIG.HEAVY_TANK.HEALTH;
         this.lastAttackTime = 0;
         this.bullets = [];
+        this.config = ENEMY_CONFIG[type];
     }
 
     async initialize(loader) {
         try {
-            const result = await loader.loadAsync('/models/enemy1.glb');
+            const modelPath = this.type === 'TANK' ? ENEMY_CONFIG.TANK.MODEL : ENEMY_CONFIG.HEAVY_TANK.MODEL;
+            const result = await loader.loadAsync(modelPath);
             this.mesh = result.scene;
             this.mesh.position.copy(this.position);
             this.mesh.scale.set(ENEMY_SCALE, ENEMY_SCALE, ENEMY_SCALE);
@@ -144,22 +88,21 @@ class Enemy {
     update(playerPosition) {
         if (!this.mesh) return;
 
-        // 플레이어 방향으로 회전
         const direction = new THREE.Vector3()
             .subVectors(playerPosition, this.mesh.position)
             .normalize();
         
         this.mesh.lookAt(playerPosition);
 
-        // 플레이어 방향으로 이동
-        this.mesh.position.add(direction.multiplyScalar(ENEMY_MOVE_SPEED));
+        // 타입별 이동 속도 적용
+        const moveSpeed = this.type === 'TANK' ? ENEMY_CONFIG.TANK.SPEED : ENEMY_CONFIG.HEAVY_TANK.SPEED;
+        this.mesh.position.add(direction.multiplyScalar(moveSpeed));
 
         // 총알 업데이트
         for (let i = this.bullets.length - 1; i >= 0; i--) {
             const bullet = this.bullets[i];
             bullet.position.add(bullet.velocity);
 
-            // 총알이 맵 밖으로 나가면 제거
             if (Math.abs(bullet.position.x) > MAP_SIZE || 
                 Math.abs(bullet.position.z) > MAP_SIZE) {
                 this.scene.remove(bullet);
@@ -170,10 +113,16 @@ class Enemy {
 
     shoot(playerPosition) {
         const currentTime = Date.now();
-        if (currentTime - this.lastAttackTime < ENEMY_CONFIG.ATTACK_INTERVAL) return;
+        const attackInterval = this.type === 'TANK' ? 
+            ENEMY_CONFIG.TANK.ATTACK_INTERVAL : 
+            ENEMY_CONFIG.HEAVY_TANK.ATTACK_INTERVAL;
+
+        if (currentTime - this.lastAttackTime < attackInterval) return;
 
         const bulletGeometry = new THREE.SphereGeometry(0.2);
-        const bulletMaterial = new THREE.MeshBasicMaterial({ color: 0xff0000 });
+        const bulletMaterial = new THREE.MeshBasicMaterial({ 
+            color: this.type === 'TANK' ? 0xff0000 : 0xff6600 
+        });
         const bullet = new THREE.Mesh(bulletGeometry, bulletMaterial);
 
         bullet.position.copy(this.mesh.position);
@@ -182,7 +131,11 @@ class Enemy {
             .subVectors(playerPosition, this.mesh.position)
             .normalize();
         
-        bullet.velocity = direction.multiplyScalar(ENEMY_CONFIG.BULLET_SPEED);
+        const bulletSpeed = this.type === 'TANK' ? 
+            ENEMY_CONFIG.TANK.BULLET_SPEED : 
+            ENEMY_CONFIG.HEAVY_TANK.BULLET_SPEED;
+
+        bullet.velocity = direction.multiplyScalar(bulletSpeed);
         
         this.scene.add(bullet);
         this.bullets.push(bullet);
@@ -202,43 +155,9 @@ class Enemy {
         }
     }
 }
-
-// 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);
-        
-        this.velocity = new THREE.Vector3(
-            (Math.random() - 0.5) * 0.3,
-            Math.random() * 0.2,
-            (Math.random() - 0.5) * 0.3
-        );
-        
-        this.gravity = -0.01;
-        this.lifetime = 60;
-        this.age = 0;
-        
-        scene.add(this.mesh);
-    }
-
-    update() {
-        this.velocity.y += this.gravity;
-        this.mesh.position.add(this.velocity);
-        this.age++;
-        return this.age < this.lifetime;
-    }
-
-    destroy(scene) {
-        scene.remove(this.mesh);
-    }
-}
-// Game 클래스 정의
+// 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 });
@@ -246,24 +165,21 @@ class Game {
         this.renderer.shadowMap.enabled = true;
         document.body.appendChild(this.renderer.domElement);
 
-        // 게임 요소 초기화
         this.tank = new TankPlayer();
         this.enemies = [];
         this.particles = [];
-        this.obstacles = [];
+        this.buildings = [];  // 건물 배열 추가
         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,
@@ -271,10 +187,7 @@ class Game {
             right: false
         };
 
-        // 이벤트 리스너 설정
         this.setupEventListeners();
-        
-        // 게임 초기화
         this.initialize();
     }
 
@@ -288,52 +201,51 @@ class Game {
         directionalLight.castShadow = true;
         this.scene.add(directionalLight);
 
-        // 바닥 생성
+        // 도시 바닥 생성
         const groundGeometry = new THREE.PlaneGeometry(MAP_SIZE, MAP_SIZE);
         const groundMaterial = new THREE.MeshStandardMaterial({ 
-            color: 0x808080,
-            roughness: 0.8,
-            metalness: 0.2
+            color: 0x333333,  // 어두운 회색 (아스팔트)
+            roughness: 0.9,
+            metalness: 0.1
         });
         const ground = new THREE.Mesh(groundGeometry, groundMaterial);
         ground.rotation.x = -Math.PI / 2;
         ground.receiveShadow = true;
         this.scene.add(ground);
 
+        // 건물 생성
+        this.createBuildings();
+
         // 탱크 초기화
         await this.tank.initialize(this.scene, this.loader);
 
-        // 장애물 생성
-        this.createObstacles();
-
-        // 카메라 위치 설정
+        // 카메라 설정
         this.camera.position.set(0, 10, -10);
         this.camera.lookAt(0, 0, 0);
 
-        // 포인터 락 컨트롤 설정
         this.controls = new PointerLockControls(this.camera, document.body);
 
-        // 게임 시작
         this.animate();
         this.spawnEnemies();
         this.startGameTimer();
     }
 
-    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);
-            
-            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);
+    createBuildings() {
+        for (let i = 0; i < BUILDING_COUNT; i++) {
+            const size = {
+                width: 10 + Math.random() * 20,
+                height: 20 + Math.random() * 80,
+                depth: 10 + Math.random() * 20
+            };
+
+            const position = new THREE.Vector3(
+                (Math.random() - 0.5) * (MAP_SIZE - size.width),
+                0,
+                (Math.random() - 0.5) * (MAP_SIZE - size.depth)
+            );
+
+            const building = new Building(this.scene, position, size);
+            this.buildings.push(building);
         }
     }
 
@@ -346,7 +258,9 @@ class Game {
                     (Math.random() - 0.5) * MAP_SIZE
                 );
                 
-                const enemy = new Enemy(this.scene, position);
+                // 랜덤하게 적 유형 선택
+                const type = Math.random() > 0.7 ? 'HEAVY_TANK' : 'TANK';
+                const enemy = new Enemy(this.scene, position, type);
                 enemy.initialize(this.loader);
                 this.enemies.push(enemy);
             }
@@ -355,7 +269,7 @@ class Game {
         
         spawnEnemy();
     }
-
+  // Game 클래스 계속...
     startGameTimer() {
         const timer = setInterval(() => {
             this.gameTime--;
@@ -367,7 +281,6 @@ class Game {
     }
 
     setupEventListeners() {
-        // 키보드 이벤트
         document.addEventListener('keydown', (event) => {
             switch(event.code) {
                 case 'KeyW': this.keys.forward = true; break;
@@ -386,13 +299,11 @@ class Game {
             }
         });
 
-        // 마우스 이벤트
         document.addEventListener('mousemove', (event) => {
             this.mouse.x = (event.clientX / window.innerWidth) * 2 - 1;
             this.mouse.y = -(event.clientY / window.innerHeight) * 2 + 1;
         });
 
-        // 창 크기 변경 이벤트
         window.addEventListener('resize', () => {
             this.camera.aspect = window.innerWidth / window.innerHeight;
             this.camera.updateProjectionMatrix();
@@ -437,22 +348,34 @@ class Game {
         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)) {
+                    if (this.tank.takeDamage(enemy.type === 'HEAVY_TANK' ? 15 : 10)) {
                         this.endGame();
                     }
                     this.scene.remove(bullet);
                     enemy.bullets = enemy.bullets.filter(b => b !== bullet);
                 }
             });
+
+            // 건물과의 충돌 체크
+            this.buildings.forEach(building => {
+                // 간단한 충돌 체크 (실제 게임에서는 더 정교한 충돌 체크가 필요할 수 있습니다)
+                const distance = enemy.mesh.position.distanceTo(building.mesh.position);
+                if (distance < 5) { // 임의의 충돌 거리
+                    const pushDirection = new THREE.Vector3()
+                        .subVectors(enemy.mesh.position, building.mesh.position)
+                        .normalize();
+                    enemy.mesh.position.add(pushDirection);
+                }
+            });
         });
     }
 
     endGame() {
         this.isGameOver = true;
-        // 게임 오버 UI 표시
         const gameOverDiv = document.createElement('div');
         gameOverDiv.style.position = 'absolute';
         gameOverDiv.style.top = '50%';
@@ -469,27 +392,21 @@ class Game {
 
         requestAnimationFrame(() => this.animate());
 
-        // 탱크 업데이트
         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) {
+            if (distance < enemy.config.ATTACK_RANGE) {
                 enemy.shoot(tankPosition);
             }
         });
 
-        // 파티클 업데이트
         this.updateParticles();
-
-        // 충돌 체크
         this.checkCollisions();
 
-        // 렌더링
         this.renderer.render(this.scene, this.camera);
     }
 }