jaildesigner-jailgames/orni-attack
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

refactor: eliminar Options::physics/audio/gameplay (codi mort)

Browse Source 
Aquestes tres seccions s'estaven carregant del YAML, parsejant,
validant i escrivint, però cap d'elles tenia consumidor en runtime:
- Options::physics: l'únic call-site era un std::cout informatiu a
  director.cpp:109. Ship/Enemy/Bullet llegeixen Defaults::Physics
  directament.
- Options::audio: explícitament desacoblat (audio.hpp:22-25) — la
  font de configuració era Defaults::Audio via Audio::Config.
- Options::gameplay: zero readers. Els arrays són compile-time.

Esborrats:
- Structs Physics/Gameplay/Music/Sound/Audio i les globals.
- Defaults a init(), helpers loadXxxConfigFromYaml, secció escrita
  a saveToFile, crides al loadFromFile.
- La línia "Física: rotation=..." del console output del Director.

Es manté Options::window i Options::rendering (sí utilitzats).

Hallazgo #21 de CODE_REVIEW.md (opció a: borrar).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Sergio Valor
2026-05-20 18:07:27 +02:00
parent e4b6d2df6a
commit 11e9d6569b
3 changed files with 493 additions and 661 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/core/system/director.cpp
+7 -11
View File
@@ -9,10 +9,6 @@
#include <iostream>
#include <memory>
#include "debug_overlay.hpp"
#include "scene.hpp"
#include "scene_context.hpp"
#include "global_events.hpp"
#include "core/audio/audio.hpp"
#include "core/audio/audio_adapter.hpp"
#include "core/defaults.hpp"
@@ -22,11 +18,15 @@
#include "core/resources/resource_helper.hpp"
#include "core/resources/resource_loader.hpp"
#include "core/utils/path_utils.hpp"
#include "debug_overlay.hpp"
#include "game/options.hpp"
#include "game/scenes/game_scene.hpp"
#include "game/scenes/logo_scene.hpp"
#include "game/scenes/title_scene.hpp"
#include "game/options.hpp"
#include "global_events.hpp"
#include "project.h"
#include "scene.hpp"
#include "scene_context.hpp"
#ifndef _WIN32
#include <pwd.h>
@@ -106,8 +106,6 @@ Director::Director(std::vector<std::string> const& args) {
std::cout << "Configuración carregada\n";
std::cout << " Finestra: " << Options::window.width << "×"
<< Options::window.height << '\n';
std::cout << " Física: rotation=" << Options::physics.rotation_speed
<< " rad/s\n";
std::cout << " Input: " << Input::get()->getNumGamepads()
<< " gamepad(s) detectat(s)\n";
}
@@ -291,8 +289,7 @@ auto Director::buildScene(SceneType type, SDLManager& sdl, SceneContext& context
}
}
void Director::runFrameLoop(Scene& scene, SDLManager& sdl, SceneContext& context,
System::DebugOverlay& debug_overlay) {
void Director::runFrameLoop(Scene& scene, SDLManager& sdl, SceneContext& context, System::DebugOverlay& debug_overlay) {
SDL_Event event;
Uint64 last_time = SDL_GetTicks();
@@ -315,8 +312,7 @@ void Director::runFrameLoop(Scene& scene, SDLManager& sdl, SceneContext& context
if (GlobalEvents::handle(event, sdl, context)) {
continue;
}
if (event.type == SDL_EVENT_KEY_DOWN
&& event.key.scancode == SDL_SCANCODE_F11) {
if (event.type == SDL_EVENT_KEY_DOWN && event.key.scancode == SDL_SCANCODE_F11) {
debug_overlay.toggle();
continue;
}
source/game/options.cpp
+58 -188
View File
@@ -11,10 +11,10 @@
namespace Options {
// ========== FUNCIONS AUXILIARS PER CONVERSIÓ DE CONTROLES ==========
// ========== FUNCIONS AUXILIARS PER CONVERSIÓ DE CONTROLES ==========
// Mapa de SDL_Scancode a string
static const std::unordered_map<SDL_Scancode, std::string> SCANCODE_TO_STRING = {
// Mapa de SDL_Scancode a string
static const std::unordered_map<SDL_Scancode, std::string> SCANCODE_TO_STRING = {
{SDL_SCANCODE_A, "A"},
{SDL_SCANCODE_B, "B"},
{SDL_SCANCODE_C, "C"},
@@ -67,8 +67,8 @@ static const std::unordered_map<SDL_Scancode, std::string> SCANCODE_TO_STRING =
{SDL_SCANCODE_LALT, "LALT"},
{SDL_SCANCODE_RALT, "RALT"}};
// Mapa invers: string a SDL_Scancode
static const std::unordered_map<std::string, SDL_Scancode> STRING_TO_SCANCODE = {
// Mapa invers: string a SDL_Scancode
static const std::unordered_map<std::string, SDL_Scancode> STRING_TO_SCANCODE = {
{"A", SDL_SCANCODE_A},
{"B", SDL_SCANCODE_B},
{"C", SDL_SCANCODE_C},
@@ -121,8 +121,8 @@ static const std::unordered_map<std::string, SDL_Scancode> STRING_TO_SCANCODE =
{"LALT", SDL_SCANCODE_LALT},
{"RALT", SDL_SCANCODE_RALT}};
// Mapa de botó de gamepad (int) a string
static const std::unordered_map<int, std::string> BUTTON_TO_STRING = {
// Mapa de botó de gamepad (int) a string
static const std::unordered_map<int, std::string> BUTTON_TO_STRING = {
{SDL_GAMEPAD_BUTTON_SOUTH, "SOUTH"}, // A (Xbox), Cross (PS)
{SDL_GAMEPAD_BUTTON_EAST, "EAST"}, // B (Xbox), Circle (PS)
{SDL_GAMEPAD_BUTTON_WEST, "WEST"}, // X (Xbox), Square (PS)
@@ -137,10 +137,10 @@ static const std::unordered_map<int, std::string> BUTTON_TO_STRING = {
{SDL_GAMEPAD_BUTTON_DPAD_RIGHT, "DPAD_RIGHT"},
{100, "L2_AS_BUTTON"}, // Trigger L2 como a botó digital
{101, "R2_AS_BUTTON"} // Trigger R2 como a botó digital
};
};
// Mapa invers: string a botó de gamepad
static const std::unordered_map<std::string, int> STRING_TO_BUTTON = {
// Mapa invers: string a botó de gamepad
static const std::unordered_map<std::string, int> STRING_TO_BUTTON = {
{"SOUTH", SDL_GAMEPAD_BUTTON_SOUTH},
{"EAST", SDL_GAMEPAD_BUTTON_EAST},
{"WEST", SDL_GAMEPAD_BUTTON_WEST},
@@ -156,30 +156,30 @@ static const std::unordered_map<std::string, int> STRING_TO_BUTTON = {
{"L2_AS_BUTTON", 100},
{"R2_AS_BUTTON", 101}};
static auto scancodeToString(SDL_Scancode code) -> std::string {
static auto scancodeToString(SDL_Scancode code) -> std::string {
auto it = SCANCODE_TO_STRING.find(code);
return (it != SCANCODE_TO_STRING.end()) ? it->second : "UNKNOWN";
}
}
static auto stringToScancode(const std::string& str) -> SDL_Scancode {
static auto stringToScancode(const std::string& str) -> SDL_Scancode {
auto it = STRING_TO_SCANCODE.find(str);
return (it != STRING_TO_SCANCODE.end()) ? it->second : SDL_SCANCODE_UNKNOWN;
}
}
static auto buttonToString(int button) -> std::string {
static auto buttonToString(int button) -> std::string {
auto it = BUTTON_TO_STRING.find(button);
return (it != BUTTON_TO_STRING.end()) ? it->second : "UNKNOWN";
}
}
static auto stringToButton(const std::string& str) -> int {
static auto stringToButton(const std::string& str) -> int {
auto it = STRING_TO_BUTTON.find(str);
return (it != STRING_TO_BUTTON.end()) ? it->second : SDL_GAMEPAD_BUTTON_INVALID;
}
}
// ========== FI FUNCIONS AUXILIARS ==========
// ========== FI FUNCIONS AUXILIARS ==========
// Inicialitzar opciones con valors per defecte de Defaults::
void init() {
// Inicialitzar opciones con valors per defecte de Defaults::
void init() {
#ifdef _DEBUG
console = true;
#else
@@ -192,44 +192,23 @@ void init() {
window.fullscreen = Defaults::Window::FULLSCREEN;
window.zoom_factor = Defaults::Window::BASE_ZOOM;
// Physics
physics.rotation_speed = Defaults::Physics::ROTATION_SPEED;
physics.acceleration = Defaults::Physics::ACCELERATION;
physics.max_velocity = Defaults::Physics::MAX_VELOCITY;
physics.friction = Defaults::Physics::FRICTION;
physics.enemy_speed = Defaults::Physics::ENEMY_SPEED;
physics.bullet_speed = Defaults::Physics::BULLET_SPEED;
// Gameplay
gameplay.max_enemies = Defaults::Entities::MAX_ORNIS;
gameplay.max_bullets = Defaults::Entities::MAX_BALES;
// Rendering
rendering.vsync = Defaults::Rendering::VSYNC_DEFAULT;
// Audio
audio.enabled = Defaults::Audio::ENABLED;
audio.volume = Defaults::Audio::VOLUME;
audio.music.enabled = Defaults::Audio::MUSIC_ENABLED;
audio.music.volume = Defaults::Audio::MUSIC_VOLUME;
audio.sound.enabled = Defaults::Audio::SOUND_ENABLED;
audio.sound.volume = Defaults::Audio::SOUND_VOLUME;
// Version
version = std::string(Project::VERSION);
}
}
// Establir la ruta del file de configuración
void setConfigFile(const std::string& path) { config_file_path = path; }
// Establir la ruta del file de configuración
void setConfigFile(const std::string& path) { config_file_path = path; }
// Funciones auxiliars per load seccions del YAML
// Funciones auxiliars per load seccions del YAML
// Lee un campo escalar del YAML aplicando un validador; si la clau no
// existe, deja `dest` intacto; si la conversió o la validació fallen,
// asigna `fallback`. Estàtic per quedar dins de la unitat de traducció.
template <typename T, typename Validator>
static void readField(const fkyaml::node& parent, const char* key, T& dest,
T fallback, Validator&& validate) {
// Lee un campo escalar del YAML aplicando un validador; si la clau no
// existe, deja `dest` intacto; si la conversió o la validació fallen,
// asigna `fallback`. Estàtic per quedar dins de la unitat de traducció.
template <typename T, typename Validator>
static void readField(const fkyaml::node& parent, const char* key, T& dest, T fallback, Validator&& validate) {
if (!parent.contains(key)) {
return;
}
@@ -239,11 +218,11 @@ static void readField(const fkyaml::node& parent, const char* key, T& dest,
} catch (...) {
dest = fallback;
}
}
}
// Variant sin validador: només lectura amb fallback en cas d'error.
template <typename T>
static void readField(const fkyaml::node& parent, const char* key, T& dest, T fallback) {
// Variant sin validador: només lectura amb fallback en cas d'error.
template <typename T>
static void readField(const fkyaml::node& parent, const char* key, T& dest, T fallback) {
if (!parent.contains(key)) {
return;
}
@@ -252,72 +231,28 @@ static void readField(const fkyaml::node& parent, const char* key, T& dest, T fa
} catch (...) {
dest = fallback;
}
}
}
static void loadWindowConfigFromYaml(const fkyaml::node& yaml) {
static void loadWindowConfigFromYaml(const fkyaml::node& yaml) {
if (!yaml.contains("window")) {
return;
}
const auto& win = yaml["window"];
readField(win, "width", window.width, Defaults::Window::WIDTH,
[](int v) { return v >= Defaults::Window::MIN_WIDTH; });
readField(win, "height", window.height, Defaults::Window::HEIGHT,
[](int v) { return v >= Defaults::Window::MIN_HEIGHT; });
readField(win, "width", window.width, Defaults::Window::WIDTH, [](int v) { return v >= Defaults::Window::MIN_WIDTH; });
readField(win, "height", window.height, Defaults::Window::HEIGHT, [](int v) { return v >= Defaults::Window::MIN_HEIGHT; });
readField(win, "fullscreen", window.fullscreen, false);
if (win.contains("zoom_factor")) {
readField(win, "zoom_factor", window.zoom_factor, Defaults::Window::BASE_ZOOM,
[](float v) { return v >= Defaults::Window::MIN_ZOOM && v <= 10.0F; });
readField(win, "zoom_factor", window.zoom_factor, Defaults::Window::BASE_ZOOM, [](float v) { return v >= Defaults::Window::MIN_ZOOM && v <= 10.0F; });
} else {
// Legacy config: infer zoom from width
window.zoom_factor = static_cast<float>(window.width) / Defaults::Window::WIDTH;
window.zoom_factor = std::max(Defaults::Window::MIN_ZOOM, window.zoom_factor);
}
}
static void loadPhysicsConfigFromYaml(const fkyaml::node& yaml) {
if (!yaml.contains("physics")) {
return;
}
const auto& phys = yaml["physics"];
constexpr auto POSITIVE = [](float v) { return v > 0.0F; };
readField(phys, "rotation_speed", physics.rotation_speed, Defaults::Physics::ROTATION_SPEED, POSITIVE);
readField(phys, "acceleration", physics.acceleration, Defaults::Physics::ACCELERATION, POSITIVE);
readField(phys, "max_velocity", physics.max_velocity, Defaults::Physics::MAX_VELOCITY, POSITIVE);
readField(phys, "friction", physics.friction, Defaults::Physics::FRICTION, POSITIVE);
readField(phys, "enemy_speed", physics.enemy_speed, Defaults::Physics::ENEMY_SPEED, POSITIVE);
readField(phys, "bullet_speed", physics.bullet_speed, Defaults::Physics::BULLET_SPEED, POSITIVE);
}
static void loadGameplayConfigFromYaml(const fkyaml::node& yaml) {
if (yaml.contains("gameplay")) {
const auto& game = yaml["gameplay"];
if (game.contains("max_enemies")) {
try {
auto val = game["max_enemies"].get_value<int>();
gameplay.max_enemies =
(val > 0 && val <= 50) ? val : Defaults::Entities::MAX_ORNIS;
} catch (...) {
gameplay.max_enemies = Defaults::Entities::MAX_ORNIS;
}
}
if (game.contains("max_bullets")) {
try {
auto val = game["max_bullets"].get_value<int>();
gameplay.max_bullets =
(val > 0 && val <= 10) ? val : Defaults::Entities::MAX_BALES;
} catch (...) {
gameplay.max_bullets = Defaults::Entities::MAX_BALES;
}
}
}
}
static void loadRenderingConfigFromYaml(const fkyaml::node& yaml) {
static void loadRenderingConfigFromYaml(const fkyaml::node& yaml) {
if (yaml.contains("rendering")) {
const auto& rend = yaml["rendering"];
@@ -331,45 +266,10 @@ static void loadRenderingConfigFromYaml(const fkyaml::node& yaml) {
}
}
}
}
static void loadAudioMusicSection(const fkyaml::node& aud) {
if (!aud.contains("music")) {
return;
}
const auto& mus = aud["music"];
constexpr auto UNIT_RANGE = [](float v) { return v >= 0.0F && v <= 1.0F; };
readField(mus, "enabled", audio.music.enabled, Defaults::Audio::MUSIC_ENABLED);
readField(mus, "volume", audio.music.volume, Defaults::Audio::MUSIC_VOLUME, UNIT_RANGE);
}
static void loadAudioSoundSection(const fkyaml::node& aud) {
if (!aud.contains("sound")) {
return;
}
const auto& snd = aud["sound"];
constexpr auto UNIT_RANGE = [](float v) { return v >= 0.0F && v <= 1.0F; };
readField(snd, "enabled", audio.sound.enabled, Defaults::Audio::SOUND_ENABLED);
readField(snd, "volume", audio.sound.volume, Defaults::Audio::SOUND_VOLUME, UNIT_RANGE);
}
static void loadAudioConfigFromYaml(const fkyaml::node& yaml) {
if (!yaml.contains("audio")) {
return;
}
const auto& aud = yaml["audio"];
constexpr auto UNIT_RANGE = [](float v) { return v >= 0.0F && v <= 1.0F; };
readField(aud, "enabled", audio.enabled, Defaults::Audio::ENABLED);
readField(aud, "volume", audio.volume, Defaults::Audio::VOLUME, UNIT_RANGE);
loadAudioMusicSection(aud);
loadAudioSoundSection(aud);
}
// Carregar controls del player 1 desde YAML
static void loadPlayer1ControlsFromYaml(const fkyaml::node& yaml) {
// Carregar controls del player 1 desde YAML
static void loadPlayer1ControlsFromYaml(const fkyaml::node& yaml) {
if (!yaml.contains("player1")) {
return;
}
@@ -414,10 +314,10 @@ static void loadPlayer1ControlsFromYaml(const fkyaml::node& yaml) {
if (p1.contains("gamepad_name")) {
player1.gamepad_name = p1["gamepad_name"].get_value<std::string>();
}
}
}
// Carregar controls del player 2 desde YAML
static void loadPlayer2ControlsFromYaml(const fkyaml::node& yaml) {
// Carregar controls del player 2 desde YAML
static void loadPlayer2ControlsFromYaml(const fkyaml::node& yaml) {
if (!yaml.contains("player2")) {
return;
}
@@ -462,10 +362,10 @@ static void loadPlayer2ControlsFromYaml(const fkyaml::node& yaml) {
if (p2.contains("gamepad_name")) {
player2.gamepad_name = p2["gamepad_name"].get_value<std::string>();
}
}
}
// Carregar configuración des del file YAML
auto loadFromFile() -> bool {
// Carregar configuración des del file YAML
auto loadFromFile() -> bool {
const std::string CONFIG_VERSION = std::string(Project::VERSION);
std::ifstream file(config_file_path);
@@ -507,10 +407,7 @@ auto loadFromFile() -> bool {
// Carregar seccions
loadWindowConfigFromYaml(yaml);
loadPhysicsConfigFromYaml(yaml);
loadGameplayConfigFromYaml(yaml);
loadRenderingConfigFromYaml(yaml);
loadAudioConfigFromYaml(yaml);
loadPlayer1ControlsFromYaml(yaml);
loadPlayer2ControlsFromYaml(yaml);
@@ -531,10 +428,10 @@ auto loadFromFile() -> bool {
saveToFile();
return true;
}
}
}
// Guardar controls del player 1 a YAML
static void savePlayer1ControlsToYaml(std::ofstream& file) {
// Guardar controls del player 1 a YAML
static void savePlayer1ControlsToYaml(std::ofstream& file) {
file << "# CONTROLS JUGADOR 1\n";
file << "player1:\n";
file << " keyboard:\n";
@@ -548,10 +445,10 @@ static void savePlayer1ControlsToYaml(std::ofstream& file) {
file << " button_thrust: " << buttonToString(player1.gamepad.button_thrust) << "\n";
file << " button_shoot: " << buttonToString(player1.gamepad.button_shoot) << "\n";
file << " gamepad_name: \"" << player1.gamepad_name << "\" # Buit = primer disponible\n\n";
}
}
// Guardar controls del player 2 a YAML
static void savePlayer2ControlsToYaml(std::ofstream& file) {
// Guardar controls del player 2 a YAML
static void savePlayer2ControlsToYaml(std::ofstream& file) {
file << "# CONTROLS JUGADOR 2\n";
file << "player2:\n";
file << " keyboard:\n";
@@ -565,10 +462,10 @@ static void savePlayer2ControlsToYaml(std::ofstream& file) {
file << " button_thrust: " << buttonToString(player2.gamepad.button_thrust) << "\n";
file << " button_shoot: " << buttonToString(player2.gamepad.button_shoot) << "\n";
file << " gamepad_name: \"" << player2.gamepad_name << "\" # Buit = segon disponible\n\n";
}
}
// Guardar configuración al file YAML
auto saveToFile() -> bool {
// Guardar configuración al file YAML
auto saveToFile() -> bool {
std::ofstream file(config_file_path);
if (!file.is_open()) {
if (console) {
@@ -592,37 +489,10 @@ auto saveToFile() -> bool {
file << " fullscreen: " << (window.fullscreen ? "true" : "false") << "\n";
file << " zoom_factor: " << window.zoom_factor << " # 0.5x-max (0.1 increments)\n\n";
file << "# FÍSICA (todos los valors en px/s, rad/s, etc.)\n";
file << "physics:\n";
file << " rotation_speed: " << physics.rotation_speed << " # rad/s\n";
file << " acceleration: " << physics.acceleration << " # px/s²\n";
file << " max_velocity: " << physics.max_velocity << " # px/s\n";
file << " friction: " << physics.friction << " # px/s²\n";
file << " enemy_speed: " << physics.enemy_speed
<< " # unitats/frame\n";
file << " bullet_speed: " << physics.bullet_speed
<< " # unitats/frame\n\n";
file << "# GAMEPLAY\n";
file << "gameplay:\n";
file << " max_enemies: " << gameplay.max_enemies << "\n";
file << " max_bullets: " << gameplay.max_bullets << "\n\n";
file << "# RENDERITZACIÓ\n";
file << "rendering:\n";
file << " vsync: " << rendering.vsync << " # 0=disabled, 1=enabled\n\n";
file << "# AUDIO\n";
file << "audio:\n";
file << " enabled: " << (audio.enabled ? "true" : "false") << "\n";
file << " volume: " << audio.volume << " # 0.0 to 1.0\n";
file << " music:\n";
file << " enabled: " << (audio.music.enabled ? "true" : "false") << "\n";
file << " volume: " << audio.music.volume << " # 0.0 to 1.0\n";
file << " sound:\n";
file << " enabled: " << (audio.sound.enabled ? "true" : "false") << "\n";
file << " volume: " << audio.sound.volume << " # 0.0 to 1.0\n\n";
// Guardar controls de jugadors
savePlayer1ControlsToYaml(file);
savePlayer2ControlsToYaml(file);
@@ -634,6 +504,6 @@ auto saveToFile() -> bool {
}
return true;
}
}
} // namespace Options
source/game/options.hpp
+31 -65
View File
@@ -6,85 +6,51 @@
namespace Options {
// Estructures de configuración
// Estructures de configuración
struct Window {
struct Window {
int width{1280};
int height{720};
bool fullscreen{false};
float zoom_factor{1.0F}; // Zoom level (0.5x to max_zoom)
};
};
struct Physics {
float rotation_speed{3.14F}; // rad/s
float acceleration{400.0F}; // px/s²
float max_velocity{120.0F}; // px/s
float friction{20.0F}; // px/s²
float enemy_speed{2.0F}; // unitats/frame
float bullet_speed{6.0F}; // unitats/frame
};
struct Gameplay {
int max_enemies{15};
int max_bullets{3};
};
struct Rendering {
struct Rendering {
int vsync{1}; // 0=disabled, 1=enabled
};
};
struct Music {
bool enabled{true};
float volume{0.8F};
};
// Controles de jugadors
struct Sound {
bool enabled{true};
float volume{1.0F};
};
struct Audio {
Music music{};
Sound sound{};
bool enabled{true};
float volume{1.0F};
};
// Controles de jugadors
struct KeyboardControls {
struct KeyboardControls {
SDL_Scancode key_left{SDL_SCANCODE_LEFT};
SDL_Scancode key_right{SDL_SCANCODE_RIGHT};
SDL_Scancode key_thrust{SDL_SCANCODE_UP};
SDL_Scancode key_shoot{SDL_SCANCODE_SPACE};
SDL_Scancode key_start{SDL_SCANCODE_1};
};
};
struct GamepadControls {
struct GamepadControls {
int button_left{SDL_GAMEPAD_BUTTON_DPAD_LEFT};
int button_right{SDL_GAMEPAD_BUTTON_DPAD_RIGHT};
int button_thrust{SDL_GAMEPAD_BUTTON_WEST}; // X button
int button_shoot{SDL_GAMEPAD_BUTTON_SOUTH}; // A button
};
};
struct PlayerControls {
struct PlayerControls {
KeyboardControls keyboard{};
GamepadControls gamepad{};
std::string gamepad_name; // Buit = auto-assignar per índex
};
};
// Variables globals (inline per evitar ODR violations)
// Variables globals (inline per evitar ODR violations)
inline std::string version{}; // Versión del config per validació
inline bool console{false}; // Eixida de debug
inline Window window{};
inline Physics physics{};
inline Gameplay gameplay{};
inline Rendering rendering{};
inline Audio audio{};
inline std::string version{}; // Versión del config per validació
inline bool console{false}; // Eixida de debug
inline Window window{};
inline Rendering rendering{};
// Controles per player
inline PlayerControls player1{
// Controles per player
inline PlayerControls player1{
.keyboard =
{.key_left = SDL_SCANCODE_LEFT,
.key_right = SDL_SCANCODE_RIGHT,
@@ -92,9 +58,9 @@ inline PlayerControls player1{
.key_shoot = SDL_SCANCODE_SPACE,
.key_start = SDL_SCANCODE_1},
.gamepad_name = "" // Primer gamepad disponible
};
};
inline PlayerControls player2{
inline PlayerControls player2{
.keyboard =
{.key_left = SDL_SCANCODE_A,
.key_right = SDL_SCANCODE_D,
@@ -102,20 +68,20 @@ inline PlayerControls player2{
.key_shoot = SDL_SCANCODE_LSHIFT,
.key_start = SDL_SCANCODE_2},
.gamepad_name = "" // Segon gamepad disponible
};
};
// Per compatibilitat con pollo (no utilitzat en orni, pero necessari per Input)
inline KeyboardControls keyboard_controls{};
inline GamepadControls gamepad_controls{};
// Per compatibilitat con pollo (no utilitzat en orni, pero necessari per Input)
inline KeyboardControls keyboard_controls{};
inline GamepadControls gamepad_controls{};
inline std::string config_file_path{}; // Establert per setConfigFile()
inline std::string config_file_path{}; // Establert per setConfigFile()
// Funciones públiques
// Funciones públiques
void init(); // Inicialitzar con valors per defecte
void setConfigFile(
void init(); // Inicialitzar con valors per defecte
void setConfigFile(
const std::string& path); // Establir ruta del file de config
auto loadFromFile() -> bool; // Carregar config YAML
auto saveToFile() -> bool; // Guardar config YAML
auto loadFromFile() -> bool; // Carregar config YAML
auto saveToFile() -> bool; // Guardar config YAML
} // namespace Options