Unity 遍历敌人——使用四叉树空间分区

最近看了《游戏编程模式》这本书，里面有一篇空间分区的文章，看了心里痒痒，决定去尝试实现一下。文章后面会给出整个学习参考的链接。

实现的效果如下，我们有一个很大的场景，场景有许许多多的敌人。红色的点代表是玩家，黑色的点代表是敌人。在这样的一个大量敌人的情景下，我们不可能在玩家或敌人寻找身边的攻击对象时穷尽所有的对象。因为我们要建立空间分区，只遍历某个对应区的对象。在图下中，红点中遍历红框中的黑点对象，其他一律不遍历。

接下来我直接放代码了，主要采用了四叉树，如果对于一些不懂的地方断点调试下就可以了，并没有涉及到很高深的算法，不要想得太难。

其中也实现了红点在分区边缘遍历另外一个区的敌人的漏洞。

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

/// <summary>
/// Rect的扩展方法类
/// </summary>
public static class RectExtension
{
    /// <summary>
    /// 计算点到Rect的border的距离，若点在Rect内则返回0
    /// </summary>
    /// <param name="rect"></param>
    /// <param name="pos"></param>
    /// <returns></returns>
    public static float PointToBorderDistance(this Rect rect, Vector2 pos)
    {
        float xdisance;
        float ydisance;

        if (rect.x <= pos.x && pos.x <= rect.xMax)
        {
            xdisance = 0;
        }
        else
        {
            xdisance = Mathf.Min((Mathf.Abs(pos.x - rect.width)), (pos.x - rect.x));
        }

        if (rect.y <= pos.y && pos.y <= rect.yMax)
        {
            ydisance = 0;
        }
        else
        {
            ydisance = Mathf.Min((Mathf.Abs(pos.y - rect.height)), (pos.y - rect.y));
        }

        return xdisance * xdisance + ydisance * ydisance;
    }
}

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

/// <summary>
/// 叶子节点类，负责坐标与数据的映射
/// </summary>
/// <typeparam name="T"></typeparam>
public class QuadTreeLeaf<T>
{
    private Vector2 pos;
    private T refObject;

    public QuadTreeLeaf(Vector2 pos,T obj)
    {
        this.pos = pos;
        refObject = obj;
    }

    public T LeafObject
    {
        get
        {
            return refObject;
        }
    }

    public Vector2 Pos
    {
        get { return pos; }
        set { pos = value; }
    }
}

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

/// <summary>
/// 四叉树节点
/// </summary>
/// <typeparam name="T"></typeparam>
public class QuadTreeNode<T>
{
    /// <summary>
    /// 节点拥有的叶子节点
    /// </summary>
    protected List<QuadTreeLeaf<T>> items;
    /// <summary>
    /// 节点拥有的分支
    /// </summary>
    protected QuadTreeNode<T>[] branch;
    /// <summary>
    /// 节点空间最大容量，受minSize影响
    /// </summary>
    protected int maxItems;
    /// <summary>
    /// 节点空间分割的最小大小（最小宽度，高度）
    /// </summary>
    protected float minSize;

    public const float TOLERANCE = 0.001f;
    /// <summary>
    /// 节点的空间
    /// </summary>
    public Rect bounds;

    public QuadTreeNode(float x, float y, float width, float height, int maximumItems, float minSize = -1)
    {
        bounds = new Rect(x, y, width, height);
        maxItems = maximumItems;
        this.minSize = minSize;
        items = new List<QuadTreeLeaf<T>>();
    }

    public bool HasChildren()
    {
        if (branch != null)
            return true;
        else
            return false;
    }

    /// <summary>
    /// 将节点空间分割4份
    /// </summary>
    protected void Split()
    {
        if (minSize != -1)
        {
            if (bounds.width <= minSize && bounds.height <= minSize)
            {
                return;
            }
        }

        float nsHalf = bounds.height - bounds.height / 2;
        float ewHalf = bounds.width - bounds.width / 2;

        branch = new QuadTreeNode<T>[4];

        branch[0] = new QuadTreeNode<T>(bounds.x, bounds.y, ewHalf, nsHalf, maxItems, minSize);
        branch[1] = new QuadTreeNode<T>(ewHalf, bounds.y, ewHalf, nsHalf, maxItems, minSize);
        branch[2] = new QuadTreeNode<T>(bounds.x, nsHalf, ewHalf, nsHalf, maxItems, minSize);
        branch[3] = new QuadTreeNode<T>(ewHalf, nsHalf, ewHalf, nsHalf, maxItems, minSize);

        foreach (var item in items)
        {
            AddNode(item);
        }

        items.Clear();
    }

    /// <summary>
    /// 根据坐标获得相应的子空间
    /// </summary>
    /// <param name="pos"></param>
    /// <returns></returns>
    protected QuadTreeNode<T> GetChild(Vector2 pos)
    {
        if (bounds.Contains(pos))
        {
            if (branch != null)
            {
                for (int i = 0; i < branch.Length; i++)
                    if (branch[i].bounds.Contains(pos))
                        return branch[i].GetChild(pos);

            }
            else
                return this;
        }
        return null;
    }
    /// <summary>
    /// 增加叶子节点数据
    /// </summary>
    /// <param name="leaf"></param>
    /// <returns></returns>
    private bool AddNode(QuadTreeLeaf<T> leaf)
    {
        if (branch == null)
        {
            this.items.Add(leaf);

            if (this.items.Count > maxItems)
                Split();
            return true;
        }
        else
        {
            QuadTreeNode<T> node = GetChild(leaf.Pos);
            if (node != null)
            {
                return node.AddNode(leaf);
            }
        }
        return false;
    }

    public bool AddNode(Vector2 pos, T obj)
    {
        return AddNode(new QuadTreeLeaf<T>(pos, obj));
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="pos">可以是空间任意位置，只是根据这个位置找到所在的空间去删除对象</param>
    /// <param name="obj"></param>
    /// <returns></returns>
    public bool RemoveNode(Vector2 pos, T obj)
    {
        if (branch == null)
        {
            for (int i = 0; i < items.Count; i++)
            {
                QuadTreeLeaf<T> qtl = items[i];
                if (qtl.LeafObject.Equals(obj))
                {
                    items.RemoveAt(i);
                    return true;
                }
            }
        }
        else
        {
            QuadTreeNode<T> node = GetChild(pos);
            if (node != null)
            {
                return node.RemoveNode(pos, obj);
            }
        }
        return false;
    }

    public bool UpdateNode(Vector2 pos, T obj)
    {
        // TODO  参找RemoveNode
        return false;
    }

    /// <summary>
    /// 得到在一个Rect内的所有数据
    /// </summary>
    /// <param name="rect"></param>
    /// <param name="nodes"></param>
    /// <returns></returns>
    public int GetNode(Rect rect, ref List<T> nodes)
    {
        if (branch == null)
        {
            foreach (QuadTreeLeaf<T> item in items)
            {
                if (rect.Contains(item.Pos))
                {
                    nodes.Add(item.LeafObject);
                }
            }
        }
        else
        {
            for (int i = 0; i < branch.Length; i++)
            {
                if (branch[i].bounds.Overlaps(rect))
                    branch[i].GetNode(rect, ref nodes);
            }
        }
        return nodes.Count;
    }

    /// <summary>
    /// 根据坐标得到坐标附近节点的数据
    /// </summary>
    /// <param name="pos"></param>
    /// <param name="ShortestDistance">离坐标最短距离</param>
    /// <param name="list"></param>
    /// <returns></returns>
    public int GetNodeRecRange(Vector2 pos, float ShortestDistance, ref List<T> list)
    {
        float distance;
        if (branch == null)
        {
            foreach (QuadTreeLeaf<T> leaf in this.items)
            {
                distance = Vector2.Distance(pos,leaf.Pos);

                if (distance < ShortestDistance)
                {
                    list.Add(leaf.LeafObject);
                }
            }
        }
        else
        {
            for (int i = 0; i < branch.Length; i++)
            {
                float childDistance = branch[i].bounds.PointToBorderDistance(pos);
                if (childDistance < ShortestDistance * ShortestDistance)
                {
                    branch[i].GetNodeRecRange(pos, ShortestDistance, ref list);
                }
            }
        }
        return list.Count;
    }
}

测试代码：

挂在红点和黑点上。

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

public class TestController : MonoBehaviour
{
    public bool IsPlayer = false;

    // Use this for initialization
    void Start()
    {
        TestObj.quadRoot.AddNode(new Vector2(transform.position.x, transform.position.z), this.gameObject);
    }

    // Update is called once per frame
    void Update()
    {
        if (IsPlayer && Input.GetKeyDown(KeyCode.S))
        {
            List<GameObject> list = new List<GameObject>();
            TestObj.quadRoot.GetNodeRecRange(new Vector2(transform.position.x, transform.position.z), 5f, ref list);
            foreach (var item in list)
            {
                Debug.Log(item.name);
            }
        }
    }
}

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

public class TestObj : MonoBehaviour
{
    public static QuadTreeNode<GameObject> quadRoot = new QuadTreeNode<GameObject>(0, 0, 100, 100, 10, 50);
}

TestObj随便挂在一个物体上就可以了。

 

《游戏编程模式》空间分区章节：http://gpp.tkchu.me/spatial-partition.html

四叉树代码参考：http://www.oxox.work/web/recommend/quadtree-c-c/