simplified policy of nodes with memory

Author: Davide Faconti

include/behavior_tree_core/basic_types.h

@@ -48,12 +48,7 @@ enum FailurePolicy
     FAIL_ON_ONE,
     FAIL_ON_ALL
 };
-enum ResetPolicy
-{
-    ON_SUCCESS_OR_FAILURE,
-    ON_SUCCESS,
-    ON_FAILURE
-};
+
 
 // Enumerates the options for when a parallel node is considered to have succeeded:
 // - "SUCCEED_ON_ONE" indicates that the node will return success as soon as one
@@ -85,13 +80,6 @@ const char* toStr(const BT::NodeType& type);
 
 std::ostream& operator<<(std::ostream& os, const BT::NodeType& type);
 
-/**
- * @brief toStr converts ResetPolicy to string.
- */
-const char* toStr(const BT::ResetPolicy& policy);
-
-std::ostream& operator<<(std::ostream& os, const BT::ResetPolicy& type);
-
 // small utility, unless you want to use <boost/algorithm/string.hpp>
 std::vector<std::string> splitString(const std::string& strToSplit, char delimeter);
 

include/behavior_tree_core/controls/fallback_node.h

@@ -20,20 +20,17 @@ namespace BT
 {
 
 /**
- * @brief The FallbackNode is used when you want to evaluate different "strategies".
+ * @brief The FallbackNode is used to try different strategies,
+ * until one succeed.
+ * If any child returns RUNNING, previous children will be ticked again.
  *
- * This control node ticks its children UNTIL one of them returns SUCCESS.
+ * - If all the children return FAILURE, this node returns FAILURE.
  *
- * In that case it return SUCCESS, otherwise it return FAILURE.
- * If it finds a child returning RUNNING, it returns RUNNING and it restarts from the first child.
+ * - If a child returns RUNNING, this node returns RUNNING.
+ *   The loop is restarted, but already completed children are not halted.
+ *   This generally implies that ConditionNode are ticked again.
  *
- * If you don't want to restart from the first child, use FallbackNodeWithMemory instead.
- *
- * Example: three children, A, B and C
- *
- * 1) A returns FAILURE. Continue.
- * 2) B returns RUNNING, Restart from A
- * 3) A returns FAILURE again but B return SUCCESS. Stop and return SUCCESS.
+ * - If a child returns SUCCESS, stop the loop and returns SUCCESS.
  *
  */
 class FallbackNode : public ControlNode

include/behavior_tree_core/controls/fallback_node_with_memory.h

@@ -20,46 +20,28 @@ namespace BT
 {
 
 /**
- * @brief The FallbackNodeWithMemory is used when you want to evaluate different "strategies".
+ * @brief The FallbackNodeWithMemory is used to try different strategies,
+ * until one succeed.
+ * If any child returns RUNNING, previous children will NOT be ticked again.
  *
- * This control node ticks its children UNTIL one of them returns SUCCESS.
+ * - If all the children return FAILURE, this node returns FAILURE.
  *
- * In that case it returns SUCCESS, otherwise it returns FAILURE.
- * If a child return RUNNING, this node returns RUNNING and at the next tick it will continue
- * from the same index.
- * It is recommended for asynchronous children which may return RUNNING.
- *
- * Example: three children, A, B and C
- *
- * 1) A returns FAILURE. Continue.
- * 2) B returns RUNNING. Stop and return RUNNING.
- * 3) B is ticked again but it returns SUCCESS. Stop and return SUCCESS.
+ * - If a child returns RUNNING, this node returns RUNNING.
+ *   Loop is NOT restarted, the same running child will be ticked again.
  *
+ * - If a child returns SUCCESS, stop the loop and returns SUCCESS.
  */
 
 class FallbackNodeWithMemory : public ControlNode
 {
   public:
-    FallbackNodeWithMemory(const std::string& name, ResetPolicy reset_policy = BT::ON_SUCCESS_OR_FAILURE);
-
-    // Reset policy passed by parameter [reset_policy]
-    FallbackNodeWithMemory(const std::string&, const NodeParameters& params);
-
-    virtual ~FallbackNodeWithMemory() override = default;
+    FallbackNodeWithMemory(const std::string& name);
 
     virtual void halt() override;
 
-    static const NodeParameters& requiredNodeParameters()
-    {
-        static NodeParameters params = {{RESET_POLICY, toStr(BT::ON_SUCCESS_OR_FAILURE)}};
-        return params;
-    }
-
   private:
     unsigned int current_child_idx_;
-    ResetPolicy reset_policy_;
 
-    constexpr static const char* RESET_POLICY = "reset_policy";
     virtual BT::NodeStatus tick() override;
 };
 }

include/behavior_tree_core/controls/sequence_node.h

@@ -19,22 +19,17 @@
 namespace BT
 {
 /**
- * @brief The SequenceNode is used to execute a sequence of synchronous children.
+ * @brief The SequenceNode is used to execute a sequence of children.
+ * If any child returns RUNNING, previous children will be ticked again.
  *
- * This control node ticks its children AS LONG AS they returns SUCCESS.
+ * - If all the children return SUCCESS, this node returns SUCCESS.
  *
- * If all the children return SUCCESS, the sequence is SUCCESS.
- * If any return FAILURE, the sequence returns FAILURE and it starts from the beginning.
- * If a child returns RUNNING, this node returns RUNNING and at the next tick it will continue
- * from the same index.
- * It is recommended for asynchronous children which may return RUNNING.
+ * - If a child returns RUNNING, this node returns RUNNING.
+ *   The loop is restarted, but already completed children are not halted.
+ *   This generally implies that ConditionNode are ticked again.
  *
- * Example: three children, A , B and C
+ * - If a child returns FAILURE, stop the loop and returns FAILURE.
  *
- * 1) A returns SUCCESS. Continue.
- * 2) B returns RUNNING. Stop and return RUNNING.
- * 3) A is ticked again and return SUCCESS. B is ticked and retuns SUCCESS. Continue.
- * 4) C returns SUCCESS. The entire sequence returns SUCCESS.
  */
 class SequenceNode : public ControlNode
 {

include/behavior_tree_core/controls/sequence_node_with_memory.h

@@ -20,24 +20,23 @@ namespace BT
 {
 
 /**
- * @brief The SequenceNode is used to execute a sequence of asynchronous children.
+ * @brief The SequenceNodeWithMemory is used to execute a sequence of children.
+ * If any child returns RUNNING, previous children are not ticked again.
  *
- * Tick all the children as long as they return SUCCESS.
- * If any child return FAILURE, stop the sequence and return FAILURE.
- * If any child return RUNNING, stop the sequence, return RUNNING. Restart from the same child
+ * - If all the children return SUCCESS, this node returns SUCCESS.
  *
- * Example: three children, A , B and C
+ * - If a child returns RUNNING, this node returns RUNNING.
+ *   Loop is NOT restarted, the same running child will be ticked again.
+ *
+ * - If a child returns FAILURE, stop the loop and returns FAILURE.
+ *   Restart the loop only if (reset_on_failure == true)
  *
- * 1) A returns SUCCESS. Continue.
- * 2) B returns RUNNING. Stop and return RUNNING.
- * 3) B is ticked and retuns SUCCESS. Continue.
- * 4) C returns SUCCESS. The entire sequence returns SUCCESS.
  */
 
 class SequenceNodeWithMemory : public ControlNode
 {
   public:
-    SequenceNodeWithMemory(const std::string& name, ResetPolicy reset_policy = BT::ON_SUCCESS_OR_FAILURE);
+    SequenceNodeWithMemory(const std::string& name, bool reset_on_failure = true);
 
     // Reset policy passed by parameter [reset_policy]
     SequenceNodeWithMemory(const std::string& name, const NodeParameters& params);
@@ -48,15 +47,14 @@ class SequenceNodeWithMemory : public ControlNode
 
     static const NodeParameters& requiredNodeParameters()
     {
-        static NodeParameters params = {{RESET_POLICY, toStr(BT::ON_SUCCESS_OR_FAILURE)}};
+        static NodeParameters params = {{"reset_on_failure", "true"}};
         return params;
     }
 
   private:
     unsigned int current_child_idx_;
-    ResetPolicy reset_policy_;
+    bool reset_on_failure_;
 
-    static constexpr const char* RESET_POLICY = "reset_policy";
     virtual BT::NodeStatus tick() override;
 };
 }

src/basic_types.cpp

@@ -63,21 +63,6 @@ const char* toStr(const NodeType& type)
     }
 }
 
-const char* toStr(const ResetPolicy& policy)
-{
-    switch (policy)
-    {
-        case ResetPolicy::ON_FAILURE:
-            return "ON_FAILURE";
-        case ResetPolicy::ON_SUCCESS:
-            return "ON_SUCCESS";
-        case ResetPolicy::ON_SUCCESS_OR_FAILURE:
-            return "ON_SUCCESS_OR_FAILURE";
-        default:
-            return "Undefined";
-    }
-}
-
 template <>
 std::string convertFromString<std::string>(const std::string& str)
 {
@@ -110,45 +95,73 @@ double convertFromString<double>(const std::string& str)
 }
 
 template <>
-NodeStatus convertFromString<NodeStatus>(const std::string& str)
+bool convertFromString<bool>(const std::string& str)
 {
-    for (auto status : {NodeStatus::IDLE, NodeStatus::RUNNING, NodeStatus::SUCCESS, NodeStatus::FAILURE})
+    if( str.size() == 1)
     {
-        if (std::strcmp(toStr(status), str.c_str()) == 0)
+        if ( str[0] == '0'){
+            return false;
+        }
+        else if( str[0] == '1'){
+            return true;
+        }
+        else{
+            std::runtime_error("invalid bool conversion");
+        }
+    }
+    else if( str.size() == 4)
+    {
+        if( str == "true" || str == "TRUE" || str == "True")
         {
-            return status;
+            return true;
+        }
+        else{
+            std::runtime_error("invalid bool conversion");
         }
     }
-    throw std::invalid_argument(std::string("Cannot convert this to NodeStatus: ") + str);
+    else if( str.size() == 5)
+    {
+        if( str == "false" || str == "FALSE" || str == "False")
+        {
+            return false;
+        }
+        else{
+            std::runtime_error("invalid bool conversion");
+        }
+    }
+
+    std::runtime_error("invalid bool conversion");
+    return false;
 }
 
 template <>
-NodeType convertFromString<NodeType>(const std::string& str)
+NodeStatus convertFromString<NodeStatus>(const std::string& str)
 {
-    for (auto status : {NodeType::ACTION, NodeType::CONDITION, NodeType::CONTROL, NodeType::DECORATOR,
-                        NodeType::SUBTREE, NodeType::UNDEFINED})
+    for (auto status : {NodeStatus::IDLE, NodeStatus::RUNNING, NodeStatus::SUCCESS, NodeStatus::FAILURE})
     {
         if (std::strcmp(toStr(status), str.c_str()) == 0)
         {
             return status;
         }
     }
-    throw std::invalid_argument(std::string("Cannot convert this to NodeType: ") + str);
+    throw std::invalid_argument(std::string("Cannot convert this to NodeStatus: ") + str);
 }
 
 template <>
-ResetPolicy convertFromString<ResetPolicy>(const std::string& str)
+NodeType convertFromString<NodeType>(const std::string& str)
 {
-    for (auto status : {ResetPolicy::ON_SUCCESS, ResetPolicy::ON_SUCCESS_OR_FAILURE, ResetPolicy::ON_FAILURE})
+    for (auto status : {NodeType::ACTION, NodeType::CONDITION, NodeType::CONTROL, NodeType::DECORATOR,
+                        NodeType::SUBTREE, NodeType::UNDEFINED})
     {
         if (std::strcmp(toStr(status), str.c_str()) == 0)
         {
             return status;
         }
     }
-    throw std::invalid_argument(std::string("Cannot convert this to ResetPolicy: ") + str);
+    throw std::invalid_argument(std::string("Cannot convert this to NodeType: ") + str);
 }
 
+
 std::ostream &operator<<(std::ostream &os, const NodeType &type)
 {
     os << toStr(type);
@@ -161,11 +174,6 @@ std::ostream &operator<<(std::ostream &os, const NodeStatus &status)
     return os;
 }
 
-std::ostream &operator<<(std::ostream &os, const ResetPolicy &type)
-{
-    os << toStr(type);
-    return os;
-}
 
 std::vector<std::string> splitString(const std::string &strToSplit, char delimeter)
 {