utility.hpp

#pragma once
 
#include <memory>
#include <vector>
#include <limits>
 
#include <type_traits>
#include <concepts>
 
namespace aitoolkit::utility {
  template <typename T>
  class action {
    public:
      virtual ~action() = default;
 
      virtual float score(const T& blackboard) const = 0;
 
      virtual void apply(T& blackboard) const = 0;
  };
 
  template <typename T>
  using action_ptr = std::unique_ptr<action<T>>;
 
  template <typename A, typename T>
  concept action_trait = std::derived_from<A, action<T>>;
 
  template <typename T, action_trait<T> ...Actions>
  std::vector<action_ptr<T>> action_list(Actions&&... actions) {
    auto actions_list = std::vector<action_ptr<T>>{};
    actions_list.reserve(sizeof...(Actions));
    (actions_list.push_back(std::make_unique<Actions>(std::move(actions))), ...);
    return actions_list;
  }
 
  template <typename T>
  class evaluator {
    public:
      evaluator(std::vector<action_ptr<T>> actions) : m_actions(std::move(actions)) {}
 
      void run(T& blackboard) const {
        if (m_actions.empty()) {
          return;
        }
 
        auto best_score = std::numeric_limits<float>::min();
        auto best_action = m_actions.front().get();
 
        for (auto& action : m_actions) {
          auto score = action->score(blackboard);
          if (score > best_score) {
            best_score = score;
            best_action = action.get();
          }
        }
 
        best_action->apply(blackboard);
      }
 
    private:
      std::vector<action_ptr<T>> m_actions;
  };
}