♻️ separate plan and planner, plan is run one step at a time

Author: linkdd

README.md

@@ -299,8 +299,12 @@ auto goal = blackboard_type{
   .wood = 3
 };
 
-auto p = plan<blackboard_type>(actions, initial, goal);
-p.run(initial); // will mutate the blackboard
+auto p = planner<blackboard_type>(actions, initial, goal);
+
+auto blackboard = initial;
+while (p) {
+  p.run_next(initial); // will mutate the blackboard
+}
 ```
 
 For more informations, consult the

include/aitoolkit/goap.hpp

@@ -150,12 +150,18 @@ auto goal = blackboard_type{
   .stone = 1
 };
 
-auto p = plan<blackboard_type>(actions, initial, goal);
-p.run(initial); // will mutate the blackboard
+auto p = planner<blackboard_type>(actions, initial, goal);
+
+auto blackboard = initial;
+while (p) {
+  p.run_next(blackboard); // will mutate the blackboard
+}
 ```
 */
 
 #include <unordered_set>
+#include <functional>
+#include <coroutine>
 #include <memory>
 #include <vector>
 #include <queue>
@@ -216,96 +222,11 @@ namespace aitoolkit::goap {
    * @ingroup goap
    * @class plan
    * @brief A plan is a sequence of actions that will lead to a goal state.
-   *
-   * The plan is created by providing a list of actions, an initial blackboard
-   * state, and a goal blackboard state. The plan will then find a sequence of
-   * actions that will lead to the goal state.
-   *
-   * The plan can then be run on a blackboard to mutate it.
    */
   template <blackboard_trait T>
   class plan {
     public:
-      /**
-       * @brief Create a plan.
-       *
-       * @param actions The list of actions that can be performed.
-       * @param initital_blackboard The initial state of the blackboard.
-       * @param goal_blackboard The goal state of the blackboard.
-       * @param max_iterations The maximum number of iterations to perform
-       * before giving up. If 0, the plan will run until it finds a solution.
-       */
-      plan(
-        std::vector<action_ptr<T>> actions,
-        T initital_blackboard,
-        T goal_blackboard,
-        size_t max_iterations = 0
-      ) {
-        struct node_type {
-          T blackboard;
-          float cost;
-
-          action_ptr<T> action_taken;
-          std::shared_ptr<node_type> parent;
-        };
-
-        using node_ptr = std::shared_ptr<node_type>;
-
-        struct node_compare {
-          bool operator()(const node_ptr& a, const node_ptr& b) const {
-            return a->cost > b->cost;
-          }
-        };
-
-        std::priority_queue<node_ptr, std::vector<node_ptr>, node_compare> open_set;
-        std::unordered_set<T> closed_set;
-
-        open_set.push(std::make_shared<node_type>(node_type{
-          .blackboard = initital_blackboard,
-          .cost = 0.0f,
-          .action_taken = nullptr,
-          .parent = nullptr
-        }));
-
-        for (
-          size_t iteration = 0;
-          !open_set.empty() && (max_iterations == 0 || iteration < max_iterations);
-          ++iteration
-        ) {
-          auto current_node = open_set.top();
-          open_set.pop();
-
-          if (current_node->blackboard == goal_blackboard) {
-            while (current_node->parent != nullptr) {
-              m_actions.push(current_node->action_taken);
-              current_node = current_node->parent;
-            }
-
-            break;
-          }
-
-          if (!closed_set.contains(current_node->blackboard)) {
-            closed_set.insert(current_node->blackboard);
-
-            for (auto& action : actions) {
-              if (action->check_preconditions(current_node->blackboard)) {
-                auto next_blackboard = current_node->blackboard;
-                action->apply_effects(next_blackboard);
-                auto next_cost = current_node->cost + action->cost(current_node->blackboard);
-
-                if (!closed_set.contains(next_blackboard)) {
-                  open_set.push(std::make_shared<node_type>(node_type{
-                    .blackboard = next_blackboard,
-                    .cost = next_cost,
-                    .action_taken = action,
-                    .parent = current_node
-                  }));
-                }
-              }
-            }
-          }
-        }
-      }
+      plan(std::queue<action_ptr<T>> actions) : m_actions(actions) {}
 
       /**
        * @brief Get the number of actions in the plan.
@@ -322,20 +243,104 @@ namespace aitoolkit::goap {
       }
 
       /**
-       * @brief Run the plan on a blackboard.
+       * @brief Execute the next planned action.
        */
-      void run(T& blackboard) {
-        auto actions = m_actions;
-
-        while (!actions.empty()) {
-          auto action = actions.front();
-          actions.pop();
-
+      void run_next(T& blackboard) {
+        if (!m_actions.empty()) {
+          auto action = m_actions.front();
+          m_actions.pop();
           action->apply_effects(blackboard);
         }
       }
+  };
+
+  /**
+   * @ingroup goap
+   * @brief Create a plan.
+   *
+   * The plan is created by providing a list of actions, an initial blackboard
+   * state, and a goal blackboard state. The plan will then find a sequence of
+   * actions that will lead to the goal state.
+   *
+   * @param actions The list of actions that can be performed.
+   * @param initital_blackboard The initial state of the blackboard.
+   * @param goal_blackboard The goal state of the blackboard.
+   * @param max_iterations The maximum number of iterations to perform
+   * before giving up. If 0, the plan will run until it finds a solution.
+   * @return A plan that can be executed.
+   */
+  template <blackboard_trait T>
+  plan<T> planner(
+    std::vector<action_ptr<T>> actions,
+    T initital_blackboard,
+    T goal_blackboard,
+    size_t max_iterations = 0
+  ) {
+    struct node_type {
+      T blackboard;
+      float cost;
+
+      action_ptr<T> action_taken;
+      std::shared_ptr<node_type> parent;
+    };
+
+    using node_ptr = std::shared_ptr<node_type>;
+
+    struct node_compare {
+      bool operator()(const node_ptr& a, const node_ptr& b) const {
+        return a->cost > b->cost;
+      }
+    };
+
+    std::priority_queue<node_ptr, std::vector<node_ptr>, node_compare> open_set;
+    std::unordered_set<T> closed_set;
+
+    open_set.push(std::make_shared<node_type>(node_type{
+      .blackboard = initital_blackboard,
+      .cost = 0.0f,
+      .action_taken = nullptr,
+      .parent = nullptr
+    }));
+
+    for (
+      size_t iteration = 0;
+      !open_set.empty() && (max_iterations == 0 || iteration < max_iterations);
+      ++iteration
+    ) {
+      auto current_node = open_set.top();
+      open_set.pop();
+
+      if (current_node->blackboard == goal_blackboard) {
+        auto actions = std::queue<action_ptr<T>>{};
+
+        while (current_node->parent != nullptr) {
+          actions.push(current_node->action_taken);
+          current_node = current_node->parent;
+        }
+
+        return plan<T>(actions);
+      }
 
-    private:
-      std::queue<action_ptr<T>> m_actions;
+      if (!closed_set.contains(current_node->blackboard)) {
+        closed_set.insert(current_node->blackboard);
+
+        for (auto& action : actions) {
+          if (action->check_preconditions(current_node->blackboard)) {
+            auto next_blackboard = current_node->blackboard;
+            action->apply_effects(next_blackboard);
+            auto next_cost = current_node->cost + action->cost(current_node->blackboard);
+
+            if (!closed_set.contains(next_blackboard)) {
+              open_set.push(std::make_shared<node_type>(node_type{
+                .blackboard = next_blackboard,
+                .cost = next_cost,
+                .action_taken = action,
+                .parent = current_node
+              }));
+            }
+          }
+        }
+      }
+    }
   };
 }