Game Config

/* Coded By JD(2026) */
#error "Reference listing only — not provided as build-ready source."
#include "game_config.h"

#include "game_colors.h"
#include "game_graphics.h"
#include "PET2001_font.h"
#include <errno.h>
#include <stdio.h>
#include <string.h>

#define CONFIG_ROOT "/spiffs"
#define CONFIG_LINE_CHARS 64
#define GAME_CONFIG_ROWS 4U
#define GAME_CONFIG_PER_PAGE (GAME_CONFIG_ROWS * 2U)
#define JOYSTICK_ENTER 600
#define JOYSTICK_RELEASE 350
#define REPEAT_START_MS 400U
#define REPEAT_MS 150U

typedef struct {
    const char *name;
    const char *filename;
    bool configured;
} game_config_game_t;

typedef enum { GAME_CONFIG_GAMES, GAME_CONFIG_OPTIONS } game_config_view_t;

static const game_config_game_t games[] = {
    {"CHECKERS", "checkers.cfg", false}, {"OTHELLO", "othello.cfg", false},
    {"CONNECT FOUR", "connect_four.cfg", false}, {"BATTLESHIPS", "battleships.cfg", false},
    {"ASTEROIDS", "asteroids.cfg", false}, {"TEMPEST", "tempest.cfg", false},
    {"INVADERS", "invaders.cfg", true}, {"YAHTZEE", "yahtzee.cfg", false},
    {"BLACKJACK", "blackjack.cfg", false}, {"PIG", "pig.cfg", false},
    {"MISSILE COMMAND", "missile_command.cfg", false}, {"SCRAMBLE", "scramble.cfg", false},
    {"DEFENDER", "defender.cfg", false}, {"GALAGA", "galaga.cfg", false},
    {"DUNGEON", "dungeon.cfg", false},
};

static bool active, waiting_for_centre, repeating;
static game_config_view_t view;
static unsigned selected_game, selected_option;
static int held_direction;
static uint32_t last_move;
static uint8_t invaders_lives;

static const game_config_game_t *selectedGame(void)
{
    return &games[selected_game];
}

static int readInteger(const char *filename, const char *key, int fallback, int minimum, int maximum)
{
    char path[48];
    const int written = snprintf(path, sizeof(path), "%s/%s", CONFIG_ROOT, filename);
    if (written < 0 || (size_t)written >= sizeof(path)) return fallback;
    FILE *file = fopen(path, "rb");
    if (file == NULL) return fallback;

    char line[CONFIG_LINE_CHARS];
    int value = fallback;
    while (fgets(line, sizeof(line), file) != NULL) {
        char found_key[32];
        int candidate;
        if (sscanf(line, " %31[^= ] = %d", found_key, &candidate) != 2) continue;
        if (strcmp(found_key, key) != 0) continue;
        if (candidate >= minimum && candidate <= maximum) value = candidate;
        break;
    }
    fclose(file);
    return value;
}

static bool writeInvadersConfig(uint8_t lives)
{
    const char *final_path = CONFIG_ROOT "/invaders.cfg";
    const char *temporary_path = CONFIG_ROOT "/invaders.tmp";
    FILE *file = fopen(temporary_path, "wb");
    if (file == NULL) return false;
    bool written = fprintf(file, "# Mini Arcade Invaders configuration\n"
                                  "# Remove this file to restore the built-in defaults.\n"
                                  "lives=%u\n", (unsigned)lives) > 0;
    if (fclose(file) != 0) written = false;
    if (!written) {
        remove(temporary_path);
        return false;
    }
    if (rename(temporary_path, final_path) == 0) return true;
    remove(temporary_path);
    return false;
}

uint8_t gameConfigInvadersStartingLives(void)
{
    return (uint8_t)readInteger("invaders.cfg", "lives", 3, 1, 9);
}

void startGameConfig(uint32_t now_ms)
{
    (void)now_ms;
    active = true;
    view = GAME_CONFIG_GAMES;
    selected_game = selected_option = 0U;
    waiting_for_centre = true;
    repeating = false;
    held_direction = 0;
    invaders_lives = gameConfigInvadersStartingLives();
}

void stopGameConfig(void)
{
    active = false;
    held_direction = 0;
}

void gameConfigAction(bool increase, bool decrease, uint32_t now_ms)
{
    (void)now_ms;
    if (!active || (!increase && !decrease)) return;
    if (view == GAME_CONFIG_GAMES) {
        view = GAME_CONFIG_OPTIONS;
        selected_option = 0U;
        invaders_lives = gameConfigInvadersStartingLives();
        return;
    }
    if (!selectedGame()->configured) return;
    if (selected_option == 0U) {
        int next = invaders_lives + (increase ? 1 : -1);
        if (next < 1) next = 1;
        if (next > 9) next = 9;
        if ((uint8_t)next == invaders_lives) return;
        if (writeInvadersConfig((uint8_t)next)) invaders_lives = (uint8_t)next;
    } else if (remove(CONFIG_ROOT "/invaders.cfg") == 0 || errno == ENOENT) {
        invaders_lives = 3U;
    }
}

static void moveGameSelection(int horizontal_direction, int vertical_direction)
{
    const unsigned count = sizeof(games) / sizeof(games[0]);
    const unsigned page_count = (count + GAME_CONFIG_PER_PAGE - 1U) / GAME_CONFIG_PER_PAGE;
    unsigned page = selected_game / GAME_CONFIG_PER_PAGE;
    unsigned column = (selected_game % GAME_CONFIG_PER_PAGE) / GAME_CONFIG_ROWS;
    unsigned row = selected_game % GAME_CONFIG_ROWS;
    unsigned page_items = count - page * GAME_CONFIG_PER_PAGE;
    if (page_items > GAME_CONFIG_PER_PAGE) page_items = GAME_CONFIG_PER_PAGE;
    unsigned rows = page_items > column * GAME_CONFIG_ROWS ? page_items - column * GAME_CONFIG_ROWS : 0U;
    if (rows > GAME_CONFIG_ROWS) rows = GAME_CONFIG_ROWS;

    if (horizontal_direction != 0) {
        const unsigned other_column = column == 0U ? 1U : 0U;
        unsigned other_rows = page_items > other_column * GAME_CONFIG_ROWS ?
            page_items - other_column * GAME_CONFIG_ROWS : 0U;
        if (other_rows > GAME_CONFIG_ROWS) other_rows = GAME_CONFIG_ROWS;
        if (other_rows > 0U) {
            column = other_column;
            if (row >= other_rows) row = other_rows - 1U;
        }
    } else if (vertical_direction != 0) {
        if ((vertical_direction < 0 && row > 0U) ||
            (vertical_direction > 0 && row + 1U < rows)) {
            row = vertical_direction < 0 ? row - 1U : row + 1U;
        } else {
            do {
                page = vertical_direction < 0 ? (page + page_count - 1U) % page_count :
                                                 (page + 1U) % page_count;
                page_items = count - page * GAME_CONFIG_PER_PAGE;
                if (page_items > GAME_CONFIG_PER_PAGE) page_items = GAME_CONFIG_PER_PAGE;
                rows = page_items > column * GAME_CONFIG_ROWS ?
                    page_items - column * GAME_CONFIG_ROWS : 0U;
                if (rows > GAME_CONFIG_ROWS) rows = GAME_CONFIG_ROWS;
            } while (rows == 0U);
            row = vertical_direction < 0 ? rows - 1U : 0U;
        }
    }
    selected_game = page * GAME_CONFIG_PER_PAGE + column * GAME_CONFIG_ROWS + row;
}

void updateGameConfig(int x_offset, int y_offset, bool joystick_valid, uint32_t now_ms)
{
    if (!active) return;
    if (!joystick_valid) { waiting_for_centre = true; held_direction = 0; return; }
    const int x_magnitude = x_offset < 0 ? -x_offset : x_offset;
    const int magnitude = y_offset < 0 ? -y_offset : y_offset;
    if (x_magnitude <= JOYSTICK_RELEASE && magnitude <= JOYSTICK_RELEASE) {
        waiting_for_centre = false;
        held_direction = 0;
        repeating = false;
        return;
    }
    if (waiting_for_centre || (x_magnitude < JOYSTICK_ENTER && magnitude < JOYSTICK_ENTER)) return;
    const bool horizontal = x_magnitude >= magnitude;
    const int direction = horizontal ? (x_offset > 0 ? 1 : -1) : (y_offset > 0 ? -1 : 1);
    const int held = horizontal ? (direction > 0 ? 1 : 2) : (direction < 0 ? 3 : 4);
    if (held == held_direction && now_ms - last_move < (repeating ? REPEAT_MS : REPEAT_START_MS)) return;
    repeating = held == held_direction;
    held_direction = held;
    last_move = now_ms;
    if (view == GAME_CONFIG_GAMES) {
        moveGameSelection(horizontal ? direction : 0, horizontal ? 0 : direction);
    } else if (selectedGame()->configured) {
        selected_option = selected_option == 0U ? 1U : 0U;
    }
}

static void drawGameList(uint16_t *frame)
{
    const unsigned count = sizeof(games) / sizeof(games[0]);
    const unsigned first = selected_game / GAME_CONFIG_PER_PAGE * GAME_CONFIG_PER_PAGE;
    clear(frame, COLOR_BLACK);
    drawPet2001TextCentredTransparent(frame, 160, 4, "GAME CONFIG", COLOR_CYAN, 2);
    for (unsigned index = first; index < count && index < first + GAME_CONFIG_PER_PAGE; ++index) {
        const unsigned position = index - first;
        const int x = position < GAME_CONFIG_ROWS ? 8 : 166;
        const int y = 39 + (int)(position % GAME_CONFIG_ROWS) * 24;
        drawPet2001TextTransparent(frame, x, y, games[index].name,
                                  index == selected_game ? COLOR_CYAN : COLOR_YELLOW, 1);
    }
    drawPet2001TextCentredTransparent(frame, 160, 157,
                                      "STICK SELECT  A/K OPEN  BOOT BACK", COLOR_LIGHTGREY, 1);
}

static void drawGameOptions(uint16_t *frame)
{
    clear(frame, COLOR_BLACK);
    drawPet2001TextCentredTransparent(frame, 160, 4, selectedGame()->name, COLOR_CYAN, 2);
    if (!selectedGame()->configured) {
        drawPet2001TextCentredTransparent(frame, 160, 66, "NO SETTINGS YET", COLOR_YELLOW, 2);
        drawPet2001TextCentredTransparent(frame, 160, 100,
                                          "BUILT-IN DEFAULTS ACTIVE", COLOR_LIGHTGREY, 1);
        drawPet2001TextCentredTransparent(frame, 160, 157, "BOOT BACK", COLOR_LIGHTGREY, 1);
        return;
    }
    char value[24];
    snprintf(value, sizeof(value), "%u", (unsigned)invaders_lives);
    drawPet2001TextTransparent(frame, 16, 43, "STARTING LIVES",
                               selected_option == 0U ? COLOR_CYAN : COLOR_YELLOW, 1);
    drawPet2001TextTransparent(frame, 258, 43, value,
                               selected_option == 0U ? COLOR_CYAN : COLOR_WHITE, 1);
    drawPet2001TextTransparent(frame, 16, 73, "RESTORE DEFAULTS",
                               selected_option == 1U ? COLOR_CYAN : COLOR_YELLOW, 1);
    drawPet2001TextCentredTransparent(frame, 160, 119, "A INCREASE  K DECREASE", COLOR_GREEN, 1);
    drawPet2001TextCentredTransparent(frame, 160, 133, "A/K RESTORES DEFAULTS", COLOR_GREEN, 1);
    drawPet2001TextCentredTransparent(frame, 160, 157, "UP/DOWN SELECT  BOOT BACK", COLOR_LIGHTGREY, 1);
}

void drawGameConfig(uint16_t *frame)
{
    if (!active || frame == NULL) return;
    if (view == GAME_CONFIG_GAMES) drawGameList(frame);
    else drawGameOptions(frame);
}