深刻理解遊戲中尋路算法

時間  2019-11-13
標籤 深刻 理解 遊戲 算法 欄目 遊戲 简体版
原文   原文鏈接

若是你玩過MMOARPG遊戲，好比魔獸，你會發現人物行走會頗有趣，爲了模仿人物行走的真實體驗，他們會選擇最近路線達到目的地，期間會避開高山或者湖水，繞過箱子或者樹林，直到走到你所選定的目的地。javascript

這種看似尋常的尋路在程序實現起來就須要必定的尋路算法來解決，如何在最短期內找到一條路徑最短的路線，這是尋路算法首先要考慮的問題。php

在這篇文章中咱們會按部就班來說解尋路算法是如何演進的，你會看到一種算法從簡單到高效所遇到的問題，以及精進的過程，帶着問題來閱讀，理解更快。html

本篇主要包含如下內容:java

一、圖，算法

二、寬度最優搜索,數據結構

三、Dijkstra 算法，測試

四、貪心算法，google

五、A*搜索算法,spa

六、B*搜索算法,code

 

一、遊戲中的人物是如何尋路的

你所看到的人物行走方式:

開發人員實際所看到的方式:

或者是這種:

對於一張地圖，開發人員須要經過必定的方案將其轉換爲數據對象，常見的就是以上這種把地圖切個成網格，固然了地圖的劃分方式不必定非要用網格這種方式，採用多邊形方式也能夠，這取決於你的遊戲，通常狀況下，同等面積的地圖採用更少的頂點，尋路算法會更快。尋路中經常使用的數據結構就是圖，如下咱們先來了解一下。

 二、圖

在講尋路算法以前咱們先了解一種數據結構—圖，數據結構是咱們進行算法運算的基礎，好的數據結構除了方便咱們理解算法，還會提高算法的效率。網格某種意義上也是圖的演變，只是圖形變了而已,理解了圖的概念能夠幫助咱們更好理解尋路算法。

圖的基本定義:

圖的正式表達式是G=(V,E),V是表明頂點的集合，E和V是一種二元關係，能夠理解爲邊，好比有條邊從頂點U到頂點V結束,那麼E能夠用(u,v)來表示這條邊。具體的有向圖和無向圖，也是邊是否有方向來區分。爲了方便理解，咱們文中全部的數據演示都是基於網格地圖來進行講解，如下是幾種關係梳理，以A爲頂點，BCDE爲子頂點,咱們能夠把每一個格子也看是一個頂點。

三、搜索算法

對一個圖進行搜索意味着按照某種特定的順序依次訪問其頂點。對於多圖算法來講，廣度優先算法和深度優先搜索算法都十分重要，由於它們提供了一套系統地訪問圖數據結構的方法。咱們着重講解廣度優先搜索算法。

深度優先搜索

深度優先算法和最小路徑關係不大，咱們只簡單介紹。

深度優先搜索算法（簡稱DFS）是一種用於遍歷或搜索樹或圖的算法。沿着樹的深度遍歷樹的節點，儘量深的搜索樹的分支。當節點v的所在邊都己被探尋過，搜索將回溯到發現節點v的那條邊的起始節點。這一過程一直進行到已發現從源節點可達的全部節點爲止。

 

廣度優先搜索

廣度優先搜索算法（簡稱BFS）又稱爲寬度優先搜索，是一種圖形搜索算法，很適合用來探討最短路徑的第一個模型，咱們會順着這個思路往下講。

BFS是一種盲目搜尋法，目的是系統地展開並檢查圖中的全部節點，以找尋結果。換句話說，它並不考慮結果的可能位址，完全地搜索整張圖，直到找到結果爲止它的步驟以下:

- 首先將根節點放入隊列中。

- 從隊列中取出第一個節點，並檢驗它是否爲目標。

- 若是找到目標，則結束搜尋並回傳結果。

- 不然將它全部還沒有檢驗過的直接子節點（鄰節點）加入隊列中。

- 若隊列爲空，表示整張圖都檢查過了——亦即圖中沒有欲搜尋的目標。結束搜尋並回傳「找不到目標」。

網格:

咱們看下代碼(js)：

var frontier = new Array();

frontier.put(start);

var visited = new Array();

visited[start] = true;



while(frontier.length>0){

    current = frontier.get();

     //查找周圍頂點

    for(next in graph.neighbors(current)){

        var notInVisited = visited.indexOf(next)==-1;

        //沒有訪問過

        if(notInVisited) {

            frontier.put(next);

            visited[next] = true;

          }

       }
}

從上能夠發現，寬度搜索就是以開始頂點爲起點，訪問其子節點（在網格中是訪問周圍節點），而後不斷的循環這個過程，直到找到目標，這種算法比較符合常規邏輯，把全部的的頂點所有枚舉一遍。不過這種方式也有很明顯的缺點。

缺陷:

一、效率底下， 時間複雜度是:T(n) = O(n^2)

二、每一個頂點之間沒有權值，沒法定義優先級，不能找到最優路線。好比遇到水域須要繞過行走，在寬度算法裏面沒法涉及。

如何解決這個問題？咱們來看Dijkstra 算法。

四、Dijkstra 算法

寬度優先搜索算法，解決了起始頂點到目標頂點路徑規劃問題，但不是最優以及合適的，由於它的邊沒有權值（好比距離），路徑沒法進行估算比較最優解。爲什麼權值這麼重要，由於真實環境中，2個頂點之間的路線並不是一直都是直線，須要繞過障礙物才能達到目的地，好比森林，湖水，高山，都須要繞過而行，並不是直接穿過。

好比我採用寬度優先算法，遇到以下狀況，他會直接穿過障礙物（綠色部分 ），明顯這個不是咱們想要的結果:

 

解決痛點:

尋找圖中一個頂點到另外一個頂點的最短以及最小帶權路徑是很是重要的提煉過程。爲每一個頂點之間的邊增長一個權值，用來跟蹤所選路徑的消耗成本，若是位置的新路徑比先前的最佳路徑更好，咱們將添加它，規劃到新的路線中。

Dijkstra 算法基於寬度優先算法進行改進，把當前看起來最短的邊加入最短路徑樹中 ，利用貪心算法計算並最終可以產生最優結果的算法。具體步驟以下:

一、每一個頂點都包含一個預估值cost(起點到當前頂點的距離)，每條邊都有權值v ，初始時，只有起始頂點的預估值cost爲0，其餘頂點的預估值d都爲無窮大 ∞。

二、查找cost值最小的頂點A，放入path隊列

三、循環A的直接子頂點，獲取子頂點當前cost值命名爲current_cost，並計算新路徑new_cost，new_cost=父節點A的cost+v(父節點到當前節點的邊權值),若是new_cost<current_cost,當前頂點的cost=new_cost

四、重複2，3直至沒有頂點能夠訪問.

咱們看下圖例:

咱們看下代碼(js)：

var frontier = new PriorityQueue();

frontier.put(start);

path = new Array();

//每一個頂點路徑消耗

cost_so_far = new Array();



path[start] = 0;

cost_so_far[start] = 0



while(frontier.length>0){

   current = frontier.get();


   if current == goal:

      break

       //查找周圍節點

    for(next in graph.neighbors(current)){

        var notInVisited = visited.indexOf(next)==-1;

        var new_cost = cost_so_far[current] + graph.cost(current, next);

           //沒有訪問過或者路徑更近

        if(notInVisited ||  new_cost < cost_so_far[next]) {

            cost_so_far[next] = new_cost;

            priority = new_cost;

            frontier.put(next, priority);

            path[next] = current;

          }

       }

}

 

咱們看到雖然Dijkstra 算法 雖然相對於寬度優先搜索更加智能，基於cost_so_far ，能夠規避路線比較長或者沒法行走的區域，但依然會存在盲目搜索的傾向，咱們在地圖中常見的狀況是查找目標和起始點的路徑，具備必定的方向性，而Dijkstra 算法從上述的圖中能夠看到，也是基於起點向子節點全方位擴散。

缺點:

一、運行時間複雜度是:T(n) = O(V^2)，其中V爲頂點個數。效率上並不高

二、目標查找不具備方向性

如何解決讓搜索不是全盤盲目瞎找？咱們來看Greedy Best First Search算法（貪婪最佳優先搜索）。  

五、貪婪最佳優先搜索

在Dijkstra算法中，我已經發現了其最終要的缺陷，搜索存在盲目性。在這裏，咱們只針對這個痛點，採用貪婪最佳優先搜索來解決。如何解決？咱們只需稍微改變下觀念便可，在Dijkstra算法中，優先隊列採用的是，每一個頂點到起始頂點的預估值來進行排序。在貪婪最佳優先搜索中 ，

解決痛點:

咱們採用每一個頂點到目標頂點的距離進行排序。一個採用離起始頂點的距離來排序，一個採用離目標頂點距離排序（離目標的遠近排序）

哪一個更快？咱們看下圖(左邊寬度優先，右邊貪婪優先):

從上圖中咱們能夠明顯看到右邊的算法（貪婪最佳優先搜索 ）尋找速度要快於左側，雖然它的路徑不是最優和最短的，但障礙物最少的時候，他的速度卻足夠的快。這就是貪心算法的優點，基於目標去搜索，而不是徹底搜索。

 

咱們看下算法(js)：

frontier = new PriorityQueue();

frontier.put(start, 0)

came_from = new Array();

came_from[start] = 0;



while(frontier.length>0){

    current = frontier.get()



   if current == goal:

      break



       for(next in graph.neighbors(current)){

           var notInVisited = visited.indexOf(next)==-1;

           //沒有訪問過

        if(notInVisited ) {

            //離目標的距離 ，距離越近優先級越高

             priority = heuristic(goal, next);

             frontier.put(next, priority);

             came_from[next] = current;

          }

       }

}



function heuristic(a, b){

    //離目標的距離

   return abs(a.x - b.x) + abs(a.y - b.y)

}

 

缺點:

1.路徑不是最短路徑，只能是較優

如何在搜索儘可能少的頂點同時保證最短路徑？咱們來看A*算法。

 六、A*算法

從上面算法的演進，咱們逐漸找到了最短路徑和搜索頂點最少數量的兩種方案，Dijkstra 算法和 貪婪最佳優先搜索。那麼咱們有沒有可能汲取兩種算法的優點，令尋路搜索算法即使快速又高效？

答案是能夠的，A*算法正是這麼作了，它吸收了Dijkstra 算法中的cost_so_far，爲每一個邊長設置權值，不停的計算每一個頂點到起始頂點的距離，以得到最短路線，同時也汲取貪婪最佳優先搜索算法中不斷向目標前進優點，並持續計算每一個頂點到目標頂點的距離，以引導搜索隊列不斷想目標逼近，從而搜索更少的頂點，保持尋路的高效。

解決痛點:

A*算法的優先隊列排序方式基於F值:

F=cost(頂點到起始頂點的距離 )+heuristic(頂點到目標頂點的距離 )

 

咱們看下算法(js)：

var frontier = new PriorityQueue();

frontier.put(start);

path = new Array();

cost_so_far = new Array();

path[start] = 0;

cost_so_far[start] = 0



while(frontier.length>0){

    current = frontier.get()



   if current == goal:

      break



       for(next in graph.neighbors(current)){

           var notInVisited = visited.indexOf(next)==-1;

           var new_cost = cost_so_far[current] + graph.cost(current, next);

           //沒有訪問過並且路徑更近

        if(notInVisited ||  new_cost < cost_so_far[next]) {

              cost_so_far[next] = new_cost

              //隊列優先級= new_cost(頂點到起始頂點的距離 )+heuristic(頂點到目標頂點的距離 )

            priority = new_cost + heuristic(goal, next)

            frontier.put(next, priority)

            path[next] = current

          }

       }

}



function heuristic(a, b){

    //離目標的距離

   return abs(a.x - b.x) + abs(a.y - b.y)

}

 

如下分別是Dijkstra算法，貪心算法，以及A*算法的尋路雷達圖，其中格子有數字標識已經被搜索了，能夠對比下三種效率:

 七、B*算法

B*算法是一種比A*算法更高效的算法， 適用於遊戲中怪物的自動尋路，其效率遠遠超過A*算法，通過測試，效率是普通A*算法的幾十上百倍。B*算法不想介紹了，本身去google下吧，

 

經過以上算法不斷的演進，咱們能夠看出每一種算法的侷限，以及延伸出的新算法中出現的解決方式，但願方便你的理解。

 

說明:

文章多出突破引用一下文章，代碼也是。原文寫的很棒，有興趣，能夠移步原文查看，或者google搜索:A*algorithm

引用文章:http://www.redblobgames.com/pathfinding/a-star/introduction.html

----------------------------------------end-----------------------------------

關注我的成長和遊戲研發，致力推進國內遊戲社區的成長與進步。

想了解更多有料的遊戲技術，請關注個人公衆號，原創以及獨到。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程