7个寻路算法 Dijkstra.h

#ifndef __DIJKSTRA__H
#define __DIJKSTRA__H

#include "AIDefine.h"
#include <queue>

class Dijkstra
{
private:
#define MAXNUM 0x7FFFFFFF
public:
    Dijkstra()
    {
        m_nodeArr = NULL;
        m_able = false;
    }
    ~Dijkstra()
    {
        if(NULL != m_nodeArr)
        {
            delete[] m_nodeArr;
            m_nodeArr = NULL;
        }
    }
    static bool find(const PointI &size, const PointI &start, const PointI &end, AI_VisitFun visitFun, Path **path = NULL,
        EFindType findType = EFIND_TYPE8, AI_DitanceFun fun = AI_Ditance1)
    {
        Dijkstra dijkstra;
        if(dijkstra.init(size, end, visitFun, findType, fun))
        {
            return dijkstra.findPath(start, path);
        }
        if(NULL != path){*path = new Path(false, 0.0f);}
        return false;
    }
    bool init(const PointI &size, const PointI &end, AI_VisitFun visitFun, EFindType findType = EFIND_TYPE8, AI_DitanceFun fun = AI_Ditance1)
    {
        if(size.x <= 0 || size.y <= 0 || end.x < 0 || end.y < 0 || end.x >= size.x || end.y >= size.y)
        {
            m_able = false;
            return false;
        }
        m_able = true;
        m_size.x = size.x; m_size.y = size.y;
        m_end.x = end.x; m_end.y = end.y;
        if(NULL != m_nodeArr){delete m_nodeArr; m_nodeArr = NULL;}
        m_nodeArr = new Info[size.x * size.y];
        Info *cur, *next;
        PointI pos;
        int i;
        PriorityQueue<Info*, InfoCmp> visit;
        //std::priority_queue<Info*, std::vector<Info*>, InfoCmp> visit;
        for(i = 0; i < findType; ++i)
        {
            pos.x = end.x + AI_FindHelpPoint[i].x;pos.y = end.y + AI_FindHelpPoint[i].y;
            if(pos.x >= 0 && pos.x <size.x && pos.y >= 0 && pos.y < size.y && AI_CheckPass(end.x, end.y, pos.x, pos.y, visitFun))
            {
                cur = &m_nodeArr[pos.y * size.x + pos.x];
                cur->x = pos.x; cur->y = pos.y;
                cur->dis = fun(end.x, end.y, cur->x, cur->y);
                cur->path.x = end.x; cur->path.y = end.y; cur->hasPath = true;
                visit.push(cur);
            }
        }
        cur = &m_nodeArr[end.y * size.x + end.x];
        cur->dis = 0; cur->visited = true;
        cur->path.x = end.x; cur->path.y = end.y; cur->hasPath = true;
        cur->x = end.x; cur->y = end.y;

        float cost;
        while(!visit.empty())
        {
            cur = visit.top();visit.pop();
            cur->visited = true;
            for(i = 0; i < findType; ++i)
            {
                pos.x = cur->x + AI_FindHelpPoint[i].x;pos.y = cur->y + AI_FindHelpPoint[i].y;
                if(pos.x >= 0 && pos.x <size.x && pos.y >= 0 && pos.y < size.y)
                {
                    next = &m_nodeArr[pos.y * size.x + pos.x];
                    next->x = pos.x; next->y = pos.y;
                    cost = fun(cur->x, cur->y, next->x, next->y);
                    if(!next->visited && AI_CheckPass(cur->x, cur->y, next->x, next->y, visitFun) && cur->dis + cost < next->dis)
                    {
                        next->dis = cur->dis + cost;
                        next->path.x = cur->x; next->path.y = cur->y; next->hasPath = true;
                        visit.push(next);
                    }
                }
            }
        }
        return true;
    }
    bool getDis(const PointI &start, float &dis)
    {
        dis = 0;
        if(m_able)
        {
            if(start.x == m_end.x && start.y == m_end.y)
            {
                return true;
            }
            if(start.x < 0 || start.x >= m_size.x || start.y < 0 || start.y >= m_size.y)
            {
                return false;
            }
            dis = m_nodeArr[start.y * m_size.x + start.x].dis;
            return true;
        }
        return false;
    }
    bool findPath(const PointI &start, Path **path = NULL, bool isStart = true)
    {
        bool result = false;
        if(m_able)
        {
            Path *_path = new Path(true, 0.0f);
            if(start.x == m_end.x && start.y == m_end.y)
            {
                if(NULL != path){*path = _path;}else{delete _path;}
                return true;
            }
            Info *cur;
            _path->push_front(PointI(start.x, start.y));
            cur = &m_nodeArr[start.y * m_size.x + start.x];
            _path->setDis(cur->dis);
            while(cur->hasPath)
            {
                if(cur->path.x == m_end.x && cur->path.y == m_end.y)
                {
                    result = true;
                    break;
                }
                if(isStart){_path->push_back(PointI(cur->path.x, cur->path.y));}
                else{_path->push_front(PointI(cur->path.x, cur->path.y));}
                cur = &m_nodeArr[cur->path.y * m_size.x + cur->path.x];
            }
            if(!result){delete _path; _path = new Path(false, MAXNUM);}
            else
            {
                if(isStart){_path->push_back(PointI(m_end.x, m_end.y));}
                else{_path->push_front(PointI(m_end.x, m_end.y));}
            }
            if(NULL != path){*path = _path;}else{delete _path;}
        }
        return result;
    }
private:
    struct Info
    {
        Info():dis(MAXNUM),visited(false), hasPath(false){}
        int x, y;
        PointI path;
        float dis;
        bool visited;
        bool hasPath;
    };
    struct InfoCmp
    {
        bool operator () (const Info *p1, const Info *p2)
        {
            return p1->dis < p2->dis;
        }
    };
private:
    Info     *m_nodeArr;
    PointI    m_size;
    PointI    m_end;
    bool     m_able;
};

#endif