A*寻路 -- 更加真实 的路径（二）

最新推荐文章于 2024-04-28 21:01:26 发布
最新推荐文章于 2024-04-28 21:01:26 发布
阅读量2.7k 收藏 2
点赞数
分类专栏： 游戏开发技术 算法

转：http://bbs.9ria.com/thread-95620-1-1.html

 

对于A*传统寻路的结果不平滑的问题，我们讨论了一种判断两点间是否存在障碍物的算法，并在用户点击鼠标选择了目的地后先判断起终点间是否存在障碍物，若不存在，则路径数组中将只具有一个终点节点；否则进行A*寻路运算。大致过程可用下面代码表示：

 

Java代码 复制代码   收藏代码
  1. //判断起终点间是否存在障碍物，若存在则调用A*算法进行寻路，通过A*寻路得到的路径是一个个所要经过的节点数组；否不存在障碍则直接把路径设置为只含有一个终点元素的数组   
  2.   
  3. var hasBarrier:Boolean = _grid.hasBarrier(startPosX, startPosY, endPosX, endPosY);   
  4.   
  5. if( hasBarrier )   
  6. {   
  7.       _grid.setStartNode(startPosX, startPosY);   
  8.       _grid.setEndNode(endPosX, endPosY);   
  9.       findPath();   
  10. }   
  11.   
  12. else  
  13. {   
  14.         _path = [_grid.getNode(endPosX, endPosY)];   
  15.        _index = 0;   
  16.        addEventListener(Event.ENTER_FRAME, onEnterFrame);//开始行走   
  17. }  
//判断起终点间是否存在障碍物，若存在则调用A*算法进行寻路，通过A*寻路得到的路径是一个个所要经过的节点数组；否不存在障碍则直接把路径设置为只含有一个终点元素的数组

var hasBarrier:Boolean = _grid.hasBarrier(startPosX, startPosY, endPosX, endPosY);

if( hasBarrier )
{
      _grid.setStartNode(startPosX, startPosY);
      _grid.setEndNode(endPosX, endPosY);
      findPath();
}

else
{
        _path = [_grid.getNode(endPosX, endPosY)];
       _index = 0;
       addEventListener(Event.ENTER_FRAME, onEnterFrame);//开始行走
}

 

如果你听从了我的建议这么做了，我只能说声抱歉，因为在实际应用中发现了一些问题，什么问题呢？就是当起终点间不存在障碍物时，主角行走的目的地将跳过 A*寻路算法的“考验”，直接设置为我点击的位置(endPosX, endPosY)，因此，此位置若有时候会是路径网格外的某一点，主角也以此为目的地进行移动，这样导致的结果就是主角“飞”起来了，或是主角“穿越” 了……为了避免这个问题的发生，我们就必须时时刻刻地使用A*算法去计算路径，即使起终点间没有障碍物也必须调用寻路方法进行寻路。但是如果用A*寻路算法计算出来的路径不平滑怎么办呢？别急，下面我们来讨论A*寻路算法的路径平滑处理办法：弗洛伊德路径平滑算法。这个算法出之lizhi写的文章：http://wonderfl.net/c/aWCe ，并已被很多人采纳~我们先看一下结果演示：MyPathFinding2

弗洛伊德路径平滑算法应在通过A*寻路算法得出路径后进行，它的步骤分为两步：一、合并路径数组中共线的节点；二、尽可能地去掉多余拐点。这个过程如下图所示：

原始A*寻路路径



 去掉共线点



 去掉多余拐点


可以看到，使用弗洛伊德路径平滑处理 后的路径正如我们期望的那样，而且大大削减了路径数组中的节点数目。

那么接下来来讲讲实现思路吧。首先，不难发现，若存在三点A(1,1), B(2,2), C(3,3)，若B与A的横、纵坐标差值分别等于C与B的横、纵坐标差值，则A,B,C三点共线，使用代码来表示就是：

 

 

Java代码 复制代码   收藏代码
  1. if( (bx -ax == cx - bx) && (by-ay == cy - by) )   
  2. {   
  3.   
  4. //三点共线   
  5.   
  6. }  
if( (bx -ax == cx - bx) && (by-ay == cy - by) )
{

//三点共线

}
 

由上式可知去掉路径中共线节点的方法。接下来讨论如何去掉多余的拐点。
仔细观察第三幅图你会发现，若路径中存在节点A,B,C,D,E,F,G，如果A与G之间的连线所经过的节点中没有一个节点是不可移动节点，则我们称A与 G之间是不存在障碍物的。如两节点间不存在障碍物，则可以去掉此两点间其他所有节点。如上例中A-G这些节点，若A与G之间不存在障碍物，则我们可以去掉 A与G之间的B,C,D,E,F节点，最终路径数组中只剩下A与G两个节点。那么如何判断两个点之间存不存在障碍物呢？在上一篇的教程中我已详细解释过方法，列位道友若不记得了，可以再回头再去仔细研读一二。
        那么最后我们使用代码来实现弗洛伊德路径平滑处理的算法：

 

 

Java代码 复制代码   收藏代码
  1. /** 弗洛伊德路径平滑处理 */  
  2. public function floyd():void {   
  3.         if (path == null)   
  4.                 return;   
  5.         _floydPath = path.concat();   
  6.         var len:int = _floydPath.length;   
  7.         if (len > 2)   
  8.         {   
  9.                 var vector:ANode = new ANode(0, 0);   
  10.                 var tempVector:ANode = new ANode(0, 0);   
  11.                 //遍历路径数组中全部路径节点，合并在同一直线上的路径节点   
  12.                 //假设有1,2,3,三点，若2与1的横、纵坐标差值分别与3与2的横、纵坐标差值相等则   
  13.                 //判断此三点共线，此时可以删除中间点2   
  14.                 floydVector(vector, _floydPath[len - 1], _floydPath[len - 2]);   
  15.                 for (var i:int = _floydPath.length - 3; i >= 0; i--)   
  16.                 {   
  17.                         floydVector(tempVector, _floydPath[i + 1], _floydPath[i]);   
  18.                         if (vector.x == tempVector.x && vector.y == tempVector.y)   
  19.                         {   
  20.                                 _floydPath.splice(i + 1, 1);   
  21.                         }   
  22.                         else  
  23.                         {   
  24.                                 vector.x = tempVector.x;   
  25.                                 vector.y = tempVector.y;   
  26.                         }   
  27.                 }   
  28.         }   
  29.         //合并共线节点后进行第二步，消除拐点操作。算法流程如下：   
  30.         //如果一个路径由1-10十个节点组成，那么由节点10从1开始检查   
  31.         //节点间是否存在障碍物，若它们之间不存在障碍物，则直接合并   
  32.         //此两路径节点间所有节点。   
  33.         len = _floydPath.length;   
  34.         for (i = len - 1; i >= 0; i--)   
  35.         {   
  36.                 for (var j:int = 0; j <= i - 2; j++)   
  37.                 {   
  38.                         if ( _grid.hasBarrier(_floydPath[i].x, _floydPath[i].y, _floydPath[j].x, _floydPath[j].y) == false )   
  39.                         {   
  40.                                 for (var k:int = i - 1; k > j; k--)   
  41.                                 {   
  42.                                         _floydPath.splice(k, 1);   
  43.                                 }   
  44.                                 i = j;   
  45.                                 len = _floydPath.length;   
  46.                                 break;   
  47.                         }   
  48.                 }   
  49.         }   
  50. }  
/** 弗洛伊德路径平滑处理 */
public function floyd():void {
        if (path == null)
                return;
        _floydPath = path.concat();
        var len:int = _floydPath.length;
        if (len > 2)
        {
                var vector:ANode = new ANode(0, 0);
                var tempVector:ANode = new ANode(0, 0);
                //遍历路径数组中全部路径节点，合并在同一直线上的路径节点
                //假设有1,2,3,三点，若2与1的横、纵坐标差值分别与3与2的横、纵坐标差值相等则
                //判断此三点共线，此时可以删除中间点2
                floydVector(vector, _floydPath[len - 1], _floydPath[len - 2]);
                for (var i:int = _floydPath.length - 3; i >= 0; i--)
                {
                        floydVector(tempVector, _floydPath[i + 1], _floydPath[i]);
                        if (vector.x == tempVector.x && vector.y == tempVector.y)
                        {
                                _floydPath.splice(i + 1, 1);
                        }
                        else
                        {
                                vector.x = tempVector.x;
                                vector.y = tempVector.y;
                        }
                }
        }
        //合并共线节点后进行第二步，消除拐点操作。算法流程如下：
        //如果一个路径由1-10十个节点组成，那么由节点10从1开始检查
        //节点间是否存在障碍物，若它们之间不存在障碍物，则直接合并
        //此两路径节点间所有节点。
        len = _floydPath.length;
        for (i = len - 1; i >= 0; i--)
        {
                for (var j:int = 0; j <= i - 2; j++)
                {
                        if ( _grid.hasBarrier(_floydPath[i].x, _floydPath[i].y, _floydPath[j].x, _floydPath[j].y) == false )
                        {
                                for (var k:int = i - 1; k > j; k--)
                                {
                                        _floydPath.splice(k, 1);
                                }
                                i = j;
                                len = _floydPath.length;
                                break;
                        }
                }
        }
}
 

接下来再讲一讲第二个棘手的问题，就是A*寻路会当你点击一个不可移动点之后返回false的寻路结果，即告知你无路可走。这不是我们想要的结果，我们想要的是点击一个不可移动点后玩家应该走到离此不可移动点最近的一个可移动点位上面。那么如果你阅读过我的上一篇帖子，你会看到我解决此问题的一个方式是使用“将不可移动点设置超大代价法”。不过使用此方法的一个弊病在于当你在选择一个不可移动点作为终点后，A*寻路算法会遍历大量的点，造成性能的低下。那么在经过另一番研究后发现还有一种办法能解决这个问题，就是“寻找替代点法”。
        先解释一下什么是“寻找替代点法”，当点击一个不可移动点U之后我们将寻找此不可移动点外围一个离起点距离最短的可移动点R作为U的替代点，替代U来完成寻路且玩家将最终移动到此R点位置。如下图所示

 

 



  那么，为了尽可能地降低寻找替代点的时间，我们提出了一种“埋葬深度”的概念。先看下图：

 


 这种情况下，U点由一圈甚至两圈或更多圈不可移动点包围着，若我们采用传统的方式以辐射型遍历U点外圈节点（从U点外围第一圈开始遍历，遍历完毕没有找到替代点，继续再遍历更外边的圈直到找到为止），将会在多次点击同一点时产生冗余遍历时间。那么此时我们为了降低重复遍历的次数，就引入了“埋葬深度的概念”。若一个节点为不可移动点，则其埋葬深度为1；在此基础上，若其周围一圈全部为不可移动点，则其埋葬深度加一，为2；若更外围一圈依然全部为不可移动点，埋葬深度再加一，依次类推，下图列出了埋葬深度为1-3的情况：

 



 在为某一个节点第一次寻找替代点时以辐射型遍历此点周围节点以计算出此节点的埋葬深度并记录于每个节点对象Node类中新增的一个埋葬深度属性buriedDepth中，下一次为此点寻找替代点时就可以根据埋葬深度从存在可移动点的那一圈遍历

 



 

 在遍历原始终点U周围存在可移动点的那一圈之后把所有可移动点都存到一个数组中，之后比较此数组中全部候选点与起点的距离，选出距离最短的一个点作为替代点R即可。

 



 好吧，寻找替代点的过程大致就是这样，最后来看代码呗。先看节点类ANode类中一些要用到的新增属性和方法：

 

Java代码 复制代码   收藏代码
  1. public class ANode   
  2. {   
  3.         .....   
  4.         /** 埋葬深度 */  
  5.         public var buriedDepth:int = -1;   
  6.   
  7.         /** 距离 */  
  8.         public var distance:Number;   
  9.   
  10.         .....   
  11.         /** 得到此节点到另一节点的网格距离 */  
  12.         public function getDistanceTo( targetNode:ANode ):Number   
  13.         {   
  14.                 var disX:Number = targetNode.x - x;   
  15.                 var disY:Number = targetNode.y - y;   
  16.                 distance = Math.sqrt( disX * disX + disY * disY );   
  17.                 return distance;   
  18.         }   
  19. }  
public class ANode
{
        .....
        /** 埋葬深度 */
        public var buriedDepth:int = -1;

        /** 距离 */
        public var distance:Number;

        .....
        /** 得到此节点到另一节点的网格距离 */
        public function getDistanceTo( targetNode:ANode ):Number
        {
                var disX:Number = targetNode.x - x;
                var disY:Number = targetNode.y - y;
                distance = Math.sqrt( disX * disX + disY * disY );
                return distance;
        }
}
 

再看节点网格NodeGrid类中新增方法。

 

Java代码 复制代码   收藏代码
  1. /**当终点不可移动时寻找一个离原终点最近的可移动点来替代之 */  
  2. public function findReplacer( fromNode:ANode, toNode:ANode ):ANode   
  3. {   
  4.         var result:ANode;   
  5.         //若终点可移动则根本无需寻找替代点   
  6.         if( toNode.walkable )   
  7.         {   
  8.                 result = toNode;   
  9.         }   
  10.         //否则遍历终点周围节点以寻找离起始点最近一个可移动点作为替代点   
  11.         else  
  12.         {   
  13.                 //根据节点的埋葬深度选择遍历的圈   
  14.                 //若该节点是第一次遍历，则计算其埋葬深度   
  15.                 if( toNode.buriedDepth == -1 )   
  16.                 {   
  17.                         toNode.buriedDepth = getNodeBuriedDepth( toNode, Math.max(_numCols, _numRows) );   
  18.                 }   
  19.                 var xFrom:int = toNode.x - toNode.buriedDepth < 0 ? 0 : toNode.x - toNode.buriedDepth;   
  20.                 var xTo:int = toNode.x + toNode.buriedDepth > numCols - 1 ? numCols - 1 : toNode.x + toNode.buriedDepth;   
  21.                 var yFrom:int = toNode.y - toNode.buriedDepth < 0 ? 0 : toNode.y - toNode.buriedDepth;   
  22.                 var yTo:int = toNode.y + toNode.buriedDepth > numRows - 1 ? numRows - 1 : toNode.y + toNode.buriedDepth;                   
  23.   
  24.                 var n:ANode;//当前遍历节点   
  25.   
  26.                 for( var i:int=xFrom; i<=xTo; i++ )   
  27.                 {   
  28.                         for( var j:int=yFrom; j<=yTo; j++ )   
  29.                         {   
  30.                                 if( (i>xFrom && i<xTo) && (j>yFrom && j<yTo) )   
  31.                                 {   
  32.                                         continue;   
  33.                                 }   
  34.                                 n = getNode(i, j);   
  35.                                 if( n.walkable )   
  36.                                 {   
  37.                                         //计算此候选节点到起点的距离，记录离起点最近的候选点为替代点   
  38.                                         n.getDistanceTo( fromNode );   
  39.   
  40.                                         if( !result )   
  41.                                         {   
  42.                                                 result = n;   
  43.                                         }   
  44.                                         else if( n.distance < result.distance )   
  45.                                         {   
  46.                                                 result = n;   
  47.                                         }   
  48.                                 }   
  49.                         }   
  50.                 }   
  51.   
  52.         }   
  53.         return result;   
  54. }   
  55. /** 计算一个节点的埋葬深度  
  56.  * @param node                欲计算深度的节点  
  57.  * @param loopCount        计算深度时遍历此节点外围圈数。默认值为10*/  
  58. private function getNodeBuriedDepth( node:ANode, loopCount:int=10 ):int  
  59. {   
  60.         //如果检测节点本身是不可移动的则默认它的深度为1   
  61.         var result:int = node.walkable ? 0 : 1;   
  62.         var l:int = 1;   
  63.   
  64.         while( l <= loopCount )   
  65.         {   
  66.                 var startX:int = node.x - l < 0 ? 0 : node.x - l;   
  67.                 var endX:int = node.x + l > numCols - 1 ? numCols - 1 : node.x + l;   
  68.                 var startY:int = node.y - l < 0 ? 0 : node.y - l;   
  69.                 var endY:int = node.y + l > numRows - 1 ? numRows - 1 : node.y + l;                   
  70.   
  71.                 var n:ANode;   
  72.                 //遍历一个节点周围一圈看是否周围一圈全部是不可移动点，若是，则深度加一，   
  73.                 //否则返回当前累积的深度值   
  74.                 for(var i:int = startX; i <= endX; i++)   
  75.                 {   
  76.                         for(var j:int = startY; j <= endY; j++)   
  77.                         {   
  78.                                 n = getNode(i, j);   
  79.                                 if( n != node && n.walkable )   
  80.                                 {   
  81.                                         return result;   
  82.                                 }   
  83.                         }   
  84.                 }   
  85.   
  86.                 //遍历完一圈，没发现一个可移动点，则埋葬深度加一。接着遍历下一圈   
  87.                 result++;   
  88.                 l++;   
  89.         }   
  90.         return result;   
  91. }  
/**当终点不可移动时寻找一个离原终点最近的可移动点来替代之 */
public function findReplacer( fromNode:ANode, toNode:ANode ):ANode
{
        var result:ANode;
        //若终点可移动则根本无需寻找替代点
        if( toNode.walkable )
        {
                result = toNode;
        }
        //否则遍历终点周围节点以寻找离起始点最近一个可移动点作为替代点
        else
        {
                //根据节点的埋葬深度选择遍历的圈
                //若该节点是第一次遍历，则计算其埋葬深度
                if( toNode.buriedDepth == -1 )
                {
                        toNode.buriedDepth = getNodeBuriedDepth( toNode, Math.max(_numCols, _numRows) );
                }
                var xFrom:int = toNode.x - toNode.buriedDepth < 0 ? 0 : toNode.x - toNode.buriedDepth;
                var xTo:int = toNode.x + toNode.buriedDepth > numCols - 1 ? numCols - 1 : toNode.x + toNode.buriedDepth;
                var yFrom:int = toNode.y - toNode.buriedDepth < 0 ? 0 : toNode.y - toNode.buriedDepth;
                var yTo:int = toNode.y + toNode.buriedDepth > numRows - 1 ? numRows - 1 : toNode.y + toNode.buriedDepth;                

                var n:ANode;//当前遍历节点

                for( var i:int=xFrom; i<=xTo; i++ )
                {
                        for( var j:int=yFrom; j<=yTo; j++ )
                        {
                                if( (i>xFrom && i<xTo) && (j>yFrom && j<yTo) )
                                {
                                        continue;
                                }
                                n = getNode(i, j);
                                if( n.walkable )
                                {
                                        //计算此候选节点到起点的距离，记录离起点最近的候选点为替代点
                                        n.getDistanceTo( fromNode );

                                        if( !result )
                                        {
                                                result = n;
                                        }
                                        else if( n.distance < result.distance )
                                        {
                                                result = n;
                                        }
                                }
                        }
                }

        }
        return result;
}
/** 计算一个节点的埋葬深度
 * @param node                欲计算深度的节点
 * @param loopCount        计算深度时遍历此节点外围圈数。默认值为10*/
private function getNodeBuriedDepth( node:ANode, loopCount:int=10 ):int
{
        //如果检测节点本身是不可移动的则默认它的深度为1
        var result:int = node.walkable ? 0 : 1;
        var l:int = 1;

        while( l <= loopCount )
        {
                var startX:int = node.x - l < 0 ? 0 : node.x - l;
                var endX:int = node.x + l > numCols - 1 ? numCols - 1 : node.x + l;
                var startY:int = node.y - l < 0 ? 0 : node.y - l;
                var endY:int = node.y + l > numRows - 1 ? numRows - 1 : node.y + l;                

                var n:ANode;
                //遍历一个节点周围一圈看是否周围一圈全部是不可移动点，若是，则深度加一，
                //否则返回当前累积的深度值
                for(var i:int = startX; i <= endX; i++)
                {
                        for(var j:int = startY; j <= endY; j++)
                        {
                                n = getNode(i, j);
                                if( n != node && n.walkable )
                                {
                                        return result;
                                }
                        }
                }

                //遍历完一圈，没发现一个可移动点，则埋葬深度加一。接着遍历下一圈
                result++;
                l++;
        }
        return result;
}

 

 

那么最后，看看实际应用这个方法进行寻路的部分吧。

 

Java代码 复制代码   收藏代码
  1. private function onGridClick(event:MouseEvent):void  
  2. {   
  3.         var startTime:int = getTimer();   
  4.   
  5.         var startPosX:int = Math.floor(_player.x / _cellSize);   
  6.         var startPosY:int = Math.floor(_player.y / _cellSize);   
  7.         var startNode:ANode = _grid.getNode(startPosX, startPosY);   
  8.   
  9.         var endPosX:int = Math.floor(event.localX / _cellSize);   
  10.         var endPosY:int = Math.floor(event.localY / _cellSize);   
  11.         var endNode:ANode = _grid.getNode(endPosX, endPosY);   
  12.   
  13.         if( endNode.walkable == false )   
  14.         {   
  15.                 replacer = _grid.findReplacer(startNode, endNode);   
  16.                 if( replacer )   
  17.                 {   
  18.                         endPosX = replacer.x;   
  19.                         endPosY = replacer.y;   
  20.                 }   
  21.         }   
  22.   
  23.         _grid.setStartNode(startPosX, startPosY);   
  24.         _grid.setEndNode(endPosX, endPosY);   
  25.   
  26.         findPath();   
  27.   
  28. }  
private function onGridClick(event:MouseEvent):void
{
        var startTime:int = getTimer();

        var startPosX:int = Math.floor(_player.x / _cellSize);
        var startPosY:int = Math.floor(_player.y / _cellSize);
        var startNode:ANode = _grid.getNode(startPosX, startPosY);

        var endPosX:int = Math.floor(event.localX / _cellSize);
        var endPosY:int = Math.floor(event.localY / _cellSize);
        var endNode:ANode = _grid.getNode(endPosX, endPosY);

        if( endNode.walkable == false )
        {
                replacer = _grid.findReplacer(startNode, endNode);
                if( replacer )
                {
                        endPosX = replacer.x;
                        endPosY = replacer.y;
                }
        }

        _grid.setStartNode(startPosX, startPosY);
        _grid.setEndNode(endPosX, endPosY);

        findPath();

}
 

 

OK, 这就是本次教程全部内容了，使用“弗洛伊德路径平滑处理”结合“寻找替代点法”做寻路，不论效率还是结果都还算如人意啦。不过，细心的朋友可以发现，“寻找替代点法”的弊端在于无法在存在“孤岛”和“回”字形的路径网格中找到正确的替代点，如下图：

 



 所以为了避免此情况，要么就用上一篇帖子中提到的“极大代价法”来进行寻路（结果准确，效率过低），要么就在布置路径网格时刻意避免编出这种形式的路径网格。

最后，奉上全部测试用代码，希望对列位有所帮助： src.rar
mybloglucis009
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
A*寻路之路径平滑（二）
u014028063的博客
07-05 1万+
背景：在上一篇文章路径优化中对于A*传统寻路的结果不平滑的问题，为了解决生成折线Z型路线，我们尝试了一种判断两点间是否存在障碍物的算法，并在生成寻路路径时候先判断起终点间是否存在障碍物，若不存在障碍物，则路径数组中将只具有一个终点节点；否则调用A*寻路运算。大致过程可用下面代码表示：//判断起终点间是否存在障碍物，若存在则调用A*算法进行寻路，通过A*寻路得到的路径是一个个所要经过的节点数组；否不...
路径规划-基于分段五次多项式对路径平滑
最新发布
NEON7788的博客
06-12 703
其中， 表示路段的弧长变量（ ∈ [0, ]， 为各段路径的弧长）， , 、 , 表示路段 的第 个多项式系数（ ∈ {1,2, …其中， 表示路段 所对应的弧长，参数样条的一阶导数和二阶导数、、、分别反映路段中的路点坐标(, )随弧长 变化的一阶连续性和二阶连续性，为了后续能以QP公式的形式进行目标函数求解，将目标函数定义为导数的平方再积分的形式。假设两个相邻路段(, )和 (, )的端点相互连接，其中各路段的弧长， ∈ {1,2, …以相邻路段(, )和 (, )为例，构建平滑约束。
寻路算法 --- A星寻路算法
weixin_60569662的博客
03-25 1万+
深度寻路算法应用场景 仅用于空旷地形，小游戏或者大游戏的某个小模块，点击地图，人物一步步试探 广度寻路算法应用场景 只适用于小地图，回合制的走格子游戏，上帝视角，在走之前已经把路都找出来了 A* 寻路算法应用场景 应用场景广泛 RPG游戏：为什么小兵追着人物砍？怎么样知道人物在哪？怎么样给它自动规划路径？人物自动跑图，怎么实现？ 通过A星算法实现 以A星为基础的寻路算法：遗传算法，蚁群算法. . . A星寻路算法排除了广度的劣势：循环比较多，每一个点都要涉及到，集合了深度的思想实现..
总结一下最短路径的弗洛伊德算法（Floyd）
riba2534的博客
01-15 9610
看了好多大牛博客，我把弗洛伊德算法在这里总结一下。 弗洛伊德算法的介绍，先参考百度百科：Floyd算法 再来几篇可以参考的博文：http://www.wutianqi.com/?p=1903 http://www.cnblogs.com/biyeymyhjob/archive/2012/07/31/2615833.html ---------------------------------
算法：A星寻路（含实例）
weixin_52596036的博客
01-05 2228
a星寻路是寻路算法中比较常用的一种，核心是启发式寻路算法（曼哈顿方法），实际开发中常用于计算最优路径，自动寻路等......
最短路径—floyd（弗洛伊德）算法
qq_37562714的博客
11-25 229
A*寻路算法《三》
01-26
A*寻路算法是计算机图形学、游戏开发和人工智能领域中的一个重要算法，它用于寻找从起点到终点的最短路径。本节将深入探讨A*算法的原理、工作流程及其在Unity引擎中的应用。 A*算法的核心思想是结合了Dijkstra算法...
A Pathfinding Project Pro.rar a*寻路 4.1.16
12-17
《A*寻路技术在Unity中的应用》 在游戏开发中，寻路系统是不可或缺的一部分，它使得游戏角色能够智能地在复杂环境中找到最优路径。...开发者可以通过灵活运用这些工具和算法，创造出更加真实和智能的游戏世界。
A*寻路算法《五》
01-26
A*寻路算法是计算机图形学、游戏开发和人工智能领域中...通过理解并熟练运用A*，开发者可以创建更加智能和真实的虚拟世界。同时，掌握A*算法也有助于理解其他相关领域，如图论、最优化问题和机器学习中的路径规划问题。
A星寻路插件A*Pathfind Project
02-23
A星(A*)路径搜索算法是游戏开发中广泛使用的寻路技术，特别是在Unity这样的3D游戏引擎中。这个“A星寻路插件A*Pathfind Project”提供了一个方便、高效的解决方案，帮助开发者实现在复杂的游戏环境中实现智能AI角色...
自动驾驶路径规划，A*和蚁群两种算法，matlab，可运行！
02-13
自动驾驶路径规划，带有图形界面，找到最短、最优路径 采用两种算法：A*和蚁群两种算法。找到最优路径后，通过卡尔曼滤波进行平滑处理。 语言：matlab。
java弗洛伊德输出最短路径及路径长度的算法
07-11
java数据结构课程设计校园超市选址中，我们要用到弗洛伊德算法输出最短路径及最短路径长度，输出的路径用点--->点表示，本文件提供输出的代码。
弗洛伊德 算法matlab
07-30
弗洛伊德 算法matlab源程序，求任意两点之间的最短距离，很不错的算法！
局部路径规划专栏之3.3：佛洛依德floyd路径平滑算法
qq_35635374的博客
04-28 346
认知有限，望大家多多包涵，有什么问题也希望能够与大家多交流，共同成长！本文先对**基于地图的平滑算法–佛洛依德路径平滑算法（FLOYD）**做个简单的介绍，具体内容后续再更，其他模块可以参考去我其他文章提示：以下是本篇文章正文内容。
路径规划/路径平滑涉及方法汇总
豆皮卷香菜
10-12 8217
这是一个目录1. 背景与参考文献2. Hybrid A* 搜索过程3. Hybrid A* 平滑过程3.1 轨迹平滑目标函数3.3 Voronoi field3.3.1 github repo[2]中使用方法3.3.2 Voronoi field的优化可能 1. 背景与参考文献 路径生成与路径平滑相关问题之前了解过，这次重新捡起来。起因是为了实现Hybrid A*，该方法中涉及了较多模块，为了弄清楚模块之间的关系以便于后续改进，近期阅读了一些相关的文献，在本文中进行梳理。 Hybrid A* 文献： 这篇文
【路径规划】A*算法方法改进思路简析
热门推荐
m0_56662453的博客
08-20 2万+
对A*算法进行基本功能实现，以分析其优缺点，并在此基础上进行改进。改进的内容为，将针对特定地图的相关特点，设计合理的预估函数，设置了包含代价函数和启发函数的权重函数，其次，将传统的8方向搜索降为5个方向，舍弃无用的方向，然后在此基础上，对开放列表的数据结构进行堆优化，并且采用双向A*算法进一步提高计算速度，并针对实际机器人运动过程中的路径不平滑问题采用贝塞尔曲线进行平滑化处理。
【路径规划】基于A星算法结合floyd和动态窗口法实现机器人栅格地图路径规划附matlab代码
m0_57702748的博客
06-17 666
1 算法原理A*算法结合Floyd算法和动态窗口法可以实现机器人在栅格地图上的路径规划。下面是一个基本的步骤：栅格地图表示：将待规划的区域划分为一组栅格，每个栅格代表一个离散的位置，其中包括可通过的栅格和障碍物。Floyd算法处理地：使用Floyd算法计算任意两个栅格之间的最短路径距离，并生成对应的路径矩阵或邻矩阵。初始化启发式值和开放列表：为每个栅格设置启发式值（如曼哈顿距离或欧几里得距离），并初始化开放列表来记录待访问的栅格。A*搜索过程：选择起始栅格作为当前节点。
碰撞检测算法：点和矩形碰撞、点和圆形碰撞、矩形碰撞、圆形碰撞
weixin_33814685的博客
02-09 805
一，原理介绍 这回有点复杂，不过看懂了还是很好理解的。当然，我不敢保证这种算法在任何情况下都会起效果，如果有同学测试时，发现出现错误，请及时联系我。 我们首先来建立一个以圆心为原点的坐标系： 然后要检测碰撞就只有两种情况了。   情况一，矩形全部都在一个象限内，如图： 当然，图中只是举个例子，不一定是只在第二象限，任何一个象限都行，只要是矩形全在该象限。 这种情况比较好解决，...
tilemap a*寻路
05-12
Tilemap A*寻路是一种用于游戏开发的寻路算法。它基于网格状地图，即用方块或瓦片组成的地图，在地图上寻找最短路径。 A*寻路算法通过启发式搜索，利用估价函数来选择下一步的方向，使得每一步都朝着目标更近的方向前进。这样能够更快速地找到最短路径，同时也减少了搜索空间，提高了算法效率。 Tilemap A*寻路算法将地图分成一个个小块，称为瓦片或格子，将每个瓦片看作是一个节点，用连接相邻瓦片的边表示节点间的连通关系。通过对每个瓦片计算启发函数估价，计算出各瓦片到目标点的距离，然后利用A*算法在网格状地图上进行搜索，找到从起点到目标点的最短路径。 Tilemap A*寻路算法可以应用于各种类型的游戏中。它可用于实时策略游戏、角色扮演游戏、平面射击游戏等游戏中，或者是用于移动机器人等领域中的路径规划。通过Tilemap A*寻路算法的应用，游戏玩家可以在游戏中获得更真实、更流畅、更丰富的游戏体验，提高了游戏的可玩性和趣味性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值