7个寻路算法 Floyd.h

#ifndef __FLOYD__H
#define __FLOYD__H

#include "AIDefine.h"

class Floyd
{
private:
#define MAXNUM 0x7FFFFFFF
public:
    Floyd()
    {
        m_nodeArr = NULL;
        m_path = NULL;
        m_able = false;
    }
    ~Floyd()
    {
        if(NULL != m_nodeArr){delete[] m_nodeArr; m_nodeArr = NULL;}
        if(NULL != m_path){delete[] m_path; m_path = NULL;}
    }
public:
    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)
    {
        Floyd floyd;
        if(floyd.init(size, visitFun, findType, fun))
        {
            return floyd.findPath(start, end, path);
        }
        if(NULL != path){*path = new Path(false, 0.0f);}
        return false;
    }
    bool init(const PointI &size, AI_VisitFun visitFun, EFindType findType = EFIND_TYPE8, AI_DitanceFun fun = AI_Ditance1)
    {
        if(NULL != m_nodeArr){delete[] m_nodeArr; m_nodeArr = NULL;}
        if(NULL != m_path){delete[] m_path; m_path = NULL;}
        if(size.x <= 0 || size.y <= 0)
        {
            m_able = false;
            return false;
        }
        m_able = true;
        m_size.x = size.x; m_size.y = size.y;
        int count = size.x * size.y;
        m_nodeArr = new Info[count * count];
        m_path = new int[count * count];
        bool *visitArr = new bool[count];

        int i, j, k, index1, index2, index3;
        PointI pos;
        for(i = 0; i < size.y; ++i)
        {
            for(j = 0; j < size.x; ++j)
            {
                index1 = i * size.x + j;
                visitArr[index1] = visitFun(j, i);
                if(visitArr[index1])
                {
                    for(k = 0; k < findType; ++k)
                    {
                        pos.x = j + AI_FindHelpPoint[k].x;pos.y = i + AI_FindHelpPoint[k].y;
                        index2 = pos.y * size.x + pos.x;
                        if(AI_CheckRange(pos,size) && AI_CheckPass(j, i, pos.x, pos.y, visitFun))
                        {
                            index3 = index1 * count + index2;
                            m_nodeArr[index3].dis = fun(j,i,pos.x,pos.y);
                            m_nodeArr[index3].assign = true;
                            m_path[index3] = index2;

                            index3 = index2 * count + index1;
                            m_nodeArr[index3].dis = fun(j,i,pos.x,pos.y);
                            m_nodeArr[index3].assign = true;
                            m_path[index3] = index1;
                        }
                    }
                    index3 = index1 * count + index1;
                    m_nodeArr[index3].dis = 0;
                    m_nodeArr[index3].assign = true;
                    m_path[index3] = index1;
                }
            }
        }
        for(k = 0; k < count; ++k)
        {
            if(!visitArr[k]){continue;}
            for(i = 0; i < count; ++i)
            {
                if(!visitArr[i] || i == k){continue;}
                for(j = 0; j < i; ++j)
                {
                    if(!visitArr[j] || i == j || j == k){continue;}

                    if(m_nodeArr[i * count + k].assign && m_nodeArr[k * count + j].assign &&
                        m_nodeArr[i * count + j].dis > m_nodeArr[i * count + k].dis + m_nodeArr[k * count + j].dis)
                    {
                        m_nodeArr[i * count + j].dis = m_nodeArr[i * count + k].dis + m_nodeArr[k * count + j].dis;
                        m_nodeArr[i * count + j].assign = true;
                        m_path[i * count + j] = m_path[i * count + k];


                        m_nodeArr[j * count + i].dis = m_nodeArr[i * count + j].dis;
                        m_nodeArr[j * count + i].assign = true;
                        m_path[j * count + i] = m_path[j * count + k];
                    }
                }
            }
        }
        delete[] visitArr;
        return true;
    }
    bool findPath(const PointI &start, const PointI &end, Path **path = NULL)
    {
        if(!m_able)
        {
            if(NULL != path){*path = new Path(false, 0.0f);}
            return false;
        }
        bool result = false;
        if(start.x < 0 || start.y < 0 || start.x >= m_size.x || start.y >= m_size.y || 
            end.x < 0 || end.y < 0 || end.x >= m_size.x || end.y >= m_size.y ||
            (start.x == end.x && start.y == end.y))
        {
            if(NULL != path){*path = new Path(false, 0.0f);}
            return false;
        }else
        {
            int index1, index2, index3;
            int count = m_size.x * m_size.y;
            index1 = start.y * m_size.x + start.x;
            index2 = end.y * m_size.x + end.x;
            index3 = index1 * count + index2;
            Path *_path = new Path(true, 0.0f);
            if(m_nodeArr[index3].assign)
            {
                result = true;
                _path->setDis(m_nodeArr[index3].dis);
                _path->push_back(PointI(start.x, start.y));
                int i, j;
                int cur = m_path[index3];
                while(true)
                {
                    i = (int)(cur / m_size.x);
                    j = cur % m_size.x;
                    _path->push_back(PointI(j, i));
                    if(i == end.y && j == end.x){break;}
                    cur = m_path[cur * count + index2];
                }
            }
            if(!result){delete _path; _path = new Path(false, 0.0f);}
            if(NULL != path){*path = _path;}
        }
        return result;
    }
private:
    struct Info
    {
        Info():dis(MAXNUM),assign(false){}
        float dis;
        bool assign;
    };
private:
    Info    *m_nodeArr;
    int     *m_path;
    PointI   m_size;
    bool    m_able;
};

#endif