menu.c

// menu.c — see menu.h for the module overview.

#include "menu.h"
#include "context.h"
#include "display.h"
#include "input.h"
#include "audio.h"

// ---- Main menu -----------------------------------------------------------

typedef enum {
    MENU_ITEM_SNAKE = 0,
    MENU_ITEM_TETRIS,
    MENU_ITEM_BRICKS,
    MENU_ITEM_SETTINGS,
    MENU_ITEM_COUNT
} MenuItem;

// TODO: swap for real labels once displayDrawText has a font.
static const char *const s_menuLabels[MENU_ITEM_COUNT] = {
    "Snake",
    "Tetris",
    "Breakout",
    "Settings",
};

static uint8_t s_selectedIndex;
static bool s_dirty;
static bool s_firstDraw;



void menuEnter(void) {
    s_selectedIndex = 0;
    s_dirty = true;
    s_firstDraw = true;
}

void menuUpdate(uint32_t nowMs, uint16_t deltaMs) {
    (void)nowMs; (void)deltaMs;

    bool up = inputIsRepeated(BUTTON_UP);
    bool down = inputIsRepeated(BUTTON_DOWN);

    if (up) {
        s_selectedIndex = (s_selectedIndex == 0) ? (MENU_ITEM_COUNT - 1) : (uint8_t)(s_selectedIndex - 1);
        audioPlaySfxMenuMove();
        s_dirty = true;
    } else if (down) {
        s_selectedIndex = (uint8_t)((s_selectedIndex + 1) % MENU_ITEM_COUNT);
        audioPlaySfxMenuMove();
        s_dirty = true;
    }

    if (inputWasPressed(BUTTON_SELECT) || inputWasPressed(BUTTON_START)) {
        audioPlaySfxMenuSelect();
        switch (s_selectedIndex) {
            case MENU_ITEM_SNAKE:    
                g_context.selectedGameId = GAME_ID_SNAKE;
                contextRequestScreen(SCREEN_GAME_LAUNCHER); break;
            case MENU_ITEM_TETRIS:   
                g_context.selectedGameId = GAME_ID_TETRIS;
                contextRequestScreen(SCREEN_GAME_LAUNCHER); break;
            case MENU_ITEM_BRICKS:     
                g_context.selectedGameId = GAME_ID_BRICKS;
                contextRequestScreen(SCREEN_GAME_LAUNCHER); break;
            case MENU_ITEM_SETTINGS: 
                contextRequestScreen(SCREEN_SETTINGS); break;
        }
    }
}

void menuDraw(void) {
    if (!s_dirty) return;
    s_dirty = false;

    if (s_firstDraw) {
        displayFillScreen(COLOR_BLACK);
        displayDrawTextScaled(10, 4, "MAIN MENU", COLOR_RED, COLOR_BLACK, 2);
        s_firstDraw = false;
    }

    uint8_t rowHeight = 20;
    for (uint8_t i = 0; i < MENU_ITEM_COUNT; i++) {
        uint8_t y = 32 + i * rowHeight;
        
        if (i == s_selectedIndex) {
            displayDrawText(8, y, ">", COLOR_BLUE, COLOR_BLACK);
            displayDrawText(20, y, s_menuLabels[i], COLOR_BLUE, COLOR_BLACK);
        } else {
            displayDrawText(8, y, " ", COLOR_WHITE, COLOR_BLACK); // clear cursor
            displayDrawText(20, y, s_menuLabels[i], COLOR_WHITE, COLOR_BLACK);
        }
    }
}

// ---- Settings screen -------------------------------------------------

typedef enum {
    SETTING_BRIGHTNESS = 0,
    SETTING_VOLUME,
    SETTING_COUNT
} SettingItem;

static uint8_t s_settingIndex;
static bool s_settingsDirty;
static bool s_settingsFirstDraw;

void settingsEnter(void) {
    s_settingIndex = 0;
    s_settingsDirty = true;
    s_settingsFirstDraw = true;
}

void settingsUpdate(uint32_t nowMs, uint16_t deltaMs) {
    (void)nowMs; (void)deltaMs;

    bool up = inputIsRepeated(BUTTON_UP);
    bool down = inputIsRepeated(BUTTON_DOWN);
    bool left = inputIsRepeated(BUTTON_LEFT);
    bool right = inputIsRepeated(BUTTON_RIGHT);

    if (up) {
        s_settingIndex = (s_settingIndex == 0) ? (SETTING_COUNT - 1) : (uint8_t)(s_settingIndex - 1);
        s_settingsDirty = true;
    } else if (down) {
        s_settingIndex = (uint8_t)((s_settingIndex + 1) % SETTING_COUNT);
        s_settingsDirty = true;
    }

    int8_t delta = 0;
    if (right) delta = 5;
    if (left)  delta = -5;

    if (delta != 0) {
        uint8_t *value = (s_settingIndex == SETTING_BRIGHTNESS)
            ? &g_context.settings.brightness
            : &g_context.settings.volume;
        
        int16_t updated = (int16_t)(*value) + delta;
        
        // Prevent backlight from going fully dark (min 10)
        if (s_settingIndex == SETTING_BRIGHTNESS) {
            if (updated < 10)  updated = 10;
        } else {
            if (updated < 0)   updated = 0;
        }
        
        if (updated > 100) updated = 100;
        *value = (uint8_t)updated;
        s_settingsDirty = true;
        
        if (s_settingIndex == SETTING_BRIGHTNESS) {
            audioPlaySfxMenuMove();
        } else {
            audioPlayTone(880, 50); // Beep to test the new volume
        }
    }

    if (inputWasPressed(BUTTON_HOME)) {
        contextRequestScreen(SCREEN_MENU);
    }
}

void settingsDraw(void) {
    if (!s_settingsDirty) return;
    s_settingsDirty = false;

    if (s_settingsFirstDraw) {
        displayFillScreen(COLOR_BLACK);
        displayDrawText(4, 4, "SETTINGS", COLOR_RED, COLOR_BLACK);
        s_settingsFirstDraw = false;
    }

    // Brightness row
    uint8_t yBright = 24;
    if (s_settingIndex == SETTING_BRIGHTNESS) {
        displayFillRect(4, yBright - 2, DISPLAY_WIDTH - 8, 28, COLOR_BLACK);
        displayDrawText(8, yBright + 2, "> Brightness", COLOR_BLUE, COLOR_BLACK);
    } else {
        displayFillRect(4, yBright - 2, DISPLAY_WIDTH - 8, 28, COLOR_BLACK);
        displayDrawText(8, yBright + 2, "  Brightness", COLOR_WHITE, COLOR_BLACK);
    }
    
    // Draw Brightness bar
    uint8_t barWidth = (uint8_t)((uint16_t)g_context.settings.brightness * (DISPLAY_WIDTH - 16) / 100);
    displayFillRect(8, yBright + 12, barWidth, 10, COLOR_WHITE);
    if (barWidth < DISPLAY_WIDTH - 16) {
        displayFillRect(8 + barWidth, yBright + 12, (DISPLAY_WIDTH - 16) - barWidth, 10, 
                         RGB565(50, 50, 50));
    }
    
    // Volume row
    uint8_t yVol = 60;
    if (s_settingIndex == SETTING_VOLUME) {
        displayFillRect(4, yVol - 2, DISPLAY_WIDTH - 8, 28, COLOR_BLACK);
        displayDrawText(8, yVol + 2, "> Volume", COLOR_BLUE, COLOR_BLACK);
    } else {
        displayFillRect(4, yVol - 2, DISPLAY_WIDTH - 8, 28, COLOR_BLACK);
        displayDrawText(8, yVol + 2, "  Volume", COLOR_WHITE, COLOR_BLACK);
    }
    
    uint8_t volVal = g_context.settings.volume;
    uint8_t volDisplay = (volVal > 50) ? (volVal - 50) * 2 : 0;
    barWidth = (uint8_t)((uint16_t)volDisplay * (DISPLAY_WIDTH - 16) / 100);
    
    displayFillRect(8, yVol + 12, barWidth, 10, COLOR_WHITE);
    if (barWidth < DISPLAY_WIDTH - 16) {
        displayFillRect(8 + barWidth, yVol + 12, (DISPLAY_WIDTH - 16) - barWidth, 10, 
                         RGB565(50, 50, 50));
    }
}