added buttons to main state

src/core/application/ApplicationManager.cpp

@@ -12,6 +12,7 @@
 #include "../../states/State.h"
 #include "../../states/LoadingState.h"
 #include "../../states/MenuState.h"
+#include "../../states/OptionsState.h"
 #include "../../states/LevelSelectorState.h"
 #include "../../states/PlayingState.h"
 #include "../assets/AssetManager.h"
@@ -285,6 +286,7 @@ bool ApplicationManager::initializeManagers() {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to initialize RenderManager");
         return false;
     }
+    m_isFullscreen = m_renderManager->isFullscreen();
 
     // Create InputManager
     m_inputManager = std::make_unique<InputManager>();
@@ -330,6 +332,7 @@ bool ApplicationManager::initializeManagers() {
                     if (m_renderManager) {
                         bool fs = m_renderManager->isFullscreen();
                         m_renderManager->setFullscreen(!fs);
+                        m_isFullscreen = m_renderManager->isFullscreen();
                     }
                     // Don’t also forward Alt+Enter as an Enter keypress to states (prevents accidental "Start")
                         // Don't also forward Alt+Enter as an Enter keypress to states (prevents accidental "Start")
@@ -588,10 +591,30 @@ bool ApplicationManager::initializeGame() {
         m_stateContext.showSettingsPopup = &m_showSettingsPopup;
         m_stateContext.showExitConfirmPopup = &m_showExitConfirmPopup;
         m_stateContext.exitPopupSelectedButton = &m_exitPopupSelectedButton;
+        m_stateContext.playerName = &m_playerName;
+        m_stateContext.fullscreenFlag = &m_isFullscreen;
+        m_stateContext.applyFullscreen = [this](bool enable) {
+            if (m_renderManager) {
+                m_renderManager->setFullscreen(enable);
+                m_isFullscreen = m_renderManager->isFullscreen();
+            } else {
+                m_isFullscreen = enable;
+            }
+        };
+        m_stateContext.queryFullscreen = [this]() -> bool {
+            if (m_renderManager) {
+                return m_renderManager->isFullscreen();
+            }
+            return m_isFullscreen;
+        };
+        m_stateContext.requestQuit = [this]() {
+            requestShutdown();
+        };
 
         // Create state instances
         m_loadingState = std::make_unique<LoadingState>(m_stateContext);
         m_menuState = std::make_unique<MenuState>(m_stateContext);
+        m_optionsState = std::make_unique<OptionsState>(m_stateContext);
         m_levelSelectorState = std::make_unique<LevelSelectorState>(m_stateContext);
         m_playingState = std::make_unique<PlayingState>(m_stateContext);
 
@@ -605,6 +628,10 @@ bool ApplicationManager::initializeGame() {
             m_stateManager->registerOnEnter(AppState::Menu, [this](){ if (m_menuState) m_menuState->onEnter(); });
             m_stateManager->registerOnExit(AppState::Menu, [this](){ if (m_menuState) m_menuState->onExit(); });
 
+            m_stateManager->registerEventHandler(AppState::Options, [this](const SDL_Event& e){ if (m_optionsState) m_optionsState->handleEvent(e); });
+            m_stateManager->registerOnEnter(AppState::Options, [this](){ if (m_optionsState) m_optionsState->onEnter(); });
+            m_stateManager->registerOnExit(AppState::Options, [this](){ if (m_optionsState) m_optionsState->onExit(); });
+
             m_stateManager->registerEventHandler(AppState::LevelSelector, [this](const SDL_Event& e){ if (m_levelSelectorState) m_levelSelectorState->handleEvent(e); });
             m_stateManager->registerOnEnter(AppState::LevelSelector, [this](){ if (m_levelSelectorState) m_levelSelectorState->onEnter(); });
             m_stateManager->registerOnExit(AppState::LevelSelector, [this](){ if (m_levelSelectorState) m_levelSelectorState->onExit(); });
@@ -720,6 +747,32 @@ void ApplicationManager::setupStateHandlers() {
             SDL_SetRenderScale(renderer.getSDLRenderer(), 1.0f, 1.0f);
         });
 
+    m_stateManager->registerRenderHandler(AppState::Options,
+        [this](RenderManager& renderer) {
+            renderer.clear(0, 0, 20, 255);
+            int winW = 0, winH = 0;
+            if (m_renderManager) m_renderManager->getWindowSize(winW, winH);
+            SDL_Texture* background = m_assetManager->getTexture("background");
+            if (background && winW > 0 && winH > 0) {
+                SDL_FRect bgRect = { 0, 0, (float)winW, (float)winH };
+                renderer.renderTexture(background, nullptr, &bgRect);
+            }
+
+            SDL_Rect logicalVP = {0,0,0,0};
+            float logicalScale = 1.0f;
+            if (m_renderManager) {
+                logicalVP = m_renderManager->getLogicalViewport();
+                logicalScale = m_renderManager->getLogicalScale();
+            }
+            SDL_SetRenderViewport(renderer.getSDLRenderer(), &logicalVP);
+            SDL_SetRenderScale(renderer.getSDLRenderer(), logicalScale, logicalScale);
+            if (m_optionsState) {
+                m_optionsState->render(renderer.getSDLRenderer(), logicalScale, logicalVP);
+            }
+            SDL_SetRenderViewport(renderer.getSDLRenderer(), nullptr);
+            SDL_SetRenderScale(renderer.getSDLRenderer(), 1.0f, 1.0f);
+        });
+
     // LevelSelector State render: draw background full-screen, then delegate to LevelSelectorState::render
     m_stateManager->registerRenderHandler(AppState::LevelSelector,
         [this](RenderManager& renderer) {

src/core/application/ApplicationManager.h

@@ -21,6 +21,7 @@ class LineEffect;
 // Forward declare state classes (top-level, defined under src/states)
 class LoadingState;
 class MenuState;
+class OptionsState;
 class LevelSelectorState;
 class PlayingState;
 
@@ -95,6 +96,8 @@ private:
     bool m_showSettingsPopup = false;
     bool m_showExitConfirmPopup = false;
     int m_exitPopupSelectedButton = 1; // 0 = YES, 1 = NO
+    bool m_isFullscreen = false;
+    std::string m_playerName = "PLAYER";
     uint64_t m_loadStartTicks = 0;
     bool m_musicStarted = false;
     bool m_musicLoaded = false;
@@ -120,6 +123,7 @@ private:
     // State objects (mirror main.cpp pattern)
     std::unique_ptr<LoadingState> m_loadingState;
     std::unique_ptr<MenuState> m_menuState;
+    std::unique_ptr<OptionsState> m_optionsState;
     std::unique_ptr<LevelSelectorState> m_levelSelectorState;
     std::unique_ptr<PlayingState> m_playingState;
     // Application state

src/core/state/StateManager.cpp

@@ -170,6 +170,7 @@ const char* StateManager::getStateName(AppState state) const {
     switch (state) {
         case AppState::Loading: return "Loading";
         case AppState::Menu: return "Menu";
+        case AppState::Options: return "Options";
         case AppState::LevelSelector: return "LevelSelector";
         case AppState::Playing: return "Playing";
         case AppState::LevelSelect: return "LevelSelect";

src/core/state/StateManager.h

@@ -13,6 +13,7 @@ class RenderManager;
 enum class AppState {
     Loading,
     Menu,
+    Options,
     LevelSelector,
     Playing,
     LevelSelect,