使用A Pathfinding Project*插件(版本4.2)在多个GridGraph网格自动形成路径

最新推荐文章于 2025-02-25 22:12:44 发布
最新推荐文章于 2025-02-25 22:12:44 发布
阅读量438 收藏 2
点赞数 1
文章标签： solr lucene
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30281539/article/details/143565600
版权

首先创建空物体命名AstarPath ，挂载Pathfinder组件，用来设置网格路径，目前只做了垂直和平面俩个面，实际可以根据需求创建多个面。主要用于在两点之间创建一条最优路线。设置参数：

框红的地方是需要注意的参数设置，包括当前网格的长宽，障碍物设置，可越过的最高坡度等等一些相关设置，会影响路径的计算，具体可以去参考下官方的参数文档。

然后可以找个空的节点或随意节点挂载seeker组件用于寻路的重要组件。

不用管seeker参数设置，默认的就好。

然后创建自定义脚本LineAroundObstacles.cs开始编写代码  这为了实现连线用到了MegaWire插件。

using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;
using Vectrosity;
using Pathfinding;

public class LineAroundObstacles : MonoBehaviour
{
    [Header("线缆的材质")]
    public Material wireMaterial;
    [Header("线缆的半径")]
    public float wireSize = 0.1f;
    private bool isDrawing = false; // 绘制状态
    private WireConnectionPoint startPoint; // 线缆的起始连接点

    private Dictionary<MegaWire, List<WireConnectionPoint>> wireConnectionDatas = new Dictionary<MegaWire, List<WireConnectionPoint>>();// 存储当前激活的线缆
    private List<WireConnectionPoint> wirePoints = new List<WireConnectionPoint>();
    private VectorLine currentLine;         // 当前正在拖拽的线条

    private int indexSpanNum = -1;  //记录当前线段下标
    [Header("清空按钮")]
    public Button clearLinesBtn;
    [Header("确认连线按钮")]
    public Button affirmButton;
    [Header("透明按钮")]
    public Button lucencyButton;
    [Header("恢复按钮")]
  public Button recoverButton;
    [Header("返回按钮")]
    public Button returnButton;

    private List<GameObject> tempObjList = new List<GameObject>();
    [Header("启用碰撞效果")]
    public bool isCrash = false;
    [Header("成功音效")]
    public AudioClip succeedClip;
    [Header("失败音效")]
    public AudioClip failClip;

    private AudioSource audioScource;

    private HintPanel hintPanel;

    public Light targetLight;
    public Material targetLightMaterial;

    public Material originalMaterial;
    private Color originalColor;

    private Seeker seeker;
    private Path path;
  void Start()
    {
        seeker = GetComponent<Seeker>();
        //targetLight.gameObject.SetActive(false);
        //targetLightMaterial.DisableKeyword("_EMISSION");
        //if (originalMaterial != null)
        //{
        //    originalColor = originalMaterial.color;
        //}

        wireConnectionDatas = new Dictionary<MegaWire, List<WireConnectionPoint>>(); // 初始化激活的线缆列表
        wirePoints = new List<WireConnectionPoint>(FindObjectsOfType<WireConnectionPoint>());
        //临时存十个空节点
        for (int i = 0; i < 10; i++)
        {
            GameObject tempObj = new GameObject();
            tempObj.name = i.ToString();
            tempObjList.Add(tempObj);
        }
    }

void Update()
    {
        if (Input.GetMouseButtonDown(1))
        {

            // 获取当前鼠标点击的连接点
            WireConnectionPoint clickedPoint = GetClickedConnectionPoint();
            if (clickedPoint != null && !isDrawing)
            {
                startPoint = clickedPoint; // 设置起始点

                // 创建新的 VectorLine
                currentLine = new VectorLine("WireLine", new List<Vector3>(), wireSize, LineType.Continuous, Joins.Weld);
                currentLine.material = wireMaterial;
                // 添加起始点和一个初始的终点
                currentLine.points3.Add(startPoint.transform.position);  // 起始点
                currentLine.points3.Add(startPoint.transform.position);  // 添加一个默认的终点（与起点相同）

                isDrawing = true;
            }
  else if (isDrawing)
            {
                // 如果已经在拖动，鼠标点击添加拐点
                //Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
                //if (Physics.Raycast(ray, out RaycastHit hit))
                //{
                Debug.Log("hit=>" + endClickPos);
                currentLine.points3[currentLine.points3.Count - 1] = endClickPos;
                currentLine.points3.Add(endClickPos);
                currentLine.points3.Add(endClickPos);
                //}
            }
        }

        if (isDrawing)
        {
            UpdateWirePosition();
        }
if (Input.GetMouseButtonDown(2))
        {

            WireConnectionPoint endPoint = GetClickedConnectionPoint();
            if (endPoint != null && endPoint != startPoint)
            {
                currentLine.points3[currentLine.points3.Count - 1] = endPoint.transform.position;

                CreateWire(currentLine.points3, endPoint, () =>
                {
                    if (currentLine != null && currentLine.points3.Count > 0)
                    {
                        currentLine.points3.Clear();
                        VectorLine.Destroy(ref currentLine);
                    }
                });
            }
            else
            {
                if (currentLine != null && currentLine.points3.Count > 0)
                {
                    currentLine.points3.Clear();
                    VectorLine.Destroy(ref currentLine);
                }

            }
  isDrawing = false;
        }
        if (Input.GetKeyDown(KeyCode.Z))
        {
            if (indexSpanNum >= 0)
            {
                //从最后一位删除
                MegaWire lastKey = wireConnectionDatas.Keys.Last();
                if (wireConnectionDatas[lastKey] != null)
                {
                    foreach (WireConnectionPoint point in wireConnectionDatas[lastKey])
                    {
                        for (int i = 0; i < point.isConnect.Count; i++)
                        {
                            point.isConnect[i] = false;
                        }
                    }
                }

                DeleteWire(lastKey);
                wireConnectionDatas.Remove(lastKey);
            }


        }
    }
 WireConnectionPoint GetClickedConnectionPoint()
    {
        Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
        if (Physics.Raycast(ray, out RaycastHit hit))
        {
            return hit.collider.GetComponent<WireConnectionPoint>();
        }
        return null;
    }

    Vector3 endClickPos;
    void UpdateWirePosition()
    {

        Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
        if (Physics.Raycast(ray, out RaycastHit hit))
        {
            Vector3 mousePos = hit.point;

            Vector3 startPoint = currentLine.points3[currentLine.points3.Count - 2];
             Vector3 constrainedPosition;
            constrainedPosition = mousePos;

            // 更新线条的终点
            if (currentLine != null && currentLine.points3.Count > 0)
            {
                endClickPos = constrainedPosition;
                currentLine.points3[currentLine.points3.Count - 1] = constrainedPosition;
                currentLine.Draw3D();
            }


        }

    }

     //多面路径计算
    List<Vector3> multipathList = new List<Vector3>();
    void CreateWire(List<Vector3> posList, WireConnectionPoint endPoint, UnityAction callback)
    {
        indexSpanNum++;

        HashSet<Vector3> seen = new HashSet<Vector3>();

        posList.RemoveAll(item => !seen.Add(item));
        List<Vector3> changePos = new List<Vector3>(seen);

        while (tempObjList.Count < changePos.Count)
        {
            GameObject temp = new GameObject();
            tempObjList.Add(temp);
        }

        while (tempObjList.Count > changePos.Count)
        {
            Destroy(tempObjList[tempObjList.Count - 1]);
            tempObjList.RemoveAt(tempObjList.Count - 1);
        }



        for (int i = 0; i < changePos.Count; i++)
        {
            tempObjList[i].transform.position = changePos[i];

        }
        MegaWire wire = null;
        // 执行扫描，更新图层
        AstarPath.active.Scan();
        // 获取起点和终点的最近节点
        var startNode = AstarPath.active.GetNearest(startPoint.transform.position);
        var endNode = AstarPath.active.GetNearest(endPoint.transform.position);

        // 输出调试信息，确认起点和终点位置

        Debug.Log("Start Node: " + startNode.node.position+"   "+(startNode.node.Graph== endNode.node.Graph));
        Debug.Log("End Node: " + endNode.node.position);

        if (startNode.node.Graph == endNode.node.Graph)
        {

            seeker.StartPath(startPoint.transform.position, endPoint.transform.position, (p) =>
            {
                if (p.error)
                {
                    Debug.LogError("Pathfinding error: " + p.errorLog);
                    return;
                }

                if (p.vectorPath.Count > 0)
                {
                    Debug.Log("currentNodes==>" + p.vectorPath.Count);  //A*的path不包含头和尾
                    tempObjList = new List<GameObject>();
                    GameObject startObj = new GameObject();
                    startObj.transform.position = startPoint.transform.position;
                    tempObjList.Add(startObj);
                    foreach (Vector3 pos in p.vectorPath)
                    {
                        GameObject obj = new GameObject();
                        obj.transform.position = pos;
                        tempObjList.Add(obj);
                    }
                    GameObject endObj = new GameObject();
                    endObj.transform.position = endPoint.transform.position;
                    tempObjList.Add(endObj);
                }
                wire = MegaWire.Create(wire, tempObjList, wireMaterial, "Wire", null, wireSize, 1.0f);
                //设置物理效果
                wire.Mass = 0.1f;
                wire.stretch = 0.1f;
                wire.massRand = 0.1f;
                wire.doCollisions = isCrash;
                wire.enabled = false;
                //wire.hidespans = false;
                //wire.doCollisions = true;  //贴墙不能设置碰撞，会有问题

                //activeWires.Add(wire);
                if (startPoint.pointName == endPoint.pointName)
                {
                    for (int i = 0; i < startPoint.isConnect.Count; i++)
                    {

                        if (!startPoint.isConnect[i])
                        {
                            startPoint.isConnect[i] = true;
                        }

                    }
                    for (int i = 0; i < endPoint.isConnect.Count; i++)
                    {
                        if (!endPoint.isConnect[i])
                List<WireConnectionPoint> currentPoints = new List<WireConnectionPoint> { startPoint, endPoint };

                    wireConnectionDatas.Add(wire, currentPoints);
                }
                else
                {
                    //多连接错误的线路处理
                    wireConnectionDatas.Add(wire, null);
                }


                //if (activeWires.Count>1)
                //{
                //    activeWires[activeWires.Count - 2].enabled = false;
                //}
                wire.RebuildWire();
                callback?.Invoke();



            });

        }
        else {
            multipathList = new List<Vector3>();
            GridGraph graphStart = startNode.node.Graph as GridGraph;
            GridGraph graphend = endNode.node.Graph as GridGraph;

            // Step 1: 根据终点的位置，计算起点图层的边界点
            Vector3 borderPoint1 = GetGraphBoundaryPoint(graphStart, startPoint.transform.position, endPoint.transform.position);
            CalculatePath(startPoint.transform.position, borderPoint1, 0,endPoint,wire,callback);  // 使用第一个图层

            // Step 2: 根据起点的位置，计算终点图层的边界点
            Vector3 borderPoint2 = GetGraphBoundaryPoint(graphend, endPoint.transform.position, startPoint.transform.position);
            CalculatePath(borderPoint1, borderPoint2, 1, endPoint, wire, callback);  // 使用第二个图层

            // Step 3: 计算从第二个图层的边界点到终点的路径
            CalculatePath(borderPoint2, endPoint.transform.position, 1, endPoint, wire, callback, true);  // 使用第二个图层

        }

    }
 // 计算路径
    void CalculatePath(Vector3 start, Vector3 end, int graphIndex,WireConnectionPoint endPoint, MegaWire wire,UnityAction callback, bool calculatePath=false)
    {
        if (AstarPath.active != null && AstarPath.active.graphs.Length > graphIndex)
        {
            GridGraph targetGraph = AstarPath.active.graphs[graphIndex] as GridGraph;
            if (targetGraph != null)
            {
                // 设置 Seeker 使用指定的图层来计算路径
                seeker.StartPath(start, end, (p)=> {
                    if (p.error)
                    {
                        Debug.LogError("路径计算错误: " + p.errorLog);
                        return;
                    }

                    // 处理路径，比如让对象沿着路径移动等
                    Debug.Log("路径计算成功！");
                    multipathList.AddRange(p.vectorPath);
                    Debug.Log("currentNodes==>" + p.vectorPath.Count);  //A*的path不包含头和尾
                        tempObjList = new List<GameObject>();
                        GameObject startObj = new GameObject();
                        startObj.transform.position = startPoint.transform.position;
                        tempObjList.Add(startObj);
                        foreach (Vector3 pos in p.vectorPath)
                        {
                            GameObject obj = new GameObject();
                            obj.transform.position = pos;
                            tempObjList.Add(obj);
                        }
                        GameObject endObj = new GameObject();
                        endObj.transform.position = endPoint.transform.position;
                        tempObjList.Add(endObj);
                    }


                    wire = MegaWire.Create(wire, tempObjList, wireMaterial, "Wire", null, wireSize, 1.0f);
                    //设置物理效果
              wire.Mass = 0.1f;
                    wire.stretch = 0.1f;
                    wire.massRand = 0.1f;
                    wire.doCollisions = isCrash;
                    wire.enabled = false;
                    //wire.hidespans = false;
                    //wire.doCollisions = true;  //贴墙不能设置碰撞，会有问题

                    //activeWires.Add(wire);
                    if (startPoint.pointName == endPoint.pointName)
                    {
                        for (int i = 0; i < startPoint.isConnect.Count; i++)
                        {

                            if (!startPoint.isConnect[i])
                            {
                                startPoint.isConnect[i] = true;
                            }

                        }
                        for (int i = 0; i < endPoint.isConnect.Count; i++)
                        {
                            if (!endPoint.isConnect[i])
                            {
                                endPoint.isConnect[i] = true;
                            }
                        }

                        List<WireConnectionPoint> currentPoints = new List<WireConnectionPoint> { startPoint, endPoint };

                        wireConnectionDatas.Add(wire, currentPoints);
                    }
                    else
                    {
                        //多连接错误的线路处理
                        wireConnectionDatas.Add(wire, null);
                    }

                    
                    //if (activeWires.Count>1)
                    //{
                    //    activeWires[activeWires.Count - 2].enabled = false;
                    //}
                    wire.RebuildWire();
                    callback?.Invoke();

                });

            
            }
        }
    }
// 根据终点的位置和起点的位置，计算图层的边界点
    Vector3 GetGraphBoundaryPoint(GridGraph graph, Vector3 point, Vector3 oppositePoint)
    {
        // 获取终点或起点在图层的对应边界点
        // 我们将选择离另一点最近的边界点作为连接点
        Vector3 boundaryPoint = point;
        float minDist = float.MaxValue;

        // 计算图层的边界点
        for (int x = 0; x < graph.width; x++)
        {
            for (int z = 0; z < graph.depth; z++)
            {
                // 获取每个网格节点的位置
                Vector3 nodePosition = (Vector3)graph.GetNode(x, z).position;
               
                // 计算与对方点之间的距离
                float dist = Vector3.Distance(oppositePoint, nodePosition);

                // 选择最接近对方点的图层边界点
                if (dist < minDist)
                {
                    minDist = dist;
                    boundaryPoint = nodePosition;
                }
            }
        }
        Debug.Log("boundaryPoint==>"+ boundaryPoint);
        return boundaryPoint;
    }

 

    public void DeleteWire(MegaWire wireToDelete)
    {
        if (wireConnectionDatas.ContainsKey(wireToDelete))
        {
            indexSpanNum--;
            wireToDelete.RemoveWire(); // 删除线缆
            if (wireConnectionDatas[wireToDelete] != null)
            {
                foreach (WireConnectionPoint point in wireConnectionDatas[wireToDelete])
                {
                    for (int i = 0; i < point.isConnect.Count; i++)
                    {
                        point.isConnect[i] = false;
                    }
                }
            }

            wireConnectionDatas.Remove(wireToDelete);
        }
    }
 //是否完成连线
    private bool ConfirmConnection()
    {

        foreach (var point in wirePoints)
        {
            foreach (var item in point.isConnect)
            {
                if (!item)
                {
                    return false;
                }
            }
        }
        foreach (var item in wireConnectionDatas.Values)
        {
            if (item == null)
            {
                return false;
            }
        }

        return true;
    }
 // 将材质变为半透明
    public void SetTransparent(float alpha)
    {
        if (originalMaterial != null)
        {
            // 设置渲染模式为透明
            originalMaterial.SetFloat("_Mode", 3);
            originalMaterial.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
            originalMaterial.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
            originalMaterial.SetInt("_ZWrite", 0);
            originalMaterial.DisableKeyword("_ALPHATEST_ON");
            originalMaterial.EnableKeyword("_ALPHABLEND_ON");
            originalMaterial.DisableKeyword("_ALPHAPREMULTIPLY_ON");
            originalMaterial.renderQueue = 3000;

            // 设置透明度
            Color color = originalMaterial.color;
            color.a = alpha;
            originalMaterial.color = color;
        }
    }
 // 恢复材质为不透明
    public void SetOpaque()
    {
        if (originalMaterial != null)
        {
            // 恢复渲染模式为不透明
            originalMaterial.SetFloat("_Mode", 0);
            originalMaterial.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
            originalMaterial.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
            originalMaterial.SetInt("_ZWrite", 1);
            originalMaterial.DisableKeyword("_ALPHATEST_ON");
            originalMaterial.DisableKeyword("_ALPHABLEND_ON");
            originalMaterial.DisableKeyword("_ALPHAPREMULTIPLY_ON");
            originalMaterial.renderQueue = -1;

            // 恢复材质的原始颜色
            originalMaterial.color = originalColor;
        }
    }
private void OnDestroy()
    {
        tempObjList.Clear();
    }
}

代码里有很多冗余，如果只想了解获取路径只看CreateWire方法就好了。

有什么不理解的地方欢迎留言。

Engine盧
关注
Unity引擎开发：复杂动作系统_结合AI实现智能动作系统
chenlz2007的博客
02-27 991
在本节中，我们详细探讨了如何在Unity中结合AI技术实现智能动作系统。通过路径寻找、状态机、决策树、动作融合和动作预测等技术，可以实现一个更加智能、反应迅速且自然的角色行为系统。这些技术的结合不仅能够提升游戏的可玩性和沉浸感，还能为开发复杂的游戏AI提供坚实的基础。希望本文对大家在Unity中实现智能动作系统有所帮助，欢迎大家在实践中不断探索和优化。
A*Pathfinding Project Pro使用
qq_42187442的博客
07-14 1131
为了让AI对象和障碍物有一些边缘，这里将Capsule的半径设置为2.另外将碰撞检测的layer设置为Obstacles，因为不想让地面成为障碍。为了把寻路的node放置到场景中的正确位置，一般使用从node向下发射一个射线来进行检测，寻路node会被放置到碰撞点的位置。好了，都准备好了，点击底部的Scan，我们就可以看到grid Graph的生成了，可以再编辑窗口中看到辅助线显示的寻路网格，包括了可寻路的区域和障碍区域。将创建的一个layer障碍物设置成Obstacle。给对象添加上这个组件。
[Unity] A* pathfinding project integrated with influence map
Ron的专栏
06-21 1315
最近一阶段重温了一些关于游戏人工智能方面的书籍。 加强了对influence map的认知。想要亲自动手实现一下。 正如文章标题所示，这篇文章讲的是：如何将influence map的机制融入到当前交火的unity寻路插件A* pathfinding project里。
A Pathfinding Project*插件的使用
最新发布
aq1229的博客
02-25 820
按照以上步骤操作，即使是小白也能成功实现A*寻路功能！
[Unity插件]A* Pathfinding Project：简易课程
yuliying的专栏
01-04 5836
[Unity插件]A* Pathfinding Project：简易教程 原文链接：http://arongranberg.com/astar/docs/getstarted.php 题外话：最近想学习一下A*插件，由于在网上没有发现什么比较详细的教程，所以就只能上官网了。这是第一次看这么长的英语文章，翻译得不好，请见谅！ 概述： A*插件的核心脚本
A* Pathfinding Project (Unity A*寻路插件) 使用教程
Unity
07-17 8832
下面是动态图，借助 A* 插件，编写很少的代码就可以做到寻路。 1、创建场景 在场景中添加一些Cube 作为障碍物 Obstacles，添加一个 Capsule 作为Player，然后添加一个Plane 作为地面，再添加一个Plane，作为斜坡测试。 在创建一个GameObject，改名为 A* ，添加A Star Path (
[Unity插件]A* Pathfinding Project：简易教程(一)
06-14 2619
原文链接：http://arongranberg.com/astar/docs/getstarted.php 插件下载地址：http://pan.baidu.com/s/1eROqaB4 题外话：最近想学习一下A*插件，由于在网上没有发现什么比较详细的教程，所以就只能上官网了。这是第一次看这么长的英语文章，翻译得不好，请见谅！ 概述： A*插件的核心脚本就是”astarpath.cs”，所以如果你想使用A*插件进行寻路，那么场景中一定要有一个”astarpath.cs”(并且一个场景仅有一个).
UNITY自动寻路插件 A* Pathfinding Project Pro 4.2.2（最新版）
04-14
A* Pathfinding Project Pro 4.2.2（最新版），供大家学习使用。
A Pathfinding Project Pro v4.2.15.unitypackage.zip
03-10
Unity引擎中的A*寻路算法就是一个广泛使用的解决方案，尤其在"A Pathfinding Project Pro v4.2.15.unitypackage"这个资源包中，提供了高级且高效的寻路工具。本文将深入探讨A*算法及其在Unity中的应用。 首先，A*...
A Pathfinding Project Pro 4.2.15.zip
09-13
"A Pathfinding Project Pro 4.2.15"是一个专为Unity3D设计的高级寻路解决方案，它基于著名的A*算法，为开发者提供了高效且灵活的路径查找功能。 A*算法，全称A-Star，是一种启发式搜索算法，广泛应用于路径规划、...
Unity寻路插件A* Pathfinding Project Pro 4.2.15发布
在Unity项目中使用A* Pathfinding Project Pro插件前，需要完成以下步骤： 1. **导入插件**：将从官方或第三方资源库下载的A Pathfinding Project Pro 4.2.15.unitypackage文件导入到Unity项目中。 2. **配置寻路...
A* Pathfinding Project Pro 3.8.6
02-04
A* Pathfinding Project Pro 3.8.6 - 超牛的寻路插件
A * pathfinding project pro 4.1.12
04-11
如题 , 目前的非Beta最新版 . Unity寻路插件 . 功能强大 .
A * Pathfinding Project Pro 4.2.15
12-24
A * Pathfinding Project Pro 4.2.15
A * pathfinding project pro 4.1.16
12-10
A * pathfinding project pro 4.1.16 比较新版本。
A* Pathfinding Project Pro 4.2.15.zip
06-04
A* Pathfinding Project Pro 4.2.15，A星寻路插件，解压出来是一个unitypackage。 插件是一个功能强大并且易于使用的 Unity 寻路系统。通过快速的路径寻找，您的 AI 将立即在复杂的迷宫中找到玩家。非常适合 TD、FPS、RTS 游戏。 支持网格、导航网格、点和六角形图。自动导航图形生成让你免于手动执行。完全多线程，因此几乎不会影响帧速率。使用光线投射、平滑和漏斗算法进行路径后处理。路径查找调用只需一行代码。可以将图形保存到文件里。在 XZ 平面和 XY 平面上均可局部回避。内含源代码。支持运行时更新图形。 包含共 16 个示例场景帮助你入门。还有一份全面的在线文档，其中几乎记录了所有功能和变量。
【Unity 路径寻路插件】A Pathfinding Project Pro* 旨在为游戏中的AI角色提供高效、精确的寻路和路径规划功能
2403_88403568的博客
01-20 1442
APathfindingProjectPro*是一款功能强大的路径寻路插件，专为Unity开发者设计，旨在为游戏中的AI角色提供高效、精确的寻路和路径规划功能。无论是简单的2D或3D游戏，还是复杂的多层次、动态环境，A*PathfindingProjectPro都能够提供强大且灵活的寻路解决方案，帮助开发者创建智能的NPC行为。
A* Pathfinding Project4.2.0
weixin_34015860的博客
10-24 905
Multiple agent types This page explains how to handle different agent types, such as agents of different sizes. When you have agents of different sizes they usually cannot take the same routes to th...
Unity导航寻路系统插件--A* Pathfinding Project
光的博客
08-14 3160
Unity的A*寻路是很常用的功能，比如LOL里面的鼠标点击行走，那么一般情况下做这个导航寻路系统的时候会用两种方式去完成，第一种就是Unity里面自带的NavMeshAgent，第二种就是在Unity官方的AssetStore里面好评如潮的A* Pathfinding Project插件，这个插件比Unity自带的一个最大的好处就是它可以动态的去生成导航网格，规划路线，并且可以平滑路线，与其他...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值