其中‘附件’有前置和后置，可以添加到任何一个节点作为前置和后置。前置往往是作为前提条件（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

可以查看目录结构

安装

安装behaviac套件的系统配置需求如下所示：

最低配置：

硬件环境：

CPU：Intel core2 Duo 2.0G或同等配置

内存：2GB以上

显卡：nvidia 6600GT或同等配置

软件环境：

操作系统：Windows XP/Vista/7/8

屏幕分辨率：1024*768

推荐配置：

硬件环境：

CPU：Intel I5 2.93G或更高配置

内存：4GB以上

显卡：nvidia GTS450或更高配置

软件环境：

操作系统：Windows 7/8

屏幕分辨率：1680*1050

运行BehaviacSetup_***.exe安装包文件，选择安装路径（推荐直接使用默认路径），安装behaviac相关套件。

可能需要下载安装Microsoft Visual C++ 运行库。
及.net。

安装完成后，会在桌面生成编辑器的快捷方式，如下图所示：

图1 安装后桌面的编辑器图标

另外，在系统的“开始”菜单中生成了一些游戏demo和文档的菜单项。其中，BattleCityDemo是采用Unity引擎实现的小游戏（C#版），LaunchCocosGame是采用Cocos引擎实现的小游戏（C++版），LaunchSDLDemo是采用SDL库实现的小游戏（C++版），如下图所示：

图2 开始菜单中demo和文档菜单项

behaviac中间件是我们对行为树、有限状态机等AI范式的一种整合实现方案，主要包括编辑器（Designer）和运行时库（Runtime）两大部分。其中，编辑器用于编辑、导出类型信息，也用于编辑、导出和调试行为树；运行时库也可导出类型信息，主要用于解释和执行编辑器导出的行为树，运行时库需要整合到自己的游戏项目中去。

编辑器和运行时之间通过类型信息（Meta）进行交互，注意类型信息流动的双向箭头，表示编辑器和运行时库双方都可以导出类型信息，如下图所示：

图1 基于类型信息的编辑器和运行时端的交互

编辑器只能运行在Windows平台上，运行时库支持C++和C#语言两个版本，对Unity引擎原生支持C#，运行时库目前支持所有主流平台，包括Windows/Linux/Android/iOS等。

该组件的使用场景，支持但不限于游戏中的逻辑、角色的人工智能、动画的控制等方面。

2 编辑器的使用

2.1 基本介绍

编辑器首次打开后为会根据操作系统的语言环境配置自动设置为中文版或英文版的界面，若需更改语言显示，可以依次选择菜单项“文件（File）”->“设置（Settings）”，在弹出的设置对话框中，选择需要的“语言（Language）”并点击“确认（OK）”后，退出并重新打开编辑器，则转为需要语言的界面。
编辑器主要分为几个部分：菜单和工具栏、行为树文件区、节点区、主视口和属性表等，如下图所示：

图2.1 编辑器主界面

• 菜单和工具栏：主要有新建/打开工作区、新建/保存/导出/关闭行为树文件、设置、退出、帮助等菜单项或按键。
• 行为树文件区：列出了当前打开的工作区里面的所有行为树文件，双击某个行为树文件节点可以打开该文件。
• 节点区：给出了behaviac组件支持的所有行为树节点类型，在编辑行为树的时候，可以通过鼠标拖拽添加到主视口的行为树上去。
• 主视口：显示了当前打开的行为树图形，可以打开多个行为树，分页显示。
• 属性表：在主视口中点击选择某个节点后，属性表会更新显示当前选中节点的所有属性，可以编辑各个属性。

所有窗口的停靠位置均可根据个人喜好，通过鼠标在窗口边框的拖拽重新布局。编辑器中所有的按钮均可将鼠标停在上面查看其tips，以便查知其功能。编辑器中鼠标、键盘的按键用法介绍，请查看菜单中的“帮助（Help）”->“起始页（StartPage）”。

编辑器分为三种操作模式：
– 编辑模式：这是常规模式，编辑器启动后默认进入该模式，主要用于为游戏项目编辑所需的类型信息和行为树。
– 连接模式：这是编辑器连接上游戏之后进入的模式，此时不能编辑行为树本身，只能用于观察行为树的高亮执行路径、设置断点等调试相关的操作。
– 分析模式：这是离线模式，在断开游戏时保存了连接过程中的所有消息，在该模式可以模拟连接模式游戏端发送过来的消息，进行离线分析行为树的执行情况。

2.2 操作说明

2.2.1 新建工作区

首次使用编辑器，需要为自己的项目创建一个工作区：

• 点击菜单“文件”->“新建工作区”，弹出新建工作区对话框，如下图所示。

图2.2.1 新建工作区

• 依次设置工作区的名字、位置（即工作区的保存路径）、源位置（即原始行为树的保存路径）、导出位置（即运行时库所需行为树的导出路径）和元数据位置（即运行时库导出的类型信息文件路径）。
• 源位置是存放编辑器创建的行为树的位置。导出位置是存放导出的行为树的位置。源位置和导出位置缺省情况下位于工作区所在的目录内：behaviors和exported。
• 元数据位置、源位置和导出位置需要和工作区文件必须位于同一个盘符下（如果位于不同的盘符下，调试的时候会有问题）。缺省情况下，它们位于同一个顶级目录下。

2.2.2 打开工作区

点击菜单“文件”->“打开工作区”，选择保存在磁盘上的*.workspace.xml文件。
在安装路径下有提供的例子供参考，例如默认安装路径下的“C:\Program Files (x86)\behaviac\integration\BattleCityDemo\Assets\BTWorkspace\BattleCity.workspace.xml”，或者从菜单中的“文件”->“最近打开的工作区”列表中选择最近打开过的工作区。
behaviac组件提供了C++和C#两种编程语言的单元测试以及游戏Demo，可以通过编辑器中的菜单项“帮助”->“控制说明” 进入，然后点击快速打开所需的单元测试或游戏Demo所用到的工作区，如下图所示：

图2.2.2 快速打开单元测试和游戏Demo的工作区

2.2.3 编辑工作区

点击菜单“文件”->“编辑工作区”，可以修改该工作区的设置（名字、元数据位置、源位置、导出位置等），如下图所示：

图2.2.3 编辑工作区

2.2.4 新建并编辑行为树文件

• 在打开的工作区中，从工具栏里面点击“新建行为树”按钮或者通过菜单中“文件”->“新建行为树”项，创建一个行为树文件。
• 在主视口中，为新建的行为树根节点选择设置其“Agent类型”。
• 在“节点区”中用鼠标左键选择并拖拽一些节点到主视口中来构建需要的行为树，并设置每个节点的属性。每种节点的具体用法请参考菜单项“帮助”->“节点介绍”。
• 编辑过程中，支持Undo/Redo、保存等文件操作，鼠标、键盘的按键用法请对照菜单项“帮助”->“控制说明”。

2.2.5 打开行为树文件

如图2.1所示，在“行为树文件区”中，双击某个行为树文件节点就可以在主视口中打开该文件。

2.2.6 导出行为树文件

• 编辑完行为树之后，可以通过菜单项“文件”->“导出行为树”（或者快捷键Ctrl+T）导出当前打开的行为树文件。
• 通过菜单项“文件”->“导出全部”项（或者快捷键Ctrl+Shift+T）导出工作区中的所有行为树文件。
• 目前支持4种文件格式的导出，即XML、BSON、C++和C#，如下图所示：

图2.2.6.1 导出行为树

• 对于C++/C#格式的导出，还可以设置导出的文件名和位置。点击图2.2.6.1中“导出设置”->“设置”列的“…”按钮，可以弹出“C++/C#导出设置”对话框。对于C++文件，还需添加游戏项目中Agent子类的.h头文件，如图2.2.6.2所示。
  导出后，将在指定的导出路径下生成behaviac_generated目录，里面又包含了behaviors和types两个子目录，需要将这两个子目录里面的所有文件全部包含到自己的项目中去。
  注意：对于导出C++文件，如果不添加Agent子类的.h头文件，那么需要注意将behaviors和types两个子目录中生成的头文件放在项目代码include “yourAgent.h”之后，以确保Agent子类先被包含进来，否则会有编译错误。

图2.2.6.2 C++/C#的导出设置

• 图2.2.6.2中的选项“是否导出统一文件”用来表示导出的C++或者C#文件是否为一个统一的大文件还是若干个小文件，其中每个小文件对应一个行为树。
• 运行时库支持行为树导出文件的热加载，如果在编辑器修改完行为树之后，重新导出，游戏端会自动重新加载所用到的行为树，无需重启游戏。

2.2.7 连接游戏Permalink

• 从开始菜单中，启动小游戏BattleCityDemo，如下图所示：

图2.2.7.1 Battle City Demo

• 点击游戏主界面右上角的“Show Levels”按钮，可以切换不同的关卡，如下图所示：

图2.2.7.2 选择关卡

• 点击游戏主界面左下角的“Launch Designer”按钮，启动编辑器，编辑器会自动打开BattleCityDemo的工作区，并打开游戏当前关卡所用到的行为树（如果没有切换其他关卡，默认打开的是Tank_Fire_Random行为树文件）。
• 点击编辑器工具栏中的“连接游戏”按钮或通过菜单项“文件”->“连接游戏”（或通过快捷键Ctrl+L），开始连接游戏。默认的，一般无需更改服务器IP和端口号，如图2.2.7.3所示。
  注意：有时候可能会发现连不上游戏，很可能是原来的端口号已被占用，可以尝试在运行时端的端口号60636改为其他值，然后相应的修改图2.2.7.3中的端口号，尝试重新连接游戏。

图2.2.7.3 连接游戏

• 连接成功后，编辑器从编辑模式切换到连接模式，如下图所示：

图2.2.7.4 连接模式

• 时间轴（Timeline）：默认位于编辑器最上方，用于表示当前帧相关的信息。
• 实例列表：列出了游戏中所有的对象实例，双击实例节点后可以开始跟踪调试选中的实例，右键单击实例节点弹出如下菜单，如图2.2.7.5所示。其中“调试”跟双击节点的作用一致，开始跟踪选中的实例，主视口会高亮显示行为树的执行路径；“查看属性”用于跟踪当前选中实例的所有属性的变化，编辑器会弹出实例的属性列表。

图2.2.7.5 实例右键菜单

• 主视口：高亮的节点边框和连接线段，表示程序当前执行的路径情况。双击树中节点的左右两侧，可以设置节点的断点（左侧表示进入断点，右侧表示退出断点），用于游戏执行时在断点位置停下来，游戏断下来后按F5键后继续运行。
• 输出窗口：列出了收到的全部消息，用于调试时查看记录。
• Agent的属性：可以显示当前Agent属性的变化。
• 断点：通过菜单项“视图”->“断点”打开断点窗口后，可以查看、管理当前工作区中的所有断点。

2.2.8 分析导出数据

• 点击菜单或工具栏中的“断开游戏”按键，断开与游戏端的连接，回到编辑模式。
• 默认弹出如下对话框，保存之前连接模式下调试的相关数据。

图2.2.8.1 保存dump数据

• 点击菜单或工具栏中的“分析导出文件”按键，选择打开上一步导出的数据文件，编辑器进入到分析模式。
• 分析模式的界面布局跟连接模式类似，但是可以通过时间轴里面的播放按钮开始重现连接过程中的情况，如下图所示：

图2.2.8.2 分析dump数据

• 要退出分析模式，可以点击菜单或工具栏中的“终止分析”按键，回到编辑模式。

需要指出的是，分析模式下还可以直接下载_behaviac_$_.log文件进行离线分析。_behaviac_$_.log文件一般生成在exe所在的目录。对于unity，_behaviac_$_.log文件生成在Assets所在的目录中。

2.2.9 其他

除了BattleCityDemo小游戏（基于Unity引擎实现，运行时库为C#版）之外，还有LaunchCocosGame（基于Cocos引擎实现，运行时库为C++版）和LaunchSDLDemo小游戏（基于SDL库实现，运行时库为C++版）。
如图2.2所示，从操作系统的开始菜单中启动LaunchCocosGame或LaunchSDLDemo小游戏后，游戏跟编辑器的连接需要单独启动编辑器，然后再点击编辑器工具栏中的“连接游戏”按钮或通过菜单项“文件”->“连接游戏”（快捷键Ctrl+L），开始连接游戏。连接后，执行情况跟BattleCityDemo小游戏类似。

请首先到/language/zh/downloads/下载或克隆源码。

C++运行时库的构建

请参考文档《使用cmake构建C++版运行时库》。

项目文件

从3.6.33版本，我们提供了预先生成的项目文件，如下图：

C#和Unity运行时库的构建

安装目录中的/integration/unity是基于Unity C#的单元测试项目。

自己的C#项目需要将目录/integration/unity/Assets/Scripts/behaviac/runtime下的所有源码直接复制过去，如下图所示：

如果是Unity平台下的C#开发，还可以在Unity编辑器中导入/integration/behaviac.unitypackage包（安装完发布的BehaviacSetup_***.exe后，会在安装目录中的/integration文件夹中找到该behaviac.unitypackage包）。

编辑器的构建

编辑器的源码目录结构，如下图所示：

请使用vs2010或以上打开并构建tools/designer/BehaviacDesigner.sln。

将behaviac组件整合到自己的项目中时，可以通过两种方式使用behaviac组件：

• 将全部源码（包括behaviac组件的所有.h和.cpp文件）全部复制到自己的游戏项目中。
• 单独编译behaviac组件库，生成lib文件，然后自己的项目包含.h文件和生成的.lib文件。

对于上面的第二种用法，请先参考如何编译构建文档来编译构建behavaic组件。

在Windows平台，如果是使用VS来管理项目的，需要在VS的项目“Property Pages”->“Configuration Properties”->“C/C++”->“General”中的“Additional Include Directories”项中添加behaviac组件头文件（即图1中的inc文件夹）所在的路径，如下图所示：

再在VS的项目“Property Pages”->“Configuration Properties”->“Linker”->“General”中的“Additional Library Directories”项中添加自己编译出的behaviac lib文件（即图1中的lib文件夹）所在的路径，如下图所示：

最后在VS的项目“Property Pages”->“Configuration Properties”->“Linker”->“Input”中的“Additional Dependencies”项中添加自己编译出的behaviac lib文件，如下图所示：

注意：上图中的behaviac_debugdll_win32_vs2010.lib文件是用VS2010编译出来的，说明游戏项目也需要用VS2010来编译。如果你的游戏项目使用其他版本的VS，则编译behaviac组件也需要用相应版本的VS来编译。

如何注册和导出类型信息请参考C++类型信息的注册和导出，如何导出行为树请参考导出和使用XML/BSON行为树。

通过编辑器导出行为树文件后，运行时端的执行主要分为三个部分：

• 初始化
• 循环更新
• 清理

1 初始化

在游戏的初始化函数中，添加初始化behaviac组件所需的功能，例如注册Agent子类信息、设置行为树文件的加载路径和文件格式、创建Agent子类的实例、加载行为树并设置当前所需执行的行为树等。

如下代码所示：

bool InitBehavic(behaviac::Workspace::EFileFormat ff)
{
    behaviac::Config::SetSocketBlocking(false);
    behaviac::Config::SetSocketPort(8081);

    behaviac::Agent::Register<CBTPlayer>();

    behaviac::Workspace::GetInstance()->SetFilePath("../test/demo_running/behaviac/exported");
    behaviac::Workspace::GetInstance()->SetFileFormat(ff);

    behaviac::Workspace::GetInstance()->ExportMetas("../test/demo_running/behaviac/demo_running.xml");

    //behaviac::Agent::SetIdMask(kIdMask_Wolrd | kIdMask_Opponent);
    behaviac::Workspace::GetInstance()->SetDeltaFrames(1);

    return true;
}

bool InitPlayer(const char* pszTreeName)
{
    g_player = behaviac::Agent::Create<CBTPlayer>();

    bool bRet = false;
    bRet = g_player->btload(pszTreeName);
    assert(bRet);

    g_player->btsetcurrent(pszTreeName);

    return bRet;
}

• Workspace::SetFilePath指定的是编辑器中Workspace的导出路径，可以是绝对路径。当指定的是相对路径的时候，相对的是当前工作路径（一般都是运行程序所在目录）。
• Agent::btload使用的文件名是相对于Workspace::SetFilePath指定的路径，没有扩展名，可以有目录结构的层次化文件名，如“node_test/selector_loop_ut_7”。在编辑器中打开某个行为树后，右键文件页选取“复制文件名”获取。

• 例如：
  • 如果运行程序所在目录（或者VS里指定的工作路径$(TargetDir)）是”D:\Test\bin”
  • Workspace::SetFilePath指定的相对路径是“../behaviac/workspace/exported”
  • btload指定是“node_test/selector_loop_ut_7”
  • 则workspace的导出路径实际是“D:/Test/behaviac/workspace/exported”，
    而相应的导出行为树文件是“D:/Test/behaviac/workspace/exported/node_test/selector_loop_ut_7.xml”或
    “D:/Test/behaviac/workspace/exported/node_test/selector_loop_ut_7.bson.bytes”。
  • 具体是xml或bson则由Workspace::SetFileFormat确定。
  • 当指定格式是cpp或c#的时候，导出的行为树是cpp或c#源码，已经编译构建进可执行程序，Agent::btload指定的文件名（跟xml的用法一样，无需修改btload的参数）只是用来标识该行为树的，从而代码可以据此创建相应的行为树，不像xml或bson格式的时候需要加载数据文件。
• 如果Agent::btload加载失败，请注意检查当前路径，Workspace::SetFilePath设定的导出路径，以及Agent::btload指定的文件标识。还可以在当前路径里检查log文件_behaviac_$_$_.log

2 循环更新

在游戏的主循环中，添加执行Agent实例的行为树相关代码，也即通过调用Agent类的接口btexec()或Workspace类的接口Update()来执行行为树。

这两种执行方式的区别，请参考更新流程。

如下代码样例所示：

void UpdateLoop()
{
	int i  = 0;
	int frames = 0;
	behaviac::EBTStatus status = behaviac::BT_RUNNING;

	while (status == behaviac::BT_RUNNING)
	{
		cout << "frame " << ++frames << std::endl;
		status = g_player->btexec();
	}
}

3 清理

最后的清理过程，包括销毁Agent子类的实例，以及反注册Agent子类信息等。

如下代码样例所示：

void CleanupPlayer()
{
    behaviac::Agent::Destroy(g_player);
}

void CleanupBehaviac()
{
    behaviac::Agent::UnRegister<CBTPlayer>();

	behaviac::Workspace::GetInstance()->Cleanup();
}

以上步骤的完整代码，请参考demo_running.cpp文件。

• 点击上图中右侧的“…”设置按钮，在弹出的“C++导出设置”对话框中设置生成文件所在的位置，并可以添加项目中游戏类（从Agent类派生而来）所在的.h头文件，添加的头文件将会被包含在生成的.cpp文件中，如下图所示：

• 回到“导出行为树”对话框，点击“导出”按钮，开始导出C++文件。在指定的导出位置（默认为当前工作区的导出路径）会自动生成一个名为behaviac_generated的文件夹，里面生成了behaviors和types两个子文件夹，如图3所示：
• behaviors文件夹中含有generated_behaviors.h及其他单个的行为树.inl文件（如果没有勾选“导出统一文件？”，则对每一棵行为树都会生成独立的.inl文件，这些.inl文件会自动include在generated_behaviors.h文件中，无需在自己的项目中再include这些.inl文件，只需要include这个generated_behaviors.h文件即可）。
• types文件夹中含有agentproperties.h（为Agent类自定义的属性和方法，会扩展在该文件中）、customizedtypes.h/customizedtypes.cpp（自定义的枚举和结构体类型，会生成在这两个文件中）以及其他自定义Agent子类的文件（这些文件是为添加的Agent子类自动生成的.h/.cpp文件，需要程序员补充代码进一步实现这些Agent子类的逻辑）。

• 注意：这些自动生成的文件（除了上面提及的单个的行为树.inl文件之外）都需要包含到自己的游戏项目中，一起参与整个项目代码的编译和构建。
• 在项目中包含了这些自动生成的代码文件后，就可以与前面提及的导出和使用XML/BSON行为树一样的接口和方式加载使用这些C++文件，只是需要将文件格式改为EFF_cpp：

behaviac::Workspace::GetInstance()->SetFileFormat(behaviac::Workspace::EFF_cpp);

图1 基于元信息的编辑器和运行时端的交互

在运行时端，也即游戏代码端，通过注册（C++通过宏的方式）并导出供行为树引擎和编辑器使用的XML元信息。运行时端主要是由程序员编写Agent的子类及其属性和方法，然后调用相关接口将这些元信息导出，就可以在编辑器中对这些元信息进行使用。

在编辑器中也可以创建和编辑元信息。在项目开始初期，也就是程序员还没把代码写出来之前，策划就可以自己手动的创建一些Agent子类、属性和方法等元信息。这样可以加速游戏原型的创建，也就是策划不用等程序员，就可以进行游戏原型的编辑。

整个工作流程主要分为以下几个步骤：

1 注册元信息

• 在.h文件中，根据项目需要按以下步骤编写自己的游戏类：
  • 首先需要包含头文件#include “behaviac/behaviac.h”。
  • 该类需要从behaviac::Agent基类继承。
  • 首先用宏DECLARE_BEHAVIAC_AGENT声明该类及其父类，用于行为树引擎内部的反射系统所需的类型信息。
  • 为该类添加必要的属性和方法等。

如下代码样例所示：

#include "behaviac/behaviac.h"

using namespace behaviac;

class CBTPlayer : public Agent
{
public:
    DECLARE_BEHAVIAC_AGENT(CBTPlayer, Agent);

    CBTPlayer();
    virtual ~CBTPlayer();

    time_t GetCurTime();
    bool Condition();
    behaviac::EBTStatus Action1();
    EBTStatus Action3();

private:
    int                 m_iX;
    int                 m_iY;
    unsigned int        m_iBaseSpeed;
    int					m_Frames;
};

• 在.cpp文件中，通过一系列宏来注册该类自身的描述及其属性与方法：
  • 宏BEGIN_PROPERTIES_DESCRIPTION和END_PROPERTIES_DESCRIPTION表示类型信息注册的开始和结束。
  • 宏CLASS_DISPLAYNAME和CLASS_DESC用于注册类自身的显示名和描述。
  • 宏REGISTER_PROPERTY用于注册类的属性，可以通过.DISPLAYNAME的追加方式为属性添加显示名，通过.DESC的追加方式为属性添加描述。
  • 宏REGISTER_METHOD用于注册类的方法，可以通过.DISPLAYNAME的追加方式为方法添加显示名，通过.DESC的追加方式为方法添加描述，通过.PARAM_DISPLAY_INFO的追加方式为参数添加显示名和描述等。如果参数类型是数值类型（例如int、unsigned int、float等），.PARAM_DISPLAY _INFO还可以用来指定参数的有效范围。

如下代码样例所示：

BEGIN_PROPERTIES_DESCRIPTION(CBTPlayer)
{
	REGISTER_PROPERTY(m_iBaseSpeed);

	REGISTER_METHOD(Condition);
	REGISTER_METHOD(Action1);
	REGISTER_METHOD(Action3);
}
END_PROPERTIES_DESCRIPTION()

2 导出元信息

注册完类信息之后，按以下步骤导出元数据文件：

• 在初始化函数里，添加Agent::Register<***>()用于注册类信息到引擎库中。
• 通过Agent::RegisterInstanceName<***>(…)来注册类的实例名。
• 调用Workspace::GetInstance()->SetFilePath(…)设置元信息文件导出的位置。
• 调用Workspace::GetInstance()->ExportMetas(…)导出元信息文件。
• 在释放函数里，添加Agent::Unregister<***>()用于释放类型的注册信息。

如下代码样例所示：

bool InitBehavic(behaviac::Workspace::EFileFormat ff)
{
    behaviac::Config::SetSocketBlocking(false);
    behaviac::Config::SetSocketPort(8081);

    behaviac::Agent::Register<CBTPlayer>();

    behaviac::Workspace::GetInstance()->SetFilePath("../test/demo_running/behaviac/exported");
    behaviac::Workspace::GetInstance()->SetFileFormat(ff);

    behaviac::Workspace::GetInstance()->ExportMetas("../test/demo_running/behaviac/demo_running.xml");

    //behaviac::Agent::SetIdMask(kIdMask_Wolrd | kIdMask_Opponent);
    behaviac::Workspace::GetInstance()->SetDeltaFrames(1);

    return true;
}

void CleanupBehaviac()
{
    behaviac::Agent::UnRegister<CBTPlayer>();
    behaviac::Workspace::GetInstance()->Cleanup();
}

更多细节可以参考behaviac组件C++源码中附带的test/demo_running工程的demo_running.cpp文件。

图1 基于元信息的编辑器和运行时端的交互

在运行时端，也即游戏代码端，通过注册（C#通过标记Attribute的方式）并导出供行为树引擎和编辑器使用的XML元信息。运行时端主要是由程序员编写Agent的子类及其属性和方法，然后调用相关接口将这些元信息导出，就可以在编辑器中对这些元信息进行使用。

在编辑器中也可以创建和编辑元信息。在项目开始初期，也就是程序员还没把代码写出来之前，策划就可以自己手动的创建一些Agent子类、属性和方法等元信息。这样可以加速游戏原型的创建，也就是策划不用等程序员，就可以进行游戏原型的编辑。

整个工作流程主要分为以下几个步骤：

1 注册元信息

C#中编写的游戏类从behaviac.Agent派生，并通过相关的Attribute来标记元信息：

• 类：TypeMetaInfo
• 成员属性：MemberMetaInfo
• 成员方法：MethodMetaInfo

这3个类都可以接受诸如显示名字，描述等更多参数。详细请参考代码。

如下代码样例所示：

[behaviac.TypeMetaInfo()]
public class AgentNodeTest : behaviac.Agent
{
    [behaviac.MemberMetaInfo()]
    public int testVar_0 = -1;

    [behaviac.MemberMetaInfo("testVar_1", "testVar_1 property", 100)]
    public int testVar_1 = -1;

    [behaviac.MemberMetaInfo()]
    public float testVar_2 = -1.0f;

    [behaviac.MemberMetaInfo()]
    public int waiting_timeout_interval = 0;

    [behaviac.MemberMetaInfo()]
    public string testVar_str_0 = string.Empty;

    public bool m_bCanSee = false;

    [behaviac.MethodMetaInfo()]
    public void setEventVarInt(int var) {
        event_test_var_int = var;
    }

    [behaviac.MethodMetaInfo()]
    public void setEventVarBool(bool var) {
        event_test_var_bool = var;
    }
}

2 导出元信息

由于C#代码中已经包含了各种Attribute来描述元信息，因而导出相比C++要简单：

• Agent子类的实例通过Agent.RegisterInstanceName<***>(…)来进行注册。
• 调用Workspace.Instance.FilePath设置元信息文件导出的位置。
• 调用Workspace.Instance.ExportMetas(…)导出元信息文件。

如下代码样例所示：

public bool Init ()
{
    if (ms_fileSystem == null)
    {
        ms_fileSystem = new BehaviacFileManager();
    }

    //< write log file
    behaviac.Config.IsLogging = true;
    //behaviac.Config.IsSocketing = false;

    behaviac.Workspace.Instance.FilePath = this.WorkspaceExportPath;
    behaviac.Workspace.Instance.FileFormat = behaviac.Workspace.EFileFormat.EFF_xml;

    //register names
    behaviac.Agent.RegisterInstanceName<GameLevelCommon>("GameLevel");
    behaviac.Workspace.Instance.ExportMetas("behaviac/workspace/xmlmeta/BattleCityMeta.xml");

    behaviac.Debug.Log("Behaviac meta data export over.");
    behaviac.Agent.SetIdMask(0xffffffff);

    return true;
}

public void Uninit()
{
    behaviac.Workspace.Instance.Cleanup();
}

更多细节可以参考behaviac组件C#源码中附带的integration/BattleCityDemo工程的BehaviacSystem.cs文件。

• 点击上图中右侧的“…”设置按钮，在弹出的“C#导出设置”对话框中设置导出文件所在的位置，如图2所示：

• 回到“导出行为树”对话框，点击“导出”按钮，开始导出C#文件。在指定的导出位置（默认为当前工作区的导出路径）会自动生成一个名为behaviac_generated的文件夹，里面生成了behaviors和types两个子文件夹，如图3所示：
• behaviors文件夹含有generated_behaviors.cs及其他单个的行为树.cs文件（如果没有勾选“导出统一文件？”，则对每一棵行为树都会生成独立的.cs文件）。
• types文件夹中含有agentproperties.cs（为Agent类自定义的属性和方法，会扩展在该文件中）、customizedtypes.cs（自定义的枚举和结构体类型，会生成在这个文件中）以及其他的Agent子类的文件（这些文件是为添加的Agent子类自动生成的.cs文件，需要程序员补充代码进一步实现这些Agent子类的逻辑），这些自动生成的文件都需要包含到自己的游戏项目中。

• 注意：这些自动生成的文件都需要包含到自己的游戏项目中，一起参与整个项目代码的编译和构建。
• 在项目中包含了这些自动生成的.cs文件后，就可以与前面提及的导出和使用XML/BSON行为树一样的接口和方式加载使用这些文件，只是需要将文件格式改为EFF_cs：

behaviac.Workspace.Instance.FileFormat = behaviac.Workspace.EFileFormat.EF

导出和使用XML/BSON行为树

• 在编辑器中导出整个工作区文件，在“导出行为树”对话框中，勾选“Xml Behavior Exporter”或“Bson Behavior Exporter”，如下图所示：

• 导出行为树文件结束后，回到运行时（游戏）代码端，按以下步骤使用行为树文件：
  • 在游戏的初始化函数中，添加Agent::Register<***>()注册类信息到引擎库中。
  • 调用Workspace::SetFilePath(…)函数，设置行为树文件的加载路径，也即编辑器导出行为树文件所在的目录。
  • 调用Workspace::SetFileFormat(…)函数，设置加载行为树的文件格式，如果不调用则默认加载EFF_xml格式。
  • 通过调用Agent的接口btload(…)加载所需的行为树文件。
  • 通过调用Agent的接口btsetcurrent(…)设置当前准备执行的行为树文件。
  • 行为树的更新执行流程请参考更新流程。
  • 在游戏的释放函数里面，添加Agent::Unregister<***>()用于释放类型的注册信息。

如下代码样例所示：

bool InitBehavic(behaviac::Workspace::EFileFormat ff)
{
    behaviac::Config::SetSocketBlocking(false);
    behaviac::Config::SetSocketPort(8081);

    behaviac::Agent::Register<CBTPlayer>();

    behaviac::Workspace::GetInstance()->SetFilePath("../test/demo_running/behaviac/exported");
    behaviac::Workspace::GetInstance()->SetFileFormat(ff);

    behaviac::Workspace::GetInstance()->ExportMetas("../test/demo_running/behaviac/demo_running.xml");

    //behaviac::Agent::SetIdMask(kIdMask_Wolrd | kIdMask_Opponent);
    behaviac::Workspace::GetInstance()->SetDeltaFrames(1);

    return true;
}

bool InitPlayer(const char* pszTreeName)
{
    g_player = behaviac::Agent::Create<CBTPlayer>();

    bool bRet = false;
    bRet = g_player->btload(pszTreeName);
    assert(bRet);

    g_player->btsetcurrent(pszTreeName);

    return bRet;
}

void CleanupPlayer()
{
    behaviac::Agent::Destroy(g_player);
}

void CleanupBehaviac()
{
    behaviac::Agent::UnRegister<CBTPlayer>();

    behaviac::Workspace::GetInstance()->Cleanup();
}

总之，一棵行为树的加载到执行，关键的就是前面提及的三个接口：btload()、btsetcurrent()和btexec()。

更多细节可以参考behaviac组件C++源码中附带的test/demo_running工程的demo_running.cpp文件。

类似的，对于C#版的运行时端，采用如下代码样例加载使用刚才导出的行为树：

public bool Init ()
{
    if (ms_fileSystem == null)
    {
        ms_fileSystem = new BehaviacFileManager();
    }

    //< write log file
    behaviac.Config.IsLogging = true;
    //behaviac.Config.IsSocketing = false;

    behaviac.Workspace.Instance.FilePath = this.WorkspaceExportPath;
    behaviac.Workspace.Instance.FileFormat = behaviac.Workspace.EFileFormat.EFF_xml;

    //register names
    behaviac.Agent.RegisterInstanceName<GameLevelCommon>("GameLevel");
    behaviac.Workspace.Instance.ExportMetas("behaviac/workspace/xmlmeta/BattleCityMeta.xml");

    behaviac.Debug.Log("Behaviac meta data export over.");
    behaviac.Agent.SetIdMask(0xffffffff);

    return true;
}

public void Uninit()
{
    behaviac.Workspace.Instance.Cleanup();
}

// 加载所需的行为树文件
if(behaviorTree.Length > 0)
{
    btloadResult = agent.btload(behaviorTree, true);
    if(btloadResult)
        agent.btsetcurrent(behaviorTree);
    else
        Debug.LogError("Behavior tree data load failed! " + behaviorTree);
}

更多细节可以参考behaviac组件C#源码中附带的integration/BattleCityDemo工程的BehaviacSystem.cs文件。

这些实例主要来自于如下三个方面：

• Self：表示当前行为树根节点所配置的Agent类型的实例，类似于程序语言中的this。
• 成员实例：当前行为树根节点所配置的Agent类型的成员属性、自定义属性或局部变量，也是Agent或其子类类型。
• 全局实例：运行时端（游戏端）注册和导出的各种Agent或其子类的全局实例。

其中，成员实例无需编写额外代码来进行注册和导出，behaviac组件会自动根据当前行为树根节点所配置的Agent类型，列举出所有的成员实例以供选择。但在使用该成员实例之前，需要确保该实例已经赋过值，不是空指针/引用。

对于全局实例，在运行时端（游戏端）的各种Agent或其子类实例的名字注册和绑定的设计意图，主要是为了支持单件（Singleton）或者类似确定的全局性的实例（同一个类可能会有若干个实例而不是仅仅有一个实例），例如：player，camera，director等。

注意：只有通过RegisterInstanceName注册过的“名字”才在导出元信息时被导出；而BindInstance和Create等与实例相关的函数在执行行为树的时候才需要，如果只是导出元信息则不需要。

C++中全局实例的注册

Agent::RegisterInstanceName可以注册一个名字，该名字表示游戏中某个Agent类的实例，如下代码所示：

behaviac::Agent::RegisterInstanceName<AgentNodeTest>();
behaviac::Agent::RegisterInstanceName<behaviac::Agent>("Name_Agent_0");

需要说明的是，游戏中需要调用Agent::Create或Agent::BindInstance创建实例并且绑定到该名字。如果指定的名字没有注册或注册的类型不同或该名字已经绑定，则调用Agent::Create的时候会有runtime的错误。

当调用Agent::RegisterInstanceName和Agent::Create而没有指定名字的时候，该Agent类型的名字将作为实例的名字被注册和绑定，如下代码所示：

behaviac::Agent* testAgentA = behaviac::Agent::Create<behaviac::Agent>("Name_Agent_0");
AgentNodeTest* testAgentB = behaviac::Agent::Create<AgentNodeTest>(NULL);

behaviac::Agent* testAgent_0 = behaviac::Agent::GetInstance<behaviac::Agent>("Name_Agent_0");
AgentNodeTest* testAgent_1 = behaviac::Agent::GetInstance<AgentNodeTest>();

behaviac::Agent::BindInstance(testAgent_0, "Name_Agent_0");
behaviac::Agent::BindInstance(testAgent_1, “AgentNodeTest”);

CHECK_EQUAL(testAgent_0, testAgentA);
CHECK_EQUAL(testAgent_1, testAgentB);

behaviac::Agent::UnbindInstance("Name_Agent_0");
behaviac::Agent::UnbindInstance("AgentNodeTest");

更多细节可以参考behaviac组件C++源码中附带的test工程的btloadtest.cpp文件。

C# 中全局实例的注册

类似的，在C#中实例的注册和绑定相关代码如下：

behaviac.Agent.RegisterInstanceName<AgentNodeTest>(); behaviac.Agent.RegisterInstanceName<behaviac.Agent>("Name_Agent_0"); 

behaviac.Agent.BindInstance(parTestAgent, "Name_Agent_0"); behaviac.Agent.BindInstance(nodeTestAgent, "AgentNodeTest");

behaviac.Agent testAgent_0 = behaviac.Agent.GetInstance<behaviac.Agent>("Name_Agent_0");
AgentNodeTest testAgent_1 = behaviac.Agent.GetInstance<AgentNodeTest>(); 
AgentNodeTest testAgent_3 = behaviac.Agent.GetAgent("AgentNodeTest") as AgentNodeTest;

Assert.AreEqual(testAgent_0, parTestAgent);
Assert.AreEqual(testAgent_1, nodeTestAgent);
Assert.AreEqual(testAgent_1, testAgent_3);

Assert.NotNull(testAgent_0);
Assert.NotNull(testAgent_1);

behaviac.Agent.UnbindInstance("Name_Agent_0");
behaviac.Agent.UnbindInstance("AgentNodeTest");

更多细节可以参考behaviac组件C#源码中附带的integration/unity工程的OtherUnitTest.cs文件。

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

目前behaviac组件支持三种方式来处理状态变化或事件发生：并行节点、选择监测节点、事件附件等。

简而言之，并行和选择监测节点的工作方式是采用“轮询”的方式，每次执行时需要重新评估所有子节点，而不是像其他节点会保留上一次正在执行的子节点以便在下一次执行时继续执行。事件附件是在游戏逻辑发出事件时，才按需得到响应。

并行节点

依靠并行（Parallel）节点处理事件，需要把事件用条件的形式表达并且需要监控该条件，当该条件不满足的时候就退出。这种方式在概念上不太清晰，使用起来也比较繁琐，如下图所示：

选择监测节点

选择监测（SelectorMonitor）和监测分支（WithPrecondition）节点作为对传统行为树的扩展，可以很自然的处理事件和状态的改变。选择监测和监测分支节点只能配对使用，即选择监测只能添加监测分支作为它的子节点，监测分支也只能作为选择监测的子节点被添加，如下图所示：

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

事件附件

事件（Event）作为一种附件，是behaviac组件的一大特色。事件主要用于在游戏逻辑发出事件时，得到响应后打断当前正在执行的行为树，并切换到所设置的另一个行为树。

用一个具体例子来说明事件的原理和用法：

• 首先，在编辑器中为AgentNodeTest类添加了event_test_int_bool(int val_int, bool val_bool)这个任务（Task）或者更形象的称之为“接口”（Interface），如下图所示：

• 其次，为行为树event_subtree_2添加一个任务节点，并作为根节点的第一个子节点，为该任务节点选择一个任务，这里我们直接选择event_test_int_bool，如下图所示。类似于编程语言中的函数参数为函数体的代码提供了局部变量，任务节点中的接口参数为当前的行为树提供了局部变量，这些局部变量可以根据需要用于该行为树所有子节点。

• 再次，将上面的行为树event_subtree_2通过鼠标拖拽到行为树event_ut_1中的第一个序列节点上，这样该序列节点就有了一个事件的附件，如下图所示：

• 然后，为该事件设置参数，如下图所示：
  其中，“触发一次”表示该事件是否只触发一次就不再起作用。“触发模式”控制该事件触发后对当前行为树的影响以及被触发的子树结束时应该如何恢复，有转移（Transfer）和返回（Return）两个选项：
  • 转移：当子树结束时，当前行为树被中断和重置，该子树将被设置为当前行为树。
  • 返回：当子树结束时，返回控制到之前打断的地方继续执行。当前行为树直接“压”到执行堆栈上而不被中断和重置，该子树被设置为当前行为树，当该子树结束时，原本的那棵行为树从执行堆栈上“弹出”，并从当初的节点恢复执行。
• 最后，在游戏代码端通过如下代码，将事件“event_test_int_bool”发出，并指定所需的参数（这里是15和true两个值）。

testAgent.FireEvent(“event_test_int_bool”, 15, true);

这样，在执行行为树event_ut_1时，如果接收到事件“event_test_int_bool”，那么行为树中的事件附件将得到响应和处理，行为树的执行就会从当前的event_ut_1跳转到event_subtree_2。

调用FireEvent的时候，只有处于running状态的节点才响应事件。这样子是是为了事件的灵活性的考虑。这个设计是为了允许不同的分支不同的时机同样的事件可以触发不同的行为。比如同样是BeingHit，你受伤的时候，或者逃跑的时候可以对应不同的行为。如果不需要根据不同的节点相应不同的行为，只是需要响应事件，可以把事件配置在根节点上（根节点同样需要是running状态，非running状态的节点没有机会相应事件）。

另外需要补充说明的是，行为树event_subtree_2带有任务节点，我们也可以直接将该行为树拖拽到行为树event_ut_1中，如下图所示：

这样在行为树event_ut_1中，选中引用节点event_test_int_bool后，就可以直接配置该子树执行时所需的参数（这里是val_int和val_bool），如下图所示：

行为树的任务及其参数可以类比编程语言中的函数及其参数，因此event_test_int_bool这个“函数”有两个“形式参数”val_int和val_bool，而上图中所选择的5和true值就是event_test_int_bool函数执行时所用到的“实际参数”。

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

可以查看 test/btunittest/NodeTest/EventUnitTest.cpp

• 调用DebugUpdate()函数来更新一些连调和热加载相关的功能。
• 根据m_bExecAgents来判断是否需要执行所有Agent实例的btexec()函数，可以通过接口Workspace::SetIsExecAgents(bool bExecAgents)对m_bExecAgents进行设置。

具体执行逻辑如下代码所示：

void Workspace::DebugUpdate()
{
    this->LogFrames();
    this->HandleRequests();

    if (this->GetAutoHotReload())
    {
        this->HotReload();
    }
}

void Workspace::Update()
{
    this->DebugUpdate();

    if (this->m_bExecAgents)
    {
        int contextId = -1;

        Context::execAgents(contextId);
    }
}

对于C++版，行为树的执行可以调用behaviac::Workspace::GetInstance()->Update()来执行所有Agent实例的行为树，也可以单独调用Agent的接口btexec()来执行单个实例的行为树。

其中，Workspace::Update()会遍历所有的Agent实例并依次执行btexec()，但在自己的游戏项目中，可能在一帧中需要对某些Agent多次调用btexec()，而另一些Agent只需调用一次，这时候就需要单独调用Agent::btexec()，而不是统一调用Workspace::Update()。

Workspace::Update()在调用Agent::btexec()之前，会检查Agent::IsActive()是否为true，如果为false，那么btexec()就不会被调用。

此外，为了支持连调和热加载，请务必保证在自己游戏的更新函数中调用了DebugUpdate()函数。如果已经调用了behaviac::Workspace::GetInstance()->Update()，那么就不需要再单独调用DebugUpdate()。

上述示例代码虽然是C++，但对于C#，也都是同名的。

特别注意：对于C#版，behaviac.Workspace.IsExecAgents默认设为false。

• 如果将behaviac.Workspace.IsExecAgents设为true，使用behaviac.Workspace.Instance.Update()集中进行更新，Agent自己的更新就不需要调用btexec()了。
• 如果将behaviac.Workspace.IsExecAgents设为false，则不使用behaviac.Workspace.Instance.Update()集中进行更新，Agent自己的更新就需要调用btexec()了。

• behaviac是游戏AI的开发框架组件，也是游戏原型的快速设计工具。支持全平台，适用于客户端和服务器，助力游戏快速迭代开发。
• 编辑器可以运行在PC上，操作方便直观可靠，支持实时和离线调试；编辑器可以导出xml/bson等多种格式，更可以导出C++/C#源码，提供最高效率。
• 运行时支持全平台，有C++/C#两个版本，原生支持Unity。
• 已被多款知名游戏及更多其他预研项目使用。
• 所有代码（包括编辑器和运行时）已经全部开源：https://github.com/Tencent/behaviac

2 背景

游戏AI的目标之一就是要找到一种简单并可扩展的开发逻辑的方案，常用的技术包括有限状态机（FSM）、层次化有限状态机（HFSM）、面向目标的动作规划（GOAP）、层次化任务网络（HTN）等。

行为树作为次时代的AI技术，距其原型提出也约有10年左右，像Halo、Spore、Crysis等大作已经采用。目前，很多知名的游戏引擎也已整合或提供了自己的行为树组件，例如Unreal4、Unity引擎等。

2.1 有限状态机

提到有限状态机（Finite State Machine，FSM），很多程序员都相当熟悉。状态机技术在游戏开发中也已变得很成熟和流行，它反映了从系统开始到现在的输入变化。

• 动作（Action）：指在给定时刻要进行的活动的描述。
• 状态（State）：指对象的某种形态，在当前形态下可能会拥有不同的行为和属性。
• 转换（Transition）：表示状态变更，并且必须满足确使转移发生的条件来执行。
• 状态机（State Machine）：控制对象状态的管理器。对象的状态不会无端的改变，它需要在某种条件下才会变换。状态会在某个事件触发之后变更，不同的状态也有可能决定了对象的不同属性和行为。

如下图2.1所示，有限状态机维护了一张图，图的节点是一个个的状态，节点和节点的连线是状态间根据一定规则所执行的状态转换，每一个状态内的逻辑都可以简要描述为：

• 如果满足条件1，则跳转到状态1；
• 如果满足条件2，则跳转到状态2；
• …；
• 否则，不做任何跳转，维持当前状态。

图2.1 有限状态机

有限状态机有着简单的优势，采用状态机来实现AI更符合思维的朴素表达。对于一些简单的AI，用状态机更加便捷，但是面对一些复杂的AI逻辑就会显得比较繁杂。

同时，当需要对现有行为逻辑进行扩展的时候，代码上会显得比较吃力，因为要维护的状态量会成倍增加。

对于大型的系统，分层有限状态机（HFSM）也支持状态间切换的重用。但是状态机需要用转换连接状态，从而状态失去了模块性。

2.2 行为树

行为树（Behavior Tree，BT），使得实现AI的过程变得更加需要技巧。框架设计者较为全面的考虑了可能会遇到的种种情况，把每种情况都抽象成了某个类型的节点，而游戏开发者要做的就是按照规范把各种节点连接成一棵所需的行为树。这样，行为树更加具有面向对象的特征，行为模块间的藕合度相对较低。

概念上，行为树就是一段脚本，以树的形式展现给用户。节点的执行结果由其父节点来管理，决定接下来做什么。由于节点间不再有转换，因此不再称为状态，节点只是行为。

行为树的基本结构如图2.2所示，行为树由叶子节点和中间节点组成，从左到右依次是父子关系的节点：叶子节点主要是一些动作、条件和赋值等原子操作节点，包含了最基本的行为（如跑动、攻击等），当一个叶子节点被选择后，就会激活其对应的基本行为；中间节点主要是一些组合节点，代表逻辑单元，用于管理子节点如何执行等。

图2.2 行为树

叶子节点和中间节点主要分为五大类节点或附件：动作、条件、组合、修饰、附件等。其中，动作、条件节点为叶子节点，组合、修饰节点为中间节点，附件必须附属在这四类节点上面而不能独立存在。

每个节点执行结束后，都必须将其返回值提供给父节点。节点的返回值包括三种：成功（Success）、失败（Failure）以及正在执行（Running）。最基本的行为（叶子节点）可能执行成功也可能失败，高等级的行为（中间节点）是否执行成功依赖于子节点是否执行成功，子节点执行失败可能导致其父节点选择另一个子节点。
行为树中最常用的节点包括：

• 动作节点（Action）：属于叶子节点，用于描述一个最终执行的动作。
• 条件节点（Condition）：属于叶子节点，用于描述一个条件是否成立。
• 选择节点（Selector）：属于组合节点，用于顺序执行子节点，只要它的一个子节点返回成功，则整个分支返回成功，反之返回失败，类似程序中的逻辑或（OR）。
• 顺序节点（Sequence）：属于组合节点，用于顺序执行子节点，只要它的一个子节点返回失败，则整个分支返回失败，反之返回成功，类似程序中的逻辑与（AND）。

行为树的执行通过帧循环的更新来驱动，不一定是每帧都需要更新，但是需要周期性的执行。基于效率的考虑，行为树的执行有点类似于协程（Coroutine）的概念。如果有返回正在执行的节点，那么在行为树下一次执行的时候会接着执行。否则，一个返回成功或失败也就是已经结束了的行为树，下一次执行就会从根节点重新开始。

一棵行为树首先需要设置一个Agent类型，Agent也就是游戏中的AI角色。在这棵行为树中的所有节点（主要是叶子节点），可以进一步选择Agent的属性、方法以及其他变量等进行配置。这些Agent的类型、属性、方法等信息，称之为类型信息，后文会更详细的对其进行介绍。

行为树的优势如下：

• 行为逻辑和状态数据分离，任何节点都可以反复利用。
• 重用性高，可用通过重组不同的节点来实现不同的行为树。
• 呈线性的方式布局，易扩展。
• 可配置，把工作交给策划。

3 behaviac组件

behaviac组件包括编辑器（Designer）和运行时（Runtime）两大部分：编辑器主要用于编辑行为树，运行时库主要用于解释和执行编辑并导出过的行为树，运行时库需要整合到自己的游戏项目中去。
编辑器和运行时之间通过类型信息（Meta）进行交互，如图3.1所示：

图3.1 基于类型信息的编辑器和运行时端的交互

3.1 类型信息

类型信息是behaviac组件的核心，包括Agent的类型、属性、方法以及类的实例名称等信息。游戏中负责运行行为的实体称谓Agent，每个Agent都存有自己的数据或者能执行自己的动作，这样的数据被称为属性（Property），这样的动作被称为方法（Method）。所谓的类型信息就是对一个Agent的描述，包括其属性和方法等。

运行时库产生一个描述Agent类型信息的XML文件。注意图3.1中类型信息的双向箭头，“双向”表示运行时端可以导出类型信息给编辑器使用，在编辑器中也可以编辑并导出类型信息到运行时端。

在运行时端，也即游戏代码端，通过注册（C++通过宏的方式，C#通过标记Attribute的方式，如代码段3.1.1和3.1.2所示）并导出供行为树引擎和编辑器使用的XML类型信息。运行时端主要是由程序员编写Agent子类及其属性和方法，然后调用相关接口将这些类型信息导出，就可以在编辑器中对这些类型信息进行使用。

BEGIN_PROPERTIES_DESCRIPTION(AgentNodeTest)
{
    //CLASS_DISPLAYNAME(L"测试behaviac::Agent")
    //CLASS_DESC(L"测试behaviac::Agent的说明")
    REGISTER_PROPERTY(testVar_0);
    REGISTER_PROPERTY(testVar_1).DISPLAYNAME(L"testVar_1").DESC(L"testVar_1 property").RANGE(100);
    REGISTER_PROPERTY(testVar_2);
    REGISTER_PROPERTY(testVar_3);
    REGISTER_PROPERTY(waiting_timeout_interval);
    REGISTER_PROPERTY(testVar_str_0);

    REGISTER_METHOD(setEventVarInt);
    REGISTER_METHOD(setEventVarBool);
    REGISTER_METHOD(setEventVarFloat);
    REGISTER_METHOD(setEventVarAgent);
    REGISTER_METHOD(getConstOne);
    REGISTER_METHOD(setTestVar_0);
    REGISTER_METHOD(setTestVar_1);
    REGISTER_METHOD(setTestVar_2);
    REGISTER_METHOD(setTestVar_0_2);
    REGISTER_METHOD(setTestVar_R);
    REGISTER_METHOD(setTestVar_3);
    REGISTER_METHOD(enter_action_0);
    REGISTER_METHOD(exit_action_0);
    REGISTER_METHOD(enter_action_1);
    REGISTER_METHOD(exit_action_1);
    REGISTER_METHOD(enter_action_2);
    REGISTER_METHOD(exit_action_2);
    REGISTER_METHOD(createGameObject);
    REGISTER_METHOD(testGameObject);
    REGISTER_METHOD(createExtendedNode);
    REGISTER_METHOD(testExtendedRefType);
    REGISTER_METHOD(testExtendedStruct);
    REGISTER_METHOD(switchRef);

    REGISTER_METHOD(CanSeeEnemy);
    REGISTER_METHOD(Move);
    REGISTER_METHOD(MoveToTarget);
}
END_PROPERTIES_DESCRIPTION()

代码3.1.1 在C++中通过宏注册类型信息

[behaviac.TypeMetaInfo()]
public class AgentNodeTest : behaviac.Agent
{
    [behaviac.MemberMetaInfo()]
    public int testVar_0 = -1;

    [behaviac.MemberMetaInfo("testVar_1", "testVar_1 property", 100)]
    public int testVar_1 = -1;

    [behaviac.MemberMetaInfo()]
    public float testVar_2 = -1.0f;

    [behaviac.MemberMetaInfo()]
    public float testVar_3 = -1.0f;

    [behaviac.MemberMetaInfo()]
    public int waiting_timeout_interval = 0;

    [behaviac.MemberMetaInfo()]
    public string testVar_str_0 = string.Empty;

    [behaviac.MemberMetaInfo()]
    public string testVar_str_1 = string.Empty;

    public bool m_bCanSee = false;

    public int event_test_var_int = -1;
    public bool event_test_var_bool = false;
    public float event_test_var_float = -1.0f;
    public AgentNodeTest event_test_var_agent = null;
}

代码3.1.2 在C#中通过Attribute标记类型信息

此外，behaviac组件的特色之一就是编辑器中也可以创建和编辑类型信息。编辑器主要交给策划编辑行为树，也可以编辑类型信息。策划在项目开始初期，也就是程序员还没把代码写出来之前，策划就可以自己手动的创建一些Agent类型、属性和方法等类型信息。这样可以加速游戏原型的创建，也就是策划不用等程序员，就可以进行游戏原型的编辑。

如图3.1.3所示，打开编辑器中提供的类型信息浏览器，可以查看或新建Agent类型。选中其中一个Agent类型之后，可以查看它的属性、方法等信息，并可以扩展Agent类型的成员属性和方法等，还支持新建枚举和结构体类型等。

图3.1.3 在类型信息浏览器中查看和编辑类型信息

3.1.1 类型

类型（Type）分为Agent、枚举和结构体等。

• Agent类：作为行为树的基本组成元素，是供其他游戏类派生的基类，在图3.1.3所示的类型信息浏览器中，我们可以查看所有导出和创建的Agent类型，这些Agent类型又包含变量和方法两大部分。可以在类型信息浏览器中添加自己的Agent子类，为其添加成员属性和方法，但方法的实现需要另外编写需要的逻辑代码。
• 枚举：游戏端的用到枚举类型会导出在类型信息文件中，也可以在类型信息浏览器中添加自己的枚举类型，并可以导出生成C++或C#源码，再添加到游戏端代码中。
• 结构体：游戏端的用到结构体类型会导出在类型信息文件中，也可以在类型信息浏览器中添加自己的结构体类型，但只能为其增加成员属性，不能添加成员方法，可以导出生成C++或C#源码，添加到游戏端代码中。

如图3.1.1.1所示，在新建一棵行为树时，首先需要为根节点选择一种Agent类型，以表明当前新建的行为树是用的哪种Agent，该行为树的所有叶子节点将可以使用该Agent类型的属性和方法。

图3.1.1.1 为根节点设置Agent类型

3.1.2 实例

上面已经提及了一棵行为树需要设置它的Agent类型，以便于所有叶子节点使用该Agent类型的属性和方法。对于这种情况，我们称之为使用自身（Self）的属性和方法。

另一方面，某个节点的参数可能会用到不是自身的属性或方法，这时就需要首先选择实例（Instance），然后再选择该实例所属的Agent类型的属性或方法，如图3.1.2.1所示。

所有Agent类的实例在运行时端需要通过注册并导出到类型信息文件中，这样编辑器拿到所有的实例列表后就可以一一列举出来以供选择，具体注册方法详见使用手册。

图3.1.2.1 为条件节点设置左参数

3.1.3 变量

变量分为成员字段（Field）、属性（Property）、自定义的属性以及局部变量等。

• 成员字段：也即面向对象编程（C++/C#）中类的字段。
• 成员属性：也即C#中类的属性，带有getter和setter。
• 自定义的属性：主要是在编辑器中为Agent类型新建出来的成员属性。在变量前有一个‘*’星号标识。如下图。
• 局部变量：在变量前有一个‘-’减号标识。相对于成员属性和自定义的属性这些全局属性而言。为什么称之为全局属性？在整个游戏项目中，可能会有很多棵行为树，我们称之为工作区来管理所有的行为树。每一种Agent类型的成员属性和自定义的属性是可以供这个工作区中的所有行为树选择使用的，而局部变量只是针对某一棵行为树，局限于在这一棵行为树中所使用的变量。

behaviac组件支持变量的只读（Readonly）特性，这样在编辑器中只可以对该属性进行读取，但不能为其赋值。局部变量不仅支持int、float、bool、枚举等基本的数据类型，也支持复杂的指针或引用类型。

3.1.4 方法

方法包括成员方法、自定义的方法、任务（Task）等。

• 成员方法：也即面向对象编程中类的成员方法。
• 自定义的方法：在编辑器中创建出来的方法。自定义的方法只是作为占位符，允许设计人员可以继续工作。使用了自定义方法的行为树不允许导出。只有当程序员实现了该方法后，自定义方法变成了成员方法后该行为树才允许被导出。这个设定是为了保证导出的行为树是可以执行的。
• 任务：用于描述子树所需的接口，包括接口名和参数列表，跟方法的定义类似。后文将结合子树的概念，对任务的用法进行更详细的说明。

最后，在编辑器中就可以根据导出和创建的类型信息，对行为树进行编辑。在行为树的每个节点上可以根据需要选择或设置属性、方法及其参数等，如图3.1.4.1所示。

图3.1.4.1 编辑节点的属性

3.2 工作区

采用behaviac组件开始项目时，首先需要在编辑器中创建一个工作区（Workspace）。

工作区文件以.workspace.xml为后缀名，是管理游戏项目中所有行为树文件的配置文件，如图3.2.1所示：

图3.2.1 工作区文件

该配置文件可以指定XML类型信息文件、行为树源文件的路径、导出文件的路径等，可以通过编辑器中的“新建工作区”或“编辑工作区”工具编辑相关设置，如图3.2.2所示：

图3.2.2 编辑工作区

行为树源文件和导出文件的区别在于，行为树源文件是在编辑器中供策划编辑使用的初始源文件（XML格式），包含了很多冗余的信息，比如UI显示所需的属性等。而导出文件是一种精简版的行为树文件，只是给运行时端使用的一种高效的执行文件。

源文件就像那些Raw Data，必须导出后才能在运行时中使用，而导出文件就像那些处理过并在游戏中直接使用的Game Data。工作区文件、源文件、类型信息文件等在游戏中都不再需要，游戏中只需要导出的文件。

目前支持XML、BSON、C++和C#四种导出格式。其中，XML/BSON主要用于开发阶段，C++/C#主要用于最后的发布。C++/C#的内存和性能明显要优于XML/BSON的格式，所以我们建议在最后的发布过程，使用C++/C#的行为树导出文件。

3.3 行为树

behaviac组件提供了数量繁多、功能齐全的节点和附件，并支持扩展自己所需的节点类型。此外，behaviac组件还支持子树、事件、预制等高级用法，下面将一一进行介绍。

3.3.1 节点与附件

前面已经介绍，行为树的节点主要分为五大类节点或附件：动作、条件、组合、修饰、附件等，如图3.3.1所示。其中，动作、条件节点为叶子节点，组合、修饰节点为中间节点，附件必须附属在这四类节点上面而不能独立存在。

behaviac组件还支持扩展新的节点类型，具体用法可以详见使用手册中的介绍。

图3.3.1.1 行为树的节点和附件

为了支持子树（Subtree）的功能，behaviac组件还提供了引用节点（ReferencedBehavior）类型，后文将对子树和引用节点详细介绍。

节点可以具有前置（Preaction）和后置（Postaction）等附件，如图3.3.2所示。前置可以表示执行某个条件或者某个操作，如果是条件，那么前置必须返回成功后才能继续执行所在的节点，否则直接返回到父节点。而后置只用于表示该节点执行完毕后继续执行的操作。

图3.3.1.2 节点上的前置和后置

还有一种附件比较特殊，也即事件（Event）。事件是将一棵行为树作为另一棵行为树中某个节点（一般为根节点）的附件，用于响应事件发生时行为树的切换。后文将对事件进行更详细的说明。

为了支持某些特殊应用，behaviac组件还为序列（Sequence）、选择（Selector）等组合节点添加了中断条件（Interrupted Condition），如图3.3.1.3所示。增加中断条件是为了让序列节点（或其他组合节点）在依次执行每个子节点的时候，都需要根据该中断条件的执行结果，来判断是否需要执行当前子节点。也即，所有的子节点有一个统一的中断条件被打断执行。

图3.3.1.3 中断条件

在编辑器中，可以通过鼠标拖拽这些节点到新建的行为树中，或拖拽前置和后置附件到某个节点上。

3.3.2 预制

为了方便或加速行为树的编辑，behaviac编辑器提供了预制（Prefab）的功能，以便利于复用已经编辑好的行为树。

behaviac组件的预制跟Unity引擎中的预制工作机制类似，如果在用到预制的地方改变了预制中某个节点的属性，那么就会在所在的行为树中创建一份该预制的实例（Instance）。如果没有改变预制中任何节点的属性，则直接跟预制母体的属性保持一致，也即修改了预制中任何节点的属性，用到该预制的其他行为树也跟着同步改变。

在编辑器中，可以将已经编辑好的行为树另存为预制，这些预制会组织在Prefabs目录下，以便区分于项目所需的行为树（归类在Behaviors目录下），如图3.3.2.1所示。

图3.3.2.1 行为树与预制

如图3.3.2.2所示，先构建了一个预制行为树“Prefab_安全的随机移动”。

图3.3.2.2 预制

如图3.3.2.3所示，再将该行为树拖拽进行为树Tank_SafeWander_RandomFire中，可以看到该预制行为树会得到展开并复制过去，这加速了行为树的编辑，提高了开发工作的效率。

图3.3.2.3 使用预制的行为树

3.3.3 子树与递归

在编辑器中，可以通过鼠标拖拽一棵行为树到另一棵行为树中，并作为引用节点（ReferencedBehavior）添加到另一棵行为树上。如图3.3.3.1所示，action_ut_0就是action_ut_1的子树，action_ut_0所在的节点是一个引用节点。

图3.3.3.1 子树

有了子树的功能，behaviac组件自然也支持了“递归”的功能，只要将当前行为树作为自己的子树即可。形成递归的时候需要注意不要造成死循环，这可以通过变量的使用来避免。

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

图3.3.3.2 递归

3.3.4 事件处理

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

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

3.3.5 热加载

behaviac组件中的编辑器和运行时库都支持热加载，但是只针对XML/BSON格式的行为树文件。

在编辑器中，只要当前打开的行为树文件在编辑器外由于某种原因得到修改（例如通过项目中的文件版本管理系统强制同步行为树文件，或者通过文本编辑器强制修改行为树XML文件等），那么都可以自动的在编辑器中得到刷新。

对于运行时端（或游戏端），只要在编辑器中修改了行为树文件并重新导出，那么在游戏运行过程中不用退出游戏，最新导出的行为树可以自动进行加载，这样就可以及时查看行为树最新的效果。

请详看文档《热加载》。

3.4 有限状态机

除了上面提及的行为树，behaviac组件还支持传统的有限状态机（FSM）。在前面的2.1章节已经说明，有限状态机主要由状态（State）和转换（Transition）构成，如图3.4.1所示。

图3.4.1 有限状态机

类似于前面提及的行为树子树的概念，behaviac组件的一大特色就是支持将编辑好的一个有限状态机整体作为另一个有限状态机的“子树”，甚至有限状态机还可以跟行为树交替引用，互相作为彼此的子树，也即一个有限状态机可以整体作为一棵行为树的“引用节点”，同时一棵行为树也可以整体作为一个有限状态机中的“引用状态”。

在behaviac编辑器中，状态是作为类似行为树的节点一样独立存在，而转换是为类似行为树中的附件一样挂在某个状态上。有限状态机的编辑也很简单，只需要通过鼠标拖拽“状态”节点和“转换”附件到新建的有限状态机中，如图3.4.2所示。

图3.4.2 有限状态机的状态和转换

类似于行为树中的节点，还可以为有限状态机中的状态节点添加前置和后置附件，以表示执行到当前状态节点时，所需要执行的前置条件和后置操作。

3.5 调试

编辑器支持跟游戏端进行连调，如图3.5.1所示。

图3.5.1 连接游戏

支持查看属性的变化（图3.5.2）、在节点上设置断点（图3.5.3）、高亮显示行为树的执行路径（图3.5.3）以及记录每帧信息以便后续查看等功能。

图3.5.2 查看Agent的属性

图3.5.3 设置断点以及高亮显示执行路径

3.6 单元测试与

为了方便入门，behaviac组件提供了C++和C#两种编程语言的单元测试以及游戏Demo，可以通过编辑器中的菜单项“帮助”->“控制说明” 进入，然后点击快速打开所需的单元测试或游戏Demo所用到的工作区，如图3.6.1所示。

图3.6.1 单元测试与Demo

3.7 开源

behaviac组件已在github上开源，网址是https://github.com/Tencent/behaviac，可以下载最新的安装包、源码以及相关文档等。

另外，behaviac视频讲解的链接为：http://gad.qq.com/tool/detail/2

添加新的节点类型，编辑器端需要实现一个插件，运行时端需要实现相应的节点类型以便加载数据并且负责执行。

编辑器端的插件

随项目提供了ExamplePlugin，可以根据该插件做相应的修改来添加自己的新节点。该项目所在路径：tools/Designer/Plugins/ExamplePlugin。

项目设置

• 该项目依赖如下DLL，如下图所示：

• 产生的DLL需要放置在BehaviacDesigner.exe同一个目录。
• 如果自己的插件只是对ExamplePlugin修改了相应的名字，并且该插件项目和ExamplePlugin的所在位置一样，即位于tools/Designer/Plugins中，那么对BehaviacDesignerBase.dll的引用以及产生DLL的输出路径不需要改动即可。否则，如果有编译错误或者运行时不能看到添加的节点，请确保上面两个步骤的设置都是正确的。
• 打开编辑器后，正常情况下新加的节点ExampleNode将出现在动作组下，如下图所示：

节点类型

每一个要添加的节点类型，都需要仿照ExampleNode或相应的节点新建文件ExampleNode.cs，并编写类ExampleNode的实现。

• 该类的Attribute（即NodeDesc）用来指定该节点出现的组和图标（icon）。如果使用自己的图标文件，则需要添加进工程的Resources.resx文件中，假如该图标命名为“exampleNodeIcon”，并使用如下代码：
  [NodeDesc(“Actions”, “exampleNodeIcon”)]
• 构造函数里需要提供显示用的名字（DisplanName）和描述（Description）
• ExportClass用来指定该类导出供C++载入时的类名。
• 根据需要添加自己的属性（Property），这些属性在designer里将会自动的显示出来供用户指定数据。
• 如果上一步添加了属性，那么需要重载protected override void CloneProperties(Node newnode)，来clone这些新加的属性。
• 重载public override void CheckForErrors(BehaviorNode rootBehavior, List result)来验证数据的有效性已经提供无效时的说明。
• 此外，还需编写生成新加节点类型的C++或C#相关的代码，参考“5.4扩展生成节点或编程语言”。这里介绍用于生成C++代码的相关类和接口（生成C#完全类似）：
  • 添加文件ExampleNodeCppExporter.cs（注意，必须是CppExporter结尾，若是生成C#，则必须以CsExporter结尾，后面类推），编写类ExampleNodeCppExporter的实现。
  • 根据新加节点的需要，重载GenerateConstructor、GenerateMember、GenerateMethod等函数。
  • 其他细节请参考样例代码的实现。

属性

• 属性（Property）的类型可以是基本类型如bool、int、float、string等
• 可以是VariableDef、MethodDef，RightValueDef来表示访问Agent的属性或方法。
• 可以是结构体（Struct）、数组（Array）或结构体的数组。
• 可以是枚举（Enum）或枚举的数组。
• 需要提供相应的Attribute来描述该属性的类型信息，比如，显示名、描述、范围、显示顺序等。请注意属性的类型必须与相应的Attribute的类型保持一致。
  • DesignerBoolean
  • DesignerInteger
  • DesignerFloat
  • DesignerString
  • DesignerTypeEnum
  • DesignerStruct
  • DesignerPropertyEnum
  • DesignerRightValueEnum
  • DesignerMethodEnum
  • DesignerArrayStruct
  • DesignerArrayBoolean
  • DesignerArrayInteger
  • DesignerArrayFloat
  • DesignerArrayString
  • DesignerArrayEnum

运行时端需要实现相应的节点类型

节点类型包括叶子节点和分支节点，而分支节点又分为组合节点（Composite）或装饰节点（Decorator）。需要根据具体的节点类型从相应的基类继承来创建自己的节点类。
每个节点类型需要两个相应的类：一个是静态Node，这个是静态的数据，负责load数据以及创建相应的动态节点；另一个是动态Task。
详细代码请参考action.h、condition.h或waitframes.h等头文件。

静态Node

静态的Node必须提供的两个虚函数如下：

• virtual void load(int version, const char* agentType, const properties_t& properties);
• virtual BehaviorTask* createTask() const;
• BehaviorNode::Register<***>();进入程序前需要注册该静态的Node类型，动态的Task类不需要注册。
• BehaviorNode::UnRegister<***>();结束程序前需要反注册该静态的Node类型，动态的Task类不需要反注册。

动态Task

对应静态Node，动态Task需要提供下列虚函数：

• virtual void copyto(BehaviorTask* target) const;
• virtual void save(ISerializableNode* node) const;
• virtual void load(ISerializableNode* node);
• virtual bool onenter(Agent* pAgent);
• virtual void onexit(Agent* pAgent, EBTStatus s);
• virtual EBTStatus update(Agent* pAgent, Interval_t& interval, EBTStatus childStatus);

如果没有特殊需要，则直接调用super的函数就可以了。

对于C++版，需要按照如下方式进行注册：

基本类型（bool、int、float、char、sbyte、ubyte等）的数组可以直接使用，但当使用到其他自定义类型数组的时候，需要添加特殊的宏和代码，否则运行时可能会有错误（如果没有使用到相应的操作，则没有错误）：

• 在.h的头文件里添加如下所示的宏，但需放在任意namespace之外：

BEHAVIAC_DECLARE_TYPE_VECTOR_HANDLER(TNS::ST::PER::WRK::kEmployee);

• 在初始化的代码里添加如下所示的注册代码：

behaviac::TypeRegister::Register<TNS::ST::PER::WRK::kEmployee>(" TNS::ST::PER::WRK::kEmployee");

• 在结束代码里添加如下所示的反注册代码：

behaviac::TypeRegister::UnRegister<TNS::ST::PER::WRK::kEmployee>(" TNS::ST::PER::WRK::kEmployee");

更多细节可以参考behaviac组件C++源码中附带的UnitTestTypes.h文件中的结构体kEmployee。

• Agent及其子类的数组
  当涉及behaviac::Agent或是其子类的时候，仅支持其指针类型即behaviac::Agent*或SubclassAgent*（SubclassAgent是behaviac::Agent的一个子类）。
  behaviac::Agent*或vector<behaviac::Agent*>类型直接被支持，不需要做什么额外的工作，其任何子类SubclassAgent*也直接被支持。
  但是需要支持vector<SubclassAgent*>的时候，则需要在.h文件里添加如下所示的宏，但需放在任意namespace之外：

BEHAVIAC_DECLARE_TYPE_VECTOR_HANDLER(SubclassAgent*);

在初始化和结束的时候分别注册和反注册：

behaviac::Agent::Register<SubclassAgent>();

behaviac::Agent::UnRegister<SubclassAgent>();

更多细节可以参考behaviac组件C++源码中附带的EmployeeParTestAgent.h文件中的类EmployeeParTestAgent。

• 在编辑器中新建一个工作区，并根据上一步中导出的元数据文件所在的文件夹，设置该工作区的“元数据位置”，可以看到demo_running.xml文件已经可以使用，如下图所示：

• 新建行为树文件，并为该行为树添加一些节点，选择某个节点后，可以设置该节点的属性（可选属性正是来至上面导出的元信息），如下图所示：

编辑元信息

• 前面介绍的是在运行时（游戏）端编写代码导出元信息到编辑器中，behaviac组件也支持在编辑器中创建和编辑元信息。
• 在编辑器中，通过菜单项“视图”->“元信息浏览”（或快捷键Ctrl+M）打开元信息浏览器，如下图所示：

• 类型列表：左上方的“类型列表”显示了所有的Agent类、自定义的枚举和结构体类型，其右侧是当前选中的类型的属性。“类型列表”中的名字前面带有“*”，表示该类型是在编辑器中创建出来的。创建一个类型（Agent类、枚举或结构体），可以点击元信息浏览器右上角的“新增”按钮，如下图所示。后文将提到对这些新增的类型，导出时会自动生成相应的C++或C#源码文件，这样程序员就可以在生成的源码文件基础上添加和实现自己的游戏逻辑。

• 实例名称：元信息浏览器中的“实例名称”，用于列出当前选中的Agent类型的所有实例，这些实例是通过之前提及的Agent::RegisterInstanceName接口在运行时端注册并导出的。如果当前选中的Agent类型没有导出任何实例，那么这一行显示为空白。
• 成员类型：成员类型包括属性（Property）、方法（Method）和任务（Task）。
• 成员列表：选中了上面的“成员类型”后，会列出当前选中的类型的所有成员属性、方法或任务。如果是自定义的成员，那么在列表中的名字前会多出一个“*”。点击“成员列表”右侧的“新增”按钮，可以新增一个成员，可以通过选中“是否局部变量”，将该变量标记为局部变量（在列表中的名字前会多出一个“-”），如下图所示。新增一个方法或任务也类似。选中某个成员后，在元信息浏览器下方会列出该成员的所有属性。

只要在元信息浏览器中编辑了元信息，那么点击元信息浏览器下方的“应用”或“确认”按钮后，编辑器就会在工作区源文件所在目录的保存出一个名为“behaviac.bb.xml”的文件，如下图所示：

后文我们将介绍，这个“behaviac.bb.xml”文件也会跟其他行为树源文件一并导出给运行时库。

1 新建工作区

打开编辑器，点击菜单项“文件”->“新建工作区”新建一个自己的工作区，如下图所示：

图1.1 新建工作区

暂不设置“元数据位置”，表示没有从运行时端导出任何元信息文件，元信息都会在编辑器中创建出来。

点击确认，创建完之后，整个编辑器几乎是空的，如下图所示：

图1.2 初始的编辑器

2 新建行为树

从工具栏中点击“新建行为树”按钮，开始创建我们的第一棵行为树，如下图所示：

图2.1 新建行为树

创建后，将这棵行为树命名为“first_behavior”，如下图所示：

图2.2 第一棵行为树

从图2.2中可以看出这棵行为树只有一个根节点，鼠标点击该根节点后，可以看到它的Agent类型只有一个behaviac::Agent可以选择，但是不要选它，如下图所示：

图2.3 根节点的Agent类型

3 新建自定义的Agent子类及其属性和方法

为了让行为树可以描述一个Agent类型，首先需要创建一个我们的Agent子类，通过菜单项“视图”->“元信息浏览”（或通过快捷键Ctrl+M）打开元信息浏览器，如下图所示：

图3.1 元信息浏览器

点击元信息浏览器右上角的“新建”按钮，开始创建我们的第一个Agent子类，命名为FirstAgent，如下图所示：

图3.2 新建Agent子类

从上图可以看出，FirstAgent类没有任何的成员属性和方法，我们接着为其添加属性和方法。

点击元信息浏览器中间靠右的“新建”按钮，为FirstAgent类添加第一个成员属性，如下图所示：

图3.3 开始添加成员属性

为这个属性命名为FirstProperty，并设置为int类型，如下图所示：

图3.4 新建成员属性

创建完之后，我们可以看到，FirstAgent类已经有了第一个成员属性FirstProperty，如下图所示：

图3.5 第一个成员属性

类似的，在元信息浏览器中，选择“成员类型”为“Method”，为FirstAgent类添加第一个成员方法，如下图所示：

图3.6 新建成员方法

创建完之后，我们可以看到，FirstAgent类已经有了第一个成员方法FirstMethod，如下图所示：

图3.7 第一个成员方法

这样，我们的第一个Agent子类（FirstAgent）就有了一个成员属性（FirstProperty）和一个成员方法（FirstMethod）。

在元信息浏览器上点击下面的“确认”按钮，关闭元信息浏览器，回到编辑器主视口，继续编辑之前创建的第一棵行为树。

4 编辑行为树

鼠标选中根节点，为其设置Agent类型，这时，我们可以看到有了FirstProperty可供选择，如下图所示：

图4.1 设置Agent类型

编辑该行为树，通过鼠标将左边的节点列表中的节点拖拽到主视口中，为该行为树添加一个序列节点、一个条件节点和一个动作节点，如下图所示：

图4.2 为行为树添加节点

为条件节点选择刚才创建的属性FirstProperty，如下图所示：

图4.3 设置条件节点

为动作节点选择刚才创建的方法FirstMethod，如下图所示：

图4.4 设置动作节点

这样，我们就编辑完了第一棵行为树。

注意，如果点击当前行为树主视图窗口右上角的“检查错误”按钮，如下图所示：

图4.5 检查错误

检查当前行为树是否包含错误，将会弹出如下图所示的错误信息提示框：

图4.6 错误信息提示框

如何消除该错误，请查看使用说明文档动作节点。

5 生成C++源码文件

为了方便讨论，下面只介绍生成C++源码文件，生成C#源码文件的流程基本类似，也可以分别参考下面两篇文档：

• 导出和使用C++行为树
• 导出和使用C#行为树

开始导出C++源码文件，点击工具栏中的“导出行为树”按钮，如下图所示：

图5.1 开始导出C++源码文件

弹出导出行为树设置窗口，我们看到“first_behavior”是一棵“有错误的行为树”，暂时忽略这个错误，直接选择下面的“导出设置”，只选择“C++ Behavior Export”，如下图所示：

图5.2 导出C++源码文件

点击“C++ Behavior Export”最右侧的“…”按钮，弹出如下图所示的配置窗口：

图5.3 导出C++源码文件设置

在上图中，暂时不用修改任何设置，只需使用默认值，直接点击“确认”按钮，回到图5.2中的导出行为树窗口，点击“导出”按钮。

导出结束后，在工作区设置的导出路径（本文示例中的导出路径是“D:\test\exported”）中，会生成“behaviac_generated”文件夹，里面又有“types”文件夹，可以看到包含了“FirstAgent.h”和“FirstAgent.cpp”文件。

这两个文件正是编辑器为运行时自动生成FirstAgent类的源码文件，需要程序员接着实现该类的其他属性和方法逻辑等代码，并添加进自己的游戏项目中去。

“FirstAgent.h”文件内容如下所示：

// ---------------------------------------------------------------------
// This agent file is auto-generated by behaviac designer, but you should
// implement the methods of the agent class if necessary!
// ---------------------------------------------------------------------

#ifndef BEHAVIAC_FIRSTAGENT_H
#define BEHAVIAC_FIRSTAGENT_H

#include "behaviac/behaviac.h"

class FirstAgent : public behaviac::Agent
{
public:
	FirstAgent();
	virtual ~FirstAgent();

	DECLARE_BEHAVIAC_AGENT(FirstAgent, behaviac::Agent)

public:
	int FirstProperty;

public:
	int FirstMethod();

};

BEHAVIAC_DECLARE_TYPE_VECTOR_HANDLER(FirstAgent*);

#endif

“FirstAgent.cpp”文件内容如下所示：

// ---------------------------------------------------------------------
// This agent file is auto-generated by behaviac designer, but you should
// implement the methods of the agent class if necessary!
// ---------------------------------------------------------------------

#include "FirstAgent.h"

FirstAgent::FirstAgent()
{
	FirstProperty = 0;
}

FirstAgent::~FirstAgent()
{
}

BEGIN_PROPERTIES_DESCRIPTION(FirstAgent)
{
	// CLASS_DISPLAYNAME(L"FirstAgent");
	// CLASS_DESC(L"");

	REGISTER_PROPERTY(FirstProperty);

	REGISTER_METHOD(FirstMethod);
}
END_PROPERTIES_DESCRIPTION()

int FirstAgent::FirstMethod()
{
	// Write your logic codes here.

	return 0;
}

6 导出元信息文件

将上面自动生成的“FirstAgent.h”和“FirstAgent.cpp”文件添加到自己的游戏项目中，并参考C++元信息的注册和导出的做法导出元信息文件。

这里我们假设生成的元信息文件名为“firstagent.xml”，并放在meta文件夹中，meta文件夹放在这个工作区的路径中，如下图所示：

图6.1 元信息文件

回到编辑器中，点击菜单项“文件”->“编辑工作区”，为当前的工作区设置“元信息位置”，如下图所示：

图6.2 设置元信息位置

点击工具栏中的“重新加载”按钮，重新加载整个工作区，如下图所示：

图6.3 重新加载工作区

重新加载整个工作区之后，再次打开我们的第一棵行为树“first_behavior”，然后点击主视口中右上角的“检查错误”按钮，如下图所示：

图6.4 检查错误

这个时候，我们发现该行为树已经没有任何错误，可以导出了，这里我们只导出XML行为树，如下图所示：

图6.5 开始导出XML行为树

导出结束后，在工作区的导出路径下，导出了我们的第一棵行为树，如下图所示：

图6.6 第一棵导出的XML行为树

有了导出的行为树，就可以参考C++运行时端的使用上手的做法开始使用运行时库。

7 导出行为树

需要注意的是，如果行为树使用到了这里在编辑器里创建的’自定义方法’的话，那个行为树是不允许导出的。因为运行时还没有实现那个方法，如果运行时试图运行那个行为树的话，由于那个方法没有定义，没办法处理。

这种情况下，编辑器只是作为‘设计’工具。

namespace TNS
{
    namespace NE
    {
        namespace NAT
	{
            enum eColor
	    {
	        RED,
                GREEN,
                BLUE,
                YELLOW,
                WHITE,
	    };
	}
    }
}

DECLARE_BEHAVIAC_ENUM(TNS::NE::NAT::eColor, eColor);

• 在.cpp文件中，通过一系列宏注册该枚举自身的描述及其枚举值：
  • 宏BEGIN_ENUM_DESCRIPTION和END_ENUM_DESCRIPTION表示枚举信息注册的开始和结束。
  • 可选的宏ENUMCLASS_DISPLAY_INFO用于注册枚举自身的显示名和描述。
  • 宏DEFINE_ENUM_VALUE用于注册枚举的值，可以通过.DISPLAYNAME的追加方式为值添加显示名，通过.DESC的追加方式为值添加描述。
    如下代码样例所示：

BEGIN_ENUM_DESCRIPTION(TNS::NE::NAT::eColor, eColor)
{
    ENUMCLASS_DISPLAY_INFO(L"色彩枚举", L"eColor是用于测试枚举使用的类型");

    DEFINE_ENUM_VALUE(TNS::NE::NAT::RED, "RED").DISPLAY_INFO(L"红色", L"激进");
    DEFINE_ENUM_VALUE(TNS::NE::NAT::GREEN, "GREEN");
    DEFINE_ENUM_VALUE(TNS::NE::NAT::BLUE, "BLUE");
    DEFINE_ENUM_VALUE(TNS::NE::NAT::YELLOW, "YELLOW");
    DEFINE_ENUM_VALUE(TNS::NE::NAT::WHITE, "WHITE");
}
END_ENUM_DESCRIPTION()

• 在初始化注册（Register）的部分需要加上如下的代码，反注册（UnRegister）的部分添加相应UnRegister的代码。注意这部分Register/UnRegister的代码不是必须的，如果该类型没有用作par或者没有用作条件比较，就可以不需要。

behaviac::TypeRegister::Register< TNS::EnumTest >(" TNS::EnumTest ");

behaviac::TypeRegister::UnRegister< TNS::EnumTest >(" TNS::EnumTest ");

更多细节可以参考behaviac组件C++源码库中btunittest工程的UnitTestTypes.h文件中eColor结构体相关的代码。

struct TypeTest2_t
{
    int	  name;
    float weight;
    bool  bLive;

    DECLARE_BEHAVIAC_STRUCT(TypeTest2_t);
};

上面的用法定义出来的TypeTest2_t在导出的元信息中为值类型（也即在导出的元信息中其值IsRefType为false），值类型可以在编辑器中设置其成员属性。与值类型对应的是引用类型，引用类型不会导出其成员属性，在编辑器中也不用配置其成员属性。

另外，宏DECLARE_BEHAVIAC_STRUCT也可以带2个参数，第一个参数为类型，第二个参数为true表示该类型用作为引用类型（也即导出元信息后其值IsRefType为true），否则不用第二个参数表示为值类型，如下代码所示：

DECLARE_BEHAVIAC_STRUCT(TypeTest2_t, true);

• 在.cpp文件中，通过一系列宏注册该类或结构体自身的描述及其属性：

BEGIN_PROPERTIES_DESCRIPTION(TypeTest2_t)
{
    CLASS_DISPLAYNAME(L"测试结构体")
    CLASS_DESC(L"自定义结构体")

    REGISTER_PROPERTY(name);
    REGISTER_PROPERTY(weight).DISPLAYNAME(L”重量”);
    REGISTER_PROPERTY(bLive) .DISPLAYNAME(L”是否活着”).DESC(L”存活状态”);
}
END_PROPERTIES_DESCRIPTION()

• 在初始化注册（Register）的部分需要加上如下的代码，反注册（UnRegister）的部分添加相应UnRegister的代码。注意这部分Register/UnRegister的代码不是必须的，如果该类型没有用作par或者没有用作条件比较，就可以不需要。

behaviac::TypeRegister::Register< TypeTest2_t >(" TypeTest2_t ");

behaviac::TypeRegister::UnRegister< TypeTest2_t >(" TypeTest2_t ");

更多细节可以参考behaviac组件C++源码库中btunittest工程的reflectionunittest.cpp文件中TypeTest2_t结构体相关的代码。

• 有些类型是程序中本来就有的，该类型可能是某个第三方库中提供的，但这些类型是不方便随意修改的。
• 另外一些可以随便修改的类型，请参考自定义类或结构体。

字符串和数组类型

需要注意的是，behaviac组件为了支持C++的反射系统，对字符串和数组类型有如下要求：

• 字符串：不要使用std::string，需要使用behaviac::string，因为behaviac::string使用了自定义的allocator，可以对内存的使用进行统一的管理。
• 数组：不要使用std::vector，需要使用behaviac::vector。

char类型

此外，需要对char、signed char和unsigned char做出一些必要的说明：

• 在C++中，char、signed char和unsigned char是三个不同的类型。
• 在编辑器中，分别对应char、sbyte、ubyte。
• 对于C#，char、sbyte和byte是基本类型，分别对应编辑器中的char、sbyte和ubyte。

扩展使用已有的类型

对于已有的不能修改源码的类型，需要按照如下步骤进行扩展：

• 在.h文件中，通过宏BEHAVIAC_EXTEND_EXISTING_TYPE特化某个需要的类型。
  如下代码样例所示（假设TestNS::Float2是某个第三方库中的类型，需要用到但不能修改它）：

BEHAVIAC_EXTEND_EXISTING_TYPE(myFloat2, TestNS::Float2);

• 定义一个“相似”的struct（myFloat2），该struct的作用是用来定义那个已存在的类的成员，以便behaviac能够访问该类。
• 通过DECLARE_BEHAVIAC_STRUCT的第二个参数isRefType为true或false表示该类型是否为引用类型，如下代码所示。

struct myFloat2
{
    float x;
    float y;

    DECLARE_BEHAVIAC_STRUCT (myFloat2, false);

    myFloat2()
    {
    }

    myFloat2(const TestNS::Float2& v) : x(v.x), y(v.y)
    {
    }
};

• 在命名空间StringUtils的嵌套子空间Private中实现该类型的ToString()和FromString()函数。注意myFloat2中需要实现相应的转换构造函数（myFloat2(const TestNS::Float2& v)），如下代码样例所示：

namespace behaviac
{
    // ValueToString & ValueFromString
    namespace StringUtils
    {
        namespace Private
        {
            template<>
            inline behaviac::string ToString(const TestNS::Float2& val)
            {
                //myFloat2::ToString is defined by DECLARE_BEHAVIAC_STRUCT(myFloat2)
                myFloat2 temp(val);
                return temp.ToString();
            }

            template<>
            inline bool FromString(const char* str, TestNS::Float2& val)
            {
                myFloat2 temp;

                //myFloat2::FromString is defined by DECLARE_BEHAVIAC_STRUCT(myFloat2)
                if (temp.FromString(str))
                {
                    val.x = temp.x;
                    val.y = temp.y;
                    return true;
                }

                return false;
            }
        }
    }
}

• 实现该类型的模板函数SwapByteTempl()，注意该函数不能放在任何命名空间（namespace）中，如下代码样例所示：

template< typename SWAPPER >
inline void SwapByteTempl(TestNS::Float2& v)
{
    SwapByteTempl< SWAPPER >(v.x);
    SwapByteTempl< SWAPPER >(v.y);
}

• 在命名空间behaviac的嵌套子空间Details中实现该类型的Equal()模板函数，如下代码样例所示：

namespace behaviac
{
    namespace Details
    {
        template<>
	inline bool Equal(const TestNS::Float2& lhs, const TestNS::Float2& rhs)
        {
	    return Tag::IsEqualWithEpsilon(lhs.x, rhs.x) && Tag::IsEqualWithEpsilon(lhs.y, rhs.y);
	}
    }
}

• 在初始化注册（Register）的部分需要加上如下的代码，反注册（UnRegister）的部分添加相应UnRegister的代码。注意：这部分Register/UnRegister的代码不是必须的，如果该类型没有用作par或者没有用作条件比较，就可以不需要。

behaviac::TypeRegister::Register<TestNS::Float2>("TestNS::Float2");

behaviac::TypeRegister::UnRegister<TestNS::Float2>("TestNS::Float2");

详细代码可以参考behaviac组件C++源码库中btunittest工程的extendstruct.h文件。

在编辑器中，只要当前打开的行为树文件在编辑器外由于某种原因得到修改（例如，通过项目中的文件版本管理系统强制同步行为树文件，或者通过文本编辑器强制修改行为树XML文件等），那么都可以自动的在编辑器中得到刷新。

对于运行时端（或程序端），只要在编辑器中修改了行为树文件并重新导出，那么在游戏运行过程中不用退出游戏，最新导出的行为树就可以自动进行加载。这样可以及时查看或使用行为树最新的修改效果。

行为树的更新执行流程请参考更新流程。

为了启动热加载功能，需要确保在运行时端直接或间接调用了Workspace::DebugUpdate()函数，有两种方式：

• 如果Agent的行为树是通过调用Workspace::Update()来集中执行的，则无需额外调用Workspace::DebugUpdate()函数
• 如果Agent的行为树是通过调用Agent::btexec()来执行的，则需要游戏每次更新时调用Workspace::DebugUpdate()函数

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