其中‘附件’有前置和后置，可以添加到任何一个节点作为前置和后置。前置往往是作为前提条件（precondition）来使用，而后置往往是当节点结束的时候施加效果（effects）。

其中‘组合’，‘装饰器’ 类都是分支节点，‘动作’ 类，和‘条件’类大都是子节点， 而‘条件’类中的‘或’、‘与’是分支节点。

需要指出的是，有些节点类型通过其他更基本类型的节点的组合也可以实现。这里提供的节点类型只是使用起来可能会更方便，更直观些。用户可以根据自己的偏好选择使用与否。 用户也可以选择扩展节点类型提供扩展功能或者快捷方式，请参考‘教程’ 中的相关章节。 同时如果根本不打算使用某些节点类型，可以在 config.xml 里配置后就不会出现在可选的列表里了，请参考配置Config.xml。

Sequence 节点是 BT 中传统的组合节点之一。 该节点以给定的顺序依次执行其子节点，直到所有子节点成功返回，该节点也返回成功。只要其中某个子节点失败，那么该节点也失败。

Sequence 实现了与（&&）的功能。我们知道表达式 R=A&&B&&C&&D 执行的时候首先执行 A，如果 A 是 false 则返回 false，如果 A 是 true 则执行 B，如果 B 是 false 则返回 false，否则如果 B 是 true 则执行 C，如果 C 是 false 则返回 false，否则如果 C 是 true 则执行 D，并且返回D 的值。

最一般的意义上， Sequence 节点实现了一个序列。 实际上， Sequence 节点不仅可以管理‘动作’子节点，也可以管理‘条件’子节点。 如上图的应用中， 如果1和2号节点是条件节点的话，这两个条件节点实际上用作进入下面其他节点的 precondition，只有这两个条件是 true，下面的其他节点才有可能执行。

此外， Sequence 上还可以添加‘中断条件’作为终止执行的条件。上图中红框所示就是可选的‘中断条件’。该‘中断条件’在每处理下一个子节点的时候被检查，当为true时，则不再继续，返回失败（Failure）。

具体的执行逻辑可以查看 behaviortree/nodes/composites/sequence.cpp

Selector 节点是 BT 中传统的组合节点之一。 该节点以给定的顺序依次调用其子节点，直到
其中一个成功返回，那么该节点也返回成功。如果所有的子节点都失败，那么该节点也失败。

Selector 实现了或（‘||’）的功能。 我们知道表达式 R=A||B||C||D 执行的时候首先执行 A，如果
A 是 true 则返回 true，如果 A 是 false 则执行 B，如果 B 是 true 则返回 true，否则如果 B 是
false 则执行 C，如果 C 是 true 则返回 true，否则如果 C 是 false 则执行 D， 并且返回 D 的值。
最一般的意义上， Selector 节点实现了一个选择，从子节点中选择一个。 Selector 节点优先
选择了排在前面的子节点。

此外， Selector 上还可以添加‘中断条件’作为终止执行的条件。上图中红框所示就是可选的‘中断条件’。该‘中断条件’在每处理下一个子节点的时候被检查，当为true时，则不再继续，返回失败（Failure）。

具体的执行逻辑可以查看 behaviortree/nodes/composites/selector.cpp

在选择或序列节点中，是顺序的一个接一个的执行其子节点，上一个子节点执行结束后，根据其状态是否执行接下来的子节点。而并行节点在逻辑上是“同时”并行的执行所有子节点（但实际也是从上往下依次执行），然后根据所有子节点的状态决定本身的状态。

注意：并行节点每帧都有可能执行所有的子树，大量使用的时候请注意其性能。

如何根据所有子节点的返回状态，来决定并行节点本身的状态呢？并行节点有几个重要属性可以配置，如下图所示：

• 失败条件：决定并行节点在什么条件下是失败的
• 成功条件：决定并行节点在什么条件下是成功的
• 子节点结束继续条件：子节点结束后是重新再循环执行，还是结束后不再执行
• 退出行为：当并行节点的成功或失败条件满足并返回成功或失败后，是否需要终止掉其他还在运行的子节点
• 当子节点执行状态既不满足失败条件，也不满足成功条件，且无Running状态子节点时，并行节点将直接返回Failure

在序列节点中，假设其子节点包括了条件节点和其他节点。那么，条件节点实际上是作为其他节点的前提条件，只有条件节点返回Success，下面的其他节点才会得到执行。

并行节点可以用来实现所谓的“上下文相关的前提条件”（context precondition），如下图所示：

并行节点配置条件节点和其他节点，并且失败条件是缺省的配置FAIL_ON_ONE，那么只有当条件节点成功的时候其他节点才被执行，从而条件节点事实上是其他节点的前提条件。

注意：作为前提条件的这种用法是不严谨的，当条件失败的时候，在并行节点返回失败之前，后续的其他节点会多执行一次。所以，请使用“前置”附件来实现这种前置条件的需求。

与序列节点+条件节点方式的不同之处在于，序列节点实现的前提条件只是“进入”其他节点的前提条件，一旦首次进入并开始执行其他节点后，就不再检查该前提条件了。而并行节点实现的前提条件是上下文相关的，不但首次进入并开始执行前需要检查，之后每次执行也都要检查。

具体的执行逻辑可以查看 behaviortree/nodes/composites/parallel.cpp

动作节点通常对应Agent的某个方法（Method），可以从下拉列表里为其选择方法，如下图所示：

在设置其方法后，需进一步设置其“决定状态的选项（Status Option）”或“决定状态的函数（Status Functor）”，如上图所示。如果没有正确配置，则视为错误不能被导出。

• “决定状态的选项”：不管动作的方法的返回值是什么，都强制返回设定的EBTStatus值（即Success、Failure或Running）。
• “决定状态的函数”：将动作的方法的返回值从不是EBTStatus类型，转换为执行行为树所需要的EBTStatus值（即Success、Failure或Running）。

有三种设置来决定每次执行动作节点后的状态（Success、Failure或Running）：

• 如果动作节点的方法返回EBTStatus值，那么该值就直接作为动作节点的状态，“决定状态的选项”和“决定状态的函数”将被禁用无需设置。
• 否则，需要设置“决定状态的选项”：当选择Invalid值时，表明需要进一步设置“决定状态的函数”，否则禁用“决定状态的函数”项，并直接使用“决定状态的选项”所选择的值（Success、Failure或Running），表示该方法执行完毕后，动作节点将返回这个设置的值。
• 在“决定状态的函数”项中选择的函数，其返回值必然是EBTStatus，作为动作节点的状态。该函数只有一个或者没有参数，当动作节点的方法无返回值时，该函数没有参数，当动作节点的方法有返回值时，该函数唯一参数的类型为动作节点方法的返回值类型。也即，
  • 当方法的原型是void Method(…)的时候，“决定状态的函数”的原型为：EBTStatus StatusFunctor()。
  • 当方法的原型是ReturnType Method(…)的时候，“决定状态的函数”的原型为：EBTStatus StatusFunctor(ReturnType param)。

具体的执行逻辑可以查看behaviortree/nodes/actions/action.cpp

图1 条件节点

条件节点根据比较结果返回成功或失败，但永远不会返回正在执行（Running）：

• 如果结果为真，则返回成功。
• 如果结果为假，则返回失败。

通常左参数是Agent的某个属性或某个有返回值的方法，用户可以从下拉列表里选择，右参数是相应类型的常数、Agent的某个属性或某个有返回值的方法，如下图所示：

图2 条件节点的属性

条件节点没有提供取反的属性。如果需要取反，请用《非（Not）节点》来装饰。

具体的执行逻辑可以查看behaviortree/nodes/conditions/condition.cpp

装饰节点作为控制分支节点，必须且只接受一个子节点。装饰节点的执行首先执行子节点，并根据自身的控制逻辑以及子节点的返回结果决定自身的状态。

装饰节点都有属性“子节点结束时作用（DecorateChildEnds）”可以配置，如果该值配置为真，则仅当子节点结束（成功或失败）的时候，装饰节点的装饰逻辑才起作用。

输出消息（Log）节点

输出消息节点作为调试的辅助工具，执行完子节点后，输出配置的消息，如下图所示：

可以在“输出消息”属性中设置想输出的任何消息，如下图所示：

具体的执行逻辑可以查看behaviortree/nodes/decorators/decoratorlog.cpp

非（Not）节点

非节点将子节点的返回值取反，如下图所示：

类似于逻辑“非”操作，非节点对子节点的返回值执行如下操作：

• 如果子节点失败，那么此节点返回成功。
• 如果子节点成功，那么此节点返回失败。
• 如果子节点返回正在执行，则同样返回正在执行。

具体的执行逻辑可以查看behaviortree/nodes/decorators/decoratornot.cpp

循环（Loop）节点

循环节点循环执行子节点指定的次数，如下图所示：

如下图可以配置循环节点的相关参数：

• 次数：如果次数配置为-1，则视为无限循环，总是返回运行。否则循环执行子节点指定的次数然后返回成功，在指定次数之前则返回运行。
• 此循环次数可以是常数，也可以是变量，当是变量的时候，每次enter的时候此循环次数被赋值，也就是每次enter的时候，循环的次数就被确定了。之后再更改该变量的值在本次循环内将不起作用，但是exit后再enter的时候会起作用。
• 一帧内结束：如果选择了‘一帧内结束’，次数不可以配置为-1，节点阻塞，直到子节点在一帧内执行指定的次数后返回成功。
  • 然而如果子节点失败了，不会执行指定次数就直接返回失败。
  • 如果子节点一直返回运行，则本节点一直阻塞。但如果“子节点结束时作用”不为真，则不会阻塞。
  • 在‘一帧内结束’的情况下，本节点只能成功或失败，不会返回运行。
  • ‘一帧内结束’的配置只在3.5.4及以后的版本中才有实现。用以取代重复节点

具体的执行逻辑可以查看behaviortree/nodes/decorators/decoratorloop.cpp

循环直到（LoopUntil）节点

循环直到节点在指定的次数到达后返回成功，在指定的次数到达前一直返回正在执行。如果指定的次数小于0，则表示无限循环，总是返回正在执行。如下图所示：

循环直到节点除了像循环节点可以配置循环的次数，还有一个属性“直到子树”需要配置，如下图所示：

循环直到节点有两个结束条件，指定的“循环次数”到达或者子树的返回值与配置的“直到子树”值一样：

• 指定的“循环次数”到达的时候，则返回成功。
• 指定的“循环次数”小于0的时候，则是无限循环，等同于只检查子树的返回值是否满足。
• 子树的返回值满足的时候：
  • 如果“直到子树”设置为真，意味着直到子树返回成功，也返回成功。
  • 如果“直到子树”设置为假，意味着直到子树返回失败，也返回失败。

具体的执行逻辑可以查看behaviortree/nodes/decorators/decoratorloopuntil.cpp

重复（Repeat）节点

重复（Repeat）节点只在3.5.4以前的版本中才有。3.5.4及以后的版本请使用循环节点，并且选上‘一帧内结束’

重复节点根据指定的次数，在一次更新过程中重复执行子节点然后返回，如下图所示：

重复节点根据子节点的返回值相应的返回：

• 如果子节点失败了，则返回失败。
• 如果子节点一直运行，则本节点一直阻塞。但如果“子节点结束时作用”不为真，则不会阻塞。
• 其他情况，则返回成功。
• 本节点只能成功或失败，不会返回运行。

重复节点可以配置重复执行的“次数”和“子节点结束时作用”，如下图所示：

具体的执行逻辑可以查看behaviortree/nodes/decorators/decoratorrepeat.cpp

时间（Time）节点

时间节点用于在指定的时间内，持续调用其子节点，如下图所示：

时间节点可以配置其属性“时间”，该属性是float或double类型，可以配置一个常量、成员属性或方法的返回值，如下图所示：

具体的执行逻辑可以查看behaviortree/nodes/decorators/decoratortime.cpp

帧数（Frames）节点

帧数节点用于在指定的帧数内，持续调用其子节点，如下图所示：

帧数节点可以配置其属性“帧数”，该属性是int类型，可以配置一个常量、成员属性或方法的返回值，如下图所示：

具体的执行逻辑可以查看behaviortree/nodes/decorators/decoratorframes.cpp

计数限制（CountLimit）节点

计数限制节点不同于循环节点，它在指定的循环次数到达前返回子节点返回的状态，无论成功、失败还是正在执行，如下图所示：

计数限制节点在指定的循环次数到达后不再执行。如果指定的循环次数小于0，则表示无限循环，等同于什么操作都没有，只是执行子节点并且返回子节点的返回值。

此外，计数限制节点上还可以添加中断条件作为重新开始条件，如下图所示：

具体的执行逻辑可以查看behaviortree/nodes/decorators/decoratorcountlimit.cpp

返回成功直到（SuccessUntil）/返回失败直到（FailureUntil）

返回成功直到节点在指定的次数到达前返回成功，指定的次数到达后返回失败。如果指定的次数小于0，则总是返回成功。如下图所示：

返回失败直到节点在指定的次数到达前返回失败，指定的次数到达后返回成功。如果指定的次数小于0，则总是返回失败。如下图所示：

具体的执行逻辑可以分别查看behaviortree/nodes/decorators/decoratorsuccessuntil.cpp和behaviortree/nodes/decorators/decoratorfailureuntil.cpp

在上图中，当执行到结束节点时，行为树直接返回Success，不再执行下面ID为0的动作节点。

可以为结束节点配置“结束状态”属性，如下图所示：

上面的“结束状态”可以是一个常量，也可以是成员属性或方法的返回值，表示行为树执行到结束节点时，强制返回“结束状态”所配置的当前值。

注意：只有“结束状态”的当前值是Success或Failure时，行为树才会结束并返回该值；为Invalid或Running时，该结束节点不起作用，行为树接着执行。

此外，还有一个属性“结束外层树”，该属性用于表示在子树中的结束节点返回时，是否需要返回该子树所在的父树。

例如，创建一个带有结束节点的子树subtree1，如下图所示：

调用该子树的父树maintree1如下图所示：

如果子树subtree1中结束节点的“结束外层树”属性没有勾选，那么在执行父树maintree1的ID为4的子树节点时，会进入子树subtree1中，在该子树中执行到ID为3的结束节点时，会直接返回Success，不再执行ID为2的动作节点。子树subtree1返回后，回到父树maintree1中，由于子树subtree1中的结束节点没有勾选“结束外层树”属性，父树maintree1中ID为5的动作节点会继续得到执行。

但是如果勾选了子树subtree1中结束节点的“结束外层树”属性，则上述的执行过程会有所变化，也即子树subree1返回Success后，父树maintree1也直接返回Success，父树maintree1中ID为5的动作节点不再执行。

具体的执行逻辑可以查看behaviortree/nodes/actions/end.cpp

其中，左参数是某个Agent实例的属性，右参数可以是常数、Agent实例的属性或者方法调用的返回值，如下图所示：

类型转换

• 3.5.10及以后版本才支持
• 当属性‘类型转换’没有选中的时候，赋值节点只允许相同的类型进行赋值，也就是说右参数的下拉列表中仅列出与左参数相同类型的参数。
• 而‘类型转换’选中的时候，赋值节点允许较为宽松的类型。
  • 当左参数是数据类型（int，short，byte，float等）的时候，右参数也将是数据类型，不需要完全一致。
  • 当左参数是指针类型（对于C#是引用类型）的时候，右参数将是左参数类型的同类或子类。

其他

当需要对某个属性做一些加减乘除运算的时候，可以用计算节点。

另外，如果需要修改某些其他没有导出的属性，或做一些复杂的计算时，可以通过动作节点调用相应的函数来实现修改或计算。

具体的执行逻辑可以查看behaviortree/nodes/actions/assignment.cpp

图1 计算节点

其中，左参数是某个Agent实例的属性，参数1和参数2可以是常数、Agent实例的属性或者方法调用的返回值，操作符可以是”+, -, *, /”，如下图所示：

图2 计算节点的属性

请注意这些操作的“粒度”过小，大量这种小粒度的操作可能对性能造成影响。

另外，如果需要修改某些其他没有导出的属性，或做一些复杂的计算时，可以通过动作节点调用相应的函数来实现修改或计算。

具体的执行逻辑可以查看behaviortree/nodes/actions/compute.cpp

1 显式附件

显式附件包括前置和后置，如下图所示：

可以在任何一个节点通过鼠标拖拽来添加前置或后置附件，前置往往是作为前提条件（precondition）来使用，而后置往往是当节点结束的时候施加效果（effect）。

前置的属性主要有“联合”、“执行时机”、“左参数”、“操作符”和“右参数”等，如下图所示：

其中，“联合”是用于同一个节点的多个前置是“与（and）”还是“或（or）”的运算关系，执行时的逻辑顺序是从上往下依次执行，不管“与”还是“或”。如果“联合”是and
– 如果有a，b两个前置，则最后的结果是（a and b）。
– 如果有a，b，c三个前置，则最后的结果是（a and b and c），也即：（（a and b） and c）。如果a是false，b和c还是会计算，没有shortcut的优化。

如果“联合”是or
– 如果有a，b两个前置，则最后的结果是（a or b）。
– 如果有a，b，c三个前置，则最后的结果是（a or b or c），也即：（（a or b） or c）。如果a是true，b和c还是会计算，没有shortcut的优化。

“执行时机”分为Enter、Update和Both三种类型：

• Enter表示进入所在节点时，需要检查该前置。
• Update表示所在节点每次更新时，都需要检查该前置。
• Both表示不管所在节点是刚进入还是每次更新时，都需要检查该前置。

后置的属性主要有“执行时机”、“左参数”、“操作符”和“右参数”等，如下图所示：

“执行时机”分为Success、Failure和Both三种类型：

• Success表示所在节点执行成功后，才需要继续执行该后置。
• Failure表示所在节点执行失败后，才需要继续执行该后置。
• Both表示不管所在节点执行成功还是失败后，都需要继续执行该后置。

2 隐式附件

隐式附件主要是指事件这种附件，编辑器中没有单独的事件节点供拖拽来产生，需要通过拖拽另一棵行为树到目标行为树的节点来间接产生该事件附件。

只有根节点是Task的子树才能被拖拽到另一个符合要求的树上生成事件。

请详看文档《事件处理》。

图1 任务节点

注意：任务节点只能作为行为树的第一个子节点存在，在任务节点上可以添加其他子节点。

在任务节点的任务属性中需要选择在类型信息浏览器中创建的事件，如下图所示：

图2 任务节点的属性

带有任务节点的行为树主要用于事件的处理，请详看文档《事件处理》。

具体的执行逻辑可以查看htn/task.cpp

通过子树节点，一个行为树可以作为另一个行为树的子树。作为子树的那个行为树被“调用”。如同一个动作节点一样，子树节点根据子树的执行结果也会返回执行结果（成功、失败或运行。），其父节点按照自己的控制逻辑来控制接下来的运行。

递归

一个行为树可以“调用”自己，这么做的时候形成递归，形成递归的时候需要注意不要造成死循环，这可以通过变量的使用来避免。

如下图所示，利用testVar_0来避免死循环：第一次进入的时候testVar_0 == 0，所以可以执行下面的序列，先把testVar_0赋值为1，那么在下面的递归重入的时候由于testVar_0 == 1，所以testVar_0 == 0的条件不满足，所以下面的序列不会进入从而避免了死循环。

子树节点的属性

当选取子树节点的时候，在属性面板中显示如下图的属性：

• 引用文件名，作为被调用的子树的行为树的相对路径。该属性不允许为空，需要是有效的路径。没有提供有效路径会导致报错并且该树不允许被导出。引用文件名可以是const常量，可以是变量(其值是行为树的相对路径)，或函数（其返回值需要是字符串，是行为树的相对路径）
• 任务，如果子树的根节点是任务节点，这里会出现该任务，并且允许提供参数。如在最上的图中，8号节点travel(x, ax)，4号节点travel(ay, y)。如果子树的根节点不是任务节点，或者引用文件名不是常量，任务属性就是空的。

添加子树节点

• 在编辑器中，可以通过鼠标拖拽一棵行为树到另一棵行为树中生成子树节点，被拖拽的行为树的路径被设置到引用文件名。需要指出的是，并非任意一个行为树都可以作为另外一个行为树的子树。作为子树的行为树的Agent类型需要是“父树”的Agent类型的子类或同类。
• 也可以像添加其他节点那样，在节点列表中选取子树，拖拽其到相应的位置，然后配置引用文件名或任务。
  
• 如果手工配置的子树的路径是空的，或无效的则会报错，该树不允许被导出。如果配置的是变量或函数，编辑器中无法知道其是否有效，只有运行的时候才会报运行时错误，如果其运行时的值无效的话。

版本

在3.4.0之前的版本中，子树节点只允许配置常量，只允许使用鼠标拖拽一棵行为树到另一棵行为树中生成子树节点。在3.4.0及以后的版本中，引用文件名可以是常量，也可以是变量或函数，也就是说3.4.0及以后的版本中，子树节点引用的子树可以是”动态”的。

• 选择监测和监测分支节点只能配对使用，即选择监测节点只能添加监测分支节点作为它的子节点，监测分支节点也只能作为选择监测节点的子节点被添加。
• 监测分支节点有条件分支子树和动作分支子树。只有条件分支子树返回成功的时候，动作分支子树才能够被执行。
• 选择监测节点是一个动态的选择节点，与选择节点（Selector）相同的是，它选择第一个返回成功的子节点，但不同的是，它不是只选择一次，而是每次执行时都对其子节点重新评估后再进行选择。

默认情况下，上一次得到执行的动作分支，如果在下一次其条件分支也返回成功，那么这个动作分支会继续执行上次返回正在运行的节点。例如，假设上图中上一次执行行为树的时候，ID为13的条件节点返回成功，并且已经执行到ID为9的动作节点（这时ID为4的动作节点已返回成功，而ID为9的动作节点返回正在运行）。那么，当下一次执行该选择检测节点时，如果发现ID为13的条件节点还是返回成功，ID为9的动作节点就会直接得到执行，而不是先执行ID为4的动作节点。

但有的时候，可能需要在条件分支再次得到满足时，其动作分支需要重新执行，而不是默认情况下的从上次返回正在执行的节点继续执行。例如，对于上面的例子，当ID为13的条件节点再次返回成功时，需要重新执行其动作分支，即重新开始执行ID为4的动作节点。这时候，需要勾选上选择检测节点的属性“重置子节点”，如下图所示：

勾选该属性后，选择检测节点每次执行时，都会从头开始执行其动作分支。

选择检测节点的实现很像并行节点，每帧都要重新执行所有的子树，大量使用的时候请注意其性能。

具体的执行逻辑可以查看behaviortree/nodes/composites/selectorloop.cpp

另外，执行行为树的过程中，当状态、条件发生变化或发生事件（Event）时如何响应或打断当前的执行是个重要的问题。

目前behaviac组件支持三种方式来处理状态变化或事件发生：并行节点、选择监测节点、事件附件等。简而言之，并行和选择监测节点的工作方式是采用“轮询”的方式，每次执行时需要重新评估所有子节点，而不是像其他节点会保留上一次正在执行的子节点以便在下一次执行时继续执行。事件附件是在游戏逻辑（程序端）发出事件时，才按需得到响应。

请详看文档《事件处理》。

条件执行节点必须要有3个子节点，第一个子节点是条件分支，第二个子节点是“真时执行”分支，第三个子节点是“假时执行”分支。如果条件为真，那么执行“真时执行”分支；否则，执行“假时执行”分支。

而条件执行节点的执行结果则根据具体执行分支的执行结果来决定，如下图所示：

如果不使用条件执行节点，完全可以用序列（Sequence）和选择（Selector）节点来实现相同的功能，只不过没有条件执行节点简洁。

另外，条件执行节点的“条件”分支，还可以挂上动作节点甚至是一棵子树。比如挂上动作节点时，如果该动作节点返回Running，则条件执行节点也返回Running，并且该条件一直持续执行，直到动作节点返回Success或Failure，则继续相应的执行“真时执行”或“假时执行”分支。

具体的执行逻辑可以查看behaviortree/nodes/composites/ifelse.cpp

例如，序列节点和随机序列节点都有A、B、C、D这四个子节点。对于序列节点，每次都是按A、B、C、D的顺序依次执行；而对于随机序列节点，有时按A、B、C、D的顺序执行，有时按B、A、D、C的顺序执行，又有时按A、C、D、B的顺序执行，等等。

与随机选择节点相同的是，随机序列节点也有随机数生成器可以配置，该随机数生成器是一个返回值为0.0到1.0之间的float类型的函数，如下图所示：

该随机数生成器一般设为空即可，表示采用系统的缺省实现，也可以使用自己提供的函数。

具体的执行逻辑可以查看behaviortree/nodes/composites/sequencestochastic.cpp

例如，选择节点和随机选择节点都有A、B、C、D这四个子节点。对于选择节点，每次都是顺序的按A、B、C、D的顺序选择；而对于随机选择节点，有时按A、B、C、D的顺序选择，有时按B、A、D、C的顺序选择，又有时按A、C、D、B的顺序选择，等等。

随机选择节点有随机数生成器可以配置，该随机数生成器是一个返回值为0.0到1.0之间的float类型的函数，如下图所示：

该随机数生成器一般设为空即可，表示采用系统的缺省实现，也可以使用自己提供的函数。

具体的执行逻辑可以查看behaviortree/nodes/composites/selectorstochastic.cpp

注意：选择节点是按照从上到下的顺序依次执行子节点，一直到第一个返回成功的那个子节点则返回成功，或者如果所有子节点都返回失败则返回失败。

而概率选择节点则是根据概率“直接”选择并执行某个子节点，无论其返回成功还是失败，概率选择节点也将返回同样的结果。如果该子节点返回失败，概率选择也返回失败，它不会像选择节点那样会继续执行接下来的子节点。

概率选择节点有随机数生成器可以配置，该随机数生成器是一个返回值为0.0到1.0之间的float类型的函数，如下图所示：

该随机数生成器一般设为空即可，表示采用系统的缺省实现，也可以使用自己提供的函数。

概率选择节点的子节点只能是“权值”的子节点，在添加子节点时，该权值节点会被系统自动添加。所有权值子节点的相加之和不需要是100，执行时会进行归一化操作，子节点的概率是该子节点的权值/总和。

概率选择节点的选择算法是基于概率区间的，比如上图中的3个子节点的权值分别是20、30、50，归一化后的概率分别是0.2、0.3、0.5，那么对应的概率区间分别是[0.0, 0.2)、[0.2, 0.5)、[0.5, 1.0)。概率选择节点的随机数生成器随机产生一个[0.0, 1.0)之间的随机数，看这个随机数落在哪个区间，则执行第几个子节点。例如，随机数为0.45，落在第二个区间[0.2, 0.5)，则选择执行第二个子节点。

具体的执行逻辑可以查看behaviortree/nodes/composites/selectorprobability.cpp

图1 或节点

只要有一个条件子节点的返回值为成功，或节点则返回成功。所有条件子节点都返回为失败，或节点则返回失败。

具体的执行逻辑可以查看behaviortree/nodes/conditions/or.cpp

图1 与节点

只要有一个条件子节点的返回值为失败，与节点则返回失败。所有条件子节点都返回为成功，与节点则返回成功。

具体的执行逻辑可以查看behaviortree/nodes/conditions/and.cpp

需要配置“持续时间”，可以是常数、属性或方法的返回值（支持double和int类型），如下图所示：

在工作区配置窗口中，可以勾选左下角的“使用整数值”来表示是否使用整数值，如下图所示：

如果勾选了“使用整数值”选项，那么在导出代码文件behaviac_agent_meta.cpp中，会自动生成Workspace::GetInstance()->SetUseIntValue(true)。

等待节点的更新逻辑是：

bool bUseIntValue = Workspace::GetInstance()->GetUseIntValue();

if (bUseIntValue)
{
    long long time = Workspace::GetInstance()->GetIntValueSinceStartup();

    if (time - this->m_intStart >= this->m_intTime)
    {
        return BT_SUCCESS;
    }
}
else
{
    double time = Workspace::GetInstance()->GetDoubleValueSinceStartup();

    if (time - this->m_start >= this->m_time)
    {
        return BT_SUCCESS;
    }
}

因此，只有保证Workspace::GetInstance()->GetIntValueSinceStartup()或Workspace::GetInstance()->GetDoubleValueSinceStartup()正确的返回从游戏启动到现在的总时间，等待节点才能正确工作。

如果勾选了“使用整数值”选项，那么Workspace::GetInstance()->GetUseIntValue()将返回true，并且该总数值需要通过Workspace::GetInstance()->SetIntValueSinceStartup(long long value)设置，可以在自己的游戏更新函数中调用该函数。

如果没有勾选“使用整数值”选项，那么Workspace::GetInstance()->GetUseIntValue()将返回false。该总时间需要通过Workspace::GetInstance()->SetDoubleValueSinceStartup(double value)设置，可以在自己的游戏更新函数中调用该函数。

注意：在C#代码中相应的接口需改为Workspace.Instance.IntValueSinceStartup或Workspace.Instance.DoubleValueSinceStartup，默认实现方式是返回Unity的系统时间Time.realtimeSinceStartup，一般情况无需自己重新实现，直接使用即可，不用类似C++的接口每帧更新时调用Workspace.Instance.IntValueSinceStartup或Workspace.Instance.DoubleValueSinceStartup为其赋值。

具体的执行逻辑可以查看behaviortree/nodes/actions/wait.cpp

图1 等待帧数节点

需要配置“帧数”，可以是常数、属性或方法的返回值（必须是int类型），如下图所示：

图2 等待帧数节点的属性

等待帧数节点的更新逻辑是:

if (Workspace::GetInstance()->GetFrameSinceStartup() - this->m_start + 1 >= this->m_frames)
{
	return BT_SUCCESS;
}

因此，只有保证Workspace::GetInstance()->GetFrameSinceStartup()正确的返回从游戏启动到当前的总帧数，等待帧数节点才能正确工作。

该总帧数需要通过Workspace::GetInstance()->SetFrameSinceStartup()设置，可以在自己的游戏更新函数中调用该函数。

注意：在C#代码中相应的接口需改为Workspace.Instance.FrameSinceStartup，默认实现方式是返回Unity的当前系统帧数Time.frameCount，一般情况无需自己重新实现，直接使用即可，不用类似以上C++的接口方式每帧更新时再额外调用Workspace.Instance.FrameSinceStartup为其赋值。

具体的执行逻辑可以查看behaviortree/nodes/actions/waitframes.cpp

behaviac组件不仅支持行为树，也支持有限状态机（FSM），并且支持行为树跟状态机的相互嵌套调用。

behaviac组件中的状态机主要用到了状态（State）、等待状态（WaitState）和等待帧数状态（WaitFramesState）三种节点，以及条件转换（Transition）和总是转换（AlwaysTransition）两种附件，如下图所示：

图1 状态机相关节点和附件

状态节点

状态节点（State）是状态机中的基本组成部分之一，可以在状态节点上添加前置、后置以及转换等附件，如下图所示：

图2 状态节点

• 在状态节点上添加的前置：表明进入该状态节点时，需要执行的操作。
• 在状态节点上添加的后置：表明退出该状态节点时，需要执行的操作。
• 在状态节点上添加的转换：表明满足该转换所表示的条件时，由当前状态切换到转换所指向的下一个状态。

如下图所示，可以编辑状态节点的相关属性：

图3 状态节点的属性

• 名字：为状态节点指定一个有意义的名字，以便区分其他状态节点。
• 方法：表示该状态节点需要执行的操作。
• 结束状态：如果勾选，表示该状态作为结束状态，即在执行完该状态节点之后，整个状态机也直接结束。该节点形状也将显示为RoundRectangle，以示区别。

具体的执行逻辑可以查看fsm/fsmstate.cpp

等待状态节点

等待状态节点（WaitState）是一种特殊的状态节点，可以在状态节点上添加前置、后置以及等待转换等附件，如下图所示：

图4 等待状态节点

添加等待状态节点时，会自动的生成唯一的等待转换附件，不接受添加其他类型的转换附件。

如下图所示，可以编辑等待状态节点的相关属性：

图5 等待状态节点的属性

相比状态节点的属性，等待状态节点少了“方法”属性，但多出了一个“持续时间”属性，用来指定需要等待多长时间，可以是常数、属性或方法的返回值。

具体的执行逻辑可以查看fsm/waitstate.cpp

等待帧数状态节点

等待帧数状态节点（WaitFramesState）也是一种特殊的状态节点，可以在状态节点上添加前置、后置以及等待转换等附件，如下图所示：

图6 等待帧数状态节点

添加等待帧数状态节点时，会自动的生成唯一的等待转换附件，不接受添加其他类型的转换附件。

如下图所示，可以编辑等待帧数状态节点的相关属性：

图7 等待帧数状态节点的属性

相比状态节点的属性，等待帧数状态节点少了“方法”属性，但多出了一个“帧数”属性，用来指定需要等待多少帧数，可以是常数、属性或方法的返回值。

具体的执行逻辑可以查看fsm/waitframesstate.cpp

条件转换附件

转换附件（Transition）是状态机中的基本组成部分之一，它表示一个条件，当这个条件满足时，由所在的状态切换到另一个状态，如下图所示：

图8 转换附件

如下图所示，类似条件节点来编辑转换附件的相关属性：

图9 转换附件的属性

此外，在上图中有个“效果”的属性，是转换附件执行完之后需要执行的额外操作。

具体的执行逻辑可以查看fsm/startcondition.cpp

状态转换附件

状态转换附件（StatusTransition）是一种特殊的转换附件，根据它的配置，转换时机会有不同：

1. 总跳转，表示无条件从所在的状态切换到另一个状态，如下图所示
2. 成功时，表示当所在节点是子树并且成功的时候转换
3. 失败时，表示当所在节点是子树并且失败的时候转换
4. 结束时，表示当所在节点是子树并且结束（成功或失败）的时候转换

图10 状态转换附件

具体的执行逻辑可以查看fsm/alwaystransition.cpp

图1 空节点

具体的执行逻辑可以查看behaviortree/nodes/actions/noop.cpp

等待信号节点返回Running，直到它上面附加的条件是true的时候：

• 如果有子节点，则执行其子节点，并当子节点结束时，返回该子节点的返回值。
• 如果没有子节点，则直接返回成功。

在图1中，该等待信号节点一直“阻塞”直到它上面附加的条件是true的时候才结束“阻塞”，从而继续序列节点中后面的节点：

图1 不带子节点的等待信号节点

而在图2中，则是在该等待信号节点上附加的条件是true的时候，结束“阻塞”而执行其子节点。

图2 带子节点的等待信号节点

具体的执行逻辑可以查看behaviortree/nodes/actions/waitforsignal.cpp

这是一篇受密码保护的文章，您需要提供访问密码：

密码：