forked from jaildesigner-jailgames/jaildoctors_dilemma
canviat Options de struct a namespace
This commit is contained in:
@@ -6,10 +6,22 @@
|
||||
#include <string> // Para string, basic_string
|
||||
|
||||
#include "core/rendering/screen.hpp" // Para ScreenFilter
|
||||
#include "utils/utils.hpp" // Para Color, Palette
|
||||
#include "utils/utils.hpp" // Para Color, Palette
|
||||
|
||||
// --- Namespace Options: gestión de configuración y opciones del juego ---
|
||||
namespace Options {
|
||||
|
||||
// =============================================================================
|
||||
// VOLUME HELPERS - Conversión de volumen 0-100 a 0-128
|
||||
// =============================================================================
|
||||
namespace VolumeHelpers {
|
||||
constexpr int convertVolume(int volume_percent) {
|
||||
return (volume_percent * 128) / 100;
|
||||
}
|
||||
} // namespace VolumeHelpers
|
||||
|
||||
// Secciones del programa
|
||||
enum class Section {
|
||||
enum class Scene {
|
||||
LOGO,
|
||||
LOADING_SCREEN,
|
||||
TITLE,
|
||||
@@ -23,7 +35,7 @@ enum class Section {
|
||||
};
|
||||
|
||||
// Subsecciones
|
||||
enum class Subsection {
|
||||
enum class SceneOptions {
|
||||
NONE,
|
||||
LOGO_TO_INTRO,
|
||||
LOGO_TO_TITLE,
|
||||
@@ -54,49 +66,27 @@ enum class ControlScheme {
|
||||
WASD
|
||||
};
|
||||
|
||||
// Constantes
|
||||
constexpr int DEFAULT_GAME_WIDTH = 256; // Ancho de la ventana por defecto
|
||||
constexpr int DEFAULT_GAME_HEIGHT = 192; // Alto de la ventana por defecto
|
||||
constexpr int DEFAULT_WINDOW_ZOOM = 2; // Zoom de la ventana por defecto
|
||||
constexpr bool DEFAULT_VIDEO_MODE = false; // Modo de pantalla completa por defecto
|
||||
constexpr ScreenFilter DEFAULT_VIDEO_FILTER = ScreenFilter::NEAREST; // Filtro por defecto
|
||||
constexpr bool DEFAULT_VIDEO_VERTICAL_SYNC = true; // Vsync activado por defecto
|
||||
constexpr bool DEFAULT_VIDEO_SHADERS = false; // Shaders desactivados 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 bool DEFAULT_BORDER_ENABLED = true; // Borde activado por defecto
|
||||
constexpr int DEFAULT_BORDER_WIDTH = 32; // Ancho del borde por defecto
|
||||
constexpr int DEFAULT_BORDER_HEIGHT = 24; // Alto del borde 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 const char* DEFAULT_PALETTE = "zx-spectrum"; // Paleta por defecto
|
||||
constexpr Section DEFAULT_SECTION = Section::LOGO; // Sección por defecto
|
||||
constexpr Subsection DEFAULT_SUBSECTION = Subsection::LOGO_TO_INTRO; // Subsección por defecto
|
||||
constexpr ControlScheme DEFAULT_CONTROL_SCHEME = ControlScheme::CURSOR; // Control por defecto
|
||||
constexpr NotificationPosition DEFAULT_NOTIFICATION_POSITION = NotificationPosition::UPPER_LEFT; // Posición de las notificaciones por defecto
|
||||
constexpr bool DEFAULT_NOTIFICATION_SOUND = true; // Sonido de las notificaciones por defecto
|
||||
const Uint8 DEFAULT_NOTIFICATION_COLOR = static_cast<Uint8>(PaletteColor::BLUE); // Color de las notificaciones por defecto
|
||||
constexpr bool DEFAULT_CONSOLE = false; // Consola desactivada por defecto
|
||||
constexpr const char* DEFAULT_VERSION = "1.10"; // Versión por defecto
|
||||
} // namespace Options
|
||||
|
||||
// Incluir constantes por defecto después de declarar los enums
|
||||
#include "game/gameplay/defaults.hpp"
|
||||
|
||||
namespace Options {
|
||||
|
||||
// Estructura para las opciones de las notificaciones
|
||||
struct OptionsNotification {
|
||||
struct Notification {
|
||||
NotificationPosition pos; // Ubicación de las notificaciones en pantalla
|
||||
bool sound; // Indica si las notificaciones suenan
|
||||
Uint8 color; // Color de las notificaciones
|
||||
|
||||
// Constructor por defecto
|
||||
OptionsNotification()
|
||||
: pos(DEFAULT_NOTIFICATION_POSITION),
|
||||
sound(DEFAULT_NOTIFICATION_SOUND),
|
||||
color(DEFAULT_NOTIFICATION_COLOR) {}
|
||||
Notification()
|
||||
: pos(GameDefaults::NOTIFICATION_POSITION),
|
||||
sound(GameDefaults::NOTIFICATION_SOUND),
|
||||
color(GameDefaults::NOTIFICATION_COLOR) {}
|
||||
|
||||
// Constructor
|
||||
OptionsNotification(NotificationPosition p, bool s, Uint8 c)
|
||||
Notification(NotificationPosition p, bool s, Uint8 c)
|
||||
: pos(p),
|
||||
sound(s),
|
||||
color(c) {}
|
||||
@@ -116,7 +106,6 @@ struct OptionsNotification {
|
||||
default:
|
||||
return NotificationPosition::UNKNOWN;
|
||||
}
|
||||
return NotificationPosition::UNKNOWN;
|
||||
}
|
||||
|
||||
// Método que devuelve la posición vertical
|
||||
@@ -133,94 +122,95 @@ struct OptionsNotification {
|
||||
default:
|
||||
return NotificationPosition::UNKNOWN;
|
||||
}
|
||||
return NotificationPosition::UNKNOWN;
|
||||
}
|
||||
};
|
||||
|
||||
// Estructura para saber la seccion y subseccion del programa
|
||||
struct SectionState {
|
||||
Section section;
|
||||
Subsection subsection;
|
||||
struct SceneState {
|
||||
Scene section;
|
||||
SceneOptions subsection;
|
||||
|
||||
// Constructor por defecto
|
||||
SectionState()
|
||||
: section(DEFAULT_SECTION),
|
||||
subsection(DEFAULT_SUBSECTION) {}
|
||||
SceneState()
|
||||
: section(GameDefaults::SCENE),
|
||||
subsection(GameDefaults::SUBSECTION) {}
|
||||
|
||||
// Constructor
|
||||
SectionState(Section s, Subsection ss)
|
||||
: section(s),
|
||||
subsection(ss) {}
|
||||
SceneState(Scene scene, SceneOptions scene_options)
|
||||
: section(scene),
|
||||
subsection(scene_options) {}
|
||||
};
|
||||
|
||||
// Estructura para albergar trucos
|
||||
struct Cheat {
|
||||
enum class CheatState : bool {
|
||||
enum class State : bool {
|
||||
DISABLED = false,
|
||||
ENABLED = true
|
||||
};
|
||||
|
||||
CheatState infinite_lives; // Indica si el jugador dispone de vidas infinitas
|
||||
CheatState invincible; // Indica si el jugador puede morir
|
||||
CheatState jail_is_open; // Indica si la Jail está abierta
|
||||
CheatState alternate_skin; // Indica si se usa una skin diferente para el jugador
|
||||
State infinite_lives; // Indica si el jugador dispone de vidas infinitas
|
||||
State invincible; // Indica si el jugador puede morir
|
||||
State jail_is_open; // Indica si la Jail está abierta
|
||||
State alternate_skin; // Indica si se usa una skin diferente para el jugador
|
||||
|
||||
// Constructor por defecto
|
||||
Cheat()
|
||||
: infinite_lives(CheatState::DISABLED),
|
||||
invincible(CheatState::DISABLED),
|
||||
jail_is_open(CheatState::DISABLED),
|
||||
alternate_skin(CheatState::DISABLED) {}
|
||||
: infinite_lives(State::DISABLED),
|
||||
invincible(State::DISABLED),
|
||||
jail_is_open(State::DISABLED),
|
||||
alternate_skin(State::DISABLED) {}
|
||||
|
||||
// Constructor
|
||||
Cheat(CheatState il, CheatState i, CheatState je, CheatState as)
|
||||
: infinite_lives(il),
|
||||
invincible(i),
|
||||
jail_is_open(je),
|
||||
alternate_skin(as) {}
|
||||
Cheat(State inf_lives, State is_invincible, State jail_enabled, State alt_skin)
|
||||
: infinite_lives(inf_lives),
|
||||
invincible(is_invincible),
|
||||
jail_is_open(jail_enabled),
|
||||
alternate_skin(alt_skin) {}
|
||||
|
||||
// Método para comprobar si alguno de los tres primeros trucos está activo
|
||||
bool enabled() const {
|
||||
return infinite_lives == CheatState::ENABLED ||
|
||||
invincible == CheatState::ENABLED ||
|
||||
jail_is_open == CheatState::ENABLED;
|
||||
return infinite_lives == State::ENABLED ||
|
||||
invincible == State::ENABLED ||
|
||||
jail_is_open == State::ENABLED;
|
||||
}
|
||||
};
|
||||
|
||||
// Estructura para almacenar estadísticas
|
||||
struct OptionsStats {
|
||||
struct Stats {
|
||||
int rooms; // Cantidad de habitaciones visitadas
|
||||
int items; // Cantidad de items obtenidos
|
||||
std::string worst_nightmare; // Habitación con más muertes acumuladas
|
||||
|
||||
// Constructor por defecto
|
||||
OptionsStats()
|
||||
Stats()
|
||||
: rooms(0),
|
||||
items(0),
|
||||
worst_nightmare("") {}
|
||||
|
||||
// Constructor
|
||||
OptionsStats(int r, int i, const std::string& wn)
|
||||
: rooms(r),
|
||||
items(i),
|
||||
worst_nightmare(wn) {}
|
||||
Stats(int room_count, int item_count, const std::string& worst_nightmare_room)
|
||||
: rooms(room_count),
|
||||
items(item_count),
|
||||
worst_nightmare(worst_nightmare_room) {}
|
||||
};
|
||||
|
||||
// Estructura con opciones de la ventana
|
||||
struct OptionsWindow {
|
||||
std::string caption = "JailDoctor's Dilemma"; // Texto que aparece en la barra de título de la ventana
|
||||
int zoom; // Zoom de la ventana
|
||||
int max_zoom; // Máximo tamaño de zoom para la ventana
|
||||
struct Window {
|
||||
std::string caption; // Texto que aparece en la barra de título 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()
|
||||
: zoom(DEFAULT_WINDOW_ZOOM),
|
||||
max_zoom(DEFAULT_WINDOW_ZOOM) {}
|
||||
Window()
|
||||
: caption("JailDoctor's Dilemma"),
|
||||
zoom(GameDefaults::WINDOW_ZOOM),
|
||||
max_zoom(GameDefaults::WINDOW_ZOOM) {}
|
||||
|
||||
// Constructor
|
||||
OptionsWindow(int z, int mz)
|
||||
: zoom(z),
|
||||
max_zoom(mz) {}
|
||||
Window(int window_zoom, int maximum_zoom)
|
||||
: caption("JailDoctor's Dilemma"),
|
||||
zoom(window_zoom),
|
||||
max_zoom(maximum_zoom) {}
|
||||
};
|
||||
|
||||
// Estructura para gestionar el borde de la pantalla
|
||||
@@ -231,19 +221,19 @@ struct Border {
|
||||
|
||||
// Constructor por defecto
|
||||
Border()
|
||||
: enabled(DEFAULT_BORDER_ENABLED),
|
||||
width(DEFAULT_BORDER_WIDTH),
|
||||
height(DEFAULT_BORDER_HEIGHT) {}
|
||||
: enabled(GameDefaults::BORDER_ENABLED),
|
||||
width(GameDefaults::BORDER_WIDTH),
|
||||
height(GameDefaults::BORDER_HEIGHT) {}
|
||||
|
||||
// Constructor
|
||||
Border(bool e, float w, float h)
|
||||
: enabled(e),
|
||||
width(w),
|
||||
height(h) {}
|
||||
Border(bool is_enabled, float border_width, float border_height)
|
||||
: enabled(is_enabled),
|
||||
width(border_width),
|
||||
height(border_height) {}
|
||||
};
|
||||
|
||||
// Estructura para las opciones de video
|
||||
struct OptionsVideo {
|
||||
struct Video {
|
||||
bool fullscreen; // Contiene el valor del modo de pantalla completa
|
||||
ScreenFilter filter; // Filtro usado para el escalado de la imagen
|
||||
bool vertical_sync; // Indica si se quiere usar vsync o no
|
||||
@@ -255,170 +245,128 @@ struct OptionsVideo {
|
||||
std::string info; // Información sobre el modo de vídeo
|
||||
|
||||
// Constructor por defecto
|
||||
OptionsVideo()
|
||||
: fullscreen(DEFAULT_VIDEO_MODE),
|
||||
filter(DEFAULT_VIDEO_FILTER),
|
||||
vertical_sync(DEFAULT_VIDEO_VERTICAL_SYNC),
|
||||
shaders(DEFAULT_VIDEO_SHADERS),
|
||||
integer_scale(DEFAULT_VIDEO_INTEGER_SCALE),
|
||||
keep_aspect(DEFAULT_VIDEO_KEEP_ASPECT),
|
||||
Video()
|
||||
: fullscreen(GameDefaults::VIDEO_MODE),
|
||||
filter(GameDefaults::VIDEO_FILTER),
|
||||
vertical_sync(GameDefaults::VIDEO_VERTICAL_SYNC),
|
||||
shaders(GameDefaults::VIDEO_SHADERS),
|
||||
integer_scale(GameDefaults::VIDEO_INTEGER_SCALE),
|
||||
keep_aspect(GameDefaults::VIDEO_KEEP_ASPECT),
|
||||
border(Border()),
|
||||
palette(DEFAULT_PALETTE) {}
|
||||
palette(GameDefaults::PALETTE_NAME),
|
||||
info("") {}
|
||||
|
||||
// Constructor
|
||||
OptionsVideo(Uint32 m, ScreenFilter f, bool vs, bool s, bool is, bool ka, Border b, const std::string& p)
|
||||
: fullscreen(m),
|
||||
filter(f),
|
||||
vertical_sync(vs),
|
||||
shaders(s),
|
||||
integer_scale(is),
|
||||
keep_aspect(ka),
|
||||
border(b),
|
||||
palette(p) {}
|
||||
Video(bool is_fullscreen, ScreenFilter screen_filter, bool vsync, bool use_shaders, bool int_scale, bool keep_aspect_ratio, Border video_border, const std::string& palette_name)
|
||||
: fullscreen(is_fullscreen),
|
||||
filter(screen_filter),
|
||||
vertical_sync(vsync),
|
||||
shaders(use_shaders),
|
||||
integer_scale(int_scale),
|
||||
keep_aspect(keep_aspect_ratio),
|
||||
border(video_border),
|
||||
palette(palette_name),
|
||||
info("") {}
|
||||
};
|
||||
|
||||
// Estructura para las opciones de musica
|
||||
struct OptionsMusic {
|
||||
struct Music {
|
||||
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
|
||||
Music()
|
||||
: enabled(GameDefaults::MUSIC_ENABLED),
|
||||
volume(VolumeHelpers::convertVolume(GameDefaults::MUSIC_VOLUME)) {}
|
||||
|
||||
// Constructor con parámetros
|
||||
OptionsMusic(bool e, int v)
|
||||
: enabled(e),
|
||||
volume(convertVolume(v)) {} // Convierte el volumen usando el método estático
|
||||
Music(bool is_enabled, int volume_percent)
|
||||
: enabled(is_enabled),
|
||||
volume(VolumeHelpers::convertVolume(volume_percent)) {}
|
||||
|
||||
// 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;
|
||||
void setVolume(int volume_percent) {
|
||||
volume_percent = std::clamp(volume_percent, 0, 100);
|
||||
volume = VolumeHelpers::convertVolume(volume_percent);
|
||||
}
|
||||
};
|
||||
|
||||
// Estructura para las opciones de sonido
|
||||
struct OptionsSound {
|
||||
struct Sound {
|
||||
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
|
||||
Sound()
|
||||
: enabled(GameDefaults::SOUND_ENABLED),
|
||||
volume(VolumeHelpers::convertVolume(GameDefaults::SOUND_VOLUME)) {}
|
||||
|
||||
// Constructor con parámetros
|
||||
OptionsSound(bool e, int v)
|
||||
: enabled(e),
|
||||
volume(convertVolume(v)) {} // También lo integra aquí
|
||||
Sound(bool is_enabled, int volume_percent)
|
||||
: enabled(is_enabled),
|
||||
volume(VolumeHelpers::convertVolume(volume_percent)) {}
|
||||
|
||||
// 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;
|
||||
void setVolume(int volume_percent) {
|
||||
volume_percent = std::clamp(volume_percent, 0, 100);
|
||||
volume = VolumeHelpers::convertVolume(volume_percent);
|
||||
}
|
||||
};
|
||||
|
||||
// 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
|
||||
struct Audio {
|
||||
Music music; // Opciones para la música
|
||||
Sound 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 (0-128 internamente)
|
||||
|
||||
// Constructor por defecto
|
||||
OptionsAudio()
|
||||
: music(OptionsMusic()),
|
||||
sound(OptionsSound()),
|
||||
enabled(DEFAULT_AUDIO_ENABLED),
|
||||
volume(DEFAULT_AUDIO_VOLUME) {}
|
||||
Audio()
|
||||
: music(Music()),
|
||||
sound(Sound()),
|
||||
enabled(GameDefaults::AUDIO_ENABLED),
|
||||
volume(VolumeHelpers::convertVolume(GameDefaults::AUDIO_VOLUME)) {}
|
||||
|
||||
// Constructor
|
||||
OptionsAudio(OptionsMusic m, OptionsSound s, bool e, int v)
|
||||
: music(m),
|
||||
sound(s),
|
||||
enabled(e),
|
||||
volume(v) {}
|
||||
Audio(Music audio_music, Sound audio_sound, bool is_enabled, int volume_percent)
|
||||
: music(audio_music),
|
||||
sound(audio_sound),
|
||||
enabled(is_enabled),
|
||||
volume(VolumeHelpers::convertVolume(volume_percent)) {}
|
||||
};
|
||||
|
||||
// Estructura para las opciones de juego
|
||||
struct OptionsGame {
|
||||
struct Game {
|
||||
float width; // Ancho de la resolucion del juego
|
||||
float height; // Alto de la resolucion del juego
|
||||
|
||||
// Constructor por defecto
|
||||
OptionsGame()
|
||||
: width(DEFAULT_GAME_WIDTH),
|
||||
height(DEFAULT_GAME_HEIGHT) {}
|
||||
Game()
|
||||
: width(GameDefaults::GAME_WIDTH),
|
||||
height(GameDefaults::GAME_HEIGHT) {}
|
||||
|
||||
// Constructor
|
||||
OptionsGame(float w, float h)
|
||||
: width(w),
|
||||
height(h) {}
|
||||
Game(float game_width, float game_height)
|
||||
: width(game_width),
|
||||
height(game_height) {}
|
||||
};
|
||||
|
||||
// Estructura con todas las opciones de configuración del programa
|
||||
struct Options {
|
||||
std::string version; // Versión del fichero de configuración. Sirve para saber si las opciones son compatibles
|
||||
bool console; // Indica si ha de mostrar información por la consola de texto
|
||||
Cheat cheats; // Contiene trucos y ventajas para el juego
|
||||
OptionsGame game; // Opciones de juego
|
||||
OptionsVideo video; // Opciones de video
|
||||
OptionsStats stats; // Datos con las estadisticas de juego
|
||||
OptionsNotification notifications; // Opciones relativas a las notificaciones;
|
||||
OptionsWindow window; // Opciones relativas a la ventana
|
||||
OptionsAudio audio; // Opciones relativas al audio
|
||||
ControlScheme keys; // Teclas usadas para jugar
|
||||
SectionState section; // Sección actual del programa
|
||||
// --- Variables ---
|
||||
extern std::string version; // Versión del fichero de configuración. Sirve para saber si las opciones son compatibles
|
||||
extern bool console; // Indica si ha de mostrar información por la consola de texto
|
||||
extern Cheat cheats; // Contiene trucos y ventajas para el juego
|
||||
extern Game game; // Opciones de juego
|
||||
extern Video video; // Opciones de video
|
||||
extern Stats stats; // Datos con las estadisticas de juego
|
||||
extern Notification notifications; // Opciones relativas a las notificaciones;
|
||||
extern Window window; // Opciones relativas a la ventana
|
||||
extern Audio audio; // Opciones relativas al audio
|
||||
extern ControlScheme keys; // Teclas usadas para jugar
|
||||
extern SceneState section; // Sección actual del programa
|
||||
|
||||
// Constructor por defecto
|
||||
Options()
|
||||
: version(DEFAULT_VERSION),
|
||||
console(DEFAULT_CONSOLE),
|
||||
cheats(Cheat()),
|
||||
game(OptionsGame()),
|
||||
video(OptionsVideo()),
|
||||
stats(OptionsStats()),
|
||||
notifications(OptionsNotification()),
|
||||
window(OptionsWindow()),
|
||||
audio(OptionsAudio()),
|
||||
keys(DEFAULT_CONTROL_SCHEME),
|
||||
section(SectionState()) {}
|
||||
// --- Funciones ---
|
||||
void init(); // Crea e inicializa las opciones del programa
|
||||
bool loadFromFile(const std::string& file_path); // Carga las opciones desde un fichero
|
||||
bool saveToFile(const std::string& file_path); // Guarda las opciones a un fichero
|
||||
|
||||
// Constructor
|
||||
Options(std::string cv, bool c, Cheat ch, OptionsGame g, OptionsVideo v, OptionsStats s, OptionsNotification n, OptionsWindow sw, OptionsAudio a, ControlScheme k, SectionState sec)
|
||||
: version(cv),
|
||||
console(c),
|
||||
cheats(ch),
|
||||
game(g),
|
||||
video(v),
|
||||
stats(s),
|
||||
notifications(n),
|
||||
window(sw),
|
||||
audio(a),
|
||||
keys(k),
|
||||
section(sec) {}
|
||||
};
|
||||
|
||||
extern Options options;
|
||||
|
||||
// Crea e inicializa las opciones del programa
|
||||
void initOptions();
|
||||
|
||||
// Carga las opciones desde un fichero
|
||||
bool loadOptionsFromFile(const std::string& file_path);
|
||||
|
||||
// Guarda las opciones a un fichero
|
||||
bool saveOptionsToFile(const std::string& file_path);
|
||||
} // namespace Options
|
||||
Reference in New Issue
Block a user