Unity笔记_行为树

Unity笔记_行为树

行为树(BehaviorTree) 是在游戏中用于控制角色AI的一种实现方式，在游戏AI中对象的动作和行为大部分都是提前设置好的，因此我们要用行为树或者状态机来实现这些对象的决策任务。

以下是行为树中的常见节点

Node节点：一个基本的节点

namespace Behavior_Tree//声明命名空间，将行为树的节点放在该namespace里
{
    public enum NodeState//声明三种节点状态
    {
        Running,
        Success,
        Failure
    }
    
    public class Node
    {
        protected NodeState state;

        public Node parent;
        
        protected List<Node> children=new List<Node>();

        public Node()
        {
            parent = null;
        }
        
        public Node(List<Node> children)//为该节点构造子节点
        {
            foreach(Node child in children)
            {
                _Attach(child);
            }
        }

        private void _Attach(Node node)//添加子节点
        {
            node.parent = this;
            children.Add(node);
        }

        public virtual NodeState Evaluate() => NodeState.Failure;//定义一个虚函数Evaluate，用于执行节点的具体操作，返回节点的状态

    }
}

基类：树（Tree）

namespace Behavior_Tree
{
    public abstract class Tree : MonoBehaviour
    {
        private Node root= null;

        protected void Start()
        {
            root = SetupTree();
        }

        protected void Update()
        {
            if(root != null)
            {
                root.Evaluate();
            }
        }

        protected abstract Node SetupTree();
    }
}

sequence节点（顺序节点）：从左到右依次执行子节点，当一个节点失败时，立刻返回

namespace Behavior_Tree
{
    public class Sequence : Node
    {
        public Sequence():base() { }
        public Sequence(List<Node> children) : base(children) { }
        public override NodeState Evaluate()
        {
            bool anyChildIsRunning = false;

            foreach(Node node in children)
            {
                switch(node.Evaluate())
                {
                    case NodeState.Failure://失败时直接跳出
                        {
                            state = NodeState.Failure;
                            return state;
                        }
                    case NodeState.Success:
                        {
                            continue;
                        }
                    case NodeState.Running:
                        {
                            anyChildIsRunning=true;
                            continue;
                        }
                    default:
                        {
                            state= NodeState.Success;
                            return state;
                        }
                }
            }

            state = anyChildIsRunning ? NodeState.Running : NodeState.Success;
            return state;
        }
    }
}

selector节点（选择节点）：从左到右依次执行子节点，当一个节点成功时，立刻返回

namespace Behavior_Tree
{
    public class Selector : Node
    {
        public Selector() : base() { }
        public Selector(List<Node> children) : base(children) { }
        public override NodeState Evaluate()
        {
            foreach (Node node in children)
            {
                switch (node.Evaluate())
                {
                    case NodeState.Failure:
                        {
                            continue;
                        }
                    case NodeState.Success://成功时直接跳出
                        {
                            state=NodeState.Success;
                            return state;
                        }
                    case NodeState.Running:
                        {
                            state=NodeState.Running;
                            return state;
                        }
                    default:
                        {
                            continue;
                        }
                }
            }

            state = NodeState.Failure;
            return state;
        }
    }
}

ActionNode（行为节点）：用于执行动作

namespace Behavior_Tree
{
    public class ActionNode : Node
    {
        public Func<NodeState> action;//使用返回节点状态执行行为

        public ActionNode(Func<NodeState> action)
        {
            this.action = action;
        }

        public override NodeState Evaluate()
        {
            if(action == null)
            {
                return NodeState.Failure;
            }

            switch (action.Invoke())
            {
                case NodeState.Success:
                    return NodeState.Success;
                case NodeState.Failure:
                    return NodeState.Failure;
                case NodeState.Running:
                    return NodeState.Running;
            }

            return NodeState.Success;

        }
    }
}

ConditionNode（条件节点）：用于判断条件

namespace Behavior_Tree
{
    public class ConditionNode : Node
    {
        public Func<bool> action;//无参有返回值的委托

        public ConditionNode(Func<bool> action)
        {
            this.action = action;
        }

        public override NodeState Evaluate()
        {
            if(action == null)
            {
                return NodeState.Failure;
            }

            return action.Invoke() ? NodeState.Success : NodeState.Failure;
        }


    }
}