Update game.js

game.js

@@ -579,65 +579,30 @@ class Enemy {
         this.bullets = [];
         this.isLoaded = false;
         this.moveSpeed = type === 'tank' ? ENEMY_MOVE_SPEED : ENEMY_MOVE_SPEED * 0.7;
-    }
-    createMuzzleFlash() {
-    if (!this.mesh) return;
-    
-    const flashGroup = new THREE.Group();
-    
-    // 화염 크기 증가 및 색상 변경
-    const flameGeometry = new THREE.SphereGeometry(1.0, 8, 8);
-    const flameMaterial = new THREE.MeshBasicMaterial({
-        color: 0xffa500, // 노란색으로 변경
-        transparent: true,
-        opacity: 0.8
-    });
-    const flame = new THREE.Mesh(flameGeometry, flameMaterial);
-    flame.scale.set(2, 2, 3);
-    flashGroup.add(flame);
+        
+        // AI 상태 관리
+        this.aiState = {
+            mode: 'pursue', // 'pursue', 'flank', 'retreat'
+            lastStateChange: 0,
+            stateChangeCooldown: 3000,
+            lastVisibilityCheck: 0,
+            visibilityCheckInterval: 500,
+            canSeePlayer: false,
+            lastKnownPlayerPosition: null,
+            searchStartTime: null
+        };
 
-    // 연기 효과 크기 증가
-    const smokeGeometry = new THREE.SphereGeometry(0.8, 8, 8);
-    const smokeMaterial = new THREE.MeshBasicMaterial({
-        color: 0x555555,
-        transparent: true,
-        opacity: 0.5
-    });
-    
-    for (let i = 0; i < 5; i++) {
-        const smoke = new THREE.Mesh(smokeGeometry, smokeMaterial);
-        smoke.position.set(
-            Math.random() * 1 - 0.5,
-            Math.random() * 1 - 0.5,
-            -1 - Math.random()
-        );
-        smoke.scale.set(1.5, 1.5, 1.5);
-        flashGroup.add(smoke);
+        // 경로 탐색 상태
+        this.pathfinding = {
+            currentPath: [],
+            pathUpdateInterval: 1000,
+            lastPathUpdate: 0,
+            isAvoidingObstacle: false,
+            avoidanceDirection: null,
+            obstacleCheckDistance: 10
+        };
     }
 
-    // 포구 위치 계산
-    const muzzleOffset = new THREE.Vector3(0, 0.5, 4);
-    const muzzlePosition = new THREE.Vector3();
-    const meshWorldQuaternion = new THREE.Quaternion();
-    
-    this.mesh.getWorldPosition(muzzlePosition);
-    this.mesh.getWorldQuaternion(meshWorldQuaternion);
-    
-    muzzleOffset.applyQuaternion(meshWorldQuaternion);
-    muzzlePosition.add(muzzleOffset);
-
-    flashGroup.position.copy(muzzlePosition);
-    flashGroup.quaternion.copy(meshWorldQuaternion);
-
-    this.scene.add(flashGroup);
-
-    // 이펙트 지속 시간 증가
-    setTimeout(() => {
-        this.scene.remove(flashGroup);
-    }, 500);
-}
-
-
     async initialize(loader) {
         try {
             const modelPath = this.type === 'tank' ? '/models/t90.glb' : '/models/t90.glb';
@@ -661,107 +626,189 @@ class Enemy {
         }
     }
 
-    update(playerPosition) {
-    if (!this.mesh || !this.isLoaded) return;
+    checkLineOfSight(playerPosition) {
+        if (!this.mesh) return false;
 
-    const direction = new THREE.Vector3()
-        .subVectors(playerPosition, this.mesh.position)
-        .normalize();
-    
-    const distanceToPlayer = this.mesh.position.distanceTo(playerPosition);
-    const minDistance = 50;
-    
-    // 이전 위치 저장
-    const previousPosition = this.mesh.position.clone();
-    
-    if (distanceToPlayer > minDistance) {
-        const moveVector = direction.multiplyScalar(this.moveSpeed);
-        const newPosition = this.mesh.position.clone().add(moveVector);
-        
-        // 지형 높이 가져오기
-        const heightAtNewPos = window.gameInstance.getHeightAtPosition(
-            newPosition.x,
-            newPosition.z
-        );
-        newPosition.y = heightAtNewPos + TANK_HEIGHT;
-        
-        // 임시로 위치 이동하여 충돌 체크
-        const originalPosition = this.mesh.position.clone();
-        this.mesh.position.copy(newPosition);
-        
-        // 장애물과 충돌 체크
-        const enemyBox = new THREE.Box3().setFromObject(this.mesh);
-        let hasCollision = false;
-        
-        // 모든 장애물에 대해 충돌 검사
-        for (const obstacle of window.gameInstance.obstacles) {
-            const obstacleBox = new THREE.Box3().setFromObject(obstacle);
-            if (enemyBox.intersectsBox(obstacleBox)) {
-                hasCollision = true;
-                break;
+        const startPos = this.mesh.position.clone();
+        startPos.y += 2; // 탱크 포탑 높이
+        const direction = new THREE.Vector3().subVectors(playerPosition, startPos).normalize();
+        const distance = startPos.distanceTo(playerPosition);
+
+        const raycaster = new THREE.Raycaster(startPos, direction, 0, distance);
+        const intersects = raycaster.intersectObjects(window.gameInstance.obstacles, true);
+
+        return intersects.length === 0;
+    }
+
+    updateAIState(playerPosition) {
+        const currentTime = Date.now();
+        const distanceToPlayer = this.mesh.position.distanceTo(playerPosition);
+
+        // 시야 체크
+        if (currentTime - this.aiState.lastVisibilityCheck > this.aiState.visibilityCheckInterval) {
+            this.aiState.canSeePlayer = this.checkLineOfSight(playerPosition);
+            this.aiState.lastVisibilityCheck = currentTime;
+
+            if (this.aiState.canSeePlayer) {
+                this.aiState.lastKnownPlayerPosition = playerPosition.clone();
+                this.aiState.searchStartTime = null;
             }
         }
-        
-        // 다른 적 탱크와의 충돌 검사
-        if (!hasCollision) {
-            for (const otherEnemy of window.gameInstance.enemies) {
-                if (otherEnemy !== this && otherEnemy.mesh) {
-                    const otherEnemyBox = new THREE.Box3().setFromObject(otherEnemy.mesh);
-                    if (enemyBox.intersectsBox(otherEnemyBox)) {
-                        hasCollision = true;
-                        break;
-                    }
-                }
+
+        // AI 상태 업데이트
+        if (currentTime - this.aiState.lastStateChange > this.aiState.stateChangeCooldown) {
+            if (this.health < 30) {
+                this.aiState.mode = 'retreat';
+            } else if (distanceToPlayer < 30 && this.aiState.canSeePlayer) {
+                this.aiState.mode = 'flank';
+            } else {
+                this.aiState.mode = 'pursue';
             }
+            this.aiState.lastStateChange = currentTime;
         }
-        
-        // 맵 경계 체크
-        const mapBoundary = MAP_SIZE / 2;
-        if (Math.abs(newPosition.x) > mapBoundary || 
-            Math.abs(newPosition.z) > mapBoundary) {
-            hasCollision = true;
+    }
+
+    findPathToTarget(targetPosition) {
+        const currentTime = Date.now();
+        if (currentTime - this.pathfinding.lastPathUpdate < this.pathfinding.pathUpdateInterval) {
+            return;
         }
+
+        // 간단한 A* 경로 찾기 구현
+        const start = this.mesh.position.clone();
+        const end = targetPosition.clone();
         
-        // 충돌이 있으면 이전 위치로 복귀, 없으면 새 위치 유지
-        if (hasCollision) {
-            this.mesh.position.copy(previousPosition);
-            
-            // 충돌 시 우회 경로 시도
-            const alternateDirections = [
-                new THREE.Vector3(-direction.z, 0, direction.x), // 왼쪽으로 90도
-                new THREE.Vector3(direction.z, 0, -direction.x), // 오른쪽으로 90도
-                new THREE.Vector3(-direction.x, 0, -direction.z)  // 180도 회전
-            ];
-            
-            for (const altDirection of alternateDirections) {
-                const altMoveVector = altDirection.multiplyScalar(this.moveSpeed);
-                const altNewPosition = previousPosition.clone().add(altMoveVector);
-                
-                this.mesh.position.copy(altNewPosition);
-                const altEnemyBox = new THREE.Box3().setFromObject(this.mesh);
-                
-                let altHasCollision = false;
-                
-                // 새로운 방향에 대한 충돌 검사
-                for (const obstacle of window.gameInstance.obstacles) {
-                    const obstacleBox = new THREE.Box3().setFromObject(obstacle);
-                    if (altEnemyBox.intersectsBox(obstacleBox)) {
-                        altHasCollision = true;
-                        break;
-                    }
-                }
-                
-                if (!altHasCollision) {
-                    // 우회 경로가 가능하면 그 방향으로 이동
-                    break;
-                } else {
-                    // 우회도 불가능하면 이전 위치로 복귀
-                    this.mesh.position.copy(previousPosition);
-                }
+        // 장애물을 고려한 경로점 생성
+        this.pathfinding.currentPath = this.generatePathPoints(start, end);
+        this.pathfinding.lastPathUpdate = currentTime;
+    }
+
+    generatePathPoints(start, end) {
+        const points = [];
+        const direction = new THREE.Vector3().subVectors(end, start).normalize();
+        const distance = start.distanceTo(end);
+        const steps = Math.ceil(distance / 10);
+
+        for (let i = 0; i <= steps; i++) {
+            const point = start.clone().add(direction.multiplyScalar(i * 10));
+            points.push(point);
+        }
+
+        return points;
+    }
+
+    moveAlongPath() {
+        if (this.pathfinding.currentPath.length === 0) return;
+
+        const targetPoint = this.pathfinding.currentPath[0];
+        const direction = new THREE.Vector3()
+            .subVectors(targetPoint, this.mesh.position)
+            .normalize();
+
+        // 장애물 감지 및 회피
+        if (this.detectObstacle(direction)) {
+            if (!this.pathfinding.isAvoidingObstacle) {
+                this.pathfinding.isAvoidingObstacle = true;
+                this.pathfinding.avoidanceDirection = this.calculateAvoidanceDirection(direction);
             }
+            direction.copy(this.pathfinding.avoidanceDirection);
+        } else {
+            this.pathfinding.isAvoidingObstacle = false;
+        }
+
+        // 이동 적용
+        const moveVector = direction.multiplyScalar(this.moveSpeed);
+        this.mesh.position.add(moveVector);
+
+        // 경로점에 도달했는지 확인
+        if (this.mesh.position.distanceTo(targetPoint) < 2) {
+            this.pathfinding.currentPath.shift();
         }
+    }
+
+    detectObstacle(direction) {
+        const raycaster = new THREE.Raycaster(
+            this.mesh.position,
+            direction,
+            0,
+            this.pathfinding.obstacleCheckDistance
+        );
+        const intersects = raycaster.intersectObjects(window.gameInstance.obstacles, true);
+        return intersects.length > 0;
+    }
+
+    calculateAvoidanceDirection(currentDirection) {
+        const left = new THREE.Vector3(-currentDirection.z, 0, currentDirection.x);
+        const right = new THREE.Vector3(currentDirection.z, 0, -currentDirection.x);
+
+        // 왼쪽과 오른쪽 방향 중 장애물이 없는 방향 선택
+        if (!this.detectObstacle(left)) return left;
+        if (!this.detectObstacle(right)) return right;
+        
+        // 둘 다 막혀있으면 뒤로
+        return currentDirection.multiplyScalar(-1);
+    }
+
+    update(playerPosition) {
+        if (!this.mesh || !this.isLoaded) return;
+
+        this.updateAIState(playerPosition);
         
-        // 지형에 따른 기울기 조정
+        let targetPosition = playerPosition;
+        if (!this.aiState.canSeePlayer && this.aiState.lastKnownPlayerPosition) {
+            targetPosition = this.aiState.lastKnownPlayerPosition;
+        }
+
+        // AI 모드에 따른 행동
+        switch (this.aiState.mode) {
+            case 'pursue':
+                this.findPathToTarget(targetPosition);
+                this.moveAlongPath();
+                break;
+
+            case 'flank':
+                const flankPosition = this.calculateFlankPosition(playerPosition);
+                this.findPathToTarget(flankPosition);
+                this.moveAlongPath();
+                break;
+
+            case 'retreat':
+                const retreatPosition = this.calculateRetreatPosition(playerPosition);
+                this.findPathToTarget(retreatPosition);
+                this.moveAlongPath();
+                break;
+        }
+
+        // 총알 업데이트
+        this.updateBullets();
+
+        // 플레이어가 시야에 있으면 발사
+        if (this.aiState.canSeePlayer) {
+            this.shoot(playerPosition);
+        }
+
+        // 지형에 따른 탱크 기울기 조정
+        this.adjustTankTilt();
+    }
+
+    calculateFlankPosition(playerPosition) {
+        const angle = Math.random() * Math.PI * 2;
+        const radius = 40;
+        return new THREE.Vector3(
+            playerPosition.x + Math.cos(angle) * radius,
+            playerPosition.y,
+            playerPosition.z + Math.sin(angle) * radius
+        );
+    }
+
+    calculateRetreatPosition(playerPosition) {
+        const direction = new THREE.Vector3()
+            .subVectors(this.mesh.position, playerPosition)
+            .normalize();
+        return this.mesh.position.clone().add(direction.multiplyScalar(50));
+    }
+
+    adjustTankTilt() {
         const forwardVector = new THREE.Vector3(0, 0, 1).applyQuaternion(this.mesh.quaternion);
         const rightVector = new THREE.Vector3(1, 0, 0).applyQuaternion(this.mesh.quaternion);
         
@@ -785,21 +832,15 @@ class Enemy {
         const pitch = Math.atan2(frontHeight - backHeight, 2);
         const roll = Math.atan2(rightHeight - leftHeight, 2);
         
-        // 현재 회전 유지하면서 기울기만 적용
         const currentRotation = this.mesh.rotation.y;
         this.mesh.rotation.set(pitch, currentRotation, roll);
     }
-    
-    // 플레이어를 향해 포탑 회전
-    this.mesh.lookAt(playerPosition);
-    
-    // 총알 업데이트
-    if (this.bullets) {
+
+    updateBullets() {
         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 / 2 || 
                 Math.abs(bullet.position.z) > MAP_SIZE / 2) {
                 this.scene.remove(bullet);
@@ -807,7 +848,6 @@ class Enemy {
                 continue;
             }
             
-            // 총알과 장애물 충돌 체크
             const bulletBox = new THREE.Box3().setFromObject(bullet);
             for (const obstacle of window.gameInstance.obstacles) {
                 const obstacleBox = new THREE.Box3().setFromObject(obstacle);
@@ -819,72 +859,116 @@ class Enemy {
             }
         }
     }
-}
 
+    createMuzzleFlash() {
+        if (!this.mesh) return;
+        
+        const flashGroup = new THREE.Group();
+        
+        const flameGeometry = new THREE.SphereGeometry(1.0, 8, 8);
+        const flameMaterial = new THREE.MeshBasicMaterial({
+            color: 0xffa500,
+            transparent: true,
+            opacity: 0.8
+        });
+        const flame = new THREE.Mesh(flameGeometry, flameMaterial);
+        flame.scale.set(2, 2, 3);
+        flashGroup.add(flame);
+
+        const smokeGeometry = new THREE.SphereGeometry(0.8, 8, 8);
+        const smokeMaterial = new THREE.MeshBasicMaterial({
+            color: 0x555555,
+            transparent: true,
+            opacity: 0.5
+        });
+        
+        for (let i = 0; i < 5; i++) {
+            const smoke = new THREE.Mesh(smokeGeometry, smokeMaterial);
+            smoke.position.set(
+                Math.random() * 1 - 0.5,
+                Math.random() * 1 - 0.5,
+                -1 - Math.random()
+            );
+            smoke.scale.set(1.5, 1.5, 1.5);
+            flashGroup.add(smoke);
+        }
+
+        const muzzleOffset = new THREE.Vector3(0, 0.5, 4);
+        const muzzlePosition = new THREE.Vector3();
+        const meshWorldQuaternion = new THREE.Quaternion();
+        
+        this.mesh.getWorldPosition(muzzlePosition);
+        this.mesh.getWorldQuaternion(meshWorldQuaternion);
+        
+        muzzleOffset.applyQuaternion(meshWorldQuaternion);
+        muzzlePosition.add(muzzleOffset);
+
+        flashGroup.position.copy(muzzlePosition);
+        flashGroup.quaternion.copy(meshWorldQuaternion);
+
+        this.scene.add(flashGroup);
+
+        setTimeout(() => {
+            this.scene.remove(flashGroup);
+        }, 500);
+    }
 
     shoot(playerPosition) {
-    const currentTime = Date.now();
-    const attackInterval = this.type === 'tank' ? 
-        ENEMY_CONFIG.ATTACK_INTERVAL : 
-        ENEMY_CONFIG.ATTACK_INTERVAL * 1.5;
+        const currentTime = Date.now();
+        const attackInterval = this.type === 'tank' ? 
+            ENEMY_CONFIG.ATTACK_INTERVAL : 
+            ENEMY_CONFIG.ATTACK_INTERVAL * 1.5;
 
-    if (currentTime - this.lastAttackTime < attackInterval) return;
+        if (currentTime - this.lastAttackTime < attackInterval) return;
 
-    // 발사 이펙트 생성
-    this.createMuzzleFlash();
+        this.createMuzzleFlash();
 
-    // 발사 사운드 재생
-    const enemyFireSound = new Audio('sounds/mbtfire5.ogg');
-    enemyFireSound.volume = 0.3;
-    enemyFireSound.play();
+        const enemyFireSound = new Audio('sounds/mbtfire5.ogg');
+        enemyFireSound.volume = 0.3;
+        enemyFireSound.play();
 
-    // 포탄 생성 (플레이어와 유사하게 수정)
-    const bulletGeometry = new THREE.CylinderGeometry(0.2, 0.2, 2, 8);
-    const bulletMaterial = new THREE.MeshBasicMaterial({ 
-        color: 0xff0000,  // 빨간색 포탄
-        emissive: 0xff0000,
-        emissiveIntensity: 0.5
-    });
-    const bullet = new THREE.Mesh(bulletGeometry, bulletMaterial);
+        const bulletGeometry = new THREE.CylinderGeometry(0.2, 0.2, 2, 8);
+        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.5, 4);
-    const muzzlePosition = new THREE.Vector3();
-    this.mesh.getWorldPosition(muzzlePosition);
-    muzzleOffset.applyQuaternion(this.mesh.quaternion);
-    muzzlePosition.add(muzzleOffset);
-    
-    bullet.position.copy(muzzlePosition);
-    
-    // 포탄 회전 설정
-    bullet.quaternion.copy(this.mesh.quaternion);
-    
-    const direction = new THREE.Vector3()
-        .subVectors(playerPosition, muzzlePosition)
-        .normalize();
-    
-    const bulletSpeed = this.type === 'tank' ? 
-        ENEMY_CONFIG.BULLET_SPEED : 
-        ENEMY_CONFIG.BULLET_SPEED * 0.8;
-    
-    bullet.velocity = direction.multiplyScalar(bulletSpeed);
-    
-    // 포탄 트레일 효과 추가
-    const trailGeometry = new THREE.CylinderGeometry(0.1, 0.1, 1, 8);
-    const trailMaterial = new THREE.MeshBasicMaterial({
-        color: 0xff4444,
-        transparent: true,
-        opacity: 0.5
-    });
-    
-    const trail = new THREE.Mesh(trailGeometry, trailMaterial);
-    trail.position.z = -1;
-    bullet.add(trail);
-    
-    this.scene.add(bullet);
-    this.bullets.push(bullet);
-    this.lastAttackTime = currentTime;
-}
+        const muzzleOffset = new THREE.Vector3(0, 0.5, 4);
+        const muzzlePosition = new THREE.Vector3();
+        this.mesh.getWorldPosition(muzzlePosition);
+        muzzleOffset.applyQuaternion(this.mesh.quaternion);
+        muzzlePosition.add(muzzleOffset);
+        
+        bullet.position.copy(muzzlePosition);
+        bullet.quaternion.copy(this.mesh.quaternion);
+        
+        const direction = new THREE.Vector3()
+            .subVectors(playerPosition, muzzlePosition)
+            .normalize();
+        
+        const bulletSpeed = this.type === 'tank' ? 
+            ENEMY_CONFIG.BULLET_SPEED : 
+            ENEMY_CONFIG.BULLET_SPEED * 0.8;
+        
+        bullet.velocity = direction.multiplyScalar(bulletSpeed);
+        
+        const trailGeometry = new THREE.CylinderGeometry(0.1, 0.1, 1, 8);
+        const trailMaterial = new THREE.MeshBasicMaterial({
+            color: 0xff4444,
+            transparent: true,
+            opacity: 0.5
+        });
+        
+        const trail = new THREE.Mesh(trailGeometry, trailMaterial);
+        trail.position.z = -1;
+        bullet.add(trail);
+        
+        this.scene.add(bullet);
+        this.bullets.push(bullet);
+        this.lastAttackTime = currentTime;
+    }
 
     takeDamage(damage) {
         this.health -= damage;