码迷，mamicode.com
首页 > 其他好文 > 详细

行为树的设计与实现

时间：2014-05-04 20:58:17      阅读：595      评论：0      收藏：0      [点我收藏+]

标签：style   blog   class   code   java   tar   

原地址：http://blog.csdn.net/luyuncsd123/article/details/18351137

查阅了一些行为树资料，目前最主要是参考了这篇文章，看完后感觉行为树实乃强大，绝对是替代状态机的不二之选。但从理论看起来很简单的行为树，真正着手起来却发现很多细节无从下手。

 

总结起来，就是：

1、行为树只是单纯的一棵决策树，还是决策+控制树。为了防止不必要的麻烦，我目前设计成单纯的决策树。

2、什么时候执行行为树的问题，也就是行为树的Tick问题，是在条件变化的时候执行一次，还是只要对象激活，就在Update里面一直Tick。前者明显很节省开销，但那样设计的最终结果可能是最后陷入事件发送的泥潭中。那么一直Tick可能是最简单的办法，于是就引下面出新的问题。目前采用了一直Tick的办法。

3、基本上可以明显节点有 Composite Node、Decorator Node、Condition Node、Action Node，但具体细节就很头疼。比如组合节点里的Sequence Node。这个节点是不是在每个Tick周期都从头迭代一次子节点，还是记录正在运行的子节点。每次都迭代子节点，就感觉开销有点大。记录运行节点就会出现条件冗余问题，具体后面再讨论。目前采用保存当前运行节点的办法。

4、条件节点（Condition Node）的位置问题。看到很多设计都是条件节点在最后才进行判断，而实际上，如果把条件放在组合节点处，就可以有效短路判断，不再往下迭代。于是我就采用了这种方法。

 

 

设计开始

在Google Code上看到的某个行为树框架，用的是抽象类做节点。考虑到C#不能多继承，抽象类可能会导致某些时候会很棘手，所以还是用接口。虽然目前还未发现接口的好处。

在进行抽象设计的时候，接口的纯粹性虽然看起来更加清晰，不过有时候遇到需要重复使用某些类函数的时候就挺麻烦，让人感觉有点不利于复用。

 

[csharp] view plaincopy
 
 
bubuko.com,布布扣 
public enum RunStatus  
{  
    Completed,  
    Failure,  
    Running,  
}  
  
public interface IBehaviourTreeNode  
{  
    RunStatus status { get; set; }  
    string nodeName { get; set; }  
    bool Enter(object input);  
    bool Leave(object input);  
    bool Tick(object input, object output);  
    RenderableNode renderNode { get; set; }  
    IBehaviourTreeNode parent { get; set; }  
    IBehaviourTreeNode Clone();  
}  
  
/************************************************************************/  
/* 组合结点                                                             */  
/************************************************************************/  
public interface ICompositeNode : IBehaviourTreeNode  
{  
    void AddNode(IBehaviourTreeNode node);  
    void RemoveNode(IBehaviourTreeNode node);  
    bool HasNode(IBehaviourTreeNode node);  
  
    void AddCondition(IConditionNode node);  
    void RemoveCondition(IConditionNode node);  
    bool HasCondition(IConditionNode node);  
  
    ArrayList nodeList { get; }  
    ArrayList conditionList { get; }  
}  
  
/************************************************************************/  
/* 选择节点                                                             */  
/************************************************************************/  
public interface ISelectorNode : ICompositeNode  
{  
  
}  
  
/************************************************************************/  
/*顺序节点                                                              */  
/************************************************************************/  
public interface ISequenceNode : ICompositeNode  
{  
  
}  
  
/************************************************************************/  
/* 平行(并列)节点                                                             */  
/************************************************************************/  
public interface IParallelNode : ICompositeNode  
{  
  
}  
  
//////////////////////////////////////////////////////////////////////////  
  
/************************************************************************/  
/* 装饰结点                                                             */  
/************************************************************************/  
public interface IDecoratorNode : IBehaviourTreeNode  
{  
  
}  
  
/************************************************************************/  
/* 条件节点                                                             */  
/************************************************************************/  
public interface IConditionNode  
{  
    string nodeName { get; set; }  
    bool ExternalCondition();  
}  
  
/************************************************************************/  
/* 行为节点                                                             */  
/************************************************************************/  
public interface IActionNode : IBehaviourTreeNode  
{  
  
}  
  
public interface IBehaviourTree  
{  
      
}
View Code

 

很多节点的接口都是空的，目前唯一的作用就是用于类型判断，很可能在最后也没有什么实际的作用，搞不好就是所谓的过度设计。如果最终确定没有用再删掉吧。

 

接口里出现了一个渲染节点，目的是为了能够更方便的把这个节点和负责渲染的节点联系到一起，方便节点的可视化。

 

如果只有接口，每次实现接口都要重复做很多工作，为了利用面向对象的复用特性，就来实现一些父类

 

 

[csharp] view plaincopy
 
 
bubuko.com,布布扣 
public class BaseNode  
{  
    public BaseNode() { nodeName_ = this.GetType().Name + "\n"; }  
  
    protected RunStatus status_ = RunStatus.Completed;  
    protected string nodeName_;  
    protected RenderableNode renderNode_;  
    protected IBehaviourTreeNode parent_;  
  
    public virtual RunStatus status { get { return status_; } set { status_ = value; } }  
    public virtual string nodeName { get { return nodeName_; } set { nodeName_ = value; } }  
    public virtual RenderableNode renderNode { get { return renderNode_; } set { renderNode_ = value; } }  
    public virtual IBehaviourTreeNode parent { get { return parent_; } set { parent_ = value; } }  
    public virtual IBehaviourTreeNode Clone() {  
        var clone = new BaseNode();  
        clone.status_ = status_;  
        clone.nodeName_ = nodeName_;  
        clone.renderNode_ = renderNode_;  
        clone.parent_ = parent_;  
        return clone as IBehaviourTreeNode;  
    }  
}  
  
public class BaseActionNode : IActionNode  
{  
    public BaseActionNode() { nodeName_ = this.GetType().Name + "\n"; }  
    protected RunStatus status_ = RunStatus.Completed;  
    protected string nodeName_;  
    protected RenderableNode renderNode_;  
    protected IBehaviourTreeNode parent_;  
    public virtual RunStatus status { get { return status_; } set { status_ = value; } }  
    public virtual string nodeName { get { return nodeName_; } set { nodeName_ = value; } }  
    public virtual RenderableNode renderNode { get { return renderNode_; } set { renderNode_ = value; } }  
    public virtual IBehaviourTreeNode parent { get { return parent_; } set { parent_ = value; } }  
    public virtual IBehaviourTreeNode Clone()  
    {  
        var clone = new BaseActionNode();  
        clone.status_ = status_;  
        clone.nodeName_ = nodeName_;  
        clone.renderNode_ = renderNode_;  
        clone.parent_ = parent_;  
        return clone as IBehaviourTreeNode;  
    }  
  
    public virtual bool Enter(object input)  
    {  
        status_ = RunStatus.Running;  
        return true;  
    }  
  
    public virtual bool Leave(object input)  
    {  
        status_ = RunStatus.Completed;  
        return true;  
    }  
  
    public virtual bool Tick(object input, object output)  
    {  
        return true;  
    }  
}  
public class BaseCondictionNode {  
    protected string nodeName_;  
    public virtual string nodeName { get { return nodeName_; } set { nodeName_ = value; } }  
    public BaseCondictionNode() { nodeName_ = this.GetType().Name+"\n"; }  
    public delegate bool ExternalFunc();  
    protected ExternalFunc externalFunc;  
    public static ExternalFunc GetExternalFunc(BaseCondictionNode node) {  
        return node.externalFunc;  
    }  
}  
  
public class Precondition : BaseCondictionNode, IConditionNode{  
    public Precondition(ExternalFunc func) { externalFunc = func; }  
    public Precondition(BaseCondictionNode pre) { externalFunc = BaseCondictionNode.GetExternalFunc(pre); }  
    public bool ExternalCondition()  
    {  
        if (externalFunc != null) return externalFunc();  
        else return false;  
    }  
}  
  
public class PreconditionNOT : BaseCondictionNode, IConditionNode  
{  
    public PreconditionNOT(ExternalFunc func) { externalFunc = func; }  
    public PreconditionNOT(BaseCondictionNode pre) { externalFunc = BaseCondictionNode.GetExternalFunc(pre); }  
    public bool ExternalCondition()  
    {  
        if (externalFunc != null) return !externalFunc();  
        else return false;  
    }  
}  
  
public class BaseCompositeNode : BaseNode{  
    protected ArrayList nodeList_ = new ArrayList();  
    protected ArrayList conditionList_ = new ArrayList();  
    protected int runningNodeIndex = 0;  
    protected bool CheckNodeAndCondition() {  
        if (nodeList_.Count == 0)  
        {  
            status_ = RunStatus.Failure;  
            Debug.Log("SequenceNode has no node!");  
            return false;  
        }  
        return CheckCondition();  
    }  
    protected bool CheckCondition() {  
        foreach (var node in conditionList_)  
        {  
            var condiction = node as IConditionNode;  
            if (!condiction.ExternalCondition())  
                return false;  
        }  
        return true;  
    }  
    public virtual void AddNode(IBehaviourTreeNode node) { node.parent = (IBehaviourTreeNode)this; nodeList_.Add(node); }  
    public virtual void RemoveNode(IBehaviourTreeNode node) { nodeList_.Remove(node); }  
    public virtual bool HasNode(IBehaviourTreeNode node) { return nodeList_.Contains(node); }  
  
    public virtual void AddCondition(IConditionNode node) { conditionList_.Add(node); }  
    public virtual void RemoveCondition(IConditionNode node) { conditionList_.Remove(node); }  
    public virtual bool HasCondition(IConditionNode node) { return conditionList_.Contains(node); }  
  
    public virtual ArrayList nodeList { get { return nodeList_; } }  
    public virtual ArrayList conditionList { get { return conditionList_; } }  
  
    public override IBehaviourTreeNode Clone()  
    {  
        var clone = base.Clone() as BaseCompositeNode;  
        clone.nodeList_.AddRange(nodeList_);  
        clone.conditionList_.AddRange(conditionList_);  
        clone.runningNodeIndex = runningNodeIndex;  
        return clone as IBehaviourTreeNode;  
    }  
}
View Code

 

 

 

然后实现具体的节点，先是序列节点

 

[csharp] view plaincopy
 
 
bubuko.com,布布扣
public class SequenceNode : BaseCompositeNode, ISequenceNode  
{  
    public SequenceNode(bool canContinue_ = false) { canContinue = canContinue_; }  
    public bool canContinue = false;  
  
  
    public bool Enter(object input)  
    {  
        var checkOk = CheckNodeAndCondition();  
        if (!checkOk) return false;  
        var runningNode = nodeList_[runningNodeIndex] as IBehaviourTreeNode;  
        checkOk = runningNode.Enter(input);  
        if (!checkOk) return false;  
        status_ = RunStatus.Running;  
        return true;  
    }  
  
    public bool Leave(object input)  
    {  
        if (nodeList_.Count == 0)  
        {  
            status_ = RunStatus.Failure;  
            Debug.Log("SequenceNode has no node!");  
            return false;  
        }  
        var runningNode = nodeList_[runningNodeIndex] as IBehaviourTreeNode;  
        runningNode.Leave(input);  
        if (canContinue)  
        {  
            runningNodeIndex++;  
            runningNodeIndex %= nodeList_.Count;  
        }  
        status_ = RunStatus.Completed;  
        return true;  
    }  
  
    public bool Tick(object input, object output)  
    {  
        if (status_ == RunStatus.Failure) return false;  
        if (status_ == RunStatus.Completed) return true;  
          
        var runningNode = nodeList_[runningNodeIndex] as IBehaviourTreeNode;  
        var checkOk = CheckCondition();  
        if (!checkOk)  
        {  
            return false;  
        }  
  
        switch (runningNode.status)  
        {  
            case RunStatus.Running:  
                if (!runningNode.Tick(input, output))  
                {  
                    runningNode.Leave(input);  
                    return false;  
                }  
  
                break;  
            default:  
                runningNode.Leave(input);  
                runningNodeIndex++;  
                if(runningNodeIndex >= nodeList_.Count)break;  
                var nextNode = nodeList_[runningNodeIndex] as IBehaviourTreeNode;  
                var check = nextNode.Enter(input);  
                if (!check) return false;  
                break;  
        }  
        return true;  
    }  
  
    public override IBehaviourTreeNode Clone()  
    {  
        var clone = base.Clone() as SequenceNode;  
        clone.canContinue = canContinue;  
        return clone;  
    }  
}
bubuko.com,布布扣

 

这就是序列节点的设计，但是明显看起来很不爽，里面还出现了一个别扭的变量canContinue 。为什么会出现这个？因为序列节点的特点就是遇到一个子节点FALSE，就会停止并返回FALSE，但是这里我想用序列节点来做根节点，如果是根节点遇到这种情况，那么就不会执行下一个节点，而我看了很多种对于几大节点的描述，似乎都没提到这个。很多都用序列节点做根节点，有些就直接说是根节点。那么要么根节点另外实现，要么改一下序列节点。因为如果序列节点是非根节点的情况下，如果不是每次都从头开始，似乎又会引来新的问题，虽然目前还没想到会出什么问题。不过最后实现执行起来之后发现，用选择节点其实是一样的。所以目前这样的设计，可能是有根本上的问题。希望哪位大神可以指点一下。

 

然后是选择节点，根据了所有FALSE才返回FALSE的特点设计了

 

[csharp] view plaincopy
 
 
bubuko.com,布布扣 
public class SelectorNode : BaseCompositeNode, ISelectorNode  
{  
    public bool Enter(object input)  
    {  
        var checkOk = CheckNodeAndCondition();  
        if (!checkOk) return false;  
         
        do  
        {  
            var runningNode = nodeList_[runningNodeIndex] as IBehaviourTreeNode;  
            checkOk = runningNode.Enter(input);  
            if (checkOk) break;  
            runningNodeIndex++;  
            if (runningNodeIndex >= nodeList_.Count) return false;  
        } while (!checkOk);  
          
        status_ = RunStatus.Running;  
        return true;  
    }  
  
    public bool Leave(object input)  
    {  
        var runningNode = nodeList_[runningNodeIndex] as IBehaviourTreeNode;  
        runningNode.Leave(input);  
        runningNodeIndex = 0;  
        status_ = RunStatus.Completed;  
        return true;  
    }  
  
    public bool Tick(object input, object output)  
    {  
        if (status_ == RunStatus.Failure) return false;  
        if (status_ == RunStatus.Completed) return true;  
        var checkOk1 = CheckCondition();  
        if (!checkOk1) return false;  
        var runningNode = nodeList_[runningNodeIndex] as IBehaviourTreeNode;  
        switch (runningNode.status)  
        {  
            case RunStatus.Running:  
                if (!runningNode.Tick(input, output))  
                {  
                    runningNode.Leave(input);  
                    return false;  
                }  
  
                break;  
            default:  
                runningNode.Leave(input);  
                runningNodeIndex++;  
                if (runningNodeIndex >= nodeList_.Count) return false;  
  
                bool checkOk = false;  
                do  
                {  
                    var nextNode = nodeList_[runningNodeIndex] as IBehaviourTreeNode;  
                    checkOk = nextNode.Enter(input);  
                    if (checkOk) break;  
                    runningNodeIndex++;  
                    if (runningNodeIndex >= nodeList_.Count) return false;  
                } while (!checkOk);  
                break;  
        }  
        return true;  
    }  
}
View Code

 

目前对于我的简单DEMO，组合节点只需要这两个就够了，实际上只需要选择节点、条件节点、动作节点就够了。所以说设计是不完全的，虽然能够实现目标需求，但是实际工作量仍挺大，具体接下来会说明。

 

行为节点

 

 

先放一些渲染节点的代码。实际上我基本上是第一次接触自己去渲染一种数据结构，看完网上的大牛们随随便便就能写出个数据结构的示意图，不得不佩服。我一时半会没想出怎么渲染出树状结构，于是就简单的把树按层分组，一层一层渲染，缺点就是不能很好的表现树的样子，父子关系不能很好的表示。这里放出来希望能抛砖引玉。我以后可能会去完事它，但是现在首先是要搞清楚行为树。实现这个完全是为了看看节点是否正确放置，以方便调试。

 

[csharp] view plaincopy
 
bubuko.com,布布扣 
 
public class RenderableNode  
{  
    public RenderableNode parent;  
    public IBehaviourTreeNode targetNode;  
    public Rect posRect = new Rect();  
    public string name;  
    public int layer;  
    public RunStatus staus;  
    public override string ToString()  
    {  
        return name + "\n" + staus.ToString();  
    }  
    public virtual void Render()  
    {  
        bool running = staus == RunStatus.Running;  
        var rect = posRect;  
        rect.y -= (posRect.height / 2);  
  
        var oldColor = GUI.color;  
         if (running)  
        {  
            GUI.color = Color.green;  
        }  
        GUI.Box(rect, ToString());  
        GUI.color = oldColor;  
  
        if (parent == null && targetNode != null && targetNode.parent!=null)  
        {  
            parent = targetNode.parent.renderNode;  
        }  
        if (parent != null)  
        {  
            Vector2 parentPos = new Vector2();  
            parentPos.x = parent.posRect.x + parent.posRect.width;  
            parentPos.y = parent.posRect.y;  
            GUIHelper.DrawLine(new Vector2(rect.x, rect.y + rect.height / 2), parentPos, running?Color.green:Color.yellow);  
        }  
          
    }  
}  
  
public class RenderableCondictionNode : RenderableNode  
{  
    public IConditionNode targetCondictionNode;  
    public override string ToString() { parent = null; return name; }  
    public override void Render()  
    {  
        var rect = posRect;  
        rect.y -= (posRect.height / 2);  
  
        var oldColor = GUI.color;  
        if (targetCondictionNode.ExternalCondition())  
            GUI.color = Color.green;  
        else  
            GUI.color = Color.blue;  
        GUI.Box(rect, ToString());  
        GUI.color = oldColor;  
    }  
}  
  
public class EmptyNode : RenderableNode { public override void Render() { } }  
  
public class NodeBox  
{  
    public Rect posRect = new Rect();  
    public List<RenderableNode> nodeList = new List<RenderableNode>();  
    public void AddNode(RenderableNode node)  
    {  
        nodeList.Add(node);  
    }  
    public void Render()  
    {  
        posRect.y = Screen.height / 2;  
        Rect rect = new Rect();  
  
        foreach (var node in nodeList)  
        {  
            var n = node;  
            rect.height += (n.posRect.height + 1);  
            rect.width = n.posRect.width + 10;  
        }  
        rect.height += 10;  
        rect.x = posRect.x - rect.width / 2;  
        rect.y = posRect.y - rect.height / 2;  
        //GUI.Box(rect, "");  
        posRect.width = rect.width;  
        posRect.height = rect.height;  
        float height = 0;  
        for (var i = 0; i < nodeList.Count; i++)  
        {  
            var n = nodeList[i];  
            n.posRect.y = rect.y + height + n.posRect.height / 2 + 5;  
            n.posRect.x = rect.x + 5;  
            n.Render();  
            height += n.posRect.height + 1;  
        }  
    }  
}
View Code

 

 

 

放一张渲染出来的效果

bubuko.com,布布扣

虽然每一组都只是简单的居中，不过效果看起来还可以接受

 

 

然后从图中就可以看到问题了。所有正条件，都会有一个反条件，不这么做就无法在条件改变时，让当前节点返回FALSE，从而让行为树去寻找其他节点。而如果用状态机来做的话，条件肯定只用判断一次，比如

 

[csharp] view plaincopy
 
  
if(run){  
   Run();  
}  
else{  
   Walk();  
}

 

那么可能就回到最初的组合节点的设计了，组合节点就不得不每次都扫描条件。其实本质上我是在担心开销问题，因为变成节点后，就不在是if else那么简单，而是变成了函数调用的开销。简单的AI还好，如果大量复杂的AI，每次对整棵树进行扫描估计够呛。但是目前的设计，条件节点就会非常多，条件不完备就会出现BUG，似乎也不是非常好的情况。

 

 

 

最后放出一些细节

 

[csharp] view plaincopy
 
bubuko.com,布布扣 
 
class PatrolAction : BaseActionNode {  
  
        public PatrolAction() { nodeName_ += "巡逻行为"; }  
  
        public override bool Tick(object input_, object output_)  
        {  
           // var input = input_ as WarriorInputData;  
            var output = output_ as WarriorOutPutData;  
            output.action = WarriorActon.ePatrol;  
            return true;  
        }  
    }  
  
    class RunAwayAction : BaseActionNode {  
        public RunAwayAction() { nodeName_ += "逃跑行为"; }  
  
        public override bool Tick(object input_, object output_)  
        {  
            // var input = input_ as WarriorInputData;  
            var output = output_ as WarriorOutPutData;  
            output.action = WarriorActon.eRunAway;  
            return true;  
        }  
    }  
  
    class AttackAction : BaseActionNode {  
        public AttackAction() { nodeName_ += "攻击行为"; }  
  
        public override bool Tick(object input_, object output_)  
        {  
            // var input = input_ as WarriorInputData;  
            var output = output_ as WarriorOutPutData;  
            output.action = WarriorActon.eAttack;  
            return true;  
        }  
    }  
  
    class CrazyAttackAction : BaseActionNode {  
        public CrazyAttackAction() { nodeName_ += "疯狂攻击行为"; }  
  
        public override bool Tick(object input_, object output_)  
        {  
            // var input = input_ as WarriorInputData;  
            var output = output_ as WarriorOutPutData;  
            output.action = WarriorActon.eCrazyAttack;  
            return true;  
        }  
    }  
  
    class AlertAction : BaseActionNode  
    {  
        public AlertAction() { nodeName_ += "警戒行为"; }  
        public override bool Tick(object input_, object output_)  
        {  
            // var input = input_ as WarriorInputData;  
            var output = output_ as WarriorOutPutData;  
            output.action = WarriorActon.eAlert;  
            return true;  
        }  
    }  



 

 

[csharp] view plaincopy
 
 
private ICompositeNode rootNode = new SelectorNode();  
    private WarriorInputData inputData = new WarriorInputData();  
    private WarriorOutPutData outputData = new WarriorOutPutData();  
    // Use this for initialization  
    public void Start()  
    {  
        inputData.attribute = GetComponent<CharacterAttribute>();  
  
        rootNode.nodeName += "根";  
  
        //条件  
        var hasNoTarget = new PreconditionNOT(() => { return inputData.attribute.hasTarget; });  
        hasNoTarget.nodeName = "无目标";  
        var hasTarget = new Precondition(hasNoTarget);  
        hasTarget.nodeName = "发现目标";  
        var isAnger = new Precondition(() => { return inputData.attribute.isAnger; });  
        isAnger.nodeName = "愤怒状态";  
        var isNotAnger = new PreconditionNOT(isAnger);  
        isNotAnger.nodeName = "非愤怒状态";  
        var HPLessThan500 = new Precondition(() => { return inputData.attribute.health < 500; });  
        HPLessThan500.nodeName = "血少于500";  
        var HPMoreThan500 = new PreconditionNOT(HPLessThan500);  
        HPMoreThan500.nodeName = "血大于500";  
        var isAlert = new Precondition(() => { return inputData.attribute.isAlert; });  
        isAlert.nodeName = "警戒";  
        var isNotAlert = new PreconditionNOT(isAlert);  
        isNotAlert.nodeName = "非警戒";  
  
  
        var patrolNode = new SequenceNode();  
        patrolNode.nodeName += "巡逻";  
        patrolNode.AddCondition(hasNoTarget);  
        patrolNode.AddCondition(isNotAlert);  
        patrolNode.AddNode(new PatrolAction());  
  
        var alert = new SequenceNode();  
        alert.nodeName += "警戒";  
        alert.AddCondition(hasNoTarget);  
        alert.AddCondition(isAlert);  
        alert.AddNode(new AlertAction());  
          
        var runaway = new SequenceNode();  
        runaway.nodeName += "逃跑";  
        runaway.AddCondition(hasTarget);  
        runaway.AddCondition(HPLessThan500);  
        runaway.AddNode(new RunAwayAction());  
  
        var attack = new SelectorNode();  
        attack.nodeName += "攻击";  
        attack.AddCondition(hasTarget);  
        attack.AddCondition(HPMoreThan500);  
  
        var attackCrazy = new SequenceNode();  
        attackCrazy.nodeName += "疯狂攻击";  
        attackCrazy.AddCondition(isAnger);  
        attackCrazy.AddNode(new CrazyAttackAction());  
        attack.AddNode(attackCrazy);  
  
        var attackNormal = new SequenceNode();  
        attackNormal.nodeName += "普通攻击";  
        attackNormal.AddCondition(isNotAnger);  
        attackNormal.AddNode(new AttackAction());  
        attack.AddNode(attackNormal);  
  
        rootNode.AddNode(patrolNode);  
        rootNode.AddNode(alert);  
        rootNode.AddNode(runaway);  
        rootNode.AddNode(attack);  
        var ret = rootNode.Enter(inputData);  
        if (!ret)  
        {  
            Debug.Log("无可执行节点！");  
        }  
    }  
      
    // Update is called once per frame  
    void Update () {  
        var ret = rootNode.Tick(inputData, outputData);  
  
        if (!ret)  
            rootNode.Leave(inputData);  
  
        if (rootNode.status == RunStatus.Completed)  
        {  
            ret = rootNode.Enter(inputData);  
            if (!ret)  
                rootNode.Leave(inputData);  
        }  
        else if (rootNode.status == RunStatus.Failure)  
        {  
            Debug.Log("BT Failed");  
            enabled = false;  
        }  
  
        if (outputData.action != inputData.action)  
        {  
            OnActionChange(outputData.action, inputData.action);  
            inputData.action = outputData.action;  
        }  
    }  
  
    void OnActionChange(WarriorActon action, WarriorActon lastAction) {  
      //  print("OnActionChange "+action+" last:"+lastAction);  
        switch (lastAction)  
        {  
            case WarriorActon.ePatrol:  
                GetComponent<WarriorPatrol>().enabled = false;  
                break;  
            case WarriorActon.eAttack:  
            case WarriorActon.eCrazyAttack:  
                GetComponent<WarriorAttack>().enabled = false;  
                break;  
            case WarriorActon.eRunAway:  
                GetComponent<WarriorRunAway>().enabled = false;  
                break;  
            case WarriorActon.eAlert:  
                GetComponent<WarriorAlert>().enabled = false;  
                break;  
        }  
  
        switch (action) {   
            case WarriorActon.ePatrol:  
                GetComponent<WarriorPatrol>().enabled = true;  
                break;  
            case WarriorActon.eAttack:  
                var attack = GetComponent<WarriorAttack>();  
                attack.revenge = false;  
                attack.enabled = true;  
                break;  
            case WarriorActon.eCrazyAttack:  
                var crazyAttack = GetComponent<WarriorAttack>();  
                crazyAttack.revenge = true;  
                crazyAttack.enabled = true;  
                break;  
            case WarriorActon.eRunAway:  
                GetComponent<WarriorRunAway>().enabled = true;  
                break;  
            case WarriorActon.eAlert:  
                GetComponent<WarriorAlert>().enabled = true;  
                break;  
            case WarriorActon.eIdle:  
                GetComponent<WarriorPatrol>().enabled = false;  
                GetComponent<WarriorAttack>().enabled = false;  
                GetComponent<WarriorRunAway>().enabled = false;  
                break;  
        }  
    }
View Code

 

行为树的设计与实现,布布扣,bubuko.com

行为树的设计与实现

标签：style   blog   class   code   java   tar   

原文地址：http://www.cnblogs.com/123ing/p/3706159.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！