C++游戏地图移动路径实现

最新推荐文章于 2024-10-15 19:21:47 发布

原创最新推荐文章于 2024-10-15 19:21:47 发布 · 656 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #游戏 #java

本文介绍了一个用于游戏或地图应用中的路径查找模块实现细节。该模块提供了丰富的接口来处理地图数据，包括读取文件、获取路径点信息、添加或删除路径点、寻找路径等功能。通过对这些功能的具体实现和使用说明，读者可以了解到如何高效地管理和利用地图数据。

#include "FindPath.h"

static FindPath g_FindPath;

POpenFile *g_pOPenFile = NULL;
PCloseFile *g_pCloseFile = NULL;
PReadFile *g_pReadFile = NULL;
PGetFileSize *g_pGetFileSize = NULL;

FILE * g_OpenFile(const char *psFileName,const char *psMode);
bool g_CloseFile(FILE *pFile);
size_t g_ReadFile(FILE *fp, void *buffer,size_t size);
size_t g_GetFileSize(const char *psFileName);

Log_System g_log;

extern bool GetScenePathInfo(const char * inifilename, const char * scene_res, std::string & pathfile, std::string & tgafile, SceneRect & rect);
extern bool SceneFindPath(const char * inifilename, const char * begin_sceneid,float sx,float sz,float sy, const char * end_sceneid,float dx,float dz,float dy,std::vector<SCENEPATHITEM> &pathsecene);

FILE * g_OpenFile(const char *psFileName,const char *psMode)
{
   if (g_pOPenFile == NULL)
   {
       return fopen(psFileName,psMode);
   }
   else
   {
       return (FILE *)(*g_pOPenFile)(psFileName,psMode);
   }
}

bool g_CloseFile(FILE *pFile)
{
   if (g_pCloseFile == NULL)
   {
       return fclose(pFile) == 0;
   }
   else
   {
       return (*g_pCloseFile)(pFile);
   }
}

size_t g_ReadFile(FILE *fp, void *buffer,size_t size)
{
   if (g_pReadFile == NULL)
   {
       return (int)fread(buffer, 1, size, fp);
   }
   else
   {
       return (*g_pReadFile)(fp, buffer,size);
   }
}

size_t g_GetFileSize(const char *psFileName)
{
   if (g_pGetFileSize == NULL)
   {
       FILE * fp = fopen(psFileName, "rb");
       ::fseek(fp, 0, SEEK_END);
       long size = ::ftell(fp);
       ::fseek(fp, 0, SEEK_SET);
       ::fclose(fp);

       return size;
   }
   else
   {
       return (*g_pGetFileSize)(psFileName);
   }
}

FindPath::FindPath()
{
g_log.OpenLog();
}

FindPath::~FindPath()
{
ReleaseAllPath();
}

bool FindPath::SetFileFunc(const char *FunName,void *FunPointer)
{
   if (strcmp(FunName,"OpenFile") == 0)
   {
       g_pOPenFile = (POpenFile*)FunPointer;
       return true;
   }
   if (strcmp(FunName,"CloseFile") == 0)
   {
       g_pCloseFile = (PCloseFile*)FunPointer;
       return true;
   }
   if (strcmp(FunName,"ReadFile") == 0)
   {
       g_pReadFile = (PReadFile*)FunPointer;
       return true;
   }
   if (strcmp(FunName,"GetFileSize") == 0)
   {
       g_pGetFileSize = (PGetFileSize*)FunPointer;
       return true;
   }
   return false;
}

void FindPath::InitFindPath(const char * path)
{
   m_strPath = path;
   m_IniFileName = path;
   m_IniFileName += "path_finding.ini";
}

//获得指定场景的路点总数
int FindPath::GetPathPointCount(const char * scene_res)
{
   std::map<std::string, CSceneMap*>::iterator it = m_mapSceneMaps.find(scene_res);
   if (it == m_mapSceneMaps.end())
       return 0;

   CSceneMap * pSceneMap = it->second;
   if(pSceneMap == NULL)
       return 0;

return pSceneMap->GetPathPointCount();
}

//获得指定场景的指定区域的路点索引列表
int FindPath::GetPathPointInZone(const char * scene_res, float x, float z, float radius, int point_lst[], int max_count)
{
   std::map<std::string, CSceneMap*>::iterator it = m_mapSceneMaps.find(scene_res);
   if (it == m_mapSceneMaps.end())
       return false;

   CSceneMap * pSceneMap = it->second;
   if(pSceneMap == NULL)
       return false;

return pSceneMap->GetPathPointInZone(x, z, radius, point_lst, max_count);
}

//获得指定场景的指定路点的信息
PATHPOINT * FindPath::GetPathPointInfo(const char * scene_res, int index)
{
   std::map<std::string, CSceneMap*>::iterator it = m_mapSceneMaps.find(scene_res);
   if (it == m_mapSceneMaps.end())
       return NULL;

   CSceneMap * pSceneMap = it->second;
   if(pSceneMap == NULL)
       return NULL;

return pSceneMap->GetPathPointInfo(index);
}

//添加路点
int FindPath::AddPathPoint(const char * scene_res, float x, float y, float z)
{
   std::map<std::string, CSceneMap*>::iterator it = m_mapSceneMaps.find(scene_res);
   if (it == m_mapSceneMaps.end())
       return -1;

   CSceneMap * pSceneMap = it->second;
   if(pSceneMap == NULL)
       return -1;

return pSceneMap->AddPathPoint(x, y, z);
}

//修改路点位置
bool FindPath::SetPathPointPos(const char * scene_res, int index, float x, float y, float z)
{
   std::map<std::string, CSceneMap*>::iterator it = m_mapSceneMaps.find(scene_res);
   if (it == m_mapSceneMaps.end())
       return -1;

   CSceneMap * pSceneMap = it->second;
   if(pSceneMap == NULL)
       return -1;

return pSceneMap->SetPathPointPos(index, x, y, z);
}

//删除路点
void FindPath::RemovePathPoint(const char * scene_res, int index)
{
   std::map<std::string, CSceneMap*>::iterator it = m_mapSceneMaps.find(scene_res);
   if (it == m_mapSceneMaps.end())
       return;

   CSceneMap * pSceneMap = it->second;
   if(pSceneMap == NULL)
       return;

pSceneMap->RemovePathPoint(index);
}

//添加连通关系
bool FindPath::AddLink(const char * scene_res, int index, int link_index)
{
   std::map<std::string, CSceneMap*>::iterator it = m_mapSceneMaps.find(scene_res);
   if (it == m_mapSceneMaps.end())
       return false;

   CSceneMap * pSceneMap = it->second;
   if(pSceneMap == NULL)
       return false;

return pSceneMap->AddLink(index, link_index);
}

//删除连通关系
void FindPath::RemoveLink(const char * scene_res, int index, int link_index)
{
   std::map<std::string, CSceneMap*>::iterator it = m_mapSceneMaps.find(scene_res);
   if (it == m_mapSceneMaps.end())
       return;

   CSceneMap * pSceneMap = it->second;
   if(pSceneMap == NULL)
       return;

pSceneMap->RemoveLink(index, link_index);
}

//数据是否已加载
bool FindPath::IsLoaded(const char * scene_res)
{
   std::map<std::string, CSceneMap*>::iterator it = m_mapSceneMaps.find(scene_res);
   if (it == m_mapSceneMaps.end())
       return false;

return true;
}

bool FindPath::NewPath(const char * scene_res, ISceneMapProcess * pSceneMapProcess)
{
   if (IsLoaded(scene_res))
   {
       //数据已加载
       return false;
   }

CSceneMap * pSceneMap = new CSceneMap(scene_res, pSceneMapProcess);
m_mapSceneMaps.insert(std::make_pair(scene_res, pSceneMap));

return true;
}

bool FindPath::LoadPath(const char * scene_res, ISceneMapProcess * pSceneMapProcess)
{
g_log.wirtetime();

   if (IsLoaded(scene_res))
   {
       //数据已加载
       return false;
   }

   //加载地图
   CSceneMap * pSceneMap = new CSceneMap(scene_res, pSceneMapProcess);
   std::string full_path = m_strPath + scene_res + ".path";

   if(!pSceneMap->LoadPath(full_path.c_str()))
   {
       delete pSceneMap;
       return false;
   }

m_mapSceneMaps.insert(std::make_pair(scene_res, pSceneMap));
return true;
}

bool FindPath::SavePath(const char * scene_res)
{
   std::map<std::string, CSceneMap*>::iterator it = m_mapSceneMaps.find(scene_res);
   if (it == m_mapSceneMaps.end())
       return false;

   CSceneMap * pSceneMap = it->second;
   if(pSceneMap == NULL)
       return false;

std::string full_path = m_strPath + scene_res + ".path";
return pSceneMap->SavePath(full_path.c_str());
}

void FindPath::ReleasePath(const char * scene_res)
{
   std::map<std::string, CSceneMap*>::iterator it = m_mapSceneMaps.find(scene_res);
   if (it == m_mapSceneMaps.end())
       //数据未加载
       return;

   CSceneMap * pSceneMap = it->second;
   if(pSceneMap != NULL)
       AW_SAFE_DELETE(pSceneMap);

m_mapSceneMaps.erase(it);

g_log.wirtetime();
}

void FindPath::ReleaseAllPath()
{
   std::map<std::string, CSceneMap*>::iterator it = m_mapSceneMaps.begin();
   for (; it != m_mapSceneMaps.end(); ++it)
       AW_SAFE_DELETE (it->second );

m_mapSceneMaps.clear();
}

int FindPath::PointFindPath(const char * scene_res, float xBegin, float zBegin, float yBegin,
                                   float xEnd, float zEnd, float yEnd,
                                   float x[], float y[], int maxcount, bool optimize)
{
   if (maxcount < 2)
       return 0;

   std::map<std::string, CSceneMap*>::iterator it = m_mapSceneMaps.find(scene_res);
   if (it == m_mapSceneMaps.end())
       return 0;

   CSceneMap * pSceneMap = it->second;
   if(pSceneMap == NULL)
       return 0;

   if (((xBegin - xEnd) * (xBegin - xEnd) + (zBegin - zEnd) * (zBegin - zEnd)) <= DIST_VALVA*DIST_VALVA)
   {
       if(pSceneMap->TryLine(xBegin, yBegin, zBegin,xEnd, yEnd, zEnd))
       {
           //如果两点距离比较近并且中间没有被阻挡，则直接走向目标点
           x[0] = xBegin;
           y[0] = zBegin;
           x[1] = xEnd;
           y[1] = zEnd;
           return 2;
       }
   }

//创建地图信息
CPathUser pathUser(pSceneMap);

   //开始寻路
   if (!pathUser.FindPath(xBegin, yBegin, zBegin,xEnd, yEnd, zEnd))
       return 0;

   int count = pathUser.GetPathPointCount();
   if (count > maxcount)
       count = maxcount;

   //把点写入用户的容器里
   if (!optimize)
   {
       //不优化处理
       for (int i = 0 ; i < count; i++)
       {
           float xtemp, ytemp, ztemp;
           pathUser.GetPathPoint(i, xtemp, ytemp, ztemp);
           x[i] = xtemp;
           y[i] = ztemp;
       }
   }
   else
   {
       //优化处理
       //当前处理的点
       int cur_proc_index = -1;
       //当前压入的点
       int last_push_index = -1;

       while(true)
       {
           cur_proc_index++;
           if (cur_proc_index >= count)
               break;

           //取当前正在处理的点的坐标
           float xtemp, ytemp, ztemp;
           pathUser.GetPathPoint(cur_proc_index, xtemp, ytemp, ztemp);

//是否可以丢弃最后一个被压入的点
bool b_canreplace = false;

           if (last_push_index > 0)
           {
               //取上一个点
               float xtemp1 = x[last_push_index - 1];
               float ytemp1 = ytemp;
               float ztemp1 = y[last_push_index - 1];

               //与当前正在处理的点是否直接连通
               if (TryLine(scene_res, xtemp1, ytemp1, ztemp1, xtemp, ytemp, ztemp))
                   b_canreplace = true;
           }

           if (!b_canreplace)
               //最后一个被压入的点不可以丢弃，添加到新的位置
               last_push_index++;

           x[last_push_index] = xtemp;
           y[last_push_index] = ztemp;
       }

       //有效的路点数量
       count = last_push_index + 1;
   }

return count;
}

int FindPath::SceneFindPath(const char * begin_scene_res, float xBegin, float zBegin, float yBegin,
                           const char * end_scene_res, float xEnd, float zEnd, float yEnd,
                           SCENEPATHITEM scenepath[], int maxcount)
{
   if (maxcount < 2)
       return 0;

   std::vector<SCENEPATHITEM> pathsecene;
   if(!::SceneFindPath(m_IniFileName.c_str(), begin_scene_res,xBegin,zBegin,yBegin,end_scene_res,xEnd,zEnd,yEnd,pathsecene))
       return 0;

   if (pathsecene.size() == 0)
   {
       scenepath[0].sceneid = begin_scene_res;
       scenepath[0].xBegin = xBegin;
       scenepath[0].yBegin = zBegin;
       scenepath[0].xEnd = xEnd;
       scenepath[0].yEnd = zEnd;
       return (int)pathsecene.size() + 1;
   }

   //将路点存为输出模式（场景号，起始点，结束点）
   int count = (int)pathsecene.size();
   if (count > maxcount - 1)
       count = maxcount - 1;

   for (int i = 0 ; i <= count ; i++)
   {
       if (i == 0)
       {
           scenepath[i].sceneid = begin_scene_res;
           scenepath[i].xBegin = xBegin;
           scenepath[i].yBegin = zBegin;
           scenepath[i].xEnd = pathsecene[i].xBegin;
           scenepath[i].yEnd = pathsecene[i].yBegin;
           continue;
       }
       if (i == pathsecene.size())
       {
           scenepath[i].sceneid = end_scene_res;
           scenepath[i].xBegin = pathsecene[i - 1].xEnd;
           scenepath[i].yBegin = pathsecene[i - 1].yEnd;
           scenepath[i].xEnd = xEnd;
           scenepath[i].yEnd = zEnd;
           break;
       }
       scenepath[i].sceneid = pathsecene[i - 1].sceneid;
       scenepath[i].xBegin = pathsecene[i - 1].xEnd;
       scenepath[i].yBegin = pathsecene[i - 1].yEnd;
       scenepath[i].xEnd = pathsecene[i].xBegin;
       scenepath[i].yEnd = pathsecene[i].yBegin;
   }

return count + 1;
}

bool FindPath::TryPoint(const char * scene_res, float x, float y, float z)
{
   std::map<std::string, CSceneMap*>::iterator it = m_mapSceneMaps.find(scene_res);
   if (it == m_mapSceneMaps.end())
       return false;

   CSceneMap * pSceneMap = it->second;
   if (pSceneMap == NULL)
       return false;

return pSceneMap->TryPoint(x, y, z);
}

bool FindPath::TryLine(const char * scene_res, float xb, float yb, float zb, float xe, float ye, float ze)
{
   std::map<std::string, CSceneMap*>::iterator it = m_mapSceneMaps.find(scene_res);
   if (it == m_mapSceneMaps.end())
       return false;

   CSceneMap *pSceneMap = it->second;
   if (pSceneMap == NULL)
       return false;

return pSceneMap->TryLine(xb, yb, zb, xe, ye, ze);
}

CSceneMap* FindPath::FindSceneMap(const char * scene_res)
{
   std::map<std::string, CSceneMap*>::iterator it = m_mapSceneMaps.find(scene_res);
   if (it == m_mapSceneMaps.end())
       return NULL;

return (*it).second;
}

IFindPath* IFindPath::GetPointer()
{
return &g_FindPath;
};