[A*算法]基于Unity实现A*算法（二）

写在前面:上一篇当时是非常简单的了解一下A*，昨天还有一些问题没解决，就暂时把自己查阅的文坛摘抄了过来（毕竟人家写的比我要好的多 :> ）

今天终于解决了，就又写了这一篇，正好我自己再梳理一遍，把Unity的实现也记录一下（Unity版本：2019.3.7.f1）

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

• 一、Unity UI表现实现

　　UI制作很简单，如下图

　　

1. Canvas

　　　　

　　　　UGUI画布（参考官网文档）

　　　　我这边主要是在上面挂载一个寻路脚本CSPathFindManager_AStar.CS

　　2.Panel

　　　　

　　　　这里我用的是UGUI创建的Panel，主要是用来生成寻路点，挂载生成脚本CopyManager.CS

　　3.Node

　　　　

　　　　UGUI创建的Image，用的纯色，用来充当路径点，挂载路径点脚本CSNode.CS

　　4.F/G/H/Pos/Index

　　　　

　　　　UGUI创建的Text，通过修改文件对齐方式，使他们的文字分别位于Node的上下左右和中间，用来方便显示相关的值

二、Unity UI显示代码

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

public class CSPathFindManager : MonoBehaviour
{
    internal CopyObjs copyObjs;

    public Vector2 CellSize = new Vector2();

    public List<CSNode> AllNodesList = new List<CSNode>();
    public List<CSNode> openNodeList = new List<CSNode>();
    public List<CSNode> closeNodeList = new List<CSNode>();


    public int notMoveNodeCount = 0;
    public CSNode curNode = null;

    public bool isEndFind = false;

    public bool isFinding = false;

    public bool isAutoFind = true;

    public bool canBevel = true;

    // Start is called before the first frame update
    void Start()
    {
        copyObjs = gameObject.GetComponentInChildren<CopyObjs>();
        if (copyObjs == null) return;
        InitAllPath();
    }

    // Update is called once per frame
    void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            if (isAutoFind)
            {
                isFinding = !isFinding;
            }
            else
            {
                InitNearNodes();
            }
        }

        if (isFinding)
        {
            InitNearNodes();
        }
    }

    public virtual void InitAllPath()
    {
        AllNodesList.Clear();
        openNodeList.Clear();
        closeNodeList.Clear();

        if (copyObjs == null) return;
        copyObjs.MaxCount = (int)(CellSize.x * CellSize.y);

        int nodeIndex = 0;
        //System.Random tempRandom = new System.Random(GetRandomSeedbyGuid());

        for (int y = 0; y < CellSize.x; y++)
        {
            for (int x = 0; x < CellSize.y; x++)
            {
                CSNode tempNode = copyObjs.copyObjList[nodeIndex].GetComponent<CSNode>();
                tempNode.SetPos(x, y);

                if (tempNode.curMoveState == EnumMoveState.NULL)
                {
                    tempNode.SetMoveState(EnumMoveState.moveing);
                }

                AllNodesList.Add(tempNode);
                nodeIndex++;
            }
        }
    }

    public virtual List<CSNode> GetNearNode(CSNode node)
    {
        List<CSNode> tempNode = AllNodesList.FindAll(temp => IsChild(node, temp));

        if (tempNode != null) tempNode.Remove(node);
        return tempNode;
    }

    public virtual bool IsChild(CSNode parentNode, CSNode childNode)
    {
        if (parentNode == null || childNode == null) return false;
        if (canBevel)
        {
            return Mathf.Abs(childNode.pos.y - parentNode.pos.y) <= 1 && Mathf.Abs(childNode.pos.x - parentNode.pos.x) <= 1;
        }
        else
        {
            return (childNode.pos.x == parentNode.pos.x && Mathf.Abs(childNode.pos.y - parentNode.pos.y) == 1) || (childNode.pos.y == parentNode.pos.y && Mathf.Abs(childNode.pos.x - parentNode.pos.x) == 1);
        }
    }


    public virtual int GetGValue(CSNode startNode, CSNode targetNode)
    {
        int gV;
        if (targetNode.pos.x == startNode.pos.x || targetNode.pos.y == startNode.pos.y) gV = 10;
        int absX = (int)Mathf.Abs(targetNode.pos.x - startNode.pos.x);
        int absY = (int)Mathf.Abs(targetNode.pos.y - startNode.pos.y);
        if (canBevel)
        {
            if (absX > absY)
            {
                gV = 14 * absY + 10 * (absX - absY);
            }
            else
            {
                gV = 14 * absX + 10 * (absY - absX);
            }
        }
        else
        {
            gV = 10 * absX + 10 * absY;
        }
        return gV + startNode.GValue;
    }

    public virtual int GetHValue(CSNode node)
    {
        if (CSNode.FinialNode == null) return 99;
        return (int)Mathf.Abs(node.pos.x - CSNode.FinialNode.pos.x) * 10 + (int)Mathf.Abs(node.pos.y - CSNode.FinialNode.pos.y) * 10;
    }

    public virtual void InitNearNodes()
    { }

    //int GetRandomSeedbyGuid()
    //{
    //    return new Guid().GetHashCode();
    //}

    public virtual void ReSetPath()
    {
        curNode = null;
        for (int i = 0; i < openNodeList.Count; i++)
        {
            openNodeList[i].SetIndex(0);
            openNodeList[i].parent = null;
        }
        openNodeList.Clear();
        for (int i = 0; i < closeNodeList.Count; i++)
        {
            if ((int)closeNodeList[i].curMoveState > 4 && (int)closeNodeList[i].curMoveState < 8) closeNodeList[i].SetMoveState(EnumMoveState.moveing);
            closeNodeList[i].parent = null;
        }
        closeNodeList.Clear();
        isEndFind = false;
    }


    public virtual CSNode GetMinNode(List<CSNode> nodes)
    {
        if (nodes == null || nodes.Count == 0) return null;
        nodes.Sort((x, y) => x.FValue.CompareTo(y.FValue));
        return nodes[0];
    }

    public virtual void RemoveNotMoveNode(ref List<CSNode> tempNearList)
    {
        List<CSNode> notMoveNode = tempNearList.FindAll(temp => temp.curMoveState == EnumMoveState.notmove);
        tempNearList.RemoveAll(temp => temp.curMoveState == EnumMoveState.notmove);
        for (int i = 0; i < notMoveNode.Count; i++)
        {
            if (notMoveNode[i].pos.y == curNode.pos.y || notMoveNode[i].pos.x == curNode.pos.x) tempNearList.RemoveAll(temp => temp.pos.y != curNode.pos.y && temp.pos.x != curNode.pos.x && (temp.pos.x == notMoveNode[i].pos.x || temp.pos.y == notMoveNode[i].pos.y));
            tempNearList.Remove(notMoveNode[i]);
        }
    }
}

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

public class CSPathFindManager_AStar : CSPathFindManager
{


    public override void InitNearNodes()
    {
        if (CSNode.StartNode == null || CSNode.FinialNode == null)
        {
            isFinding = false;
            return;
        }
        if (!isEndFind)
        {
            if (curNode == null)
            {
                curNode = CSNode.StartNode;
                curNode.SetIndex(0);
            }
            else if (curNode != CSNode.FinialNode)
            {
                curNode = GetMinNode(openNodeList);

                curNode.SetIndex(curNode.parent.Index + 1);
            }
            else
            {
                isEndFind = true;
            }
        }

        if(isEndFind)
        {
            if (curNode!= null && curNode.parent != null && curNode.parent != CSNode.StartNode)
            {
                curNode = curNode.parent;
                curNode.SetMoveState(EnumMoveState.best);
            }
            else
            {
                isFinding = false;

                Debug.LogError("找到了！");
            }
            return;
        }
        if (curNode.curMoveState == EnumMoveState.moveing) curNode.SetMoveState(EnumMoveState.select);
        if (AllNodesList == null) return;
        for (int i = 0; i < closeNodeList.Count; i++)
        {
            if (closeNodeList[i].curMoveState == EnumMoveState.select) closeNodeList[i].SetMoveState(EnumMoveState.path);
        }
        closeNodeList.Add(curNode);
        openNodeList.Remove(curNode);
        List<CSNode> tempNearList = GetNearNode(curNode);
        tempNearList.RemoveAll(temp => closeNodeList.Contains(temp));
        RemoveNotMoveNode(ref tempNearList);

        for (int i = 0; i < tempNearList.Count; i++)
        {
            if (tempNearList[i].parent == null || tempNearList[i].parent.Index >= curNode.Index)
            {
                if (tempNearList[i].parent!= null && tempNearList[i].parent.Index == curNode.Index)
                {
                    int gV1 = GetGValue(curNode, tempNearList[i]);
                    int gV2 = GetGValue(tempNearList[i].parent, tempNearList[i]);
                    if (gV1 > gV2)
                    {
                        continue;
                    }
                }
                tempNearList[i].parent = curNode;
                int gV = GetGValue(tempNearList[i].parent, tempNearList[i]);
                int hV = GetHValue(tempNearList[i]);
                tempNearList[i].SetNodeInfo(gV, hV);
            }
        }

        openNodeList.AddRange(tempNearList.FindAll(temp=>!closeNodeList.Contains(temp) && !openNodeList.Contains(temp)));

        //for (int i = 0; i < openNodeList.Count; i++)
        //{
        //    int gV = GetGValue(openNodeList[i].parent, openNodeList[i]);
        //    int hV = GetHValue(openNodeList[i]);
        //    openNodeList[i].SetNodeInfo(gV, hV);
        //}
        if (openNodeList.Count == 0)
        {
            isFinding = false;
            Debug.LogError("死路！");
        }
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;

public enum EnumMoveState
{
    NULL,
    moveing,
    notmove,
    start,
    finial,
    path,
    select,
    best,
}

public class CSNode : MonoBehaviour
{

    private Text F;
    private Text G;
    private Text H;
    private Text PosText;
    private Text IndexText;
    private Image movePoint;

    public Vector2 pos;
    public int FValue;
    public int GValue;
    public int HValue;
    public int Index;

    public CSNode parent;
    public EnumMoveState curMoveState;

    private EventTrigger eventTrigger;
    private CSPathFindManager cSPathFindManager;

    public static CSNode StartNode;
    public static CSNode FinialNode;
    public static List<CSNode> NotMoveNodeList = new List<CSNode>();

    public CSNode(int _x,int _y)
    {
        pos.x = _x;
        pos.y = _y;
    }

    public static Dictionary<EnumMoveState, Color> pointColorDic = new Dictionary<EnumMoveState, Color>()
    {
        { EnumMoveState.moveing,Color.white},
        { EnumMoveState.notmove,Color.red},
        { EnumMoveState.start,Color.blue},
        { EnumMoveState.finial,Color.yellow},
        { EnumMoveState.path,Color.gray},
        { EnumMoveState.select,Color.cyan},
        { EnumMoveState.best,Color.green},
    };
    // Start is called before the first frame update
    void Awake()
    {
        F = transform.Find("F").GetComponent<Text>();
        G = transform.Find("G").GetComponent<Text>();
        H = transform.Find("H").GetComponent<Text>();
        PosText = transform.Find("Pos").GetComponent<Text>();
        IndexText = transform.Find("Index").GetComponent<Text>();
        movePoint = GetComponent<Image>();
        eventTrigger = gameObject.GetComponent<EventTrigger>();
        if (eventTrigger == null) eventTrigger = gameObject.AddComponent<EventTrigger>();
        List<EventTrigger.Entry> entryList = eventTrigger.triggers;
        if (entryList == null) entryList = new List<EventTrigger.Entry>();
        EventTrigger.Entry tempEntry = new EventTrigger.Entry();
        bool isExist = false;
        for (int i = 0; i < entryList.Count; i++)
        {
            if (entryList[i].eventID == EventTriggerType.PointerDown)
            {
                tempEntry = entryList[i];
                isExist = true;
                break;
            }
        }
        tempEntry.callback.AddListener(OnClick);
        if (!isExist)
        {
            tempEntry.eventID = EventTriggerType.PointerDown;
            entryList.Add(tempEntry);
        }
        cSPathFindManager = GetComponentInParent<CSPathFindManager>();
    }

    private void OnClick(BaseEventData arg0)
    {
        SetMoveState((EnumMoveState)SetNextType());
        cSPathFindManager.ReSetPath();
    }

    public int SetNextType()
    {
        int tempType = ((int)curMoveState + 1) % 8;
        if (tempType < 1 || tempType > 4) tempType = 1;
        return tempType;
    }

    // Update is called once per frame
    void Update()
    {
        
    }

    public void SetMoveState(EnumMoveState state)
    {
        if (state != curMoveState)
        {
            ResetNodeInfo(curMoveState, true);
            ResetNodeInfo(state,false);
            curMoveState = state;
            if (movePoint) movePoint.color = pointColorDic[state];

        }
    }

    public void ResetNodeInfo(EnumMoveState state,bool isDel = false)
    {
        switch (state)
        {
            case EnumMoveState.notmove:
                if (isDel)
                {
                    NotMoveNodeList.Remove(this);
                }
                else
                {
                    if (NotMoveNodeList.Contains(this)) NotMoveNodeList.Add(this);
                }
                break;
            case EnumMoveState.start:
                if (isDel)
                {
                    if (StartNode == this)
                    {
                        StartNode = null;
                    }
                }
                else
                {
                    if (StartNode != this)
                    {
                        if(StartNode != null)StartNode.SetMoveState(EnumMoveState.moveing);
                        StartNode = this;
                    }
                }
                break;
            case EnumMoveState.finial:
                if (isDel)
                {
                    if (FinialNode == this)
                    {
                        FinialNode = null;
                    }
                }
                else
                {
                    if (FinialNode != this)
                    {
                        if (FinialNode != null) FinialNode.SetMoveState(EnumMoveState.moveing);
                        FinialNode = this;
                    }
                }
                break;
            default:
                break;
        }
        //Debug.LogErrorFormat("当前状态：{0}; 是否删除：{3} 起点:{1}; 终点:{2}",state,StartNode,FinialNode,isDel);
    }

    public void SetNodeInfo(int _G,int _H)
    {
        FValue = _G + _H;
        GValue = _G;
        HValue = _H;
        if (F) F.text = (_G + _H).ToString();
        if (G) G.text = _G.ToString();
        if (H) H.text = _H.ToString();
    }

    internal void SetPos(int _x, int _y)
    {
        pos.x = _x;
        pos.y = _y;
        if (PosText) PosText.text = string.Format("{0},{1}", _x, _y);
    }

    internal void SetIndex(int index)
    {
        Index = index;
        if (IndexText) IndexText.text = string.Format("{0}", index);
    }
}

三、寻路算法

　　寻路算法逻辑都在CSPathFindManager_AStar

　　1.获取当前点cueNode

　　　

　　初始化当前点为出发点，之后为从搜索列表openNodeList中FValue(下面会有介绍)最小的节点，并为其设置当前索引值为父节点的索引值+1

　　2.获取FValue最小节点（GetMinNode）

　　　　列表排序，取第一个

　　　　

　　3.获取当前点的子节点

　　

 　　　　设置当前点的UI表现为选中状态

　　　　遍历挑选出来的列表，将其UI表现设置为已挑选过状态

　　　　将当前点加入已挑选列表

　　　　获取当前点的子节点，删选掉已挑选过的节点，（在RemoveNotMoveNode里面处理不可走点的删选）

　　4.为上面获取到的子节点赋值

　　　　这块就是昨天我困扰很久的地方，下面是我曾踩过的坑

　　　　(1).在这里遍历子节点，为他们赋值GValue是相对于当前点的移动距离

　　　　(2).把所有子节点加入搜索列表，再为列表里面的所有节点赋值GValue为当前相对于当前点的移动距离

　　　　(3).把所有子节点加入搜索列表，再为列表里面的所有节点赋值GValue为当前相对于起点的移动距离

　　　　我这么修改是因为下面这种情况：

　　　　　　

　　　　后来我改了第四种方式，并将获取G的方式改为子节点到中转点的G+中转点到起点的G：

　　　　(4). 在这里遍历子节点，判断如果自己点的父节点不存在或者父节点的索引值大于当前点的索引点，将当前点设为子节点的当前父节点，为他们赋值GValue是当前点为中转点的移动距离

　　　　　　

　　　　结果一样，因为这里索引值是相同的，于是我又加了=

　　　　(5). 在这里遍历子节点，判断如果自己点的父节点不存在或者父节点的索引值大于或等于当前点的索引点，将当前点设为子节点的当前父节点，为他们赋值GValue是当前点为中转点的移动距离

　　　　　　

 　　　　　就在我以为没问题的时候 :>

　　　　　　

　　　　　　在我一步一步看选点顺序的时候，发现也没毛病，但总有哪里不对劲 :>

　　　　　　后来我发现，他是在搜索点里面去找F值最小的，但是主要就是在第5遍修改后加的==判断，当索引一样的时候，该子节点在当前点的斜方向上，G值可能会更大

　　　　　　(6).在这里遍历子节点，判断如果自己点的父节点不存在或者父节点的索引值大于当前点的索引点，将当前点设为子节点的当前父节点，为他们赋值GValue是当前点为中转点的移动距离;而当索引值相等时，比较分别以当前点和父节点为中转点的G值

　　　　

　　　　nice！！！！ :>

　　　　

　　　　

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

我估计上面几种困扰可能也是我理解不够造成的，走过路过的还请不吝赐教。:>