Update game.js

game.js

@@ -732,119 +732,111 @@ class Enemy {
 
     // 메인 업데이트 함수
     update(playerPosition) {
-        if (!this.mesh || !this.isLoaded) return;
+    if (!this.mesh || !this.isLoaded) return;
 
-        // AI 상태 업데이트
-        this.updateAIState(playerPosition);
+    // AI 상태 업데이트
+    this.updateAIState(playerPosition);
 
-        // 장애물 감지
-        const obstacles = this.detectObstacles();
-        const currentTime = Date.now();
-        const hasLineOfSight = this.checkLineOfSight(playerPosition);
-        const distanceToPlayer = this.mesh.position.distanceTo(playerPosition);
-        // 경로 업데이트 주기 체크
-        if (currentTime - this.lastPathUpdateTime > this.pathUpdateInterval) {
-            if (!hasLineOfSight) {
-                this.alternativePath = this.findAlternativePath(playerPosition);
-            }
-            this.lastPathUpdateTime = currentTime;
-        }
-        if (!hasLineOfSight) {
-            if (this.alternativePath) {
-                const pathDirection = new THREE.Vector3()
-                    .subVectors(this.alternativePath, this.mesh.position)
-                    .normalize();
-                this.mesh.position.add(pathDirection.multiplyScalar(this.moveSpeed));
-
-                const targetRotation = Math.atan2(pathDirection.x, pathDirection.z);
-                this.mesh.rotation.y = this.smoothRotation(this.mesh.rotation.y, targetRotation, 0.1);
-            }
-        } else {
-            this.alternativePath = null;
-
-            // 거리에 따른 행동 결정
-            if (distanceToPlayer > ENEMY_CONFIG.ATTACK_RANGE * 0.7) {
-                const moveDirection = new THREE.Vector3()
-                    .subVectors(playerPosition, this.mesh.position)
-                    .normalize();
-                this.mesh.position.add(moveDirection.multiplyScalar(this.moveSpeed));
-            } else if (distanceToPlayer < ENEMY_CONFIG.ATTACK_RANGE * 0.3) {
-                const retreatDirection = new THREE.Vector3()
-                    .subVectors(this.mesh.position, playerPosition)
-                    .normalize();
-                this.mesh.position.add(retreatDirection.multiplyScalar(this.moveSpeed));
-            }
-
-            // 플레이어 방향으로 회전
-            const directionToPlayer = new THREE.Vector3()
-                .subVectors(playerPosition, this.mesh.position)
-                .normalize();
-            const targetRotation = Math.atan2(directionToPlayer.x, directionToPlayer.z);
-            this.mesh.rotation.y = this.smoothRotation(this.mesh.rotation.y, targetRotation, 0.1);
+    // 장애물 감지 및 시야 체크
+    const obstacles = this.detectObstacles();
+    const currentTime = Date.now();
+    const hasLineOfSight = this.checkLineOfSight(playerPosition);
+    const distanceToPlayer = this.mesh.position.distanceTo(playerPosition);
 
-            // 공격 조건 확인
-            if (hasLineOfSight && distanceToPlayer <= ENEMY_CONFIG.ATTACK_RANGE) {
-                this.shoot(playerPosition);
-            }
+    // 경로 업데이트 주기 체크
+    if (currentTime - this.lastPathUpdateTime > this.pathUpdateInterval) {
+        if (!hasLineOfSight) {
+            this.alternativePath = this.findAlternativePath(playerPosition);
         }
+        this.lastPathUpdateTime = currentTime;
     }
-}
 
-        
-        // 이동 및 회피 로직
-        if (obstacles.length > 0 && !this.pathfinding.isAvoidingObstacle) {
-            this.pathfinding.isAvoidingObstacle = true;
-            this.pathfinding.avoidanceDirection = this.calculateAvoidanceDirection(obstacles);
-            this.pathfinding.avoidanceTime = 0;
-        }
+    // 장애물 회피 로직
+    if (obstacles.length > 0 && !this.pathfinding.isAvoidingObstacle) {
+        this.pathfinding.isAvoidingObstacle = true;
+        this.pathfinding.avoidanceDirection = this.calculateAvoidanceDirection(obstacles);
+        this.pathfinding.avoidanceTime = 0;
+    }
 
-        // 회피 동작 수행
-        if (this.pathfinding.isAvoidingObstacle) {
-            this.pathfinding.avoidanceTime += 16; // 약 16ms per frame
-            if (this.pathfinding.avoidanceTime >= this.pathfinding.maxAvoidanceTime) {
-                this.pathfinding.isAvoidingObstacle = false;
-            } else {
-                const avoidMove = this.pathfinding.avoidanceDirection.multiplyScalar(this.moveSpeed);
-                this.mesh.position.add(avoidMove);
-            }
+    // 이동 로직 실행
+    if (this.pathfinding.isAvoidingObstacle) {
+        // 회피 동작
+        this.pathfinding.avoidanceTime += 16;
+        if (this.pathfinding.avoidanceTime >= this.pathfinding.maxAvoidanceTime) {
+            this.pathfinding.isAvoidingObstacle = false;
         } else {
-            // 일반 이동 로직
-            switch (this.aiState.mode) {
-                case 'pursue':
-                    this.findPathToTarget(playerPosition);
-                    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;
-            }
+            const avoidMove = this.pathfinding.avoidanceDirection.multiplyScalar(this.moveSpeed);
+            this.mesh.position.add(avoidMove);
         }
+    } else if (!hasLineOfSight) {
+        // 시야가 없을 때의 이동
+        if (this.alternativePath) {
+            const pathDirection = new THREE.Vector3()
+                .subVectors(this.alternativePath, this.mesh.position)
+                .normalize();
+            this.mesh.position.add(pathDirection.multiplyScalar(this.moveSpeed));
 
-        // 전투 거리 조정
-        const combatMove = this.maintainCombatDistance(playerPosition);
-        if (combatMove.length() > 0) {
-            this.mesh.position.add(combatMove.multiplyScalar(this.moveSpeed));
+            const targetRotation = Math.atan2(pathDirection.x, pathDirection.z);
+            this.mesh.rotation.y = this.smoothRotation(this.mesh.rotation.y, targetRotation, 0.1);
         }
+    } else {
+        // 시야가 있을 때의 이동
+        this.alternativePath = null;
 
-        // 발사 처리
-        if (this.canShoot(playerPosition)) {
-            this.shoot(playerPosition);
+        // AI 상태에 따른 이동
+        switch (this.aiState.mode) {
+            case 'pursue':
+                if (distanceToPlayer > ENEMY_CONFIG.ATTACK_RANGE * 0.7) {
+                    const moveDirection = new THREE.Vector3()
+                        .subVectors(playerPosition, this.mesh.position)
+                        .normalize();
+                    this.mesh.position.add(moveDirection.multiplyScalar(this.moveSpeed));
+                }
+                break;
+
+            case 'flank':
+                const flankPosition = this.calculateFlankPosition(playerPosition);
+                this.findPathToTarget(flankPosition);
+                this.moveAlongPath();
+                break;
+
+            case 'retreat':
+                if (distanceToPlayer < ENEMY_CONFIG.ATTACK_RANGE * 0.3) {
+                    const retreatDirection = new THREE.Vector3()
+                        .subVectors(this.mesh.position, playerPosition)
+                        .normalize();
+                    this.mesh.position.add(retreatDirection.multiplyScalar(this.moveSpeed));
+                }
+                break;
         }
 
-        // 총알 업데이트
-        this.updateBullets();
+        // 플레이어 방향으로 회전
+        const directionToPlayer = new THREE.Vector3()
+            .subVectors(playerPosition, this.mesh.position)
+            .normalize();
+        const targetRotation = Math.atan2(directionToPlayer.x, directionToPlayer.z);
+        this.mesh.rotation.y = this.smoothRotation(this.mesh.rotation.y, targetRotation, 0.1);
+    }
 
-        // 탱크 기울기 조정
-        this.adjustTankTilt();
+    // 전투 거리 조정
+    const combatMove = this.maintainCombatDistance(playerPosition);
+    if (combatMove.length() > 0) {
+        this.mesh.position.add(combatMove.multiplyScalar(this.moveSpeed));
     }
-    checkLineOfSight(targetPosition) {
+
+    // 공격 처리
+    if (hasLineOfSight && distanceToPlayer <= ENEMY_CONFIG.ATTACK_RANGE && this.canShoot(playerPosition)) {
+        this.shoot(playerPosition);
+    }
+
+    // 총알 업데이트
+    this.updateBullets();
+
+    // 탱크 기울기 조정
+    this.adjustTankTilt();
+}
+
+checkLineOfSight(targetPosition) {
     if (!this.mesh) return false;
 
     const startPos = this.mesh.position.clone();