logo_01/source/options.h

#pragma once

#include <SDL3/SDL.h> // Para Uint32
#include <string>     // Para string, basic_string
#include "utils.h"    // Para Color, Palette
#include <algorithm>

// Constantes
constexpr int DEFAULT_GAME_WIDTH = 480;                             // Ancho de la ventana por defecto
constexpr int DEFAULT_GAME_HEIGHT = 270;                            // Alto de la ventana por defecto
constexpr Uint64 DEFAUL_LOGO_SPEED = 1000 / 60;                     // Velocidad a la que se ejecuta el logo
constexpr bool DEFAUL_LOGO_RUNNING = true;                          // Flag para el bucle principal
constexpr int DEFAULT_WINDOW_ZOOM = 2;                              // Zoom de la ventana por defecto
constexpr int DEFAULT_VIDEO_FULLSCREEN = false;                     // Modo de pantalla completa por defecto
constexpr SDL_ScaleMode DEFAULT_SCALE_MODE = SDL_SCALEMODE_NEAREST; // Modo de pantalla completa por defecto
constexpr bool DEFAULT_VIDEO_VERTICAL_SYNC = true;                  // Vsync activado por defecto
constexpr bool DEFAULT_VIDEO_INTEGER_SCALE = true;                  // Escalado entero activado por defecto
constexpr bool DEFAULT_VIDEO_KEEP_ASPECT = true;                    // Mantener aspecto activado por defecto
constexpr int DEFAULT_SOUND_VOLUME = 100;                           // Volumen por defecto de los efectos de sonido
constexpr bool DEFAULT_SOUND_ENABLED = true;                        // Sonido habilitado por defecto
constexpr int DEFAULT_MUSIC_VOLUME = 80;                            // Volumen por defecto de la musica
constexpr bool DEFAULT_MUSIC_ENABLED = true;                        // Musica habilitada por defecto
constexpr int DEFAULT_AUDIO_VOLUME = 100;                           // Volumen por defecto
constexpr bool DEFAULT_AUDIO_ENABLED = true;                        // Audio por defecto
constexpr bool DEFAULT_CONSOLE = false;                             // Consola desactivada por defecto
constexpr const char *DEFAULT_WINDOW_CAPTION = "logo_01";           // Versión por defecto

// Estructura con opciones de la ventana
struct OptionsWindow
{
    std::string caption; // Texto que aparece en la barra de titulo de la ventana
    int zoom;            // Zoom de la ventana
    int max_zoom;        // Máximo tamaño de zoom para la ventana

    // Constructor por defecto
    OptionsWindow()
        : caption(DEFAULT_WINDOW_CAPTION),
          zoom(DEFAULT_WINDOW_ZOOM),
          max_zoom(DEFAULT_WINDOW_ZOOM) {}

    // Constructor
    OptionsWindow(std::string caption, int zoom, int max_zoom)
        : caption(caption),
          zoom(zoom),
          max_zoom(max_zoom) {}
};

// Estructura para las opciones de video
struct OptionsVideo
{
    bool fullscreen;          // Contiene el valor del modo de pantalla completav
    SDL_ScaleMode scale_mode; // Filtro usado para el escalado de la imagen
    bool vertical_sync;       // Indica si se quiere usar vsync o no
    bool integer_scale;       // Indica si el escalado de la imagen ha de ser entero en el modo a pantalla completa
    bool keep_aspect;         // Indica si se ha de mantener la relación de aspecto al poner el modo a pantalla completa
    std::string info;         // Información sobre el modo de video

    // Constructor por defecto
    OptionsVideo()
        : fullscreen(DEFAULT_VIDEO_FULLSCREEN),
          scale_mode(DEFAULT_SCALE_MODE),
          vertical_sync(DEFAULT_VIDEO_VERTICAL_SYNC),
          integer_scale(DEFAULT_VIDEO_INTEGER_SCALE),
          keep_aspect(DEFAULT_VIDEO_KEEP_ASPECT),
          info(std::string()) {}

    // Constructor
    OptionsVideo(bool fs, SDL_ScaleMode sm, bool vs, bool is, bool ka, std::string i)
        : fullscreen(fs),
          scale_mode(sm),
          vertical_sync(vs),
          integer_scale(is),
          keep_aspect(ka),
          info(i) {}
};

// Estructura para las opciones de musica
struct OptionsMusic
{
    bool enabled; // Indica si la música suena o no
    int volume;   // Volumen al que suena la música (0 a 128 internamente)

    // Constructor por defecto
    OptionsMusic()
        : enabled(DEFAULT_MUSIC_ENABLED),
          volume(convertVolume(DEFAULT_MUSIC_VOLUME)) {} // Usa el método estático para la conversión

    // Constructor con parámetros
    OptionsMusic(bool e, int v)
        : enabled(e),
          volume(convertVolume(v)) {} // Convierte el volumen usando el método estático

    // Método para establecer el volumen
    void setVolume(int v)
    {
        v = std::clamp(v, 0, 100); // Ajusta v al rango [0, 100]
        volume = convertVolume(v); // Convierte al rango interno
    }

    // Método estático para convertir de 0-100 a 0-128
    static int convertVolume(int v)
    {
        return (v * 128) / 100;
    }
};

// Estructura para las opciones de sonido
struct OptionsSound
{
    bool enabled; // Indica si los sonidos suenan o no
    int volume;   // Volumen al que suenan los sonidos (0 a 128 internamente)

    // Constructor por defecto
    OptionsSound()
        : enabled(DEFAULT_SOUND_ENABLED),
          volume(convertVolume(DEFAULT_SOUND_VOLUME)) {} // Usa el método estático para la conversión

    // Constructor con parámetros
    OptionsSound(bool e, int v)
        : enabled(e),
          volume(convertVolume(v)) {} // También lo integra aquí

    // Método para establecer el volumen
    void setVolume(int v)
    {
        v = std::clamp(v, 0, 100); // Ajusta v al rango [0, 100]
        volume = convertVolume(v); // Convierte al rango interno
    }

    // Método estático para convertir de 0-100 a 0-128
    static int convertVolume(int v)
    {
        return (v * 128) / 100;
    }
};

// Estructura para las opciones de audio
struct OptionsAudio
{
    OptionsMusic music; // Opciones para la música
    OptionsSound sound; // Opciones para los efectos de sonido
    bool enabled;       // Indica si el audio está activo o no
    int volume;         // Volumen al que suenan el audio

    // Constructor por defecto
    OptionsAudio()
        : music(OptionsMusic()),
          sound(OptionsSound()),
          enabled(DEFAULT_AUDIO_ENABLED),
          volume(DEFAULT_AUDIO_VOLUME) {}

    // Constructor
    OptionsAudio(OptionsMusic m, OptionsSound s, bool e, int v)
        : music(m),
          sound(s),
          enabled(e),
          volume(v) {}
};

// Estructura para las opciones del logo
struct OptionsLogo
{
    int width;    // Ancho de la resolucion del logo
    int height;   // Alto de la resolucion del logo
    Uint64 speed; // Velocidad de ejecución del logo
    bool running; // Para gestionar el bucle principal

    // Constructor por defecto
    OptionsLogo()
        : width(DEFAULT_GAME_WIDTH),
          height(DEFAULT_GAME_HEIGHT),
          speed(DEFAUL_LOGO_SPEED),
          running(DEFAUL_LOGO_RUNNING) {}

    // Constructor
    OptionsLogo(int w, int h, Uint64 s, bool r)
        : width(w),
          height(h),
          speed(s),
          running(r) {}
};

// Estructura con todas las opciones de configuración del programa
struct Options
{
    OptionsLogo logo;     // Opciones de juego
    OptionsVideo video;   // Opciones de video
    OptionsWindow window; // Opciones de la ventana
    OptionsAudio audio;   // Opciones del audio

    // Constructor por defecto
    Options()
        : logo(OptionsLogo()),
          video(OptionsVideo()),
          window(OptionsWindow()),
          audio(OptionsAudio()) {}

    // Constructor
    Options(OptionsLogo l, OptionsVideo v, OptionsWindow sw, OptionsAudio a)
        : logo(l),
          video(v),
          window(sw),
          audio(a) {}
};

extern Options options;

// Crea e inicializa las opciones del programa
void initOptions();