arvidsson / braintree

C++ behavior tree single header library

BrainTree

A C++ behavior tree single header library.

Features

• behavior tree implementation
• predefined composites
• predefined decorators
• (optional) rudimentary blackboard
• (optional) behavior tree builders

Install

Include BrainTree.h in your project.

Example

// this example should print out "Hello, World!", four times
#include <iostream>
#include "BrainTree.h"

class Action : public BrainTree::Node
{
public:
    Status update() override
    {
        std::cout << "Hello, World!" << std::endl;
        return Node::Status::Success;
    }
};

void CreatingBehaviorTreeManually()
{
    BrainTree::BehaviorTree tree;
    auto sequence = std::make_shared<BrainTree::Sequence>();
    auto sayHello = std::make_shared<Action>();
    auto sayHelloAgain = std::make_shared<Action>();
    sequence->addChild(sayHello);
    sequence->addChild(sayHelloAgain);
    tree.setRoot(sequence);
    tree.update();
}

void CreatingBehaviorTreeUsingBuilders()
{
    auto tree = BrainTree::Builder()
        .composite<BrainTree::Sequence>()
            .leaf<Action>()
            .leaf<Action>()
        .end()
        .build();
    tree->update();
}

int main()
{
    CreatingBehaviorTreeManually();
    CreatingBehaviorTreeUsingBuilders();
    return 0;
}

Composites

Composite	Behaviour	Success	Running	Failure
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
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
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
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

Decorators

Decorator	Behaviour
Succeeder	Always returns success
Failer	Always returns failure
Inverter	Inverts the result of the child node
Repeater	Repeats until child node succeeds (infinitely or limited)
UntilSuccess	Repeats until child node succeeds
UntilFailure	Repeats until child node fails

Builder

The Builder class simplifies the process of creating a behavior tree. You use three methods to build your tree:

• leaf<NodeType>()
• composite<CompositeType>()
• decorator<DecoratorType>()

Both 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.

auto tree = Builder()
    .decorator<Repeater>()
        .composite<Sequence>()
            .leaf<SayHello>("Foo")
            .leaf<SayHello>("Bar")
        .end()
    .end()
    .build();

License

MIT (c) Pär Arvidsson 2015-2018

braintree's Issues

Improve use of smart pointers

Don't use shared_ptr everywhere

add Ptr type alias for most classes

c++98 version

Hello, is there an c++98 version port of the library ?

BehaviorTreeFactory

create behavior trees from json or xml

Hungry for a more complete and runnable example

Thanks for your nice work。I am new to behavior tree and I am learning it, could you please provide a more complete and runnable example? I failed to build the curent one. And I can't get what below codes mean.
auto targetNearestEnemyNode = std::make_shared<TargetNearestEnemyNode>(blackboard);

Does this mean that I should write a class named TargetNearestEnemyNode like the WaitNode in the current example?

Improve composites

Use asserts and improve the code for running the children.

Change namespace from bt to BrainTree

But let's keep an alias bt as a shorthand.

header only

Make it a header only library

add helper MakeX functions for some classes

Rename project to BrainTree

Succeeder and Failer nodes not managing RUNNING cases

Hello !
Concerning the Succeeder and Failer nodes: When reading forcefailure, forcesuccess documentation https://www.behaviortree.dev/docs/nodes-library/DecoratorNode I think you've missed checking and returning the RUNNING state.

Make repeating decorators repeat per frame/call instead of using while(1)

Add a more advanced example

Use Builder pattern to construct behavior tree and initialize nodes with references

More advanced blackboard

Make blackboard use a Type class that encapsulates whatever we need and which can also be extended by anyone.

BehaviorTree constructor that can be passed a blackboard useful for sharing state between trees

Missing forwarding for constructor args

In areas like:

template <class NodeType, typename... Args>
SomeBuilder<Parent> leaf(Args... args)
{
    auto child = std::make_shared<NodeType>((args)...);
    node->setChild(child);
    return *this;
}

there needs to be forwarding to avoid unintended copying:

template <class NodeType, typename... Args>
SomeBuilder<Parent> leaf(Args&&... args)
{
    auto child = std::make_shared<NodeType>(std::forward<Args>(args)...);
    node->setChild(child);
    return *this;
}

GodotBrainTree

Not an issue, but I wanted to say thanks for this lib and that I am using it to create an addon for Godot : https://github.com/kakoeimon/GodotBrainTree

Make library single header

Make it a proper single-header, so we only need to include BrainTree.hpp. Alternative is to keep the composites and decorators that exist in their own respective headers, eg Composites.hpp and Decorators.hpp, but as they are pretty essential maybe just keep them in the single headerfile.

Improve implementation from lessons learned

Document API using eg DocumentUp

The README suggests shared_ptr handling, but classes work with raw pointers.

The README suggests shared_ptr of Nodes can be added as children to composite; but composite only takes Node*.