Unity-行为树

using System.Collections.Generic;

namespace BhTree
{
    public class BhBaseNode
    {
        public int id;

        protected BhResult result;

        private BhBaseNode _parent;

        protected List<BhBaseNode> children = new List<BhBaseNode>();

        protected int currentChildIndex;

        public void SetResult(BhResult res)
        {
            result = res;
        }

        public BhResult GetResult()
        {
            return result;
        }

        /// <summary>
        /// 添加子节点
        /// </summary>
        /// <param name="node"></param>
        public void AddChild(BhBaseNode node)
        {
            children.Add(node);
            node._parent = this;
        }

        /// <summary>
        /// 获取所有子节点
        /// </summary>
        /// <returns></returns>
        public List<BhBaseNode> GetChildren()
        {
            return children;
        }

        /// <summary>
        /// 获取当前子节点索引
        /// </summary>
        /// <returns></returns>
        public int GetCurIndex()
        {
            return currentChildIndex;
        }

        public void SetCurIndex(int index)
        {
            currentChildIndex = index;
        }

        /// <summary>
        /// 获取父节点
        /// </summary>
        /// <returns></returns>
        public BhBaseNode GetParent()
        {
            return _parent;
        }

        public virtual void Init(dynamic data)
        {

        }

        public virtual void Run()
        {
        }

        /// <summary>
        /// 检测运行结果是否会终止执行状态
        /// </summary>
        /// <param name="res"></param>
        /// <returns></returns>
        public virtual bool CheckState(BhResult res)
        {
            return true;
        }

        public virtual bool CheckStop()
        {
            return true;
        }

        public virtual void Reset()
        {
            currentChildIndex = 0;
            result = BhResult.Running;
        }
    }
}

/// <summary>
/// 创建行为树
/// </summary>
/// <param name="json"></param>
/// <returns></returns>
public BhBaseNode InitBHNode(SaveJson json)
{
    var data = json.data;

    string typeName = "BhTree." + data.node;

    Type type = Type.GetType(typeName);

    BhBaseNode node = Activator.CreateInstance(type) as BhBaseNode;

    //初始化数据
    node?.Init(data);

    node.id = _id++;

    foreach (var child in json.children)
    {
        node?.AddChild(InitBHNode(child));
    }

    return node;
}

public void Run(BhBaseNode node)
{
    if (node == null) return;

    BhBaseNode root = node;

    BhBaseNode curNode;

    _curNode.TryGetValue(node, out curNode);

    if (curNode != null)
    {
        node = curNode;
    }

    RunNode(node, root);
}

private void RunNode(BhBaseNode node, BhBaseNode root, BhBaseNode parent = null)
{
    if (node == null)
    {
        Debug.Log("一次执行结束");
        _curNode[root] = null;
        root.Reset();
        return;
    }

    if (node == parent)
    {
        return;
    }

    var children = node.GetChildren();

    if (children.Count != 0)
    {
        bool interrupt = node.GetInterruptCheck();
        int index = interrupt && node.GetResult() == BhResult.Running ? 0 : node.GetCurIndex();
        BhResult res;

        for (int i = index; i < children.Count; i++)
        {
            var child = children[i];
            RunNode(child, root, node);

            child.Run();
            res = child.GetResult();

            if (!node.CheckState(res) || i == children.Count - 1)
            {
                node.SetCurIndex(i);
                node.SetResult(res);
                break;
            }
        }

        if (node.CheckStop())
        {
            RunNode(node.GetParent(), root, parent);
        }
        else
        {
            if (!interrupt)
            {
                _curNode[root] = node;
            }
            else
            {
                //如果当前节点可打断，向上查找到最后一个能打断的节点并存入
                BhBaseNode baseNode = node;
                BhBaseNode tempNode = null;
                while (baseNode.GetInterruptCheck())
                {
                    tempNode = baseNode;
                    baseNode = baseNode.GetParent();
                }

                _curNode[root] = tempNode;
            }
        }
    }
}

public class BlackboardManager<T> : Singleton<BlackboardManager<T>>
{
    private Dictionary<string, T> _blackboard = new Dictionary<string, T>();

    public void SetBlackboard(string key, T data)
    {
        _blackboard[key] = data;
    }

    public T GetBlackboard(string key)
    {
        _blackboard.TryGetValue(key, out var data);
        return data;
    }
}

public class SaveJson
{
    public List<SaveJson> children = new List<SaveJson>();

    public dynamic data;
}

public static SaveJson Load(string path)
{
    string jsonData = FileUtils.ReadFile(path);

    SaveJson json = JsonConvert.DeserializeObject<List<SaveJson>>(jsonData)[0];

    Deserialize(json);

    return json;
}

/// <summary>
/// 反序列化
/// </summary>
/// <param name="parent"></param>
private static void Deserialize(SaveJson parent)
{
    dynamic obj = new ExpandoObject();
    foreach (var res in (parent.data as JObject).Properties())
    {
        JTokenType jType = res.Value.Type;

        // ConsoleUtils.Log(dataObj);
        switch (jType)
        {
            case JTokenType.String:
                ((IDictionary<string, object>)obj)[res.Name] = res.Value.Value<string>();
                break;
            case JTokenType.Float:
                ((IDictionary<string, object>)obj)[res.Name] = res.Value.Value<float>();
                break;
            case JTokenType.Integer:
                ((IDictionary<string, object>)obj)[res.Name] = res.Value.Value<int>();
                break;
            case JTokenType.Boolean:
                ((IDictionary<string, object>)obj)[res.Name] = res.Value.Value<bool>();
                break;
        }
    }

    parent.data = obj;

    foreach (var child in parent.children)
    {
        Deserialize(child);
    }
}