cocos2d-x学习日志(13) --A星寻路算法demo

最新推荐文章于 2020-08-03 09:05:29 发布
最新推荐文章于 2020-08-03 09:05:29 发布
阅读量3.3k 收藏 3
点赞数
分类专栏： cocos2d-x(win32)学习日志 文章标签： Cocos2d-x
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rexuefengye/article/details/12648733
版权

    你是否在做一款游戏的时候想创造一些怪兽或者游戏主角，让它们移动到特定的位置，避开墙壁和障碍物呢？如果是的话，请看这篇教程，我们会展示如何使用A星寻路算法来实现它！


A星算法简介：

A*搜寻算法俗称A星算法。这是一种在图形平面上，有多个节点的路径，求出最低通过成本的算法。常用于游戏中的NPC的移动计算，或线上游戏的BOT的移动计算上。


实现原理：

可参考这两篇文章：

http://www.raywenderlich.com/zh-hans/21503/a星寻路算法介绍 

http://www.raywenderlich.com/zh-hans/21315/如何使用cocos2d实现a星寻路算法


实现代码：


1.创建ShortestPathStep类，代表路径上的一步操作；

ShortestPathStep.h

#ifndef __AStarDemo__ShortestPathStep__
#define __AStarDemo__ShortestPathStep__

#include "cocos2d.h"
USING_NS_CC;
class ShortestPathStep:public CCNode
{
public:
    ShortestPathStep(void);
    ~ShortestPathStep(void);
    //CREATE_FUNC(ShortestPathStep);
    
    //m_pos表示方块的坐标;  GScore表示这是开始点到当前点之间的方块数目;
    //HScore表示当前点到终点之前的方块估算值;  m_Parent表示它自身的前继
    CC_SYNTHESIZE(CCPoint, m_pos, Pos);
	CC_SYNTHESIZE(float,m_fGScore,GScore);
	CC_SYNTHESIZE(float,m_fHScore,HScore);
    CC_SYNTHESIZE(ShortestPathStep*,m_Parent,Parent);
    
    bool InitWithPosition(CCPoint point);
	bool IsEqual(ShortestPathStep* step);
    
    //方块的score值（它是F和G的和)
    float getFScore();
    
	bool operator == (const ShortestPathStep& other);
};

#endif /* defined(__AStarDemo__ShortestPathStep__) */
ShortestPathStep.cpp 

#include "ShortestPathStep.h"

ShortestPathStep::ShortestPathStep(void)
{
    
}

ShortestPathStep::~ShortestPathStep(void)
{
    
}

bool ShortestPathStep::InitWithPosition(CCPoint point)
{
    bool pRet = false;
    if (CCNode::node()) {
        m_pos = point;
        m_fGScore = 0;
        m_fHScore = 0;
        m_Parent = NULL;
        pRet = true;
    }
    return pRet;
}

bool ShortestPathStep::IsEqual(ShortestPathStep *step)
{
    return this->m_pos.equals(step->getPos());
}

float ShortestPathStep::getFScore()
{
    return (m_fGScore+m_fHScore);
}

bool ShortestPathStep::operator==(const ShortestPathStep &other)
{
    return (other.getPos().equals(this->m_pos));
}

2.创建头文件resource,添加必要宏定义


resource.h

#ifndef AStarDemo_resource_h
#define AStarDemo_resource_h

#define IDS_PROJNAME                100
#define IDR_ASTARDEMO               100
#define ID_FILE_NEW_WINDOW          32771

#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE     201
#define _APS_NEXT_CONTROL_VALUE      1000
#define _APS_NEXT_SYMED_VALUE        101
#define _APS_NEXT_COMMAND_VALUE      32775
#endif

#endif

3.创建AStar类，实现A星算法基本操作


AStar.h

#ifndef __AStarDemo__AStar__
#define __AStarDemo__AStar__

#include "cocos2d.h"
USING_NS_CC;

class ShortestPathStep;

typedef struct st_AStar_Coord_Info
{
    CCPoint pointOrg;
    CCPoint point;
    int nType;
}AStar_Coord_Info;

class AStar:public CCNode
{
public:
    
    AStar(void);
    ~AStar(void);
    //创建open和closed列表
    CC_SYNTHESIZE_RETAIN(CCArray*,openArray,OpenArray);
    CC_SYNTHESIZE_RETAIN(CCArray*,closeArray,CloseArray);
    
    //检查开始和结束点
    void MoveToward(CCPoint fromPos,CCPoint toPos);
    
    void InsertInOpenArrays(ShortestPathStep *step);
    virtual CCPoint AStarCoordForPosition(CCPoint point);
    virtual bool IsValidPos(CCPoint point);
    void ConstructShortestPath(ShortestPathStep* step);
    void EndAStar();
	int costToMoveFromStep(ShortestPathStep *fromStep ,ShortestPathStep *toStep);
    
    //实现对角线移动
    void walkableAdjacentTilesCoordForTileCoord(CCPoint point, std::vector<CCPoint>& tmp);
    
    int computeHScoreFromCoord(CCPoint fromCoord ,CCPoint toCoord);
    void setBlockSize(int size = 32);
    int indexOfObject(CCArray *array,ShortestPathStep *st);
    bool ContainObject(CCArray *array,ShortestPathStep *st);
    int		m_nBlockSize;	
    CCArray *m_shortestPaths;

public:
    virtual void SetMapSize(CCSize size,CCPoint orgPoint = CCPointZero);
    virtual void InitAStarCoord();


    std::vector<AStar_Coord_Info>   m_AstarCoordInfo;


};

#endif /* defined(__AStarDemo__AStar__) */
AStar.cpp 

#include "AStar.h"
#include "ShortestPathStep.h"
#include <algorithm>

AStar::AStar(void)
{
    m_nBlockSize = 32;
    m_shortestPaths = NULL;
}

AStar::~AStar()
{
    
}

void AStar::setBlockSize(int size)
{
    m_nBlockSize = size;
}

CCPoint AStar::AStarCoordForPosition(CCPoint point)
{
    return CCPointMake(((int)point.x) / m_nBlockSize ,((int)point.y) / m_nBlockSize);
}

bool AStar::IsValidPos(CCPoint point)
{
    std::vector<AStar_Coord_Info>::iterator it = m_AstarCoordInfo.begin();
    for (; it!=m_AstarCoordInfo.end(); it++) {
        if ((*it).point.equals(point)) 
            return ((*it).nType == 0);
    }
    return false;
}

void AStar::InsertInOpenArrays(ShortestPathStep *step)
{
    int stepFScore = step->getFScore();
    int count = openArray->count();
    int i = 0;
    for (; i<count; i++) {
        if (stepFScore <= ((ShortestPathStep*)openArray->objectAtIndex(i))->getFScore()) {
            break;
        }
    }
    
    openArray->insertObject(step, i);
}

void AStar::ConstructShortestPath(ShortestPathStep *step)
{
    m_shortestPaths = CCArray::create();
    m_shortestPaths->retain();
    do{
        if (step->getParent() != NULL)
        {
            m_shortestPaths->insertObject(step, 0);
        }
        step = step->getParent();
    }while (step != NULL); 
        
}

void AStar::EndAStar()
{
    openArray->removeAllObjects();
    openArray->release();
    closeArray->removeAllObjects();
    closeArray->release();
}

void AStar::walkableAdjacentTilesCoordForTileCoord(cocos2d::CCPoint point, std::vector<CCPoint> &tmp)
{
    bool t = false;
    bool l = false;
    bool b = false;
    bool r = false;
    
    //Top
    CCPoint p = CCPointMake(point.x, point.y-1);
    if (IsValidPos(p))
    {
        tmp.push_back(p);
        t = true;
    }
    
    // Left
    p = CCPointMake(point.x - 1, point.y);
    if (IsValidPos(p)) {
        tmp.push_back(p);
        l = true;
    }
    
    // Bottom
    p = CCPointMake(point.x, point.y + 1);
    if (IsValidPos(p)) {
        tmp.push_back(p);
        b = true;
    }
    
    // Right
    p = CCPointMake(point.x + 1, point.y);
    if (IsValidPos(p)) {
        tmp.push_back(p);
        r = true;
    }
    

    // Top Left
    p = CCPointMake(point.x - 1, point.y - 1);
    if (t && l && IsValidPos(p)) {
        tmp.push_back(p);
    }
    
    // Bottom Left
    p = CCPointMake(point.x - 1, point.y + 1);
    if (b && l && IsValidPos(p)) {
        tmp.push_back(p);
    }
    
    // Top Right
    p = CCPointMake(point.x + 1, point.y - 1);
    if (t && r && IsValidPos(p)) {
        tmp.push_back(p);
    }
    
    // Bottom Right
    p = CCPointMake(point.x + 1, point.y + 1);
    if (b && r && IsValidPos(p)) {
        tmp.push_back(p);
    }
}

void AStar::MoveToward(cocos2d::CCPoint fromPos, cocos2d::CCPoint toPos)
{
    if (m_shortestPaths) {
        m_shortestPaths->removeAllObjects();
    }
    
    CCPoint fromAStarCoor = AStarCoordForPosition(fromPos);
	CCPoint toAStarCoord = AStarCoordForPosition(toPos);
    
    if(fromAStarCoor.equals(toAStarCoord))
	{
		return;
	}
    

	if(!IsValidPos(toAStarCoord))
	{
		return;
	}
    
	
	openArray = CCArray::create();
	openArray->retain();
	closeArray = CCArray::create();
	closeArray->retain();
    

	ShortestPathStep *step =  new ShortestPathStep();
	step->retain();
	
	step->InitWithPosition(fromAStarCoor);
    
	InsertInOpenArrays(step);
    
    do{
        ShortestPathStep *curStep = (ShortestPathStep *)openArray->objectAtIndex(0);
        curStep->retain();
        closeArray->addObject(curStep);
        
        openArray->removeObjectAtIndex(0);
        
        if (curStep->getPos().equals(toAStarCoord))
        {
            ConstructShortestPath(curStep);
            
            EndAStar();
            break;
        }
        
        std::vector<CCPoint> pointVec;
		walkableAdjacentTilesCoordForTileCoord(curStep->getPos(),pointVec);
        for (int i = 0; i<pointVec.size(); i++)
        {
            ShortestPathStep *st = new ShortestPathStep();
            st->autorelease();
            st->InitWithPosition(pointVec[i]);
            
            if (ContainObject(closeArray, st))
            {
                st->release();
                continue;
            }
            int moveCost = costToMoveFromStep(curStep, st);
            
            int index = indexOfObject(openArray, st);
            
            if (index == UINT_MAX)
            {
                st->setParent(curStep);
                st->setHScore(computeHScoreFromCoord(st->getPos(), toAStarCoord));
                InsertInOpenArrays(st);
                st->release();
            }
            else
            {
                st->release();
                st = (ShortestPathStep*) openArray->objectAtIndex(index);
                if ((curStep->getGScore() + moveCost)<st->getGScore())
                {
                    st->setGScore(curStep->getGScore() + moveCost);
                    st->retain();
                    openArray->removeObjectAtIndex(index);
                    InsertInOpenArrays(st);
                    st->release();
                }
            }
        }
        
        
    }while (openArray->count() > 0);
    EndAStar();
}

int AStar::costToMoveFromStep(ShortestPathStep *fromStep ,ShortestPathStep *toStep)
{
	return ((fromStep->getPos().x != toStep->getPos().x) && (fromStep->getPos().y != toStep->getPos().y)) ? 14 : 10;
}

int AStar::computeHScoreFromCoord(CCPoint fromCoord ,CCPoint toCoord)
{
	// Here we use the Manhattan method, which calculates the total number of step moved horizontally and vertically to reach the
	// final desired step from the current step, ignoring any obstacles that may be in the way
	return abs(toCoord.x - fromCoord.x) + abs(toCoord.y - fromCoord.y);
}

bool AStar::ContainObject(CCArray *array,ShortestPathStep *st)
{
	if(array == NULL)
		return false;
	for(int i=0; i<array->count(); i++)
	{
		ShortestPathStep *t = (ShortestPathStep *)array->objectAtIndex(i);
		if(t->getPos().equals(st->getPos()))
		{
			return true;
		}
	}
	return false;
}

int AStar::indexOfObject(CCArray *array,ShortestPathStep *st)
{
	if(array == NULL)
		return UINT_MAX;
	for(int i=0; i<array->count(); i++)
	{
		ShortestPathStep *t = (ShortestPathStep *)array->objectAtIndex(i);
		if(t->getPos().equals(st->getPos()))
		{
			return i;
		}
	}
	return UINT_MAX;
}

void AStar::SetMapSize(CCSize size,CCPoint orgPoint)
{
    
}

void AStar::InitAStarCoord()
{
	//
	CCSize size = 	CCDirector::sharedDirector()->getWinSize();
	int AStarWidth = size.width/m_nBlockSize ;	//
	int AStarHeight = size.height/m_nBlockSize;
    
	for (int w=-1; w <AStarWidth; w++)
	{
		for (int h=-1; h<AStarHeight; h++)
		{
			AStar_Coord_Info coordInfo;
			coordInfo.point =  CCPointMake(w,h);
			coordInfo.pointOrg = CCPointMake(m_nBlockSize/2+w*m_nBlockSize,m_nBlockSize/2+m_nBlockSize*h);
			//
			if (w == -1 || h==-1 || w == AStarWidth-1 || h == AStarHeight-1)
			{
				coordInfo.nType = 1;
			}
            
			//
			else if ((w>3 && w <= 8) && h == 4)
 			{
				coordInfo.nType = 1;
			}
			else if ((w>3 && w <= 6) && h == 2)
			{
				coordInfo.nType = 1;
			}
			else if ((h>4 && h <= 8) && w == 8)
			{
				coordInfo.nType = 1;
			}else
			{
				coordInfo.nType = 0;
			}
            
			m_AstarCoordInfo.push_back(coordInfo);
		}
	}
	
}

4.测试代码：


HelloWorldScene.h

#ifndef __HELLOWORLD_SCENE_H__
#define __HELLOWORLD_SCENE_H__

#include "cocos2d.h"
#include "AStar.h"
#include "ShortestPathStep.h"
USING_NS_CC;

class HelloWorld : public cocos2d::CCLayer
{
public:
    // Method 'init' in cocos2d-x returns bool, instead of 'id' in cocos2d-iphone (an object pointer)
    virtual bool init();

    // there's no 'id' in cpp, so we recommend to return the class instance pointer
    static cocos2d::CCScene* scene();
    
    // a selector callback
    void menuCloseCallback(CCObject* pSender);

    // preprocessor macro for "static create()" constructor ( node() deprecated )
    CREATE_FUNC(HelloWorld);
    
    void ClearPath();
	void PaintPath();
private:
	AStar *m_AStar;
	CCArray *m_PathArray;
	CCLayerColor *m_colorFrom;
	CCLayerColor *m_colorEnd;
public:	//ccTouches
	virtual void ccTouchesBegan(CCSet *pTouches, CCEvent *pEvent);
	virtual void ccTouchesMoved(CCSet *pTouches, CCEvent *pEvent);
	virtual void ccTouchesEnded(CCSet *pTouches, CCEvent *pEvent);
	virtual void ccTouchesCancelled(CCSet *pTouches, CCEvent *pEvent);
    
private:
	CCPoint		m_FromPoint;		//
	CCPoint		m_ToPoint;			//
	bool		m_bSecondPoint;		//
};

#endif // __HELLOWORLD_SCENE_H__
HelloWorldScene.cpp 

#include "HelloWorldScene.h"
#include "SimpleAudioEngine.h"

using namespace cocos2d;
using namespace CocosDenshion;
#define  AStar_Coord_Block	32

CCScene* HelloWorld::scene()
{
    // 'scene' is an autorelease object
    CCScene *scene = CCScene::create();
    
    // 'layer' is an autorelease object
    HelloWorld *layer = HelloWorld::create();

    // add layer as a child to scene
    scene->addChild(layer);

    // return the scene
    return scene;
}

// on "init" you need to initialize your instance
bool HelloWorld::init()
{
    //
    // 1. super init first
    if ( !CCLayer::init() )
    {
        return false;
    }

    m_bSecondPoint = false;
    m_AStar = new AStar;
    m_AStar->InitAStarCoord();
    m_PathArray = CCArray::create();
    m_PathArray->retain();
   
    std::vector<AStar_Coord_Info>::iterator it = m_AStar->m_AstarCoordInfo.begin();
    
    for (; it != m_AStar->m_AstarCoordInfo.end(); it++) {
        CCLayerColor *color = CCLayerColor::create(ccc4(124, 124, 124, 124));
        if ((*it).nType == 0)
        {
            color->setColor(ccc3(255, 0, 255));
        }
        else
        {
            color->setColor(ccc3(125, 125, 0));
        }
        color->setContentSize(CCSizeMake(AStar_Coord_Block,AStar_Coord_Block));
        color->setPosition((*it).pointOrg);
        this->addChild(color);
    }
    PaintPath();
    this->setTouchEnabled(true);
    
    return true;
}

void HelloWorld::menuCloseCallback(CCObject* pSender)
{
    CCDirector::sharedDirector()->end();

#if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS)
    exit(0);
#endif
}

void HelloWorld::PaintPath()
{
	if(m_AStar->m_shortestPaths != NULL)
	{
        
		for (int i=0; i<m_AStar->m_shortestPaths->count();i++)
		{
			CCLayerColor *color = CCLayerColor::create(ccc4(255,124,124,124),AStar_Coord_Block,AStar_Coord_Block);
            
			ShortestPathStep* s =(ShortestPathStep*) (m_AStar->m_shortestPaths->objectAtIndex(i));
            
            CCPoint point = CCPointMake(s->getPos().x *AStar_Coord_Block +AStar_Coord_Block/2,s->getPos().y*AStar_Coord_Block+AStar_Coord_Block/2);
            
			color->setPosition(point);
			this->addChild(color);
			m_PathArray->addObject(color);
		}
	}
}

void HelloWorld::ClearPath()
{
	CCObject* it = NULL;
	CCARRAY_FOREACH(m_PathArray, it)
	{
		CCLayerColor *color = (CCLayerColor *)it;
		this->removeChild(color,true);
	}
	m_PathArray->removeAllObjects();
    
    this->removeChild(m_colorEnd, true);
    this->removeChild(m_colorFrom, true);
}



void HelloWorld::ccTouchesBegan(CCSet *pTouches, CCEvent *pEvent)
{
    CCSetIterator it = pTouches->begin();
    CCTouch *pTouch = (CCTouch*)(*it);
    CCPoint touchLocation = convertTouchToNodeSpace(pTouch);
    touchLocation = m_AStar->AStarCoordForPosition(touchLocation);
    touchLocation = CCPointMake(AStar_Coord_Block*touchLocation.x+AStar_Coord_Block/2,AStar_Coord_Block*touchLocation.y+AStar_Coord_Block/2);
    if (m_bSecondPoint)
	{
		m_ToPoint = touchLocation;
        
		//
		m_AStar->MoveToward(m_FromPoint,m_ToPoint);
        
		//
		m_colorEnd = CCLayerColor::create(ccc4(255,0,0,255),AStar_Coord_Block,AStar_Coord_Block);
		m_colorEnd->setPosition(m_ToPoint);
		this->addChild(m_colorEnd);
        
		//
		PaintPath();
		m_bSecondPoint = false;
	}
	else
	{
		m_FromPoint = touchLocation;
		//
		ClearPath();
		//
		m_colorFrom = CCLayerColor::create(ccc4(255,0,255,255),AStar_Coord_Block,AStar_Coord_Block);
		m_colorFrom->setPosition(m_FromPoint);
		this->addChild(m_colorFrom);
        
		m_bSecondPoint = true;
	}
    
}



void HelloWorld::ccTouchesMoved(CCSet *pTouches, CCEvent *pEvent)
{
	CCSetIterator it = pTouches->begin();
	CCTouch *pTouch = (CCTouch*)(*it);
	switch (pTouches->count())
	{
        case 1:
		{
			CCPoint touchLocation = convertTouchToNodeSpace(pTouch);
		}
            break;
        case 2:
		{
		}
            break;
	}
}

void HelloWorld::ccTouchesEnded(CCSet *pTouches, CCEvent *pEvent)
{
}
void HelloWorld::ccTouchesCancelled(CCSet *pTouches, CCEvent *pEvent)
{
}


效果图：




备注：


     



热血枫叶
关注
专栏目录
A星算法DEMO
10-31
自己用Java写的A星算法，工具是NetBeans 8.1。
寻路DEMO
weixin_34092370的博客
02-02 82
网格场景的寻路算法DEMO 灰色格子为默认正常蓝色格子表示为障碍物,不可进入红色细条在格子周围,表示格子的墙,用于阻碍行走紫色为当前鼠标选中格子黄色为寻路的起始位置和结束位置.鼠标左键设置,CTRL+鼠标左键可以重设起始位置.绿色格子为寻路路径淡蓝色为寻路算法的搜索路径.鼠标右键控制场景的视角,按X键恢复为默认视角.鼠标滚轮调节视口远近.ESC 程序退出F11 全屏显示 实现了三种寻路算法...
cocos2d-x游戏实例（5）-A星算法（1）
编程资料大全
02-26 121
小满（bill man）个人原创，欢迎转载，转载请注明地址，小满（bill man）的专栏地址http://blog.csdn.net/bill_man 继续上一篇地图上的处理，不过和本篇相比，我们之前的四篇，可都算是“热身准备”了，因为我们要研究一个算法并把它加入到我们的游戏中，这种算法在rpg，以及现在比较火爆的“乱斗”类（参考战斗之心battleheart）中都是比较多地被采用了。 ...
cocos2d-x游戏实例（9）-A星算法（5）
编程资料大全
03-01 114
小满（bill man）个人原创，欢迎转载，转载请注明地址，小满（bill man）的专栏地址http://blog.csdn.net/bill_man 上一篇我们已经完成了A星算法，那么如何使用呢，我们会在这篇里介绍，还是回到MapScene中，我们首先来看接受用户输入ccTouchesBegan方法： 我们这是一个“指哪打哪”的例子，也就是说，用户点到哪个位置，我们的主角就会移动到...
Unity 算法 之 A星（A Star/A*）寻路算法实现和封装，并带动态演示Demo
03-08
Unity 算法 之 A星（A Star/A*）寻路算法实现和封装，并带动态演示Demo Demo 使用操作说明 1、按空格可以刷线地图，更新地图的障碍物位置（动态随机设置） 2、鼠标左键设置开始点位置 3、鼠标右键设置目标点位置 4、开始点和目标点都不为空，即会动态绘制路径 寻路原理 1）首先有一张一定宽高的地图 （定义好 Point 点的地图，其中 Point 中有 IsWall 属性） 2）设定开始点，和目标点 3）传入 FindPath 开始寻找较短路径，找到返回true，否则 false 4）为 true 就可以通过 目标点的父亲点的父亲点的父亲点，直到父亲点为开始点，这些点集合即是路径 5）FindPath 寻找原理 （1）开列表，关列表初始化 （2）添加开始点到开列表，然后获得周围点集合，接着又把开始点从开列表中移除，并添加到关列表 （3）判断这些周围点集合是否已经在开列表中，不在则更新这些点的F 和 父亲点，并添加到开列表；再则重新计算G值，G较小则更新GF 和父亲点 （4）从周围点集合中找到 F 最小的点，然后获得周围点集合，接着又把找到 F 最小的点从开列表中移除，并添加到关列表 （5）接着执行第 3） 步骤 （6）直到目标点被添加到开列表中，则路径找到 （7）否则，直到开列表中没有了数据，则说明没有合适路径
cocos2d-x-v2:更新cocos2d-x 2.2.6的库并支持Android Studio，64位Android
05-19
cocos2d-x 游戏类 通过PayPal支持更新第三库： $ 10，$ 50，$ 100等。 经过测试 带有ndk-r10d的cocos命令3.8.1 cocos run -p android --android-studio --app-abi armeabi-v7a:arm64-v8a cocos run -p android --...
Cocos2d-x实战C++卷关东升著完整版pdf
07-24
《Cocos2d-x实战C++卷》是关东升所著的一本深入探讨Cocos2d-x游戏引擎开发的专业书籍。Cocos2d-x是一个开源的、跨平台的2D游戏开发框架，广泛应用于iOS、Android、Windows等多个操作系统。本书以C++语言为主要编程...
cocos引擎老版本集合（cocos2d-x-2.2.1 - 3.5）.zip
02-17
cocos引擎老版本下载集合（cocos2d-x-2.2.1 - 3.5），分别有cocos2d-x-3.5、cocos2d-x-3.4、cocos2d-x-3.2、cocos2d-x-2.2.6、cocos2d-x-2.2.2和cocos2d-x-2.2.1。
cocos2d-x实战 c++卷教程及完整源码
09-01
cocos2d-x实战 c++卷教程及完整源码下载，使用最新cocos2d-x-3.14版本，在xcode7.3上已编译通过。 解决相关问题 1、解决源程序在高版本上无法编译问题 2、解决源程序中文注释部分,xcode上显示乱码问题 3、根据书籍...
Cocos2d-X游戏源码大合集.rar
10-04
这个“Cocos2d-X游戏源码大合集.rar”文件显然包含了大约三十个使用Cocos2d-X开发的游戏实例源代码，对于学习和理解Cocos2d-X游戏开发的原理、技巧以及实践应用具有极大的价值。 1. **Cocos2d-X基础**： Cocos2d-X...
CocosCreator A*自动寻路demo
09-29
CocosCreator A*自动寻路，使用js实现的，可以点击地图寻路，并实现了中途转变终点位置的cocos项目
简单的AStar算法Demo
11-29
使用AStar算法实现了一个简单的demo，亲测可用，代码不多流程简单，一看就会
用cocos实现A星寻路算法
02-25
在学校的课程作业，用cocos实现A星寻路算法。做的太基础了。
cocos2d A*算法游戏demo
12-19
基于cocos2d游戏引擎开发的实例 一款基于 A*算法自动寻路游戏demo源代码
CocosCreator实现A星自动寻路
06-18
使用CocosCreator实现A星自动寻路逻辑，点击屏幕的可行点后，即出现自动寻路的路径。
CocosCreator之A星寻路
Nick_Li_的博客
08-03 2154
源码地址： https://github.com/NickMonkeys/AStar
cocos2dx中使用A星寻路算法
juy19901128的专栏
01-06 438
最近被生活摩擦，难道有两天闲着没事，写个寻路玩玩。 效果图：其中紫色是close点，浅紫色是open点。 托管在码云，有兴趣的朋友可以看看：https://gitee.com/bludawn/fzsg 文件：AStarFindPath.lua...
cocos2dx 3.x 实现 A星（A*）（A-star）算法自动寻路（一）
麻花
10-11 8016
自动寻路里面的说的最多的就是A星寻路了，但是网上找了些博客大家写的有点简略，导致对于刚接触的人来说理解的不够清楚。在这里我将用大量的图片一步一步地列出A星算法的寻路过程。A星算法对于大地图的效率不高，大地图的寻路算法可以尝试用导航网络处理，如果想了解大地图的算法，可以来这里看下http://www.zhihu.com/question/20298134（知乎里面的高票回答） A*算法原理 - A
Cocos2D-x A星寻路法
我的
12-31 1036
Cocos2D-x A星寻路法 (2013-05-22 17:43:19) 转载▼ 标签： it 分类： Cocos2D-x 里面的A星寻路法代码有点坑爹,考虑不是很全面,内存管理也不是很细心.因为它主要目的是为了诠释算法的思路,也没有必要面面俱到.算法是灵魂,理解算法就可以了. 但也花了我半天的时间修改它的bug,下面贴出劈人修改后的代码
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

热血枫叶

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

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

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

打赏作者

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

抵扣说明：

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

余额充值