cocos2dx下的A星算法

        这是我依据这篇博文http://hi.baidu.com/wsapyoemdfacmqr/item/bdfb5c0a74c904d01ef0466d。来在cocos2dx上编写。这是终于的效果图：

红色的地方是执行轨迹，黑色是禁止区域，接下来是代码，请结合那篇博文观看：

首先创建地板类，必需要有x和y，还有依据那篇博文的h和g。这是h文件里的代码：

#include "cocos2d.h"

typedef enum _FloorState
{
    FloorGround,
    FloorRiver
} FloorState;

class Floor : public cocos2d::LayerColor
{
public:
    Floor();
    ~Floor(){}
    
    static int at(int x, int y);
    static Floor * create(const cocos2d::Color4B& color);
    bool initWithColor(const cocos2d::Color4B& color);
    
    int getF();
    
private:
    CC_SYNTHESIZE(int, _x, X);
    CC_SYNTHESIZE(int, _y, Y);
    
    CC_SYNTHESIZE(int, _h, H);
    CC_SYNTHESIZE(int, _g, G);
    
    CC_SYNTHESIZE(FloorState, _landForm, LandForm);
    
    CC_SYNTHESIZE(Floor *, _lastFloor, LastFloor);
};

基本上没有什么难度，另外，那个静态方法at使用了从数组中高速获取地板。

然后是cpp文件：

#include "Floor.h"

USING_NS_CC;

Floor::Floor()
{
    _x = 0;
    _y = 0;
    
    _h = -1;
    _g = -1;
    
    _lastFloor = NULL;
}

int Floor::at(int x, int y)
{
    return x + 28 * y;
}

Floor *Floor::create(const cocos2d::Color4B &color)
{
    Floor *_floor = new Floor();
    if ( _floor && _floor -> initWithColor( color ) )
    {
        _floor -> autorelease();
        return _floor;
    }
    
    delete _floor;
    _floor = NULL;
    return NULL;
}

bool Floor::initWithColor(const cocos2d::Color4B &color)
{
    if ( LayerColor::initWithColor(color, 39, 39) )
    {
        return true;
    }
    
    return false;
}

int Floor::getF()
{
    return _h + _g;
}

然后在执行的Layer中：

void MainScene::createGround()
{
    for (int y = 0; y < 18; y++)
    {
        for (int x = 0; x < 28; x++)
        {
            auto _floor = Floor::create( Color4B(255, 255, 255, 255) );
            _floor -> setPosition(x * (_floor -> getContentSize().width + 1), y * (_floor -> getContentSize().height + 1));
            _floor -> setX(x);
            _floor -> setY(y);
            _floor -> setLandForm( FloorGround );
            this -> addChild( _floor );
            
            if ( (x == 15 && y < 7) || (x == 3 && y < 10) || (y == 12 && x < 20) || (x == 5 && y > 8) || (x == 13 && y > 1) )
            {
                _floor -> setColor( Color3B(0, 0, 0) );
                _floor -> setLandForm( FloorRiver );
            }
            ground.pushBack( _floor );
        }
    }
}

当中，这种方法：_floor -> setLandForm( FloorRiver )使用来制造禁止区域

然后加入起点和终点：

    end = Floor::create( Color4B(0, 255, 255, 10) );
    end -> setPosition( (ground.at( Floor::at(24, 14) )) -> getPosition() );
    end -> setX(24);
    end -> setY(14);
    this -> addChild( end );
    
    origin = Floor::create( Color4B(255, 255, 0, 255) );
    origin -> setPosition( (ground.at( Floor::at(0, 0) )) -> getPosition() );
    origin -> setX(0);
    origin -> setY(0);
    origin -> setH( fabs((end -> getX() - origin -> getX())) + fabs( end -> getY() - origin -> getY() ) );
    origin -> setG(0);
    this -> addChild( origin );
    open.pushBack( origin );

在这些完毕后，就是须要使用A*算法来计算出路径了

首先从open数组中寻找F最小的地板；之后。将上下左右的地板做个推断，是否增加数组中。这部分放在一个死循环中，当增加的地板正是终点时，能够结束：

while (1)
    {
        Vector< Floor * >::iterator index = open.begin();
        Vector< Floor * >::iterator minF = index;
        for (; index != open.end(); index++)
        {
            if ( (*index) -> getF() < (*minF) -> getF() )
            {
                minF = index;
            }
        }
        
        Floor *_origin = (*minF);
        
        handleFloor(_origin, _origin -> getX(), _origin -> getY() - 1);
        handleFloor(_origin, _origin -> getX(), _origin -> getY() + 1);
        handleFloor(_origin, _origin -> getX() - 1, _origin -> getY());
        handleFloor(_origin, _origin -> getX() + 1, _origin -> getY());
        
        open.eraseObject( _origin );
        close.pushBack( _origin );
        _origin -> setColor( Color3B(0, 255, 0) );
        
        Floor *getEnd = open.at( open.size() - 1 );
        if ( getEnd -> getX() == end -> getX() && getEnd -> getY() == end -> getY() )
        {
            CCLOG("ENDG");
            return;
        }
    }

handleFloor函数是用来推断该地板是否可以增加数组中

void MainScene::handleFloor(Floor *_floor, int x, int y)
{
    if ( x < 0 || y < 0 )
    {
        return;
    }
    Floor *handle = ground.at( Floor::at(x, y) );
    handle -> setX(x);
    handle -> setY(y);
    handle -> setH( fabs((end -> getX() - handle -> getX())) + fabs( end -> getY() - handle -> getY() ) );
    handle -> setG( fabs((origin -> getX() - handle -> getX())) + fabs( origin -> getY() - handle -> getY() ) );
    JUDGE( handle, _floor );
}

#define JUDGE(__FLOOR__, __LAST__)    \
if ( !open.contains(__FLOOR__) && !close.contains(__FLOOR__) && __FLOOR__ -> getLandForm() != FloorRiver )  \
{ \
open.pushBack( __FLOOR__ ); \
__FLOOR__ -> setColor( Color3B(100, 100, 100) ); \
__FLOOR__ -> setLastFloor( __LAST__ );  \
}   \

之后，就是取出open数组终的最后一块地板，并能够获取这块地板的上一块地板。并将其颜色改变

    Floor *index = open.at( open.size() - 1 );
    
    while ( index -> getLastFloor() != NULL )
    {
        index -> setColor( Color3B(255, 0, 0) );
        index = index -> getLastFloor();
    }

在这里下载