MenuScene.cpp

#include "MenuScene.h"
#include "MenuConstants.h"
#include "core/Engine.h"
#include "platforms/EngineConfig.h"
#include "graphics/Renderer.h"

#include "examples/Games/Pong/PongScene.h"
#include "examples/Games/BrickBreaker/BrickBreakerScene.h"
#include "examples/Games/TicTacToe/TicTacToeScene.h"
#include "examples/Games/Snake/SnakeScene.h"
#include "examples/Games/SpaceInvaders/SpaceInvadersScene.h"

#ifdef PIXELROOT32_ENABLE_4BPP_SPRITES
#include "examples/Games/Metroidvania/MetroidvaniaScene.h"
#endif

#include "examples/PhysicsDemo/PhysicsDemoScene.h"
#include "examples/CameraDemo/CameraDemoScene.h"
#include "examples/DualPaletteTest/DualPaletteTestScene.h"
#include "examples/FontTest/FontTestScene.h"
#if defined(PIXELROOT32_ENABLE_2BPP_SPRITES) || defined(PIXELROOT32_ENABLE_4BPP_SPRITES)
#include "examples/SpritesDemo/SpritesDemoScene.h"
#endif
#ifdef PIXELROOT32_ENABLE_4BPP_SPRITES
#include "examples/TileMapDemo/TileMapDemoScene.h"
#endif
#include "examples/UIElementDemo/CheckBoxDemo/CheckBoxScene.h"
#include "examples/UIElementDemo/ButtonDemo/ButtonScene.h"
#include "examples/UIElementDemo/LabelDemo/LabelScene.h"
#include "examples/UIElementDemo/Layouts/VerticalLayoutDemo/VerticalLayoutDemoScene.h"
#include "examples/UIElementDemo/Layouts/HorizontalLayoutDemo/HorizontalLayoutDemoScene.h"
#include "examples/UIElementDemo/Layouts/GridLayoutDemo/GridLayoutDemoScene.h"
#include "examples/UIElementDemo/Layouts/AnchorLayoutDemo/AnchorLayoutDemoScene.h"

namespace pr32 = pixelroot32;

extern pr32::core::Engine engine;

// Define instances here
pong::PongScene pongScene;
brickbreaker::BrickBreakerScene brickScene;
tictactoe::TicTacToeScene tttScene;
snake::SnakeScene snakeScene;
spaceinvaders::SpaceInvadersScene spaceInvadersScene;

#ifdef PIXELROOT32_ENABLE_4BPP_SPRITES
metroidvania::MetroidvaniaScene metroidvaniaScene;
#endif

physicsdemo::PhysicsDemoScene physicsDemoScene;
camerademo::CameraDemoScene cameraDemoScene;
dualpalettetest::DualPaletteTestScene dualPaletteTestScene;
fonttest::FontTestScene fontTestScene;
checkboxdemo::CheckBoxScene checkBoxScene;
buttondemo::ButtonScene buttonScene;
labeldemo::LabelScene labelScene;
verticallayoutdemo::VerticalLayoutDemoScene verticalLayoutDemoScene;
horizontallayoutdemo::HorizontalLayoutDemoScene horizontalLayoutDemoScene;
gridlayoutdemo::GridLayoutDemoScene gridLayoutDemoScene;
anchorlayoutdemo::AnchorLayoutDemoScene anchorLayoutDemoScene;
#if defined(PIXELROOT32_ENABLE_2BPP_SPRITES) || defined(PIXELROOT32_ENABLE_4BPP_SPRITES)
spritesdemo::SpritesDemoScene spritesDemoScene;
#endif
#ifdef PIXELROOT32_ENABLE_4BPP_SPRITES
tilemapdemo::TileMapDemoScene tileMapDemoScene;
#endif

using Color = pr32::graphics::Color;
using Vector2 = pr32::math::Vector2;

void MenuScene::init() {
    // Clear any existing entities to prevent duplicates if init() is called multiple times
    clearEntities();

    pr32::graphics::setPalette(pr32::graphics::PaletteType::PR32);
    int screenWidth = engine.getRenderer().getLogicalWidth();
    int screenHeight = engine.getRenderer().getLogicalHeight();

    // Create title label
    titleLabel = std::make_unique<pr32::graphics::ui::UILabel>("Examples", Vector2(0, menu::TITLE_Y), Color::White, menu::TITLE_FONT_SIZE);
    titleLabel->centerX(screenWidth);
    titleLabel->setRenderLayer(2);
    addEntity(titleLabel.get());

    // Create vertical layout for buttons
    float btnW = menu::BTN_WIDTH;
    float cx = screenWidth / 2.0f;
    float btnX = cx - (btnW / 2.0f);
    float startY = menu::BTN_START_Y;
    float layoutHeight = screenHeight - startY - menu::NAV_INSTR_Y_OFFSET - 10;
    
    buttonLayout = std::make_unique<pr32::graphics::ui::UIVerticalLayout>(btnX, startY, btnW, layoutHeight);
    buttonLayout->setPadding(0);
    buttonLayout->setSpacing(menu::BTN_GAP);
    buttonLayout->setScrollEnabled(true);
    buttonLayout->setNavigationButtons(menu::BTN_NAV_UP, menu::BTN_NAV_DOWN);
    buttonLayout->setButtonStyle(Color::White, Color::Cyan, Color::White, Color::Black);
    buttonLayout->setRenderLayer(2);
    addEntity(buttonLayout.get());

    // Create all buttons (will be shown/hidden based on menu state)
    setupMainMenu();
    setupGamesMenu();
    setupUIElementsMenu();
    setupLayoutsMenu();

    // Navigation labels
    lblNavigate = std::make_unique<pr32::graphics::ui::UILabel>("UP/DOWN: Navigate", Vector2(0, screenHeight - menu::NAV_INSTR_Y_OFFSET), Color::Cyan, menu::INSTRUCTION_FONT_SIZE);
    lblNavigate->centerX(screenWidth);
    lblNavigate->setRenderLayer(2);
    addEntity(lblNavigate.get());

    lblSelect = std::make_unique<pr32::graphics::ui::UILabel>("A: Select", Vector2(0, screenHeight - menu::SEL_INSTR_Y_OFFSET), Color::Cyan, menu::INSTRUCTION_FONT_SIZE);
    lblSelect->centerX(screenWidth);
    lblSelect->setRenderLayer(2);
    addEntity(lblSelect.get());

    lblBack = std::make_unique<pr32::graphics::ui::UILabel>("B: Back", Vector2(0, screenHeight - 15), Color::Cyan, menu::INSTRUCTION_FONT_SIZE);
    lblBack->centerX(screenWidth);
    lblBack->setRenderLayer(2);
    addEntity(lblBack.get());

    // Show main menu initially
    currentState = MenuState::MAIN;
    showMenu(MenuState::MAIN);
}

void MenuScene::update(unsigned long deltaTime) {
    Scene::update(deltaTime);
    
    // Input Handling
    auto& input = engine.getInputManager();

    // Handle back button (B button, typically button 5)
    static bool wasBackPressed = false;
    bool isBackPressed = input.isButtonPressed(5); // B button
    if (isBackPressed && !wasBackPressed) {
        goBack();
        // Play back sound
        pr32::audio::AudioEvent ev;
        ev.type = pr32::audio::WaveType::TRIANGLE;
        ev.frequency = menu::SOUND_NAV_FREQ;
        ev.duration = menu::SOUND_NAV_DUR;
        ev.volume = menu::SOUND_VOL_NAV;
        engine.getAudioEngine().playEvent(ev);
    }
    wasBackPressed = isBackPressed;

    // Handle layout navigation (UP/DOWN handled by layout)
    // Track previous selection for sound feedback
    static int lastSelectedIndex = -1;
    
    buttonLayout->handleInput(input);
    
    // Check if selection changed (for sound feedback)
    int newSelectedIndex = buttonLayout->getSelectedIndex();
    if (newSelectedIndex != lastSelectedIndex && newSelectedIndex >= 0) {
        // Play navigation sound
        pr32::audio::AudioEvent ev;
        ev.type = pr32::audio::WaveType::TRIANGLE;
        ev.frequency = menu::SOUND_NAV_FREQ;
        ev.duration = menu::SOUND_NAV_DUR;
        ev.volume = menu::SOUND_VOL_NAV;
        engine.getAudioEngine().playEvent(ev);
        lastSelectedIndex = newSelectedIndex;
    }

    // Sound test for SELECT button
    if (input.isButtonPressed(menu::BTN_SELECT)) {
        pr32::audio::AudioEvent ev;
        ev.type = pr32::audio::WaveType::PULSE;
        ev.frequency = menu::SOUND_BLIP_FREQ;
        ev.duration = menu::SOUND_BLIP_DUR;
        ev.volume = menu::SOUND_VOL_BLIP;
        ev.duty = 0.5f;
        engine.getAudioEngine().playEvent(ev);
    }
}

void MenuScene::draw(pixelroot32::graphics::Renderer& renderer) {
    Scene::draw(renderer);
}

void MenuScene::setupMainMenu() {
    int btnW = menu::BTN_WIDTH;
    int btnH = menu::BTN_HEIGHT;
    
    gamesButton = std::make_unique<pr32::graphics::ui::UIButton>("GAMES", menu::BTN_SELECT, Vector2::ZERO(), Vector2{btnW, btnH}, [this]() {
        showMenu(MenuState::GAMES);
    }, pr32::graphics::ui::TextAlignment::CENTER, menu::BTN_FONT_SIZE);
    
    physicsDemoButton = std::make_unique<pr32::graphics::ui::UIButton>("PHYSICS DEMO", menu::BTN_SELECT, Vector2::ZERO(), Vector2{btnW, btnH}, []() {
        engine.setScene(&physicsDemoScene);
    }, pr32::graphics::ui::TextAlignment::CENTER, menu::BTN_FONT_SIZE);

    cameraDemoButton = std::make_unique<pr32::graphics::ui::UIButton>("CAMERA DEMO", menu::BTN_SELECT, Vector2::ZERO(), Vector2{btnW, btnH}, []() {
        engine.setScene(&cameraDemoScene);
    }, pr32::graphics::ui::TextAlignment::CENTER, menu::BTN_FONT_SIZE);
    
#if defined(PIXELROOT32_ENABLE_2BPP_SPRITES) || defined(PIXELROOT32_ENABLE_4BPP_SPRITES)
    spritesDemoButton = std::make_unique<pr32::graphics::ui::UIButton>("SPRITES DEMO", menu::BTN_SELECT, Vector2::ZERO(), Vector2{btnW, btnH}, []() {
        engine.setScene(&spritesDemoScene);
    }, pr32::graphics::ui::TextAlignment::CENTER, menu::BTN_FONT_SIZE);
#endif
    
#ifdef PIXELROOT32_ENABLE_4BPP_SPRITES
    tileMapDemoButton = std::make_unique<pr32::graphics::ui::UIButton>("TILEMAP DEMO", menu::BTN_SELECT, Vector2::ZERO(), Vector2{btnW, btnH}, []() {
        engine.setScene(&tileMapDemoScene);
    }, pr32::graphics::ui::TextAlignment::CENTER, menu::BTN_FONT_SIZE);
#endif
    fontTestButton = std::make_unique<pr32::graphics::ui::UIButton>("FONT TEST", menu::BTN_SELECT, Vector2::ZERO(), Vector2{btnW, btnH}, []() {
        engine.setScene(&fontTestScene);
    }, pr32::graphics::ui::TextAlignment::CENTER, menu::BTN_FONT_SIZE);
    
    dualPaletteTestButton = std::make_unique<pr32::graphics::ui::UIButton>("DUAL PALETTE TEST", menu::BTN_SELECT, Vector2::ZERO(), Vector2{btnW, btnH}, []() {
        engine.setScene(&dualPaletteTestScene);
    }, pr32::graphics::ui::TextAlignment::CENTER, menu::BTN_FONT_SIZE);
    
    uiElementsButton = std::make_unique<pr32::graphics::ui::UIButton>("UIELEMENTS", menu::BTN_SELECT, Vector2::ZERO(), Vector2{btnW, btnH}, [this]() {
        showMenu(MenuState::UIELEMENTS);
    }, pr32::graphics::ui::TextAlignment::CENTER, menu::BTN_FONT_SIZE);
}

void MenuScene::setupGamesMenu() {
    int btnW = menu::BTN_WIDTH;
    int btnH = menu::BTN_HEIGHT;
    
    pongButton = std::make_unique<pr32::graphics::ui::UIButton>("PONG", menu::BTN_SELECT, Vector2::ZERO(), Vector2{btnW, btnH}, []() {
        engine.setScene(&pongScene);
    }, pr32::graphics::ui::TextAlignment::CENTER, menu::BTN_FONT_SIZE);

    brickBreakerButton = std::make_unique<pr32::graphics::ui::UIButton>("BRICK BREAKER", menu::BTN_SELECT, Vector2::ZERO(), Vector2{btnW, btnH}, []() {
        engine.setScene(&brickScene);
    }, pr32::graphics::ui::TextAlignment::CENTER, menu::BTN_FONT_SIZE);
    
    snakeButton = std::make_unique<pr32::graphics::ui::UIButton>("SNAKE", menu::BTN_SELECT, Vector2::ZERO(), Vector2{btnW, btnH}, []() {
        engine.setScene(&snakeScene);
    }, pr32::graphics::ui::TextAlignment::CENTER, menu::BTN_FONT_SIZE);
    
    spaceInvadersButton = std::make_unique<pr32::graphics::ui::UIButton>("SPACE INVADERS", menu::BTN_SELECT, Vector2::ZERO(), Vector2{btnW, btnH}, []() {
        engine.setScene(&spaceInvadersScene);
    }, pr32::graphics::ui::TextAlignment::CENTER, menu::BTN_FONT_SIZE);
    
    tttButton = std::make_unique<pr32::graphics::ui::UIButton>("TIC TAC TOE", menu::BTN_SELECT, Vector2::ZERO(), Vector2{btnW, btnH}, []() {
        engine.setScene(&tttScene);
    }, pr32::graphics::ui::TextAlignment::CENTER, menu::BTN_FONT_SIZE);


#ifdef PIXELROOT32_ENABLE_4BPP_SPRITES
    metroidvaniaButton = std::make_unique<pr32::graphics::ui::UIButton>("METROIDVANIA", menu::BTN_SELECT, Vector2::ZERO(), Vector2{btnW, btnH}, []() {
        engine.setScene(&metroidvaniaScene);
    }, pr32::graphics::ui::TextAlignment::CENTER, menu::BTN_FONT_SIZE);
#endif
}

void MenuScene::setupUIElementsMenu() {
    int btnW = menu::BTN_WIDTH;
    int btnH = menu::BTN_HEIGHT;

    buttonsButton = std::make_unique<pr32::graphics::ui::UIButton>("BUTTONS", menu::BTN_SELECT, Vector2::ZERO(), Vector2{btnW, btnH}, [this]() {
        showMenu(MenuState::BUTTONS);
        engine.setScene(&buttonScene);
    }, pr32::graphics::ui::TextAlignment::CENTER, menu::BTN_FONT_SIZE);
    
    labelsButton = std::make_unique<pr32::graphics::ui::UIButton>("LABELS", menu::BTN_SELECT, Vector2::ZERO(), Vector2{btnW, btnH}, [this]() {
        showMenu(MenuState::LABELS);
        engine.setScene(&labelScene);
    }, pr32::graphics::ui::TextAlignment::CENTER, menu::BTN_FONT_SIZE);
    
    checkboxesButton = std::make_unique<pr32::graphics::ui::UIButton>("CHECKBOXES", menu::BTN_SELECT, Vector2::ZERO(), Vector2{btnW, btnH}, [this]() {
        showMenu(MenuState::CHECKBOXES);
        engine.setScene(&checkBoxScene);
    }, pr32::graphics::ui::TextAlignment::CENTER, menu::BTN_FONT_SIZE);
    
    layoutsButton = std::make_unique<pr32::graphics::ui::UIButton>("LAYOUTS", menu::BTN_SELECT, Vector2::ZERO(), Vector2{btnW, btnH}, [this]() {
        showMenu(MenuState::LAYOUTS);
    }, pr32::graphics::ui::TextAlignment::CENTER, menu::BTN_FONT_SIZE);
}

void MenuScene::setupLayoutsMenu() {
    int btnW = menu::BTN_WIDTH;
    int btnH = menu::BTN_HEIGHT;
    
    verticalLayoutButton = std::make_unique<pr32::graphics::ui::UIButton>("VERTICAL LAYOUT", menu::BTN_SELECT, Vector2::ZERO(), Vector2{btnW, btnH}, []() {
        engine.setScene(&verticalLayoutDemoScene);
    }, pr32::graphics::ui::TextAlignment::CENTER, menu::BTN_FONT_SIZE);
    
    horizontalLayoutButton = std::make_unique<pr32::graphics::ui::UIButton>("HORIZONTAL LAYOUT", menu::BTN_SELECT, Vector2::ZERO(), Vector2{btnW, btnH}, []() {
        engine.setScene(&horizontalLayoutDemoScene);
    }, pr32::graphics::ui::TextAlignment::CENTER, menu::BTN_FONT_SIZE);
    
    gridLayoutButton = std::make_unique<pr32::graphics::ui::UIButton>("GRID LAYOUT", menu::BTN_SELECT, Vector2::ZERO(), Vector2{btnW, btnH}, []() {
        engine.setScene(&gridLayoutDemoScene);
    }, pr32::graphics::ui::TextAlignment::CENTER, menu::BTN_FONT_SIZE);
    
    anchorLayoutButton = std::make_unique<pr32::graphics::ui::UIButton>("ANCHOR LAYOUT", menu::BTN_SELECT, Vector2::ZERO(), Vector2{btnW, btnH}, []() {
        engine.setScene(&anchorLayoutDemoScene);
    }, pr32::graphics::ui::TextAlignment::CENTER, menu::BTN_FONT_SIZE);
}

void MenuScene::showMenu(MenuState state) {
    currentState = state;
    
    // Clear all elements from layout
    buttonLayout->clearElements();
    
    // Update title
    int screenWidth = engine.getRenderer().getLogicalWidth();
    
    switch (state) {
        case MenuState::MAIN:
            titleLabel->setText("Main");
            buttonLayout->addElement(gamesButton.get());
            buttonLayout->addElement(physicsDemoButton.get());
            buttonLayout->addElement(cameraDemoButton.get());
#if defined(PIXELROOT32_ENABLE_2BPP_SPRITES) || defined(PIXELROOT32_ENABLE_4BPP_SPRITES)
            buttonLayout->addElement(spritesDemoButton.get());
#endif
#ifdef PIXELROOT32_ENABLE_4BPP_SPRITES
            buttonLayout->addElement(tileMapDemoButton.get());
#endif
            buttonLayout->addElement(fontTestButton.get());
            buttonLayout->addElement(dualPaletteTestButton.get());
            buttonLayout->addElement(uiElementsButton.get());
            break;
            
        case MenuState::GAMES:
            titleLabel->setText("Games");
#ifdef PIXELROOT32_ENABLE_4BPP_SPRITES
            buttonLayout->addElement(metroidvaniaButton.get());
#endif
            buttonLayout->addElement(pongButton.get());
            buttonLayout->addElement(brickBreakerButton.get());
            buttonLayout->addElement(snakeButton.get());
            buttonLayout->addElement(spaceInvadersButton.get());
            buttonLayout->addElement(tttButton.get());
            break;
        
        case MenuState::UIELEMENTS: 
            titleLabel->setText("UIElements");
            buttonLayout->addElement(buttonsButton.get());
            buttonLayout->addElement(labelsButton.get());
            buttonLayout->addElement(checkboxesButton.get());
            buttonLayout->addElement(layoutsButton.get());
            break;
            
        case MenuState::LAYOUTS:
            titleLabel->setText("Layouts");
            buttonLayout->addElement(verticalLayoutButton.get());
            buttonLayout->addElement(horizontalLayoutButton.get());
            buttonLayout->addElement(gridLayoutButton.get());
            buttonLayout->addElement(anchorLayoutButton.get());
            break;
            
        case MenuState::BUTTONS:
        case MenuState::LABELS:
        case MenuState::CHECKBOXES:
            break;
    }
    
    titleLabel->centerX(screenWidth);
}

void MenuScene::goBack() {
    switch (currentState) {
        case MenuState::MAIN:
            // Already at main menu, nothing to do
            break;
        case MenuState::GAMES:
            showMenu(MenuState::MAIN);
            break;
        case MenuState::UIELEMENTS:
            showMenu(MenuState::MAIN);
            break;
        case MenuState::BUTTONS:
        case MenuState::LABELS:
        case MenuState::CHECKBOXES:
        case MenuState::LAYOUTS:
            showMenu(MenuState::UIELEMENTS);
            break;

    }
}