游戏AI：（一）图、树与寻路算法

一、图

无向图：

有向图：

权重图：

 哈密顿图：

定义：经过所有的顶点并且只经过一次的路径，加哈密顿路径，闭合的哈密顿路径叫哈密顿回路。

例如送快递，快递车从快递公司出发，遍历每个小区，且每个小区只去一次，最后回到快递公司。这就是一条哈密顿回路。

例如我最近玩的一个游戏，第一次通关之后开启迷宫扫荡功能，但是这个游戏显然没把扫荡算法写好(也许是故意不让我把道具拿完...)，迷宫里随机位置有很多道具，每次扫荡道具都没拿完就直接打BOSS了((＃￣～￣＃))

根据上面讲的想必你也想到了，每个道具点可以看做一个顶点，BOSS所在位置是终点，起点随机(但别踩BOSS头上)，搜索出一个哈密顿回路就行了。

那么怎么表示图上节点之间的关系呢？

方法一：01矩阵（0表示没有路径，1表示有路径）

 上图用01矩阵表示如下：

[1 1 0 0]   //1和1有路径是因为上图中1有一个回路

[1 0 1 0]

[0 1 0 1]

[0 0 1 0]

方法二：链表 

1->1->2

2->1->3

3->2->4

4->3

哪种方式更好要看具体情况，链表没有冗余信息，有就是有，没有就不写。矩阵则把所有信息都表示出来了，但是在游戏里，有时地图数据是从json文件里读出来的，这样就可以把配置地图工作交给策划，用一个矩阵来表示地图上的每个点会很方便，点可以定义成一个类，所以每个点可以表示很多信息。

二、树

二叉树：什么是二叉树？国家出台二胎法，要求每个家庭最多可以生两个孩子，所以只要有一个节点生了三个子树那就违法了，赶出二叉树家族。

满二叉树：他是二叉树家族的一员，所以也在二胎法环境下，但他们家多了一条家训，每个家庭要么不生，要生就必须生两个。生一个的非吾族类，虽远必诛。

完全二叉树：

满二叉树也是完全二叉树。

前面生一个的被满二叉树家族排挤了，完全二叉树长老说，别怕，来我这儿，但是你生的这一个是儿子还是女儿啊？这男左女右，要是你生的是儿子(左子树)，我就让你加入，你只有一个女儿(右子树)那就不行了。

所以完全二叉树家族的家训是，要么不生，要么先生儿子(左子树)。

平衡二叉树：左右子树的深度差<=1，通俗来说就是：我兄弟（兄弟节点：就是同一个妈生的左子树和右子树）有孩子（不管左右）了，我还没有，我不着急。但是我兄弟有孙子（子孙节点）了，我连孩子都没有，我就不平衡了。

二叉查找树：

 对于每个根节点，左节点值小于父节点，右节点值大于父节点。

 红黑树：

 红黑树是每个结点都带有颜色属性的二叉查找树，颜色或红色或黑色。

寻路算法

1. 广度优先搜索 BFS & 深度优先搜索 DFS

广度优先搜索 BFS：顾名思义，广度优先就是从根节点出发，先遍历它所有的子节点，再遍历第一个子节点所有的子节点，一层一层下去。

优点：可以找出最短路径

缺点：遍历了所有顶点

深度优先搜索 DFS：从根节点出发，先访问它的子节点，然后是子节点的子节点，一直访问到叶子节点，再一层层回溯前面的过程。

缺点：找到的路径往往不是最短的

2. Dijkstra 算法

采用贪心算法策略，每次都选择距离最短的节点。

A* 算法

 g(n)表示该点距离起点的代价，h(n)表示该点距离终点的代价。所以这个点的总开销=到起点的代价+到终点的代价。

下面讨论几种情况：

h(n)=0 ： 即只有g(n)在起作用，总开销=到起点的代价，那么每次都会选择距离最近的点，这等同于Dijkstra算法。

g(n)=0 ：即只有h(n)在起作用，总开销=到终点的代价，这种情况叫最佳优先搜索算法。

那么怎么求代价呢？

如果只能上下左右四方向移动，那么可以用曼哈顿距离，即 abs(node.x-nextNode.x)+abs(node.y-nextNode.y)

如果可以走斜线，那么可以用欧几里得距离，计算三角形的对角线就行了。sqrt(pow(abs(node.x-nextNode.x),2)+pow(abs(node.y-nextNode.y),2))，不用真的每次都傻傻的计算这么大一串，一般我们取的是边长为1的正方形，按曼哈顿距离，到达对角顶点每次要走两条边，按欧几里得距离直接走对角线，就是sqrt(2)，约等1.4。

下面我们用Unity来测试一下A*算法：

1）先创建Node类，这个类得包含坐标，父节点，该节点是路还是障碍，寻路消耗

public enum NodeType
{
    Walk,
    Stop
}
public class Node 
{
    //坐标
    public int x;
    public int y;
    //父节点
    public Node father;
    //节点能不能走
    public NodeType type;
    //寻路消耗
    public float G;
    public float H;
    public float F;
    public Node(int x,int y,NodeType type)
    {
        this.x = x;
        this.y = y;
        this.type = type;
    }
    public void SetNode(Node father,float g,float h)
    {
        this.father = father;
        this.G = g;
        this.H = h;
        this.F = g + h;
    }
}

2 )创建AStar寻路算法类

public class AStar :MonoBehaviour
{
    public static AStar instance;  //这里只是为了方便使用，这种写法并不规范
    
    int mapWidth;
    int mapHight;

    public Node[,] nodes;
    List<Node> openList = new List<Node>();
    List<Node> closeList = new List<Node>();
    private void Awake()
    {
        instance = this;
    }
    public void InitMap(int w,int h)
    {
        mapWidth = w;
        mapHight = h;
        nodes = new Node[w, h];
        //随机生成地图
        for(int i = 0; i < w; i++)
        {
            for(int j = 0; j < h; j++)
            {
                Node node = new Node(i, j, Random.Range(0, 10) < 3 ? NodeType.Stop : NodeType.Walk);
                nodes[i, j] = node;
            }
        }
    }
    public List<Node> FindPath(Vector2 startPos,Vector2 endPos)
    {
        //判断传入的两个点是否合法
        if (startPos.x < 0 || startPos.x > mapWidth || startPos.y < 0 || startPos.y > mapHight
            || endPos.x < 0 || endPos.x > mapWidth || endPos.y < 0 || endPos.y > mapHight)
        {
            Debug.Log("开始或结束结点超出地图范围");
            return null;
        }
        Node startNode = nodes[(int)startPos.x, (int)startPos.y];
        Node endNode = nodes[(int)endPos.x,(int)endPos.y];
        if (startNode.type == NodeType.Stop || endNode.type == NodeType.Stop)
        {
            Debug.Log("开始或结束结点是阻挡物");
            return null;
        }

        //清空关闭和开启列表
        openList.Clear();
        closeList.Clear();

        //开始点放入关闭列表中
        startNode.SetNode(null, 0, 0);
        closeList.Add(startNode);

        while (true)
        {
            //从起点开始找周围的点
            //左上
            FindNeighbors(startNode.x - 1, startNode.y - 1, startNode, 1.4f, endPos);
            //上
            FindNeighbors(startNode.x, startNode.y - 1, startNode, 1.4f, endPos);
            //右上
            FindNeighbors(startNode.x + 1, startNode.y - 1, startNode, 1.4f, endPos);
            //左
            FindNeighbors(startNode.x - 1, startNode.y, startNode, 1.4f, endPos);
            //右
            FindNeighbors(startNode.x + 1, startNode.y, startNode, 1.4f, endPos);
            //左下
            FindNeighbors(startNode.x - 1, startNode.y + 1, startNode, 1.4f, endPos);
            //下
            FindNeighbors(startNode.x, startNode.y + 1, startNode, 1.4f, endPos);
            //右下
            FindNeighbors(startNode.x + 1, startNode.y + 1, startNode, 1.4f, endPos);

            //选出开启列表中F值最小的点
            openList.Sort(CompareNode);

            //放入关闭列表中，并从开启列表移除
            closeList.Add(openList[0]);
            startNode = openList[0];
            openList.RemoveAt(0);

            //如果这个点是终点，则返回结果
            if (startNode==endNode)
            {
                return closeList;
            }
        }
    }
    private void FindNeighbors(int x,int y,Node father,float g,Vector2 endPos)
    {
        //判断这些点是否是边界或阻挡或在开启或关闭列表中，都不是才能放入开启列表中
        if (x < 0 || x >= mapWidth || y < 0 || y >= mapHight)
            return;
        Node node = nodes[x, y];
        if (node == null || node.type == NodeType.Stop ||
            closeList.Contains(node) || openList.Contains(node))
            return;
        //我离起点的距离=我父亲离起点的距离+我离父亲的距离
        node.SetNode(father, father.G + g, Mathf.Abs(node.x - endPos.x) + Mathf.Abs(node.y - endPos.y));
        openList.Add(node);
    }
    private int CompareNode(Node a,Node b)
    {
        if (a.F > b.F)
            return 1;
        else
            return -1;
    }
}

3）接下来是测试的代码

public class Test : MonoBehaviour
{
    //格子坐标
    public int beginX=-3;
    public int beginY=3;
    //格子之间的偏移位置
    public int offsetX=1;
    public int offsetY=-1;
    //地图大小
    public int mapWidth=5;
    public int mapHeight=5;

    private Vector2 beginPos = Vector2.right * -1;
    private Dictionary<string, GameObject> cubes = new Dictionary<string, GameObject>();
    private void Start()
    {
        AStar.instance.InitMap(mapWidth, mapHeight);
        for(int i = 0; i < mapWidth; i++)
        {
            for(int j = 0; j < mapHeight; j++)
            {
                GameObject obj = GameObject.CreatePrimitive(PrimitiveType.Cube);
                obj.transform.position = new Vector3(beginX + i * offsetX, beginY + j * offsetY, 0);
                obj.name = i + "_" + j;
                cubes.Add(obj.name, obj);
                Node node = AStar.instance.nodes[i, j];
                if (node.type == NodeType.Stop)
                {
                    obj.GetComponent<MeshRenderer>().material.color = Color.red;
                }
            }
        }
    }
    private void Update()
    {
        if (Input.GetMouseButtonDown(0))
        {
            RaycastHit hitInfo;
            Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
            if(Physics.Raycast(ray,out hitInfo, 1000))
            {
                if (beginPos == Vector2.right * -1)
                {
                    string[] strs = hitInfo.collider.gameObject.name.Split('_');
                    beginPos = new Vector2(int.Parse(strs[0]), int.Parse(strs[1]));
                    hitInfo.collider.gameObject.GetComponent<MeshRenderer>().material.color = Color.yellow;
                }
                else
                {
                    string[] strs = hitInfo.collider.gameObject.name.Split('_');
                    Vector2 endPos = new Vector2(int.Parse(strs[0]), int.Parse(strs[1]));
                    hitInfo.collider.gameObject.GetComponent<MeshRenderer>().material.color = Color.yellow;
                    List<Node> list = AStar.instance.FindPath(beginPos, endPos);
                    if (list != null)
                    {
                        for(int i = 0; i < list.Count; i++)
                        {
                            cubes[list[i].x + "_" + list[i].y].GetComponent<MeshRenderer>().material.color = Color.green;
                        }
                    }
                }

            }

        }
    }
}

测试结果：