How should a reactive sequence work when a coroutine node is one of its children?

[IgorAlvesSilva]

I was testing having a tree composed of a reactive sequence with two children: an AlwaysSuccess first and then a coroutine that returns running until a certain codition is met. Instead of executing the AlwaysSuccess node again each time the tree is ticked only the coroutine node is executed. That's the same behavior of having the same tree but with a sequence control node instead of the reactive sequence.

[hlzl]

Reactive Sequences only tick conditions again if one of their asnyc or coroutine nodes returns running. As AlwaysSuccess is an action, it's not getting ticked. Have a look at this example from the wiki.

As this issue is also quite old, I vote to close it. @facontidavide

[facontidavide]

I noticed (thank to both of you) that the documentation was obsolete (fixed).

@hlzl I think your comment is not accurate. There should be no difference between a Condition child or an Action Child.

@IgorAlvesSilva what you described is not supposed to happen. Can you give me a way to reproduce this issue?

[glegarda]

Hi, I have run into this same issue. I wrote a custom node that inherits from CoroActionNode. It writes an int to a port; however, if the int is zero, it calls setStatusRunningAndYield(). I expected that calling this node twice in a ReactiveSequence, where the first node would write 1 to the port and the second one 0 would result in the first one returning success and the second one returning running every tick. Instead, what I get is that, every other tick, the second node is set to success directly (and therefore the sequence returns success).

I am attaching the sample files where I am getting this error: in my_nodes.h, I define the custom node; in my_test.cpp, I define implement the BT. Let me know if this helps.

my_nodes.h:

#ifndef MY_NODES_H
#define MY_NODES_H

#include <behaviortree_cpp_v3/bt_factory.h>

using namespace BT;

class MyAction : public CoroActionNode
{
	public:
		MyAction(const std::string& name, const NodeConfiguration& config)
			: CoroActionNode(name, config) {}

		static PortsList providedPorts()
		{
			PortsList pl;
			pl.insert(OutputPort<int>("arg0")); // entry
			pl.insert(InputPort<int>("arg1"));  // scalar
			return pl;
		}

	private:
		NodeStatus tick() override
		{
			Optional<int> s = getInput<int>("arg1");
			if (!s)
			{
				throw RuntimeError("missing required input [arg1]: ", s.error());
			}

			if (s.value() == 0)
			{
				setStatusRunningAndYield();
			}
			else
			{
				setOutput("arg0", s.value());
			}

			return NodeStatus::SUCCESS;
		}

		void halt() override
		{
			CoroActionNode::halt();
		}
};

#endif

my_test.cpp

#include <iostream>
#include <behaviortree_cpp_v3/loggers/bt_cout_logger.h>
#include "my_nodes.h"

static const char* xml_text = R"(
<root main_tree_to_execute="MainTree">
	<BehaviorTree ID="MainTree">
		<ReactiveSequence>
			<MyAction name="Action_1" arg0="{entry}" arg1="1"/>
			<MyAction name="Action_2" arg0="{entry}" arg1="0"/>
		</ReactiveSequence>
	</BehaviorTree>
</root>

)";

int main() 
{
	NodeBuilder builder_my_action =
		[](const std::string& name, const NodeConfiguration& config)
	{
		return std::make_unique<MyAction>(name, config);
	};

	// Register custom node
	BT::BehaviorTreeFactory factory;
	factory.registerBuilder<MyAction>("MyAction", builder_my_action);

	BT::Tree tree = factory.createTreeFromText(xml_text);

	// Initialise blackboard entries
	tree.rootBlackboard()->set("entry", 0);

	// Logger
	StdCoutLogger logger_cout(tree);

	// Tick tree
	for (int i = 0; i < 3; ++i)
	{
		std::cout << "Tick " << i << std::endl;
		tree.tickRoot();
	}

	return 0;
}

[facontidavide]

A ReactiveSequence can have only one single child (the last, usually) in RUNNING mode.
What you are trying to do should just be a regular Sequence