jaildesigner-jailgames/coffee-crisis-ae
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 15 Wiki Activity

neteja clang-tidy

Browse Source
This commit is contained in:
Sergio Valor
2026-05-16 22:47:41 +02:00
parent 17341f923d
commit a903343385
40 changed files with 1246 additions and 1384 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/game/options.cpp
+120 -235
View File
@@ -26,12 +26,12 @@ namespace Options {
Keyboard keyboard; // Opciones para el teclado
PendingChanges pending_changes; // Opciones que se aplican al cerrar
std::vector<PostFXPreset> postfx_presets = {
{"CRT", 0.15F, 0.7F, 0.2F, 0.5F, 0.1F, 0.0F, 0.0F, 0.0F},
{"NTSC", 0.4F, 0.5F, 0.2F, 0.3F, 0.3F, 0.0F, 0.6F, 0.0F},
{"Curved", 0.5F, 0.6F, 0.1F, 0.4F, 0.4F, 0.8F, 0.0F, 0.0F},
{"Scanlines", 0.0F, 0.8F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F},
{"Subtle", 0.3F, 0.4F, 0.05F, 0.0F, 0.2F, 0.0F, 0.0F, 0.0F},
{"CRT Live", 0.15F, 0.6F, 0.3F, 0.3F, 0.1F, 0.0F, 0.4F, 0.8F},
{.name = "CRT", .vignette = 0.15F, .scanlines = 0.7F, .chroma = 0.2F, .mask = 0.5F, .gamma = 0.1F, .curvature = 0.0F, .bleeding = 0.0F, .flicker = 0.0F},
{.name = "NTSC", .vignette = 0.4F, .scanlines = 0.5F, .chroma = 0.2F, .mask = 0.3F, .gamma = 0.3F, .curvature = 0.0F, .bleeding = 0.6F, .flicker = 0.0F},
{.name = "Curved", .vignette = 0.5F, .scanlines = 0.6F, .chroma = 0.1F, .mask = 0.4F, .gamma = 0.4F, .curvature = 0.8F, .bleeding = 0.0F, .flicker = 0.0F},
{.name = "Scanlines", .vignette = 0.0F, .scanlines = 0.8F, .chroma = 0.0F, .mask = 0.0F, .gamma = 0.0F, .curvature = 0.0F, .bleeding = 0.0F, .flicker = 0.0F},
{.name = "Subtle", .vignette = 0.3F, .scanlines = 0.4F, .chroma = 0.05F, .mask = 0.0F, .gamma = 0.2F, .curvature = 0.0F, .bleeding = 0.0F, .flicker = 0.0F},
{.name = "CRT Live", .vignette = 0.15F, .scanlines = 0.6F, .chroma = 0.3F, .mask = 0.3F, .gamma = 0.1F, .curvature = 0.0F, .bleeding = 0.4F, .flicker = 0.8F},
};
std::string postfx_file_path;
std::vector<CrtPiPreset> crtpi_presets;
@@ -50,11 +50,17 @@ namespace Options {
void setCrtPiFile(const std::string& path) { crtpi_file_path = path; }
// Helper: extrae un campo float de un nodo YAML si existe, ignorando errores de conversión
static void parseFloatField(const fkyaml::node& node, const std::string& key, float& target) {
if (node.contains(key)) {
try {
target = node[key].get_value<float>();
} catch (...) {}
// Llig un camp opcional d'un node YAML. Si no existeix, no toca `target`.
// Si existeix però el tipus no encaixa, manté el valor previ i avisa per stderr
// (un fitxer de configuració parcialment malformat no ha de tombar l'arrencada,
// però l'usuari ha de saber quin camp ha quedat ignorat).
template <typename T>
void parseField(const fkyaml::node& node, const std::string& key, T& target) {
if (!node.contains(key)) { return; }
try {
target = node[key].get_value<T>();
} catch (...) {
std::cerr << "config YAML: valor invàlid per a '" << key << "', es manté el valor per defecte\n";
}
}
@@ -80,14 +86,14 @@ namespace Options {
if (p.contains("name")) {
preset.name = p["name"].get_value<std::string>();
}
parseFloatField(p, "vignette", preset.vignette);
parseFloatField(p, "scanlines", preset.scanlines);
parseFloatField(p, "chroma", preset.chroma);
parseFloatField(p, "mask", preset.mask);
parseFloatField(p, "gamma", preset.gamma);
parseFloatField(p, "curvature", preset.curvature);
parseFloatField(p, "bleeding", preset.bleeding);
parseFloatField(p, "flicker", preset.flicker);
parseField(p, "vignette", preset.vignette);
parseField(p, "scanlines", preset.scanlines);
parseField(p, "chroma", preset.chroma);
parseField(p, "mask", preset.mask);
parseField(p, "gamma", preset.gamma);
parseField(p, "curvature", preset.curvature);
parseField(p, "bleeding", preset.bleeding);
parseField(p, "flicker", preset.flicker);
postfx_presets.push_back(preset);
}
}
@@ -212,24 +218,6 @@ namespace Options {
return true;
}
// Helper: extrae un campo bool de un nodo YAML si existe, ignorando errores
static void parseBoolField(const fkyaml::node& node, const std::string& key, bool& target) {
if (node.contains(key)) {
try {
target = node[key].get_value<bool>();
} catch (...) {}
}
}
// Helper: extrae un campo int de un nodo YAML si existe, ignorando errores
static void parseIntField(const fkyaml::node& node, const std::string& key, int& target) {
if (node.contains(key)) {
try {
target = node[key].get_value<int>();
} catch (...) {}
}
}
// Rellena los presets CrtPi por defecto
static void populateDefaultCrtPiPresets() {
crtpi_presets.clear();
@@ -289,20 +277,20 @@ namespace Options {
if (p.contains("name")) {
preset.name = p["name"].get_value<std::string>();
}
parseFloatField(p, "scanline_weight", preset.scanline_weight);
parseFloatField(p, "scanline_gap_brightness", preset.scanline_gap_brightness);
parseFloatField(p, "bloom_factor", preset.bloom_factor);
parseFloatField(p, "input_gamma", preset.input_gamma);
parseFloatField(p, "output_gamma", preset.output_gamma);
parseFloatField(p, "mask_brightness", preset.mask_brightness);
parseFloatField(p, "curvature_x", preset.curvature_x);
parseFloatField(p, "curvature_y", preset.curvature_y);
parseIntField(p, "mask_type", preset.mask_type);
parseBoolField(p, "enable_scanlines", preset.enable_scanlines);
parseBoolField(p, "enable_multisample", preset.enable_multisample);
parseBoolField(p, "enable_gamma", preset.enable_gamma);
parseBoolField(p, "enable_curvature", preset.enable_curvature);
parseBoolField(p, "enable_sharper", preset.enable_sharper);
parseField(p, "scanline_weight", preset.scanline_weight);
parseField(p, "scanline_gap_brightness", preset.scanline_gap_brightness);
parseField(p, "bloom_factor", preset.bloom_factor);
parseField(p, "input_gamma", preset.input_gamma);
parseField(p, "output_gamma", preset.output_gamma);
parseField(p, "mask_brightness", preset.mask_brightness);
parseField(p, "curvature_x", preset.curvature_x);
parseField(p, "curvature_y", preset.curvature_y);
parseField(p, "mask_type", preset.mask_type);
parseField(p, "enable_scanlines", preset.enable_scanlines);
parseField(p, "enable_multisample", preset.enable_multisample);
parseField(p, "enable_gamma", preset.enable_gamma);
parseField(p, "enable_curvature", preset.enable_curvature);
parseField(p, "enable_sharper", preset.enable_sharper);
crtpi_presets.push_back(preset);
}
}
@@ -353,98 +341,46 @@ namespace Options {
void loadWindowFromYaml(const fkyaml::node& yaml) {
if (!yaml.contains("window")) { return; }
const auto& win = yaml["window"];
if (win.contains("zoom")) {
try {
int val = win["zoom"].get_value<int>();
window.zoom = (val > 0) ? val : window.zoom;
} catch (...) {}
}
int zoom = window.zoom;
parseField(win, "zoom", zoom);
window.zoom = (zoom > 0) ? zoom : window.zoom;
}
void loadVideoFromYaml(const fkyaml::node& yaml) {
if (!yaml.contains("video")) { return; }
const auto& vid = yaml["video"];
if (vid.contains("fullscreen")) {
try {
video.fullscreen = vid["fullscreen"].get_value<bool>();
} catch (...) {}
}
if (vid.contains("scale_mode")) {
try {
video.scale_mode = static_cast<SDL_ScaleMode>(vid["scale_mode"].get_value<int>());
} catch (...) {}
}
if (vid.contains("vsync")) {
try {
video.vsync = vid["vsync"].get_value<bool>();
} catch (...) {}
}
if (vid.contains("integer_scale")) {
try {
video.integer_scale = vid["integer_scale"].get_value<bool>();
} catch (...) {}
}
parseField(vid, "fullscreen", video.fullscreen);
parseField(vid, "vsync", video.vsync);
parseField(vid, "integer_scale", video.integer_scale);
int scale_mode_int = static_cast<int>(video.scale_mode);
parseField(vid, "scale_mode", scale_mode_int);
video.scale_mode = static_cast<SDL_ScaleMode>(scale_mode_int);
// --- GPU ---
if (vid.contains("gpu")) {
const auto& gpu_node = vid["gpu"];
if (gpu_node.contains("acceleration")) {
try {
video.gpu.acceleration = gpu_node["acceleration"].get_value<bool>();
} catch (...) {}
}
if (gpu_node.contains("preferred_driver")) {
try {
video.gpu.preferred_driver = gpu_node["preferred_driver"].get_value<std::string>();
} catch (...) {}
}
parseField(gpu_node, "acceleration", video.gpu.acceleration);
parseField(gpu_node, "preferred_driver", video.gpu.preferred_driver);
}
// --- Shader config ---
if (vid.contains("shader")) {
const auto& sh = vid["shader"];
if (sh.contains("enabled")) {
try {
video.shader.enabled = sh["enabled"].get_value<bool>();
} catch (...) {}
}
if (sh.contains("current_shader")) {
try {
auto s = sh["current_shader"].get_value<std::string>();
video.shader.current_shader = (s == "crtpi") ? Rendering::ShaderType::CRTPI : Rendering::ShaderType::POSTFX;
} catch (...) {}
}
if (sh.contains("postfx_preset")) {
try {
video.shader.current_postfx_preset_name = sh["postfx_preset"].get_value<std::string>();
} catch (...) {}
}
if (sh.contains("crtpi_preset")) {
try {
video.shader.current_crtpi_preset_name = sh["crtpi_preset"].get_value<std::string>();
} catch (...) {}
parseField(sh, "enabled", video.shader.enabled);
parseField(sh, "postfx_preset", video.shader.current_postfx_preset_name);
parseField(sh, "crtpi_preset", video.shader.current_crtpi_preset_name);
std::string shader_name;
parseField(sh, "current_shader", shader_name);
if (!shader_name.empty()) {
video.shader.current_shader = (shader_name == "crtpi") ? Rendering::ShaderType::CRTPI : Rendering::ShaderType::POSTFX;
}
}
// --- Supersampling ---
if (vid.contains("supersampling")) {
const auto& ss_node = vid["supersampling"];
if (ss_node.contains("enabled")) {
try {
video.supersampling.enabled = ss_node["enabled"].get_value<bool>();
} catch (...) {}
}
if (ss_node.contains("linear_upscale")) {
try {
video.supersampling.linear_upscale = ss_node["linear_upscale"].get_value<bool>();
} catch (...) {}
}
if (ss_node.contains("downscale_algo")) {
try {
video.supersampling.downscale_algo = ss_node["downscale_algo"].get_value<int>();
} catch (...) {}
}
parseField(ss_node, "enabled", video.supersampling.enabled);
parseField(ss_node, "linear_upscale", video.supersampling.linear_upscale);
parseField(ss_node, "downscale_algo", video.supersampling.downscale_algo);
}
}
@@ -452,50 +388,30 @@ namespace Options {
if (!yaml.contains("audio")) { return; }
const auto& aud = yaml["audio"];
if (aud.contains("enabled")) {
try {
audio.enabled = aud["enabled"].get_value<bool>();
} catch (...) {}
}
if (aud.contains("volume")) {
try {
audio.volume = std::clamp(aud["volume"].get_value<float>(), 0.0F, 1.0F);
} catch (...) {}
}
parseField(aud, "enabled", audio.enabled);
parseField(aud, "volume", audio.volume);
audio.volume = std::clamp(audio.volume, 0.0F, 1.0F);
if (aud.contains("music")) {
const auto& mus = aud["music"];
if (mus.contains("enabled")) {
try {
audio.music.enabled = mus["enabled"].get_value<bool>();
} catch (...) {}
}
if (mus.contains("volume")) {
try {
audio.music.volume = std::clamp(mus["volume"].get_value<float>(), 0.0F, 1.0F);
} catch (...) {}
}
parseField(mus, "enabled", audio.music.enabled);
parseField(mus, "volume", audio.music.volume);
audio.music.volume = std::clamp(audio.music.volume, 0.0F, 1.0F);
}
if (aud.contains("sound")) {
const auto& snd = aud["sound"];
if (snd.contains("enabled")) {
try {
audio.sound.enabled = snd["enabled"].get_value<bool>();
} catch (...) {}
}
if (snd.contains("volume")) {
try {
audio.sound.volume = std::clamp(snd["volume"].get_value<float>(), 0.0F, 1.0F);
} catch (...) {}
}
parseField(snd, "enabled", audio.sound.enabled);
parseField(snd, "volume", audio.sound.volume);
audio.sound.volume = std::clamp(audio.sound.volume, 0.0F, 1.0F);
}
}
void loadLoadingFromYaml(const fkyaml::node& yaml) {
if (!yaml.contains("loading")) { return; }
const auto& ld = yaml["loading"];
parseBoolField(ld, "show", loading.show);
parseBoolField(ld, "show_resource_name", loading.show_resource_name);
parseBoolField(ld, "wait_for_input", loading.wait_for_input);
parseField(ld, "show", loading.show);
parseField(ld, "show_resource_name", loading.show_resource_name);
parseField(ld, "wait_for_input", loading.wait_for_input);
}
void loadGameFromYaml(const fkyaml::node& yaml) {
@@ -503,37 +419,23 @@ namespace Options {
const auto& game = yaml["game"];
if (game.contains("language")) {
try {
auto lang = static_cast<Lang::Code>(game["language"].get_value<int>());
if (lang == Lang::Code::ENGLISH || lang == Lang::Code::VALENCIAN || lang == Lang::Code::SPANISH) {
settings.language = lang;
} else {
settings.language = Lang::Code::ENGLISH;
}
pending_changes.new_language = settings.language;
} catch (...) {}
int lang_int = static_cast<int>(settings.language);
parseField(game, "language", lang_int);
const auto LANG = static_cast<Lang::Code>(lang_int);
settings.language = (LANG == Lang::Code::ENGLISH || LANG == Lang::Code::VALENCIAN || LANG == Lang::Code::SPANISH)
? LANG
: Lang::Code::ENGLISH;
pending_changes.new_language = settings.language;
}
if (game.contains("difficulty")) {
try {
settings.difficulty = static_cast<Difficulty::Code>(game["difficulty"].get_value<int>());
pending_changes.new_difficulty = settings.difficulty;
} catch (...) {}
}
if (game.contains("autofire")) {
try {
settings.autofire = game["autofire"].get_value<bool>();
} catch (...) {}
}
if (game.contains("shutdown_enabled")) {
try {
settings.shutdown_enabled = game["shutdown_enabled"].get_value<bool>();
} catch (...) {}
}
if (game.contains("params_file")) {
try {
settings.params_file = game["params_file"].get_value<std::string>();
} catch (...) {}
int diff_int = static_cast<int>(settings.difficulty);
parseField(game, "difficulty", diff_int);
settings.difficulty = static_cast<Difficulty::Code>(diff_int);
pending_changes.new_difficulty = settings.difficulty;
}
parseField(game, "autofire", settings.autofire);
parseField(game, "shutdown_enabled", settings.shutdown_enabled);
parseField(game, "params_file", settings.params_file);
}
void loadControllersFromYaml(const fkyaml::node& yaml) {
@@ -543,25 +445,14 @@ namespace Options {
size_t i = 0;
for (const auto& ctrl : controllers) {
if (i >= GamepadManager::size()) { break; }
if (ctrl.contains("name")) {
try {
gamepad_manager[i].name = ctrl["name"].get_value<std::string>();
} catch (...) {}
}
if (ctrl.contains("path")) {
try {
gamepad_manager[i].path = ctrl["path"].get_value<std::string>();
} catch (...) {}
}
if (ctrl.contains("player")) {
try {
int player_int = ctrl["player"].get_value<int>();
if (player_int == 1) {
gamepad_manager[i].player_id = Player::Id::PLAYER1;
} else if (player_int == 2) {
gamepad_manager[i].player_id = Player::Id::PLAYER2;
}
} catch (...) {}
parseField(ctrl, "name", gamepad_manager[i].name);
parseField(ctrl, "path", gamepad_manager[i].path);
int player_int = 0;
parseField(ctrl, "player", player_int);
if (player_int == 1) {
gamepad_manager[i].player_id = Player::Id::PLAYER1;
} else if (player_int == 2) {
gamepad_manager[i].player_id = Player::Id::PLAYER2;
}
++i;
}
@@ -570,11 +461,9 @@ namespace Options {
void loadKeyboardFromYaml(const fkyaml::node& yaml) {
if (!yaml.contains("keyboard")) { return; }
const auto& kb = yaml["keyboard"];
if (kb.contains("player")) {
try {
keyboard.player_id = static_cast<Player::Id>(kb["player"].get_value<int>());
} catch (...) {}
}
int player_int = static_cast<int>(keyboard.player_id);
parseField(kb, "player", player_int);
keyboard.player_id = static_cast<Player::Id>(player_int);
}
// Carga el fichero de configuración
@@ -595,11 +484,7 @@ namespace Options {
// Comprobar versión: si no coincide, regenerar config por defecto
int file_version = 0;
if (yaml.contains("version")) {
try {
file_version = yaml["version"].get_value<int>();
} catch (...) {}
}
parseField(yaml, "version", file_version);
if (file_version != Settings::CURRENT_CONFIG_VERSION) {
std::cout << "Config version " << file_version << " != expected " << Settings::CURRENT_CONFIG_VERSION << ". Recreating defaults." << '\n';
init();
@@ -820,14 +705,14 @@ namespace Options {
continue;
}
const auto it = std::ranges::find_if(physical_gamepads,
[this, &desired_path, &assigned_instances](const auto& pg) {
const auto IT = std::ranges::find_if(physical_gamepads,
[&desired_path, &assigned_instances](const auto& pg) {
return pg->path == desired_path && !isGamepadAssigned(pg, assigned_instances);
});
if (it != physical_gamepads.end()) {
gamepads_[i].instance = *it;
gamepads_[i].name = (*it)->name;
assigned_instances.push_back(*it);
if (IT != physical_gamepads.end()) {
gamepads_[i].instance = *IT;
gamepads_[i].name = (*IT)->name;
assigned_instances.push_back(*IT);
}
}
}
@@ -849,15 +734,15 @@ namespace Options {
continue;
}
const auto it = std::ranges::find_if(physical_gamepads,
[this, &desired_name, &assigned_instances](const auto& pg) {
const auto IT = std::ranges::find_if(physical_gamepads,
[&desired_name, &assigned_instances](const auto& pg) {
return pg->name == desired_name && !isGamepadAssigned(pg, assigned_instances);
});
if (it != physical_gamepads.end()) {
gamepads_[i].instance = *it;
gamepads_[i].name = (*it)->name;
gamepads_[i].path = (*it)->path;
assigned_instances.push_back(*it);
if (IT != physical_gamepads.end()) {
gamepads_[i].instance = *IT;
gamepads_[i].name = (*IT)->name;
gamepads_[i].path = (*IT)->path;
assigned_instances.push_back(*IT);
}
}
}
@@ -871,15 +756,15 @@ namespace Options {
continue;
}
const auto it = std::ranges::find_if(physical_gamepads,
[this, &assigned_instances](const auto& pg) {
const auto IT = std::ranges::find_if(physical_gamepads,
[&assigned_instances](const auto& pg) {
return !isGamepadAssigned(pg, assigned_instances);
});
if (it != physical_gamepads.end()) {
gamepads_[i].instance = *it;
gamepads_[i].name = (*it)->name;
gamepads_[i].path = (*it)->path;
assigned_instances.push_back(*it);
if (IT != physical_gamepads.end()) {
gamepads_[i].instance = *IT;
gamepads_[i].name = (*IT)->name;
gamepads_[i].path = (*IT)->path;
assigned_instances.push_back(*IT);
}
}
}