cocos2d实现2D地图A*广度路径算法

.h

#ifndef __HELLOWORLD_SCENE_H__
#define __HELLOWORLD_SCENE_H__

#include "cocos2d.h"

USING_NS_CC;

enum PatchFront
{
Uper = 1,
Down = 2,
Left = 3,
Right = 4,
};

struct SinglePatch;
static SinglePatch* patchvector[32][32];

struct SinglePatch
{
public:
static SinglePatch* CreatePatch(int row, int field)
{
SinglePatch* TempPatch = new SinglePatch(row, field);
return TempPatch;
}

Sprite* GetVision() const { return pSprite; }

SinglePatch* GetPatchNear(PatchFront f)
{
SinglePatch* returnpatch = nullptr;
switch (f)
{
case Uper:
if (Row + 1 >= 32)
return nullptr;
returnpatch = patchvector[Row + 1][Field];
break;
case Down:
if (Row - 1 < 0)
return nullptr;
returnpatch = patchvector[Row - 1][Field];
break;
case Left:
if (Field - 1 < 0)
return nullptr;
returnpatch = patchvector[Row][Field - 1];
break;
case Right:
if (Field + 1 >= 32)
return nullptr;
returnpatch = patchvector[Row][Field + 1];
break;
}
if (returnpatch->IsMarked)
return nullptr;

return returnpatch;
}

void Marked()
{
pSprite->setTexture("Finded.png");
}

void SetStep(int step)
{
Step = step;
char msg[20];
snprintf(msg, 20, "%d", step);
pText->setString(msg);
pSprite->setTexture("Marked.png");
}

void _draw()
{
pSprite->setTexture("WayPoint.png");
}

void SetBefore(SinglePatch* before) { BeforeStep = before; }

void DrawWayPoint()
{
_draw();
SinglePatch* Before = BeforeStep;
while (Before)
{
Before->_draw();
Before = Before->BeforeStep;
}
}

int Step;
bool IsMarked;
private:

SinglePatch(int row, int field) : Row(row), Field(field), Step(0), IsMarked(false), BeforeStep(nullptr)
{
pSprite = Sprite::create("SinglePatch.png");
pSprite->setAnchorPoint(Vec2(0, 0));
pSprite->setPosition(row * 30, field * 30);

char msg[255];
snprintf(msg, 255, "%d|%d", row, field);
pText = LabelTTF::create();
pText->setString(msg);
pText->setHorizontalAlignment(TextHAlignment::CENTER);
pText->setVerticalAlignment(TextVAlignment::CENTER);
pText->setPosition(pSprite->getContentSize() / 2);
pText->setColor(ccc3(0, 0, 0));
pText->setFontSize(18);
pSprite->addChild(pText);
}
~SinglePatch();

int Row;
int Field;
Sprite* pSprite;
LabelTTF* pText;
SinglePatch* BeforeStep;

};

class HelloWorld : public cocos2d::Layer
{
public:
static cocos2d::Scene* createScene();

virtual bool init();

// implement the "static create()" method manually
CREATE_FUNC(HelloWorld);

void FindPatch(SinglePatch* _patch, int Step);
void Begin();
private:

SinglePatch* StartPoint;
SinglePatch* EndPoint;

bool Finded;
std::list<SinglePatch*> ArrayBefore;
std::list<SinglePatch*> ArrayAfter;
};

#endif


.cpp

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

USING_NS_CC;

Scene* HelloWorld::createScene()
{
// 'scene' is an autorelease object
auto scene = Scene::create();

// 'layer' is an autorelease object
auto layer = HelloWorld::create();
layer->setTag(159);
// 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 ( !Layer::init() )
{
return false;
}

for (int i = 0; i < 32; i++)
{
for (int j = 0; j < 32; j++)
{
SinglePatch* patch = SinglePatch::CreatePatch(i, j);
addChild(patch->GetVision());
patchvector[i][j] = patch;
}
}

EndPoint = patchvector[rand() % 31][rand() % 31];
Finded = false;
StartPoint = patchvector[15][15];
StartPoint->SetStep(0);
StartPoint->IsMarked = true;

ArrayBefore.push_back(StartPoint);

std::thread th(&HelloWorld::Begin, this);
th.detach();

return true;
}

void HelloWorld::Begin()
{
//_begin:
while (ArrayBefore.size())
{
if (Finded)
break;
SinglePatch* TempSreach = *ArrayBefore.begin();
ArrayBefore.pop_front();
FindPatch(TempSreach, TempSreach->Step);
}

//goto _begin;
}

void HelloWorld::FindPatch(SinglePatch* _StartPatch, int Step)
{
for (int i = Uper; i != Right + 1; i++)
{
SinglePatch* tempPatch = _StartPatch->GetPatchNear((PatchFront)i);
if (tempPatch == EndPoint)
{
tempPatch->Marked();
_StartPatch->DrawWayPoint();
Finded = true;
return;
}
if (tempPatch)
{
tempPatch->SetBefore(_StartPatch);
tempPatch->SetStep(Step + 1);
tempPatch->IsMarked = true;
ArrayBefore.push_back(tempPatch);
Sleep(100);
}
}
}