StateSystem/StateMachine.hpp

Go to the documentation of this file.

#pragma once
#include "EntityState.hpp"
#include "WorldSystem/Entity.hpp"
 
namespace Cori {
    namespace World {
        namespace Systems {
            class StateMachine;
        }
 
        namespace Components {
            namespace Entity {
                class StateMachine {
                public:
                    StateMachine() = default;
 
                    ~StateMachine() {
                        if (m_CurrentState) {
                            m_CurrentState->OnExit(m_Owner, typeid(nullptr));
                        }
                    }
 
                    StateMachine(const StateMachine&) = delete;
                    StateMachine& operator=(const StateMachine&) = delete;
                    StateMachine(StateMachine&&) = delete;
                    StateMachine& operator=(StateMachine&&) = delete;

                    template<std::derived_from<EntityState> StateType, typename... Args>
                    void Register(Args&&... args) {
                        const std::type_index stateID(typeid(StateType));
 
                        if (m_States.contains(stateID)) {
                            CORI_CORE_WARN_TAGGED({ Logger::Tags::World::Self, Logger::Tags::World::Entity::Self, Logger::Tags::World::Entity::StateMachine }, "StateMachine for Entity - {}: State type '{}' already registered.", m_Owner.GetDebugData(), CORI_CLEAN_TYPE_NAME(*m_CurrentState));
                            return;
                        }
 
                        m_States[stateID] = std::make_unique<StateType>(std::forward<Args>(args)...);
                        CORI_CORE_TRACE_TAGGED({ Logger::Tags::World::Self, Logger::Tags::World::Entity::Self, Logger::Tags::World::Entity::StateMachine }, "StateMachine for Entity - {}: Registered state '{}'", m_Owner.GetDebugData(), CORI_CLEAN_TYPE_NAME(StateType));
                    }

                    template<std::derived_from<EntityState> StateType>
                    void SetState() {
                        const std::type_index nextStateID(typeid(StateType));
 
                        if (CORI_CORE_CHECK(m_States.contains(nextStateID), "StateMachine for Entity - {}: Attempted to change to unregistered state type '{}', register the State first!", m_Owner.GetDebugData(), CORI_CLEAN_TYPE_NAME(StateType))) { return; }
 
                        EntityState* nextStateRawPtr = m_States.at(nextStateID).get();
 
                        if (m_CurrentState == nextStateRawPtr) {
                            return;
                        }
 
                        if (m_CurrentState) {
                            CORI_CORE_TRACE_TAGGED({ Logger::Tags::World::Self, Logger::Tags::World::Entity::Self, Logger::Tags::World::Entity::StateMachine }, "StateMachine for Entity - {}: Exiting state '{}'", m_Owner.GetDebugData(), CORI_CLEAN_TYPE_NAME(*m_CurrentState));
                            m_CurrentState->OnExit(m_Owner, typeid(*nextStateRawPtr));
                        }
 
                        if (m_LastState) {
                            m_LastState = m_CurrentState;
                        } else {
                            m_LastState = nextStateRawPtr;
                        }
 
                        m_CurrentState = nextStateRawPtr;
                        CORI_CORE_TRACE_TAGGED({ Logger::Tags::World::Self, Logger::Tags::World::Entity::Self, Logger::Tags::World::Entity::StateMachine }, "StateMachine for Entity - {}: Entering state '{}'", m_Owner.GetDebugData(), CORI_CLEAN_TYPE_NAME(*m_CurrentState));
                        m_CurrentState->OnEnter(m_Owner, typeid(*m_LastState));
                    }
 
                    void OnTickUpdate(const float timeStep) {
                        if (m_CurrentState) {
                            m_CurrentState->OnTickUpdate(m_Owner, timeStep);
                        }
                    }

                    template<std::derived_from<EntityState> StateType>
                    bool IsInState() const {
                        if (!m_CurrentState) {
                            return false;
                        }
 
                        return typeid(StateType) == typeid(*m_CurrentState);
                    }

                    template<std::derived_from<EntityState> StateType>
                    void SetStateIfNotInState() {
                        if (!IsInState<StateType>()) {
                            return SetState<StateType>();
                        }
                    }

                    EntityState* GetCurrentState() const {
                        CORI_CORE_ASSERT(m_CurrentState, "Trying to retrieve current state, but current state is null. Always make sure you set some initial state before using fsm.")
                        return m_CurrentState;
                    }

                    EntityState* GetLastState() const {
                        CORI_CORE_ASSERT(m_LastState, "Trying to retrieve last state, but last state is null. Always make sure you set some initial state before using fsm.")
                        return m_LastState;
                    }
 
                private:
                    friend Systems::StateMachine;
                    World::Entity m_Owner;
                    EntityState* m_CurrentState{ nullptr };
                    EntityState* m_LastState{ nullptr };
 
                    std::unordered_map<std::type_index, std::unique_ptr<EntityState>> m_States;
                };
            }
        }
    }
}