通用Astar算法 通用A星算法 通用A*算法

最新推荐文章于 2023-08-11 21:23:21 发布
最新推荐文章于 2023-08-11 21:23:21 发布
阅读量1.4k 收藏 2
点赞数 1
分类专栏： 2D游戏
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sryan/article/details/8266021
版权

写RPG游戏的时候，解决怪物寻路问题的时候写的，寻路是正确的，效率虽然说不高，但是还是满足了游戏里面的寻路要求。

提供了4个算法，其中2个是用POINT结构体来输入输出的，还有一个是用自定的结构体来输入输出的，同时函数接受一个数据源，只要自己实现那个Adapter的GetData接口就行了，所以无论你的数据是怎么样的，不用改动原先的代码即可寻路。

SEARCH_OFFSET_X和SEARCH_OFFSET_Y是确定搜索范围的，因为游戏效率要求，所以可以设置的小点，不然的话设大点也行。


下面是代码：

头文件:

#ifndef _SASTART_H_
#define _SASTART_H_
#include <Windows.h>
#include <stack>
#include <vector>
#include <list>

#define SEARCH_OFFSET_X	5
#define SEARCH_OFFSET_Y	5

namespace SASTAR
{
	enum ASTAR_DIRECTION
	{
		ADT_TOPLEFT,
		ADT_TOP,
		ADT_TOPRIGHT,
		ADT_LEFT,
		ADT_RIGHT,
		ADT_BOTTOMLEFT,
		ADT_BOTTOM,
		ADT_BOTTOMRIGHT,
		ADT_TOTAL,
	};
	struct SAstarElement
	{
		int nX;
		int nY;
		BOOL bOpen;
		//	计算信息
		//	和
		int nFn;
		//	开始点到当前位置移动距离
		UINT nGn;
		//	当前位置到目标坐标的距离
		UINT nHn;
		SAstarElement* pParent;
	};

	typedef std::list<SAstarElement>								SAstarElements;
	typedef std::list<SAstarElement*>								SAstarPelements;
	typedef std::list<POINT>										SAstarPoints;

	class SAstarDataAdaptor
	{
	public:
		SAstarDataAdaptor()
		{
			m_pSrc = NULL;
		}
		virtual ~SAstarDataAdaptor(){}

	public:
		void SetDataSource(void* _psrc)
		{
			m_pSrc = _psrc;
		}
		//	返回元素nFn为-1表示元素不存在
		virtual SAstarElement GetData(int _x, int _y) const = 0;

	protected:
		void* m_pSrc;
	};

	//	Element
	BOOL Calculate8DirectionNormal(const SAstarDataAdaptor* _psrc, SAstarElements* _pret, const SAstarElement* _pfrom, const SAstarElement* _pto);
	BOOL Calculate8DirectionNoDiag(const SAstarDataAdaptor* _psrc, SAstarElements* _pret, const SAstarElement* _pfrom, const SAstarElement* _pto);
	//	POINT
	BOOL Calculate8DirectionNormal(const SAstarDataAdaptor* _psrc, SAstarPoints* _pret, const POINT* _pfrom, const POINT* _pto);
	BOOL Calculate8DirectionNoDiag(const SAstarDataAdaptor* _psrc, SAstarPoints* _pret, const POINT* _pfrom, const POINT* _pto);

	//	启发式计算Hn
	int GetElementHn(const SAstarElement* _pcur, const SAstarElement* _pdest);
	int GetElementHn(const SAstarElement* _pcur, const POINT* _pdest);
	bool operator== (const SAstarElement& ele1, const SAstarElement& ele2);

	struct SAstarCompGreater
	{
		bool operator()(const SAstarElement* e1, const SAstarElement* e2)
		{
 			if(e1->nFn < e2->nFn)
 			{
 				return true;
 			}
			
			return false;
		}
	};

	struct SAstarEqual
	{
		bool operator()(const SAstarElement& e1, const SAstarElement& e2)
		{
			if(e1.nX == e2.nX &&
				e2.nY == e1.nY)
			{
				return true;
			}
			return false;
		}
	};

};

#endif


源文件:

//#include "stdafx.h"
#include "SAstar.h"
#include <math.h>
#include <algorithm>

namespace SASTAR
{
	BOOL Calculate8DirectionNormal(const SAstarDataAdaptor* _psrc, SAstarElements* _pret, const SAstarElement* _pfrom, const SAstarElement* _pto)
	{
		if(_psrc == NULL ||
			_pret == NULL)
		{
			return FALSE;
		}

		static const int nCalTable[] = {-1,-1,0,-1,1,-1,-1,0,1,0,-1,1,0,1,1,1};
		static const int nCostNormal = 10;
		static const int nCostDiag = 14;

		SAstarPelements m_OpenTable;
		SAstarPelements m_CloseTable;

		int nLeftX = min(_pfrom->nX, _pto->nX);
		int nTopY = min(_pfrom->nY, _pto->nY);
		int nArrayWidth = (nLeftX < SEARCH_OFFSET_X ? nLeftX : SEARCH_OFFSET_X) + SEARCH_OFFSET_X + abs(_pfrom->nX - _pto->nX) + 1;
		int nArrayHeight = (nTopY < SEARCH_OFFSET_Y ? nTopY : SEARCH_OFFSET_Y) + SEARCH_OFFSET_Y + abs(_pfrom->nY - _pto->nY) + 1;
		int nArraySize = (nArrayWidth * nArrayHeight);
		nLeftX -= SEARCH_OFFSET_X;
		if(nLeftX < 0)
		{
			nLeftX = 0;
		}
		nTopY -= SEARCH_OFFSET_Y;
		if(nTopY < 0)
		{
			nTopY = 0;
		}
		SAstarElement* pSearchEle = new SAstarElement[nArraySize];
		ZeroMemory(pSearchEle, sizeof(SAstarElement) * nArraySize);

		SAstarElement ardEles[ADT_TOTAL];
		ZeroMemory(ardEles, sizeof(ardEles));
		SAstarElement getEle;

		SAstarElement* pTst;

// 		_pfrom->pParent = NULL;
// 		_pfrom->nGn = 0;
// 		_pfrom->nHn = 0;
// 		_pfrom->nFn = 0;
		pSearchEle[(_pfrom->nY - nTopY) * nArrayWidth + _pfrom->nX - nLeftX] = *_pfrom;
		pSearchEle[(_pfrom->nY - nTopY) * nArrayWidth + _pfrom->nX - nLeftX].pParent = NULL;
		pSearchEle[(_pfrom->nY - nTopY) * nArrayWidth + _pfrom->nX - nLeftX].nGn = 0;
		pSearchEle[(_pfrom->nY - nTopY) * nArrayWidth + _pfrom->nX - nLeftX].nFn = 0;
		pSearchEle[(_pfrom->nY - nTopY) * nArrayWidth + _pfrom->nX - nLeftX].nHn = 0;
		m_CloseTable.push_back(&pSearchEle[(_pfrom->nY - nTopY) * nArrayWidth + _pfrom->nX - nLeftX]);
		getEle = *m_CloseTable.back();
		SAstarPelements::iterator iter;
		while(1)
		{
			for(int i = ADT_TOPLEFT; i < ADT_TOTAL; ++i)
			{
				ardEles[i] = _psrc->GetData((*m_CloseTable.back()).nX + nCalTable[2 * i],
					m_CloseTable.back()->nY + nCalTable[2 * i + 1]);

				if((*m_CloseTable.back()).nX + nCalTable[2 * i] < nLeftX ||
					(*m_CloseTable.back()).nX + nCalTable[2 * i] >= nLeftX + nArrayWidth ||
					(*m_CloseTable.back()).nY + nCalTable[2 * i + 1] < nTopY ||
					(*m_CloseTable.back()).nY + nCalTable[2 * i + 1] >= nTopY + nArrayHeight)
				{
					//	不检索在Buffer区域外的点
					ardEles[i].nFn = -1;
					continue;
				}
				for(iter = m_CloseTable.begin();
					iter != m_CloseTable.end();
					++iter)
				{
					if((*iter)->nX == ardEles[i].nX &&
						(*iter)->nY == ardEles[i].nY)
					{
						//	Close表不检测
						break;
					}
				}
				if(iter != m_CloseTable.end())
				{
					//	在Close表中 跳出
					continue;
				}
				if(ardEles[i].nFn == -1 ||
					ardEles[i].bOpen == 0)
				{
					//	不存在 或者不可通过
					ardEles[i].nFn = -1;
				}
				else
				{
					//	存在 有两种情况 一种在Open表中 一种不在
					for(iter = m_OpenTable.begin();
						iter != m_OpenTable.end();
						++iter)
					{
						if((*iter)->nX == ardEles[i].nX &&
							(*iter)->nY == ardEles[i].nY)
						{
							break;
						}
					}

					//ardEles[i].pParent = &pSearchEle[(m_CloseTable.back()->nY - nTopY) * nArrayWidth + m_CloseTable.back()->nX - nLeftX];
					ardEles[i].pParent = m_CloseTable.back();

					//	假设该元素与目的元素相同 则找到
					if(ardEles[i].nX == _pto->nX &&
						ardEles[i].nY == _pto->nY)
					{
						//	依照parent寻找路径
						SAstarElement* pEle = ardEles[i].pParent;
						while(pEle)
						{
							_pret->push_back(*pEle);
							pEle = pEle->pParent;
						}
						_pret->reverse();
						delete[] pSearchEle;
						return TRUE;
					}

					if(iter == m_OpenTable.end())
					{
						//	没有重复元素 直接添加入Open表
						//ardEles[i].pParent = m_CloseTable.back();
						ardEles[i].nGn = ardEles[i].pParent->nGn + ((i == 1 || i == 3 || i == 4 || i == 6) ? nCostNormal : nCostDiag);
						ardEles[i].nHn = GetElementHn(&ardEles[i], _pto) * 10;
						ardEles[i].nFn = ardEles[i].nGn + ardEles[i].nHn;
						pSearchEle[(ardEles[i].nY - nTopY) * nArrayWidth + ardEles[i].nX - nLeftX] = ardEles[i];
						m_OpenTable.push_back(&pSearchEle[(ardEles[i].nY - nTopY) * nArrayWidth + ardEles[i].nX - nLeftX]);
					}
					else
					{
						//	有重复元素 判断Gn 若走到重复方块的Gn小于原先方块的Gn 则修改
						int nTestGn = ardEles[i].pParent->nGn + ((i == 1 || i == 3 || i == 4 || i == 6) ? nCostNormal : nCostDiag);
						if(nTestGn < (*iter)->nGn)
						{
							(*iter)->nGn = nTestGn;
							(*iter)->nFn = (*iter)->nHn + nTestGn;
							//(*iter)->pParent = &pSearchEle[(m_CloseTable.back()->nY - nTopY) * nArrayWidth + m_CloseTable.back()->nX - nLeftX];
							(*iter)->pParent = m_CloseTable.back();
						}
					}
				}
			}

			//	从Open表中找出最小Fn，加入Close表搜索
			if(m_OpenTable.empty())
			{
				//	Open表搜索完了 没有找到路劲
				delete[] pSearchEle;
				return FALSE;
			}
			else
			{
				m_OpenTable.sort(SAstarCompGreater());
				pTst = *m_OpenTable.begin();
				m_CloseTable.push_back(*m_OpenTable.begin());
				m_OpenTable.erase(m_OpenTable.begin());
			}
		}
	}

	BOOL Calculate8DirectionNoDiag(const SAstarDataAdaptor* _psrc, SAstarElements* _pret, const SAstarElement* _pfrom, const SAstarElement* _pto)
	{
		if(_psrc == NULL ||
			_pret == NULL)
		{
			return FALSE;
		}

		if(_pfrom->nX == _pto->nX &&
			_pfrom->nY == _pto->nY)
		{
			return FALSE;
		}

		static const int nCalTable[] = {-1,-1,0,-1,1,-1,-1,0,1,0,-1,1,0,1,1,1};
		static const int nCostNormal = 10;
		static const int nCostDiag = 14;

		SAstarPelements m_OpenTable;
		SAstarPelements m_CloseTable;

		int nLeftX = min(_pfrom->nX, _pto->nX);
		int nTopY = min(_pfrom->nY, _pto->nY);
		int nArrayWidth = (nLeftX < SEARCH_OFFSET_X ? nLeftX : SEARCH_OFFSET_X) + SEARCH_OFFSET_X + abs(_pfrom->nX - _pto->nX) + 1;
		int nArrayHeight = (nTopY < SEARCH_OFFSET_Y ? nTopY : SEARCH_OFFSET_Y) + SEARCH_OFFSET_Y + abs(_pfrom->nY - _pto->nY) + 1;
		int nArraySize = (nArrayWidth * nArrayHeight);
		nLeftX -= SEARCH_OFFSET_X;
		if(nLeftX < 0)
		{
			nLeftX = 0;
		}
		nTopY -= SEARCH_OFFSET_Y;
		if(nTopY < 0)
		{
			nTopY = 0;
		}
		SAstarElement* pSearchEle = new SAstarElement[nArraySize];
		ZeroMemory(pSearchEle, sizeof(SAstarElement) * nArraySize);

		SAstarElement ardEles[ADT_TOTAL];
		ZeroMemory(ardEles, sizeof(ardEles));
		SAstarElement* pTst;

		pSearchEle[(_pfrom->nY - nTopY) * nArrayWidth + _pfrom->nX - nLeftX] = *_pfrom;
		pSearchEle[(_pfrom->nY - nTopY) * nArrayWidth + _pfrom->nX - nLeftX].pParent = NULL;
		pSearchEle[(_pfrom->nY - nTopY) * nArrayWidth + _pfrom->nX - nLeftX].nGn = 0;
		pSearchEle[(_pfrom->nY - nTopY) * nArrayWidth + _pfrom->nX - nLeftX].nFn = 0;
		pSearchEle[(_pfrom->nY - nTopY) * nArrayWidth + _pfrom->nX - nLeftX].nHn = 0;
		m_CloseTable.push_back(&pSearchEle[(_pfrom->nY - nTopY) * nArrayWidth + _pfrom->nX - nLeftX]);
		//getEle = *m_CloseTable.back();
		SAstarPelements::iterator iter;
		while(1)
		{
			for(int i = ADT_TOPLEFT; i < ADT_TOTAL; ++i)
			{
				ardEles[i] = _psrc->GetData((*m_CloseTable.back()).nX + nCalTable[2 * i],
					m_CloseTable.back()->nY + nCalTable[2 * i + 1]);

				if((*m_CloseTable.back()).nX + nCalTable[2 * i] < nLeftX ||
					(*m_CloseTable.back()).nX + nCalTable[2 * i] >= nLeftX + nArrayWidth ||
					(*m_CloseTable.back()).nY + nCalTable[2 * i + 1] < nTopY ||
					(*m_CloseTable.back()).nY + nCalTable[2 * i + 1] >= nTopY + nArrayHeight)
				{
					//	不检索在Buffer区域外的点
					ardEles[i].nFn = -1;
					continue;
				}
				for(iter = m_CloseTable.begin();
					iter != m_CloseTable.end();
					++iter)
				{
					if((*iter)->nX == ardEles[i].nX &&
						(*iter)->nY == ardEles[i].nY)
					{
						//	Close表不检测
						break;
					}
				}
				if(iter != m_CloseTable.end())
				{
					//	在Close表中 跳出
					continue;
				}
				//	对角线行走判断周围两点是否可以行走
				if(i == 0 ||
					i == 2 ||
					i == 5 ||
					i == 7)
				{
					SAstarElement getEle1;
					SAstarElement getEle2;
					POINT ptCenter = {m_CloseTable.back()->nX, m_CloseTable.back()->nY};
					switch(i)
					{
					case 0:
						{
							getEle1 = _psrc->GetData(ptCenter.x - 1, ptCenter.y);
							getEle2 = _psrc->GetData(ptCenter.x, ptCenter.y - 1);
						}break;
					case 2:
						{
							getEle1 = _psrc->GetData(ptCenter.x, ptCenter.y - 1);
							getEle2 = _psrc->GetData(ptCenter.x + 1, ptCenter.y);
						}break;
					case 5:
						{
							getEle1 = _psrc->GetData(ptCenter.x - 1, ptCenter.y);
							getEle2 = _psrc->GetData(ptCenter.x, ptCenter.y + 1);
						}break;
					case 7:
						{
							getEle1 = _psrc->GetData(ptCenter.x, ptCenter.y + 1);
							getEle2 = _psrc->GetData(ptCenter.x + 1, ptCenter.y);
						}break;
					}
					if(!getEle1.bOpen ||
						!getEle2.bOpen)
					{
						//	该元素不作检测 不加入Open表
						continue;
					}
				}

				if(ardEles[i].nFn == -1 ||
					ardEles[i].bOpen == 0)
				{
					//	不存在 或者不可通过
					ardEles[i].nFn = -1;
				}
				else
				{
					//	存在 有两种情况 一种在Open表中 一种不在
					for(iter = m_OpenTable.begin();
						iter != m_OpenTable.end();
						++iter)
					{
						if((*iter)->nX == ardEles[i].nX &&
							(*iter)->nY == ardEles[i].nY)
						{
							break;
						}
					}

					//ardEles[i].pParent = &pSearchEle[(m_CloseTable.back()->nY - nTopY) * nArrayWidth + m_CloseTable.back()->nX - nLeftX];
					ardEles[i].pParent = m_CloseTable.back();

					//	假设该元素与目的元素相同 则找到
					if(ardEles[i].nX == _pto->nX &&
						ardEles[i].nY == _pto->nY)
					{
						//	依照parent寻找路径
						_pret->push_back(ardEles[i]);
						SAstarElement* pEle = ardEles[i].pParent;
						while(pEle)
						{
							_pret->push_back(*pEle);
							pEle = pEle->pParent;
						}
						_pret->reverse();
						delete[] pSearchEle;
						return TRUE;
					}

					if(iter == m_OpenTable.end())
					{
						//	没有重复元素 直接添加入Open表
						//ardEles[i].pParent = m_CloseTable.back();
						ardEles[i].nGn = ardEles[i].pParent->nGn + ((i == 1 || i == 3 || i == 4 || i == 6) ? nCostNormal : nCostDiag);
						ardEles[i].nHn = GetElementHn(&ardEles[i], _pto) * 10;
						ardEles[i].nFn = ardEles[i].nGn + ardEles[i].nHn;
						pSearchEle[(ardEles[i].nY - nTopY) * nArrayWidth + ardEles[i].nX - nLeftX] = ardEles[i];
						m_OpenTable.push_back(&pSearchEle[(ardEles[i].nY - nTopY) * nArrayWidth + ardEles[i].nX - nLeftX]);
					}
					else
					{
						//	有重复元素 判断Gn 若走到重复方块的Gn小于原先方块的Gn 则修改
						int nTestGn = ardEles[i].pParent->nGn + ((i == 1 || i == 3 || i == 4 || i == 6) ? nCostNormal : nCostDiag);
						if(nTestGn < (*iter)->nGn)
						{
							(*iter)->nGn = nTestGn;
							(*iter)->nFn = (*iter)->nHn + nTestGn;
							//(*iter)->pParent = &pSearchEle[(m_CloseTable.back()->nY - nTopY) * nArrayWidth + m_CloseTable.back()->nX - nLeftX];
							(*iter)->pParent = m_CloseTable.back();
						}
					}
				}
			}

			//	从Open表中找出最小Fn，加入Close表搜索
			if(m_OpenTable.empty())
			{
				//	Open表搜索完了 没有找到路劲
				delete[] pSearchEle;
				return FALSE;
			}
			else
			{
				m_OpenTable.sort(SAstarCompGreater());
				pTst = *m_OpenTable.begin();
				m_CloseTable.push_back(*m_OpenTable.begin());
				m_OpenTable.erase(m_OpenTable.begin());
			}
		}
	}


	//	POINT
	BOOL Calculate8DirectionNormal(const SAstarDataAdaptor* _psrc, SAstarPoints* _pret, const POINT* _pfrom, const POINT* _pto)
	{
		if(_psrc == NULL ||
			_pret == NULL)
		{
			return FALSE;
		}

		if(_pfrom->x == _pto->x &&
			_pfrom->y == _pto->y)
		{
			return FALSE;
		}

		static const int nCalTable[] = {-1,-1,0,-1,1,-1,-1,0,1,0,-1,1,0,1,1,1};
		static const int nCostNormal = 10;
		static const int nCostDiag = 14;

		SAstarPelements m_OpenTable;
		SAstarPelements m_CloseTable;

		int nLeftX = min(_pfrom->x, _pto->x);
		int nTopY = min(_pfrom->y, _pto->y);
		int nArrayWidth = (nLeftX < SEARCH_OFFSET_X ? nLeftX : SEARCH_OFFSET_X) + SEARCH_OFFSET_X + abs(_pfrom->x - _pto->y) + 1;
		int nArrayHeight = (nTopY < SEARCH_OFFSET_Y ? nTopY : SEARCH_OFFSET_Y) + SEARCH_OFFSET_Y + abs(_pfrom->x - _pto->y) + 1;
		int nArraySize = (nArrayWidth * nArrayHeight);
		nLeftX -= SEARCH_OFFSET_X;
		if(nLeftX < 0)
		{
			nLeftX = 0;
		}
		nTopY -= SEARCH_OFFSET_Y;
		if(nTopY < 0)
		{
			nTopY = 0;
		}
		SAstarElement* pSearchEle = new SAstarElement[nArraySize];
		ZeroMemory(pSearchEle, sizeof(SAstarElement) * nArraySize);

		SAstarElement ardEles[ADT_TOTAL];
		ZeroMemory(ardEles, sizeof(ardEles));
		SAstarElement getEle;

		SAstarElement* pTst;

		// 		_pfrom->pParent = NULL;
		// 		_pfrom->nGn = 0;
		// 		_pfrom->nHn = 0;
		// 		_pfrom->nFn = 0;
		//		pSearchEle[(_pfrom->nY - nTopY) * nArrayWidth + _pfrom->nX - nLeftX] = *_pfrom;
		pSearchEle[(_pfrom->y - nTopY) * nArrayWidth + _pfrom->x - nLeftX].nX = _pfrom->x;
		pSearchEle[(_pfrom->y - nTopY) * nArrayWidth + _pfrom->x - nLeftX].nY = _pfrom->y;
		pSearchEle[(_pfrom->y - nTopY) * nArrayWidth + _pfrom->x - nLeftX].pParent = NULL;
		pSearchEle[(_pfrom->y - nTopY) * nArrayWidth + _pfrom->x - nLeftX].nGn = 0;
		pSearchEle[(_pfrom->y - nTopY) * nArrayWidth + _pfrom->x - nLeftX].nFn = 0;
		pSearchEle[(_pfrom->y - nTopY) * nArrayWidth + _pfrom->x - nLeftX].nHn = 0;
		m_CloseTable.push_back(&pSearchEle[(_pfrom->y - nTopY) * nArrayWidth + _pfrom->x - nLeftX]);
		getEle = *m_CloseTable.back();
		SAstarPelements::iterator iter;
		while(1)
		{
			for(int i = ADT_TOPLEFT; i < ADT_TOTAL; ++i)
			{
				ardEles[i] = _psrc->GetData((*m_CloseTable.back()).nX + nCalTable[2 * i],
					m_CloseTable.back()->nY + nCalTable[2 * i + 1]);

				if((*m_CloseTable.back()).nX + nCalTable[2 * i] < nLeftX ||
					(*m_CloseTable.back()).nX + nCalTable[2 * i] >= nLeftX + nArrayWidth ||
					(*m_CloseTable.back()).nY + nCalTable[2 * i + 1] < nTopY ||
					(*m_CloseTable.back()).nY + nCalTable[2 * i + 1] >= nTopY + nArrayHeight)
				{
					//	不检索在Buffer区域外的点
					ardEles[i].nFn = -1;
					continue;
				}
				for(iter = m_CloseTable.begin();
					iter != m_CloseTable.end();
					++iter)
				{
					if((*iter)->nX == ardEles[i].nX &&
						(*iter)->nY == ardEles[i].nY)
					{
						//	Close表不检测
						break;
					}
				}
				if(iter != m_CloseTable.end())
				{
					//	在Close表中 跳出
					continue;
				}
				if(ardEles[i].nFn == -1 ||
					ardEles[i].bOpen == 0)
				{
					//	不存在 或者不可通过
					ardEles[i].nFn = -1;
				}
				else
				{
					//	存在 有两种情况 一种在Open表中 一种不在
					for(iter = m_OpenTable.begin();
						iter != m_OpenTable.end();
						++iter)
					{
						if((*iter)->nX == ardEles[i].nX &&
							(*iter)->nY == ardEles[i].nY)
						{
							break;
						}
					}

					//ardEles[i].pParent = &pSearchEle[(m_CloseTable.back()->nY - nTopY) * nArrayWidth + m_CloseTable.back()->nX - nLeftX];
					ardEles[i].pParent = m_CloseTable.back();

					//	假设该元素与目的元素相同 则找到
					if(ardEles[i].nX == _pto->x &&
						ardEles[i].nY == _pto->y)
					{
						//	依照parent寻找路径
						SAstarElement* pEle = ardEles[i].pParent;
						POINT tPoint = {ardEles[i].nX, ardEles[i].nY};
						_pret->push_back(tPoint);
						while(pEle)
						{
							tPoint.x = pEle->nX;
							tPoint.y = pEle->nY;
							_pret->push_back(tPoint);
							pEle = pEle->pParent;
						}
						_pret->reverse();
						delete[] pSearchEle;
						return TRUE;
					}

					if(iter == m_OpenTable.end())
					{
						//	没有重复元素 直接添加入Open表
						//ardEles[i].pParent = m_CloseTable.back();
						ardEles[i].nGn = ardEles[i].pParent->nGn + ((i == 1 || i == 3 || i == 4 || i == 6) ? nCostNormal : nCostDiag);
						ardEles[i].nHn = GetElementHn(&ardEles[i], _pto) * 10;
						ardEles[i].nFn = ardEles[i].nGn + ardEles[i].nHn;
						pSearchEle[(ardEles[i].nY - nTopY) * nArrayWidth + ardEles[i].nX - nLeftX] = ardEles[i];
						m_OpenTable.push_back(&pSearchEle[(ardEles[i].nY - nTopY) * nArrayWidth + ardEles[i].nX - nLeftX]);
					}
					else
					{
						//	有重复元素 判断Gn 若走到重复方块的Gn小于原先方块的Gn 则修改
						int nTestGn = ardEles[i].pParent->nGn + ((i == 1 || i == 3 || i == 4 || i == 6) ? nCostNormal : nCostDiag);
						if(nTestGn < (*iter)->nGn)
						{
							(*iter)->nGn = nTestGn;
							(*iter)->nFn = (*iter)->nHn + nTestGn;
							//(*iter)->pParent = &pSearchEle[(m_CloseTable.back()->nY - nTopY) * nArrayWidth + m_CloseTable.back()->nX - nLeftX];
							(*iter)->pParent = m_CloseTable.back();
						}
					}
				}
			}

			//	从Open表中找出最小Fn，加入Close表搜索
			if(m_OpenTable.empty())
			{
				//	Open表搜索完了 没有找到路劲
				delete[] pSearchEle;
				return FALSE;
			}
			else
			{
				m_OpenTable.sort(SAstarCompGreater());
				pTst = *m_OpenTable.begin();
				m_CloseTable.push_back(*m_OpenTable.begin());
				m_OpenTable.erase(m_OpenTable.begin());
			}
		}
	}

	BOOL Calculate8DirectionNoDiag(const SAstarDataAdaptor* _psrc, SAstarPoints* _pret, const POINT* _pfrom, const POINT* _pto)
	{
		if(_psrc == NULL ||
			_pret == NULL)
		{
			return FALSE;
		}

		if(_pfrom->x == _pto->x &&
			_pfrom->y == _pto->y)
		{
			return FALSE;
		}

		static const int nCalTable[] = {-1,-1,0,-1,1,-1,-1,0,1,0,-1,1,0,1,1,1};
		static const int nCostNormal = 10;
		static const int nCostDiag = 14;

		SAstarPelements m_OpenTable;
		SAstarPelements m_CloseTable;

		int nLeftX = min(_pfrom->x, _pto->x);
		int nTopY = min(_pfrom->y, _pto->y);
		int nArrayWidth = (nLeftX < SEARCH_OFFSET_X ? nLeftX : SEARCH_OFFSET_X) + SEARCH_OFFSET_X + abs(_pfrom->x - _pto->x) + 1;
		int nArrayHeight = (nTopY < SEARCH_OFFSET_Y ? nTopY : SEARCH_OFFSET_Y) + SEARCH_OFFSET_Y + abs(_pfrom->y - _pto->y) + 1;
		int nArraySize = (nArrayWidth * nArrayHeight);
		nLeftX -= SEARCH_OFFSET_X;
		if(nLeftX < 0)
		{
			nLeftX = 0;
		}
		nTopY -= SEARCH_OFFSET_Y;
		if(nTopY < 0)
		{
			nTopY = 0;
		}
		SAstarElement* pSearchEle = new SAstarElement[nArraySize];
		ZeroMemory(pSearchEle, sizeof(SAstarElement) * nArraySize);

		SAstarElement ardEles[ADT_TOTAL];
		ZeroMemory(ardEles, sizeof(ardEles));
		SAstarElement* pTst;

		pSearchEle[(_pfrom->y - nTopY) * nArrayWidth + _pfrom->x - nLeftX].nX = _pfrom->x;
		pSearchEle[(_pfrom->y - nTopY) * nArrayWidth + _pfrom->x - nLeftX].nY = _pfrom->y;
		pSearchEle[(_pfrom->y - nTopY) * nArrayWidth + _pfrom->x - nLeftX].pParent = NULL;
		pSearchEle[(_pfrom->y - nTopY) * nArrayWidth + _pfrom->x - nLeftX].nGn = 0;
		pSearchEle[(_pfrom->y - nTopY) * nArrayWidth + _pfrom->x - nLeftX].nFn = 0;
		pSearchEle[(_pfrom->y - nTopY) * nArrayWidth + _pfrom->x - nLeftX].nHn = 0;
		m_CloseTable.push_back(&pSearchEle[(_pfrom->y - nTopY) * nArrayWidth + _pfrom->x - nLeftX]);
		//getEle = *m_CloseTable.back();
		SAstarPelements::iterator iter;
		while(1)
		{
			for(int i = ADT_TOPLEFT; i < ADT_TOTAL; ++i)
			{
				ardEles[i] = _psrc->GetData((*m_CloseTable.back()).nX + nCalTable[2 * i],
					m_CloseTable.back()->nY + nCalTable[2 * i + 1]);

				if((*m_CloseTable.back()).nX + nCalTable[2 * i] < nLeftX ||
					(*m_CloseTable.back()).nX + nCalTable[2 * i] >= nLeftX + nArrayWidth ||
					(*m_CloseTable.back()).nY + nCalTable[2 * i + 1] < nTopY ||
					(*m_CloseTable.back()).nY + nCalTable[2 * i + 1] >= nTopY + nArrayHeight)
				{
					//	不检索在Buffer区域外的点
					ardEles[i].nFn = -1;
					continue;
				}
				for(iter = m_CloseTable.begin();
					iter != m_CloseTable.end();
					++iter)
				{
					if((*iter)->nX == ardEles[i].nX &&
						(*iter)->nY == ardEles[i].nY)
					{
						//	Close表不检测
						break;
					}
				}
				if(iter != m_CloseTable.end())
				{
					//	在Close表中 跳出
					continue;
				}
				//	对角线行走判断周围两点是否可以行走
				if(i == 0 ||
					i == 2 ||
					i == 5 ||
					i == 7)
				{
					SAstarElement getEle1;
					SAstarElement getEle2;
					POINT ptCenter = {m_CloseTable.back()->nX, m_CloseTable.back()->nY};
					switch(i)
					{
					case 0:
						{
							getEle1 = _psrc->GetData(ptCenter.x - 1, ptCenter.y);
							getEle2 = _psrc->GetData(ptCenter.x, ptCenter.y - 1);
						}break;
					case 2:
						{
							getEle1 = _psrc->GetData(ptCenter.x, ptCenter.y - 1);
							getEle2 = _psrc->GetData(ptCenter.x + 1, ptCenter.y);
						}break;
					case 5:
						{
							getEle1 = _psrc->GetData(ptCenter.x - 1, ptCenter.y);
							getEle2 = _psrc->GetData(ptCenter.x, ptCenter.y + 1);
						}break;
					case 7:
						{
							getEle1 = _psrc->GetData(ptCenter.x, ptCenter.y + 1);
							getEle2 = _psrc->GetData(ptCenter.x + 1, ptCenter.y);
						}break;
					}
					if(!getEle1.bOpen ||
						!getEle2.bOpen)
					{
						//	该元素不作检测 不加入Open表
						continue;
					}
				}

				if(ardEles[i].nFn == -1 ||
					ardEles[i].bOpen == 0)
				{
					//	不存在 或者不可通过
					ardEles[i].nFn = -1;
				}
				else
				{
					//	存在 有两种情况 一种在Open表中 一种不在
					for(iter = m_OpenTable.begin();
						iter != m_OpenTable.end();
						++iter)
					{
						if((*iter)->nX == ardEles[i].nX &&
							(*iter)->nY == ardEles[i].nY)
						{
							break;
						}
					}

					//ardEles[i].pParent = &pSearchEle[(m_CloseTable.back()->nY - nTopY) * nArrayWidth + m_CloseTable.back()->nX - nLeftX];
					ardEles[i].pParent = m_CloseTable.back();

					//	假设该元素与目的元素相同 则找到
					if(ardEles[i].nX == _pto->x &&
						ardEles[i].nY == _pto->y)
					{
						//	依照parent寻找路径
						//_pret->push_back(ardEles[i]);
						POINT tPoint = {ardEles[i].nX, ardEles[i].nY};
						_pret->push_back(tPoint);
						SAstarElement* pEle = ardEles[i].pParent;
						while(pEle)
						{
							tPoint.x = pEle->nX;
							tPoint.y = pEle->nY;
							_pret->push_back(tPoint);
							pEle = pEle->pParent;
						}
						_pret->reverse();
						delete[] pSearchEle;
						return TRUE;
					}

					if(iter == m_OpenTable.end())
					{
						//	没有重复元素 直接添加入Open表
						//ardEles[i].pParent = m_CloseTable.back();
						ardEles[i].nGn = ardEles[i].pParent->nGn + ((i == 1 || i == 3 || i == 4 || i == 6) ? nCostNormal : nCostDiag);
						ardEles[i].nHn = GetElementHn(&ardEles[i], _pto) * 10;
						ardEles[i].nFn = ardEles[i].nGn + ardEles[i].nHn;
						pSearchEle[(ardEles[i].nY - nTopY) * nArrayWidth + ardEles[i].nX - nLeftX] = ardEles[i];
						m_OpenTable.push_back(&pSearchEle[(ardEles[i].nY - nTopY) * nArrayWidth + ardEles[i].nX - nLeftX]);
					}
					else
					{
						//	有重复元素 判断Gn 若走到重复方块的Gn小于原先方块的Gn 则修改
						int nTestGn = ardEles[i].pParent->nGn + ((i == 1 || i == 3 || i == 4 || i == 6) ? nCostNormal : nCostDiag);
						if(nTestGn < (*iter)->nGn)
						{
							(*iter)->nGn = nTestGn;
							(*iter)->nFn = (*iter)->nHn + nTestGn;
							//(*iter)->pParent = &pSearchEle[(m_CloseTable.back()->nY - nTopY) * nArrayWidth + m_CloseTable.back()->nX - nLeftX];
							(*iter)->pParent = m_CloseTable.back();
						}
					}
				}
			}

			//	从Open表中找出最小Fn，加入Close表搜索
			if(m_OpenTable.empty())
			{
				//	Open表搜索完了 没有找到路径
				delete[] pSearchEle;
				return FALSE;
			}
			else
			{
				m_OpenTable.sort(SAstarCompGreater());
				pTst = *m_OpenTable.begin();
				m_CloseTable.push_back(*m_OpenTable.begin());
				m_OpenTable.erase(m_OpenTable.begin());
			}
		}
	}



	//	Helper
	int GetElementHn(const SAstarElement* _pcur, const SAstarElement* _pdest)
	{
		int nHn = 0;
		nHn = abs((int)_pdest->nX - (int)_pcur->nX) + abs((int)_pdest->nY - (int)_pcur->nY);
		return nHn;
	}
	int GetElementHn(const SAstarElement* _pcur, const POINT* _pdest)
	{
		int nHn = 0;
		nHn = abs((int)_pdest->x - (int)_pcur->nX) + abs((int)_pdest->y - (int)_pcur->nY);
		return nHn;
	}

	bool operator== (const SAstarElement& ele1, const SAstarElement& ele2)
	{
		if(ele1.nX == ele2.nX &&
			ele2.nY == ele1.nY)
		{
			return true;
		}
		return false;
	}

};


碎炎
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
A*算法(Astar算法/A星算法)C++模板函数实现.zip
01-28
这是A*算法的C++(MSVC)实现，利用了模板函数，有两个测试用例，一个是迷宫寻路，一个是求解八数码问题。 压缩包内包括: Astar.hpp //这是A*算法的模板函数实现 (还附送个快排算法 testMain_eightDigital.cpp //这是A*算法求解八数码问题的测试用例 testMain_maze.cpp //这是A*算法走迷宫的测试用例 mazeMap.txt //这是A*算法走迷宫的测试用例中用到的地图
Astar3D算法matlab实现
09-12
数学建模中的常用路径规划算法。A*避障算法，实现语言是matlab
AStar寻路算法
weixin_46084262的博客
12-19 4073
AStar算法是一种图形搜索算法，常用于寻路。他是以广度优先搜索为基础，集Dijkstra算法和最佳优先(best fit)于一身的一种算法。
Python|A*算法解决八数码问题
weixin_44217002的博客
01-11 9511
一、Dijkstra算法和A*算法比较 Dijkstra算法和A*算法总结 Dijkstra算法计算源点到其他所有点的最短路径长度，A*关注点到点的最短路径(包括具体路径)。 Dijkstra算法建立在较为抽象的图论层面，A*算法可以更轻松地用在诸如游戏地图寻路中。 Dijkstra算法的实质是广度优先搜索，是一种发散式的搜索，所以空间复杂度和时间复杂度都比较高。对路径上的当前点，A*算法不但记录其到源点的代价，还计算当前点到目标点的期望代价，是一种启发式算法，也可以认为是一种深度优先的算法。 由第一
AStar(A*) 算法
lq
12-28 3491
A*算法是一种静态网格中求解最短路径最有效最直接的搜索方法，估计值与实际值越接近，估价函数取得就越好。 除了A*算法还有很多其他算法，当然有很多寻路算法比A*算法寻路快很多倍，在此主要说A*算法，其他算法不做过多介绍。 A*算法公式为 ： f ( n ) = g ( n ) + h ( n ). 其中 f(n) 是从初始点经由节点n到目标点的估价函数， g(n) 是在状态空间中从初始节...
记录：A星算法
m0_58138380的博客
04-21 436
A*算法、八数码问题
自动驾驶路径规划——A*（Astar）算法
sinat_52032317的博客
10-03 2万+
      1968年发明的A*算法就是把启发式方法（heuristic approaches）如BFS，和常规方法如Dijsktra算法结合在一起的算法。      A-Star算法是一种静态路网中求解最短路径最有效的直接搜索方法，也是解决许多搜索问题的有效算法。
Astar算法
鱼儿往上游的博客
11-02 8492
1.什么是Astar算法？ Astar算法是一种图形搜索算法，常用于寻路。它是个以广度优先搜索为基础，集Dijkstra算法与最佳优先(best fit)算法特点于一身的一种算法。 它通过下面这个函数来计算每个节点的优先级，然后选择优先级最高的节点作为下一个待遍历的节点。优先级函数： 其中： 1.g(n) 是节点n距离起点的代价。 2.h(n)是节点距离终点的预计代价，也就是A*算法的启发函数。 A*算法伪代码如下： //使用open_set、close_set来表示待遍
基于英雄联盟寻路背景的A星算法及python实现
zaowuyingshu的博客
03-27 1729
文章目录前言一、什么是A星算法？二、算法流程三、python算法实现四、结果展示 前言 Astar算法是游戏中最常见的寻路算法，比如LOL的自动导航等。 一、什么是A星算法？ Astar算法是在实际生活和工业应用包括游戏设计等情景中所频繁被使用的一种路径规划算法。算法类似于贪婪最佳优先搜索，因为同样属于启发式算法，通过设定一个估价函数来实现。标准算法计算当前位置上相邻的每个节点，其方向可以是四面也可以是八面，并选择估价函数值成本最低的节点加入数组。添加到新数组的节点将用于搜索更多可行的路径。A*搜索算.
AStar算法
热门推荐
梦回唐朝
09-01 2万+
什么是AStar: 是一种静态路网中求解最短路最有效的直接搜索方法,估价值跟实例值非常接近; 启发式搜索 : 启发式搜索就是在状态空间中的搜索对每一个搜索的位置进行评估,得到最好的位置,在从这个位置进行搜索直到目标.这样可以省略大量无谓的搜索路径,提高了效率; 在启发式搜索中,对位置的估价是十分重要的.采用了不同的估价,可以有不同的效果; (估价函数就一种规则,制定的规则不同,...
AI自动寻路AStar算法【图示讲解原理】
Jacksqh的博客
04-09 5874
本文通过图示讲解了AI自动寻路算法中AStar算法的实现原理，读完相信对您会有所帮助
Astar算法机器人路径规划
03-15
Astar算法机器人路径规划 Ubuntu,在playerstage仿真。
改编的三维空间A*star算法matlab
08-24
刚开始研究路径规划，因为要研究三维的，所以将二维的A*算法简单改为三维，对自己是一个备份，写的不好，轻喷，可以相互交流
unityAStar寻路 A星 A*寻路算法Demo
04-25
基于Unity5.4.4版本，随机障碍物，动态实现寻路，UnityA星寻路完整Demo
A*算法的MATLAB仿真程序.rar
02-27
对传统的A*算法进行matlab仿真实验，位做改进，只为给读者提供最原始简介的实验环境，避免因为过度的改进造成不必要的理解误区。该实验程序可自由定义栅格地图大小，自由定义障碍物的摆放位置与数量，同时也可以生成...
unity简单实现AStar A*算法
09-18
Unity简单实现A*算法 一、功能概述 1.地图节点类 坐标值； 定义节点类型； 记录父节点； 计算F,G,H； 2.AStart类 寻路； 寻找路径点； openList； closeList； 建立链表关系； 按照F值排序；
AStar.zip_AStar_Astar算法 Python_A星_A星算法_A星算法 python
07-14
A星算法的实现与仿真，运行平台python3.6，可以自行更改设计学习
NO.71——用A-star算法求解8数码问题
ghl1390490928的博客
01-31 620
问题描述： 到 算法原理： A*的原理已经在上一篇博客讲解。https://blog.csdn.net/ghl1390490928/article/details/104121195 * 初始化open_set和close_set； * 将起点加入open_set中，并设置优先级为0（优先级最高）； * 如果open_set不为空，则从open_set中选取优先级最高...
A star算法
最新发布
chunchun2021的博客
08-11 3112
A star是一种启发式算法，用于在图像中或者网格中寻找从起点到终点的最短路径，以下是A star算法的流程。
a星算法求解5*5迷宫寻路python
04-26
接下来，它定义了一些函数，包括create_maze（用于生成迷宫），is_valid_node（用于检查节点是否合法），get_neighbors（用于获取相邻节点）和astar_search（用于运行A*算法）。 在astar_search函数中，程序使用了...

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

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值