cocos2dx 45度Staggered格式A*寻路 曼哈顿算法(待优化)

最新推荐文章于 2022-12-06 23:07:23 发布
最新推荐文章于 2022-12-06 23:07:23 发布
阅读量7.4k 收藏 8
点赞数 2
分类专栏： cocos2dx
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hpking/article/details/9775289
版权 
#ifndef __ASTARPATHFINDER_H__
#define __ASTARPATHFINDER_H__
 
#include "cocos2d.h"
 
USING_NS_CC;
 
/**
 * 横向移动一格的路径评分
 */
static const int COST_HORIZONTAL = 20;
 
/**
 * 竖向移动一格的路径评分
 */
static const int COST_VERTICAL = 5;
 
/**
 * 斜向移动一格的路径评分
 */
static const int COST_DIAGONAL = 12;
 
class PathInfo;
 
/**
 * A星寻路类
 * @author hpking
 *
 */
class AStarPathFinder
{
	// 未探索的节点列表
    cocos2d::CCArray* _openSteps;
	// 已探索的,不需要再寻路的节点列表
    cocos2d::CCArray* _closedSteps;
 
	// 地图相关数据
	PathInfo* _pathInfo;
 
public:
	AStarPathFinder(PathInfo* info);
	virtual ~AStarPathFinder();
 
    /**
     * public 寻路
     *
     * @param CCPoint startPoint tile开始坐标点
     * @param CCPoint endPoint tile结束坐标点
     * @return CCArray* 读取方法:CCPointFromString ( string->getCString() )
     */
    CCArray* find( CCPoint startTilePt, CCPoint endTilePt );
 
private:
	// 最短路径步数
	class ShortestPathStep : public cocos2d::CCObject
	{
	public:
		bool initWithPosition( cocos2d::CCPoint pos )
		{
			bool bRet = false;
 
			do
			{
				position = pos;
				gScore = 0;
				hScore = 0;
				parent = NULL;
				inOpen = false;
				inClose = false;
 
				bRet = true;
			}
			while ( 0 );
 
			return bRet;
		}
 
		int fScore()
		{
			return this->getGScore() + this->getHScore();
		}
 
		inline bool operator==( const ShortestPathStep* other )
		{
			return isEqual( other );
		}
 
		bool isEqual( const ShortestPathStep* other )
		{
			return this->getPosition().equals ( other->getPosition() );
		}
 
		static ShortestPathStep* inst( cocos2d::CCPoint pos )
		{
			AStarPathFinder::ShortestPathStep* sps = new AStarPathFinder::ShortestPathStep;
 
			if ( sps && sps->initWithPosition ( pos ) )
			{
				sps->autorelease();
				return sps;
			}
 
			CC_SAFE_DELETE ( sps );
			return NULL;
		}
 
		CC_SYNTHESIZE( cocos2d::CCPoint, position, Position );
		CC_SYNTHESIZE( int, gScore, GScore );
		CC_SYNTHESIZE( int, hScore, HScore );
		CC_SYNTHESIZE( ShortestPathStep*, parent, Parent );
		CC_SYNTHESIZE( bool, inOpen, InOpen );
		CC_SYNTHESIZE( bool, inClose, InClose );
 
	private:
		cocos2d::CCString* description()
		{
			return CCString::createWithFormat ( "pos = [%f, %f], g=%d, h=%d, f=%d", this->getPosition().x, this->getPosition().y, this->getGScore(), this->getHScore(), this->fScore() );
		}
	};
 
private:
    void destroyLists();
 
    CCArray* createPath( ShortestPathStep* step );//int xStart, int yStart
    
	void findAndSort( ShortestPathStep* step );
 
	void insertAndSort( ShortestPathStep* step );
 
    /**
     * private  判断是否超出边界或路点是否可走
     *
     * @param CCPoint tpt 
     * @return bool 
     */
    bool isWalkable( CCPoint tpt );
 
    /**
     * private  计算G值
     *
     * @param Node * curNode
     * @param Node * node
     * @return int
     */
    int getGValue( ShortestPathStep* curStep, ShortestPathStep* step );
 
    /**
     * private  计算H值
     *
     * @param Node * curNode
     * @param Node * endNode
     * @param Node * node
     * @return int
     */
    int getHValue( ShortestPathStep* curStep, ShortestPathStep* endStep, ShortestPathStep* step );
 
    cocos2d::CCArray* getAroundsNode( CCPoint tPt );
 
	bool isInClosed(CCPoint tPt);
 
    void setOpenSteps ( cocos2d::CCArray* var );
    void setClosedSteps ( cocos2d::CCArray* var );
    void setShortestPath ( cocos2d::CCArray* var );
};
 
#endif

 

#include "AStarPathFinder.h"
#include "map/PathInfo.h"
 
AStarPathFinder::AStarPathFinder( PathInfo* info )
{
    _pathInfo = info;
    _openSteps = NULL;
    _closedSteps = NULL;
}
 
AStarPathFinder::~AStarPathFinder()
{
    destroyLists();
}
 
// 获取毫秒时间
long msNow()
{
	struct cc_timeval now;
	CCTime::gettimeofdayCocos2d( &now, NULL );
	return ( now.tv_sec * 1000 + now.tv_usec / 1000 );
}
 
CCArray* AStarPathFinder::find( CCPoint startTilePt, CCPoint endTilePt )
{
    bool isFinded = false; //能否找到路径，true-已找到
 
    // 到达终点
    if ( startTilePt.equals ( endTilePt ) )
    {
        CCLog ( "You're already there! :P" );
        return NULL;
    }
 
    // 终点不可走,直接退出(可优化为最近的可走地点停止)
    if ( !isWalkable( endTilePt ) )
    {
        CCLog ( "blocked! :P" );
        return NULL;
    }
 
    // 设置打开和封闭步数
    setOpenSteps ( CCArray::create() );
    setClosedSteps ( CCArray::create() );
 
    //CCLog ( "From:(%f, %f) To(%f, %f)", startTilePt.x, startTilePt.y, endTilePt.x, endTilePt.y );
 
    // 结束坐标
    ShortestPathStep* endStep = ShortestPathStep::inst ( endTilePt );
 
    // 插入开始点
    insertAndSort ( ShortestPathStep::inst ( startTilePt ) );
 
    ShortestPathStep* curStep;
    long time1 = msNow();
 
    do
    {
        // 取出并删除开放列表第一个元素
        curStep = ( ShortestPathStep* ) _openSteps->objectAtIndex ( 0 );
        curStep->setInClose( true );
        curStep->setInOpen( false );
        _closedSteps->addObject ( curStep );
        _openSteps->removeObjectAtIndex ( 0 );
 
        // 当前节点==目标节点
        if ( curStep->getPosition().equals( endTilePt ) )
        {
            isFinded = true; //能达到终点，找到路径
            break;
        }
 
        // 取相邻八个方向的节点，去除不可通过和已在关闭列表中的节点
        CCArray* aroundNodes  = getAroundsNode ( curStep->getPosition() );
        //CCLog("8 dirc %d",aroundNodes->count());
        CCObject* obj;
        CCARRAY_FOREACH ( aroundNodes, obj )
        {
            // 计算 G， H 值
            CCString* string = ( CCString* ) obj;
            ShortestPathStep* nextStep = new ShortestPathStep;
            nextStep->initWithPosition ( CCPointFromString ( string->getCString() ) );
 
            int g = getGValue ( curStep , nextStep );
            int h = getHValue ( curStep , endStep , nextStep );
 
            if ( nextStep->getInOpen() ) // 如果节点已在播放列表中
            {
                // 如果该节点新的G值比原来的G值小,修改F,G值，设置该节点的父节点为当前节点
                if ( g < nextStep->getGScore() )
                {
                    nextStep->setGScore( g );
                    nextStep->setHScore( h );
                    nextStep->setParent( curStep );
                    findAndSort ( nextStep );
                    nextStep->release();
                }
            }
            else // 如果节点不在开放列表中
            {
                // 插入开放列表中，并按照估价值排序
                nextStep->setGScore( g );
                nextStep->setHScore( h );
                nextStep->setParent( curStep );
 
                insertAndSort ( nextStep );
                nextStep->release();
            }
 
            //CCLog("open num:%d",_openSteps->count());
        }
    }
    while ( _openSteps->count() > 0 );
 
    CCLog( "a* time:%d", msNow() - time1 );
 
    /*if( _openSteps )
    CCLog( "finded:%d, openlen %d, closelen %d", isFinded ? 1 : 0, _openSteps->count(), _closedSteps->count() );*/
 
    // 找到路径
    if ( isFinded )
    {
        CCArray* path = createPath ( curStep );
 
        destroyLists ();
 
        return path;
    }
    else // 没有找到路径
    {
        destroyLists ();
 
        return NULL;
    }
}
 
void AStarPathFinder::destroyLists()
{
    CC_SAFE_RELEASE_NULL ( _openSteps );
    CC_SAFE_RELEASE_NULL ( _closedSteps );
}
 
CCArray* AStarPathFinder::createPath( ShortestPathStep* step )//int xStart, int yStart
{
    CCArray* path = CCArray::create();
 
    CCString* str;
 
    do
    {
        if ( step->getParent() != NULL )
        {
            str = CCString::createWithFormat ( "{%f, %f}", step->getPosition().x, step->getPosition().y );
            path->insertObject ( str, 0 );
        }
 
        step = step->getParent();
    }
    while ( step != NULL );
 
    return path;
}
 
void AStarPathFinder::findAndSort( ShortestPathStep* step )
{
    unsigned int count = _openSteps->count();
 
    if ( count < 1 )
        return;
 
    int stepFScore = step->fScore();
 
    for ( unsigned int i = 0; i < count; i++ )
    {
        ShortestPathStep* sps = ( ShortestPathStep* ) _openSteps->objectAtIndex ( i );
 
        if ( stepFScore <= sps->fScore() )
            _openSteps->insertObject ( step, i );
 
        if ( step->getPosition().equals( sps->getPosition() ) )
            _openSteps->removeObjectAtIndex( i );
    }
}
 
void AStarPathFinder::insertAndSort( ShortestPathStep* step )
{
    step->setInOpen( true );
 
    int stepFScore = step->fScore();
    unsigned int count = _openSteps->count();
 
    if( count == 0 )
        _openSteps->addObject( step );
    else
    {
        for ( unsigned int i = 0; i < count; i++ )
        {
            ShortestPathStep* sps = ( ShortestPathStep* ) _openSteps->objectAtIndex ( i );
 
            if ( stepFScore <= sps->fScore() )
            {
                _openSteps->insertObject ( step, i );
                return;
            }
        }
    }
}
 
bool AStarPathFinder::isWalkable( CCPoint tPt )
{
    // 1. 是否是有效的地图上点（数组边界检查）
    if ( tPt.x < _pathInfo->startPt.x || tPt.x >= _pathInfo->iCol )
        return false;
 
    if ( tPt.y < _pathInfo->startPt.y || tPt.y >= _pathInfo->iRow )
        return false;
 
    // 2. 是否是walkable
    return _pathInfo->isWalkable( tPt );
}
 
 
/**
 * private  计算G值
 *
 * @param ShortestPathStep * curStep
 * @param ShortestPathStep * step
 * @return int
 */
int AStarPathFinder::getGValue( ShortestPathStep* curStep, ShortestPathStep* step )
{
    int g  = 0;
 
    if ( curStep->getPosition().y == step->getPosition().y ) // 横向  左右
    {
        g = curStep->getGScore() + COST_HORIZONTAL;
    }
    else if ( curStep->getPosition().y + 2 == step->getPosition().y || curStep->getPosition().y - 2 == step->getPosition().y ) // 竖向  上下
    {
        g = curStep->getGScore() + COST_VERTICAL * 2;
    }
    else // 斜向  左上 左下 右上 右下
    {
        g = curStep->getGScore() + COST_DIAGONAL;
    }
 
    return g;
}
 
/**
 * private  计算H值
 *
 * @param ShortestPathStep * curStep
 * @param ShortestPathStep * endStep
 * @param ShortestPathStep * step
 * @return int
 */
int AStarPathFinder::getHValue( ShortestPathStep* curStep, ShortestPathStep* endStep, ShortestPathStep* step )
{
    if ( curStep == NULL || endStep == NULL || step == NULL )
        return 0;
 
    // 节点到0，0点的x轴距离
    int to0  = step->getPosition().x * COST_HORIZONTAL + ( ( int )step->getPosition().y & 1 ) * COST_HORIZONTAL / 2;
 
    // 终止节点到0，0点的x轴距离
    int endTo0  = endStep->getPosition().x * COST_HORIZONTAL + ( ( int )endStep->getPosition().y & 1 ) * COST_HORIZONTAL / 2;
 
    return abs ( ( float )endTo0 - ( float )to0 ) + abs ( ( float )endStep->getPosition().y - ( float )step->getPosition().y ) * COST_VERTICAL;
}
 
cocos2d::CCArray* AStarPathFinder::getAroundsNode( CCPoint tPt )
{
    CCArray* aroundNodes = CCArray::create();
 
    /// 菱形组合的地图八方向与正常不同
 
    // 左
    CCPoint p = CCPointMake ( tPt.x - 1, tPt.y );
    CCString* str;
 
    if ( isWalkable ( p ) && !isInClosed( p ) ) // 可走并且不在关闭列表
    {
        str = CCString::createWithFormat ( "{%f, %f}", p.x, p.y );
        //CCLOG( "left=%s", str->getCString() );
        aroundNodes->addObject ( str );
    }
 
    // 右
    p = CCPointMake ( tPt.x + 1, tPt.y );
 
    if ( isWalkable ( p ) && !isInClosed( p ) )
    {
        str = CCString::createWithFormat ( "{%f, %f}", p.x, p.y );
        // CCLOG( "right=%s", str->getCString() );
        aroundNodes->addObject ( str );
    }
 
    // 上
    p = CCPointMake ( tPt.x, tPt.y - 2 );  // -2
 
    if ( isWalkable ( p ) && !isInClosed( p ) )
    {
        str = CCString::createWithFormat ( "{%f, %f}", p.x, p.y );
        //CCLOG( "up=%s", str->getCString() );
        aroundNodes->addObject ( str );
    }
 
    // 下
    p = CCPointMake ( tPt.x, tPt.y + 2 );// + 2
 
    if ( isWalkable ( p ) && !isInClosed( p ) )
    {
        str = CCString::createWithFormat ( "{%f, %f}", p.x, p.y );
        //CCLOG( "down=%s", str->getCString() );
        aroundNodes->addObject ( str );
    }
 
    // 左上
    p = CCPointMake ( tPt.x - 1 + ( ( int )tPt.y & 1 ), tPt.y - 1 );
 
    if ( isWalkable ( p ) && !isInClosed( p ) )
    {
        str = CCString::createWithFormat ( "{%f, %f}", p.x, p.y );
        //CCLOG( "leftUp=%s", str->getCString() );
        aroundNodes->addObject ( str );
    }
 
    // 左下
    p = CCPointMake ( tPt.x - 1 + ( ( int )tPt.y & 1 ), tPt.y + 1 );
 
    if ( isWalkable ( p ) && !isInClosed( p ) )
    {
        str = CCString::createWithFormat ( "{%f, %f}", p.x, p.y );
        //CCLOG( "leftDown=%s", str->getCString() );
        aroundNodes->addObject ( str );
    }
 
    //右上
    p = CCPointMake ( tPt.x + ( ( int )tPt.y & 1 ), tPt.y - 1 );
 
    if ( isWalkable ( p ) && !isInClosed( p ) )
    {
        str = CCString::createWithFormat ( "{%f, %f}", p.x, p.y );
        //CCLOG( "rightUp=%s", str->getCString() );
        aroundNodes->addObject ( str );
    }
 
    //右下
    p = CCPointMake ( tPt.x + ( ( int )tPt.y & 1 ), tPt.y + 1 );
 
    if ( isWalkable ( p ) && !isInClosed( p ) )
    {
        str = CCString::createWithFormat ( "{%f, %f}", p.x, p.y );
        //CCLOG( "rightDown=%s", str->getCString() );
        aroundNodes->addObject ( str );
    }
 
    return aroundNodes;
}
 
bool AStarPathFinder::isInClosed( CCPoint pt )
{
    CCObject* temp;
    CCARRAY_FOREACH ( _closedSteps, temp )
    {
        ShortestPathStep* sps = ( ShortestPathStep* ) temp;
 
        if( sps->getPosition().equals( pt ) )
        {
            return true;
        }
    }
 
    return false;
}
 
void AStarPathFinder::setOpenSteps ( cocos2d::CCArray* var )
{
    if ( _openSteps != var )
    {
        CC_SAFE_RELEASE_NULL ( _openSteps );
        CC_SAFE_RETAIN ( var );
        _openSteps = var;
    }
}
 
void AStarPathFinder::setClosedSteps ( cocos2d::CCArray* var )
{
    if ( _closedSteps != var )
    {
        CC_SAFE_RELEASE_NULL ( _closedSteps );
        CC_SAFE_RETAIN ( var );
        _closedSteps = var;
    }
}
 
void AStarPathFinder::setShortestPath ( cocos2d::CCArray* var )
{
    /*if ( shortestPath != var )
    {
    CC_SAFE_RELEASE_NULL ( shortestPath );
    CC_SAFE_RETAIN ( var );
    shortestPath = var;
    }*/
}

 

 


                

        

        

    




    

      

        

            

              
                
                  hpking
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    2
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    8
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                  2
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
cocos2dx 3.0 对战的寻路AI

				
			

			

				

					frankxixu的专栏
				

				

					11-10
					
					733
					
				

			

		

		

			
				
多角色对战中的寻路是一个比较复杂的问题，笔者尝试用一个简单的例子进行说明

			
		

	



                

              
                



	

		

			

				
					
cocos creator 实现A*寻路

				
			

			

				

					06-30
				

			

		

		

			
				
使用javascript在cocos creator上实现了A*寻路算法，使用方块格表示起始点以及障碍路径等，动态调整行列数，障碍物密度，初始点坐标，实现鼠标点击计算起始点到点击位置方块的路径。

			
		

	



                


  
              

                


	

		

			

				
					
cocos2dx-3.10 45度A*寻路

				
			

			

				

					04-27
				

			

		

		

			
				
cocos2dx-3.10 45度A*寻路，
http://blog.csdn.net/iuoon/article/details/51261187

			
		

	





	

		

			

				
					
cocos2dx +lua 斜45度A星寻路算法

				
			

			

				

					07-13
				

			

		

		

			
				
cocos2dx +lua 斜45度A星寻路算法 lua实现
使用
Astar:getInstance():InitAstar(阻挡数组,地图宽,地图高)
Astar:getInstance():GetPath(起点,终点,true) 返回路径点

			
		

	



		

			
		



	

		

			

				
					
cocos2dx使用TiledMap创建斜45度地图场景

				
			

			

				

					帘卷西风的专栏
				

				

					01-02
					
					1万+
					
				

			

		

		

			
				
做游戏，场景是一个很重要的部分，如果缺少这一步，很难做出好的游戏，对于cocos2dx来说，有很多2D的地图编辑器可以用，效果都还可以，其中Tiled是支持的比较好的，它支持Tiled编辑出来的几种模式，比如正常、45度地图等。
     如果要做小型的手机游戏，使用正常模式就足够了，cocosdx支持的很好，如果要具有3D感，那么可以使用45度正常地图。但是如果要做大场景，比如底图4000*4

			
		

	





	

		

			

				
					
Bstar 算法

				
			

			

				

					qq_37405874的博客
				

				

					07-26
					
					1260
					
				

			

		

		

			
				
https://www.cnblogs.com/0x-1119/p/10603162.html


			
		

	





	

		

			

				
					
android 45度地图 道路,45度角地图人物行走寻路

				
			

			

				

					weixin_42298254的博客
				

				

					05-27
					
					372
					
				

			

		

		

			
				
iteye的博客太难编辑了，改天要换个地方了。最近在研究45度地图，写了一个demo，主要的类有两个，第一个,人物控制的类package view{import com.friendsofed.isometric.IsoObject;import constVars.Directions;import flash.display.Bitmap;import flash.display.Bitmap...

			
		

	





	

		

			

				
					
[cocos2d-x]瓦片地图的应用

				
			

			

				

					学无止境的专栏
				

				

					09-22
					
					5178
					
				

			

		

		

			
				
前言：
我们在做经典的格斗类的游戏的时候，场景常常用的是45°斜地图来创建的。下面我就来实现一个简单的Demo来展现一下斜地图的使用。
功能实现：
1.倾斜地图的加载；
2.点击地图居中；
代码实现：
HelloWorld.h:

#ifndef __HELLOWORLD_SCENE_H__
#define __HELLOWORLD_SCENE_H__

#include "coc

			
		

	





	

		

			

				
					
Cocos2dx-2.2.3  A星寻路算法源码

				
			

			

				

					04-09
				

			

		

		

			
				
理解并实现A星寻路算法对于Cocos2dx游戏开发者来说至关重要，因为它能确保游戏角色在复杂环境中准确、高效地移动，提升玩家的游戏体验。通过深入研究提供的源码，开发者可以学习到如何将A*算法应用于实际项目，同时...

			
		

	





	

		

			

				
					
CocosCreator A*自动寻路demo

				
			

			

				

					09-29
				

			

		

		

			
				
CocosCreator A*自动寻路，使用js实现的，可以点击地图寻路，并实现了中途转变终点位置的cocos项目

			
		

	





	

		

			

				
					
A星寻路Cocos2dx3.3自动寻路代码

				
			

			

				

					10-16
				

			

		

		

			
				
利用cocos2dx写的A星自动寻路算法，为了大家能很好的理解，我画了程序流程图辅助大家理解算法。vs2012+cocos2dx 3.3 编写。
如果对于原理不太懂，可以到我的博客看原理，地址如下。
http://blog.csdn.net/u010946556/article/details/49027301

			
		

	





	

		

			

				
					
Cocos Creator 3.2 中实现2D地图3D人物45度角RPG游戏效果笔记（摄像机设置方案）

				
			

			

				

					weixin_39324642的博客
				

				

					07-12
					
					2962
					
				

			

		

		

			
				
2D地图摄像机
3D人物摄像机
界面小地图摄像机
动态3D人物头像摄像机



			
		

	





	

		

			

				
					
[cocos2d-x]45度斜地图的应用

				
			

			

				

					jishublog
				

				

					09-22
					
					338
					
				

			

		

		

			
				
前言：
我们在做经典的格斗类的游戏的时候，场景常常用的是45°斜地图来创建的。下面我就来实现一个简单的Demo来展现一下斜地图的使用。
功能实现：
1.倾斜地图的加载；
2.点击地图居中；
3.主角的移动；
代码实现：
图层要设置z轴属性，方便可以隐藏主角：
在图层的属性中加上 cc_vertexz -400
如果前面的图层那就设置为automatic
在AppDelegate...

			
		

	





	

		

			

				
					
高级数据结构——B*算法（Branch Star）

				
			

			

				

					菜鸡工坊
				

				

					09-10
					
					8003
					
				

			

		

		

			
				
算法原理
前置定义：

探索节点：

为了叙述方便，我们定义在寻路过程中向前探索的节点（地图格子）称为探索节点，起始探索节点即为原点。（探索节点可以对应为A*中的开放节点）

自由的探索节点：

探索节点朝着目标前进，如果前方不是阻挡，探索节点可以继续向前进入下一个地图格子，这种探索节点我们称为自由探索节点；

绕爬的探索节点：

探索节点朝着目标前进，如果前方是阻挡，探索节点将试图绕过阻挡，绕行...

			
		

	





	

		

			

				
					
地图信息,障碍判断以及寻路算法(A星算法,B星算法和蚁群算法等)

				
			

			

				

					任鸟飞2217777779的博客
				

				

					12-06
					
					3810
					
				

			

		

		

			
				
A星不会像广度优先遍历那样探索所有的步骤,而是选择每一步中最优的方块。
这样就可以大大提高效率了。

			
		

	





	

		

			

				
					
如何基于cocos2dx3.x实现A星寻路算法

				
			

			

				

					水墨鱼的专栏
				

				

					05-15
					
					3167
					
				

			

		

		

			
				
在学习本篇教程之前，如果你有cocos2d-x的开发经验，将会有所帮助。如果没有也没关系，因为你可以将这里讲解的例子迁移到其他的语言或者框架中。

找到到达你键盘的最短路径，开始吧！

Maze猫

首先介绍下我们将要在本篇教程中开发的简单游戏。

前往下载本篇教程的工程代码。编译运行工程，你将看到以下画面。



在这款游戏中，你扮演着一只小偷猫，在一个由危险的狗守护着的

			
		

	





	

		

			

				
					
cocos2dx之寻路 A星

				
			

			

				

					xi_mi_的专栏
				

				

					09-19
					
					435
					
				

			

		

		

			
				
–寻路local MAX_ROW_NUM = 9 --行数
local MAX_COL_NUM = 9 --列数
local director = cc.Director:getInstance()
local visibleSize = director:getVisibleSize()–小方块宽高local ItemWidth  = visibleSize.width / MAX_COL_NUM

			
		

	





	

		

			

				
					
一种高效的寻路算法 - B*寻路算法

					
热门推荐

				
			

			

				

					y13156556538的博客
				

				

					04-13
					
					2万+
					
				

			

		

		

			
				
http://qinysong.iteye.com/blog/678941


在此把这个算法称作B* 寻路算法（Branch Star 分支寻路算法，且与A*对应），本算法适用于游戏中怪物的自动寻路，其效率远远超过A*算法，经过测试，效率是普通A*算法的几十上百倍。 

通过引入该算法，一定程度上解决了游戏服务器端无法进行常规寻路的效率问题，除非服务器端有独立的AI处理线程，否则在服务

			
		

	





	

		

			

				
					
让Tiled成为一个强有力的45度菱形Staggered打点器(地图编辑器)

				
			

			

				

					navno1的专栏
				

				

					01-15
					
					2295
					
				

			

		

		

			
				
让Tiled成为一个强有力的45度菱形Staggered打点器(地图编辑器)


分类： cocos2dx2013-08-05
 23:09 1601人阅读 评论(1) 收藏 举报

Tiled的确强大，处理基于tile(网格)的地图很方便，曾成功的利用Tiled来打点45度地图，在此分享点小技巧。
先看效果图:


然后看打点层的:




强大的地方在于：可以按下

			
		

	





	

		

			

				
					
Cocos A*算法寻路

					
最新发布

				
			

			

				

					08-12
				

			

		

		

			
				
Cocos A*算法寻路是基于A*算法的一种路径搜索算法，用于在游戏中实现角色的自动寻路功能。A*算法是一种启发式搜索算法，它通过评估节点的启发式值来选择最优路径。在待探索列表里，A*算法会先预测哪个节点的路径可能...

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		
评论 2

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值