fsm.hpp

#pragma once
 
#include <memory>
#include <vector>
 
#include <type_traits>
#include <concepts>
 
namespace aitoolkit::fsm {
  template <typename T>
  class state {
    public:
      virtual ~state() = default;
 
      virtual void enter(T& blackboard) {};
      virtual void exit(T& blackboard) {};
 
      virtual void pause(T& blackboard) {};
      virtual void resume(T& blackboard) {};
 
      virtual void update(T& blackboard) {};
  };
 
  template <typename T>
  using state_ptr = std::unique_ptr<state<T>>;
 
  template <typename S, typename T>
  concept state_trait = std::derived_from<S, state<T>>;
 
  template <typename T>
  class simple_machine {
    public:
      template <state_trait<T> S>
      void set_state(S state, T& blackboard) {
        if (m_current_state) {
          m_current_state->exit(blackboard);
        }
 
        m_current_state = std::make_unique<S>(state);
        m_current_state->enter(blackboard);
 
        if (m_paused) {
          m_current_state->pause(blackboard);
        }
      }
 
      void clear_state(T& blackboard) {
        if (m_current_state) {
          m_current_state->exit(blackboard);
          m_current_state = nullptr;
        }
      }
 
      void pause(T& blackboard) {
        m_paused = true;
 
        if (m_current_state) {
          m_current_state->pause(blackboard);
        }
      }
 
      void resume(T& blackboard) {
        m_paused = false;
 
        if (m_current_state) {
          m_current_state->resume(blackboard);
        }
      }
 
      void update(T& blackboard) {
        if (m_paused) {
          return;
        }
 
        if (m_current_state) {
          m_current_state->update(blackboard);
        }
      }
 
    private:
      state_ptr<T> m_current_state{nullptr};
      bool m_paused{false};
  };
 
  template <typename T>
  class stack_machine {
    public:
      template <state_trait<T> S>
      void push_state(S state, T& blackboard) {
        if (!m_state_stack.empty()) {
          auto& current_state = m_state_stack.back();
          current_state->pause(blackboard);
        }
 
        state.enter(blackboard);
        m_state_stack.push_back(std::make_unique<S>(state));
      }
 
      void pop_state(T& blackboard) {
        if (!m_state_stack.empty()) {
          auto& current_state = m_state_stack.back();
          current_state->exit(blackboard);
          m_state_stack.pop_back();
        }
 
        if (!m_state_stack.empty()) {
          auto& current_state = m_state_stack.back();
          current_state->resume(blackboard);
        }
      }
 
      void update(T& blackboard) {
        if (!m_state_stack.empty()) {
          auto& current_state = m_state_stack.back();
          current_state->update(blackboard);
        }
      }
 
    private:
      std::vector<state_ptr<T>> m_state_stack;
  };
}