精华内容
下载资源
问答
  • 迷宫寻路

    2012-12-19 09:53:54
    写了一个小程序,使用BFS(宽度优先),GREED(贪婪算法),A*(启发式),GA(遗传算法)来解决迷宫寻路问题,大家看看算法有没有可以的改进的地方?源代码可以直接查看。 Demo地址: [url]...
    写了一个小程序,使用BFS(宽度优先),GREED(贪婪算法),A*(启发式),GA(遗传算法)来解决迷宫寻路问题,大家看看算法有没有可以的改进的地方?源代码可以直接查看。

    Demo地址: [url]http://slab.sinaapp.com/pathfinder/[/url]

    由于使用了canvas来显示,所以请使用支持html5的浏览器来查看(chrome,firefox,IE9+等)。

    [img]http://dl.iteye.com/upload/attachment/0078/1211/59633bd3-8962-30eb-8d08-696de4e8018f.jpg[/img]
    展开全文
  • java实现寻路

    千次阅读 2016-04-09 15:48:53
    package com.person.appframework.test;... * 图寻路算法  * 深度回溯  * @author wuwhe  *  */ public class GraphPath {  private int[][] block;  /** 高度 */  private int maxHeigh

    package com.person.appframework.test;

    import java.util.Stack;

    /**
     * 图寻路算法
     * 深度回溯
     * @author wuwhe
     *
     */
    public class GraphPath {

     private int[][] block;

     /** 高度 */
     private int maxHeight;

     /** 宽度 */
     private int maxWidth;
     /** 结束x坐标 */
     private int targetx = 9;
     /** 结束y坐标 */
     private int targety = 9;
     /** 回溯节点需要的路径 */
     private Stack stack = new Stack();
     /** 开始坐标 */
     private int startx;
     /** 结束时间 */
     private int starty;
     /** 状态保存 */
     private NodeInfo[][] table=null;

     private boolean isCompelet = true;

     private boolean result = false;
     

     GraphPath(int[][] grapdata) {
      this.block = grapdata;
      this.maxHeight = block.length;
      this.maxWidth = block[0].length;
      table = new NodeInfo[maxHeight][maxWidth];
      // initTable();

     }

     /**
      * 初始化路径的表格
      */
     public void initTable() {
      for (int i = 0; i < maxHeight; i++)
       for (int j = 0; j < maxWidth; j++) {
        NodeInfo node = new NodeInfo();
        node.tagx = i;
        node.tagy = j;
        table[i][j] = node;
       }
     }

     public boolean findPath(int x, int y, int endx, int endy) {
      this.targetx = endx;
      this.targety = endy;
      this.startx = x;
      this.starty = y;
      initTable();
      this.deepPathLocation(x, y);
      return result & isCompelet;
     }

     public void printPath() {
      for (int i = 0; i < maxWidth; i++) {
       for (int j = 0; j < maxHeight; j++) {

        NodeInfo info = table[i][j];
        if (info.isPaht == 1) {
         System.out.print("1");
        } else {
         System.out.print(" ");
        }
       }
       System.out.println();

      }
     }

     /**
      * 是否到达
      *
      * @param x
      * @param y
      * @return
      */
     public boolean isOk(int x, int y) {
      if (x == targetx && y == targety)
       return true;
      return false;
     }

     /**
      * 判断是否通过
      *
      * @param x
      * @param y
      * @return
      */
     private boolean check(int x, int y) {

      // 地址越界
      if (x >= maxWidth || x < 0)
       return false;
      if (y >= maxHeight || y < 0)
       return false;
      // 是否曾经来过
      NodeInfo info = table[x][y];
      if (info.isPaht > 0)
       return false;
      // 是否可以通过
      if (block[x][y] == 1)
       return false;
      return true;
     }

     /**
      * 深度优先算法
      *
      * @param x
      * @param y
      */
     private void deepPathLocation(int x, int y) {
      NodeInfo info = table[x][y];
      // 判断是否到达,如果到达 直接返回
      if (isOk(x, y)) {
       info.isPaht = 1;
       result = true;
       return;
      }

      // 如果没有到达,先看x+1 是否可以通过 如果可以通过
      // 可以向右
      if (info.x == 0) {
       System.out.println("向下边");
       info.x = 1;
       // 可以移动
       if (check(x + 1, y)) {
        // 想右边移动
        // 记录当前为已经过来的
        info.isPaht = 1;
        stack.push(info);
        deepPathLocation(x + 1, y);
       } else {

        // 看其他的路
        deepPathLocation(x, y);
       }
       // 右边已经走了

      }
      // 右边已经走了看下边可以走吗
      else if (info.buttom == 0) {
       System.out.println("向右走");
       info.buttom = 1;
       if (check(x, y + 1)) {
        // 想右边移动
        info.isPaht = 1;
        stack.push(info);
        deepPathLocation(x, y + 1);

       } else {
        deepPathLocation(x, y);
       }

      }

      else if (info.y == 0) {
       info.y = 1;
       if (check(x, y - 1)) {
        info.isPaht = 1;
        stack.push(info);
        deepPathLocation(x, y - 1);
       } else {
        deepPathLocation(x, y);
       }
      }

      else if (info.left == 0) {
       System.out.println("向后");
       info.left = 1;
       if (check(x - 1, y)) {
        info.isPaht = 1;
        stack.push(info);
        deepPathLocation(x - 1, y);

        // info.left=1;
       } else {
        deepPathLocation(x, y);
       }
      }
      // 回退
      else {
       // 去掉当前路径
       if (!stack.isEmpty()) {
        info.isPaht = 0;
        System.out.println("后退回去");
        NodeInfo preinfo = (NodeInfo) stack.pop();
        deepPathLocation(preinfo.tagx, preinfo.tagy);
       } else {
        System.out.println("死在这里弹出" + info);
        isCompelet = false;
       }

      }
     }
     
     
     /**
      * 节点状态统计
      * @author wuwhe
      *
      */
      private  class NodeInfo {
      //當前在圖中的x坐標
       int tagx;
       //當前在圖中的y坐標
       int tagy;
       //右邊是否有同路
       int x;
       //上邊是否有同路
       int y;
       //左邊是佛有同路
       int left;
       //底部是否有同路
       int buttom;
       int isPaht;
       @Override
      public String toString() {
       // TODO Auto-generated method stub
       return "tagx:"+tagx+"tagy:"+tagy+"x:"+x+" y:"+y +"left:"+left+" buttom:"+buttom+" isPath:"+isPaht;
      }
      
      public void resetLevel(){
        this.x=0;
        this.y=0;
        this.left=0;
        this.buttom=0;
       
       }
      }
     
     public static void main(String[] a){
      
      int[][] data = {{0,1,1,1,1,1,0},
                {0,1,1,1,1,1,0},
                {0,0,1,1,1,1,0},
                {1,0,0,1,0,0,1},
                {1,1,0,1,0,0,0},
                {1,1,0,0,0,1,0},
                {1,1,1,1,1,1,0},
             };
      GraphPath grap = new GraphPath(data);
      if(grap.findPath(0, 0, 6, 6)){
       grap.printPath();
      }
      
     }

    }

    展开全文
  • 最近要参加学校的APP比赛,我们组做的是一个3D迷宫的小APP,我负责的是迷宫的生成与寻路寻路算法选择的是A*寻路算法,具体参考的是下面的这篇博客。 本文主要是谈谈自己对A*算法的理解,具体细节,上文链接以及...

    最近要参加学校的APP比赛,我们组做的是一个3D迷宫的小APP,我负责的是迷宫的生成与寻路。

    寻路算法选择的是A*寻路算法,具体参考的是下面的这篇博客。

    本文主要是谈谈自己对A*算法的理解,具体细节,上文链接以及讲的很详细了。

    http://www.cnblogs.com/technology/archive/2011/05/26/2058842.html

    关于A*算法的实现我是用的广度优先搜索这种比较常见的实现模式。

     

    那么关于这两者之间的关系是怎么样呢?

    个人理解的是A*算法其实是一种带有路径信息的有策略的广度优先搜索,我们平常用的广度优先搜索,没有带有路径信息,搜索起来是一种盲目的搜索。

    例如,当寻路到A节点时,下一步是以A为中心,分别测试A周围的8个点,并且又以它们为中心,继续向外扩散,以期找到待寻找的点。

    这样的搜索带有盲目性,测试了大量的无效的点。

     

    A*算法在每个节点中加入了路径的信息:

    F:当前点的路径信息,包含了到当前点到起点与到终点的信息。(F=G+H)

    G:当前点到唯一的起点的路径信息。

    H:当前点到指定终点的距离信息。

     

    那么我们怎么样通过这些指定的路径信息来避免广度优先搜索的盲目选取下一个路径点而得到一条最小路径呢? 

    其实我们可以把这看成是一个最小路径的“感染”问题。

    F B C D

    E A G H

    I  N K L

    如上图:

    首先参照上文博客,水平方向移动一格路径代价是10,斜方向移动一格路径代价是14。

    起点A的G值初始化0,这个当然,自己到自己的距离是0;其它点中的G初始化为INT_MAX;通过对A的广度搜索,来设置各个节点的G值与父节点。

    例:A的八个方向,FBCEGINK,选取出F最小的点,假设为G。

         对G的八个方向,BCDAHNKL,我们同样需要设定这8个方向的G值与父节点。这8个方向中与A重叠的有BCNK。

         重叠意味着有两条路径,对于K来说,可以是A->K,也可以是A->G->K。

    那么怎么样选择呢?

    这时我们要判断G的值,哪条路径使得G的值最小,我们就选择它。

    G的值是起点A到本节点的路径长度,这是一个累积的值,是前面各个G一路累积(感染)下来的,代表的是当前的路径,我们选择的肯定是使得K的G最小,这样对整个最小路径都是有利的,因为可以一直感染下去。

    那么H的作用在哪里呢?

    H仅仅是对路径方向的一个大致的判断,上图中,若指定终点在A的右边,那么EFI肯定不会被选中,这样就不用盲目的8个方向都去判断。

     

    终上所述:

    G和H的作用共同体现于F中,每次我们都是在广度搜索中去寻找F最小的点,然后根据G的值,设置下一个广度搜索中的节点的父节点,父节点永远是使得子节点中的G值最小。(到起点A的路径最短)。

     

    自己写的A*的核心函数代码,测试curr节点的周围8个节点,并且设置路径及父节点信息,其余的部分则是广度优先搜索的框架,这里不再写出来。

     

     1 void getSurrroundPoints(point& curr, list<point>& result)
     2 {
     3     int x = curr.m_x;                              //curr坐标信息
     4     int y = curr.m_y;
     5     
     6     for (int i = x-1;i <= x+1; i++)
     7     {
     8         for (int j = y - 1; j <= y + 1; j++)       //8个方向
     9         {
    10             if (i == x && j == y)                  //循环到自己,跳过此次循环
    11                 continue;
    12 
    13             if ( find_if(closeList.begin(), closeList.end(), pointEqualLocation(i, j)) == closeList.end()  //当前节点还没有被检查过
    14                 &&canReach(i, j))                                                                          //当前节点不是障碍物
    15             {            
    16                 if (x == i || y == j)      //上下左右四个方向 g=10
    17                 {
    18                     if ((curr.m_g + 10) >= point_ptr[i][j].m_g)
    19                     {
    20                                           //start到(i,j)的 不必经过curr 
    21                                           //什么也不做,保留原来的路径信息与父节点
    22                     }
    23                     else
    24                     {                    //start到(i,j)的 经过curr路径会更小 
    25                                          //更新路径信息 更改父节点
    26                         point_ptr[i][j].m_g = curr.m_g + 10;      //更新节点中的G值
    27                         point_ptr[i][j].m_fx = curr.m_x;          //设置父节点
    28                         point_ptr[i][j].m_fy = curr.m_y;
    29 
    30                     }
    31                 }
    32                 else                     //斜方向 g=14;
    33                 {
    34                     if ((curr.m_g + 14) >= point_ptr[i][j].m_g)
    35                     {
    36                                         //start到(i,j)的 不必经过curr 
    37                                         //什么也不做,保留原来的路径信息与父节点
    38                     }
    39                     else
    40                     {                    //start到(i,j)的 经过curr路径会更小 
    41                                           //更新路径信息 更改父节点
    42                         point_ptr[i][j].m_g = curr.m_g + 14;    //更新节点中的G值
    43                         point_ptr[i][j].m_fx = curr.m_x;        //设置父节点
    44                         point_ptr[i][j].m_fy = curr.m_y;
    45 
    46                     }
    47                 }
    48                 point_ptr[i][j].m_h = abs(endPoint_x - i) + abs(endPoint_y - j);  //计算到终点的距离
    49                 point_ptr[i][j].m_f = point_ptr[i][j].m_g + point_ptr[i][j].m_h;  //F=G+H
    50 
    51                 result.push_back(point_ptr[i][j]);                  //放到链表中 等待下次的检查
    52             }
    53         }
    54     }
    55 }

     

     

     

     

     

     

    转载于:https://www.cnblogs.com/coder-chen/p/4442820.html

    展开全文
  • A星寻路算法介绍

    2014-02-27 15:57:26
    这篇文章还可以在这里...他是Hot Apps Factory的创始人,该公司开发了App Cooker。   学习A星寻路算法是如何工作的! 你是否在做一款游戏的时候想创造一些怪兽或者游戏主角,让它们移动到特定的位置

    这篇文章还可以在这里找到 英语

    这篇blog是由iOS Tutorial Team的成员  Johann Fradj发表的,他目前是一位全职的资深iOS开发工程师。他是Hot Apps Factory的创始人,该公司开发了App Cooker

     

    Learn how the A* Pathfinding Algorithm Works!

    学习A星寻路算法是如何工作的!

    你是否在做一款游戏的时候想创造一些怪兽或者游戏主角,让它们移动到特定的位置,避开墙壁和障碍物呢?

    如果是的话,请看这篇教程,我们会展示如何使用A星寻路算法来实现它!

    在网上已经有很多篇关于A星寻路算法的文章,但是大部分都是提供给已经了解基本原理的高级开发者的。

    本篇教程将从最基本的原理讲起。我们会一步步讲解A星寻路算法,幷配有很多图解和例子。

    不管你使用的是什么编程语言或者操作平台,你会发现本篇教程很有帮助,因为它在非编程语言的层面上解释了算法的原理。稍后,会有一篇教程,展示如何在Cocos2D iPhone 游戏中实现A星算法。

    现在找下到达一杯咖啡因饮料和美味的零食的最短路径,开始吧!:]

    一只探路猫

     

    让我们想象一下,有一款游戏,游戏中一只猫想要找到获取骨头的路线。

    “为什么会有一只猫想要骨头?!”你可能会这么想。在本游戏中, 这是一只狡猾的猫,他想捡起骨头给狗,以防止被咬死!:]

    现在想像一下下图中的猫想找到到达骨头的最短路径:

    This cat just wants someone to throw him a bone!

    不幸的是,猫不能直接从它当前的位置走到骨头的位置,因为有面墙挡住了去路,而且它在游戏中不是一只幽灵猫!

    游戏中的猫同样懒惰,它总是想找到最短路径,这样当他回家看望它的女朋友时不会太累:-)

    但是我们如何编写一个算法计算出猫要选择的那条路径呢?A星算法拯救了我们!

     

    简化搜索区域

     

    寻路的第一步是简化成容易控制的搜索区域。

    怎么处理要根据游戏来决定了。例如,我们可以将搜索区域划分成像素点,但是这样的划分粒度对于我们这款基于方块的游戏来说太高了(没必要)。

    作为代替,我们使用方块(一个正方形)作为寻路算法的单元。其他的形状类型也是可能的(比如三角形或者六边形),但是正方形是最简单并且最适合我们需求的。

    像那样去划分,我们的搜索区域可以简单的用一个地图大小的二维数组去表示。所以如果是25*25方块大小的地图,我们的搜索区域将会是一个有625个正方形的数组。如果我们把地图划分成像素点,搜索区域就是一个有640,000个正方形的数组了(一个方块是32*32像素)!

    现在让我们基于目前的区域,把区域划分成多个方块来代表搜索空间(在这个简单的例子中,7*6个方块 = 42 个方块):

    Dividing the maze into a tile-based search area

     

    Open和Closed列表

     

    既然我们创建了一个简单的搜索区域,我们来讨论下A星算法的工作原理吧。

    除了懒惰之外,我们的猫没有好的记忆力,所以它需要两个列表:

    1. 一个记录下所有被考虑来寻找最短路径的方块(称为open 列表)
    2. 一个记录下不会再被考虑的方块(成为closed列表)

    猫首先在closed列表中添加当前位置(我们把这个开始点称为点 “A”)。然后,把所有与它当前位置相邻的可通行小方块添加到open列表中。

    下图是猫在某一位置时的情景(绿色代表open列表):
    Adding adjacent tiles from the start position to the open list

    现在猫需要判断在这些选项中,哪项才是最短路径,但是它要如何去选择呢?

    在A星寻路算法中,通过给每一个方块一个和值,该值被称为路径增量。让我们看下它的工作原理!

    路径增量

     

    我们将会给每个方块一个G+H 和值:

    • G是从开始点A到当前方块的移动量。所以从开始点A到相邻小方块的移动量为1,该值会随着离开始点越来越远而增大。
    • H是从当前方块到目标点(我们把它称为点B,代表骨头!)的移动量估算值。这个常被称为探视,因为我们不确定移动量是多少 – 仅仅是一个估算值。

    你也许会对“移动量”感兴趣。在游戏中,这个概念很简单 – 仅仅是方块的数量。

    然而,在游戏中你可以对这个值做调整。例如:

    • 如果你允许对角线移动,你可以针对对角线移动把移动量调得大一点。
    • 如果你有不同的地形,你可以将相应的移动量调整得大一点 – 例如针对一块沼泽,水,或者猫女海报:-)

    这就是大概的意思 – 现在让我们详细分析下如何计算出G和H值。

    关于G值

     

    G是从开始点A到达当前方块的移动量(在本游戏中是指方块的数目)。

    为了计算出G的值,我们需要从它的前继(上一个方块)获取,然后加1。所以,每个方块的G值代表了从点A到该方块所形成路径的总移动量。

    例如,下图展示了两条到达不同骨头的路径,每个方块都标有它的G值:
    An illustration of the G variable in the A* Pathfinding Algorithm

    关于H值

    H值是从当前方块到终点的移动量估算值(在本游戏中是指方块的数目)。

    移动量估算值离真实值越接近,最终的路径会更加精确。如果估算值停止作用,很可能生成出来的路径不会是最短的(但是它可能是接近的)。这个题目相对复杂,所以我们不会再本教程中讲解,但是我在教程的末尾提供了一个网络链接,对它做了很好的解释。

    为了让它更简单,我们将使用“曼哈顿距离方法”(也叫“曼哈顿长”或者“城市街区距离”),它只是计算出距离点B,剩下的水平和垂直的方块数量,略去了障碍物或者不同陆地类型的数量。

    例如,下图展示了使用“城市街区距离”,从不同的开始点到终点,去估算H的值(黑色字):
    An illustration of the H variable in the A* pathfinding algorithm with the Manhattan algorithm

    A星算法

     

    既然你知道如何计算每个方块的和值(我们将它称为F,等于G+H),  我们来看下A星算法的原理。

    猫会重复以下步骤来找到最短路径:

    1. 将方块添加到open列表中,该列表有最小的和值。且将这个方块称为S吧。
    2. 将S从open列表移除,然后添加S到closed列表中。
    3. 对于与S相邻的每一块可通行的方块T:
    1. 如果T在closed列表中:不管它。
    2. 如果T不在open列表中:添加它然后计算出它的和值。
    3. 如果T已经在open列表中:当我们使用当前生成的路径到达那里时,检查F 和值是否更小。如果是,更新它的和值和它的前继。

    如果你对它的工作原理还有点疑惑,不用担心 – 我们会用例子一步步介绍它的原理!:]

    猫的路径

    让我们看下我们的懒猫到达骨头的行程例子。

    在下图中,我根据以下内容,列出了公式F = G + H 中的每项值:

    • F(方块的和值):左上角
    • G(从A点到方块的移动量):左下角
    • H(从方块到B点的估算移动量): 右下角

    同时,箭头指示了到达相应方块的移动方向。

    最后,在每一步中,红色方块表示closed列表,绿色方块表示open列表。

    好的,我们开始吧!

    第一步

    第一步,猫会确定相对于开始位置(点A)的相邻方块,计算出他们的F和值,然后把他们添加到open列表中:
    A* Example Part 1

    你会看到每个方块都列出了H值(有两个是6,一个是4)。我建议根据“城市街区距离”去计算方块的相关值,确保你理解了它的原理。

    同时注意F值(在左上角)是G(左下角)值和H(右下脚)值的和。
    第二步

    在第二步中,猫选择了F和值最小的方块,把它添加到closed列表中,然后检索它的相邻方块的相关数值。
    A* Example Part 2

    现在你将看到拥有最小增量的是F值为4的方块。猫尝试添加所有相邻的方块到open列表中(然后计算他们的和值),除了猫自身的方块不能添加以外(因为它已经被添加到了closed列表中)或者它是墙壁方块(因为它不能通行)。

    注意被添加到open列表的两个新方块,他们的G值都增加了1,因为他们现在离开始点有2个方块远了。你也许需要再计算下“城市街区距离”以确保你理解了每个新方块的H值。
    第三步

    再次,我们选择了有最小F和值(5)的方块,继续重复之前的步骤:
    A* Example Part 3

    现在,只有一个可能的方块被添加到open列表中了,因为已经有一个相邻的方块在close列表中,其他两个是墙壁方块。

    第四步

    现在我们遇到了一个有趣的情况。正如你之前看到的,有4个方块的F和值都为7 – 我们要怎么做呢?!

    有几种解决方法可以使用,但是最简单(快速)的方法是一直跟着最近被添加到open列表中的方块。现在继续沿着最近被添加的方块前进。
    A* Example Part 4

    这次有两个可通过的相邻方块了,我们还是像之前那样计算他们的和值。
    第五步

    接着我们选择了最小和值(7)的方块,继续重复之前的步骤:
    A* Example Part 5

    我们越来越接近终点了!

    第六步

    你现在训练有素了!我打赌你能够猜出下一步是下面这样子了:
    A* Example Part 6

    我们差不多到终点了,但是这次你看到有两条到达骨头的最短路径提供给我们选择:
    Two shortest paths to the bone

    在我们的例子中,有两条最短路径:

    • 1-2-3-4-5-6
    • 1-2-3-4-5-7

    It doesn’t really matter which of these we choose, it comes down to the actual implementation in code.

    选择哪一条其实没关系,现在到了真正用代码实现的时候了。

    第七步

    让我们从其中一块方块,再重复一遍步骤吧:
    A* Example Part 7

    啊哈,骨头在open列表中了!
    第八步

    现在目标方块在open列表中了,算法会把它添加到closed列表中:
    A* Example Part 8

    然后,算法要做的所有事情就是返回,计算出最终的路径!
    A* Example Part 9

    一只有远见的猫

    在上面的例子中,我们看到当猫在寻找最短路径时,它经常选择更好的方块(那个在它的未来最短路径上的方块)- 好像它是一只有远见的猫!

    但是如果猫是盲目的,并且总是选择第一个添加到它的列表上的方块,会发生什么事情?

    下图展示了所有在寻找过程中会被使用到的方块。你会看到猫在尝试更多的方块,但是它仍然找到了最短路径(不是之前的那条,而是另一条等价的):
    What would happen if the cat wasn't so smart...

    图中的红色方块不代表最短路径,它们只是代表在某个时候被选择为“S”的方块。

    我建议你看着上面的图,并且尝试过一遍步骤。这次无论你看到哪个相邻的方块,都选择“最坏”的方式去走。你会发现最后还是找到了最短路径!

    所以你可以看到跟随一个“错误的”方块是没有问题的,你仍然会在多次重复尝试后找到最短路径。

    所以在我们的实现中,我们会按照以下的算法添加方块到open列表中:

    • 相邻的方块会返回这些顺序: 上面/左边/下面/右边。
    • 当所有的方块都有相同的和值后,方块会被添加到open列表中(所以第一个被添加的方块是第一个被猫挑选的)。

    下面是从原路返回的示意图:
    The cat finding the shortest path, even after some wrong turns

    最短的路径是从终点开始,一步步返回到起点构成的(例子:在终点我们可以看到箭头指向右边,所以该方块的前继在它的左边)。

    总的来说,我们可以用下面的伪代码,合成猫的寻找过程。这是Objective-C写的,但是你可以用任何的语言去实现它:

    [openList add:originalSquare]; // start by adding the original position to the open list
    do {
    	currentSquare = [openList squareWithLowestFScore]; // Get the square with the lowest F score
     
    	[closedList add:currentSquare]; // add the current square to the closed list
    	[openList remove:currentSquare]; // remove it to the open list
     
    	if ([closedList contains:destinationSquare]) { // if we added the destination to the closed list, we've found a path
    		// PATH FOUND
    		break; // break the loop
    	}
     
    	adjacentSquares = [currentSquare walkableAdjacentSquares]; // Retrieve all its walkable adjacent squares
     
    	foreach (aSquare in adjacentSquares) {
     
    		if ([closedList contains:aSquare]) { // if this adjacent square is already in the closed list ignore it
    			continue; // Go to the next adjacent square
    		}
     
    		if (![openList contains:aSquare]) { // if its not in the open list
     
    			// compute its score, set the parent
    			[openList add:aSquare]; // and add it to the open list
     
    		} else { // if its already in the open list
     
    			// test if using the current G score make the aSquare F score lower, if yes update the parent because it means its a better path
     
    		}
    	}
     
    } while(![openList isEmpty]); // Continue until there is no more available square in the open list (which means there is no path)

     

    现在是不是对实现它很兴奋了?!在接下来的教程中,我们将会这么做!

     

    展开全文
  • 寻路可视化器-源码

    2021-02-20 12:35:49
    Create React App入门 该项目是通过。 可用脚本 在项目目录中,可以运行: npm start 在开发模式下运行应用程序。 打开在浏览器中查看。 如果进行编辑,页面将重新加载。 您还将在控制台中看到任何棉绒错误。 npm ...
  • iOS google 公交寻路

    2014-04-23 18:33:15
    在stackoverflow找到了解决方法:http://stackoverflow.com/questions/1563880/launch-google-maps-app-from-iphone-application CLLocationCoordinate2D stationLocation = ... NSString *urlString = [...
  • 他是Hot Apps Factory的创始人,该公司开发了App Cooker。 学习A星寻路算法是如何工作的! 你是否在做一款游戏的时候想创造一些怪兽或者游戏主角,让它们移动到特定的位置,避开墙壁和障碍物呢? 如果是的话,请...
  • Unity2D寻路插件Polynav2D-1.5.2

    千次阅读 2019-01-02 22:07:59
    链接: https://pan.baidu.com/s/1EgpVTsPNFuFrJCQBlrTFyg 提取码: 8nkm 复制这段内容后打开百度网盘手机App,操作更方便哦
  • 2D寻路可视化器 现场演示: : 目前仅Dijkstra可用 堆 React钩 样式预处理器 可用脚本(create-react-app) 在项目目录中,可以运行: yarn start 在开发模式下运行应用程序。 打开在浏览器中查看。 如果进行编辑...
  • 他还是Hot Apps Factory的创始人,该公司开发了App Cooker。   添加A星寻路算法到简单的Cocos2D游戏中! 在本篇教程中,你将学到如何在一款简单的cocos2D游戏中使用A星寻路算法。 在学习本篇教程...
  • 本文ray官方中英阅读地址:... 这篇blog是由iOS Tutorial Team的成员 Johann Fradj发表的,他目前是一位全职的资深iOS开发工程师。他是Hot Apps Factory的创始人,该公司开发了App Cooker。 学
  • 从今天开始给大家逐步讲解单片机编程,有兴趣的小伙伴们,可以关注本课程,完全免费本人从事从2004年大学毕业开始从事开发工作,先后做过单片机开发、ucOSII开发、手机开发、android APP开发、PHP开发、微信小程序...
  • 转载自 ... 这篇blog是由iOS Tutorial Team的成员 Johann Fradj发表的,他目前是一位全职的资深iOS开发工程师。他还是Hot Apps Factory的创始人,该公司开发了App Cooker。
  • 题目链接:http://gdutcode.sinaapp.com/problem.php?cid=1031&pid=2 题目由于要找对称的路径,那么狠明显可以把右下角的每一块加到左上角对应的每一块上。然后就变成从左上角走到对角线的最短路径的个数。 先...
  • 他是Hot Apps Factory(其是App Cooker的创造者)的共同创建者. 学习A*寻路算法是如何实现的! 你是否在你的游戏中想要怪物或者玩家移动到特定的地点,同时避免墙和障碍物? 如果是,读一读这篇课程,它将向你展示你能...
  • csdn第一天

    2013-12-25 23:15:46
    一个开源的是A*寻路的demo 因为之前是做ios应用的不是做游戏的 所以用的是uikit 框架去实现了..不是cocos2d 这个应用我在code4app上开源了, 现在还不知道 csdn哪里上传demo http://code4app.com/ios
  • 寻路者 映射工具 项目URL 截图 影片 许可证 发展历程 测试服务器: : 运行当前develop分支 SISI ESI (确保使用您的测试服务器客户端) 可用于公共测试(例如,新功能,…) 数据库将不时清除 安装指南: ...
  • 用户在APP上提交申请,填写外卖、快递的必要信息,小车出发,分析位置信息,寻路,避障,寻找外卖大哥,呼喊外卖大哥,等待大哥将钢放入篮子,寻路,避障,敲肥宅的门,等待取走物品,over。 鉴于实现起来难度...
  • 【算法导论】A*算法(A星算法)

    千次阅读 2014-08-22 13:03:08
    这篇文章还可以在这里...他是Hot Apps Factory的创始人,该公司开发了App Cooker。   学习A星寻路算法是如何工作的! 你是否在做一款游戏的时候想创造一些怪兽或者游戏主角,让它们移动到特定的位置
  • A* 算法

    2014-06-02 19:31:17
    他是Hot Apps Factory的创始人,该公司开发了App Cooker。   学习A星寻路算法是如何工作的! 你是否在做一款游戏的时候想创造一些怪兽或者游戏主角,让它们移动到特定的位置,避开墙壁和障碍物呢...
  • 数据结构-A*算法2

    2014-04-19 11:03:42
    这篇文章还可以在这里找到 ... Apps Factory的创始人,该公司开发了App Cooker。   学习A星寻路算法是如何工作的! 你是否在做一款游戏的时候想创造一些怪兽或者游戏主角,让它们移动到特定的位置,避
  • easystar(寻路) 快递(服务器) socket.io(多人游戏2p) ... 去做 : 使用Gulp而不是Webpack(并不需要webpack) 函数式编程方法(那时我还不知道) 更好的资产 测试和一些清理 ... 运行游戏: bower ...
  • 【cocos2D-x学习】16.A*算法

    千次阅读 2014-03-23 19:17:33
    他是Hot Apps Factory的创始人,该公司开发了App Cooker。   学习A星寻路算法是如何工作的! 你是否在做一款游戏的时候想创造一些怪兽或者游戏主角,让它们移动到特定的位置,避开墙壁和障碍物呢? ...
  • A星

    2013-07-12 11:06:55
    他是Hot Apps Factory的创始人,该公司开发了App Cooker。     学习A星寻路算法是如何工作的! 你是否在做一款游戏的时候想创造一些怪兽或者游戏主角,让它们移动到特定的位置,避开墙壁和障碍物呢? ...

空空如也

空空如也

1 2
收藏数 29
精华内容 11
关键字:

寻路app