关于智能寻路算法的研究，A-Star算法拓展，B星寻路算法
B星算法的原理图：
以下是C语言的一段源码
#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;
}*/
}
-----------------------------------------------------------
为此我做了一个各种算法时间的效率对比
---------------------------------------------------------------
关于B星和B星算法的加强版C星算法的使用，强调的是速度而不是种类繁多的花样。
---------------------------------------------------------------
言归正传，以下我做了一些测试工具（仅仅是测试）
