[
  {
    "path": "BrainTree.h",
    "content": "// BrainTree - A C++ behavior tree single header library.\n// Copyright 2015-2018 Par Arvidsson. All rights reserved.\n// Licensed under the MIT license (https://github.com/arvidsson/BrainTree/blob/master/LICENSE).\n\n#pragma once\n\n#include <memory>\n#include <vector>\n#include <string>\n#include <unordered_map>\n#include <cassert>\n\nnamespace BrainTree\n{\n\nclass Blackboard\n{\npublic:\n    void setBool(std::string key, bool value) { bools[key] = value; }\n    bool getBool(std::string key)\n    {\n        if (bools.find(key) == bools.end()) {\n            bools[key] = false;\n        }\n        return bools[key];\n    }\n    bool hasBool(std::string key) const { return bools.find(key) != bools.end(); }\n\n    void setInt(std::string key, int value)  { ints[key] = value; }\n    int getInt(std::string key)\n    {\n        if (ints.find(key) == ints.end()) {\n            ints[key] = 0;\n        }\n        return ints[key];\n    }\n    bool hasInt(std::string key) const  { return ints.find(key) != ints.end(); }\n\n    void setFloat(std::string key, float value)  { floats[key] = value; }\n    float getFloat(std::string key)\n    {\n        if (floats.find(key) == floats.end()) {\n            floats[key] = 0.0f;\n        }\n        return floats[key];\n    }\n    bool hasFloat(std::string key) const  { return floats.find(key) != floats.end(); }\n\n    void setDouble(std::string key, double value)  { doubles[key] = value; }\n    double getDouble(std::string key)\n    {\n        if (doubles.find(key) == doubles.end()) {\n            doubles[key] = 0.0f;\n        }\n        return doubles[key];\n    }\n    bool hasDouble(std::string key) const  { return doubles.find(key) != doubles.end(); }\n\n    void setString(std::string key, std::string value)  { strings[key] = value; }\n    std::string getString(std::string key)\n    {\n        if (strings.find(key) == strings.end()) {\n            strings[key] = \"\";\n        }\n        return strings[key];\n    }\n    bool hasString(std::string key) const  { return strings.find(key) != strings.end(); }\n\n    using Ptr = std::shared_ptr<Blackboard>;\n\nprotected:\n    std::unordered_map<std::string, bool> bools;\n    std::unordered_map<std::string, int> ints;\n    std::unordered_map<std::string, float> floats;\n    std::unordered_map<std::string, double> doubles;\n    std::unordered_map<std::string, std::string> strings;\n};\n\nclass Node\n{\npublic:\n    enum class Status\n    {\n        Invalid,\n        Success,\n        Failure,\n        Running,\n    };\n\n    virtual ~Node() {}\n    void setBlackboard(Blackboard::Ptr board) {\n        blackboard = board;\n    }\n    Blackboard::Ptr getBlackboard() const { return blackboard; }\n\n    virtual Status update() = 0;\n    virtual void initialize() {}\n    virtual void terminate(Status s) {}\n\n    Status tick()\n    {\n        if (status != Status::Running) {\n            initialize();\n        }\n\n        status = update();\n\n        if (status != Status::Running) {\n            terminate(status);\n        }\n\n        return status;\n    }\n\n    bool isSuccess() const { return status == Status::Success; }\n    bool isFailure() const { return status == Status::Failure; }\n    bool isRunning() const { return status == Status::Running; }\n    bool isTerminated() const { return isSuccess() || isFailure(); }\n\n    void reset() { status = Status::Invalid; }\n\n    using Ptr = std::shared_ptr<Node>;\n\nprotected:\n    Status status = Status::Invalid;\n    Blackboard::Ptr blackboard = nullptr;\n};\n\nclass Composite : public Node\n{\npublic:\n    virtual ~Composite() {}\n    \n    void addChild(Node::Ptr child) { children.push_back(child); it=children.begin(); }\n    bool hasChildren() const { return !children.empty(); }\n    \nprotected:\n    std::vector<Node::Ptr> children;\n    std::vector<Node::Ptr>::iterator it;\n};\n\nclass Decorator : public Node\n{\npublic:\n    virtual ~Decorator() {}\n\n    void setChild(Node::Ptr node) { child = node; }\n    bool hasChild() const { return child != nullptr; }\n    \nprotected:\n    Node::Ptr child = nullptr;\n};\n\nclass Leaf : public Node\n{\npublic:\n    Leaf() {}\n    virtual ~Leaf() {}\n    Leaf(Blackboard::Ptr blackboard) : blackboard(blackboard) {}\n    \n    virtual Status update() = 0;\n\nprotected:\n    Blackboard::Ptr blackboard;\n};\n\nclass BehaviorTree : public Node\n{\npublic:\n    BehaviorTree() {\n        blackboard = std::make_shared<Blackboard>();\n    }\n    BehaviorTree(const Node::Ptr &rootNode) : BehaviorTree() { root = rootNode; }\n    \n    Status update() { return root->tick(); }\n    \n    void setRoot(const Node::Ptr &node) { root = node; }\n    \nprivate:\n    Node::Ptr root = nullptr;\n};\n\ntemplate <class Parent>\nclass DecoratorBuilder;\n\ntemplate <class Parent>\nclass CompositeBuilder\n{\npublic:\n    CompositeBuilder(Parent* parent, Composite* node) : parent(parent), node(node) {}\n\n    template <class NodeType, typename... Args>\n    CompositeBuilder<Parent> leaf(Args... args)\n    {\n        auto child = std::make_shared<NodeType>((args)...);\n        child->setBlackboard(node->getBlackboard());\n        node->addChild(child);\n        return *this;\n    }\n\n    template <class CompositeType, typename... Args>\n    CompositeBuilder<CompositeBuilder<Parent>> composite(Args... args)\n    {\n        auto child = std::make_shared<CompositeType>((args)...);\n        child->setBlackboard(node->getBlackboard());\n        node->addChild(child);\n        return CompositeBuilder<CompositeBuilder<Parent>>(this, (CompositeType*)child.get());\n    }\n\n    template <class DecoratorType, typename... Args>\n    DecoratorBuilder<CompositeBuilder<Parent>> decorator(Args... args)\n    {\n        auto child = std::make_shared<DecoratorType>((args)...);\n        child->setBlackboard(node->getBlackboard());\n        node->addChild(child);\n        return DecoratorBuilder<CompositeBuilder<Parent>>(this, (DecoratorType*)child.get());\n    }\n\n    Parent& end()\n    {\n        return *parent;\n    }\n\nprivate:\n    Parent * parent;\n    Composite* node;\n};\n\ntemplate <class Parent>\nclass DecoratorBuilder\n{\npublic:\n    DecoratorBuilder(Parent* parent, Decorator* node) : parent(parent), node(node) {}\n\n    template <class NodeType, typename... Args>\n    DecoratorBuilder<Parent> leaf(Args... args)\n    {\n        auto child = std::make_shared<NodeType>((args)...);\n        child->setBlackboard(node->getBlackboard());\n        node->setChild(child);\n        return *this;\n    }\n\n    template <class CompositeType, typename... Args>\n    CompositeBuilder<DecoratorBuilder<Parent>> composite(Args... args)\n    {\n        auto child = std::make_shared<CompositeType>((args)...);\n        child->setBlackboard(node->getBlackboard());\n        node->setChild(child);\n        return CompositeBuilder<DecoratorBuilder<Parent>>(this, (CompositeType*)child.get());\n    }\n\n    template <class DecoratorType, typename... Args>\n    DecoratorBuilder<DecoratorBuilder<Parent>> decorator(Args... args)\n    {\n        auto child = std::make_shared<DecoratorType>((args)...);\n        child->setBlackboard(node->getBlackboard());\n        node->setChild(child);\n        return DecoratorBuilder<DecoratorBuilder<Parent>>(this, (DecoratorType*)child.get());\n    }\n\n    Parent& end()\n    {\n        return *parent;\n    }\n\nprivate:\n    Parent * parent;\n    Decorator* node;\n};\n\nclass Builder\n{\npublic:\n    Builder() {\n        tree = std::make_shared<BehaviorTree>();\n    }\n    template <class NodeType, typename... Args>\n    Builder leaf(Args... args)\n    {\n        root = std::make_shared<NodeType>((args)...);\n        root->setBlackboard(tree->getBlackboard());\n        return *this;\n    }\n\n    template <class CompositeType, typename... Args>\n    CompositeBuilder<Builder> composite(Args... args)\n    {\n        root = std::make_shared<CompositeType>((args)...);\n        root->setBlackboard(tree->getBlackboard());\n        return CompositeBuilder<Builder>(this, (CompositeType*)root.get());\n    }\n\n    template <class DecoratorType, typename... Args>\n    DecoratorBuilder<Builder> decorator(Args... args)\n    {\n        root = std::make_shared<DecoratorType>((args)...);\n        root->setBlackboard(tree->getBlackboard());\n        return DecoratorBuilder<Builder>(this, (DecoratorType*)root.get());\n    }\n\n    Node::Ptr build()\n    {\n        assert(root != nullptr && \"The Behavior Tree is empty!\");\n        tree->setRoot(root);\n        return tree;\n    }\n\nprivate:\n    Node::Ptr root;\n    std::shared_ptr<BehaviorTree> tree;\n};\n\n// The Selector composite ticks each child node in order.\n// If a child succeeds or runs, the selector returns the same status.\n// In the next tick, it will try to run each child in order again.\n// If all children fails, only then does the selector fail.\nclass Selector : public Composite\n{\npublic:\n    void initialize() override\n    {\n        it = children.begin();\n    }\n\n    Status update() override\n    {\n        assert(hasChildren() && \"Composite has no children\");\n\n        while (it != children.end()) {\n            auto status = (*it)->tick();\n\n            if (status != Status::Failure) {\n                return status;\n            }\n\n            it++;\n        }\n\n        return Status::Failure;\n    }\n};\n\n// The Sequence composite ticks each child node in order.\n// If a child fails or runs, the sequence returns the same status.\n// In the next tick, it will try to run each child in order again.\n// If all children succeeds, only then does the sequence succeed.\nclass Sequence : public Composite\n{\npublic:\n    void initialize() override\n    {\n        it = children.begin();\n    }\n\n    Status update() override\n    {\n        assert(hasChildren() && \"Composite has no children\");\n\n        while (it != children.end()) {\n            auto status = (*it)->tick();\n\n            if (status != Status::Success) {\n                return status;\n            }\n\n            it++;\n        }\n\n        return Status::Success;\n    }\n};\n\n// The StatefulSelector composite ticks each child node in order, and remembers what child it prevously tried to tick.\n// If a child succeeds or runs, the stateful selector returns the same status.\n// In the next tick, it will try to run the next child or start from the beginning again.\n// If all children fails, only then does the stateful selector fail.\nclass StatefulSelector : public Composite\n{\npublic:\n    Status update() override\n    {\n        assert(hasChildren() && \"Composite has no children\");\n\n        while (it != children.end()) {\n            auto status = (*it)->tick();\n\n            if (status != Status::Failure) {\n                return status;\n            }\n\n            it++;\n        }\n\n        it = children.begin();\n        return Status::Failure;\n    }\n};\n\n// The StatefulSequence composite ticks each child node in order, and remembers what child it prevously tried to tick.\n// If a child fails or runs, the stateful sequence returns the same status.\n// In the next tick, it will try to run the next child or start from the beginning again.\n// If all children succeeds, only then does the stateful sequence succeed.\nclass StatefulSequence : public Composite\n{\npublic:\n    Status update() override\n    {\n        assert(hasChildren() && \"Composite has no children\");\n\n        while (it != children.end()) {\n            auto status = (*it)->tick();\n\n            if (status != Status::Success) {\n                return status;\n            }\n\n            it++;\n        }\n\n        it = children.begin();\n        return Status::Success;\n    }\n};\n\nclass ParallelSequence : public Composite\n{\npublic:\n    ParallelSequence(bool successOnAll = true, bool failOnAll = true) : useSuccessFailPolicy(true), successOnAll(successOnAll), failOnAll(failOnAll) {}\n    ParallelSequence(int minSuccess, int minFail) : minSuccess(minSuccess), minFail(minFail) {}\n\n    Status update() override\n    {\n        assert(hasChildren() && \"Composite has no children\");\n\n        int minimumSuccess = minSuccess;\n        int minimumFail = minFail;\n\n        if (useSuccessFailPolicy) {\n            if (successOnAll) {\n                minimumSuccess = children.size();\n            }\n            else {\n                minimumSuccess = 1;\n            }\n\n            if (failOnAll) {\n                minimumFail = children.size();\n            }\n            else {\n                minimumFail = 1;\n            }\n        }\n\n        int total_success = 0;\n        int total_fail = 0;\n\n        for (auto &child : children) {\n            auto status = child->tick();\n            if (status == Status::Success) {\n                total_success++;\n            }\n            if (status == Status::Failure) {\n                total_fail++;\n            }\n        }\n\n        if (total_success >= minimumSuccess) {\n            return Status::Success;\n        }\n        if (total_fail >= minimumFail) {\n            return Status::Failure;\n        }\n\n        return Status::Running;\n    }\n\nprivate:\n    bool useSuccessFailPolicy = false;\n    bool successOnAll = true;\n    bool failOnAll = true;\n    int minSuccess = 0;\n    int minFail = 0;\n};\n\n// The Succeeder decorator returns success, regardless of what happens to the child.\nclass Succeeder : public Decorator\n{\npublic:\n    Status update() override\n    {\n        child->tick();\n        return Status::Success;\n    }\n};\n\n// The Failer decorator returns failure, regardless of what happens to the child.\nclass Failer : public Decorator\n{\npublic:\n    Status update() override\n    {\n        child->tick();\n        return Status::Failure;\n    }\n};\n\n// The Inverter decorator inverts the child node's status, i.e. failure becomes success and success becomes failure.\n// If the child runs, the Inverter returns the status that it is running too.\nclass Inverter : public Decorator\n{\npublic:\n    Status update() override\n    {\n        auto s = child->tick();\n\n        if (s == Status::Success) {\n            return Status::Failure;\n        }\n        else if (s == Status::Failure) {\n            return Status::Success;\n        }\n\n        return s;\n    }\n};\n\n// The Repeater decorator repeats infinitely or to a limit until the child returns success.\nclass Repeater : public Decorator\n{\npublic:\n    Repeater(int limit = 0) : limit(limit) {}\n\n    void initialize() override\n    {\n        counter = 0;\n    }\n\n    Status update() override\n    {\n        child->tick();\n\n        if (limit > 0 && ++counter == limit) {\n            return Status::Success;\n        }\n\n        return Status::Running;\n    }\n\nprotected:\n    int limit;\n    int counter = 0;\n};\n\n// The UntilSuccess decorator repeats until the child returns success and then returns success.\nclass UntilSuccess : public Decorator\n{\npublic:\n    Status update() override\n    {\n        while (1) {\n            auto status = child->tick();\n\n            if (status == Status::Success) {\n                return Status::Success;\n            }\n        }\n    }\n};\n\n// The UntilFailure decorator repeats until the child returns fail and then returns success.\nclass UntilFailure : public Decorator\n{\npublic:\n    Status update() override\n    {\n        while (1) {\n            auto status = child->tick();\n\n            if (status == Status::Failure) {\n                return Status::Success;\n            }\n        }\n    }\n};\n\n} // namespace BrainTree\n"
  },
  {
    "path": "LICENSE",
    "content": "The MIT License (MIT)\n\nCopyright (c) Pr Arvidsson 2015-2018\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n\n"
  },
  {
    "path": "README.md",
    "content": "# BrainTree\n\nA C++ [behavior tree](http://gamasutra.com/blogs/ChrisSimpson/20140717/221339/Behavior_trees_for_AI_How_they_work.php) single header library.\n\n## Features\n\n- behavior tree implementation\n- predefined composites\n- predefined decorators\n- (optional) rudimentary blackboard\n- (optional) behavior tree builders\n\n## Install\n\nInclude `BrainTree.h` in your project.\n\n## Example\n\n```c++\n// this example should print out \"Hello, World!\", four times\n#include <iostream>\n#include \"BrainTree.h\"\n\nclass Action : public BrainTree::Node\n{\npublic:\n    Status update() override\n    {\n        std::cout << \"Hello, World!\" << std::endl;\n        return Node::Status::Success;\n    }\n};\n\nvoid CreatingBehaviorTreeManually()\n{\n    BrainTree::BehaviorTree tree;\n    auto sequence = std::make_shared<BrainTree::Sequence>();\n    auto sayHello = std::make_shared<Action>();\n    auto sayHelloAgain = std::make_shared<Action>();\n    sequence->addChild(sayHello);\n    sequence->addChild(sayHelloAgain);\n    tree.setRoot(sequence);\n    tree.update();\n}\n\nvoid CreatingBehaviorTreeUsingBuilders()\n{\n    auto tree = BrainTree::Builder()\n        .composite<BrainTree::Sequence>()\n            .leaf<Action>()\n            .leaf<Action>()\n        .end()\n        .build();\n    tree->update();\n}\n\nint main()\n{\n    CreatingBehaviorTreeManually();\n    CreatingBehaviorTreeUsingBuilders();\n    return 0;\n}\n```\n\n## Composites\n\n| Composite        | Behaviour                                                                       | Success                 | Running               | Failure              |\n| ---------------- | ------------------------------------------------------------------------------- | ----------------------- | --------------------- | -------------------- |\n| Selector         | Ticks each child node in order, starting from the beginning each tick           | If a child succeeds     | If a child is running | If all children fail |\n| Sequence         | Ticks each child node in order, starting from the beginning each tick           | If all children succeed | If a child is running | If a child fails     |\n| StatefulSelector | Ticks each child node in order, starting from the child ticked in previous tick | If a child succeeds     | If a child is running | If all children fail |\n| StatefulSequence | Ticks each child node in order, starting from the child ticked in previous tick | If all children succeed | If a child is running | If a child fails     |\n\n## Decorators\n\n| Decorator    | Behaviour                                                 |\n| ------------ | --------------------------------------------------------- |\n| Succeeder    | Always returns success                                    |\n| Failer       | Always returns failure                                    |\n| Inverter     | Inverts the result of the child node                      |\n| Repeater     | Repeats until child node succeeds (infinitely or limited) |\n| UntilSuccess | Repeats until child node succeeds                         |\n| UntilFailure | Repeats until child node fails                            |\n\n## Builder\n\nThe Builder class simplifies the process of creating a behavior tree. You use three methods to build your tree:\n\n- `leaf<NodeType>()`\n- `composite<CompositeType>()`\n- `decorator<DecoratorType>()`\n\nBoth `composite()` and `decorator()` require a corresponding call to `end()`, this marks where you are done adding children to a composite or a child to a decorator. At the very end you call `build()` which will then give you the finished behavior tree.\n\n```\nauto tree = Builder()\n    .decorator<Repeater>()\n        .composite<Sequence>()\n            .leaf<SayHello>(\"Foo\")\n            .leaf<SayHello>(\"Bar\")\n        .end()\n    .end()\n    .build();\n```\n\n## License\n\nMIT (c) Pär Arvidsson 2015-2018\n"
  },
  {
    "path": "example/Example01_Simple.cpp",
    "content": "#include <iostream>\n#include \"BrainTree.h\"\n\nnamespace bt = BrainTree;\n\nclass SayHello : public bt::Node\n{\n    Status update() override\n    {\n        std::cout << \"Hello, World!\" << std::endl;\n        return Node::Status::Success;\n    }\n};\n\nint main()\n{\n    bt::BehaviorTree tree;\n\n    auto repeater = std::make_shared<bt::Repeater>(5);\n    repeater->setChild(std::make_shared<SayHello>());\n    tree.setRoot(repeater);\n\n    // simulate 5 frames\n    for (int i = 0; i < 5; i++)\n        tree.update();\n\n    return 0;\n}\n"
  },
  {
    "path": "example/Example02_Simple.cpp",
    "content": "// this example demonstrates the beviorial difference between\n// Sequence, MemSequence, Selector, StatefulSelector\n//\n// g++ -std=c++11 Example02_Simple.cpp && ./a.out\n#include <iostream>\nusing namespace std;\n#include \"../BrainTree.h\"\n\n#define STR(var) #var\n\nenum BoardItem {\n    MSG,\n};\n\nclass SuccessAction : public BrainTree::Node {\npublic:\n    SuccessAction(int i) {\n         id = i;\n    }\n    Status update() override {\n        cout << \"  success\" << id << \" action\" << endl;\n        sprintf(buffer, \"    message from success%d\", id);\n        assert(blackboard != nullptr && \"The Blackboard is empty!\");\n        blackboard->setString(STR(MSG), buffer);\n        return Status::Success;\n    }\nprivate:\n    char buffer[128]; \n    int id;\n};\n\nclass FailAction : public BrainTree::Node {\npublic:\n    Status update() override {\n        cout << \"  fail action\" << endl;\n        assert(blackboard != nullptr && \"The Blackboard is empty!\");\n        cout << blackboard->getString(STR(MSG)) << endl;\n        return Status::Failure;\n    }\n};\n\nvoid CreatingBehaviorTreeUsingBuilders() {\n    cout << \"\\n*** Creating BehaviorTree Using Builders\" << endl;\n    cout << \"\\n* Sequence: success1 -> fail -> success2, three times\" << endl;\n    auto tree = BrainTree::Builder()\n        .composite<BrainTree::Sequence>()\n            .leaf<SuccessAction>(1)\n            .leaf<FailAction>()\n            .leaf<SuccessAction>(2)\n        .end()\n        .build();\n    cout << \" first update()\" << endl;\n    tree->update();\n    cout << \" second update()\" << endl;\n    tree->update();\n    cout << \" third update()\" << endl;\n    tree->update();\n\n    cout << \"\\n* MemSequence: success1 -> fail -> success2, three times\" << endl;\n    tree = BrainTree::Builder()\n        .composite<BrainTree::MemSequence>()\n            .leaf<SuccessAction>(1)\n            .leaf<FailAction>()\n            .leaf<SuccessAction>(2)\n        .end()\n        .build();\n    cout << \" first update()\" << endl;\n    tree->update();\n    cout << \" second update()\" << endl;\n    tree->update();\n    cout << \" third update()\" << endl;\n    tree->update();\n\n    cout << \"\\n* Selector: fail -> success1 -> success2, three times\" << endl;\n    tree = BrainTree::Builder()\n        .composite<BrainTree::Selector>()\n            .leaf<FailAction>()\n            .leaf<SuccessAction>(1)\n            .leaf<SuccessAction>(2)\n        .end()\n        .build();\n    cout << \" first update()\" << endl;\n    tree->update();\n    cout << \" second update()\" << endl;\n    tree->update();\n    cout << \" third update()\" << endl;\n    tree->update();\n\n    cout << \"\\n* StatefulSelector: fail -> success1 -> success2, three times\" << endl;\n    tree = BrainTree::Builder()\n        .composite<BrainTree::StatefulSelector>()\n            .leaf<FailAction>()\n            .leaf<SuccessAction>(1)\n            .leaf<SuccessAction>(2)\n        .end()\n        .build();\n    cout << \" first update()\" << endl;\n    tree->update();\n    cout << \" second update()\" << endl;\n    tree->update();\n    cout << \" third update()\" << endl;\n    tree->update();\n\n    cout << \"\\n* Sequence: Succeeder w/ fail child\" << endl;\n    cout << \"-> Inverted Failer w/ success1 child\" << endl;\n    cout << \"-> success2\" << endl;\n    tree = BrainTree::Builder()\n        .composite<BrainTree::Sequence>()\n            .decorator<BrainTree::Succeeder>()\n                .leaf<FailAction>()\n            .end()\n            .decorator<BrainTree::Inverter>()\n                .decorator<BrainTree::Failer>()\n                    .leaf<SuccessAction>(1)\n                .end()\n            .end()\n            .leaf<SuccessAction>(2)\n        .end()\n        .build();\n    tree->update();\n}\n\nint main() {\n    CreatingBehaviorTreeUsingBuilders();\n    return 0;\n}"
  }
]