ReactiveSequence and ReactiveFallback will behave more similarly to 3.8

Author: facontidavide

include/behaviortree_cpp/controls/reactive_fallback.h

@@ -36,8 +36,19 @@ class ReactiveFallback : public ControlNode
   ReactiveFallback(const std::string& name) : ControlNode(name, {})
   {}
 
+  /** A ReactiveFallback is not supposed to have more than a single
+  * anychronous node; if it does an exception is thrown.
+  * You can disabled that check, if you know what you are doing.
+  */
+  static void EnableException(bool enable);
+
 private:
-  virtual BT::NodeStatus tick() override;
+  BT::NodeStatus tick() override;
+
+  void halt() override;
+
+  int running_child_ = -1;
+  static bool throw_if_multiple_running;
 };
 
 }   // namespace BT

include/behaviortree_cpp/controls/reactive_sequence.h

@@ -36,10 +36,16 @@ class ReactiveSequence : public ControlNode
   ReactiveSequence(const std::string& name) : ControlNode(name, {})
   {}
 
+  /** A ReactiveSequence is not supposed to have more than a single
+  * anychronous node; if it does an exception is thrown.
+  * You can disabled that check, if you know what you are doing.
+  */
   static void EnableException(bool enable);
 
 private:
-  virtual BT::NodeStatus tick() override;
+  BT::NodeStatus tick() override;
+
+  void halt() override;
 
   int running_child_ = -1;
 

src/controls/reactive_fallback.cpp

@@ -14,11 +14,21 @@
 
 namespace BT
 {
-NodeStatus ReactiveFallback::tick()
+
+bool ReactiveFallback::throw_if_multiple_running = true;
+
+void ReactiveFallback::EnableException(bool enable)
 {
-  size_t failure_count = 0;
+  ReactiveFallback::throw_if_multiple_running = enable;
+}
 
+NodeStatus ReactiveFallback::tick()
+{
   bool all_skipped = true;
+  if(status() == NodeStatus::IDLE)
+  {
+    running_child_ = -1;
+  }
   setStatus(NodeStatus::RUNNING);
 
   for (size_t index = 0; index < childrenCount(); index++)
@@ -32,19 +42,28 @@ NodeStatus ReactiveFallback::tick()
     switch (child_status)
     {
       case NodeStatus::RUNNING: {
-        // reset the previous children, to make sure that they are in IDLE state
-        // the next time we tick them
-        for (size_t i = 0; i < index; i++)
+        // reset the previous children, to make sure that they are
+        // in IDLE state the next time we tick them
+        for (size_t i = 0; i < childrenCount(); i++)
+        {
+          if(i != index)
+          {
+            haltChild(i);
+          }
+        }
+        if(running_child_ == -1)
+        {
+          running_child_ = int(index);
+        }
+        else if(throw_if_multiple_running && running_child_ != int(index))
         {
-          haltChild(i);
+          throw LogicError("[ReactiveFallback]: only a single child can return RUNNING.\n"
+                           "This throw can be disabled with ReactiveFallback::EnableException(false)");
         }
         return NodeStatus::RUNNING;
       }
 
-      case NodeStatus::FAILURE: {
-        failure_count++;
-      }
-      break;
+      case NodeStatus::FAILURE: break;
 
       case NodeStatus::SUCCESS: {
         resetChildren();
@@ -69,4 +88,10 @@ NodeStatus ReactiveFallback::tick()
   return all_skipped ? NodeStatus::SKIPPED : NodeStatus::FAILURE;
 }
 
+void ReactiveFallback::halt()
+{
+  running_child_ = -1;
+  ControlNode::halt();
+}
+
 }   // namespace BT

src/controls/reactive_sequence.cpp

@@ -25,6 +25,10 @@ void ReactiveSequence::EnableException(bool enable)
 NodeStatus ReactiveSequence::tick()
 {
   bool all_skipped = true;
+  if(status() == NodeStatus::IDLE)
+  {
+    running_child_ = -1;
+  }
   setStatus(NodeStatus::RUNNING);
 
   for (size_t index = 0; index < childrenCount(); index++)
@@ -38,19 +42,23 @@ NodeStatus ReactiveSequence::tick()
     switch (child_status)
     {
       case NodeStatus::RUNNING: {
-        // reset the previous children, to make sure that they are in IDLE state
-        // the next time we tick them
-        for (size_t i = 0; i < index; i++)
+        // reset the previous children, to make sure that they are
+        // in IDLE state the next time we tick them
+        for (size_t i = 0; i < childrenCount(); i++)
         {
-          haltChild(i);
+          if(i != index)
+          {
+            haltChild(i);
+          }
         }
         if(running_child_ == -1)
         {
           running_child_ = int(index);
         }
         else if(throw_if_multiple_running && running_child_ != int(index))
         {
-          throw LogicError("[ReactiveSequence]: only a single child can return RUNNING");
+          throw LogicError("[ReactiveSequence]: only a single child can return RUNNING.\n"
+                           "This throw can be disabled with ReactiveSequence::EnableException(false)");
         }
         return NodeStatus::RUNNING;
       }
@@ -80,4 +88,10 @@ NodeStatus ReactiveSequence::tick()
   return all_skipped ? NodeStatus::SKIPPED : NodeStatus::SUCCESS;
 }
 
+void ReactiveSequence::halt()
+{
+  running_child_ = -1;
+  ControlNode::halt();
+}
+
 }   // namespace BT