migrant input: corregit GamepadManager.swapPlayers()

source/options.cpp

@@ -23,7 +23,7 @@ Window window;                   // Opciones de la ventana
 Settings settings;               // Opciones del juego
 Video video;                     // Opciones de vídeo
 Audio audio;                     // Opciones de audio
-GamepadManager gamepads;         // Opciones de mando para cada jugador
+GamepadManager gamepad_manager;  // Opciones de mando para cada jugador
 Keyboard keyboard;               // Opciones para el teclado
 PendingChanges pending_changes;  // Opciones que se aplican al cerrar
 
@@ -42,7 +42,7 @@ void init() {
     Difficulty::init();
 
     // Opciones de control
-    gamepads.init();
+    gamepad_manager.init();
     setKeyboardToPlayer(Player::Id::PLAYER1);
 
     // Opciones de cambios pendientes
@@ -67,7 +67,7 @@ auto loadFromFile() -> bool {
             if (line.substr(0, 1) != "#") {
                 int pos = line.find("=");
                 if (!set(line.substr(0, pos), line.substr(pos + 1, line.length()))) {
-                     SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Unknown parameter: %s", line.substr(0, pos).c_str());
+                    SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Unknown parameter: %s", line.substr(0, pos).c_str());
                 }
             }
         }
@@ -75,7 +75,7 @@ auto loadFromFile() -> bool {
     }
 
     // 3. Llamamos al asignador inteligente.
-    gamepads.assignAndLinkGamepads();
+    gamepad_manager.assignAndLinkGamepads();
 
     // 4. Si el fichero no existía, lo creamos ahora con la configuración por defecto.
     if (!file.good()) {
@@ -148,7 +148,7 @@ auto saveToFile() -> bool {
 
     // Opciones de mandos
     file << "\n\n## CONTROLLERS\n";
-    gamepads.saveToFile(file);
+    gamepad_manager.saveToFile(file);
 
     // Cierra el fichero
     file.close();
@@ -169,7 +169,7 @@ void parseAndSetController(const std::string& var, const std::string& value) {
         int controller_index = std::stoi(var.substr(first_dot + 1, second_dot - first_dot - 1));
         std::string setting_key = var.substr(second_dot + 1);
 
-        gamepads.setControllerProperty(controller_index, setting_key, value);
+        gamepad_manager.setControllerProperty(controller_index, setting_key, value);
     } catch (const std::exception&) {
         // Error en parsing
     }
@@ -252,7 +252,7 @@ void swapKeyboard() {
 
 // Intercambia los jugadores asignados a los dos primeros mandos
 void swapControllers() {
-    gamepads.swapPlayers();
+    gamepad_manager.swapPlayers();
 }
 
 // Averigua quien está usando el teclado
@@ -279,7 +279,7 @@ bool assignGamepadByName(const std::string& gamepad_name_to_find, Player::Id pla
     auto found_gamepad = Input::get()->findAvailableGamepadByName(gamepad_name_to_find);
 
     if (found_gamepad) {
-        return gamepads.assignGamepadToPlayer(player_id, found_gamepad, found_gamepad->name);
+        return gamepad_manager.assignGamepadToPlayer(player_id, found_gamepad, found_gamepad->name);
     }
     return false;
 }
@@ -287,7 +287,7 @@ bool assignGamepadByName(const std::string& gamepad_name_to_find, Player::Id pla
 // Obtener información de un gamepad específico
 std::string getGamepadInfo(Player::Id player_id) {
     try {
-        const auto& gamepad = gamepads.getGamepad(player_id);
+        const auto& gamepad = gamepad_manager.getGamepad(player_id);
         return "Player " + std::to_string(static_cast<int>(player_id)) +
             ": " + (gamepad.name.empty() ? "No gamepad" : gamepad.name);
     } catch (const std::exception&) {
@@ -303,10 +303,10 @@ void GamepadManager::assignAndLinkGamepads() {
     // 2. Reiniciamos las asignaciones actuales y guardamos los nombres que teníamos en la config.
     std::array<std::string, MAX_PLAYERS> desired_names;
     for (size_t i = 0; i < MAX_PLAYERS; ++i) {
-        desired_names[i] = gamepads[i].name; // Guardamos el nombre deseado
+        desired_names[i] = gamepads[i].name;  // Guardamos el nombre deseado
-        gamepads[i].instance = nullptr;      // Limpiamos la instancia
+        gamepads[i].instance = nullptr;       // Limpiamos la instancia
     }
-    
+
     // 3. Vector para rastrear los mandos físicos que ya hemos asignado.
     std::vector<std::shared_ptr<Input::Gamepad>> assigned_instances;
 
@@ -315,7 +315,7 @@ void GamepadManager::assignAndLinkGamepads() {
     for (size_t i = 0; i < MAX_PLAYERS; ++i) {
         const std::string& desired_name = desired_names[i];
         if (desired_name.empty()) {
-            continue; // Si no se pide un nombre específico, pasamos a la siguiente fase.
+            continue;  // Si no se pide un nombre específico, pasamos a la siguiente fase.
         }
 
         // Buscamos un mando físico que coincida con el nombre deseado.
@@ -331,9 +331,9 @@ void GamepadManager::assignAndLinkGamepads() {
                 }
 
                 if (!already_assigned) {
-                    gamepads[i].instance = physical_gamepad; // Enlazamos la instancia
+                    gamepads[i].instance = physical_gamepad;         // Enlazamos la instancia
-                    assigned_instances.push_back(physical_gamepad); // Lo marcamos como asignado
+                    assigned_instances.push_back(physical_gamepad);  // Lo marcamos como asignado
-                    break; // Mando encontrado para este jugador, pasamos al siguiente.
+                    break;                                           // Mando encontrado para este jugador, pasamos al siguiente.
                 }
             }
         }
@@ -342,8 +342,8 @@ void GamepadManager::assignAndLinkGamepads() {
     // --- SEGUNDA PASADA: Asignar los mandos restantes a los jugadores sin mando ---
     // Recorremos de nuevo la configuración de nuestros jugadores.
     for (size_t i = 0; i < MAX_PLAYERS; ++i) {
-        if (gamepads[i].instance == nullptr) { // Si este jugador aún no tiene mando...
+        if (gamepads[i].instance == nullptr) {  // Si este jugador aún no tiene mando...
-            
+
             // ...buscamos un mando físico que todavía esté libre.
             for (const auto& physical_gamepad : physical_gamepads) {
                 bool already_assigned = false;
@@ -355,12 +355,12 @@ void GamepadManager::assignAndLinkGamepads() {
                 }
 
                 if (!already_assigned) {
-                    gamepads[i].instance = physical_gamepad; // Se lo asignamos
+                    gamepads[i].instance = physical_gamepad;  // Se lo asignamos
                     // MUY IMPORTANTE: Actualizamos el nombre en la configuración.
                     // Si guardamos, ahora se guardará el nombre del mando real que se le asignó.
                     gamepads[i].name = physical_gamepad->name;
-                    assigned_instances.push_back(physical_gamepad); // Lo marcamos como asignado
+                    assigned_instances.push_back(physical_gamepad);  // Lo marcamos como asignado
-                    break; // Mando encontrado, pasamos al siguiente jugador.
+                    break;                                           // Mando encontrado, pasamos al siguiente jugador.
                 }
             }
         }

source/options.h

@@ -161,7 +161,8 @@ class GamepadManager {
         }
 
         void swapPlayers() {
-            std::swap(gamepads[0].player_id, gamepads[1].player_id);
+            std::swap(gamepads[0].instance, gamepads[1].instance);
+            std::swap(gamepads[0].name, gamepads[1].name);
         }
 
         // Para serialización/deserialización
@@ -203,7 +204,7 @@ class GamepadManager {
         }
 
         // Asigna los mandos físicos basándose en la configuración actual de nombres.
-        void assignAndLinkGamepads(); 
+        void assignAndLinkGamepads();
 
         // Iteradores
         auto begin() { return gamepads.begin(); }
@@ -233,7 +234,7 @@ extern Window window;                   // Opciones de la ventana
 extern Settings settings;               // Opciones del juego
 extern Video video;                     // Opciones de vídeo
 extern Audio audio;                     // Opciones de audio
-extern GamepadManager gamepads;         // Manager de mandos para cada jugador
+extern GamepadManager gamepad_manager;  // Manager de mandos para cada jugador
 extern Keyboard keyboard;               // Opciones para el teclado
 extern PendingChanges pending_changes;  // Opciones que se aplican al cerrar
 

source/sections/game.cpp

@@ -1218,9 +1218,12 @@ auto Game::getPlayer(Player::Id id) -> std::shared_ptr<Player> {
 // Obtiene un controlador a partir del "id" del jugador
 auto Game::getController(Player::Id player_id) -> int {
     switch (player_id) {
-        case Player::Id::PLAYER1: return 0;
+        case Player::Id::PLAYER1:
-        case Player::Id::PLAYER2: return 1;
+            return 0;
-        default: return -1;
+        case Player::Id::PLAYER2:
+            return 1;
+        default:
+            return -1;
     }
 }
 
@@ -1597,7 +1600,7 @@ void Game::initPlayers(Player::Id player_id) {
     auto player1 = std::make_unique<Player>(config_player1);
     player1->setScoreBoardPanel(Scoreboard::Id::LEFT);
     player1->setName(Lang::getText("[SCOREBOARD] 1"));
-    player1->setGamepad(Options::gamepads.getGamepad(Player::Id::PLAYER1).instance);
+    player1->setGamepad(Options::gamepad_manager.getGamepad(Player::Id::PLAYER1).instance);
     player1->setUsesKeyboard(Player::Id::PLAYER1 == Options::keyboard.player_id);
     player1->setPlayingState(Player::State::WAITING);
     players_.push_back(std::move(player1));
@@ -1617,7 +1620,7 @@ void Game::initPlayers(Player::Id player_id) {
     auto player2 = std::make_unique<Player>(config_player2);
     player2->setScoreBoardPanel(Scoreboard::Id::RIGHT);
     player2->setName(Lang::getText("[SCOREBOARD] 2"));
-    player2->setGamepad(Options::gamepads.getGamepad(Player::Id::PLAYER2).instance);
+    player2->setGamepad(Options::gamepad_manager.getGamepad(Player::Id::PLAYER2).instance);
     player2->setUsesKeyboard(Player::Id::PLAYER2 == Options::keyboard.player_id);
     player2->setPlayingState(Player::State::WAITING);
     players_.push_back(std::move(player2));

source/sections/title.cpp

@@ -213,12 +213,12 @@ void Title::printColorValue(const Color& color) {
 void Title::handleControlKeys(SDL_Keycode key) {
     switch (key) {
         case SDLK_1:
-            define_buttons_->enable(&Options::gamepads.getGamepad(Player::Id::PLAYER1));
+            define_buttons_->enable(&Options::gamepad_manager.getGamepad(Player::Id::PLAYER1));
             resetCounter();
             break;
 
         case SDLK_2:
-            define_buttons_->enable(&Options::gamepads.getGamepad(Player::Id::PLAYER2));
+            define_buttons_->enable(&Options::gamepad_manager.getGamepad(Player::Id::PLAYER2));
             resetCounter();
             break;
 
@@ -262,14 +262,14 @@ auto Title::shouldSkipInputCheck() const -> bool {
 }
 
 void Title::processControllerInputs() {
-    for (const auto& controller : Options::gamepads) {
+    for (const auto& controller : Options::gamepad_manager) {
         if (isStartButtonPressed(&controller)) {
             handleStartButtonPress(&controller);
         }
     }
 }
 
-auto Title::isStartButtonPressed(const Options::Gamepad *controller) -> bool {
+auto Title::isStartButtonPressed(const Options::Gamepad* controller) -> bool {
     return Input::get()->checkAction(
         Input::Action::START,
         Input::DO_NOT_ALLOW_REPEAT,
@@ -277,7 +277,7 @@ auto Title::isStartButtonPressed(const Options::Gamepad *controller) -> bool {
         controller->instance);
 }
 
-void Title::handleStartButtonPress(const Options::Gamepad *controller) {
+void Title::handleStartButtonPress(const Options::Gamepad* controller) {
     if (!canProcessStartButton()) {
         return;
     }