Console & States Stack print

CMakeLists.txt

@@ -42,6 +42,8 @@ add_executable(kariokaEngine
 	src/states/MainMenuState.cpp
 	src/states/GamePlayState.cpp
 	src/states/PauseState.cpp
+	src/states/MapEditorState.cpp
+	src/states/AssetEditorState.cpp
 
     # Python
     src/scripting/PythonEngine.cpp

assets/scripts/states.py

@@ -0,0 +1,8 @@
+import karioka
+
+def print_stack():
+    engine = karioka.engine()
+
+
+if __name__ == "__main__":
+    print_stack()

imgui.ini

@@ -7,6 +7,10 @@ Pos=440,110
 Size=400,500
 
 [Window][Python Console (~)]
-Pos=100,100
+Pos=778,63
 Size=800,500
 
+[Window][Pause Menu]
+Pos=440,210
+Size=400,300
+

src/Engine.cpp

@@ -2,9 +2,12 @@
 #include "states/MainMenuState.h"
 #include <SDL2/SDL_log.h>
 #include <SDL2/SDL_mixer.h>
-
+#include <pybind11/pybind11.h>
 #include "scripting/PythonEngine.h"
 #include "scripting/bindings/kariokaModule.h"
+#include <iostream>
+
+namespace py = pybind11;
 
 Engine* Engine::s_instance = nullptr;
 
@@ -210,4 +213,41 @@ Engine& Engine::Get()
 void Engine::DebugInfo()
 {
     SDL_Log("kariokaEngine v0.1 DebugInfo()");
+}
+
+py::list Engine::GetStateStack()
+{
+    return py::cast(stateManager.GetStack());
+}
+
+void Engine::PrintStates()
+{
+    auto stack = stateManager.GetStack();
+    
+    SDL_Log("=== Current State Stack ===");
+    if (stack.empty())
+    {
+        SDL_Log("Stack is empty");
+    }
+    else
+    {
+        std::cout << "Stack size: " << stack.size() << "\n";
+        
+        for (size_t i = 0; i < stack.size(); ++i)
+        {
+            std::string prefix = (i == stack.size() - 1) ? "-> " : " ";
+            std::cout << prefix << stack[i] << "\n";
+        }
+    }
+    SDL_Log("===========================");
+}
+
+StateManager& Engine::GetStateManager()
+{
+    return stateManager;
+}
+
+const StateManager& Engine::GetStateManager() const
+{
+    return stateManager;
 }

src/Engine.h

@@ -34,6 +34,10 @@ public:
     
     // StateManager
     StateManager  stateManager;
+    pybind11::list GetStateStack();
+    void PrintStates();
+    StateManager& GetStateManager();
+    const StateManager& GetStateManager() const;
     
     // Safe State transition
     void RequestStateChange(std::unique_ptr<BaseState> newState);

src/scripting/PythonEngine.cpp

@@ -32,6 +32,9 @@ void PythonEngine::Init()
         sys.attr("path").attr("append")("scripts");
         sys.attr("path").attr("append")("assets/scripts");
         SDL_Log("[Python] scripts paths added");
+        
+        // Load modules
+        py::module_::import("states");
     }
     catch (...)
     {

src/scripting/bindings/kariokaModule.cpp

@@ -3,6 +3,7 @@
 #include <pybind11/stl.h>
 #include "../../Engine.h"
 #include <SDL2/SDL_log.h>
+#include <iostream>
 
 namespace py = pybind11;
 
@@ -24,6 +25,31 @@ PYBIND11_EMBEDDED_MODULE(karioka, m)
     engine_cls.def("RequestStateChange", &Engine::RequestStateChange);
     engine_cls.def("RequestPopState", &Engine::RequestPopState);
     
+    engine_cls.def("GetStateStack", [](Engine& self) -> py::list {
+        auto stackVec = self.GetStateManager().GetStack();
+        py::list pyStack;
+        for (const auto& name : stackVec)
+        {
+            pyStack.append(name);
+        }
+        return pyStack;
+    });
+    
+    engine_cls.def("PrintStates", [](Engine& self) {
+        SDL_Log("=== C++ State Stack ===");
+        SDL_Log("Current top state: MainMenuState");
+        SDL_Log("Total states on stack: 1");
+        SDL_Log("=======================");
+    });
+    
+    m.def("print_states", []() {
+        Engine::Get().PrintStates();
+    });
+    
+    m.def("get_states", []() -> py::list {
+        return Engine::Get().GetStateStack();
+    });
+    
     // Logging
     engine_cls.def("log",  [](Engine& self, const std::string& msg) {
         SDL_Log("[PY] %s", msg.c_str());

src/states/AssetEditorState.cpp

@@ -0,0 +1,42 @@
+#include "AssetEditorState.h"
+#include "../Engine.h"
+#include "MainMenuState.h"
+#include <imgui.h>
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_log.h>
+#include <cstring>
+
+void AssetEditorState::Enter(Engine& engine)
+{
+}
+
+void AssetEditorState::Exit(Engine& engine)
+{
+}
+
+void AssetEditorState::HandleEvents(Engine& engine, SDL_Event& event)
+{
+    if (event.type == SDL_KEYDOWN)
+    {
+        if (event.key.keysym.sym == SDLK_ESCAPE)
+        {
+            engine.RequestPopState();
+        }
+    }
+}
+
+void AssetEditorState::Update(Engine& engine, float dt)
+{
+}
+
+void AssetEditorState::Render(Engine& engine)
+{
+    SDL_Renderer* r = engine.GetRenderer();
+    if (!r) { return; }
+    SDL_SetRenderDrawColor(r, 20, 20, 30, 255);
+    SDL_RenderClear(r);
+}
+
+void AssetEditorState::RenderImGui(Engine& engine)
+{
+}

src/states/AssetEditorState.h

@@ -0,0 +1,25 @@
+#ifndef __STATES__ASSET_EDITOR_STATE_H__
+#define __STATES__ASSET_EDITOR_STATE_H__
+
+#include "BaseState.h"
+#include "../EngineConfig.h"
+#include <entt/entt.hpp>
+#include <SDL2/SDL.h>
+
+class AssetEditorState : public BaseState
+{
+public:
+    void Enter(Engine& engine) override;
+    void Exit(Engine& engine) override;
+    void HandleEvents(Engine& engine, SDL_Event& event) override;
+    void Update(Engine& engine, float dt) override;
+    void Render(Engine& engine) override;
+    void RenderImGui(Engine& engine) override;
+    
+    std::string GetName() const override { return "AssetEditorState"; }
+    
+private:
+
+};
+
+#endif

src/states/BaseState.h

@@ -2,6 +2,7 @@
 #define __STATES__BASE_STATE_H__
 
 #include <SDL2/SDL.h>
+#include <string>
 
 class Engine; // Forward declaration
 
@@ -16,6 +17,7 @@ public:
     virtual void Update(Engine& engine, float dt) = 0;
     virtual void Render(Engine& engine) = 0;
     virtual void RenderImGui(Engine& engine) {};
+    virtual std::string GetName() const = 0;
 
 private:
 

src/states/GamePlayState.h

@@ -5,6 +5,7 @@
 #include "../EngineConfig.h"
 #include <entt/entt.hpp>
 #include <SDL2/SDL.h>
+#include <string>
 
 class GamePlayState : public BaseState
 {
@@ -15,6 +16,8 @@ public:
     void Update(Engine& engine, float dt) override;
     void Render(Engine& engine) override;
     void RenderImGui(Engine& engine) override;
+    
+    std::string GetName() const override { return "GamePlayState"; }
 
 private:
 

src/states/MainMenuState.cpp

@@ -1,4 +1,7 @@
 #include "MainMenuState.h"
+#include "GamePlayState.h"
+#include "AssetEditorState.h"
+#include "MapEditorState.h"
 #include "../Engine.h"
 #include <imgui.h>
 #include <SDL2/SDL_log.h>
@@ -62,19 +65,20 @@ void MainMenuState::RenderImGui(Engine& engine)
     ImGui::SetCursorPosX((windowWidth - buttonWidth) * 0.5f);
     if (ImGui::Button("Enter World", ImVec2(buttonWidth, 30)))
     {
-        SDL_Log("TODO: GamePlayState");
+        // engine.stateManager.ChangeState(std::make_unique<GamePlayState>(), engine);
+        engine.stateManager.PushState(std::make_unique<GamePlayState>(), engine);
     }
     
     ImGui::SetCursorPosX((windowWidth - buttonWidth) * 0.5f);
     if (ImGui::Button("Map Editor", ImVec2(buttonWidth, 30)))
     {
-        SDL_Log("TODO: MapEditorState");
+        engine.stateManager.PushState(std::make_unique<MapEditorState>(), engine);
     }
     
     ImGui::SetCursorPosX((windowWidth - buttonWidth) * 0.5f);
     if (ImGui::Button("Asset Editor", ImVec2(buttonWidth, 30)))
     {
-        SDL_Log("TODO: AssetEditorState");
+        engine.stateManager.PushState(std::make_unique<AssetEditorState>(), engine);
     }
     
     ImGui::SetCursorPosX((windowWidth - buttonWidth) * 0.5f);

src/states/MainMenuState.h

@@ -14,6 +14,8 @@ public:
     void Update(Engine& engine, float dt) override;
     void Render(Engine& engine) override;
     void RenderImGui(Engine& engine) override;
+    
+    std::string GetName() const override { return "MainMenuState"; }
 
 private:
     std::string versionText = "kariokaEngine v0.01 - Built with SDL2 + EnTT + ImGui + Python - (c) poloniumv 2026";

src/states/MapEditorState.cpp

@@ -0,0 +1,38 @@
+#include "MapEditorState.h"
+#include "../Engine.h"
+#include <SDL2/SDL.h>
+
+void MapEditorState::Enter(Engine& engine)
+{
+}
+
+void MapEditorState::Exit(Engine& engine)
+{
+}
+
+void MapEditorState::HandleEvents(Engine& engine, SDL_Event& event)
+{
+    if (event.type == SDL_KEYDOWN)
+    {
+        if (event.key.keysym.sym == SDLK_ESCAPE)
+        {
+            engine.RequestPopState();
+        }
+    }
+}
+
+void MapEditorState::Update(Engine& engine, float dt)
+{
+}
+
+void MapEditorState::Render(Engine& engine)
+{
+    SDL_Renderer* r = engine.GetRenderer();
+    if (!r) { return; }
+    SDL_SetRenderDrawColor(r, 30, 30, 40, 255);
+    SDL_RenderClear(r);
+}
+
+void MapEditorState::RenderImGui(Engine& engine)
+{
+}

src/states/MapEditorState.h

@@ -0,0 +1,22 @@
+#ifndef __STATES__MAP_EDITOR_STATE_H__
+#define __STATES__MAP_EDITOR_STATE_H__
+
+#include "BaseState.h"
+
+class MapEditorState : public BaseState
+{
+public:
+    void Enter(Engine& engine) override;
+    void Exit(Engine& engine) override;
+    void HandleEvents(Engine& engine, SDL_Event& event) override;
+    void Update(Engine& engine, float dt) override;
+    void Render(Engine& engine) override;
+    void RenderImGui(Engine& engine) override;
+    
+    std::string GetName() const override { return "MapEditorState"; }
+    
+private:
+
+};
+
+#endif

src/states/PauseState.cpp

@@ -3,6 +3,7 @@
 #include "GamePlayState.h"
 #include "MainMenuState.h"
 #include <imgui.h>
+#include <SDL2/SDL.h>
 
 void PauseState::Enter(Engine& engine)
 {
@@ -16,7 +17,7 @@ void PauseState::HandleEvents(Engine& engine, SDL_Event& event)
 {
     if (event.type == SDL_KEYDOWN)
     {
-        if (event.type.keysym.sym == SDLK_ESCAPE)
+        if (event.key.keysym.sym == SDLK_ESCAPE)
         {
             engine.RequestPopState();
         }
@@ -50,15 +51,15 @@ void PauseState::RenderImGui(Engine& engine)
     ImGui::SetCursorPosX((ImGui::GetWindowSize().x - ImGui::CalcTextSize("PAUSED").x) * 0.5f);
     ImGui::TextColored(ImVec4(1.0f, 0.8f, 0.0f, 1.0f), "PAUSED");
 
-    ImGui::Dummy(ImVec2(0.0f, 100.0f));
+    ImGui::Dummy(ImVec2(0.0f, 60.0f));
     
     float buttonWidth = 200.f;
     float windowWidth = ImGui::GetWindowSize().x;
 
     ImGui::SetCursorPosX((windowWidth - buttonWidth) * 0.5f);
-    if (ImGui::Button("Back to Game", ImVec2(buttonWidth, 30)))
+    if (ImGui::Button("Resume Game", ImVec2(buttonWidth, 30)))
     {
-        SDL_Log("TODO: GamePlayState");
+        engine.RequestPopState();
     }
 
     ImGui::SetCursorPosX((windowWidth - buttonWidth) * 0.5f);
@@ -74,9 +75,12 @@ void PauseState::RenderImGui(Engine& engine)
     }
 
     ImGui::SetCursorPosX((windowWidth - buttonWidth) * 0.5f);
-    if (ImGui::Button("Exit", ImVec2(buttonWidth, 30)))
+    if (ImGui::Button("Exit to Main Menu", ImVec2(buttonWidth, 30)))
     {
-        engine.StopRunning();
+        //engine.RequestStateChange(std::make_unique<MainMenuState>());
+        engine.stateManager.PopState(engine); // Drop PauseState
+        engine.stateManager.PopState(engine); // Drop GamePlayState
+        //engine.stateManager.ChangeState(std::make_unique<MainMenuState>(), engine);
     }
 
     ImGui::End();

src/states/PauseState.h

@@ -2,6 +2,7 @@
 #define __STATES__PAUSE_STATE_H__
 
 #include "BaseState.h"
+#include <string>
 
 class PauseState : public BaseState
 {
@@ -12,6 +13,8 @@ public:
     void Update(Engine& engine, float dt) override;
     void Render(Engine& engine) override;
     void RenderImGui(Engine& engine) override;
+    
+    std::string GetName() const override { return "PauseState"; }
 
 private:
     SDL_Color overlayColor = { 0, 0, 0, 180 };

src/states/StateManager.cpp

@@ -88,4 +88,33 @@ BaseState* StateManager::GetCurrentState() const
     }
     
     return nullptr;
+}
+
+std::vector<std::string> StateManager::GetStack() const
+{
+    std::vector<std::string> stackNames;
+    stackNames.reserve(states.size());
+    for (const auto& statePtr : states)
+    {
+        if (statePtr)
+        {
+            std::string name = typeid(*statePtr).name();
+            if (name.find("MainMenuState") != std::string::npos)
+            {
+                name = "MainMenuState";
+            }
+            else if (name.find("PauseState") != std::string::npos)
+            {
+                name = "PauseState";
+            }
+            else if (name.find("GamePlayState") != std::string::npos)
+            {
+                name = "GamePlayState";
+            }
+            
+            stackNames.push_back(name);
+        }
+    }
+    
+    return stackNames;
 }

src/states/StateManager.h

@@ -21,6 +21,7 @@ public:
     void RenderImGui(Engine& engine);
     
     BaseState* GetCurrentState() const;
+    std::vector<std::string> GetStack() const;
     bool IsEmpty() const { return states.empty(); }
 
 private: