數據結構與算法——圖（游戲中的自動尋路-A*算法）

在復雜的 3D 游戲環境中如何能使非玩家控制角色准確實現自動尋路功能成為了 3D 游戲開 發技術中一大研究熱點。其中 A*算法得到了大量的運用，A*算法較之傳統的路徑規划算法,實時性更高、靈活性更強,尋路 結果更加接近人工選擇的路徑結果. A*尋路算法並不是找到最優路徑，只是找到相對近的路徑，因為找最優要把所有可行 路徑都找出來進行對比，消耗性能太大，尋路效果只要相對近路徑就行了。

 

 

1.A* 算法的原理（如顯示不全 刷新重試）

我們假設在推箱子游戲中人要從站里的地方移動到右側的箱子目的地，但是這兩點之間被一堵牆隔開。

 

我們下一步要做的便是查找最短路徑。既然是 AI 算法， A* 算法和人尋找路徑的做法十分類似，當我們離目標較遠時，我 們的目標方向是朝向目的點直線移動，但是在近距離上因為各種障礙需要繞行（走彎路）！而且已走過的地方就無須再次 嘗試。

為了簡化問題，我們把要搜尋的區域划分成了正方形的格子。這是尋路的第一步，簡化搜索區域，就像推箱子游戲一樣。 這樣就把我們的搜索區域簡化為了 2 維數組。數組的每一項代表一個格子，它的狀態就是可走 (walkalbe) 和不可走 (unwalkable) 。通過計算出從起點到終點需要走過哪些方格，就找到了路徑。一旦路徑找到了，人物便從一個方格的中心 移動到另一個方格的中心，直至到達目的地。

簡化搜索區域以后，如何定義小人當前走要走的格子離終點是近是遠呢？我們需要兩個指標來表示：

• G 表示從起點移動到網格上指定方格的移動距離 (暫時不考慮沿斜向移動，只考慮上下左右移動)。
• H 表示從指定的方格移動到終點的預計移動距離，只計算直線距離 (H 有很多計算方法, 這里我們設定只可以上 下左右移動，即該點與終點的直線距離)。

 

令 F = G + H ，F 即表示從起點經過此點預計到終點的總移動距離接下來我們從起點開始，按照以下尋路步驟，直至找到目標。

 

2.尋路步驟

1. 從起點開始, 把它作為待處理的方格存入一個預測可達的節點列表，簡稱 openList, 即把起點放入“預測可達節點列表”， 可達節點列表 openList 就是一個等待檢查方格的列表。

2. 尋找 openList 中 F 值最小的點 min（一開始只有起點）周圍可以到達的方格（可到達的意思是其不是障礙物，也不存 在關閉列表中的方格,即不是已走過的方格）。計算 min 周圍可到達的方格的 F 值。將還沒在 openList 中點放入其中, 並 設置它們的"父方格"為點 min,表示他們的上一步是經過 min 到達的。如果 min 下一步某個可到達的方格已經在 openList 列表那么並且經 min 點它的 F 值更優,則修改 F 值並把其"父方格"設為點 min。

3. 把 2 中的點 min 從"開啟列表"中刪除並存入"關閉列表"closeList 中, closeList 中存放的都是不需要再次檢查的方格。如 果 2 中點 min 不是終點並且開啟列表的數量大於零，那么繼續從第 2 步開始。如果是終點執行第 4 步，如果 openList 列 表數量為零，那么就是找不到有效路徑。

4.如果第 3 步中 min 是終點，則結束查找，直接追溯父節點到起點的路徑即為所選路徑

 

 具體尋路步步驟如下所示：

 

  

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

3.算法實現

Astar.h

#pragma once

#include <list>

const int kCost1 = 10; //直移一格消耗
const int kCost2 = 14; //斜移一格消耗

typedef struct _Point
{
    int x,y; //點坐標，這里為了方便按照 C++的數組來計算，x 代表橫排，y 代表豎列
    int F,G,H; //F=G+H
    struct _Point *parent; //parent 的坐標
}Point;

/*分配一個節點(格子)*/
Point* AllocPoint(int x, int y);

/*初始化地圖*/
void InitAstarMaze(int *_maze, int _lines, int _colums);

/*通過 A* 算法尋找路徑*/
std::list<Point *> GetPath(Point *startPoint, Point *endPoint);

/*清理資源，結束后必須調用*/
void ClearAstarMaze();

 

 

 Astar.cpp

#include <math.h>
#include "Astar.h"
#include <iostream>
#include <vector>

static int *maze;                        //迷宮對應的二維數組，使用一級指針表示
static int cols;                        //二維數組對應的列數
static int lines;                        //二維數組對應的行數
static std::list<Point *> openList;        //開放列表
static std::list<Point *> closeList;    //關閉列表

/*搜索從起點到終點的最佳路徑*/
static Point* findPath(Point *startPoint,Point *endPoint) ;
/*從開啟列表中返回 F 值最小的節點*/
static Point *getLeastFpoint();
/*獲取當前點周圍可達的節點*/
static std::vector<Point *> getSurroundPoints(const Point *point);
/*判斷某點是否可以用於下一步判斷 */
static bool isCanreach(const Point *point,const Point *target);
/*判斷開放/關閉列表中是否包含某點*/
static Point *isInList(const std::list<Point *> &list,const Point *point);
//計算 FGH 值
static int calcG(Point *temp_start,Point *point);
static int calcH(Point *point,Point *end);
static int calcF(Point *point);

/*分配一個節點(格子)*/
Point* AllocPoint(int x, int y)
{
    Point *temp = new Point;
    memset(temp, 0, sizeof(Point));        //初始值清零
    temp->x = x;
    temp->y = y;
    return temp;
}

/*初始化 A*搜索的地圖*/
void InitAstarMaze(int *_maze, int _lines, int _colums)
{
    maze = _maze;
    lines = _lines;
    cols = _colums;
}

/*通過 A* 算法尋找路徑*/
std::list<Point *> GetPath(Point *startPoint, Point *endPoint)
{
    Point *result=findPath(startPoint, endPoint);
    std::list<Point *> path;
    
    //返回路徑，如果沒找到路徑，返回空鏈表
    while(result)
    {
        path.push_front(result);
        result=result->parent;
    }
    return path;
}

/*搜索從起點到終點的最佳路徑*/
static Point* findPath(Point *startPoint,Point *endPoint)
{
    openList.push_back(AllocPoint(startPoint->x, startPoint->y));    //置入起點,拷貝開辟一個節點，內外隔離
    while(!openList.empty())
    {
        //第一步，從開放列表中取最小 F 的節點
        Point *curPoint = getLeastFpoint();            //找到 F 值最小的點
        
        //第二步，把當前節點放到關閉列表中
        openList.remove(curPoint);
        closeList.push_back(curPoint);
        
        //第三步，找到當前節點周圍可達的節點，並計算 F 值
        std::vector<Point *> surroundPoints = getSurroundPoints(curPoint);
        std::vector<Point *>::const_iterator iter;
        
        for(iter=surroundPoints.begin();iter!=surroundPoints.end();    iter++)
        {
            Point *target = *iter;
            
            //對某一個格子，如果它不在開放列表中，加入到開啟列表，設置當前格為其父節點，計算 F G H
            Point *exist = isInList(openList, target);
            if(!exist)
            {
                target->parent=curPoint;
                target->G=calcG(curPoint,target);
                target->H=calcH(target,endPoint);
                target->F=calcF(target);
                openList.push_back(target);
            }
            else
            {
                int tempG = calcG(curPoint, target);
                if(tempG<target->G)
                {
                    exist->parent = curPoint;
                    exist->G=tempG;
                    exist->F=calcF(target);
                }
                delete target;
            }
        }//end for
        
        surroundPoints.clear();
        Point *resPoint = isInList(openList, endPoint);
        if(resPoint)
        {
            return resPoint;
        }
    }
    return NULL;
}

/*從開啟列表中返回 F 值最小的節點*/
static Point *getLeastFpoint()
{
    if(!openList.empty())
    {
        Point *resPoint = openList.front();
        std::list<Point*>::const_iterator itor;
        
        for(itor = openList.begin(); itor!= openList.end(); itor++)
        {
            if((*itor)->F < resPoint->F)
            {
                resPoint = *itor;
            }
        }
        return resPoint;
    }
    return NULL;
}

/*獲取當前點周圍可達的節點*/
static std::vector<Point *> getSurroundPoints(const Point *point)
{
    std::vector<Point *> surroundPoints;
    for(int x=point->x-1; x<=point->x+1; x++)
    {
        for(int y=point->y-1; y<=point->y+1; y++)
        {
            Point *temp = AllocPoint(x, y);
            if(isCanreach(point, temp))
            {
                surroundPoints.push_back(temp);
            }
            else 
            {
                delete temp;
            }
        }
    }
    return surroundPoints;
}

/*判斷某點是否可以用於下一步判斷 */
static bool isCanreach(const Point *point,const Point *target)
{
    if(target->x<0||target->x>(lines-1)
    ||target->y<0||target->y>(cols-1)
    ||maze[target->x *cols + target->y]==1
    ||maze[target->x *cols + target->y]==2
    ||(target->x==point->x && target->y==point->y)
    ||isInList(closeList, target))
    {
        return false;
    }
    if(abs(point->x-target->x)+abs(point->y-target->y)==1)
    {
        return true;
    }
    else
    {
        return false;
    }
}
static Point* isInList(const std::list<Point *> &list,const Point *point)
{
    //判斷某個節點是否在列表中，這里不能比較指針，因為每次加入列表是新開辟的節點，只能比較坐標
    std::list<Point *>::const_iterator itor;
    for(itor = list.begin(); itor!=list.end();itor++)
    {
        if((*itor)->x==point->x&&(*itor)->y==point->y) 
        {
            return *itor;
        }
    }
    return NULL;
}

/*計算節點的 G 值*/
static int calcG(Point *temp_start, Point *point)
{
    int    extraG=(abs(point->x-temp_start->x)+abs(point->y-temp_start->y))==1?kCost1:kCost2;
    
    //如果是初始節點，則其父節點是空
    int parentG=(point->parent==NULL? NULL:point->parent->G);
    
    return parentG+extraG;
}

static int calcH(Point *point,Point *end)
{
    //用簡單的歐幾里得距離計算 H，可以用多中方式實現
    return (int)sqrt((double)(end->x-point->x)*
    (double)(end->x-point->x)+(double)(end->y-point->y)*
    (double)(end->y-point->y))*kCost1;
}

/*計算節點的 F 值*/
static int calcF(Point *point)
{
    return point->G+ point->H;
}

/*清理資源，結束后必須調用*/
void ClearAstarMaze()
{
    maze = NULL;
    lines = 0;
    cols = 0;
    std::list<Point *>::iterator itor;
    
    //清除 openList 中的元素
    for(itor = openList.begin(); itor!=openList.end();)
    {
        delete *itor;
        itor = openList.erase(itor);//獲取到下一個節點
    }
    
    //清理 closeList 中的元素
    for(itor = closeList.begin(); itor!=closeList.end();)
    {
        delete *itor;
        itor = closeList.erase(itor);
    }
}

 

 

 main.cpp

#include "Astar.h"
#include <list>
#include <iostream>
#include <windows.h>

using namespace std;

//定義地圖數組,二維數組在內存順序存儲的
int map[13][13] = {
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
{ 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, },
{ 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, },
{ 0, 1, 0, 1, 0, 1, 2, 1, 0, 1, 0, 1, 0, },
{ 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, },
{ 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, },
{ 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, },
{ 2, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 2, },
{ 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, },
{ 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, },
{ 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, },
{ 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }
};

void AStarTest()
{
    InitAstarMaze(&map[0][0], 13, 13);
    
    //設置起始和結束點
    Point* start = AllocPoint(12, 4);
    Point* end = AllocPoint(0, 0);
    
    //A*算法找尋路徑
    list<Point *> path = GetPath(start, end);
    cout<<"尋路結果:"<<endl;
    list<Point *>::const_iterator iter;
    
    for(iter=path.begin(); iter!=path.end(); iter++)
    {
        Point *cur = *iter;
        cout<<'('<<cur->x<<','<<cur->y<<')'<<endl;
        Sleep(800);
    }
    
    ClearAstarMaze();
}

int main(void)
{
    AStarTest();
    system("pause");
    return 0;
}

 

 

 

 

 

 

 

============================================================================================================