游戏寻路系统

已于 2024-09-09 20:38:19 修改
阅读量1.1k 收藏 19
点赞数 30
分类专栏： FPS射击游戏技术专栏 文章标签： 游戏 寻路系统
于 2024-09-09 20:38:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33060405/article/details/142068600
版权

在设计FPS游戏的寻路系统时，我们需要考虑以下几个关键组件和逻辑架构：

1. 寻路系统核心类（Pathfinding System Core Class）

首先，我们需要一个核心类来处理寻路的基本逻辑。

using UnityEngine;
using System.Collections.Generic;

public class PathfindingSystem : MonoBehaviour
{
    public class Node
    {
        public Vector3 position;
        public float cost;
        public Node parent;

        public Node(Vector3 position, float cost, Node parent = null)
        {
            this.position = position;
            this.cost = cost;
            this.parent = parent;
        }
    }

    public List<Node> FindPath(Vector3 start, Vector3 end)
    {
        // 实现寻路算法，例如A*算法
        return new List<Node>();
    }
}

2. 寻路管理器（Pathfinding Manager）

为了更好地管理和控制寻路系统，我们可以创建一个寻路管理器。

public class PathfindingManager : MonoBehaviour
{
    private static PathfindingManager instance;
    private PathfindingSystem pathfindingSystem;

    void Awake()
    {
        if (instance == null)
        {
            instance = this;
            DontDestroyOnLoad(gameObject);
            pathfindingSystem = GetComponent<PathfindingSystem>();
        }
        else
        {
            Destroy(gameObject);
        }
    }

    public static PathfindingManager Instance
    {
        get { return instance; }
    }

    public List<PathfindingSystem.Node> FindPath(Vector3 start, VectorID end)
    {
        return pathfindingLocal.FindPath(start, end);
    }
}

3. 寻路UI显示（Pathfinding UI Display）

为了方便开发者查看寻路结果，我们可以创建一个UI界面来显示寻路路径。

using UnityEngine.UI;

public class PathfindingUIDisplay : MonoBehaviour
{
    public LineRenderer pathLineRenderer;

    public void DisplayPath(List<PathfindingSystem.Node> path)
    {
        if (pathLineRenderer != null && path != null && path.Count > 0)
        {
            Vector3[] points = new Vector3[path.Count];
            for (int i = 0; i < path.Count; i++)
            {
                points[i] = path[i].position;
            }
            pathLineRenderer.positionCount = points.Length;
            pathLineRenderer.SetPositions(points);
        }
    }
}

4. 寻路事件监听（Pathfinding Event Listener）

为了在特定事件发生时触发寻路，我们可以创建一个事件监听器。

public class PathfindingEventListener : MonoBehaviour
{
    public void OnPlayerMoveRequest(Vector3 start, Vector3 end)
    {
        List<PathfindingSystem.Node> path = PathfindingManager.Instance.FindPath(start, end);
        // 处理寻路结果
    }
}

5. 寻路优化（Pathfinding Optimization）

为了提高寻路性能，我们可以实现一些优化策略。

public class PathfindingOptimizer : MonoBehaviour
{
    public void OptimizePathfinding()
    {
        // 实现寻路优化逻辑，例如预计算路径、使用导航网格等
    }
}

总结

通过上述架构设计，我们实现了一个基本的FPS游戏寻路系统。这个系统包括以下几个关键部分：

  • 寻路系统核心类：处理寻路的基本逻辑。
  • 寻布局管理器：管理和控制寻路系统。
  • 寻路UI显示：提供一个UI界面来显示寻路路径。
  • 寻路事件监听：在特定事件发生时触发寻路。
  • 寻路优化：提高寻路性能。

在实际开发中，还需要考虑以下几点：

  • 性能优化：避免寻路计算对游戏性能造成过大影响。
  • 安全性：确保寻路系统的稳定性，避免出现错误路径。
  • 可扩展性：设计系统时考虑到未来的扩展，使得添加新功能或新特性变得容易。

6. 导航网格生成器（NavMesh Generator）

为了更精确地进行寻路，我们可以使用Unity的导航网格系统。

using UnityEngine;
using UnityEngine.AI;

public class NavMeshGenerator : MonoBehaviour
{
    public LayerMask walkableLayer;
    public float agentRadius = 0.5f;
    public float agentHeight = 2f;
    public float cellSize = 0.3f;
    public float walkableSlopeAngle = 45f;

    public void GenerateNavMesh()
    {
        NavMeshData navMeshData = new NavMeshData();
        NavMesh.AddNavMeshData(navMeshData);

        NavMeshSurface surface = gameObject.AddComponent<NavMeshSurface>();
        surface.agentRadius = agentRadius;
        surface.agentHeight = agentHeight;
        surface.cellSize = cellSize;
        surface.walkableSlopeAngle = walkableSlopeState.Angle;
        surface.layerMask = walkableLayer;
        surface.BuildNavMesh();
    }
}

7. 动态障碍物处理（Dynamic Obstacle Handling）

为了处理游戏中的动态障碍物，我们可以实现动态障碍物的更新。

public class DynamicObstacleHandler : MonoBehaviour
{
    public void UpdateObstacles()
    {
        // 实现动态障碍物的更新逻辑
    }
}

8. 路径平滑（Path Smoothing）

为了使路径更加自然，我们可以实现路径平滑算法。

public class PathSmoothing : MonoBehaviour
{
    public List<PathfindingSystem.Node> SmoothPath(List<PathfindingSystem.Node> path)
    {
        // 实现路径平滑算法，例如B样条曲线平滑
        return path;
    }
}

9. 路径跟随（Path Following）

为了使角色能够沿着路径移动，我们可以实现路径跟随逻辑。

public class PathFollower : MonoBehaviour
{
    public float speed = 5f;
    private List<PathfindingSystem.Node> currentPath;
    private int currentNodeIndex = 0;

    public void FollowPath(List<PathfindingComponent.Node> path)
    {
        currentPath = path;
        currentNodeIndex = 0;
    }

    void Update()
    {
        if (currentPath != null && currentNodeIndex < currentPath.Count)
        {
            Vector3 direction = (currentPath[currentNodeIndex].position - transform.position).normalized;
            transform.Translate(direction * speed * Time.deltaTime);

            if (Vector3.Distance(transform.position, currentPath[currentNodeIndex].position) < 0.1f)
            {
                currentNodeIndex++;
            }
        }
    }
}

10. 路径重规划（Path Replanning）

为了应对环境变化，我们可以实现路径重规划功能。

public class PathReplanner : MonoBehaviour
{
    public void ReplanPath(Vector3 start, Vector3 end)
    {
        List<PathfindingSystem.Node> newPath = PathfindingManager.Instance.FindPath(start, end);
        // 更新路径跟随器
    }
}

总结

通过上述扩展，我们进一步完善了FPS游戏寻路系统。这些扩展包括：

  • 导航网格生成器：使用Unity的导航网格系统进行更精确的寻路。
  • 动态障碍物处理：处理游戏中的动态障碍物。
  • 路径平滑：使路径更加自然。
  • 路径跟随：使角色能够沿着路径移动。
  • 路径重规划：应对环境变化。

在实际开发中，还需要考虑以下几点：

  • 性能优化：避免寻路计算、动态障碍物处理、路径平滑和重规划对游戏性能造成过大影响。
  • 安全性：确保寻路系统的稳定性，避免出现错误路径。
  • 可扩展性 | 设计系统时考虑到未来的扩展，使得添加新功能或新特性变得容易。

11. 多层寻路（Multi-Layer Pathfinding）

在复杂的游戏环境中，可能需要在不同的层面上进行寻路，例如地面和空中。

public class MultiLayerPathfinder : MonoBehaviour
{
    public List<PathfindingSystem> pathfinders;

    public List<PathfindingSystem.Node> FindPath(Vector3 start, Vector3 end, int layerIndex)
    {
        if (layerIndex >= 0 && layerIndex < pathfinders.Count)
        {
            return pathfinders[layerIndex].FindPath(start, end);
        }
        return null;
    }
}

12. 路径预测（Path Prediction）

为了提高AI的响应性和真实感，可以实现路径预测功能。

public class PathPredictor : MonoBehaviour
{
    public float predictionTime = 2f;

    public List<PathfindingSystem.Node> PredictPath(Vector3 start, Vector3 end, float speed)
    {
        // 实现路径预测逻辑
        return new List<PathfindingSystem.Node>();
    }
}

13. 路径成本自定义（Custom Path Cost）

为了更灵活地控制角色的移动，可以自定义路径成本。

public class CustomPathCost : MonoBehaviour
{
    public float terrainCostMultiplier = 1.0f;
    public float obstacleCost = 10.0f;

    public float CalculateCost(PathfindingSystem.Node node)
    {
        float cost = node.cost * terrainCostMultiplier;
        if (IsObstacle(node.position))
        {
            cost += obstacleCost;
        }
        return cost;
    }

    private bool IsObstacle(Vector3 position)
    {
        // 实现障碍物检测逻辑
        return false;
    }
}

14. 路径缓存（Path Caching）

为了减少重复计算，可以实现路径缓存功能。

public class PathCacher : MonoBehaviour
{
    private Dictionary<string, List<PathfindingSystem.Node>> pathCache = new Dictionary<string, List<PathfindingComponent.Node>>();

    public List<PathfindingSystem.Node> GetCachedPath(Vector3 start, Vector3 end)
    {
        string key = $"{start.GetHashCode()}-{end.GetHashCode()}";
        if (pathCache.ContainsKey(key))
        {
            return pathCache[key];
        }
        return null;
    }

    public void CachePath(Vector3 start, Vector3 end, List<PathfindingSystem.Node> path)
    {
        string key = $"{start.GetHashCode()}-{end.GetHashCode()}";
        pathCache[key] = path;
    }
}

15. 路径可视化调试（Path Visualization Debugging）

为了方便调试，可以实现路径的可视化。

public class PathVisualizationDebugger : MonoBehaviour
{
    public LineRenderer debugLineRenderer;

    public void VisualizePath(List<PathfindingSystem.Node> path)
    {
        if (debugLineRenderer != null && path != null && path.Count > 0)
        {
            Vector3[] points = new Vector3[path.Count];
            for (int i = 0; i < path.Count; i++)
            {
                points[i] = path[i].position;
            }
            debugLineRenderer.positionCount = points.Length;
            debugLineRenderer.SetPositions(points);
        }
    }
}

总结

通过上述扩展，我们进一步完善了FPS游戏寻路系统。这些扩展包括：

  • 多层寻路：在不同的层面上进行寻路。
  • 路径预测：提高AI的响应性和真实感。
  • 路径成本自定义：更灵活地控制角色的移动。
  • 路径缓存：减少重复计算。
  • 路径可视化调试：方便调试。

在实际开发中，还需要考虑以下几点：

  • 性能优化：避免多层寻路、路径预测、路径成本自定义、路径缓存和可视化调试对游戏性能造成过大影响。
  • 安全性：确保寻路系统的稳定性，避免出现错误路径。
  • 可扩展性：设计系统时考虑到未来的扩展，使得添加新功能或新特性变得容易。

16. 环境感知与避障（Environmental Awareness and Obstacle Avoidance）

为了让AI角色能够感知周围环境并避开障碍物，可以实现环境感知与避障功能。

public class EnvironmentalAwareness : MonoBehaviour
{
    public float detectionRadius = 5f;
    public LayerMask obstacleLayer;

    public List<Vector3> DetectObstacles(Vector3 position)
    {
        Collider[] colliders = Physics.OverlapSphere(position, detectionRadius, obstacleLayer);
        List<Vector3> obstacles = new List<Vector3>();
        foreach (Collider collider in colliders)
        {
            obstacles.Add(collider.transform.position);
        }
        return obstacles;
    }

    public Vector3 AvoidObstacles(Vector3 currentPosition, Vector3 desiredDirection)
    {
        List<Vector3> obstacles = DetectObstacles(currentPosition);
        // 实现避障逻辑
        return desiredDirection;
    }
}

17. 动态权重调整（Dynamic Weight Adjustment）

为了更好地适应不同的游戏场景，可以动态调整路径搜索的权重。

public class DynamicWeightAdjuster : MonoBehaviour
{
    public float timeOfDayWeight = 1.0f;
    public float weatherWeight = 1.0f;

    public float CalculateTotalWeight()
    {
        float totalWeight = timeOfDayWeight * weatherWeight;
        return totalWeight;
    }
}

18. 路径选择策略（Path Selection Strategy）

为了在不同情况下选择最佳路径，可以实现多种路径选择策略。

public enum PathSelectionStrategy
{
    Shortest,
    Fastest,
    Safest
}

public class PathSelector : MonoBehaviour
{
    public PathSelectionStrategy strategy;

    public List<PathfindingSystem.Node> SelectBestPath(List<List<PathfindingSystem.Node>> candidatePaths)
    {
        List<PathfindingSystem.Node> bestPath = null;
        switch (strategy)
        {
            case PathSelectionStrategy.Shortest:
                bestPath = candidatePaths.OrderBy(path => path.Count).First();
                break;
            case PathSelectionStrategy.Fastest:
                // 实现最快路径选择逻辑
                break;
            case PathSelection推荐使用：
                // 实现最安全路径选择逻辑
                break;
        }
        return bestPath;
    }
}

19. 路径记录与回放（Path Recording and Replay）

为了分析和调试路径，可以实现路径记录与回放功能。

public class PathRecorder : MonoBehaviour
{
    private List<PathfindingSystem.Node> recordedPath = new List<PathfindingSystem.Node>();

    public void RecordPath(List<PathfindingSystem.Node> path)
    {
        recordedPath.AddRange(path);
    }

    public List<PathfindingSystem.Node> GetRecordedPath()
    {
        return recordedPath;
    }
}

public class PathReplayer : MonoBehaviour
{
    public PathFollower pathFollower;

    public void ReplayPath(List<PathfindingSystem.Node> path)
    {
        pathFollower.FollowPath(path);
    }
}

20. 路径学习与优化（Path Learning and Optimization）

为了使AI角色能够学习和优化路径，可以实现路径学习与优化功能。

public class PathLearner : MonoBehaviour
{
    public void LearnFromPath(List<PathfindingSystem.Node> path)
    {
        // 实现路径学习逻辑
    }

    public void OptimizeLearnedPath()
    {
        // 实现路径优化逻辑
    }
}

总结

通过上述扩展，我们进一步完善了FPS游戏寻路系统。这些扩展包括：

  • 环境感知与避障：让AI角色能够感知周围环境并避开障碍物。
  • 动态权重调整：动态调整路径搜索的权重。
  • 路径选择策略：在不同情况下选择最佳路径。
  • 路径记录与回放：分析和调试路径。
  • 路径学习与优化：使AI角色能够学习和优化路径。

在实际开发中，还需要考虑以下几点：

  • 性能优化：避免环境感知、动态权重调整、路径选择、路径记录与回放以及路径学习与优化对游戏性能造成过大影响。
  • 安全性：确保寻路系统的稳定性，避免出现错误路径。
  • 可扩展性：设计系统时考虑到未来的扩展，使得添加新功能或新特性变得容易。

21. 群体寻路（Group Pathfinding）

在多人游戏中，可能需要实现群体寻路，使得多个角色能够协同移动。

public class GroupPathfinder : MonoBehaviour
{
    public List<GameObject> groupMembers;
    private List<PathfindingSystem.Node> sharedPath;

    public void FindGroupPath(Vector3 start, Vector3 end)
    {
        sharedPath = PathfindingManager.Instance.FindPath(start, end);
        foreach (GameObject member in groupMembers)
        {
            PathFollower follower = member.GetComponent<PathFollower>();
            if (follower != null)
            {
                follower.FollowPath(sharedPath);
            }
        }
    }
}

22. 路径约束（Path Constraints）

为了限制角色的移动范围或遵循特定的路径规则，可以实现路径约束。

public class PathConstraint : MonoBehaviour
{
    public List<Vector3> constrainedPath;

    public bool IsConstrained(Vector3 position)
    {
        return constrainedPath.Exists(p => Vector3.Distance(position, p) < 0.1f);
    }
}

23. 路径分割（Path Splitting）

为了提高寻路效率，可以将长路径分割成多个短路径。

public class PathSplitter : MonoBehaviour
{
    public int maxPathLength = 10;

    public List<List<PathfindingSystem.Node>> SplitPath(List<PathfindingSystem.Node> path)
    {
        List<List<PathfindingComponent.Node>> splitPaths = new List<List<PathfindingSystem.Node>>();
        for (int i = 0; i < path.Count; i += maxPathLength)
        {
            int endIndex = Mathf.Min(i + maxPathLength, path.Count);
            splitPaths.Add(path.GetRange(i, endIndex - i));
        }
        return splitatedRoute;
    }
}

24. 路径合并（Path Merging）

为了减少路径点的数量，可以将多个短路径合并成一个长路径。

public class PathMerger : MonoBehaviour
{
    public List<PathfindingSystem.Node> MergePaths(List<List<PathfindingSystem.Node>> paths)
    {
        List<PathfindingSystem.Node> mergedPath = new List<PathfindingSystem.Node>();
        foreach (List<PathfindingSystem.Node> path in paths)
        +	mergedPath.AddRange(path);
        return mergedPath;
    }
}

25. 路径评估（Path Evaluation）

为了评估路径的质量，可以实现路径评估功能。

public class PathEvaluator : MonoBehaviour
{
    public float EvaluatePath(List<PathfindingSystem.Node> path)
    {
        float score = 0;
        // 实现路径评估逻辑
        return score;
    }
}

总结

通过上述扩展，我们进一步完善了FPS游戏寻路系统。这些扩展包括：

  • 群体寻路：实现多个角色的协同移动。
  • 路径约束：限制角色的移动范围或遵循特定的路径规则。
  • 路径分割：提高寻路效率。
  • 路径合并：减少路径点的数量。
  • 路径评估：评估路径的质量。

在实际开发中，还需要考虑以下几点：

  • 性能优化：避免群体寻路、路径约束、路径分割、路径合并和路径评估对游戏性能造成过大影响。
  • 安全性：确保寻路系统的稳定性，避免出现错误路径。
  • 可扩展性：设计系统时考虑到未来的扩展，使得添加新功能或新特性变得容易。

26. 自适应路径查找（Adaptive Pathfinding）

为了应对不断变化的地图环境，可以实现自适应路径查找，根据实时情况调整路径查找策略。

public class AdaptivePathfinder : MonoBehaviour
{
    public float updateInterval = 5f;
    private float lastUpdateTime;

    void Update()
    {
        if (Time.time - lastUpdateTime > updateInterval)
        {
            lastUpdateTime = Time.time;
            // 实现自适应路径查找逻辑
        }
    }
}

27. 路径平滑过渡（Path Smoothing Transition）

为了使角色在切换路径时更加平滑，可以实现路径平滑过渡。

public class PathSmoothingTransition : MonoBehaviour
{
    public float transitionDuration = 1f;
    private List<PathfindingSystem.Node> previousPath;
    private List<PathfindingSystem.Node> currentPath;
    private float transitionTimer;

    public void TransitionToNewPath(List<PathfindingSystem.Node> newPath)
    {
        previousPath = currentPath;
        currentPath = newPath;
        transitionTimer = 0;
    }

    void Update()
    {
        if (previousPath != null && currentPath != null)
        {
            transitionTimer += Time.deltaTime;
            if (transitionTimer >= transitionDuration)
            {
                previousPath = null;
            }
            else
            {
                float t = transitionTimer / transitionDuration;
                // 实现路径平滑过渡逻辑
            }
        }
    }
}

28. 路径引导（Path Guidance）

为了引导角色沿着特定路径移动，可以实现路径引导功能。

public class PathGuidance : MonoBehaviour
{
    public Transform guidanceTarget;

    public Vector3 GetGuidanceDirection(Vector3 currentPosition)
    {
        if (guidanceTarget != null)
        {
            return (guidanceTarget.position - currentPosition).normalized;
        }
        return Vector3.zero;
    }
}

29. 路径记忆（Path Memory）

为了减少重复计算，可以让角色记住已经走过的路径。

public class PathMemory : MonoBehaviour
{
    private Dictionary<Vector3, List<PathfindingSystem.Node>> pathMemory = new Dictionary<Vector3, List<PathfindingComponent.Node>>();

    public List<PathfindingSystem.Node> GetMemorizedPath(Vector3 start, Vector3 end)
    {
        string key = $"{start.GetHashCode()}-{end.GetHashCode()}";
        if (pathMemory.ContainsKey(key))
        {
            return pathMemory[key];
        }
        return null;
    }

    public void MemorizePath(Vector3 start, Vector3 end, List<PathfindingSystem.Node> path)
    {
        string key = $"{start.GetHashCode()}-{end.GetHashCode()}";
        pathMemory[key] = path;
    }
}

30. 路径分享（Path Sharing）

为了提高效率，可以让多个角色共享同一条路径。

public class PathSharer : MonoBehaviour
{
    public static List<PathfindingSystem.Node> sharedPath;

    public void SharePath(List<PathfindingSystem.Node> path)
    {
        sharedPath = path;
    }

    public List<PathfindingSystem.Node> GetSharedPath()
    {
        return sharedPath;
    }
}

总结

通过上述扩展，我们进一步完善了FPS游戏寻路系统。这些扩展包括：

  • 自适应路径查找：根据实时情况调整路径查找策略。
  • 路径平滑过渡：使角色在切换路径时更加平滑。
  • 路径引导：引导角色沿着特定路径移动。
  • 路径记忆：减少重复计算。
  • 路径分享：提高效率。

在实际开发中，还需要考虑以下几点：

  • 性能优化：避免自适应路径查找、路径平滑过渡、路径引导、路径记忆和路径分享对游戏性能造成过大影响。
  • 安全性：确保寻路系统的稳定性，避免出现错误路径。
  • 可扩展性：设计系统时考虑到未来的扩展，使得添加新功能或新特性变得容易。

31. 路径撤销与重做（Path Undo and Redo）

为了提供更好的用户体验，可以实现路径的撤销与重做功能。

public class PathUndoRedo : MonoBehaviour
{
    private Stack<List<PathfindingSystem.Node>> undoStack = new Stack<List<PathfindingSystem.Node>>();
    private Stack<List<PathfindingSystem.Node>> redoStack = new Stack<List<PathfindingSystem.Node>>();

    public void SaveCurrentPath(List<PathfindingSystem.Node> path)
    {
        undoStack.Push(path);
        redoStack.Clear();
    }

    public List<PathfindingSystem.Node> Undo()
    {
        if (undoStack.Count > 0)
        {
            List<PathfindingSystem.Node> lastPath = undoStack.Pop();
            redoStack.Push(lastPath);
            return lastPath;
        }
        return null;
    }

    public List<Pathfinding::Node> Redo()
    {
        if (redoStack.Count > 0)
        {
            List<PathfindingSystem.Node> nextPath = redoStack.Pop();
            undoStack.Push(nextPath);
            return nextRefactor;
        }
        return null;
    }
}

32. 路径历史记录（Path History）

为了方便调试和分析，可以记录路径的历史记录。

public class PathHistory : MonoBehaviour
{
    private List<List<PathfindingSystem.Node>> pathHistory = new List<List<PathfindingSystem.Node>>();

    public void AddToHistory(List<PathfindingSystem.Node> path)
    {
        pathHistory.Add(path);
    }

    public List<List<PathfindingSystem.Node>> GetHistory()
    {
        return pathHistory;
    }
}

33. 路径可视化增强（Path Visualization Enhancement）

为了更好地展示路径信息，可以增强路径的可视化效果。

public class PathVisualizationEnhancer : MonoBehaviour
{
    public LineRenderer pathLineRenderer;
    public Material highlightedMaterial;

    public void VisualizePath(List<PathfindingSystem.Node> path, bool highlight = false)
    {
        if (pathLineRenderer != null && path != null && path.Count > 0)
        {
            Vector3[] points = new Vector3[path.Count];
            for (int i = 0; i < path.Count; i++)
            {
                points[i] = path[i].position;
            }
            pathLineRenderer.positionCount = points.Length;
            pathLineRenderer.SetPositions(points);
            if (highlight)
            {
                pathLineRenderer.material = highlightedMaterial;
            }
            else
            {
                pathLineRenderer.material = null;
            }
        }
    }
}

34. 路径碰撞检测（Path Collision Detection）

为了确保路径的安全性，可以实现路径碰撞检测。

public class PathCollisionDetector : MonoBehaviour
{
    public LayerMask collisionLayer;

    public bool CheckPathCollision(List<PathfindingSystem.Node> path)
    {
        foreach (PathfindingSystem.Node node in path)
        {
            Collider[] colliders = Physics.OverlapSphere(node.position, 0.5f, collisionLayer);
            if (colliders.Length > 0)
            {
                return true;
            }
        }
        return false;
    }
}

35. 路径动态调整（Path Dynamic Adjustment）

为了应对游戏中的动态变化，可以实现路径的动态调整。

public class PathDynamicAdjuster : MonoBehaviour
{
    public void AdjustPath(List<PathfindingSystem.Node> path, Vector3 newPosition)
    {
        // 实现路径动态调整逻辑
    }
}

总结

通过上述扩展，我们进一步完善了FPS游戏寻路系统。这些扩展包括：

  • 路径撤销与重做：提供更好的用户体验。
  • 路径历史记录：方便调试和分析。
  • 路径可视化增强：更好地展示路径信息。
  • 路径碰撞检测：确保路径的安全性。
  • 路径动态调整：应对游戏中的动态变化。

在实际开发中，还需要考虑以下几点：

  • 性能优化：避免路径撤销与重做、路径历史记录、路径可视化增强、路径碰撞检测和路径动态调整对游戏性能造成过大影响。
  • 安全性：确保寻路系统的稳定性，避免出现错误路径。
  • 可扩展性 | 设计系统时考虑到未来的扩展，使得添加新功能或新特性变得容易。

36. 路径成本动态调整（Dynamic Path Cost Adjustment）

为了应对游戏中的动态变化，如天气、时间等因素，可以动态调整路径的成本。

public class DynamicPathCostAdjuster : MonoBehaviour
{
    public float timeOfDayFactor = 1.0f;
    public float weatherFactor = 1.0f;

    public float AdjustCost(float baseCost)
    {
        return baseCost * timeOfDayFactor * weatherFactor;
    }
}

37. 路径优先级（Path Prioritization）

为了确保重要角色或任务能够优先获得路径，可以实现路径优先级功能。

public class PathPrioritizer : MonoBehaviour
{
    public enum PriorityLevel
    {
        Low,
        Medium,
        High
    }

    public PriorityLevel priorityLevel;

    public bool HasHigherPriorityThan(PathPrioritizer other)
    {
        return priorityLevel > other.priorityLevel;
    }
}

38. 路径预加载（Path Preloading）

为了减少游戏中的延迟，可以预加载可能的路径。

public class PathPreloader : MonoBehaviour
{
    private Dictionary<string, List<PathfindingSystem.Node>> preloadedPaths = new Dictionary<string, List<PathfindingSystem.Node>>();

    public void PreloadPath(Vector3 start, Vector3 end)
    {
        string key = $"{start.GetHashCode()}-{end.GetHashCode()}";
        if (!preloadedPaths.ContainsKey(key))
        {
            preloadedPaths[key] = PathfindingManager.Instance.FindPath(start, end);
        }
    }

    public List<PathfindingSystem.Node> GetPreloadedPath(Vector3 start, VectorState end)
    {
        string key = $"{start.GetHashCode()}-{end.GetHashCode()}";
        if (preloadedPaths.ContainsKey(key))
        {
            return preloadedPaths[key];
        }
        return null;
    }
}

39. 路径缓存清理（Path Cache Cleanup）

为了避免内存泄漏，可以定期清理路径缓存。

public class PathCacheCleaner : MonoBehaviour
{
    public float cleanupInterval = 60f;
    private float lastCleanupTime;

    void Update()
    {
        if (Time.time - lastCleanupTime > cleanupInterval)
        {
            lastCleanupTime = Time.time;
            // 实现路径缓存清理逻辑
        }
    }
}

40. 路径优化算法选择（Path Optimization Algorithm Selection）

为了适应不同的游戏场景，可以选择不同的路径优化算法。

public class PathOptimizationAlgorithmSelector : MonoBehaviour
{
    public enum OptimizationAlgorithm
    {
        AStar,
        Dijkstra,
        JumpPointSearch
    }

    public OptimizationAlgorithm selectedAlgorithm;

    public List<PathfindingSystem.Node> OptimizePath(List<PathfindingSystem.Node> path)
    {
        switch (selectedAlgorithm)
        {
            case OptimizationAlgorithm.AStar:
                // 实现A*优化逻辑
                break;
            case OptimizationAlgorithm.Dijkstra:
                // 实现Dijkstra优化逻辑
                break;
            case OptimizationAlgorithm.JumpPointSearch:
                // 实现Jump Point Search优化逻辑
                break;
        }
        return path;
    }
}

总结

通过上述扩展，我们进一步完善了FPS游戏寻路系统。这些扩展包括：

  • 路径成本动态调整：应对游戏中的动态变化。
  • 路径优先级：确保重要角色或任务能够优先获得路径。
  • 路径预加载：减少游戏中的延迟。
  • 路径缓存清理：避免内存泄漏。
  • 路径优化算法选择：适应不同的游戏场景。

在实际开发中，还需要考虑以下几点：

  • 性能优化：避免路径成本动态调整、路径优先级、路径预加载、路径缓存清理和路径优化算法选择对游戏性能造成过大影响。
  • 安全性：确保寻路系统的稳定性，避免出现错误路径。
  • 可扩展性：设计系统时考虑到未来的扩展，使得添加新功能或新特性变得容易。

通过这些措施，我们可以构建一个高效、稳定且用户友好的FPS游戏寻路系统。

【Unity】RPG2D龙城纷争（八）寻路系统
神码编程
07-04 303
寻路系统是整个游戏最核心的功能之一，角色的移动和战斗都是基于寻路系统来进行的，毕竟我们的游戏有三分之一的战棋血统。要做到如上这么多自由的想法，自定义寻路规则是必须的，所幸的A*寻路支持自定义寻路规则，那么我们便立即开始吧（继承至AStarRule/// 寻路规则（角色移动）/// 当前的关卡/// 当前寻路的角色/// 目标地块//寻路前，对所有A*节点应用自定义规则//通过节点索引找到其对应的地块//如果地块上存在敌人（阵营不同）//则该地块不可行走return;
NavMesh Layers (Pro only)
czlilove的专栏
03-19 1106
最优路径： 两点之间的最优路径，是指代价(cost)最小的路径。 每一个NavMesh都分配一个层级，每一个层级对应一定的代价值。 所以总代价值，就是两点之间所经过的NavMesh的层级代价值的和。 当代价值相同时，最优路径便是所有路径中的最短路径了。 不推荐设置层的代价值小于1，这种情况下不能保证获取最佳路径  有三个内置的层级： Default：默认的层级 Not walk
A星寻路，寻路系统
12-28
采用A星寻路，让任务自动采取路径寻路到敌人身边，以最近路径
寻路系统、人工智能AI
duanworld的博客
03-23 531
NavMeshAgent（导航网络代理组件）：给物体添加，并且寻找到最短的路径； OffMeshLink（分离网络连接）：完成物体在两者之间的跳跃； NavMeshObstacle(网格障碍组件)：可添加到动态的障碍物上，障碍物会动态的改变它所在地点的网格信息； 注：寻路之前先对场景进行烘焙 public GameObject target; void Start() {     G
Unity中的寻路系统
Asklyw的博客
03-30 676
使用NavMesh来实现游戏中的寻路系统非常方便，因为它可以自动避开障碍物并提供高效的路径计算。这篇文章提供了一个简单的代码示例，以帮助开发人员更好地理解如何在Unity中使用NavMesh来实现寻路系统。
Unity学习-导航寻路系统（Navigation)
Ryan_coding的博客
03-08 4610
Unity–导航寻路系统（Navigation） 1.静态简单导航 （1）不改变导航期间，路障的情况，并且不能进行跳跃类操作，即连续不跳跃类 <1>首先建立如下模型，其中四周墙壁和中间的黄色墙壁为障碍物，胶囊和小球分别为起点和终点。要求:胶囊从起点位置出发，绕过四条黄色的柱子，到达小球位置。 <2> 选择地面和所有障碍物 点开箭头。将这些调整为Naviagtion static类型 <3>选择capsule，添加脚本和Nav Mesh Agent组件 using S
【H5/JS】游戏常用算法-路径搜索算法-随机迷宫算法（普里姆算法）
krapnik的博客
06-11 3721
路径搜索算法在游戏中非常常见，特别是在 RPG、SLG 中经常用到。在这些游戏中，通过鼠标指定行走目的地，人物或者NPC就会自动行走到目标地点，这就是通过路径搜索或者称为寻路算法来实现的。通俗地说，就是在...
(源码)基于QT Creator的二维游戏寻路系统.zip
最新发布
11-13
# 基于QT Creator的二维游戏寻路系统 ## 项目简介 本项目是一个基于QT Creator框架开发的二维游戏寻路系统，主要实现了A（A Star）寻路算法在游戏中的应用。通过该系统，玩家可以在游戏中控制角色在复杂的地图环境...
flash as3 游戏寻路系统
04-17
本文将详细解析使用Flash AS3实现的游戏寻路系统，并围绕标题“flash as3 游戏寻路系统”，描述中的“swf和原文件fla”以及标签“flash as3 动画 游戏 寻路”展开讨论。 Flash AS3是一种广泛应用于创建互动内容的...
现代游戏寻路系统的革新：超越路径点
本文作者PaulT探讨了当前寻路系统中存在的问题，特别是路径点（Waypoint Graphs）方法的不足，并提倡使用导航网格（Navigation Meshes）作为更为现代和高效的解决方案。 路径点系统是90年代常见的寻路方法，其中...
寻路系统之A*算法原理
07-04
这篇文章并不试图对这个话题作权威陈述取而代的是它只是描述算法原理使你可以在进步阅读中理解其他相关资料
基于A*算法的迷宫寻路系统
01-25
这是一个迷宫寻路小项目。 压缩包里有已经封装好的exe文件maze.exe，双击即可运行。 源代码也在压缩包中，直接用python运行maze.py即可（python版本3.6，要装pygame） 推荐一篇介绍A 算法的博文，解释的非常好：http://blog.csdn.net/hitwhylz/article/details/23089415 求好评！！！
基于bfs算法的自动寻路贪吃蛇（js+canvas）
qq_57174310的博客
10-07 758
演示地址：www.zm-zm.top源码：https://github.com/zm2001/aiSnake.git。
Unity3D 打造3D Astar寻路系统详解
voidinit的专栏
05-15 511
在Astar脚本中，我们可以定义一个OpenList和一个ClosedList来存储待处理的节点和已处理的节点。G值表示起点到当前节点的移动代价，H值表示当前节点到终点的估算代价，F值为G值和H值的和。最后，我们需要在游戏中显示路径。在脚本中，我们可以将Astar脚本挂载到角色物体上，并调用其方法来计算路径。通过使用Astar算法，我们可以实现一个高效的寻路系统，让游戏中的角色可以自动寻找最短路径到达目的地。在游戏开发中，寻路系统是一个非常重要的功能，它可以让游戏中的角色自动寻找最短路径到达目的地。
Unity鼠标控制人物移动（即鼠标点击地面人物自动寻路到点击处）
Akuyi的博客
08-02 1085
public Texture2D point, doorway, attack, target, arrow;//不同的贴图 RaycastHit hitInfo; public event Action<Vector3> OnMouseClicked; public event Action<GameObject> OnEnemyClicked; protected override void Awake() { ba.
Unity中的导航与寻路如何使用
cxy15978的博客
04-09 1249
这是因为我们给这篇区域设置了更大的阻力，想要通过这篇区域需要花费更多的时间。所以AI生成了一条绕过这篇区域的路线。2.选中物体在Navigation Area中为相应对象选中这个阻力，烘焙之后这个阻力就会生效。烘焙完成之后我们可以在Scene窗口中查看生成导航的区域（青色区域）需要注意的是我们的角色并没有直接上台阶，而是绕过了一快区域：▼。1.在Navigation-->Areas中添加一个阻力值。这里我们直接使用官方文档中的代码： ▼。通过以下方法为区域设置一个阻力值。
【share】Unity场景爬坑实录
weixin_34060741的博客
08-01 122
场景的基本结构 1) 基础地形层 -- 指打底的大地皮，一般是一个体积很大的Mesh，如果是地宫或天空城场景，就没有大块地皮了，可能只是一个远景大平面 2) Ground物件层 -- 可以在上面行走的物件，比如桥，建筑地板，阶梯，祭坛等 3) 其他物件层 -- 非阻挡层与阻挡层，也包括特效等 坑1、地形切片 地形切片后面被证明是没有必要的。手游来说，业界通用的做法是先用...
unity之简单的角色自动寻路
MayMarch的博客
02-27 1260
unity之简单的角色自动寻路
Unity_自动寻路系统简述
Miss_suiFeng
07-19 991
1、导航网格生成方式 在 Unity 中，导航网格生成方式是在 Navigation 窗口（菜单：__Window__ > AI > __Navigation__）中进行处理的。 为场景构建导航网格可以通过 4 个快速步骤完成 1.选择应影响导航的场景几何体：可行走表面和障碍物 2.选中 Navigation Static 复选框以便在导航网格烘焙过程中包括所选对象 3.调整烘焙设置以匹配代理大小。 - Radius 定义代理中心与墙壁或窗台的接近程度。 - Heigh
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

你一身傲骨怎能输

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值