behtree.hpp

#pragma once
 
#include <functional>
#include <memory>
#include <vector>
 
#include <type_traits>
#include <concepts>
 
namespace aitoolkit::bt {
  enum class execution_state {
    success, 
    failure, 
    running  
  };
 
  template <class T>
  class node {
    public:
      node() = default;
      node(const node&) = delete;
      node(node&& other) {
        m_children = std::move(other.m_children);
      }
 
      virtual ~node() = default;
 
      virtual execution_state evaluate(T& blackboard) const = 0;
 
    protected:
      std::vector<std::unique_ptr<node<T>>> m_children;
  };
 
  template <class T>
  using node_ptr = std::unique_ptr<node<T>>;
 
  template <typename N, class T>
  concept node_trait = std::derived_from<N, node<T>>;
 
  template <typename T, node_trait<T> ...Children>
  std::vector<node_ptr<T>> node_list(Children&&... children) {
    auto nodes = std::vector<node_ptr<T>>{};
    nodes.reserve(sizeof...(children));
    (nodes.push_back(std::make_unique<Children>(std::move(children))), ...);
    return nodes;
  }
 
  template <class T>
  class seq final : public node<T> {
    public:
      seq(std::vector<node_ptr<T>> children) {
        this->m_children = std::move(children);
      }
 
      virtual execution_state evaluate(T& blackboard) const override {
        for (auto& child : this->m_children) {
          auto state = child->evaluate(blackboard);
          if (state != execution_state::success) {
            return state;
          }
        }
 
        return execution_state::success;
      }
  };
 
  template <class T>
  class sel final : public node<T> {
    public:
      sel(std::vector<node_ptr<T>> children) {
        this->m_children = std::move(children);
      }
 
      virtual execution_state evaluate(T& blackboard) const override {
        for (auto& child : this->m_children) {
          auto state = child->evaluate(blackboard);
          if (state != execution_state::failure) {
            return state;
          }
        }
 
        return execution_state::failure;
      }
  };
 
  template <class T>
  class neg final : public node<T> {
    public:
      template <node_trait<T> N>
      neg(N&& child) {
        this->m_children.reserve(1);
        this->m_children.push_back(std::make_unique<N>(std::move(child)));
      }
 
      virtual execution_state evaluate(T& blackboard) const override {
        if (this->m_children.size() != 1) {
          return execution_state::failure;
        }
 
        auto& child = this->m_children.front();
        auto state = child->evaluate(blackboard);
        if (state == execution_state::success) {
          return execution_state::failure;
        } else if (state == execution_state::failure) {
          return execution_state::success;
        }
 
        return state;
      }
  };
 
  template <class T>
  class check final : public node<T> {
    public:
      using callback_type = std::function<bool(const T&)>;
 
    public:
      check(callback_type fn) : m_fn(fn) {}
 
      virtual execution_state evaluate(T& blackboard) const override {
        if (m_fn(blackboard)) {
          return execution_state::success;
        }
 
        return execution_state::failure;
      }
 
    private:
      callback_type m_fn;
  };
 
  template <class T>
  class task final : public node<T> {
    public:
      using callback_type = std::function<execution_state(T&)>;
 
    public:
      task(callback_type fn) : m_fn(fn) {}
 
      virtual execution_state evaluate(T& blackboard) const override {
        return m_fn(blackboard);
      }
 
    private:
      callback_type m_fn;
  };
}