Added cheat console (desktop only)

src/game-loop/CMakeLists.txt

@@ -9,6 +9,7 @@ add_library(GameLoop STATIC
         src/game-loop/GameLoopStartedState.cpp
         src/game-loop/GameLoopLevelSummaryState.cpp
         src/game-loop/GameLoopScoresState.cpp
+        src/game-loop/GameLoopSandboxState.cpp
 
         interface/game-loop/GameLoop.hpp
         interface/game-loop/GameLoopBaseState.hpp
@@ -17,6 +18,7 @@ add_library(GameLoop STATIC
         interface/game-loop/GameLoopStartedState.hpp
         interface/game-loop/GameLoopLevelSummaryState.hpp
         interface/game-loop/GameLoopScoresState.hpp
+        interface/game-loop/GameLoopSandboxState.hpp
 
         # Main dude:
 
@@ -339,6 +341,9 @@ add_library(GameLoop STATIC
         include/other/LootCollectedEvent.hpp
         include/other/NpcType.hpp
         include/other/ParticleGenerator.hpp
+        include/components/generic/ImguiComponent.hpp
+        include/prefabs/ui/CheatConsole.hpp
+        src/prefabs/ui/CheatConsole.cpp
 )
 
 target_include_directories(GameLoop
@@ -366,4 +371,5 @@ target_link_libraries(GameLoop
         Audio
         glad
         GraphicsUtils
+        imgui
 )

src/game-loop/include/components/generic/ImguiComponent.hpp

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <functional>
+
+struct ImguiComponent
+{
+    std::function<void()> render_callback;
+};

src/game-loop/include/prefabs/ui/CheatConsole.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "entt/entt.hpp"
+#include "viewport/Viewport.hpp"
+#include "game-loop/GameLoop.hpp"
+
+namespace prefabs
+{
+    class CheatConsoleComponent
+    {
+    public:
+        bool is_state_change_requested() const { return _state_change_requested; }
+        void request_state_change(GameLoop::State requested_state) { _requested_state = requested_state; _state_change_requested = true; }
+        GameLoop::State get_requested_state() const { return _requested_state;}
+    private:
+        bool _state_change_requested = false;
+        GameLoop::State _requested_state{GameLoop::State::CURRENT};
+    };
+
+    struct CheatConsole
+    {
+        static entt::entity create(const std::shared_ptr<Viewport>& viewport);
+    };
+}

src/game-loop/include/system/RenderingSystem.hpp

@@ -21,6 +21,8 @@ class RenderingSystem final : public System
 
 private:
 
+    void update_opengl(std::uint32_t delta_time_ms);
+    void update_imgui();
     void use_camera(CameraType camera_type);
     void use_model_view_camera();
     void use_screen_space_camera();

src/game-loop/interface/game-loop/GameLoop.hpp

@@ -13,6 +13,7 @@
 #include "game-loop/GameLoopPlayingState.hpp"
 #include "game-loop/GameLoopStartedState.hpp"
 #include "game-loop/GameLoopScoresState.hpp"
+#include "game-loop/GameLoopSandboxState.hpp"
 
 #include <entt/entt.hpp>
 
@@ -34,8 +35,21 @@ class ShoppingSystem;
 class GameLoop
 {
 public:
+    enum class State
+    {
+        MAIN_MENU = 0,
+        PLAYING,
+        STARTED,
+        LEVEL_SUMMARY,
+        SCORES,
+        SANDBOX,
+        CURRENT
+    };
+
     GameLoop(const std::shared_ptr<Viewport>&);
     std::function<bool(uint32_t delta_time_ms)>& get();
+    GameLoopBaseState* get_game_loop_state_ptr(State);
+
 private:
 
     friend class GameLoopBaseState;
@@ -44,6 +58,7 @@ class GameLoop
     friend class GameLoopStartedState;
     friend class GameLoopLevelSummaryState;
     friend class GameLoopScoresState;
+    friend class GameLoopSandboxState;
 
     struct
     {
@@ -52,6 +67,7 @@ class GameLoop
         GameLoopStartedState started;
         GameLoopLevelSummaryState level_summary;
         GameLoopScoresState scores;
+        GameLoopSandboxState sandbox;
         GameLoopBaseState* current;
     } _states;
 

src/game-loop/interface/game-loop/GameLoopMainMenuState.hpp

@@ -14,6 +14,7 @@ class GameLoopMainMenuState : public GameLoopBaseState
     void enter(GameLoop&) override;
     void exit(GameLoop&) override;
 private:
+    entt::entity _cheat_console = entt::null;
     entt::entity _main_dude = entt::null;
     entt::entity _pause_overlay = entt::null;
     entt::entity _death_overlay = entt::null;

src/game-loop/interface/game-loop/GameLoopPlayingState.hpp

@@ -32,4 +32,5 @@ class GameLoopPlayingState : public GameLoopBaseState, public Observer<MainDudeE
     entt::entity _hud = entt::null;
     entt::entity _pause_overlay = entt::null;
     entt::entity _death_overlay = entt::null;
+    entt::entity _cheat_console = entt::null;
 };

src/game-loop/interface/game-loop/GameLoopSandboxState.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <memory>
+#include <entt/entt.hpp>
+#include "game-loop/GameLoopBaseState.hpp"
+
+class GameLoop;
+class PauseOverlayComponent;
+class ScoresOverlayComponent;
+
+class GameLoopSandboxState : public GameLoopBaseState
+{
+public:
+    GameLoopBaseState* update(GameLoop&, uint32_t delta_time_ms) override;
+    void enter(GameLoop&) override;
+    void exit(GameLoop&) override;
+private:
+    entt::entity _main_dude = entt::null;
+    entt::entity _pause_overlay = entt::null;
+    entt::entity _death_overlay = entt::null;
+    entt::entity _cheat_console = entt::null;
+};

src/game-loop/interface/game-loop/GameLoopScoresState.hpp

@@ -18,4 +18,5 @@ class GameLoopScoresState : public GameLoopBaseState
     entt::entity _main_dude = entt::null;
     entt::entity _pause_overlay = entt::null;
     entt::entity _death_overlay = entt::null;
+    entt::entity _cheat_console = entt::null;
 };

src/game-loop/src/game-loop/GameLoop.cpp

@@ -57,3 +57,23 @@ GameLoop::GameLoop(const std::shared_ptr<Viewport>& viewport)
         return _exit;
     };
 }
+
+GameLoopBaseState *GameLoop::get_game_loop_state_ptr(GameLoop::State state) {
+    switch (state) {
+        case State::MAIN_MENU:
+            return &_states.main_menu;
+        case State::PLAYING:
+            return &_states.playing;
+        case State::STARTED:
+            return &_states.started;
+        case State::LEVEL_SUMMARY:
+            return &_states.level_summary;
+        case State::SCORES:
+            return &_states.scores;
+        case State::SANDBOX:
+            return &_states.sandbox;
+        case State::CURRENT:
+            return _states.current;
+        default: assert(false);
+    }
+}

src/game-loop/src/game-loop/GameLoopMainMenuState.cpp

@@ -34,6 +34,7 @@
 #include "prefabs/items/Flare.hpp"
 #include "prefabs/main-dude/MainDude.hpp"
 #include "prefabs/ui/PauseOverlay.hpp"
+#include "prefabs/ui/CheatConsole.hpp"
 
 #include <cmath>
 
@@ -110,6 +111,11 @@ GameLoopBaseState *GameLoopMainMenuState::update(GameLoop& game_loop, uint32_t d
         game_loop._exit = true;
     }
 
+    auto& cheat_console = registry.get<prefabs::CheatConsoleComponent>(_cheat_console);
+    if (cheat_console.is_state_change_requested()) {
+        return game_loop.get_game_loop_state_ptr(cheat_console.get_requested_state());
+    }
+
     return this;
 }
 
@@ -134,6 +140,7 @@ void GameLoopMainMenuState::enter(GameLoop& game_loop)
     auto& model_view_camera = rendering_system->get_model_view_camera();
     model_view_camera.set_x_not_rounded(game_loop._viewport->get_width_world_units() / 4.0f);
     model_view_camera.set_y_not_rounded(game_loop._viewport->get_height_world_units() / 4.0f);
+    model_view_camera.update_gl_modelview_matrix();
 
     prefabs::StartSign::create(5.55, 9.0);
     prefabs::ScoresSign::create(9.55, 9.0);
@@ -155,6 +162,7 @@ void GameLoopMainMenuState::enter(GameLoop& game_loop)
 
     _pause_overlay = prefabs::PauseOverlay::create(game_loop._viewport, PauseOverlayComponent::Type::MAIN_MENU);
     _main_dude = prefabs::MainDude::create(17.5, 9.5);
+    _cheat_console = prefabs::CheatConsole::create(game_loop._viewport);
 
     game_loop._level_summary_tracker->reset();
 

src/game-loop/src/game-loop/GameLoopPlayingState.cpp

@@ -36,6 +36,7 @@
 #include "Level.hpp"
 #include "audio/Audio.hpp"
 #include "populator/Populator.hpp"
+#include "prefabs/ui/CheatConsole.hpp"
 
 GameLoopBaseState *GameLoopPlayingState::update(GameLoop& game_loop, uint32_t delta_time_ms)
 {
@@ -112,6 +113,11 @@ GameLoopBaseState *GameLoopPlayingState::update(GameLoop& game_loop, uint32_t de
 
     game_loop._level_summary_tracker->update(delta_time_ms);
 
+    auto& cheat_console = registry.get<prefabs::CheatConsoleComponent>(_cheat_console);
+    if (cheat_console.is_state_change_requested()) {
+        return game_loop.get_game_loop_state_ptr(cheat_console.get_requested_state());
+    }
+
     return this;
 }
 
@@ -147,6 +153,7 @@ void GameLoopPlayingState::enter(GameLoop& game_loop)
     _pause_overlay = prefabs::PauseOverlay::create(game_loop._viewport, PauseOverlayComponent::Type::PLAYING);
     _death_overlay = prefabs::DeathOverlay::create(game_loop._viewport);
     _hud = prefabs::HudOverlay::create(game_loop._viewport);
+    _cheat_console = prefabs::CheatConsole::create(game_loop._viewport);
 
     game_loop._rendering_system->sort();
 

src/game-loop/src/game-loop/GameLoopSandboxState.cpp

@@ -0,0 +1,124 @@
+#include "game-loop/GameLoopSandboxState.hpp"
+#include "game-loop/GameLoop.hpp"
+
+#include "EntityRegistry.hpp"
+
+#include "prefabs/main-dude/MainDude.hpp"
+#include "prefabs/ui/ScoresOverlay.hpp"
+#include "prefabs/ui/PauseOverlay.hpp"
+#include "prefabs/props/ResetSign.hpp"
+
+#include "components/specialized/PauseOverlayComponent.hpp"
+#include "components/specialized/MainDudeComponent.hpp"
+
+#include "system/RenderingSystem.hpp"
+#include "system/ScriptingSystem.hpp"
+#include "system/PhysicsSystem.hpp"
+#include "system/ShoppingSystem.hpp"
+#include "system/AnimationSystem.hpp"
+#include "system/InputSystem.hpp"
+#include "system/DisposingSystem.hpp"
+#include "system/ParticleSystem.hpp"
+#include "system/ItemSystem.hpp"
+
+#include "populator/Populator.hpp"
+#include "logger/log.h"
+#include "ModelViewCamera.hpp"
+#include "ScreenSpaceCamera.hpp"
+#include "CameraType.hpp"
+#include "Level.hpp"
+#include "other/Inventory.hpp"
+#include "prefabs/ui/CheatConsole.hpp"
+
+GameLoopBaseState *GameLoopSandboxState::update(GameLoop& game_loop, uint32_t delta_time_ms)
+{
+    auto& registry = EntityRegistry::instance().get_registry();
+
+    auto& rendering_system = game_loop._rendering_system;
+    auto& scripting_system = game_loop._scripting_system;
+    auto& physics_system = game_loop._physics_system;
+    auto& animation_system = game_loop._animation_system;
+    auto& input_system = game_loop._input_system;
+    auto& disposing_system = game_loop._disposing_system;
+    auto& particle_system = game_loop._particle_system;
+    auto& item_system = game_loop._item_system;
+
+    // Adjust camera to follow main dude:
+    auto& position = registry.get<PositionComponent>(_main_dude);
+    auto& model_view_camera = game_loop._rendering_system->get_model_view_camera();
+
+    model_view_camera.adjust_to_bounding_box(position.x_center, position.y_center);
+    model_view_camera.adjust_to_level_boundaries(Consts ::LEVEL_WIDTH_TILES, Consts::LEVEL_HEIGHT_TILES);
+    model_view_camera.update_gl_modelview_matrix();
+
+    rendering_system->update(delta_time_ms);
+    input_system->update(delta_time_ms);
+
+    auto& pause = registry.get<PauseOverlayComponent>(_pause_overlay);
+
+    if (pause.is_paused())
+    {
+        if (pause.is_quit_requested())
+        {
+            log_info("Quit requested.");
+            game_loop._exit = true;
+        }
+
+        pause.update(registry);
+    }
+    else
+    {
+        physics_system->update(delta_time_ms);
+        animation_system->update(delta_time_ms);
+        scripting_system->update(delta_time_ms);
+        disposing_system->update(delta_time_ms);
+        particle_system->update(delta_time_ms);
+        item_system->update(delta_time_ms);
+    }
+
+    auto& dude = registry.get<MainDudeComponent>(_main_dude);
+
+    if (dude.entered_door())
+    {
+        return &game_loop._states.main_menu;
+    }
+
+    auto& cheat_console = registry.get<prefabs::CheatConsoleComponent>(_cheat_console);
+    if (cheat_console.is_state_change_requested()) {
+        return game_loop.get_game_loop_state_ptr(cheat_console.get_requested_state());
+    }
+
+    return this;
+}
+
+void GameLoopSandboxState::enter(GameLoop& game_loop)
+{
+    log_info("Entered GameLoopSandboxState");
+
+    auto& registry = EntityRegistry::instance().get_registry();
+
+    auto& rendering_system = game_loop._rendering_system;
+
+    Level::instance().get_tile_batch().clean();
+    Level::instance().get_tile_batch().generate_frame();
+    Level::instance().get_tile_batch().generate_cave_background();
+    Level::instance().get_tile_batch().batch_vertices();
+    Level::instance().get_tile_batch().add_render_entity(registry);
+
+    auto& inventory = Inventory::instance();
+    inventory.clear_items();
+    game_loop._shopping_system = std::make_shared<ShoppingSystem>();
+
+    float pos_x = Consts::LEVEL_WIDTH_TILES / 2;
+    float pos_y = Consts::LEVEL_HEIGHT_TILES / 2;
+
+    _main_dude = prefabs::MainDude::create(pos_x, pos_y);
+    _pause_overlay = prefabs::PauseOverlay::create(game_loop._viewport, PauseOverlayComponent::Type::SCORES);
+    _cheat_console = prefabs::CheatConsole::create(game_loop._viewport);
+}
+
+void GameLoopSandboxState::exit(GameLoop& game_loop)
+{
+    auto& registry = EntityRegistry::instance().get_registry();
+    registry.clear();
+}