2. 程式人生 > >unity3D 簡單實現A*演算法

unity3D 簡單實現A*演算法

阿新 • • 發佈：2019-02-16

前言

在兩個物體之間尋找最短有效路徑

  1. 學習A*思想
  2. 其他演算法，計算機估計距離
  3. 曼哈頓（城市街區演算法、直來直去）
  4. 幾何法（對角線，勾股定理）
  5. 估演算法（先對角線，再直線）本文使用估演算法計算距離
  6. GHF
  7. G : 從開始到當前位置的移動步數
  8. H : 從當前位置到目標位置的距離，使用上面3種演算法獲得
  9. F ：G + H 的總和
  10. OpenList 和 CloseList
  11. OpenList ：被考慮最短有效路徑的位置集合
  12. CloseList : 不被考慮最短語效路徑的位置集合
  13. 尋路思想：知道F = G + H 且知道如何計算得出，知道OpenList 和CloseList並知道如何得出

F G H 分別表示什麼，有什麼用，如何計算機它們？

  1. 首先得G表示的是從起始結點走到下一個結點（下下…下個）的距離，因此這個G是每走一格就會疊加一次並賦值給新的結點，從而累計得到從當前結點到下下下..個結點的距離
    newCostg = gCost + GetDistance()
    nodeCell.gCost = newCostg; //移動步數
  2. 其次是H，它表示從當前結點到終點結點的最短距離
  3. F 就是 G + H 得到的估算值

再根據百度百科的解釋做個比較或許更容易理解：

f(n)=g(n)+h(n)
f(n) 是從初始狀態經由狀態n到目標狀態的代價估計，
g(n) 是在狀態空間中從初始狀態到狀態n的實際代價，
h(n) 是從狀態n到目標狀態的最佳路徑的估計代價。
（對於路徑搜尋問題，狀態就是圖中的節點，代價就是距離）

這裡需要寫一個兩點之間的距離估算方法,來計算得出G H 從而得出F
注意最好避免小數計算，
因為計算機計算機浮點的效率較低
而這裡的x表示長 y表示高 可以通過畫圖理解，x = y 就是正方形，兩點距離就是1.4 ，避免小數計算乘10 就是14整數了

    //計算距離 ,這裡是因為NodeItem是巢狀類，在Grid裡面 
    public int GetDistance(Grid.NodeItem a,Grid.NodeItem b) {
        //估演算法
        int x = Mathf.Abs (a.x - b.x);
        int y = Mathf.Abs (a.y - b.y);
        //根號2 = 1.4  然後都擴大10倍 去除小數計算,這裡返回值都放大了10倍
 

        if (x > y) {
            return 14 * y + 10 * (x - y);  
        }else{
            return 14 * x + 10 * (y - x);
        }
    //也可以用曼哈頓得到距離
    //return Mathf.Abs (a.x-b.x)+Mathf.Abs(a.y-b.y);//得到正數，但是可能是浮點數
    }

OpenList和CloseList是什麼，可以用來做什麼？

OpenList ：被考慮最短有效路徑的位置集合
CloseList : 不被考慮最短語效路徑的位置集合

1、從第一個結點開始，放入OpenList容器，然後這個結點獲取全部周圍符合條件（1）的結點；
2、把符合條件的結點全部放入OpenList容器；
3、並且還要對周圍符合條件（2）的每個結點進行更新他們的G值和H值，記錄這個當前結點為它們的父結點；
4、然後把這第一個結點放入CloseList容器裡 這是第一次迴圈

5、隨後進入第二次迴圈，
此時就從OpenList容器找到符合條件（3）的當前結點，
當前結點是要在OpenList容器中H值最小，且F值最小的；
6、找到後就獲取這個當前結點的周圍結點，然後重新進入第2步驟到第5步驟；
7、此時它會慢慢接近終點，直到發現當前結點==最終結點；
8、最終結點找到後根據最終結點的父結點一個一個返回（類似資料結構的連結串列）找到開始結點；
9、此時用一個容器（List容器、Stack容器等）來接收這些結點，這些結點的Position就是最短路徑

介紹符合條件：
第一個符合條件（1）是對周圍結點的判斷，該結點如果是標有牆類標記、或不可走標記就是不符合條件的，
第二個符合條件（2）是在滿足第一個條件的前提下，在CloseList容器下遍歷過，或更新後的G值比原來G值還要大的結點，2者不滿足一個就是不滿足條件，不能更新該結點的G，H值
第三個符合條件（3）就是儲存在OpenList容器中的結點中，找一個H值最小，且， F值最小的結點，找到這個H值且F值最小的結點後，就把這個結點設定為當前結點。

當前結點在這裡指為離終點結點的最短距離估計點。這個點其實並不會太智慧，一下就找到最短路徑。
而是根據OpenList裡的全部結點來判斷找到離終點最短估計值最小的結點，讓周圍的結點加入OpenList。然後就放入CloseList容器這個最短估計值最小的結點以後不再做任何判斷。

CS指令碼程式碼
結點類
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class AStarNode {

    public bool isWall;
    public int posX;
    public int posY;
    public int posZ;

    public Vector3 pos;
    public AStarNode parentNode;

    public int costG;
    public int costH;

    public int CostF{
        get{ return costG + costH; }
    }

    public AStarNode(bool _isWall,Vector3 _pos,int _z,int _x){
        this.isWall = _isWall;
        this.pos = _pos;
        this.posX = _x;
        this.posZ = _z;
    }
}
結點地圖生成類
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class AStarMAP : MonoBehaviour {

    public AStarNode [,] AllNodeGroup; 

    public LayerMask wallLayer;
    public int xWidth;
    public int zHeight;
    private float nodeRange = 0.4f;

    public GameObject nodeWallPrefabs;

    void Awake(){
        Init();
    }

    void Init(){

        zHeight = 40;
        xWidth = 40;
        AllNodeGroup = new AStarNode[zHeight, xWidth];
        //初始化所有結點，把結點node存入二維數組裡
        for (int i = 0; i < zHeight; i++) {
            for (int j = 0; j < xWidth; j++) {

                Vector3 nodePos =new Vector3 (j,0,i);
                nodePos += new Vector3 (0.5f, 0, 0.5f); 
                bool isWall = Physics.CheckSphere (nodePos, nodeRange, wallLayer);
                AStarNode nd = new AStarNode (isWall, nodePos,i,j);

                if (isWall) {
                    GameObject obj = GameObject.Instantiate (nodeWallPrefabs, nodePos, Quaternion.identity) as GameObject;

                }
                AllNodeGroup[i,j] = nd;

            }
        }
    }

    public List<AStarNode> GetAroundNodes(AStarNode curNode){

        List<AStarNode> retGroup = new List<AStarNode> ();
        for (int i = -1; i <= 1; i++) {
            for (int j = -1; j <= 1; j++) {
                if (i == 0 && j == 0) {
                    continue;
                }
                int z = curNode.posZ + i;
                int x = curNode.posX + j;

                if (x >= 0 && x < xWidth && z >= 0 && z < zHeight) {
                    retGroup.Add (AllNodeGroup [z, x]);
                }
            }
        }
        return retGroup;

    }

    public AStarNode GetItem(Vector3 pos){
        int x = Mathf.RoundToInt (pos.x - 0.5f);
        int z = Mathf.RoundToInt (pos.z - 0.5f);
        x = Mathf.Clamp (x, 0, xWidth - 1);
        z = Mathf.Clamp (z, 0, zHeight - 1);
        return AllNodeGroup [z, x];
    }
}
找最短路徑類
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class AStarFindPath : MonoBehaviour {

    private AStarMAP aStarMap;

    public List<Vector3> peoplePath;
    public List<AStarNode> peopleNodePath;

    void Start(){
        aStarMap = GetComponent<AStarMAP> ();
    }

    private int GetDistance(AStarNode startNode,AStarNode endNode){
        int x = Mathf.Abs (startNode.posX - endNode.posX);
        int z = Mathf.Abs (startNode.posZ - endNode.posZ);
        if (x > z) {
            return 10 * (x - z) + 14 * z;
        } else {
            return 10 * (z - x) + 14 * x;
        }
    }


    //根據開始和結束點來查詢最優路徑
    private void toFindPath(Vector3 startPos,Vector3 endPos) {

        //根據位置獲取到NodeItem
        AStarNode start = aStarMap.GetItem (startPos);
        AStarNode end = aStarMap.GetItem (endPos);

        List<AStarNode> openList = new List<AStarNode> ();
        List<AStarNode> closeList = new List<AStarNode> ();

        openList.Add (start);
        //從開始點開始判斷
        while (openList.Count > 0) {
            AStarNode curNode = openList [0];
            for (int i = 0; i < openList.Count; i++) {
                //h是估演算法的距離  f是估演算法加實際格子的距離g
                if (openList [i].CostF < curNode.CostF && openList [i].costH < curNode.costH) {
                    curNode = openList [i];
                }
            }

            openList.Remove (curNode);
            closeList.Add (curNode);

            //已經找到結束點
            if (curNode == end) {
                Debug.Log (">>");
                GetPathWithPos (startPos, endPos);
                return;
            }
            // 獲取當前點的周圍點
            List<AStarNode> nodeItemGroup =  aStarMap.GetAroundNodes(curNode);

            //遍歷當前點周圍的NodeItem 對其進行
            foreach (AStarNode nodeCell in nodeItemGroup) {
                //先過濾： 牆 closeList
                if (nodeCell.isWall || closeList.Contains (nodeCell)) {
                    continue;
                }

                //計算 G H F 進行賦值
                int newCostg = curNode.costG + GetDistance (curNode, nodeCell);

                if (newCostg <= nodeCell.costG || !openList.Contains (nodeCell)) {
                    //重新整理g h
                    nodeCell.costG = newCostg; //移動步數距離
                    nodeCell.costH = GetDistance (nodeCell, end);//到該結點到終點的距離
                    //設定中心點為父親
                    nodeCell.parentNode = curNode;
                    if (!openList.Contains (nodeCell)) {
                        openList.Add (nodeCell);
                    }
                }
            }
        }
    }

    //獲取路徑
    private void GetPathWithPos(Vector3 startPos,Vector3 endNodePos){
        //此處可以優化GC記憶體
        peopleNodePath = new List<AStarNode> ();
        peoplePath = new List<Vector3> ();

        AStarNode endNode = aStarMap.GetItem (endNodePos);
        AStarNode startNode = aStarMap.GetItem (startPos);

        if (endNode != null) {

            AStarNode temp = endNode;

            while (temp != startNode) {
                peoplePath.Add (temp.pos);
                peopleNodePath.Add (temp);
                temp = temp.parentNode;
            }
            peopleNodePath.Reverse ();
            peoplePath.Reverse ();
        }
    }
    //提供給人物移動類使用
    public List<Vector3> PeopleGoTo(Vector3 startpos,Vector3 endpos){
        toFindPath (startpos, endpos);
        return peoplePath;
    }

    public List<AStarNode> PeopleGoToWithNode(Vector3 startpos,Vector3 endpos){
        toFindPath (startpos, endpos);
        return peopleNodePath;
    }
}
人物移動實現類

這裡是我以前實現了一個有點簡單AI的A*移動，現在看起來有點醜，，還可以做優化，
實現的時候也可以發現：
A*演算法可以做出介面來用的，不過需要根據需求情況設定一些值。
開始結點，最終點結點的位置（可自動獲取開始結點位置，滑鼠點選獲取終點結點位置）
生成地圖的大小，結點的大小，地圖、結點座標設計需要考慮
找到後的路徑結點容器該怎麼優化，實現是也是要考慮的

這裡我使用了協程來寫。

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PlayerTest : MonoBehaviour {

    AStarFindPath astarFindPath;
    public Vector3 endPos = new Vector3(12.5f,0,0.5f);
    RaycastHit hit;
    Ray ray;

    AStarNode currentNode;
    public bool isGO = true;
    List<AStarNode> pathGroupNode;
    void Awake(){
        astarFindPath = GetComponent<AStarFindPath> ();
    }
    void Start () {
        pathGroupNode = new List<AStarNode> ();
    }
    void Update(){
        peopleCtrl ();
    }
    void peopleCtrl(){
        if (Input.GetMouseButtonDown (0)) {
            ray = Camera.main.ScreenPointToRay (Input.mousePosition);
            if (Physics.Raycast (ray, out hit)) {
                endPos = hit.point;
                pathGroupNode.Clear ();
                i = 1;
                //執行A*演算法
                pathGroupNode = astarFindPath.PeopleGoToWithNode (transform.position, endPos);
                if (pathGroupNode.Count <= 1) {
                    Debug.Log ("不需要走");
                    return;
                }
                currentNode = pathGroupNode [1];
                StopAllCoroutines ();
                StartCoroutine (pahtGo ());

            } else {
                Debug.Log ("重新點選");
            }
        }
    }
    IEnumerator pahtGo(){
        while (true) {
            if (Vector3.Distance (transform.position, currentNode.pos) <= 0.5f) {
                currentNode = pathGroupNode[i++];
                if (currentNode == null) {
                    Debug.Log ("到終點了...");
                    yield break;
                }   
                if (i >= pathGroupNode.Count) {
                    Debug.Log ("到達目的地");
                    yield break;
                }
            } else {
                transform.LookAt (currentNode.pos);
                transform.Translate (Vector3.forward * 2f * Time.deltaTime, Space.Self);
            }
            yield return new WaitForEndOfFrame ();
        }
    }
}

相關推薦

unity3D 簡單實現A*演算法

前言 在兩個物體之間尋找最短有效路徑 學習A*思想 其他演算法，計算機估計距離 曼哈頓（城市街區演算法、直來直去） 幾何法（對角線，勾股定理） 估演算法（先對角線，再直線）本文使用估演算法計算距離 GHF G : 從開始到當前位置的移動步數 H : 從

Unity3d 簡單實現 NGUI UI系統

首先定義兩個配置表： UILevel.txt 層級ID 層級名稱 層級起始深度 鎖定層級（1，鎖定層級，不會自動更新Panel深度） 層級描述 UILeveID UILevelName UILevelDepth UILevelLock UILevelD

C#實現A*演算法(轉載)

理解A*尋路演算法具體過程 這兩天研究了下 A* 尋路演算法, 主要學習了這篇文章, 但這篇翻譯得不是很好, 我花了很久才看明白文章中的各種指代. 特寫此篇部落格用來總結, 並寫了尋路演算法的程式碼, 覺得有用的同學可以看看. 另外因為圖片製作起來比較麻煩, 所以我用的是原

營救公主(Java實現A*演算法解決迷宮問題)

很早就聽說過A*演算法，據說在尋路徑時，是一種比較高效的演算法。但是一直沒有搞清楚原理。 這段時間剛好有個營救公主的例子： 題描述 : 公主被魔王抓走了 ， 王子需要拯救出美麗的公主 。 他進入了魔王的城 堡 ， 魔王的城堡是一座很大的迷宮 。 為了使問題簡單化 ， 我們假設這個迷宮是

A*尋路演算法的C++簡單實現

2007/8/13 17:26:59 #include <iostream> #include <ctime> #include <list> #include <algorithm> #include <cassert&

Unity3d 實現 A * 尋路演算法

原理A* 演算法是一種啟發式搜尋演算法，通過代價函式f = g+h，A*演算法每次查詢代價最低的點作為搜尋點，並更新搜尋節點列表。最終搜尋到目標位置。需要定義兩個列表 (Open和Closed列表)：    private List<Tile> openList

A*尋路演算法C++簡單實現

參考文章： A*尋路演算法是遊戲中常用的AI演算法，這裡用C++簡單實現了一下演算法，便於理解。 搜尋區域 如圖所示簡易地圖, 其中綠色方塊的是起點 (用 A 表示), 中間藍色的是障礙物, 紅色的方塊 (用 B 表示) 是目的地. 為了可以用一個二

A*算法的理解與簡單實現

update for port 移動 ont 效率 print 估算 net 基本定義 一種尋路算法，特點是：啟發式的，效率高，基本思路比較簡單。 用途 尋路。在指定的地圖上，考慮到地圖上的移動代價，找到最優的路徑。 核心概念 開表，閉表，估值函數。 開表 開表，記錄了當前

[轉] A*尋路算法C++簡單實現

track pos endpoint 障礙 close math.h 不存在 rec 節點 參考文章： http://www.policyalmanac.org/games/aStarTutorial.htm 這是英文原文《A*入門》，最經典的講解，有demo演示 ht

雙向連結串列簡單實現--資料結構與演算法紀錄片第一記

　　從這個月開始得準備春招的東西，所以打算重新學習資料結構與演算法，以後的部落格就以這個為主。 　　今天是線性結構中的雙向連結串列。 　　程式碼實現與測試： 　　DoubleLinkNode：　 package linear.doublelink;/** * @Description: 連結串列節點結

A*演算法實現（圖形化表示）——C++描述

概要 　　A*演算法是一種啟發式尋路演算法，BFS是一種盲目的無目標的搜尋演算法，相比於BFS，A*演算法根據適應度構建優先佇列，根據適應度值可以很好的向目標點移動，具體詳情，請看搜尋相關文件，我在只是實現了在無障礙的情況下的A*演算法，有障礙的情況類似。 開發環境 　　visual studio 20

OneR演算法的Python簡單實現

OneR演算法就是，在已有資料中，根據具有相同特徵值的個體最可能屬於哪個類別進行分類。即取效果最好的那個特徵進行分類。 #-*- coding=utf-8 -*- # import numpy as np from sklearn.datasets import load_iris f

Python實現幾種簡單的排序演算法

一.氣泡排序 概念:為一個無序的列表排成有序的 實現過程描述:(升序) 　　1.比較相鄰的元素,如果第一個比第二個大,就交換他們的位置 　　2.對每一對相鄰元素重複1的工作,從開始第一隊到最後一對,最後結束的時候最大的數會在後面 　　3.針對所有元素重複1,2的工作,除了最後一個數,因為最後的數最大

負載均衡演算法---Java簡單實現（2）

上一篇介紹了負載均衡的輪詢，隨機，跟hash演算法，這邊我們一起了解下，加權的輪詢以及加權的隨機。其實理解好了輪詢跟隨機演算法，再加權的話其實是差不多的。 看面通過程式碼來了解： （1）為了不重複建立一個server列表，我們先建立一個共有的server列表，如下： pu

負載均衡演算法---Java的簡單實現（1）

最近，大夥常在談論什麼負載均衡，什麼伺服器的，而自己對於這一塊也是不太理解深入模糊，然後就去看書學習，印證自己的想法。下面是自己的一些總結吧：   比較常用的負載均衡演算法，有下面的這一些： （1）輪詢（其實就是迴圈） （2）隨機 （3）hash （4）加權輪詢

unity3D-簡單Animation 實現Ground來回移動

1.向場景中新增模型 ： Ground      2.選中場景中模型：Ground  3.window視窗中Animation 4.點選Create  建立Gound_Ani .anim 5.AddProperty 

A*演算法解決15數碼問題_Python實現

1問題描述 數碼問題常被用來演示如何在狀態空間中生成動作序列。一個典型的例子是15數碼問題，它是由放在一個4×4的16宮格棋盤中的15個數碼(1-15)構成，棋盤中的一個單元是空的，它的鄰接單元中的數碼可以移到該單元中，通過這樣不斷地移動數碼來改變棋盤佈局，使棋盤從給定的初始棋局變為目標棋局(圖1)。【數字

N數碼問題的啟發式搜尋演算法--A*演算法python實現

一、啟發式搜尋：A演算法 1）評價函式的一般形式 : f(n) = g(n) + h(n) g(n):從S0到Sn的實際代價(搜尋的橫向因子) h(n):從N到目標節點的估計代價,稱為啟發函式(搜尋的縱向因子); 特點: 效率高, 無回溯,   搜尋演算法 OPEN表 : 存放待擴充套件的節點. CLOS

簡單選擇排序演算法原理及java實現（超詳細）

選擇排序是一種非常簡單的排序演算法，就是在序列中依次選擇最大（或者最小）的數，並將其放到待排序的數列的起始位置。 簡單選擇排序的原理 簡單選擇排序的原理非常簡單，即在待排序的數列中尋找最大（或者最小）的一個數，與第 1 個元素進行交換，接著在剩餘的待排序的數列中繼續找最大（最小）的一個數，與第 2 個元素交

探祕多智慧體強化學習-MADDPG演算法原理及簡單實現

之前接觸的強化學習演算法都是單個智慧體的強化學習演算法，但是也有很多重要的應用場景牽涉到多個智慧體之間的互動，比如說，多個機器人的控制，語言的交流，多玩家的遊戲等等。本文，就帶你簡單瞭解一下Open-AI的MADDPG(Multi-Agent Deep Determinist