src/Core/StateManager.cpp


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

#include "StateManager.h"
#include "Log.h"

namespace Donut
{
    void StateManager::Shutdown()
    {
        if (m_CurrentState)
            m_CurrentState->OnExit();
            
        DestroyStates();
        DONUT_INFO("StateManager shutdown");
    }

    void StateManager::DestroyStates()
    {
        m_States.clear();
        m_CurrentState = nullptr;
        m_CurrentStateName = "";
    }

    void StateManager::RegisterState(const std::string& stateName, Scope<State> state)
    {
        if (m_States.find(stateName) != m_States.end())
            DONUT_WARN("State '{}' already exists, overwriting", stateName);
        m_States[stateName] = std::move(state);
        DONUT_INFO("Registered state: {}", stateName);
    }

    void StateManager::SwitchToState(const std::string& stateName)
    {
        auto it = m_States.find(stateName);
        if (it == m_States.end())
        {
            DONUT_ERROR("Attempted to switch to unknown state: {}", stateName);
            return;
        }

        State* newState = it->second.get();
        if (newState == m_CurrentState)
            return;

        if (m_CurrentState)
            m_CurrentState->OnExit();

        m_CurrentState = newState;
        m_CurrentStateName = stateName;
        m_CurrentState->OnEnter();
        DONUT_INFO("Switched to state: {}", stateName);
    }

    State* StateManager::GetState(const std::string& stateName)
    {
        auto it = m_States.find(stateName);
        if (it != m_States.end())
            return it->second.get();
        return nullptr;
    }

    bool StateManager::HasState(const std::string& stateName) const
    {
        return m_States.find(stateName) != m_States.end();
    }

    void StateManager::Update(float deltaTime)
    {
        if (m_CurrentState)
            m_CurrentState->OnUpdate(deltaTime);
    }

    void StateManager::Render()
    {
        if (m_CurrentState)
            m_CurrentState->OnRender();
    }

    void StateManager::OnEvent(Event& event)
    {
        if (m_CurrentState)
            m_CurrentState->OnEvent(event);
    }
}