编辑器的使用

新建工作区

工作区用于管理整个项目的配置，包括一些位置和语言等参数。

视频

打开编辑器，点击菜单项“文件”->“新建工作区”，弹出新建工作区窗口，如下图所示：

• 工作区位置：保存工作区文件的目录，在该目录下会保存出*.workspace.xml的文件，该文件即是编辑器打开的工作区文件（或者称之为项目文件）。
• 行为树源位置：对既有服务器，又有客户端的项目开发，可能需要共用行为树，这时候只要为服务器和客户端分别创建工作区，然后为它们设置相同的“行为树源位置”即可。这样，只需要编辑同一份行为树，就可以让服务器和客户端的AI逻辑保持一致。此外，源位置中还自动生成behaviac_meta文件夹，里面保存了跟工作区同名但后缀名为*.meta.xml的类型信息文件。
• 行为树导出位置：在该目录下，导出编辑好的行为树，并且需要在程序端设置的加载位置，以便程序运行起来后，加载所需的行为树。
• 代码生成位置：用于存放后面将要描述的类型信息浏览器中编辑好的类型代码文件，还包含了一些“胶水”代码文件，都需要整合到运行时（游戏端）一起编译构建。
• 程序端开发语言：可选cpp（即C++）和cs（即C#）两种，表示程序端的代码语言。结合上面所说的情况，可以支持服务器和客户端采用不同的语言编写代码，但共用同一份行为树数据。

“胶水”代码：是指编辑器自动生成的代码文件，用于注册类型信息，并用于程序端执行时通过名字或ID调用类的成员属性或方法。

点击确认后，就可以创建自己的工作区。创建完工作区之后，后续如果需要修改工作区中的参数，可以通过菜单项“文件”->“编辑工作区”，重新打开上图所示的窗口来修改相关的参数。

另外，还可以直接打开为本教程建好的工作区。点击菜单项“文件”->“打开工作区”，找到安装或源码包目录中的tutorials/tutorial_1/workspace文件夹，打开tutorial_1_cpp.workspace.xml文件，如下图所示：

编辑类型信息

为了让行为树可以描述某个Agent类型的行为，首先需要创建自己的Agent子类。

视频

通过菜单项“视图”->“类型信息”（或快捷键Ctrl+M），打开类型信息浏览器，可以看到当前类型列表中只有一个默认生成的behaviac::Agent基类，如下图所示：

点击右上角的“新增”按钮，弹出“新增类型”窗口，如下图所示：

• 将“类型”选择为“Agent”
• 将“名称”设置为“FirstAgent”
• 右上方的“生成代码?”默认是勾选上的，表示编辑器要自动生成该类型的代码文件，否则该类型代码需要手工编写
• “生成位置”是生成该类型文件所在的文件夹，默认不用设置，表示默认生成在工作区中配置的“代码生成位置”里面

点击“确定”按钮后，可以看到类型列表中有了“FirstAgent”这个类，如下图所示：

选中该“FirstAgent”类，并设置中部的 “成员类型”为“Method”，可以看到目前该类有六个来自behaviac::Agent基类的成员方法，方法名前面的“~”表示该方法是从基类继承过来的，如上图所示。

点击右侧的“新增”按钮，弹出“新增方法”窗口，如下图所示：

将新方法的“名字”设为“SayHello”，其他参数暂不用设置。

直接点击“确定”按钮，回到类型信息浏览器，可以看到“FirstAgent”类有了第一个自己添加的成员方法“SayHello”，其他几个带“~”的方法表示是从基类继承过来的成员方法，如下图所示：

现在，我们有了第一个Agent子类的“FirstAgent”，以及它的成员方法“SayHello”。

点击右下方的“应用”按钮，自动生成类型和其他相关的“胶水”代码文件等。

点击左下方的“打开代码生成位置”按钮，可以查看生成的代码文件，如下图所示：

其中，behaviac_types.h需要包含到自己的代码中，以便使用自动生成的类型和“胶水”代码，如下代码所示：

#include "behaviac_generated/types/behaviac_types.h"

“internal”文件夹中包含了前面提及的类型和“胶水”代码，如下图所示：

其中，behaviac_agent_member_visitor.h文件生成了用于访问类的私有属性和方法的“胶水”代码，behaviac_agent_meta.h/cpp文件生成了用于注册类及其属性、方法、实例等信息的“胶水”代码，这些“胶水”代码主要是为了程序端可以通过名字自动取用到类及其成员属性、方法及其实例等。

这些生成的代码需要添加到自己的项目中一起编译构建，如下图所示：

创建行为树

有了上面创建的Agent子类“FirstAgent”后，就可以开始创建和编辑行为树了。

视频

如果对编辑器的按键操作不熟悉，请通过菜单项“帮助”->“起始页”，查看按键说明，如下图所示：

点击工具栏中的“新建行为树”按钮，如下图所示：

新建行为树后，将该行为树名字改为“FirstBT”，现在有了第一棵行为树，该树只有一个根节点，如下图所示：

鼠标左键单击选中该根节点，为该节点的“Agent类型”设置为前面创建的“FirstAgent”，表示这棵行为树用来描述FirstAgent类的行为，如下图所示：

设置完后，可以发现根节点已经具有类型“FirstAgent”，如下图所示：

在左侧的节点列表中（如下图所示），用鼠标左键选中“动作”节点（或其他需要的节点）后，按住鼠标左键并拖拽该节点到右侧的主视口中，并将动作节点落在根节点右侧的黑色三角箭头处。

拖拽完毕，可以看到行为树有了叶子节点“动作”，如下图所示：

选中该动作节点，在右侧“动作的属性”窗口中，为其选择成员方法“SayHello”，并将另一参数“决定状态的选项”设置为“Success”，如下图所示：

如果想了解动作节点的更多细节，请参考文档《动作节点》。或者选中某个节点后，按F1键或右键菜单直接打开该节点的文档。

至此，我们得到了一棵最简单但是完整的行为树，如下图所示：

导出行为树

编辑完行为树后，需要导出全部行为树，以便程序端加载使用。

视频

点击工具栏中的“导出全部”按钮，如下图所示：

弹出“导出”窗口，在导出格式中暂只用勾选“Xml”，点击右下方的“导出”按钮，如下图所示： 

导出后，打开工作区中指定的导出目录，可以看到成功导出了FirstBT.xml文件和meta文件夹中的tutorial_1_cpp.meta.xml文件，如下图所示：

导出的FirstBT.xml文件就是交给程序端加载使用的行为树，tutorial_1_cpp.meta.xml文件是交给程序端加载使用的含有类型和自定义成员属性信息的文件。

运行时的使用

编写并运行程序

需要整合behaviac运行时库到自己的项目中来一起编译构建和运行行为树。如何编译构建behaviac运行时库，请参考文档《如何编译构建》。

C++版

对于自己的C++项目，需要包含behaviac库的inc目录（该inc目录位于源码压缩包的最顶级）。例如，对于Visual Studio项目，inc目录配置如下图所示：

同时还需要包含编译behaviac生成的lib文件。例如，对于Visual Studio项目，behaviac lib文件配置如下图所示

将编辑器生成的Agent子类的类型和相关的“胶水”代码都整合到自己的项目中，如下图所示：

在tutorial_1.cpp文件中，通过使用behaviac组件提供的API来体现行为树是如何加载和执行起来的。

首先，在InitBehaviac()方法中初始化behaviac的加载目录和文件格式等，如下代码所示：

bool InitBehavic()
{
    LOGI("InitBehavic\n");

    behaviac::Workspace::GetInstance()->SetFilePath("../tutorials/tutorial_1/cpp/exported");

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

    return true;
}

上面的几个接口说明如下：

• Workspace::SetFilePath()用于设置加载编辑器导出的行为树所在的目录。
• Workspace::SetFileFormat()用于设置加载的行为树格式，这里用的是xml格式。

接着，创建Agent子类“FirstAgent”的实例，并加载指定的行为树，这里的行为树名字为“FirstBT”，如下代码所示：

bool InitPlayer()
{
    LOGI("InitPlayer\n");

    g_FirstAgent = behaviac::Agent::Create<FirstAgent>();

    bool bRet = g_FirstAgent->btload("FirstBT");

    g_FirstAgent->btsetcurrent("FirstBT");

    return bRet;
}

上面的几个接口说明如下：

• Agent::Create()用于创建Agent子类的实例。
• Agent::btload()用于加载行为树，入口参数是行为树的名字，不要加后缀。
• Agent::btsetcurrent()用于指定当前准备执行的行为树。

其次，开始执行行为树，如下代码所示：

void UpdateLoop()
{
    LOGI("UpdateLoop\n");

    int frames = 0;
    behaviac::EBTStatus status = behaviac::BT_RUNNING;

    while (status == behaviac::BT_RUNNING)
    {
        LOGI("frame %d\n", ++frames);
        status = g_FirstAgent->btexec();
    }
}

Agent::btexec()用于执行一次前面通过Agent::btsetcurrent()指定的行为树。

另外，如果不通过Agent::btexec()来单独执行行为树，也可以调用Workspace::Update()的方式来统一执行所有Agent实例的行为树，详见文章《运行时端的执行流程》。

然后，对创建的Agent实例进行销毁释放，并清理整个工作区，如下代码所示：

void CleanupPlayer()
{
    LOGI("CleanupPlayer\n");

    behaviac::Agent::Destroy(g_FirstAgent);
}

void CleanupBehaviac()
{
    LOGI("CleanupBehaviac\n");

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

最后，打开FirstAgent.cpp文件，并修改FirstAgent::SayHello()方法如下：

///<<< THE METHOD HEAD
void FirstAgent::SayHello()
{
    ///<<< BEGIN WRITING YOUR CODE
    printf("\nHello Behaviac!\n\n");
    ///<<< END WRITING YOUR CODE
}

注意：自己的代码需要添加在“///<<< BEGIN WRITING YOUR CODE”和“///<<< END WRITING YOUR CODE”之间，以便编辑器下次生成代码的时候，可以自动合并手工添加的内容和生成的内容。

编译并运行整个程序，执行结果如下：

可以看到，程序结果输出了“Hello Behaviac!”，也就是成功执行了我们创建的第一棵最简单的行为树，并成功执行了动作节点配置的成员方法“SayHello”。

下载源码包后，打开projects目录中的工程文件behaviac.sln（Windows平台）或make文件（Linux平台），编译并执行tutorial_1项目，就可以看到上图的结果。

纯C#版

本教程纯C#版的工作区文件是安装包目录下的tutorials/tutorial_1/workspace/tutorial_1_cs.workspace.xml，相关参数配置如下图所示：

对于自己的C#项目，需要包含behaviac库的所有运行时源码（在源码包的integration\unity\Assets\Scripts\behaviac\runtime文件夹中）整合进来，如下图所示：

将编辑器生成的Agent子类的类型和相关的“胶水”代码都整合到自己的项目中，如下图所示：

为项目添加条件编译宏BEHAVIAC_NOT_USE_UNITY，表示用的是纯C#模式，没有使用Unity相关的API，如下图所示：

在tutorial_1.cs文件中，通过使用behaviac组件提供的API来体现行为树是如何加载和执行起来的。

首先，在InitBehaviac()方法中初始化behaviac的加载目录和文件格式等，如下代码所示：

static bool InitBehavic()
{
    Console.WriteLine("InitBehavic");

    behaviac.Workspace.Instance.FilePath = "../../exported";
    behaviac.Workspace.Instance.FileFormat = behaviac.Workspace.EFileFormat.EFF_xml;

    return true;
}

上面的几个接口说明如下：

• Workspace.FilePath用于设置加载编辑器导出的行为树所在的目录。
• Workspace.FileFormat用于设置加载的行为树格式，这里用的是xml格式。

接着，创建Agent子类“FirstAgent”的实例，并加载指定的行为树，这里的行为树名字为“FirstBT”，如下代码所示：

static bool InitPlayer()
{
    Console.WriteLine("InitPlayer");

    g_FirstAgent = new FirstAgent();

    bool bRet = g_FirstAgent.btload("FirstBT");
    Debug.Assert(bRet);

    g_FirstAgent.btsetcurrent("FirstBT");

    return bRet;
}

上面的几个接口说明如下：

• Agent.btload()用于加载行为树，入口参数是行为树的名字，不要加后缀。
• Agent.btsetcurrent()用于指定当前准备执行的行为树。

其次，开始执行行为树，如下代码所示：

static void UpdateLoop()
{
    Console.WriteLine("UpdateLoop");

    int frames = 0;
    behaviac.EBTStatus status = behaviac.EBTStatus.BT_RUNNING;

    while (status == behaviac.EBTStatus.BT_RUNNING)
    {
        Console.WriteLine("frame {0}", ++frames);

        status = g_FirstAgent.btexec();
    }
}

Agent.btexec()用于执行一次前面通过Agent.btsetcurrent()指定的行为树。

然后，对创建的Agent实例进行销毁释放，并清理整个工作区，如下代码所示：

static void CleanupPlayer()
{
    Console.WriteLine("CleanupPlayer");

    g_FirstAgent = null;
}

static void CleanupBehaviac()
{
    Console.WriteLine("CleanupBehaviac");

    behaviac.Workspace.Instance.Cleanup();
}

最后，打开FirstAgent.cs文件，并修改SayHello()方法如下：

///<<< THE METHOD HEAD
public void SayHello()
{
    ///<<< BEGIN WRITING YOUR CODE
    Console.WriteLine();
    Console.WriteLine("Hello Behaviac!");
    Console.WriteLine();
    ///<<< END WRITING YOUR CODE
}

注意：自己的代码需要添加在“///<<< BEGIN WRITING YOUR CODE”和“///<<< END WRITING YOUR CODE”之间，以便编辑器下次生成代码的时候，可以自动合并手工添加的内容和生成的内容。

编译并运行整个程序，执行结果如下：

可以看到，程序结果输出了“Hello Behaviac!”，也就是成功执行了我们创建的第一棵最简单的行为树，并成功执行了动作节点配置的成员方法“SayHello”。

下载源码包后，打开tutorials/CsTutorials目录中的工程文件CsTutorials.sln，编译并执行tutorial_1项目，就可以看到上图的结果。

Unity C#版

打开Unity编辑器创建一个空的Unity项目，保存该项目，或者直接打开安装目录下的tutorials/tutorial_1/unity目录中的项目。

通过behaviac编辑器创建一个工作区（或者直接打开安装包目录下的Unity工作区文件tutorials/tutorial_1/workspace/tutorial_1_unity.workspace.xml），相关参数配置如下图所示：

添加FirstAgent类及其成员方法SayHello()、创建和导出行为树FirstBT等流程跟上文相同。

导出整个工作区后，可以看到在目录tutorials\tutorial_1\unity\Assets\Scripts\behaviac\behaviac_generated\types有了自动生成的源码文件，如下图所示：

在Unity编辑器中导入安装包目录下的behaviac运行时包integration/behaviac***.unitypackage。

打开整个项目的源码工程，可以看到有了behaviac的运行时库runtime和编辑器生成的源码behaviac_generated，如下图所示：

打开FirstAgent.cs文件，添加代码如下：

首先，在InitBehaviac()方法中初始化behaviac的加载目录和文件格式等，如下代码所示：

private static string ExportedFilePath
{
    get
    {
        string relativePath = "/Resources/behaviac/exported";

        if (Application.platform == RuntimePlatform.WindowsEditor) {
            return Application.dataPath + relativePath;
        }
        else if (Application.platform == RuntimePlatform.WindowsPlayer) {
            return Application.dataPath + relativePath;
        }
        else {
            return "Assets" + relativePath;
        }
    }
}

private bool InitBehavic()
{
    behaviac.Debug.LogWarning("InitBehavic");

    behaviac.Workspace.Instance.FilePath = ExportedFilePath;
    behaviac.Workspace.Instance.FileFormat = behaviac.Workspace.EFileFormat.EFF_xml;

    return true;
}

接着，加载指定的行为树，这里的行为树名字为“FirstBT”，如下代码所示：

private bool InitPlayer()
{
    behaviac.Debug.LogWarning("InitPlayer");

    bool bRet = this.btload("FirstBT");
    if (bRet)
    {
        this.btsetcurrent("FirstBT");
    }

    return bRet;
}

在Awake()方法中调用InitBehavic和InitPlayer方法，如下代码所示：

void Awake()
{
    InitBehavic();

    InitPlayer();
}

其次，在Update()方法中执行行为树，如下代码所示：

behaviac.EBTStatus _status = behaviac.EBTStatus.BT_RUNNING;

void Update()
{
    if (_status == behaviac.EBTStatus.BT_RUNNING)
    {
        behaviac.Debug.LogWarning("Update");

        _status = this.btexec();
     }
}

然后，修改SayHello()方法如下：

public void SayHello()
{
    ///<<< BEGIN WRITING YOUR CODE SayHello
    behaviac.Debug.LogWarning("Hello Behaviac!");
    ///<<< END WRITING YOUR CODE
}

注意：自己的代码需要添加在“///<<< BEGIN WRITING YOUR CODE”和“///<<< END WRITING YOUR CODE”之间，以便编辑器下次生成代码的时候，可以自动合并手工添加的内容和生成的内容。

最后，在Unity编辑器中添加一个GameObject，并且为其添加脚本组件FirstAgent，如下图所示：

在Unity编辑器中运行这个简单的程序，执行结果如下：

下载源码包后，通过Unity编辑器打开并运行tutorials/tutorial_1/unity目录中的项目，就可以看到上图的结果。

本教程相关的工作区和代码工程详见源码包的目录tutorials/tutorial_1。

如《教程1：Hello Behaviac》所述，程序端的类型代码可以通过编辑器自动生成基本原型，然后在生成的代码模板上继续添加自己的逻辑代码。

本教程将详细介绍相关的具体操作步骤，包括：从创建Agent类型到生成其代码文件，并利用该Agent类型创建行为树，最后执行该行为树的流程。

1. 新建Agent类型

通过编辑器的菜单项“视图”->“类型信息”（或快捷键Ctrl+M），打开类型信息浏览器，如下图所示：

点击右上角的“新增”按钮，弹出“新增类型”窗口，添加FirstAgent类，勾选“生成代码”选项，如下图所示：

更详细的类型信息编辑过程以及相关操作面板的参数说明，请参考文章《编辑类型信息》。

2. 新增成员属性

为FirstAgent类添加int类型的成员属性p1，如下图所示：

3. 新增成员方法

再为FirstAgent类添加成员方法m1，如下图所示：

添加完FirstAgent类型及其成员属性和方法之后，可以在类型信息浏览器中看到如下所示：

4. 修改成员

如果修改了成员属性和方法，例如改名、加参数等操作后，只需点击右下方的“应用”按钮即可。

例如，将成员属性p1改名为p2，如下图所示：

5. 生成代码

点击右下方的“应用”按钮，在工作区配置的“代码生成位置”生成了类型及其相关的“胶水”代码文件，如下图所示：

在上图中的internal文件夹中生成了Agent类型及其“胶水”代码，如下图所示：

需要将types文件夹中的所有代码文件都加到自己的项目中一起编译构建，并只需在程序端代码中包含头文件types/behaviac_types.h即可，其他“胶水”代码头文件不用包含，如下代码所示：

#include "behaviac_generated/types/behaviac_types.h"

6. 添加逻辑代码

打开上面生成的FirstAgent.cpp文件，为FirstAgent::m1方法添加自己的逻辑代码。注意所有自己添加的代码都需要添加在注释“///<<< BEGIN WRITING YOUR CODE”和“///<<< END WRITING YOUR CODE”之间，如下代码所示：

#include "FirstAgent.h"

///<<< BEGIN WRITING YOUR CODE FILE_INIT

///<<< END WRITING YOUR CODE

FirstAgent::FirstAgent()
{
    p1 = 0;
///<<< BEGIN WRITING YOUR CODE CONSTRUCTOR

///<<< END WRITING YOUR CODE
}

FirstAgent::~FirstAgent()
{
///<<< BEGIN WRITING YOUR CODE DESTRUCTOR

///<<< END WRITING YOUR CODE
}

void FirstAgent::m1(behaviac::string& value)
{
///<<< BEGIN WRITING YOUR CODE m1
    printf("\n%s\n\n", value.c_str());
///<<< END WRITING YOUR CODE
}

///<<< BEGIN WRITING YOUR CODE FILE_UNINIT

///<<< END WRITING YOUR CODE

如果在类型信息浏览器中将成员方法m1改名为m2，点击右下方的“应用”按钮，重新生成代码，上面代码中的m1会自动变为m2，在BEGIN和END之间的手写代码不会改变，会自动保留。

7. 添加行为树

利用新加的FirstAgent类及其成员属性和方法，添加行为树“FirstBT”，如下图所示：

8. 执行行为树

加载并执行该行为树，可以看到输出结果如下图所示：

本教程相关的工作区和代码工程详见源码包的目录tutorials/tutorial_1_1。

在《教程1.1：编辑器生成类型代码的工作流程》中，介绍了通过编辑器自动生成类型代码的基本原型，然后在生成的代码模板上继续添加自己的逻辑代码。

而对于习惯手工编写代码，或已经有了大量手工编写的类型代码（如从老版本升级到3.6新版本），可以依然使用原来的代码，但需要在编辑器中创建对应的类型信息。

本教程详细介绍相关的具体步骤，包括：从创建Agent类型到手工编辑代码文件，并利用该Agent类型创建行为树，最后执行该行为树的结果。

1. 新建Agent类型

首先需要在编辑器中创建跟程序端同名的Agent类型。

通过编辑器的菜单项“视图”->“类型信息”（或快捷键Ctrl+M），打开类型信息浏览器，如下图所示：

点击右上角的“新增”按钮，弹出“新增类型”窗口，添加SecondAgent类，不要勾选“生成代码”选项，如下图所示：

详细的类型信息编辑过程以及相关操作面板的参数说明，请参考文章《编辑类型信息》。

2. 新增成员属性

为SecondAgent类添加int类型的成员属性p1，如下图所示：

3. 新增成员方法

再为SecondAgent类添加成员方法m1，如下图所示：

添加完SecondAgent类型及其成员属性和方法之后，可以在类型信息浏览器中看到如下所示：

4. 修改成员

如果修改了成员属性和方法，例如改名、加参数等操作后，只需点击右下方的“应用”按钮即可。

例如，将成员属性p1改名为p2，如下图所示：

5. 生成“胶水”代码

点击右下方的“应用”按钮，在工作区配置的“代码生成位置”生成了“胶水”代码文件，如下图所示：

在上图中的internal文件夹中生成了Agent类型的“胶水”代码，但并没有生成SecondAgent类型本身的代码文件，如下图所示：

需要将types文件夹中的所有代码文件都加到自己的项目中一起编译构建，并只需在程序端代码中包含头文件types/behaviac_types.h即可，其他“胶水”代码头文件不用包含，如下代码所示：

#include "behaviac_generated/types/behaviac_types.h"

6. 添加类型代码

在代码项目中手工添加SecondAgent.h/.cpp文件，如下图所示：

为了提高手工编写代码的效率并保持与编辑器中定义的一致性，请点击类型信息浏览器中的“预览原型代码”按钮，如下图所示：

可以看到SecondAgent类的原型代码如下所示，复制粘贴需要的类型、成员属性或方法的申明代码到自己的SecondAgent.h头文件中：

#ifndef _BEHAVIAC_SECONDAGENT_H_
#define _BEHAVIAC_SECONDAGENT_H_

#include "behaviac_headers.h"

class SecondAgent : public behaviac::Agent
{
public:
    SecondAgent();

    virtual ~SecondAgent();

    BEHAVIAC_DECLARE_AGENTTYPE(SecondAgent, behaviac::Agent)

private: int p1;

private: void m1(behaviac::string& value);

};

#endif

在SecondAgent.cpp中实现该类的各个方法如下所示：

#include "SecondAgent.h"

SecondAgent::SecondAgent()
    : p1(0)
{
}

SecondAgent::~SecondAgent()
{
}

void SecondAgent::m1(behaviac::string& value)
{
    printf("\n%s\n\n", value.c_str());
}

在类型信息浏览器中点击右上方的”设置头文件“，添加刚才手工新建的SecondAgent类的头文件路径，如下图所示：

这样在生成的types/internal/behaviac_headers.h文件中，就自动包含了上面添加的SecondAgent.h头文件，如下代码所示：

#ifndef _BEHAVIAC_HEADERS_H_
#define _BEHAVIAC_HEADERS_H_

#include "behaviac/behaviac.h"

// YOU SHOULD SET THE HEADER FILES OF YOUR GAME WHEN EXPORTING CPP FILES ON THE BEHAVIAC EDITOR:
#include "../../../SecondAgent.h"

#endif // _BEHAVIAC_HEADERS_H_

注意上图中左下方的选项“生成代码时使用相对路径”，该选项用于生成上述包含头文件时，是否生成相对路径。

如果已经在自己的代码项目中设置了包含路径，可以不勾选该选项，生成的代码如下所示：

#ifndef _BEHAVIAC_HEADERS_H_
#define _BEHAVIAC_HEADERS_H_

#include "behaviac/behaviac.h"

// YOU SHOULD SET THE HEADER FILES OF YOUR GAME WHEN EXPORTING CPP FILES ON THE BEHAVIAC EDITOR:
#include "SecondAgent.h"

#endif // _BEHAVIAC_HEADERS_H_

7. 手工编辑类型信息

有的程序员可能不喜欢使用类型信息浏览器来编辑类型信息，那么可以编写自己的导出工具或者直接手工编辑类型信息文件*.meta.xml。

该文件保存在工作区配置的“行为树源位置”中的behaviac_meta文件夹中，例如本教程对应的类型信息文件tutorial_1_2_cpp.meta.xml就在源码包tutorials/tutorial_1_2/workspace/behaviors/behaviac_meta目录下，该文件的内容如下：

可以手工编辑该文件，根据自己的需要添加或修改自己的类型信息，但需要确保内容格式跟上图保持一致，没有任何错误，否则会加载失败。

此外，编辑器还支持加载多个类型信息文件，支持混用编辑器编辑的类型信息和通过自己编写导出工具或手工编辑生成的类型信息这两种方式，那么可以将自己生成的*.meta.xml文件，也放在行为树源位置中的behaviac_meta目录里，如下图所示：

重新加载工作区后，会弹出如下提示窗口：

如果没有弹出上述提示窗口，说明已经合并过多个类型信息文件，可以打开工作区文件tutorial_1_2_cpp.workspace.xml，并修改promptmergingmeta的值为”false”，如下图所示：

重新加载工作区，会再次弹出上述提示窗口。点击”是(Y)“，编辑器会自动合并多个类型信息文件。

这样，在类型信息浏览器中就可以查看手工编辑的所有类型信息，并在行为树中使用这些类型信息了。

8. 添加行为树

利用新加的SecondAgent类及其成员属性和方法，添加行为树”SecondBT”，如下图所示：

9. 执行行为树

加载并执行该行为树，可以看到输出结果如下图所示：

本教程相关的工作区和代码工程详见源码包的目录tutorials/tutorial_1_2。

类似于任何一种程序语言的基本语法，behaviac组件也提供了基本的赋值、条件、循环、序列、选择等基本节点。有了《教程1：Hello Behaviac》的基本介绍，本教程将引入这些常用的复合节点，以便将行为树编辑得更加丰富多彩。

用编辑器打开本教程C++版的工作区文件tutorial_2_cpp.workspace.xml（而C#版工作区文件是tutorial_2_cs.workspace.xml），如下图所示：

注意：本教程延用了《教程一》的FirstAgent子类及其成员方法SayHello等类型信息，可以参考《教程一》的做法，打开类型信息浏览器创建该子类。此外，还为FirstAgent子类添加了int类型的成员属性p1，如下图所示：

参考《教程一》的做法，点击上图中右下方的“应用”按钮，生成“胶水”代码，并将这些代码整合到项目tutorial_2中，并添加tutorial_2.cpp文件用于使用behaviac的相关接口来加载和执行行为树，如下图所示：

循环节点

循环节点类似于程序语言中的for或while循环，用于重复执行某个操作。

新建行为树“LoopBT”，将根节点的Agent类型设置为“FirstAgent”，并为其添加循环和动作节点，如下图所示：

选中循环节点，将其参数“次数”设置为3，其他参数暂不用设置，如下图所示：

选中动作节点，为其选择“SayHello”方法，如下图所示：

导出、加载并执行该行为树“LoopBT”，得到如下图所示的结果：

可以看到输出了3次“Hello Behaviac!”，这是我们预期的结果。

如果想了解循环节点其他参数的用法，请选中循环节点，并按F1键，会自动打开该节点的使用手册。

此外，循环直到节点类似于循环节点，两者的差别可以参考手册《循环直到节点》和《循环节点》。

赋值节点

新建行为树“SequenceBT”，将根节点的Agent类型设置为“FirstAgent”，并为其依次添加序列、赋值、条件和动作节点，如下图所示：

类似于程序语言中的赋值语句，赋值节点可以将右值赋给左值。

选中上图中的赋值节点，将“左参数”选择为前面所添加的成员属性“p1”，“右参数”直接设置为6，表示程序端在执行该行为树时，会将右值6赋给左值p1，如下图所示：

更多细节请参考手册《赋值节点》。

条件节点

类似于程序语言中的条件判断语句，条件节点用于比较两个值的情况，用于跟后续节点组合使用，表示条件满足时，是否执行后续的节点。

选中上面行为树“SequenceBT”中的条件节点，将“左参数”选择为前面所添加的成员属性“p1”，“右参数”直接设置为3，“操作符”设置为“>”，表示判断p1是否大于3，如下图所示：

更多细节请参考手册《条件节点》。

序列节点

序列节点是行为树中传统的组合节点之一。该节点以给定的顺序依次执行其子节点，直到所有子节点成功返回，该节点也返回成功。只要其中某个子节点失败，那么该节点就直接返回失败，不再执行后续的子节点。

在上面行为树“SequenceBT”中，可以看到序列节点有3个子节点，分别是赋值、条件和动作节点。在依次执行该序列节点的子节点时，赋值节点（p1 = 6）永远返回成功，将继续执行条件节点（p1 > 3），该条件节点也返回成功，因此继续执行动作节点（SayHello），最后期望输出“Hello Behaviac!”。

执行该行为树，得到如下结果：

可以看到，执行结果跟期望保持一致。

如果将条件节点的右值3改为8，得到行为树如下图所示：

重新导出并加载执行该行为树，执行结果如下所示：

可以看到，并没有输出“Hello Behaviac!”，说明动作节点（SayHello）没有得到执行，因为条件节点（p1 > 8）已经返回失败。

更多细节请参考手册《序列节点》。

选择节点

选择节点也是行为树中传统的组合节点之一。该节点以给定的顺序依次调用其子节点，直到其中一个成功返回，那么该节点也直接返回成功，不再执行后续的子节点。如果所有的子节点都失败，那么该节点也返回失败。

新建行为树“SelectBT”，将根节点的Agent类型设置为“FirstAgent”，并为其依次添加序列、赋值、选择、条件和动作节点，如下图所示：

执行该行为树，得到结果如下：

可以看到，并没有输出“Hello Behaviac!”，说明动作节点（SayHello）没有得到执行，因为条件节点（p1 > 3）已经返回成功，那么选择节点直接返回成功，不再执行后续的子节点。

如果将条件节点的右值3改为8，得到如下的行为树：

重新导出并加载执行该行为树，执行结果如下所示：

可以看到，执行结果输出了“Hello Behaviac!”，说明动作节点（SayHello）得到了执行，因为条件节点（p1 > 8）返回失败，选择节点会继续执行后续的子节点，也就是该动作节点。

更多细节请参考手册《选择节点》。

导出格式

除了支持《教程一》介绍的XML导出格式，behaviac组件还支持BSON、C++和C#格式的行为树导出。

勾选上所有的导出格式，如下图所示：

XML

指定文件格式为XML，如下代码所示：

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

BSON

点击右下方的“导出”按钮后，可以看到在导出目录tutorials/tutorial_2/cpp/exported下，除了原有的*.xml文件之外，还有了*.bson.bytes文件，如下图所示：

加载使用BSON文件，只需要把文件格式改为BSON即可，如下代码所示：

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

加载某个行为树时，文件名并不需要指定后缀，只要指定相对于导出位置的路径和文件名，如下代码所示：

g_FirstAgent->btload(“LoopBT”);

这里，我们使用行为树“LoopBT”，执行后的结果如下图所示：

可以看出，跟XML格式的执行结果保持一致。

C++

在代码生成目录tutorials/tutorial_2/cpp/behaviac_generated/behaviors下，导出了行为树的C++源码文件，如下图所示：

需要把这些文件整合到自己的项目中一起编译，如下图所示：

所有C++版教程的项目都包含在源码包中projects/vs2013目录中的工程behaviac.sln，打开该工程文件后，可以看到里面有behaviac组件的源码和所有的教程项目，如下图所示：

找到tutorial_2项目，打开里面的tutorial_2.cpp文件，将文件格式改为C++，如下代码所示：

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

这里，我们使用行为树“LoopBT”，执行后的结果如下图所示：

可以看出，跟XML格式的执行结果保持一致。

C#

打开本教程C#版的工作区文件tutorials/tutorial_2/workspace/tutorial_2_cs.workspace.xml，该工作区的参数配置如下图所示：

类似于前面介绍的导出窗口配置，选中所有的格式并进行导出，如下图所示：

打开位于源码包tutorials/tutorial_2/cs目录中的tutorial_2.sln工程，可以查看本教程的C#示例代码。

可以通过修改文件格式来加载不同类型的行为树文件，如下代码所示：

加载XML版的行为树：

behaviac.Workspace.Instance.FileFormat = behaviac.Workspace.EFileFormat.EFF_xml;

加载BSON版的行为树：

behaviac.Workspace.Instance.FileFormat = behaviac.Workspace.EFileFormat.EFF_bson;

加载C#版的行为树：

behaviac.Workspace.Instance.FileFormat = behaviac.Workspace.EFileFormat.EFF_cs;

编译并执行C#工程，可以查看加载和执行行为树后的结果。

本教程相关的工作区和代码工程详见源码包的目录tutorials/tutorial_2。

我们知道，面向对象程序编程的定义就是使用对象来做设计，对象即是类的实例。behaviac组件是基于Agent类及其实例来运转的，Agent类的实例加载和执行行为树，而在行为树的节点中又有可能用到了Agent实例的成员属性或方法。

在编辑器的节点属性窗口中，为了给该节点配置参数，首先需要选择一个实例，然后再选择该实例的成员属性或方法，如下图所示：

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

• Self：当前行为树根节点所配置的Agent类的实例，类似于程序语言中的this。
• 成员实例：当前行为树根节点所配置的Agent类的成员属性，或是当前行为树的局部变量，需要是Agent或其子类类型。
• 全局实例：在类型信息浏览器中编辑并生成注册代码的各种Agent或其子类的全局变量。

成员实例

对于成员实例，在上图所示的节点属性窗口中会根据当前行为树根节点所配置的Agent类型，自动列举出所有的成员实例以供选择。但在使用该成员实例之前，需要确保该实例已经赋过值，而不是空指针或引用。

在类型信息浏览器中添加新的Agent子类SecondAgent，并为其添加一个int类型的成员属性p2，如下图所示：

然后，为FirstAgent类添加SecondAgent类型的成员属性pInstance，如下图所示：

点击上图中的“确认”按钮后，可以看到FirstAgent类多了一个成员属性pInstance，如下图所示：

全局实例

对于全局实例，各种Agent或其子类实例的名字注册和绑定是为了支持单件（Singleton）或者类似确定的全局性实例（同一个类可能会有若干个实例而不是仅仅有一个实例），如player、camera、director等。

点击类型信息浏览器中部的“实例名称”右侧的“新增”按钮，添加SecondAgent类型的全局实例SecondAgentInstance，如下图所示：

点击上图中的“确认”按钮后，可以看到SecondAgent类的“实例名称”下拉列表中有了新加的全局实例SecondAgentInstance，如下图所示：

点击上图中右下方的“应用”按钮，就可以在行为树中分别使用这2个新加的成员实例和全局实例了。

应用

新建一棵行为树“InstanceBT”，依次添加序列、赋值、条件和动作节点，并为根节点选择FirstAgent类型，将动作节点配置为Self及其成员方法SayHello，如下图所示：

选中ID为1的赋值节点，在其属性窗口“左参数”的实例名中，可以为其选择Self、SecondAgentInstance和pInstance 3个实例了，如下图所示：

为其选择SecondAgentInstance及其成员属性p2，如下图所示：

类似的，选中ID为2的赋值节点，为其选择pInstance及其成员属性p2，如下图所示：

选中ID为3的条件节点，将“左参数”选择为SecondAgentInstance及其成员属性p2，将“右参数”选择为pInstance及其成员属性p2，将“操作符”选择为“>”，如下图所示：

配置完之后，得到行为树“InstanceBT”如下图所示：

导出行为树后，程序端就可以在加载和执行该行为树“InstanceBT”了。

C++版

在源码包的tutorials/tutorial_3/cpp/tutorial_3.cpp文件中，定义了3个变量，如下代码所示：

FirstAgent* g_FirstAgent = NULL;
SecondAgent* g_SecondAgent = NULL;
SecondAgent* g_ThirdAgent = NULL;

其中，g_FirstAgent用于加载和执行行为树“InstanceBT”，g_SecondAgent用于赋值给g_FirstAgent的成员属性pInstance，g_ThirdAgent作为全局实例供行为树“InstanceBT”中的节点使用。这3个变量的初始化，如下代码所示：

bool InitPlayer()
{
    LOGI("InitPlayer : %s\n", "InstanceBT");

    // 创建g_FirstAgent，并加载行为树“InstanceBT”
    g_FirstAgent = behaviac::Agent::Create<FirstAgent>();
    bool bRet = g_FirstAgent->btload("InstanceBT");
    g_FirstAgent->btsetcurrent("InstanceBT");

    // 创建g_SecondAgent，并将该实例赋给g_FirstAgent的成员pInstance
    g_SecondAgent = behaviac::Agent::Create<SecondAgent>();
    g_FirstAgent->SetSecondAgent(g_SecondAgent);

    // 创建g_ThirdAgent，并将"SecondAgentInstance"绑定给该实例
    g_ThirdAgent = behaviac::Agent::Create<SecondAgent>("SecondAgentInstance");

    return bRet;
}

C#版

在源码包的tutorials/tutorial_3/cs/tutorial_3.cs文件中，定义了3个变量，如下代码所示：

static FirstAgent g_FirstAgent;
static SecondAgent g_SecondAgent;
static SecondAgent g_ThirdAgent;

其中，g_FirstAgent用于加载和执行行为树“InstanceBT”，g_SecondAgent用于赋值给g_FirstAgent的成员属性pInstance，g_ThirdAgent作为全局实例供行为树“InstanceBT”中的节点使用。这3个变量的初始化，如下代码所示：

static bool InitPlayer()
{
    Console.WriteLine("InitPlayer");

    // 创建g_FirstAgent，并加载行为树“InstanceBT”
    g_FirstAgent = new FirstAgent();
    bool bRet = g_FirstAgent.btload("InstanceBT");
    Debug.Assert(bRet);
    g_FirstAgent.btsetcurrent("InstanceBT");

    // 创建g_SecondAgent，并将该实例赋给g_FirstAgent的成员pInstance
    g_SecondAgent = new SecondAgent();
    g_FirstAgent._set_pInstance(g_SecondAgent);

    // 创建g_ThirdAgent，并将"SecondAgentInstance"绑定给该实例
    g_ThirdAgent = new SecondAgent();
    behaviac.Agent.BindInstance(g_ThirdAgent, "SecondAgentInstance");

    return bRet;
 }

编译并执行，可以看到输出了“Hello Behaviac!”，说明行为树的执行结果符合我们的预期，Agent实例得到了正确的使用。

本教程相关的工作区和代码工程详见源码包的目录tutorials/tutorial_3。

预制（Prefab）可以用来复用和实例化已有的行为树，如果只是直接复用行为树，预制跟引用子树的功能是一样的。

但是预制还可以用来定制个别节点的配置，称之为对预制的实例化。也即，如果一棵行为树用到了一棵预制行为树，那么可以局部修改某些节点，这些修改的节点不会跟着预制行为树的更新而同步更新。

首先新建一棵行为树“ParentBT”，如下图所示：

在ID为2的序列节点上右键鼠标，弹出菜单，选择“另存为预制行为树”，表示准备将该序列节点为根节点的子树保存为一棵预制行为树，如下图所示：

在弹出的“另存为预制”窗口中，可以为当前的预制改名，然后点击“确认”按钮，如下图所示：

在编辑器左侧的行为树列表中，可以看到多了“pf_Sequence”节点，这就是刚刚保存出来的预制行为树，如下图所示：

在“Prefabs”下面的所有预制行为树都可以直接拖拽到主视口中打开的行为树中使用，不过需要保证预制行为树跟主视口中打开的行为树的Agent类型保持兼容，也即要么类型相同，要么预制行为树的Agent类型是主视口中打开的行为树的Agent类型的基类。

双击打开预制行为树“pf_Sequence”，可以看到该树自动添加了根节点及其Agent类型“FirstAgent”，其他节点跟原有的情况保持一致，如下图所示：

而在行为树“ParentBT”中，可以看到原有的ID为2的序列节点所在的子树已被上面的预制行为树“pf_Sequence”所替代，如下图所示：

修改了预制行为树“pf_Sequence”中的节点，所有引用到该预制行为树的行为树都会保持相同的更新，除非在行为树中有对预制行为树的节点属性有自己的修改或定制。

再为行为树“ParentBT”拖拽添加一个预制“pf_Sequence”分支，如下图所示：

修改上图中的第二个预制“pf_Sequence”中ID为9的赋值节点右值为3，如下图所示：

可以看到上图ID为8和9的两个节点都变为了虚线框，表示这是预制实例化（定制）后的节点及其父节点。

如果在预制行为树“pf_Sequence”中，修改节点ID为5的赋值节点的右值为6，如下图所示：

那么行为树“ParentBT”中ID为5的赋值节点的右值会同步更新为6，但是ID为9的赋值节点的右值还是为3，并没有同步更新，因为该节点已经被定制过了，如下图所示：

执行最终的行为树，输出结果如下图所示：

本教程相关的工作区和代码工程详见源码包的目录tutorials/tutorial_4。

子树可以用来复用已有的行为树。通过子树节点，一个行为树可以作为另一个行为树的子树，而作为子树的那个行为树将被父树所“调用”。

子树还可以类似编程语言中的函数调用一样通过传递参数来使用。

类似动作节点，子树节点根据子树的执行结果也会返回一样的执行结果（即成功、失败或正在执行），其父节点按照自己的控制逻辑来控制接下来的运行。

1. 编辑类型信息

首先，我们需要添加一个Agent类，后面会利用这个Agent类来创建行为树。

打开类型信息浏览器，分别为Agent类“FirstAgent”添加成员属性、方法和任务。

添加int类型的成员属性p1，如下图所示：

添加成员方法Say，该方法带有一个string&类型的参数，如下图所示：

添加任务t1，该任务带有一个int类型的参数，如下图所示：

2. 不带参数的子树

首先给出子树最直接的用法——不带参数的子树：

首先，创建行为树“subtree”，将动作节点的方法Say的参数设置为“Hello subtree!”，如下图所示：

Say方法的功能是输出指定的字符串，如下代码所示：

void FirstAgent::Say(behaviac::string& param0)
{
///<<< BEGIN WRITING YOUR CODE Say
    printf("\n%s\n\n", param0.c_str());
///<<< END WRITING YOUR CODE
}

然后，创建行为树“maintree”，并将行为树列表中的节点“subtree”直接拖拽到该树中，如下图所示：

这样，行为树“maintree”就可以“调用”子树“subtree”了。

加载并执行行为树“maintree”后，结果如下图所示：

可以看到，输出了“Hello subtree!”字符串，说明子树“subtree”得到了正确的调用和执行。

3. 带参数的子树

有时候，我们可能需要给子树传递参数来使用，这样子树会更加模块化。

对于这种需要传参的子树，可以按照如下操作进行：

首先，创建行为树“subtree_task”，并为其添加的第一个子节点必须是任务节点，如下图所示：

为上图中的任务节点，在其属性窗口中配置其“任务”参数为“t1”，如下图所示：

由于任务“t1”带有参数“param0”，所以在上面行为树“subtree_task”的条件节点中可以使用该参数“param0”，如上图所示。可以借鉴程序语言的说法，该参数“param0”就类似于函数的形参。

然后，创建行为树“maintree_task”，并将行为树列表中的节点“subtree_task”直接拖拽到该树中，如下图所示：

选中上图中的子树节点，配置任务的参数值“param0”为2（这个参数类似于函数中的实参），如下图所示：

这样，行为树“maintree_task”就可以“调用”子树“subtree_task”，并为该子树传递参数了。

加载并执行行为树“maintree_task”后，结果如下图所示：

可以看到，输出了“Hello subtree_task!”字符串，说明子树“subtree_task”得到了正确的调用和执行。

4. 添加子树节点的补充说明

• 如上所述，可以从编辑器左侧的行为树节点列表中，通过鼠标选择并拖拽一棵行为树到另一棵行为树中来生成子树节点。被拖拽的行为树的路径被设置到引用文件名。需要指出的是，并非任意一个行为树都可以作为另外一个行为树的子树。3.6.32及之前版本，作为子树的Agent类型必须是父树的Agent类型的同类或父类。而3.6.33及之后版本，作为子树的Agent类型可以是父树的Agent类型的同类或父类或子类，但是需要保证执行该父树的Agent实例是父树和子树的Agent类型的子类或更低子类的实例（例如，假设父树的Agent类型是A，子树的Agent类型是B：如果A是B的子类，那么执行该父树的Agent实例必须是A或者A的子类的实例；如果B是A的子类，那么执行该父树的Agent实例必须是B或者B的子类的实例）。
• 另外，也可以像添加其他节点那样，在节点列表中选取子树，拖拽到相应的位置，然后点击该子树节点，在右侧的属性窗口中配置引用文件名或任务。
  
• 如果手工配置的子树的路径是空的或无效的，在检查错误时会报错，表示该树不允许被导出。如果配置的是属性或方法，在编辑器中无法知其是否有效，只有运行的时候才会报运行时错误，如果运行过程中该值无效。

本教程相关的工作区和代码工程详见源码包的目录tutorials/tutorial_5。

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

1. 添加类型信息及任务

在类型信息浏览器中为类“FirstAgent”添加了event_task(int param0)这个任务，或者更形象的称之为“接口”，该任务带有一个int类型的param0参数，如下图所示：

2. 创建带任务节点的子树

创建行为树subtree_task，该树根节点的第一个子节点务必是任务节点，并为其配置上面添加的任务event_task，如下三图所示：

在上面的行为树subtree_task中，ID为1的条件节点使用了任务event_task的参数param0。这类似于编程语言中的函数参数为函数体的代码提供了局部变量，任务节点中的参数也为当前的行为树提供了同名的局部变量，这些“局部变量”可以根据需要用于该行为树所有子节点，也就在行为树节点中使用了任务的参数。

3. 创建带有事件的主树

创建另一个行为树maintree_task，并将ID为4的动作节点的参数“决定状态的选项”设置为Running，用于模拟行为树一直持续执行在该动作节点上，如下二图所示：

接着，在编辑器左侧的行为树节点列表中，将行为树节点subtree_task通过鼠标拖拽到行为树maintree_task中的第一个序列节点上（注意：一般默认把事件附件放在根节点的第一个子节点上），这样该序列节点就有了一个事件附件，如下图所示：

然后，为该事件设置参数，如下图所示：

其中，“触发一次”表示该事件是否只触发一次就不再起作用。

“触发模式”控制该事件触发后对当前行为树的影响以及被触发的子树结束时应该如何恢复，有转移（Transfer）和返回（Return）两个选项：

• 转移：当子树结束时，当前行为树被中断和重置，该子树将被设置为当前行为树。
• 返回：当子树结束时，返回控制到之前打断的地方继续执行。当前行为树直接“压”到执行堆栈上而不被中断和重置，该子树被设置为当前行为树，当该子树结束时，原本的那棵行为树从执行堆栈上“弹出”，并从当初的节点恢复执行。

4. 程序端发送事件

最后，在程序端通过如下代码，将事件“event_task”发出，并指定所需的参数，如下代码所示：

g_FirstAgent->FireEvent("event_task", 2);

这样，在执行行为树maintree_task过程中，如果接收到事件event_task，那么该行为树中的事件附件event_task将得到响应和处理，行为树的执行就会从当前的maintree_task跳转到subtree_task。

注意：调用FireEvent的时候，只有处于Running状态的节点才会响应事件。这是为了允许不同分支在不同时机下，同样的事件可以触发不同的行为。比如同样是BeingHit，受伤或逃跑的时候可以分别对应不同的行为。如果不需要根据不同的节点响应不同的行为，只是需要响应事件，一般只需把事件配置在根节点的第一个子节点上（根节点同样需要是Running状态，非Running状态的节点没有机会响应事件）。

5. 执行行为树

执行行为树maintree_task，可以得到如下结果：

本教程对应的工作区和代码工程，请查看源码包中的目录tutorials/tutorial_6。

对于行为树的调试，behaviac提供了连调和离线调试两大功能。

连调功能是在游戏运行的时候，编辑器可以连上游戏，实时的查看树的运行情况、变量的当前值并可以设置断点等；而离线调试实际上是回放运行时所产生的log。

本教程主要介绍连调的过程和相关的功能说明，离线调试可以参考文章《调试功能的说明》。

连调需要游戏是开发版本（即宏BEHAVIAC_RELEASE没有被定义），发布版本下没有连调的功能，可以参考文章《版本说明》和《开发功能开关》。

打开目录tutorials/tutorial_7/workspace中的工作区，并打开类型信息浏览器，可以看到类FirstAgent有一个成员属性p1和两个成员方法Start和Wait，如下图所示：

点击上图右下方的应用按钮，在生成的FirstAgent.cpp文件中，填写Start和Wait的方法内容如下代码所示：

void FirstAgent::Start()
{
///<<< BEGIN WRITING YOUR CODE Start
    count = 0;
///<<< END WRITING YOUR CODE
}

behaviac::EBTStatus FirstAgent::Wait()
{
///<<< BEGIN WRITING YOUR CODE Wait
    count++;

    printf("p1 = %i\n", p1);

    if (count == 10000)
    {
        return behaviac::BT_SUCCESS;
    }

    return behaviac::BT_RUNNING;
///<<< END WRITING YOUR CODE
}

打开行为树demo，可以看到该行为树如下图所示：

为了在程序启动时，等待编辑器连接上才往后继续执行，需要在tutorial_7.cpp文件中的InitBehaviac方法中，添加如下代码：

behaviac::Config::SetSocketBlocking(true);

如果需要修改端口号，需要添加如下代码：

behaviac::Config::SetSocketPort(60636);

为了在连调时，程序端能够发送消息到编辑器端，需要在游戏循环中执行Workspace::DebugUpdate()方法，如下代码所示：

void UpdateLoop()
{
    LOGI("UpdateLoop\n");

    int frames = 0;
    behaviac::EBTStatus status = behaviac::BT_RUNNING;

    while (status == behaviac::BT_RUNNING)
    {
        LOGI("frame %d\n", ++frames);

        behaviac::Workspace::GetInstance()->DebugUpdate();

        status = g_FirstAgent->btexec();
    }
}

另外，如果程序端是通过Workspace::Update()的方式来统一执行所有Agent实例的行为树，则不需要再额外调用Workspace::DebugUpdate()方法，详见文章《运行时端的执行流程》。

启动程序，可以看到如下图所示：

上面表示，程序端已经在开始等待编辑器的连接了。

点击编辑器工具栏中的“连接”按钮，如下图所示：

在弹出的“连接游戏”窗口中，设置相应的IP和端口号后，点击“确认”按钮开始连接游戏，如下图所示：

编辑器成功连接后，在左侧的实例节点列表中，会列出当前的Agent实例，如下图所示：

在“输出”窗口中，可以看到程序端发送过来的所有消息，编辑器也正是根据这些消息来相应的刷新当前的高亮执行路径和处理断点、刷新成员属性的当前值等，如下图所示：

鼠标双击实例节点列表中的节点FirstAgent_0_0，开始跟踪该实例的当前行为树的执行情况，可以看到行为树有了高亮的执行路径效果，表示当前返回Running的所有节点序列，如下图所示：

双击某个节点的左侧可以为该节点添加“进入”断点，双击某个节点的右侧可以为该节点添加“退出”断点，如下图所示：

上图中高亮的断点，表示当前行为树的执行已经停在该处。点击Timeline工具栏中的“继续”按钮或直接按F5快捷键，可以继续执行行为树，如下图所示：

在属性窗口中，可以查看当前实例的所有成员属性及其当前值，如下图所示：

为了方便调试，可以在上图中手工修改属性的值，该值会被发送到程序端，影响行为树的执行。

有关连调的使用还可以参考连调相关常见问题。

本教程相关的工作区和代码工程详见源码包的目录tutorials/tutorial_7。

对于结构体类型的使用，包括新增全新的结构体和扩展使用已有的结构体。对于新增的结构体，又包括编辑器是否自动生成该结构体的代码。

实际上，我们将新增结构体，又不自动生成该结构体代码的情况，认为跟扩展使用已有的结构体是一致的，即都是在程序端已经有了该结构体的定义代码（要么手工编写，要么第三方代码已经包含了该结构体的定义），不用再让编辑器自动生成。

进而，后文将只通过“生成代码”和“不生成代码”来区分上面所说的各种使用情况，但这里需要注意的是，生成或不生成代码，只是针对结构体本身的定义而言，而结构体相关的“胶水”代码都是会自动生成的，并且必须要整合到自己的项目中一起编译构建。

1. 如果是“生成代码”的情况，则忽略这一步说明。否则，如果是“不生成代码”的情况，这里假定程序端已经有了结构体类型文件FirstStruct.h，该文件中包含了结构体“FirstStruct”的定义，如下代码所示：

struct FirstStruct
{
    int s1;
    float s2;
};

2. 在类型信息浏览器中新增跟程序端同名的结构体类型“FirstStruct”，并且根据自己的需要，来决定是否勾选“生成代码”选项（如果只是扩展使用已有的结构体，则不需要勾选），如下图所示：

3. 上图中的“引用类型”选项，一般不用勾选，表示在行为树编辑器中可以为该结构体配置其成员属性，并且在该结构体的两个实例做比较运算时，会比较所有的成员属性。否则，如果勾选了“引用类型”选项，则表示该结构体在行为树中使用时是作为引用类型来使用，在该结构体的两个实例做比较运算时，只会比较两个实例的引用（指针），而不比较其内容（成员属性）。

4. 为结构体“FirstStruct”添加成员属性s1和s2，这跟程序端的定义保持一致，如下图所示：

5. 对于C++版的运行时库，如果是“生成代码”的情况，则忽略这一步操作。否则，如果是“不生成代码”的情况，则说明程序端已经有了包含该结构体类型的头文件。点击上图右上方的“设置头文件”按钮，弹出“C++导出设置”窗口，并添加已有的结构体头文件FirstStruct.h，如下图所示：

6. 点击类型信息浏览器右下方的“应用”按钮，这样会在“代码生成位置”中生成该结构体的定义（如果上面勾选了“生成代码”选项）及相关的“胶水”代码behaviac_customized_types.h等文件，如下代码所示：

BEHAVIAC_EXTEND_EXISTING_TYPE_EX(FirstStruct, false);
BEHAVIAC_DECLARE_TYPE_VECTOR_HANDLER(FirstStruct);

// 如下结构体的定义代码，会根据是否勾选了上面所说的“生成代码”选项来决定是否生成
 
struct FirstStruct
{
    int s1;
    float s2;
};

// 如下代码，不管是否勾选了“生成代码”选项，都会自动生成

BEHAVIAC_EXTEND_EXISTING_TYPE_EX(FirstStruct, false);
BEHAVIAC_DECLARE_TYPE_VECTOR_HANDLER(FirstStruct);

template< typename SWAPPER >
inline void SwapByteImplement(FirstStruct& v)
{
    SwapByteImplement< SWAPPER >(v.s1);
    SwapByteImplement< SWAPPER >(v.s2);
}

namespace behaviac
{
    namespace PrivateDetails
    {
        template<>
        inline bool Equal(const FirstStruct& lhs, const FirstStruct& rhs)
        {
            return Equal(lhs.s1, rhs.s1)
                && Equal(lhs.s2, rhs.s2);
         }
     }
}

7. 为FirstAgent类新增成员属性p1，其类型是结构体FirstStruct，如下图所示：

8. 点击类型信息浏览器右下方的“应用”按钮，将“代码生成位置”中behaviac_generated/types目录下所有生成的代码文件，添加到自己的项目中一起编译构建。

9. 新增行为树“StrcutBT”，并使用成员属性p1来赋值和做比较运算，如下图所示：

10. 执行该行为树，得到如下执行结果：

本教程相关的工作区和代码工程详见源码包的目录tutorials/tutorial_8。

对于枚举类型的使用，包括新增全新的枚举和扩展使用已有的枚举。对于新增的枚举，又包括编辑器是否自动生成该枚举的代码。

实际上，我们将新增枚举，又不自动生成该枚举代码的情况，认为跟扩展使用已有的枚举是一致的，即都是在程序端已经有了该枚举的定义代码（要么手工编写，要么第三方代码已经包含了该枚举的定义），不用再让编辑器自动生成。

进而，后文将只通过“生成代码”和“不生成代码”来区分上面所说的各种使用情况，但这里需要注意的是，生成或不生成代码，只是针对枚举本身的定义而言，而枚举相关的“胶水”代码都是会自动生成的，并且必须要整合到自己的项目中一起编译构建。

1. 如果是“生成代码”的情况，则忽略这一步说明。否则，如果是“不生成代码”的情况，这里假定程序端已经有了枚举类型文件FirstEnum.h，该文件中包含了枚举“FirstEnum”的定义，如下代码所示：

enum FirstEnum
{
    e1,
    e2,
    e3
};

2. 在类型信息浏览器中新增跟程序端同名的枚举类型“FirstEnum”，并且根据自己的需要，来决定是否勾选“生成代码”选项（如果只是扩展使用已有的枚举，则不需要勾选），如下图所示：

3. 为枚举“FirstEnum”添加成员e1、e2和e3，这跟程序端的定义保持一致，如下图所示：

4. 对于C++版的运行时库，如果是“生成代码”的情况，则忽略这一步操作。否则，如果是“不生成代码”的情况，则说明程序端已经有了包含该枚举类型的头文件。点击上图右上方的“设置头文件”按钮，弹出“C++导出设置”窗口，并添加已有的枚举类型头文件FirstEnum.h，如下图所示：

5. 点击类型信息浏览器右下方的“应用”按钮，这样会在“代码生成位置”中生成该枚举的定义（如果上面勾选了“生成代码”选项）及相关的“胶水”代码behaviac_customized_types.h和behaviac_customized_types.cpp等文件，如下代码所示：

// behaviac_customized_types.h

// 如下枚举的定义代码，会根据是否勾选了上面所说的“生成代码”选项来决定是否生成

enum FirstEnum
{
    e1,
    e2,
    e3,
};

// 如下代码，不管是否勾选了“生成代码”选项，都会自动生成
 
DECLARE_BEHAVIAC_ENUM_EX(FirstEnum, FirstEnum);
BEHAVIAC_DECLARE_TYPE_VECTOR_HANDLER(FirstEnum);


// behaviac_customized_types.cpp

BEHAVIAC_BEGIN_ENUM_EX(FirstEnum, FirstEnum)
{
    BEHAVIAC_ENUMCLASS_DISPLAY_INFO_EX(L"FirstEnum", L"");

    BEHAVIAC_ENUM_ITEM_EX(e1, "e1");
    BEHAVIAC_ENUM_ITEM_EX(e2, "e2");
    BEHAVIAC_ENUM_ITEM_EX(e3, "e3");
}
BEHAVIAC_END_ENUM_EX()

6. 为FirstAgent类新增成员属性p1，其类型是枚举“FirstEnum”，如下图所示：

7. 点击类型信息浏览器右下方的“应用”按钮，将“代码生成位置”中behaviac_generated/types目录下所有生成的代码文件，添加到自己的项目中一起编译构建。

8. 新增行为树“EnumBT”，并使用成员属性p1来赋值和做比较运算，如下图所示：

9. 执行该行为树，得到如下执行结果：

本教程相关的工作区和代码工程详见源码包的目录tutorials/tutorial_9。

有的时候，由于自身项目的需要，例如对行为树文件进行加密、打包等处理，behaviac组件默认提供的文件加载机制不再满足需要，因此程序端需要定制自己的读取方式来加载行为树文件。

C++版

1. 需要从behaviac::CFileManager派生出自己的子类，并根据需要重载相关的方法，如下代码所示：

#include "behaviac/common/file/filemanager.h"

class BEHAVIAC_API MyFileManager : public behaviac::CFileManager
{
public:
    BEHAVIAC_DECLARE_MEMORY_OPERATORS(MyFileManager);

    MyFileManager();
    virtual ~MyFileManager();

    virtual behaviac::IFile* FileOpen(const char* fileName, behaviac::CFileSystem::EOpenMode iOpenAccess = behaviac::CFileSystem::EOpenMode_Read);

    virtual void FileClose(behaviac::IFile* file);
    virtual bool FileExists(const char* fileName);
    virtual bool FileExists(const behaviac::string& filePath, const behaviac::string& ext);

    virtual uint64_t FileGetSize(const char* fileName);
    virtual behaviac::wstring GetCurrentWorkingDirectory();
};

2. 根据自己的开发平台需要，实现相应的方法，这里只是简单的调用了基类的同名方法，仅用于演示流程，如下代码所示：

#include "myfilemanager.h"

MyFileManager::MyFileManager()
{
}

MyFileManager::~MyFileManager()
{
}

behaviac::IFile* MyFileManager::FileOpen(const char* fileName, behaviac::CFileSystem::EOpenMode iOpenAccess)
{
    // 需要实现自己的代码，这里直接调用基类的方法仅供演示
    return CFileManager::FileOpen(fileName, iOpenAccess);
}

void MyFileManager::FileClose(behaviac::IFile* file)
{
    CFileManager::FileClose(file);
}

bool MyFileManager::FileExists(const behaviac::string& filePath, const behaviac::string& ext)
{
    return CFileManager::FileExists(filePath, ext);
}

bool MyFileManager::FileExists(const char* fileName)
{
    return CFileManager::FileExists(fileName);
}

uint64_t MyFileManager::FileGetSize(const char* fileName)
{
    return CFileManager::FileGetSize(fileName);
}

behaviac::wstring MyFileManager::GetCurrentWorkingDirectory()
{
    return CFileManager::GetCurrentWorkingDirectory();
}

3. 在程序端初始化的地方，创建MyFileManager实例，如下代码所示：

bool InitBehavic()
{
    LOGI("InitBehavic\n");

    g_MyFileManager = BEHAVIAC_NEW MyFileManager();

    behaviac::Workspace::GetInstance()->SetFilePath("../tutorials/tutorial_10/cpp/exported");

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

    return true;
}

4. 调用Agent::btload()方法，就可以通过上面实现的MyFileManager来加载行为树文件了（Agent::btload()方法内部会执行到MyFileManager::FileOpen()方法），如下代码所示：

bool InitPlayer()
{
    LOGI("InitPlayer\n");

    g_FirstAgent = behaviac::Agent::Create<FirstAgent>();

    bool bRet = g_FirstAgent->btload("FirstBT");

    g_FirstAgent->btsetcurrent("FirstBT");

    return bRet;
}

5. 在程序端结束清理的地方，销毁上面创建的MyFileManager实例，如下代码所示：

void CleanupBehaviac()
{
    LOGI("CleanupBehaviac\n");

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

    if (g_MyFileManager)
    {
        BEHAVIAC_DELETE(g_MyFileManager);
        g_MyFileManager = NULL;
    }
}

C#版

1. 需要从behaviac.FileManager派生出自己的子类，并根据需要重载相关的方法，这里只是简单的调用了基类的同名方法，仅用于演示流程，如下代码所示：

public class MyFileManager : behaviac.FileManager
{
    public MyFileManager()
    {
    }

    public override byte[] FileOpen(string filePath, string ext)
    {
        // 需要实现自己的代码，这里直接调用基类的方法仅供演示
        return base.FileOpen(filePath, ext);
    }

    public override void FileClose(string filePath, string ext, byte[] fileHandle)
    {
        base.FileClose(filePath, ext, fileHandle);
    }
}

2. 在程序端初始化的地方，创建MyFileManager实例，如下代码所示：

static bool InitBehavic()
{
    Console.WriteLine("InitBehavic");

    g_MyFileManager = new MyFileManager();

    behaviac.Workspace.Instance.FilePath = "../../exported";
    behaviac.Workspace.Instance.FileFormat = behaviac.Workspace.EFileFormat.EFF_xml;

    return true;
}

3. 调用Agent.btload()方法，就可以通过上面实现的MyFileManager来加载行为树文件了（Agent.btload()方法内部会执行到MyFileManager.FileOpen()方法），如下代码所示：

static bool InitPlayer()
{
    Console.WriteLine("InitPlayer");

    g_FirstAgent = new FirstAgent();

    bool bRet = g_FirstAgent.btload("FirstBT");
    Debug.Assert(bRet);

    g_FirstAgent.btsetcurrent("FirstBT");

    return bRet;
}

4. 在程序端结束清理的地方，释放上面创建的MyFileManager实例引用，如下代码所示：

static void CleanupBehaviac()
{
    Console.WriteLine("CleanupBehaviac");

    behaviac.Workspace.Instance.Cleanup();

    g_MyFileManager = null;
}

本教程相关的工作区和代码工程详见源码包的目录tutorials/tutorial_10。

可以参考源码包中tutorials/tutorial_11的做法类似构建自己的项目，具体步骤如下：

1. 新建自己的项目。这里我们直接打开已有的behaviac_android项目，如下图所示：

2. 双击打开build.gradle文件，如下图所示：

3. 在打开的文件中，修改cmake文件的相对路径，如下代码所示：

externalNativeBuild {
    cmake {
        path "../../../../CMakeLists.txt"
    }
}

add_subdirectory ("${PROJECT_SOURCE_DIR}/tutorials/tutorial_11/cpp")

打开该文件，可以看到我们将tutorial_11作为一个lib来编译构建，如下代码所示：

if (BEHAVIAC_ANDROID_STUDIO)
   add_library(tutorial_11 SHARED ${BTUNITTEST_INC} ${BTUNITTEST_SRC})
else()
   # add the executable
   add_executable(tutorial_11 ${BTUNITTEST_INC} ${BTUNITTEST_SRC})
endif()

target_link_libraries (tutorial_11 libbehaviac ${CMAKE_THREAD_LIBS_INIT})

5. 新建Android所需的assets目录，将behaviac编辑器导出的行为树和类型信息文件全部放在该目录中，如下图所示：

6. 在tutorial_11.cpp文件的InitBehavic()方法中，调用了Workspace::SetFilePath()接口，设置行为树加载路径，必须要以“assets:/”字符串开头，如下代码所示：

const char* InitBehavic()
{
    LOGI("InitBehavic\n");

#if !BEHAVIAC_CCDEFINE_ANDROID
    behaviac::Workspace::GetInstance()->SetFilePath("../tutorials/tutorial_11/cpp/exported");
#else
    behaviac::Workspace::GetInstance()->SetFilePath("assets:/behaviac/exported");
#endif

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

    return "InitBehavic\n";
}

7. 在项目的MainActivity.java文件中，加载behaviac_gcc_debug和tutorial_11_gcc_debug库，如下代码所示：

static {
    System.loadLibrary("behaviac_gcc_debug");
    System.loadLibrary("tutorial_11_gcc_debug");
}

8. 在onCreate()方法中调用C++的方法（这样处理仅供示范），并将AssetManager实例传递给C++端，如下代码所示：

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    // Example of a call to a native method
    TextView tv = (TextView) findViewById(R.id.sample_text);
    tv.setText(TestMain(getApplication().getAssets()));
}

public native String TestMain(android.content.res.AssetManager assetManager);

9. 在tutorial_11.cpp文件中，实现了上一步中的TestMain()方法，调用接口Workspace::SetAssetManager()设置AssetManager实例，如下代码所示：

extern "C"
JNIEXPORT jstring JNICALL
Java_com_tencent_behaviac_behaviac_1android_MainActivity_TestMain(JNIEnv* env, jclass cls, jobject assetManager)
{
    AAssetManager* mgr = AAssetManager_fromJava(env, assetManager);
    BEHAVIAC_ASSERT(mgr);

    behaviac::CFileManager::GetInstance()->SetAssetManager(mgr);

    std::string str = TestBehaviac();

    return env->NewStringUTF(str.c_str());
}

10. 编译构建APK包，并安装运行，结果如下图所示：

本教程相关的工作区和代码工程详见源码包的目录tutorials/tutorial_11。

并行节点用于一般意义上并行的执行所有子节点，相关的功能和属性说明详见手册《并行节点》。

并行节点容易在其属性配置上产生误用，本文将结合行为树中对并行节点的实际使用来加以说明。

1. 首先创建Agent子类“FirstAgent”及其成员属性p1和成员方法Say(behaviac::string& value, bool isLatent)，Say()方法用于打印指定的参数，如下图所示：

Say()方法表示对于isLatent为真的情况，在第三帧后返回成功，前两帧返回正在执行；而对于isLatent为假的情况，在第一帧就直接返回成功，其实现代码如下所示：

behaviac::EBTStatus FirstAgent::Say(behaviac::string& value, bool isLatent)
{
///<<< BEGIN WRITING YOUR CODE Say
    if (isLatent && behaviac::Workspace::GetInstance()->GetFrameSinceStartup() < 3)
    {
        printf("\n%s [Running]\n\n", value.c_str());

        return behaviac::BT_RUNNING;
    }

    printf("\n%s [Success]\n\n", value.c_str());

    return behaviac::BT_SUCCESS;
///<<< END WRITING YOUR CODE
}

其中，当前帧数在主循环代码中每帧进行累加，如下代码所示：

void UpdateLoop()
{
    LOGI("UpdateLoop\n");

    behaviac::Workspace::GetInstance()->SetFrameSinceStartup(0);

    behaviac::EBTStatus status = behaviac::BT_RUNNING;

    while (status == behaviac::BT_RUNNING)
    {
        behaviac::Workspace::GetInstance()->SetFrameSinceStartup(behaviac::Workspace::GetInstance()->GetFrameSinceStartup() + 1);

        LOGI("frame %d\n", behaviac::Workspace::GetInstance()->GetFrameSinceStartup());

        status = g_FirstAgent->btexec();
    }
}

2. 创建行为树“ParallelBT”，其中并行节点有3个子节点，第一个是条件节点，第二和三个都是动作节点，如下图所示：

3. 该并行节点的的属性默认配置如下图所示：

• 失败条件：FAIL_ON_ONE表示一个子节点返回失败，那么并行节点就返回失败。
• 成功条件：SUCCEED_ON_ALL表示所有子节点都返回成功，并行节点才返回成功。这里需要注意，失败条件优先于成功条件。
• 子节点结束继续条件：CHILDFINISH_LOOP表示子节点结束后会重新再循环执行。
• 退出行为：EXIT_ABORT_RUNNINGSIBLINGS表示当并行节点的成功或失败条件满足并返回成功或失败后，会终止掉其他还在运行的子节点。

4. 执行该行为树，结果如下图所示：

5. 将并行节点的属性“子节点结束继续条件”改为CHILDFINISH_ONCE，表示子节点结束后不再执行（除非重入该并行节点），如下图所示：

6. 再执行该行为树，结果如下图所示：

从上图可以看到，虽然一共循环了3次，但ID为7的动作节点只执行了一次，而ID为0的动作节点由于前两帧执行时返回Running，得到持续执行，直到第三帧返回Success或Failure。

7. 将并行节点的属性“失败条件”改为FAIL_ON_ALL，并将“成功条件”改为SUCCEED_ON_ONE，如下图所示：

8. 再执行该行为树，结果如下图所示：

从上图可以看到，一共循环了1次，并行节点的所有子节点也都执行了1次。

本教程相关的工作区和代码工程详见源码包的目录tutorials/tutorial_12。

为了方便使用，behaviac组件除了提供传统的序列、选择等组合节点之外，还提供了随机与概率相关的节点类型，主要包括随机序列（SequenceStochastic）、随机选择（SelectorStochastic）和概率选择（SelectorProbability）等节点。

这3个节点对于初学者容易混淆，本文将结合行为树中对这3个节点的使用来分别加以说明。

1. 创建类型信息

首先创建Agent子类“FirstAgent”及其成员方法Say(behaviac::string& value)，Say()方法用于打印指定的参数，如下图所示：

2. 随机序列节点

如果对随机序列节点不熟悉，请首先查看其手册《随机序列节点》。

1. 创建行为树“sequencestochasticBT”，其中随机序列节点有3个动作子节点，分别输出“A”、“B”、“C”，如下图所示：

2. 随机序列节点的的属性“随机数”默认为空，表示使用系统默认的随机数产生器，当然也可以配置自己实现的随机数方法，这里我们保持为空即可，如下图所示：

3. 执行该行为树，结果如下图所示：

可以看到随机输出了“B”、“C”、“A”，但多次执行程序，发现都是输出这个顺序，并没有随机输出。这是由于没有调用随机种子方法，需要在代码中调用如下接口即可：

#if BEHAVIAC_CCDEFINE_MSVC
    time_t timer;
    time(&timer);

    behaviac::RandomGenerator::GetInstance()->setSeed((unsigned int)timer);
#endif

3. 随机选择节点

如果对随机选择节点不熟悉，请首先查看其手册《随机选择节点》。

1. 创建行为树“selectorstochasticBT”，其中随机选择节点有3个动作子节点，分别输出“A”、“B”、“C”，如下图所示：

2. 随机选择节点的的属性“随机数”默认为空，表示使用系统默认的随机数产生器，当然也可以配置自己实现的随机数方法，这里我们保持为空即可，如下图所示：

3. 执行该行为树，结果如下图所示：

可以看到随机输出了“C”，多次执行程序，可以看到还会随机输出“A”或“B”。

4. 概率选择节点

如果对概率选择节点不熟悉，请首先查看其手册《概率选择节点》。

1. 创建行为树“selectorprobabilityBT”，其中概率选择节点有3个动作子节点，权值分别为20、30、50，表示分别会已20%、30%、50%的概率输出“A”、“B”、“C”，如下图所示：

2. 概率选择节点节点的的属性“随机数”默认为空，表示使用系统默认的随机数产生器，当然也可以配置自己实现的随机数方法，这里我们保持为空即可，如下图所示：

3. 执行该行为树，结果如下图所示：

可以看到随机输出了“B”，多次执行程序，可以看到还会随机输出“A”或“C”。

本教程相关的工作区和代码工程详见源码包的目录tutorials/tutorial_13。