Cocos2D-x A星寻路法

最新推荐文章于 2021-04-11 05:35:08 发布
最新推荐文章于 2021-04-11 05:35:08 发布
阅读量1k 收藏
点赞数
分类专栏： cocos2d-x

Cocos2D-x A星寻路法

(2013-05-22 17:43:19)
转载▼
标签：

it

分类： Cocos2D-x
里面的A星寻路法代码有点坑爹,考虑不是很全面,内存管理也不是很细心.因为它主要目的是为了诠释算法的思路,也没有必要面面俱到.算法是灵魂,理解算法就可以了.
但也花了我半天的时间修改它的bug,下面贴出劈人修改后的代码,节省大家的时间-直接copy它就行了.

//

// AstarItem.h

// AstarAlgorithm

//

// Created by liboxiang on 13-5-21.

//

//


#ifndef __AstarAlgorithm__AstarItem__

#define __AstarAlgorithm__AstarItem__


#include <iostream>

#include "cocos2d.h"


class AstarItem: public cocos2d::CCObject

{

public:

// AstarItem();

// ~AstarItem();

 

  // 行 / 列 setter/getter

  void setPos(const int &col, const int &row)

  {

      id_col = col;

      id_row = row;

  }

  int getCol(){return id_col;}

  int getRow(){return id_row;}

 

  //实际估价 setter/getter

  void setG(const int &g){id_g = g;}

  int getG(){return id_g;}

 

  //估计代价 setter/getter

  void setH(const int &h){id_h = h;}

  int getH(){return id_h;}

 

  //父节点 setter/getter

  void setFid(const int &fid){id_fid = fid;}

  int getFid(){return id_fid;}

 

  //估价函数 setter/getter

  void setF(const int &f){id_f = f;}

  int getF(){return id_f;}

 

private:

  int id_col;//列

  int id_row;//行

  int id_g;//实际估价

  int id_h;//估计代价

  int id_fid;//父节点 标志close中的index

  int id_f;//估价函数 f = g + h

};

#endif


//

// Astar.h

// AstarAlgorithm

//

// Created by liboxiang on 13-5-21.

//

//


#ifndef __AstarAlgorithm__Astar__

#define __AstarAlgorithm__Astar__


#include <iostream>


namespace cocos2d

{

  class CCArray;

  class CCTMXTiledMap;

}


class Astar

{

private:

  int curCol, curRow, aimCol, aimRow;

// int AimX, AimY, AimW, AimH;

  cocos2d::CCArray *open;

  cocos2d::CCArray *close;

  cocos2d::CCArray *path;

  cocos2d::CCTMXTiledMap *map;

 

  std::string conflictProerty;

int conflictValue;

 

  int getG(const int &col, const int &row, const int &id);//获得g()

  int getH(const int &col, const int &row);//获得h()

  void fromOpenToClose();//将open中的元素导入close

  void removeFromOpen();//从open列表中删除元素

  void getPath();//获得整个路径

  void starSearch(const int &fid);//搜索

  void resetSort(int last);//排序

  bool checkClose(const int &col, const int &row);//检查close

  void addToOpen(const int &col, const int &row, const int &id);//向open添加元素

  bool checkMap(const int &col, const int &row);//检查地图

  bool checkOpen(const int &col, const int &row, const int &id);//检查列表

 

public:

  Astar();

  ~Astar();

  cocos2d::CCArray *findPath(const int &curX,

                            const int &curY,

                            const int &aimX,

                            const int &aimY,

                            cocos2d::CCTMXTiledMap *passMap,

                            const std::string &theConflictProerty,

                            const int &theConflictValue);//入口函数

};




#endif


//

// Astar.cpp

// AstarAlgorithm

//

// Created by liboxiang on 13-5-21.

//

//


#include "Astar.h"

#include "cocos2d.h"

#include "AstarItem.h"


using namespace cocos2d;


Astar::Astar():map(NULL), conflictProerty("conflict"), conflictValue(1)

{

path = CCArray::create();

  path->retain();

 

  open = CCArray::create();

  open->retain();

 

  close = CCArray::create();

  close->retain();

}


Astar::~Astar()

{

  CC_SAFE_RELEASE(open);

  CC_SAFE_RELEASE(close);

  CC_SAFE_RELEASE(path);

  CC_SAFE_RELEASE(map);

}


int Astar::getG(const int &col, const int &row, const int &id)//获得g()

{

  AstarItem *closeMember = (AstarItem *)close->objectAtIndex(id);

int fx = closeMember->getCol();

  int fy = closeMember->getRow();

  int fg = closeMember->getG();

 

  if (col - fx != 0 && row - fy != 0)

  {

      return fg + 14;

  }

  else

  {

      return fg + 10;

  }

}


int Astar::getH(const int &col, const int &row)//获得h()

{

  //获得该点的h值

  return abs(aimCol - col) * 10 + abs(aimRow - row) * 10;

}


void Astar::fromOpenToClose()//将open中的元素导入close

{

  //把open列表中的点 放到close列表

  AstarItem *temp = (AstarItem *)open->objectAtIndex(1);

  close->addObject(temp);

  removeFromOpen();

}


void Astar::removeFromOpen()//从open列表中删除元素

{

  //最後一个 替换第一个

  open->replaceObjectAtIndex(1, open->lastObject(), true);

 

  //删除最後一个

  open->removeLastObject();

 

  int last = open->count() - 1;

 

  //对排序

  int head = 1;

  while ( (head * 2) <= last )

  {

      int child1 = head * 2;

      int child2 = child1 + 1;

      int childMin(0);

     

      //找出 childMin

      if (child2 <= last)

      {

          AstarItem *child1AstarItem = (AstarItem *)open->objectAtIndex(child1);

          AstarItem *child2AstarItem = (AstarItem *)open->objectAtIndex(child2);

          childMin = child1AstarItem->getF() < child2AstarItem->getF() ? child1 : child2;

      }

      else

      {

          childMin = child1;

      }

     

      //head > childMin就交换

      AstarItem *headAstarItem = (AstarItem *)open->objectAtIndex(head);

      AstarItem *childMinAstarItem = (AstarItem *)open->objectAtIndex(childMin);

      if (headAstarItem->getF() <= childMinAstarItem->getF())

      {

          break;

      }


      open->exchangeObject(headAstarItem, childMinAstarItem);


     

      head = childMin;

  }

}


void Astar::getPath()//获得整个路径

{

  path->addObject(close->lastObject());

 

  while (true)

  {

      if (((AstarItem *)path->objectAtIndex(0))->getG() == 0 )

      { //达到终点时,结束循环

          break;

      }

     

      path->insertObject(

                        close->objectAtIndex(((AstarItem *)path->objectAtIndex(0))->getFid()),

                        0);

  }

  curCol = aimCol;

  curRow = aimRow;

}


void Astar::starSearch(const int &fid)//搜索

{

  AstarItem *fidAstarItem = (AstarItem *)close->objectAtIndex(fid);

 

  //view coordinate

  int col = fidAstarItem->getCol();

  int row = fidAstarItem->getRow();

 

  //搜索目前点的上 左 下 右 四个方向

 

  //上

  int myCol = col;

  int myRow = row - 1;

  if (myRow >= 0 && checkMap(myCol, myRow))

  {

      if (checkOpen(myCol, myRow, fid) && checkClose(myCol, myRow))

      {

      addToOpen(myCol, myRow, fid);

      }

  }

 

  //--上左

  myCol = col -1;

  myRow = row - 1;

  if (myCol >= 0 && myRow >= 0 && checkMap(myCol, myRow))

  {

      if (checkOpen(myCol, myRow, fid) && checkClose(myCol, myRow))

      {

      addToOpen(myCol, myRow, fid);

      }

  }

 

  //左

  myCol = col - 1;

  myRow = row;

  if (myCol >= 0 && checkMap(myCol, myRow))

  {

      if (checkOpen(myCol, myRow, fid) && checkClose(myCol, myRow))

      {

      addToOpen(myCol, myRow, fid);

      }

  }

 

  //--左下

  myCol = col -1;

  myRow = row + 1;

  if (myCol >= 0 && myRow <= map->getMapSize().height && checkMap(myCol, myRow))

  {

      if (checkOpen(myCol, myRow, fid) && checkClose(myCol, myRow))

      {

      addToOpen(myCol, myRow, fid);

      }

  }

 

  //下

  myCol = col;

  myRow = row + 1;

  if (myRow <= map->getMapSize().height && checkMap(myCol, myRow))

  {

      if (checkOpen(myCol, myRow, fid) && checkClose(myCol, myRow))

      {

      addToOpen(myCol, myRow, fid);

      }

  }

 

  //--右下

  myCol = col + 1;

  myRow = row + 1;

  if (myCol <=map->getMapSize().width && myRow <= map->getMapSize().height && checkMap(myCol, myRow))

  {

      if (checkOpen(myCol, myRow, fid) && checkClose(myCol, myRow))

      {

      addToOpen(myCol, myRow, fid);

      }

  }

 

  //右

  myCol = col + 1;

  myRow = row;

  if (myCol <=map->getMapSize().width && checkMap(myCol, myRow))

  {

      if (checkOpen(myCol, myRow, fid) && checkClose(myCol, myRow))

      {

      addToOpen(myCol, myRow, fid);

      }

  }

 

  //--上右

  myCol = col + 1;

  myRow = row - 1;

  if (myCol <=map->getMapSize().width && myRow >= 0 && checkMap(myCol, myRow))

  {

      if (checkOpen(myCol, myRow, fid) && checkClose(myCol, myRow))

      {

      addToOpen(myCol, myRow, fid);

      }

  }

}


void Astar::resetSort(int last)//排序

{

  while (last > 1)

  {

      int half = last / 2;

     

      AstarItem *lastAstarItem = (AstarItem *)open->objectAtIndex(last);

      AstarItem *halfAstarItem = (AstarItem *)open->objectAtIndex(half);

      if (halfAstarItem->getF() <= lastAstarItem->getF()) break;

     

      open->exchangeObject(halfAstarItem, lastAstarItem);

     

      last = half;

  }

}


bool Astar::checkClose(const int &col, const int &row)//检查close

{

  AstarItem *closeMember = NULL;

  CCObject *theObject = NULL;

  CCARRAY_FOREACH_REVERSE(close, theObject)

  {

      closeMember = (AstarItem *)theObject;

      if (closeMember->getCol() == col && closeMember->getRow() == row)

      {

          return false;

      }

  }

  return true;

}


void Astar::addToOpen(const int &col, const int &row, const int &id)//向open添加元素

{

  AstarItem *temp = new AstarItem();

  temp->setPos(col, row);

  temp->setFid(id);

 

  int g = getG(col, row, id);

  int h = getH(col, row);

 

  temp->setG(g);

  temp->setH(h);

  temp->setF(g + h);

  open->addObject(temp);

  resetSort(open->count() - 1);

}


bool Astar::checkMap(const int &col, const int &row)//检查地图

{

  CCTMXLayer *layer = map->layerNamed("grass");

  CCAssert(layer, "grass layer is not found at Astar::checkMap");

 

  if (col >= map->getMapSize().width || row >= map->getMapSize().height)

  {

      return false;

  }

  unsigned int tileGid = layer->tileGIDAt(ccp(col, row));CCAssert(tileGid > 0, "tileGid is empty");

 

  CCDictionary *tileDic = map->propertiesForGID(tileGid);CCAssert(tileDic, "tileDic is not found at Astar::checkMap");

 

  CCString *mValue = (CCString *)tileDic->objectForKey(conflictProerty.c_str());CCAssert(mValue, "mValue is not found at Astar::checkMap");

 

  if (mValue->intValue() == conflictValue)

  {

      return false;

  }

  else

  {

      return true;

  }

}

bool Astar::checkOpen(const int &col, const int &row, const int &id)//检查列表

{

  AstarItem *openMember = NULL;

  CCObject *theObject = NULL;

  unsigned int index = open->count() - 1;

  CCARRAY_FOREACH_REVERSE(open, theObject)

  {

      openMember = (AstarItem *)theObject;

      if (openMember->getCol() == col && openMember->getRow() == row)

      {

          int tempG = getG(col, row, id);

          if (tempG < openMember->getG())

          {

              openMember->setG(tempG);

              openMember->setFid(id);

              openMember->setF(openMember->getG() + openMember->getH());

              resetSort(index);

          }

         

          return false;

      }

      --index;

  }

 

  return true;

}


CCArray *Astar::findPath(const int &curX,

                      const int &curY,

                      const int &aimX,

                      const int &aimY,

                      CCTMXTiledMap *passMap,

                      const std::string &theConflictProerty,

                      const int &theConflictValue)//入口函数

{

curCol = curX;

  curRow = curY;

aimCol = aimX;

  aimRow = aimY;

 

  conflictProerty = theConflictProerty;

  conflictValue = theConflictValue;

 

  if (map != passMap)

  {

      CC_SAFE_RELEASE(map);

      map = passMap;

      map->retain();

  }

 

  path->removeAllObjects();

 

  // index = 0;

  AstarItem *temp = new AstarItem();

  open->addObject(temp);

 

  //index = 1;

  AstarItem *temp1 = new AstarItem();

  temp1->setPos(curCol, curRow);

  temp1->setG(0);

  int ag = getH(curCol, curRow);

  temp1->setH(ag);

  temp1->setFid(0);

  temp1->setF(0 + ag);

  open->addObject(temp1); 

  //遍历寻找路径

  while (open->count() > 1)

  {

      //open 中 最小的移动啊 close

      //open 中 重新排列

      fromOpenToClose();

      int fatherid = close->count() - 1;

     

      AstarItem *lastAstarItem = (AstarItem *)close->objectAtIndex(fatherid);

      if (abs(aimCol - lastAstarItem->getCol()) == 0 &&

          abs(aimRow - lastAstarItem->getRow()) == 0)

      {

          getPath();

          break;

      }

      else

      {

          //搜索

          starSearch(fatherid);

      }

  }

 

  open->removeAllObjects();

  close->removeAllObjects();

 

  //获得路径

  if (path->count() == 0)

  {

      return NULL;

  }

  else

  {

      AstarItem *lastAstarItem = (AstarItem *)path->lastObject();

      if (lastAstarItem->getCol() != aimCol ||

          lastAstarItem->getRow() != aimRow)

      {

          AstarItem *temp = new AstarItem();

          temp->setPos(aimCol, aimRow);

          path->addObject(temp);

      }

      return path;

  }

}

wiyun
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Cocos2d-x实现的A*寻路
09-05
Cocos2d-x实现的A*寻路.主要参考和修改了这篇文章：http://www.ityran.com/archives/1994 实现的。开始时是根据自己的理解用中文注释，后来看来原代码，就直接使用和修改原代码，注释就用原文里的英文了。 原作者代码是以cocos2d + tield实现了一个完整的游戏。我这里使用了虚拟坐标系统，即可修改使用到非tield游戏中。详情可参考：http://ldlnew.blog.163.com/blog/static/106074620138525856180/
cocos2d-x寻路
04-14
本篇文章将深入探讨如何在Cocos2d-x中实现A*（A-star）寻路算法，这是一种高效且广泛应用的路径搜索算法。 A*寻路算法是一种启发式搜索方法，它结合了Dijkstra算法的优点，并引入了评估函数来指导搜索，以减少计算...
cocos2d-x的A*寻路
ithome
09-15 109
如果你还不熟悉A*寻路，请先看下这篇文章《明明白白A*寻路，一定让你懂》http://blog.csdn.net/dssdss123/article/details/11494065 一、先介绍几个函数和结构： 1、virtual void draw() 这个函数跟与MFC上单文档里的OnDraw函数很像，这里只是少了dc，这个函数会一直被调用，无需刷新，也就是说，你无需像在MFC上一样调用...
cocos2dx中使用A星寻路算法
juy19901128的专栏
01-06 412
最近被生活摩擦，难道有两天闲着没事，写个寻路玩玩。 效果图：其中紫色是close点，浅紫色是open点。 托管在码云，有兴趣的朋友可以看看：https://gitee.com/bludawn/fzsg 文件：AStarFindPath.lua...
cocos2d-x学习日志(13) --A星寻路算法demo
小枫的专栏
10-12 3317
你是否在做一款游戏的时候想创造一些怪兽或者游戏主角，让它们移动到特定的位置，避开墙壁和障碍物呢？如果是的话，请看这篇教程，我们会展示如何使用A星寻路算法来实现它！ A星算法简介： A*搜寻算法俗称A星算法。这是一种在图形平面上，有多个节点的路径，求出最低通过成本的算法。常用于游戏中的NPC的移动计算，或线上游戏的BOT的移动计算上。 实现原理： 可参考这
CocosCreator之A星寻路
Nick_Li_的博客
08-03 1941
源码地址： https://github.com/NickMonkeys/AStar
A星智能寻路（cocos cteator 2D 版本2.4.3）
04-16
在网上找的基本上都不太齐全，需要自己再去兼容版本（作为初学者的我来说深有体会），而且有些版本也比较老，所以我自己也兼容了cocoscreator2.4.3版本的A星智能寻路 可以配合TiledMap进行地图编辑并生成寻路算法，...
Cocos2D-x权威指南 A星算法正确版
06-21
《Cocos2D-x权威指南》是一本专为游戏开发者准备的详细教程，重点讲解了Cocos2D-x游戏引擎的使用以及A星(A*)寻路算法的正确实现。Cocos2D-x是一款广泛使用的开源游戏开发框架，支持多种平台，如iOS、Android、...
cocos2d-x的A星算法代码（基于2.0.1）
03-18
在Cocos2d-x这样的2D游戏引擎中，A星算法可以帮助实现角色或物体的有效移动，找到从起点到终点的最短路径。这里我们将深入探讨A星算法及其在Cocos2d-x中的应用。 一、A星算法基础 1. **基本原理**：A星算法结合了...
Cocos2dx-2.2.3 A星寻路算法源码
04-09
理解并实现A星寻路算法对于Cocos2dx游戏开发者来说至关重要，因为它能确保游戏角色在复杂环境中准确、高效地移动，提升玩家的游戏体验。通过深入研究提供的源码，开发者可以学习到如何将A*算法应用于实际项目，同时...
用cocos实现A星寻路算法
02-25
在学校的课程作业，用cocos实现A星寻路算法。做的太基础了。
CocosCreator实现A星自动寻路
06-18
使用CocosCreator实现A星自动寻路逻辑，点击屏幕的可行点后，即出现自动寻路的路径。
cocos2d-x上的A*寻路
09-17
这是我的博文《cocos2d-x的A*寻路》相应的资源文件，请参考我的博文http://blog.csdn.net/dssdss123/article/details/11709847
A星寻路Cocos2dx3.3自动寻路代码
10-16
利用cocos2dx写的A星自动寻路算法，为了大家能很好的理解，我画了程序流程图辅助大家理解算法。vs2012+cocos2dx 3.3 编写。 如果对于原理不太懂，可以到我的博客看原理，地址如下。 http://blog.csdn.net/u010946556/article/details/49027301
Cocos2d-x 地图行走的实现3：A*算法
08-09
本资源对应的文章：http://blog.csdn.net/stevenkylelee/article/details/38456419
cocos2dx 3.x 实现 A星（A*）（A-star）算法自动寻路（一）
麻花
10-11 7944
自动寻路里面的说的最多的就是A星寻路了，但是网上找了些博客大家写的有点简略，导致对于刚接触的人来说理解的不够清楚。在这里我将用大量的图片一步一步地列出A星算法的寻路过程。A星算法对于大地图的效率不高，大地图的寻路算法可以尝试用导航网络处理，如果想了解大地图的算法，可以来这里看下http://www.zhihu.com/question/20298134（知乎里面的高票回答） A*算法原理 - A
CocosCreator之KUOKUO趣味文章：小怪A星寻路详解
kuokuo666的博客
07-03 2118
对上一篇小怪系列文章作详细分析，帮助大家理解。 正文 首先，对于曼哈顿估价法。 你就可以理解为直线的一段或者几段距离的加和，直线距离。 // 曼哈顿估价法,传入当前点与目标点,返回估值 // abs 为取绝对值 manHattan (nowPoint, pIndex) { let dx = Math.abs(nowPoint.x - pIndex.x); ...
cocos creator主程入门教程（十）—— A*寻路
houjia159的专栏
09-07 1163
这一篇介绍A*寻路算法。在RPG、SLG、模拟经营类游戏，有需要给角色寻路的需求，一般寻路我们采用A*寻路算法，A*寻路算法是一种广度优先启发性算法。 先说说什么叫广度优先。搜索分为广度优先和深度优先，主要体现在对节点的展开上。深度优先一直往一个方向查找，如果没办法查找下去，在当前节点改变方向继续查找，直到找到终点。如果无法继续查找，就回退上一格重复操作。广度优先把当前节点放入待探索列表，循环从待探索列表里取出节点进行展开，直到找到终点。如果待探索列表为空，说明没有路可走。 启发性指算法在待探索列表里取
a星寻路算法 php,如何基于Cocos2d-x 3.0实现A星寻路算法 转
weixin_29161785的博客
04-11 114
在学习本篇教程之前，如果你有cocos2d-x的开发经验，将会有所帮助。如果没有也没关系，因为你可以将这里讲解的例子迁移到其他的语言或者框架中。找到到达你键盘的最短路径，开始吧！Maze猫首先介绍下我们将要在本篇教程中开发的简单游戏。前往下载本篇教程的工程代码(https://github.com/cocos2d/cocos-docs/blob/master/tutorial/how-to-use...
cocos2d-x游戏开发入门教程
本文档主要介绍了cocos2d-x游戏引擎的学习笔记，涵盖了cocos2d-x的基本概念、安装步骤、项目创建等内容，旨在帮助新手快速入门cocos2d-x游戏引擎。 一、cocos2d-x游戏引擎简介 cocos2d-x是一个开源的跨平台游戏...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值