From 101e375fd30d85349f8c9f2d47d68f77408833ed Mon Sep 17 00:00:00 2001 From: Sergio Valor Date: Sat, 12 Oct 2024 11:01:42 +0200 Subject: [PATCH] Variables renombrades en input.cpp --- source/define_buttons.cpp | 12 +- source/define_buttons.h | 2 +- source/director.cpp | 92 +++++---- source/game.cpp | 74 ++++---- source/global_inputs.cpp | 42 ++--- source/global_inputs.h | 2 +- source/hiscore_table.cpp | 134 ++++++------- source/hiscore_table.h | 25 ++- source/input.cpp | 384 ++++++++++++++++++-------------------- source/input.h | 153 +++++++-------- source/options.cpp | 10 +- source/player.cpp | 26 +-- source/player.h | 6 +- source/screen.cpp | 16 +- source/title.cpp | 10 +- source/utils.h | 2 +- 16 files changed, 467 insertions(+), 523 deletions(-) diff --git a/source/define_buttons.cpp b/source/define_buttons.cpp index 2504c63..bd9b606 100644 --- a/source/define_buttons.cpp +++ b/source/define_buttons.cpp @@ -24,27 +24,27 @@ DefineButtons::DefineButtons(std::unique_ptr text_) DefineButtonsButton button; button.label = lang::getText(95); - button.input = input_fire_left; + button.input = InputType::FIRE_LEFT; button.button = SDL_CONTROLLER_BUTTON_X; buttons_.push_back(button); button.label = lang::getText(96); - button.input = input_fire_center; + button.input = InputType::FIRE_CENTER; button.button = SDL_CONTROLLER_BUTTON_Y; buttons_.push_back(button); button.label = lang::getText(97); - button.input = input_fire_right; + button.input = InputType::FIRE_RIGHT; button.button = SDL_CONTROLLER_BUTTON_RIGHTSHOULDER; buttons_.push_back(button); button.label = lang::getText(98); - button.input = input_start; + button.input = InputType::START; button.button = SDL_CONTROLLER_BUTTON_START; buttons_.push_back(button); button.label = lang::getText(99); - button.input = input_exit; + button.input = InputType::EXIT; button.button = SDL_CONTROLLER_BUTTON_BACK; buttons_.push_back(button); @@ -155,7 +155,7 @@ void DefineButtons::incIndexButton() // Guarda los cambios en las opciones saveBindingsToOptions(); - input_->allActive(index_controller_); + //input_->allActive(index_controller_); // Reinicia variables index_button_ = 0; diff --git a/source/define_buttons.h b/source/define_buttons.h index 3c6f902..e0e4c58 100644 --- a/source/define_buttons.h +++ b/source/define_buttons.h @@ -11,7 +11,7 @@ struct DefineButtonsButton { std::string label; // Texto en pantalla para el botón - inputs_e input; // Input asociado + InputType input; // Input asociado SDL_GameControllerButton button; // Botón del mando correspondiente }; diff --git a/source/director.cpp b/source/director.cpp index 584e703..bbfaf46 100644 --- a/source/director.cpp +++ b/source/director.cpp @@ -132,65 +132,59 @@ Director::~Director() /// Inicializa el objeto input void Director::initInput() { - // Establece si ha de mostrar mensajes -#ifdef VERBOSE - Input::get()->setVerbose(true); -#else - Input::get()->setVerbose(false); -#endif // Busca si hay mandos conectados Input::get()->discoverGameControllers(); // Teclado - Movimiento del jugador - Input::get()->bindKey(input_up, SDL_SCANCODE_UP); - Input::get()->bindKey(input_down, SDL_SCANCODE_DOWN); - Input::get()->bindKey(input_left, SDL_SCANCODE_LEFT); - Input::get()->bindKey(input_right, SDL_SCANCODE_RIGHT); + Input::get()->bindKey(InputType::UP, SDL_SCANCODE_UP); + Input::get()->bindKey(InputType::DOWN, SDL_SCANCODE_DOWN); + Input::get()->bindKey(InputType::LEFT, SDL_SCANCODE_LEFT); + Input::get()->bindKey(InputType::RIGHT, SDL_SCANCODE_RIGHT); - Input::get()->bindKey(input_fire_left, SDL_SCANCODE_Q); - Input::get()->bindKey(input_fire_center, SDL_SCANCODE_W); - Input::get()->bindKey(input_fire_right, SDL_SCANCODE_E); + Input::get()->bindKey(InputType::FIRE_LEFT, SDL_SCANCODE_Q); + Input::get()->bindKey(InputType::FIRE_CENTER, SDL_SCANCODE_W); + Input::get()->bindKey(InputType::FIRE_RIGHT, SDL_SCANCODE_E); - Input::get()->bindKey(input_start, SDL_SCANCODE_RETURN); + Input::get()->bindKey(InputType::START, SDL_SCANCODE_RETURN); // Teclado - Control del programa - Input::get()->bindKey(input_service, SDL_SCANCODE_0); - Input::get()->bindKey(input_exit, SDL_SCANCODE_ESCAPE); - Input::get()->bindKey(input_pause, SDL_SCANCODE_P); - Input::get()->bindKey(input_window_dec_size, SDL_SCANCODE_F1); - Input::get()->bindKey(input_window_inc_size, SDL_SCANCODE_F2); - Input::get()->bindKey(input_window_fullscreen, SDL_SCANCODE_F3); - Input::get()->bindKey(input_video_shaders, SDL_SCANCODE_F4); - Input::get()->bindKey(input_mute, SDL_SCANCODE_F5); - Input::get()->bindKey(input_showinfo, SDL_SCANCODE_F6); - Input::get()->bindKey(input_reset, SDL_SCANCODE_F10); + Input::get()->bindKey(InputType::SERVICE, SDL_SCANCODE_0); + Input::get()->bindKey(InputType::EXIT, SDL_SCANCODE_ESCAPE); + Input::get()->bindKey(InputType::PAUSE, SDL_SCANCODE_P); + Input::get()->bindKey(InputType::WINDOW_DEC_SIZE, SDL_SCANCODE_F1); + Input::get()->bindKey(InputType::WINDOW_INC_SIZE, SDL_SCANCODE_F2); + Input::get()->bindKey(InputType::WINDOW_FULLSCREEN, SDL_SCANCODE_F3); + Input::get()->bindKey(InputType::VIDEO_SHADERS, SDL_SCANCODE_F4); + Input::get()->bindKey(InputType::MUTE, SDL_SCANCODE_F5); + Input::get()->bindKey(InputType::SHOWINFO, SDL_SCANCODE_F6); + Input::get()->bindKey(InputType::RESET, SDL_SCANCODE_F10); // Asigna botones a inputs const int numGamePads = Input::get()->getNumControllers(); for (int i = 0; i < numGamePads; ++i) { // Mando - Movimiento del jugador - Input::get()->bindGameControllerButton(i, input_up, SDL_CONTROLLER_BUTTON_DPAD_UP); - Input::get()->bindGameControllerButton(i, input_down, SDL_CONTROLLER_BUTTON_DPAD_DOWN); - Input::get()->bindGameControllerButton(i, input_left, SDL_CONTROLLER_BUTTON_DPAD_LEFT); - Input::get()->bindGameControllerButton(i, input_right, SDL_CONTROLLER_BUTTON_DPAD_RIGHT); + Input::get()->bindGameControllerButton(i, InputType::UP, SDL_CONTROLLER_BUTTON_DPAD_UP); + Input::get()->bindGameControllerButton(i, InputType::DOWN, SDL_CONTROLLER_BUTTON_DPAD_DOWN); + Input::get()->bindGameControllerButton(i, InputType::LEFT, SDL_CONTROLLER_BUTTON_DPAD_LEFT); + Input::get()->bindGameControllerButton(i, InputType::RIGHT, SDL_CONTROLLER_BUTTON_DPAD_RIGHT); - Input::get()->bindGameControllerButton(i, input_fire_left, SDL_CONTROLLER_BUTTON_X); - Input::get()->bindGameControllerButton(i, input_fire_center, SDL_CONTROLLER_BUTTON_Y); - Input::get()->bindGameControllerButton(i, input_fire_right, SDL_CONTROLLER_BUTTON_B); + Input::get()->bindGameControllerButton(i, InputType::FIRE_LEFT, SDL_CONTROLLER_BUTTON_X); + Input::get()->bindGameControllerButton(i, InputType::FIRE_CENTER, SDL_CONTROLLER_BUTTON_Y); + Input::get()->bindGameControllerButton(i, InputType::FIRE_RIGHT, SDL_CONTROLLER_BUTTON_B); - Input::get()->bindGameControllerButton(i, input_start, SDL_CONTROLLER_BUTTON_START); + Input::get()->bindGameControllerButton(i, InputType::START, SDL_CONTROLLER_BUTTON_START); // Mando - Control del programa - Input::get()->bindGameControllerButton(i, input_service, SDL_CONTROLLER_BUTTON_BACK); - Input::get()->bindGameControllerButton(i, input_exit, input_start); - Input::get()->bindGameControllerButton(i, input_pause, input_fire_right); - Input::get()->bindGameControllerButton(i, input_video_shaders, input_fire_left); - Input::get()->bindGameControllerButton(i, input_mute, input_left); - Input::get()->bindGameControllerButton(i, input_showinfo, input_right); - Input::get()->bindGameControllerButton(i, input_reset, input_fire_center); - Input::get()->bindGameControllerButton(i, input_config, input_down); - Input::get()->bindGameControllerButton(i, input_swap_controllers, input_up); + Input::get()->bindGameControllerButton(i, InputType::SERVICE, SDL_CONTROLLER_BUTTON_BACK); + Input::get()->bindGameControllerButton(i, InputType::EXIT, InputType::START); + Input::get()->bindGameControllerButton(i, InputType::PAUSE, InputType::FIRE_RIGHT); + Input::get()->bindGameControllerButton(i, InputType::VIDEO_SHADERS, InputType::FIRE_LEFT); + Input::get()->bindGameControllerButton(i, InputType::MUTE, InputType::LEFT); + Input::get()->bindGameControllerButton(i, InputType::SHOWINFO, InputType::RIGHT); + Input::get()->bindGameControllerButton(i, InputType::RESET, InputType::FIRE_CENTER); + Input::get()->bindGameControllerButton(i, InputType::CONFIG, InputType::DOWN); + Input::get()->bindGameControllerButton(i, InputType::SWAP_CONTROLLERS, InputType::UP); } // Mapea las asignaciones a los botones desde el archivo de configuración, si se da el caso @@ -208,14 +202,14 @@ void Director::initInput() // Asigna botones a inputs desde otros inputs for (int i = 0; i < numGamePads; ++i) { - Input::get()->bindGameControllerButton(i, input_exit, input_start); - Input::get()->bindGameControllerButton(i, input_reset, input_fire_center); - Input::get()->bindGameControllerButton(i, input_pause, input_fire_right); - Input::get()->bindGameControllerButton(i, input_video_shaders, input_fire_left); - Input::get()->bindGameControllerButton(i, input_mute, input_left); - Input::get()->bindGameControllerButton(i, input_showinfo, input_right); - Input::get()->bindGameControllerButton(i, input_config, input_down); - Input::get()->bindGameControllerButton(i, input_swap_controllers, input_up); + Input::get()->bindGameControllerButton(i, InputType::EXIT, InputType::START); + Input::get()->bindGameControllerButton(i, InputType::RESET, InputType::FIRE_CENTER); + Input::get()->bindGameControllerButton(i, InputType::PAUSE, InputType::FIRE_RIGHT); + Input::get()->bindGameControllerButton(i, InputType::VIDEO_SHADERS, InputType::FIRE_LEFT); + Input::get()->bindGameControllerButton(i, InputType::MUTE, InputType::LEFT); + Input::get()->bindGameControllerButton(i, InputType::SHOWINFO, InputType::RIGHT); + Input::get()->bindGameControllerButton(i, InputType::CONFIG, InputType::DOWN); + Input::get()->bindGameControllerButton(i, InputType::SWAP_CONTROLLERS, InputType::UP); } // Guarda las asignaciones de botones en las opciones diff --git a/source/game.cpp b/source/game.cpp index c653cdd..7ce17bc 100644 --- a/source/game.cpp +++ b/source/game.cpp @@ -1972,7 +1972,7 @@ void Game::checkInput() for (int i = 0; i < input_->getNumControllers(); ++i) { // Comprueba si se va a pausar el juego - if (input_->checkModInput(input_service, input_pause, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i)) + if (input_->checkModInput(InputType::SERVICE, InputType::PAUSE, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i)) { pause(!paused_); return; @@ -1990,17 +1990,17 @@ void Game::checkInput() // Comprueba direcciones if (demo_.data_file[i][demo_.counter].left == 1) { - player->setInput(input_left); + player->setInput(InputType::LEFT); } else if (demo_.data_file[i][demo_.counter].right == 1) { - player->setInput(input_right); + player->setInput(InputType::RIGHT); } else if (demo_.data_file[i][demo_.counter].no_input == 1) { - player->setInput(input_null); + player->setInput(InputType::NONE); } // Comprueba botones @@ -2008,7 +2008,7 @@ void Game::checkInput() { if (player->canFire()) { - player->setInput(input_fire_center); + player->setInput(InputType::FIRE_CENTER); createBullet(player->getPosX() + (player->getWidth() / 2) - 4, player->getPosY() + (player->getHeight() / 2), BulletType::UP, player->isPowerUp(), player->getId()); player->setFireCooldown(10); } @@ -2018,7 +2018,7 @@ void Game::checkInput() { if (player->canFire()) { - player->setInput(input_fire_left); + player->setInput(InputType::FIRE_LEFT); createBullet(player->getPosX() + (player->getWidth() / 2) - 4, player->getPosY() + (player->getHeight() / 2), BulletType::LEFT, player->isPowerUp(), player->getId()); player->setFireCooldown(10); } @@ -2028,7 +2028,7 @@ void Game::checkInput() { if (player->canFire()) { - player->setInput(input_fire_right); + player->setInput(InputType::FIRE_RIGHT); createBullet(player->getPosX() + (player->getWidth() / 2) - 4, player->getPosY() + (player->getHeight() / 2), BulletType::RIGHT, player->isPowerUp(), player->getId()); player->setFireCooldown(10); } @@ -2064,9 +2064,9 @@ void Game::checkInput() if (player->isPlaying()) { // Input a la izquierda - if (input_->checkInput(input_left, INPUT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index)) + if (input_->checkInput(InputType::LEFT, INPUT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index)) { - player->setInput(input_left); + player->setInput(InputType::LEFT); #ifdef RECORDING demo.keys.left = 1; #endif @@ -2074,9 +2074,9 @@ void Game::checkInput() else { // Input a la derecha - if (input_->checkInput(input_right, INPUT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index)) + if (input_->checkInput(InputType::RIGHT, INPUT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index)) { - player->setInput(input_right); + player->setInput(InputType::RIGHT); #ifdef RECORDING demo.keys.right = 1; #endif @@ -2084,18 +2084,18 @@ void Game::checkInput() else { // Ninguno de los dos inputs anteriores - player->setInput(input_null); + player->setInput(InputType::NONE); #ifdef RECORDING demo.keys.no_input = 1; #endif } } // Comprueba el input de disparar al centro - if (input_->checkInput(input_fire_center, autofire, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index)) + if (input_->checkInput(InputType::FIRE_CENTER, autofire, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index)) { if (player->canFire()) { - player->setInput(input_fire_center); + player->setInput(InputType::FIRE_CENTER); createBullet(player->getPosX() + (player->getWidth() / 2) - 4, player->getPosY() + (player->getHeight() / 2), BulletType::UP, player->isPowerUp(), player->getId()); player->setFireCooldown(10); @@ -2108,11 +2108,11 @@ void Game::checkInput() } // Comprueba el input de disparar a la izquierda - else if (input_->checkInput(input_fire_left, autofire, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index)) + else if (input_->checkInput(InputType::FIRE_LEFT, autofire, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index)) { if (player->canFire()) { - player->setInput(input_fire_left); + player->setInput(InputType::FIRE_LEFT); createBullet(player->getPosX() + (player->getWidth() / 2) - 4, player->getPosY() + (player->getHeight() / 2), BulletType::LEFT, player->isPowerUp(), player->getId()); player->setFireCooldown(10); @@ -2125,11 +2125,11 @@ void Game::checkInput() } // Comprueba el input de disparar a la derecha - else if (input_->checkInput(input_fire_right, autofire, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index)) + else if (input_->checkInput(InputType::FIRE_RIGHT, autofire, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index)) { if (player->canFire()) { - player->setInput(input_fire_right); + player->setInput(InputType::FIRE_RIGHT); createBullet(player->getPosX() + (player->getWidth() / 2) - 4, player->getPosY() + (player->getHeight() / 2), BulletType::RIGHT, player->isPowerUp(), player->getId()); player->setFireCooldown(10); @@ -2153,15 +2153,15 @@ void Game::checkInput() else if (player->isContinue() || player->isWaiting()) { // Si no está jugando, el botón de start le permite continuar jugando - if (input_->checkInput(input_start, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index)) + if (input_->checkInput(InputType::START, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index)) { player->setStatusPlaying(PlayerStatus::PLAYING); } // Si está continuando, los botones de fuego hacen decrementar el contador - const auto fire1 = input_->checkInput(input_fire_left, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index); - const auto fire2 = input_->checkInput(input_fire_center, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index); - const auto fire3 = input_->checkInput(input_fire_right, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index); + const auto fire1 = input_->checkInput(InputType::FIRE_LEFT, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index); + const auto fire2 = input_->checkInput(InputType::FIRE_CENTER, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index); + const auto fire3 = input_->checkInput(InputType::FIRE_RIGHT, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index); if (fire1 || fire2 || fire3) { player->decContinueCounter(); @@ -2169,41 +2169,41 @@ void Game::checkInput() } else if (player->isEnteringName()) { - const auto fire1 = input_->checkInput(input_fire_left, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index); - const auto fire2 = input_->checkInput(input_fire_center, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index); - const auto fire3 = input_->checkInput(input_fire_right, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index); + const auto fire1 = input_->checkInput(InputType::FIRE_LEFT, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index); + const auto fire2 = input_->checkInput(InputType::FIRE_CENTER, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index); + const auto fire3 = input_->checkInput(InputType::FIRE_RIGHT, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index); if (fire1 || fire2 || fire3) { if (player->getRecordNamePos() == 7) { - player->setInput(input_start); + player->setInput(InputType::START); addScoreToScoreBoard(player->getRecordName(), player->getScore()); player->setStatusPlaying(PlayerStatus::CONTINUE); } else { - player->setInput(input_right); + player->setInput(InputType::RIGHT); } } - else if (input_->checkInput(input_up, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index)) + else if (input_->checkInput(InputType::UP, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index)) { - player->setInput(input_up); + player->setInput(InputType::UP); } - else if (input_->checkInput(input_down, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index)) + else if (input_->checkInput(InputType::DOWN, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index)) { - player->setInput(input_down); + player->setInput(InputType::DOWN); } - else if (input_->checkInput(input_left, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index)) + else if (input_->checkInput(InputType::LEFT, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index)) { - player->setInput(input_left); + player->setInput(InputType::LEFT); } - else if (input_->checkInput(input_right, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index)) + else if (input_->checkInput(InputType::RIGHT, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index)) { - player->setInput(input_right); + player->setInput(InputType::RIGHT); } - else if (input_->checkInput(input_start, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index)) + else if (input_->checkInput(InputType::START, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index)) { - player->setInput(input_start); + player->setInput(InputType::START); addScoreToScoreBoard(player->getRecordName(), player->getScore()); player->setStatusPlaying(PlayerStatus::CONTINUE); } diff --git a/source/global_inputs.cpp b/source/global_inputs.cpp index 4cf192b..403867f 100644 --- a/source/global_inputs.cpp +++ b/source/global_inputs.cpp @@ -12,16 +12,16 @@ namespace globalInputs { // Variables - std::vector servicePressedCounter; + std::vector service_pressed_counter; // Inicializa variables void init() { - const auto numInputs = Input::get()->getNumControllers() + 1; - servicePressedCounter.reserve(numInputs); - for (int i = 0; i < numInputs; ++i) + const auto num_inputs = Input::get()->getNumControllers() + 1; + service_pressed_counter.reserve(num_inputs); + for (int i = 0; i < num_inputs; ++i) { - servicePressedCounter.push_back(0); + service_pressed_counter.push_back(0); } } @@ -59,78 +59,78 @@ namespace globalInputs void check() { // Comprueba si se sale con el teclado - if (Input::get()->checkInput(input_exit, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD)) + if (Input::get()->checkInput(InputType::EXIT, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD)) { quit(section::Options::QUIT_NORMAL); return; } // Comprueba si se va a resetear el juego - else if (Input::get()->checkInput(input_reset, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD)) + else if (Input::get()->checkInput(InputType::RESET, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD)) { reset(); return; } - else if (Input::get()->checkInput(input_mute, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD)) + else if (Input::get()->checkInput(InputType::MUTE, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD)) { switchAudio(); return; } - else if (Input::get()->checkInput(input_service, INPUT_ALLOW_REPEAT, INPUT_USE_KEYBOARD)) + else if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, INPUT_USE_KEYBOARD)) { - servicePressedCounter[0]++; + service_pressed_counter[0]++; - if (servicePressedCounter[0] >= 3000) + if (service_pressed_counter[0] >= 3000) { OnScreenHelp::get()->toggleState(); - servicePressedCounter[0] = 0; + service_pressed_counter[0] = 0; } return; } else { - servicePressedCounter[0] = 0; + service_pressed_counter[0] = 0; } for (int i = 0; i < Input::get()->getNumControllers(); ++i) { // Comprueba si se sale con el mando - if (Input::get()->checkModInput(input_service, input_exit, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i)) + if (Input::get()->checkModInput(InputType::SERVICE, InputType::EXIT, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i)) { quit(section::Options::QUIT_SHUTDOWN); return; } // Comprueba si se va a resetear el juego - else if (Input::get()->checkModInput(input_service, input_reset, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i)) + else if (Input::get()->checkModInput(InputType::SERVICE, InputType::RESET, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i)) { reset(); return; } // Comprueba si se va a activar o desactivar el audio - else if (Input::get()->checkModInput(input_service, input_mute, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i)) + else if (Input::get()->checkModInput(InputType::SERVICE, InputType::MUTE, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i)) { switchAudio(); return; } - if (Input::get()->checkInput(input_service, INPUT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i)) + if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i)) { - servicePressedCounter[i + 1]++; + service_pressed_counter[i + 1]++; - if (servicePressedCounter[i + 1] >= 3000) + if (service_pressed_counter[i + 1] >= 3000) { OnScreenHelp::get()->toggleState(); - servicePressedCounter[i + 1] = 0; + service_pressed_counter[i + 1] = 0; } return; } else { - servicePressedCounter[i + 1] = 0; + service_pressed_counter[i + 1] = 0; } } } diff --git a/source/global_inputs.h b/source/global_inputs.h index 9275630..66fa1a5 100644 --- a/source/global_inputs.h +++ b/source/global_inputs.h @@ -1,7 +1,7 @@ #include namespace globalInputs { -extern std::vector servicePressedCounter; + extern std::vector service_pressed_counter; // Inicializa variables void init(); diff --git a/source/hiscore_table.cpp b/source/hiscore_table.cpp index 560e7e7..ec1fe02 100644 --- a/source/hiscore_table.cpp +++ b/source/hiscore_table.cpp @@ -19,40 +19,39 @@ // Constructor HiScoreTable::HiScoreTable(JA_Music_t *music) - : music(music) + : music_(music) { // Copia punteros - renderer = Screen::get()->getRenderer(); + renderer_ = Screen::get()->getRenderer(); // Objetos - eventHandler = std::make_unique(); - fade = std::make_unique(renderer); - background = std::make_unique(renderer); - text = std::make_unique(Asset::get()->get("smb2.gif"), Asset::get()->get("smb2.txt"), renderer); + fade_ = std::make_unique(renderer_); + background_ = std::make_unique(renderer_); + text_ = std::make_unique(Asset::get()->get("smb2.gif"), Asset::get()->get("smb2.txt"), renderer_); // Crea un backbuffer para el renderizador - backbuffer = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height); - SDL_SetTextureBlendMode(backbuffer, SDL_BLENDMODE_BLEND); + backbuffer_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height); + SDL_SetTextureBlendMode(backbuffer_, SDL_BLENDMODE_BLEND); // Inicializa variables section::name = section::Name::HI_SCORE_TABLE; - ticks = 0; - ticksSpeed = 15; - counter = 0; - counterEnd = 800; - viewArea = {0, 0, param.game.width, param.game.height}; - fadeMode = FadeMode::IN; + ticks_ = 0; + ticks_speed_ = 15; + counter_ = 0; + counter_end_ = 800; + view_area_ = {0, 0, param.game.width, param.game.height}; + fade_mode_ = FadeMode::IN; // Inicializa objetos - background->setPos(param.game.game_area.rect); - background->setCloudsSpeed(-0.1f); - background->setGradientNumber(1); - background->setTransition(0.8f); - fade->setColor(fade_color.r, fade_color.g, fade_color.b); - fade->setType(FadeType::RANDOM_SQUARE); - fade->setPost(param.fade.post_duration); - fade->setMode(fadeMode); - fade->activate(); + background_->setPos(param.game.game_area.rect); + background_->setCloudsSpeed(-0.1f); + background_->setGradientNumber(1); + background_->setTransition(0.8f); + fade_->setColor(fade_color.r, fade_color.g, fade_color.b); + fade_->setType(FadeType::RANDOM_SQUARE); + fade_->setPost(param.fade.post_duration); + fade_->setMode(fade_mode_); + fade_->activate(); // Crea el contenido de la textura con la lista de puntuaciones fillTexture(); @@ -61,45 +60,45 @@ HiScoreTable::HiScoreTable(JA_Music_t *music) // Destructor HiScoreTable::~HiScoreTable() { - SDL_DestroyTexture(backbuffer); + SDL_DestroyTexture(backbuffer_); } // Actualiza las variables void HiScoreTable::update() { // Actualiza las variables - if (SDL_GetTicks() - ticks > ticksSpeed) + if (SDL_GetTicks() - ticks_ > ticks_speed_) { // Actualiza el contador de ticks - ticks = SDL_GetTicks(); + ticks_ = SDL_GetTicks(); // Mantiene la música sonando if ((JA_GetMusicState() == JA_MUSIC_INVALID) || (JA_GetMusicState() == JA_MUSIC_STOPPED)) { - JA_PlayMusic(music); + JA_PlayMusic(music_); } // Actualiza el objeto screen Screen::get()->update(); // Actualiza el fondo - background->update(); + background_->update(); // Gestiona el fade updateFade(); // Gestiona el contador y sus eventos - counter++; + counter_++; - if (counter == 150) + if (counter_ == 150) { - background->setColor({0, 0, 0}); - background->setAlpha(96); + background_->setColor({0, 0, 0}); + background_->setAlpha(96); } - if (counter == counterEnd) + if (counter_ == counter_end_) { - fade->activate(); + fade_->activate(); } } } @@ -107,40 +106,40 @@ void HiScoreTable::update() // Crea el contenido de la textura con la lista de puntuaciones void HiScoreTable::fillTexture() { - // hay 27 letras - 7 de puntos quedan 20 caracteres 20 - nameLenght 0 numDots - constexpr auto maxNames = 10; - constexpr auto spaceBetweenHeader = 32; - const auto spaceBetweenLines = text->getCharacterSize() * 2.0f; - const auto size = spaceBetweenHeader + spaceBetweenLines * (maxNames - 1) + text->getCharacterSize(); - const auto firstLine = (param.game.height - size) / 2; + // hay 27 letras - 7 de puntos quedan 20 caracteres 20 - name_lenght 0 num_dots + constexpr auto max_names = 10; + constexpr auto space_between_header = 32; + const auto space_between_lines = text_->getCharacterSize() * 2.0f; + const auto size = space_between_header + space_between_lines * (max_names - 1) + text_->getCharacterSize(); + const auto first_line = (param.game.height - size) / 2; // Pinta en el backbuffer el texto y los sprites - auto temp = SDL_GetRenderTarget(renderer); - SDL_SetRenderTarget(renderer, backbuffer); - SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0); - SDL_RenderClear(renderer); + auto temp = SDL_GetRenderTarget(renderer_); + SDL_SetRenderTarget(renderer_, backbuffer_); + SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 0); + SDL_RenderClear(renderer_); // Escribe el texto: Mejores puntuaciones - text->writeDX(TEXT_CENTER | TEXT_COLOR | TEXT_SHADOW, param.game.game_area.center_x, firstLine, lang::getText(42), 1, orange_color, 1, shdw_txt_color); + text_->writeDX(TEXT_CENTER | TEXT_COLOR | TEXT_SHADOW, param.game.game_area.center_x, first_line, lang::getText(42), 1, orange_color, 1, shdw_txt_color); // Escribe los nombres de la tabla de puntuaciones - for (int i = 0; i < maxNames; ++i) + for (int i = 0; i < max_names; ++i) { - const auto nameLenght = options.game.hi_score_table[i].name.length(); + const auto name_lenght = options.game.hi_score_table[i].name.length(); const auto score = format(options.game.hi_score_table[i].score); - const auto scoreLenght = score.size(); - const auto numDots = 25 - nameLenght - scoreLenght; + const auto score_lenght = score.size(); + const auto num_dots = 25 - name_lenght - score_lenght; std::string dots = ""; - for (int j = 0; j < (int)numDots; ++j) + for (int j = 0; j < (int)num_dots; ++j) { dots = dots + "."; } const auto line = options.game.hi_score_table[i].name + dots + score; - text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, (i * spaceBetweenLines) + firstLine + spaceBetweenHeader, line, 1, orange_color, 1, shdw_txt_color); + text_->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, (i * space_between_lines) + first_line + space_between_header, line, 1, orange_color, 1, shdw_txt_color); } // Cambia el destino de renderizado - SDL_SetRenderTarget(renderer, temp); + SDL_SetRenderTarget(renderer_, temp); } // Pinta en pantalla @@ -153,16 +152,16 @@ void HiScoreTable::render() Screen::get()->clean(bg_color); // Pinta el fondo - background->render(); + background_->render(); // Establece la ventana del backbuffer - viewArea.y = std::max(0, param.game.height - counter + 100); + view_area_.y = std::max(0, param.game.height - counter_ + 100); // Copia el backbuffer al renderizador - SDL_RenderCopy(renderer, backbuffer, nullptr, &viewArea); + SDL_RenderCopy(renderer_, backbuffer_, nullptr, &view_area_); // Renderiza el fade - fade->render(); + fade_->render(); // Vuelca el contenido del renderizador en pantalla Screen::get()->blit(); @@ -171,7 +170,7 @@ void HiScoreTable::render() // Recarga todas las texturas void HiScoreTable::reloadTextures() { - text->reLoadTexture(); + text_->reLoadTexture(); fillTexture(); } @@ -179,19 +178,20 @@ void HiScoreTable::reloadTextures() void HiScoreTable::checkEvents() { // Comprueba los eventos que hay en la cola - while (SDL_PollEvent(eventHandler.get()) != 0) + SDL_Event event; + while (SDL_PollEvent(&event)) { // Evento de salida de la aplicación - if (eventHandler->type == SDL_QUIT) + if (event.type == SDL_QUIT) { section::name = section::Name::QUIT; break; } // Comprueba si se ha cambiado el tamaño de la ventana - else if (eventHandler->type == SDL_WINDOWEVENT) + else if (event.type == SDL_WINDOWEVENT) { - if (eventHandler->window.event == SDL_WINDOWEVENT_SIZE_CHANGED) + if (event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED) { reloadTextures(); } @@ -233,16 +233,16 @@ void HiScoreTable::run() // Gestiona el fade void HiScoreTable::updateFade() { - fade->update(); + fade_->update(); - if (fade->hasEnded() && fadeMode == FadeMode::IN) + if (fade_->hasEnded() && fade_mode_ == FadeMode::IN) { - fade->reset(); - fadeMode = FadeMode::OUT; - fade->setMode(fadeMode); + fade_->reset(); + fade_mode_ = FadeMode::OUT; + fade_->setMode(fade_mode_); } - if (fade->hasEnded() && fadeMode == FadeMode::OUT) + if (fade_->hasEnded() && fade_mode_ == FadeMode::OUT) { section::name = section::Name::INSTRUCTIONS; } diff --git a/source/hiscore_table.h b/source/hiscore_table.h index 965592e..8721d63 100644 --- a/source/hiscore_table.h +++ b/source/hiscore_table.h @@ -28,22 +28,21 @@ class HiScoreTable { private: // Objetos y punteros - SDL_Renderer *renderer; // El renderizador de la ventana - SDL_Texture *backbuffer; // Textura para usar como backbuffer - JA_Music_t *music; // Musica de fondo + SDL_Renderer *renderer_; // El renderizador de la ventana + SDL_Texture *backbuffer_; // Textura para usar como backbuffer + JA_Music_t *music_; // Musica de fondo - std::unique_ptr fade; // Objeto para renderizar fades - std::unique_ptr background; // Objeto para dibujar el fondo del juego - std::unique_ptr eventHandler; // Manejador de eventos - std::unique_ptr text; // Objeto para escribir texto + std::unique_ptr fade_; // Objeto para renderizar fades + std::unique_ptr background_; // Objeto para dibujar el fondo del juego + std::unique_ptr text_; // Objeto para escribir texto // Variables - Uint16 counter; // Contador - Uint16 counterEnd; // Valor final para el contador - Uint32 ticks; // Contador de ticks para ajustar la velocidad del programa - Uint32 ticksSpeed; // Velocidad a la que se repiten los bucles del programa - SDL_Rect viewArea; // Parte de la textura que se muestra en pantalla - FadeMode fadeMode; // Modo de fade a utilizar + Uint16 counter_; // Contador + Uint16 counter_end_; // Valor final para el contador + Uint32 ticks_; // Contador de ticks para ajustar la velocidad del programa + Uint32 ticks_speed_; // Velocidad a la que se repiten los bucles del programa + SDL_Rect view_area_; // Parte de la textura que se muestra en pantalla + FadeMode fade_mode_; // Modo de fade a utilizar // Actualiza las variables void update(); diff --git a/source/input.cpp b/source/input.cpp index 7f0d5c5..2d74762 100644 --- a/source/input.cpp +++ b/source/input.cpp @@ -6,122 +6,108 @@ #include // for basic_ostream, operator<<, cout, basi... // [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado -Input *Input::input = nullptr; +Input *Input::input_ = nullptr; // [SINGLETON] Crearemos el objeto input con esta función estática -void Input::init(std::string dbPath) +void Input::init(std::string game_controller_db_path) { - Input::input = new Input(dbPath); + Input::input_ = new Input(game_controller_db_path); } // [SINGLETON] Destruiremos el objeto input con esta función estática void Input::destroy() { - delete Input::input; + delete Input::input_; } // [SINGLETON] Con este método obtenemos el objeto input y podemos trabajar con él Input *Input::get() { - return Input::input; + return Input::input_; } // Constructor -Input::Input(std::string dbPath) - : dbPath(dbPath) +Input::Input(std::string game_controller_db_path) + : game_controller_db_path_(game_controller_db_path) { // Inicializa variables - verbose = false; - enabled = true; + enabled_ = true; // Busca si hay mandos conectados discoverGameControllers(); // Inicializa las vectores - keyBindings_t kb; + KeyBindings kb; kb.scancode = 0; kb.active = false; - keyBindings.resize(input_number_of_inputs, kb); + key_bindings_.resize(static_cast(InputType::NUMBER_OF_INPUTS), kb); - GameControllerBindings_t gcb; + ControllerBindings gcb; gcb.button = SDL_CONTROLLER_BUTTON_INVALID; gcb.active = false; - gameControllerBindings.resize(numGamepads); - for (int i = 0; i < numGamepads; ++i) + controller_bindings_.resize(num_gamepads_); + for (int i = 0; i < num_gamepads_; ++i) { - gameControllerBindings[i].resize(input_number_of_inputs, gcb); + controller_bindings_[i].resize(static_cast(InputType::NUMBER_OF_INPUTS), gcb); } // Listado de los inputs usados para jugar, excluyendo botones para la interfaz - gameInputs.clear(); - gameInputs.push_back(input_fire_left); - gameInputs.push_back(input_fire_center); - gameInputs.push_back(input_fire_right); - gameInputs.push_back(input_up); - gameInputs.push_back(input_down); - gameInputs.push_back(input_left); - gameInputs.push_back(input_right); + game_inputs_.clear(); + game_inputs_.push_back(InputType::FIRE_LEFT); + game_inputs_.push_back(InputType::FIRE_CENTER); + game_inputs_.push_back(InputType::FIRE_RIGHT); + game_inputs_.push_back(InputType::UP); + game_inputs_.push_back(InputType::DOWN); + game_inputs_.push_back(InputType::LEFT); + game_inputs_.push_back(InputType::RIGHT); // Listado de los inputs para jugar que utilizan botones, ni palancas ni crucetas - buttonInputs.clear(); - buttonInputs.push_back(input_fire_left); - buttonInputs.push_back(input_fire_center); - buttonInputs.push_back(input_fire_right); - buttonInputs.push_back(input_start); -} - -// Destructor -Input::~Input() -{ -} - -// Actualiza el estado del objeto -void Input::update() -{ - if (disabledUntil == d_keyPressed && !checkAnyInput()) - { - enable(); - } + button_inputs_.clear(); + button_inputs_.push_back(InputType::FIRE_LEFT); + button_inputs_.push_back(InputType::FIRE_CENTER); + button_inputs_.push_back(InputType::FIRE_RIGHT); + button_inputs_.push_back(InputType::START); } // Asigna inputs a teclas -void Input::bindKey(inputs_e input, SDL_Scancode code) +void Input::bindKey(InputType input, SDL_Scancode code) { - keyBindings[input].scancode = code; + key_bindings_[static_cast(input)].scancode = code; } // Asigna inputs a botones del mando -void Input::bindGameControllerButton(int index, inputs_e input, SDL_GameControllerButton button) +void Input::bindGameControllerButton(int controller_index, InputType input, SDL_GameControllerButton button) { - if (index < numGamepads) + if (controller_index < num_gamepads_) { - gameControllerBindings[index][input].button = button; + controller_bindings_[controller_index][static_cast(input)].button = button; } } // Asigna inputs a botones del mando -void Input::bindGameControllerButton(int index, inputs_e inputTarget, inputs_e inputSource) +void Input::bindGameControllerButton(int controller_index, InputType input_target, InputType input_source) { - if (index < numGamepads) + if (controller_index < num_gamepads_) { - gameControllerBindings[index][inputTarget].button = gameControllerBindings[index][inputSource].button; + controller_bindings_[controller_index][static_cast(input_target)].button = controller_bindings_[controller_index][static_cast(input_source)].button; } } // Comprueba si un input esta activo -bool Input::checkInput(inputs_e input, bool repeat, int device, int index) +bool Input::checkInput(InputType input, bool repeat, int device, int controller_index) { - if (!enabled) + if (!enabled_) { return false; } - bool successKeyboard = false; - bool successGameController = false; + bool success_keyboard = false; + bool success_controller = false; + const int input_index = static_cast(input); if (device == INPUT_USE_ANY) { - index = 0; + controller_index = 0; } if (device == INPUT_USE_KEYBOARD || device == INPUT_USE_ANY) @@ -130,108 +116,109 @@ bool Input::checkInput(inputs_e input, bool repeat, int device, int index) if (repeat) { - if (keyStates[keyBindings[input].scancode] != 0) + if (keyStates[key_bindings_[input_index].scancode] != 0) { - successKeyboard = true; + success_keyboard = true; } else { - successKeyboard = false; + success_keyboard = false; } } else { - if (!keyBindings[input].active) + if (!key_bindings_[input_index].active) { - if (keyStates[keyBindings[input].scancode] != 0) + if (keyStates[key_bindings_[input_index].scancode] != 0) { - keyBindings[input].active = true; - successKeyboard = true; + key_bindings_[input_index].active = true; + success_keyboard = true; } else { - successKeyboard = false; + success_keyboard = false; } } else { - if (keyStates[keyBindings[input].scancode] == 0) + if (keyStates[key_bindings_[input_index].scancode] == 0) { - keyBindings[input].active = false; - successKeyboard = false; + key_bindings_[input_index].active = false; + success_keyboard = false; } else { - successKeyboard = false; + success_keyboard = false; } } } } - if (gameControllerFound() && index < numGamepads) + if (gameControllerFound() && controller_index < num_gamepads_) if ((device == INPUT_USE_GAMECONTROLLER) || (device == INPUT_USE_ANY)) { - successGameController = checkAxisInput(input, index); - if (!successGameController) + success_controller = checkAxisInput(input, controller_index); + if (!success_controller) { if (repeat) { - if (SDL_GameControllerGetButton(connectedControllers[index], gameControllerBindings[index][input].button) != 0) + if (SDL_GameControllerGetButton(connected_controllers_[controller_index], controller_bindings_[controller_index][input_index].button) != 0) { - successGameController = true; + success_controller = true; } else { - successGameController = false; + success_controller = false; } } else { - if (!gameControllerBindings[index][input].active) + if (!controller_bindings_[controller_index][input_index].active) { - if (SDL_GameControllerGetButton(connectedControllers[index], gameControllerBindings[index][input].button) != 0) + if (SDL_GameControllerGetButton(connected_controllers_[controller_index], controller_bindings_[controller_index][input_index].button) != 0) { - gameControllerBindings[index][input].active = true; - successGameController = true; + controller_bindings_[controller_index][input_index].active = true; + success_controller = true; } else { - successGameController = false; + success_controller = false; } } else { - if (SDL_GameControllerGetButton(connectedControllers[index], gameControllerBindings[index][input].button) == 0) + if (SDL_GameControllerGetButton(connected_controllers_[controller_index], controller_bindings_[controller_index][input_index].button) == 0) { - gameControllerBindings[index][input].active = false; - successGameController = false; + controller_bindings_[controller_index][input_index].active = false; + success_controller = false; } else { - successGameController = false; + success_controller = false; } } } } } - return (successKeyboard || successGameController); + return (success_keyboard || success_controller); } // Comprueba si un input con modificador esta activo -bool Input::checkModInput(inputs_e inputMod, inputs_e input, bool repeat, int device, int index) +bool Input::checkModInput(InputType input_mod, InputType input, bool repeat, int device, int controller_index) { - if (!enabled || index >= numGamepads || !checkInput(inputMod, INPUT_ALLOW_REPEAT, device, index)) + if (!enabled_ || controller_index >= num_gamepads_ || !checkInput(input_mod, INPUT_ALLOW_REPEAT, device, controller_index)) { return false; } - bool successKeyboard = false; - bool successGameController = false; + bool success_keyboard = false; + bool success_controller = false; + const int input_index = static_cast(input); if (device == INPUT_USE_ANY) { - index = 0; + controller_index = 0; } if (device == INPUT_USE_KEYBOARD || device == INPUT_USE_ANY) @@ -240,111 +227,111 @@ bool Input::checkModInput(inputs_e inputMod, inputs_e input, bool repeat, int de if (repeat) { - if (keyStates[keyBindings[input].scancode] != 0) + if (keyStates[key_bindings_[input_index].scancode] != 0) { - successKeyboard = true; + success_keyboard = true; } else { - successKeyboard = false; + success_keyboard = false; } } else { - if (!keyBindings[input].active) + if (!key_bindings_[input_index].active) { - if (keyStates[keyBindings[input].scancode] != 0) + if (keyStates[key_bindings_[input_index].scancode] != 0) { - keyBindings[input].active = true; - successKeyboard = true; + key_bindings_[input_index].active = true; + success_keyboard = true; } else { - successKeyboard = false; + success_keyboard = false; } } else { - if (keyStates[keyBindings[input].scancode] == 0) + if (keyStates[key_bindings_[input_index].scancode] == 0) { - keyBindings[input].active = false; - successKeyboard = false; + key_bindings_[input_index].active = false; + success_keyboard = false; } else { - successKeyboard = false; + success_keyboard = false; } } } } - if (gameControllerFound() && index < numGamepads) + if (gameControllerFound() && controller_index < num_gamepads_) if ((device == INPUT_USE_GAMECONTROLLER) || (device == INPUT_USE_ANY)) { - successGameController = checkAxisInput(input, index); - if (!successGameController) + success_controller = checkAxisInput(input, controller_index); + if (!success_controller) { if (repeat) { - if (SDL_GameControllerGetButton(connectedControllers[index], gameControllerBindings[index][input].button) != 0) + if (SDL_GameControllerGetButton(connected_controllers_[controller_index], controller_bindings_[controller_index][input_index].button) != 0) { - successGameController = true; + success_controller = true; } else { - successGameController = false; + success_controller = false; } } else { - if (!gameControllerBindings[index][input].active) + if (!controller_bindings_[controller_index][input_index].active) { - if (SDL_GameControllerGetButton(connectedControllers[index], gameControllerBindings[index][input].button) != 0) + if (SDL_GameControllerGetButton(connected_controllers_[controller_index], controller_bindings_[controller_index][input_index].button) != 0) { - gameControllerBindings[index][input].active = true; - successGameController = true; + controller_bindings_[controller_index][input_index].active = true; + success_controller = true; } else { - successGameController = false; + success_controller = false; } } else { - if (SDL_GameControllerGetButton(connectedControllers[index], gameControllerBindings[index][input].button) == 0) + if (SDL_GameControllerGetButton(connected_controllers_[controller_index], controller_bindings_[controller_index][input_index].button) == 0) { - gameControllerBindings[index][input].active = false; - successGameController = false; + controller_bindings_[controller_index][input_index].active = false; + success_controller = false; } else { - successGameController = false; + success_controller = false; } } } } } - return (successKeyboard || successGameController); + return (success_keyboard || success_controller); } // Comprueba si hay almenos un input activo -bool Input::checkAnyInput(int device, int index) +bool Input::checkAnyInput(int device, int controller_index) { if (device == INPUT_USE_ANY) { - index = 0; + controller_index = 0; } if (device == INPUT_USE_KEYBOARD || device == INPUT_USE_ANY) { const Uint8 *mKeystates = SDL_GetKeyboardState(nullptr); - for (int i = 0; i < (int)keyBindings.size(); ++i) + for (int i = 0; i < (int)key_bindings_.size(); ++i) { - if (mKeystates[keyBindings[i].scancode] != 0 && !keyBindings[i].active) + if (mKeystates[key_bindings_[i].scancode] != 0 && !key_bindings_[i].active) { - keyBindings[i].active = true; + key_bindings_[i].active = true; return true; } } @@ -354,11 +341,11 @@ bool Input::checkAnyInput(int device, int index) { if (device == INPUT_USE_GAMECONTROLLER || device == INPUT_USE_ANY) { - for (int i = 0; i < (int)gameControllerBindings.size(); ++i) + for (int i = 0; i < (int)controller_bindings_.size(); ++i) { - if (SDL_GameControllerGetButton(connectedControllers[index], gameControllerBindings[index][i].button) != 0 && !gameControllerBindings[index][i].active) + if (SDL_GameControllerGetButton(connected_controllers_[controller_index], controller_bindings_[controller_index][i].button) != 0 && !controller_bindings_[controller_index][i].active) { - gameControllerBindings[index][i].active = true; + controller_bindings_[controller_index][i].active = true; return true; } } @@ -372,13 +359,13 @@ bool Input::checkAnyInput(int device, int index) int Input::checkAnyButtonPressed(bool repeat) { // Si está pulsado el botón de servicio, ningún botón se puede considerar pulsado - if (checkInput(input_service, INPUT_ALLOW_REPEAT, INPUT_USE_ANY)) + if (checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, INPUT_USE_ANY)) { return 0; } // Solo comprueba los botones definidos previamente - for (auto bi : buttonInputs) + for (auto bi : button_inputs_) { // Comprueba el teclado if (checkInput(bi, repeat, INPUT_USE_KEYBOARD)) @@ -387,7 +374,7 @@ int Input::checkAnyButtonPressed(bool repeat) } // Comprueba los mandos - for (int i = 0; i < numGamepads; ++i) + for (int i = 0; i < num_gamepads_; ++i) { if (checkInput(bi, repeat, INPUT_USE_GAMECONTROLLER, i)) { @@ -409,60 +396,64 @@ bool Input::discoverGameControllers() SDL_InitSubSystem(SDL_INIT_GAMECONTROLLER); } - if (SDL_GameControllerAddMappingsFromFile(dbPath.c_str()) < 0) + if (SDL_GameControllerAddMappingsFromFile(game_controller_db_path_.c_str()) < 0) { - if (verbose) +#ifdef VERBOSE { - std::cout << "Error, could not load " << dbPath.c_str() << " file: " << SDL_GetError() << std::endl; + std::cout << "Error, could not load " << game_controller_db_path_.c_str() << " file: " << SDL_GetError() << std::endl; } +#endif } - numJoysticks = SDL_NumJoysticks(); - numGamepads = 0; + num_joysticks_ = SDL_NumJoysticks(); + num_gamepads_ = 0; // Cuenta el número de mandos - joysticks.clear(); - for (int i = 0; i < numJoysticks; ++i) + joysticks_.clear(); + for (int i = 0; i < num_joysticks_; ++i) { SDL_Joystick *joy = SDL_JoystickOpen(i); - joysticks.push_back(joy); + joysticks_.push_back(joy); if (SDL_IsGameController(i)) { - numGamepads++; + num_gamepads_++; } } - if (verbose) +#ifdef VERBOSE { std::cout << "\nChecking for game controllers...\n"; - std::cout << numJoysticks << " joysticks found, " << numGamepads << " are gamepads\n"; + std::cout << num_joysticks_ << " joysticks found, " << num_gamepads_ << " are gamepads\n"; } +#endif - if (numGamepads > 0) + if (num_gamepads_ > 0) { found = true; - for (int i = 0; i < numGamepads; i++) + for (int i = 0; i < num_gamepads_; i++) { // Abre el mando y lo añade a la lista SDL_GameController *pad = SDL_GameControllerOpen(i); if (SDL_GameControllerGetAttached(pad) == 1) { - connectedControllers.push_back(pad); + connected_controllers_.push_back(pad); const std::string separator(" #"); std::string name = SDL_GameControllerNameForIndex(i); - if (verbose) +#ifdef VERBOSE { std::cout << name << std::endl; } - controllerNames.push_back(name); +#endif + controller_names_.push_back(name); } else { - if (verbose) +#ifdef VERBOSE { std::cout << "SDL_GetError() = " << SDL_GetError() << std::endl; } +#endif } } @@ -475,47 +466,27 @@ bool Input::discoverGameControllers() // Comprueba si hay algun mando conectado bool Input::gameControllerFound() { - return numGamepads > 0 ? true : false; + return num_gamepads_ > 0 ? true : false; } // Obten el nombre de un mando de juego -std::string Input::getControllerName(int index) const +std::string Input::getControllerName(int controller_index) const { - return numGamepads > 0 ? controllerNames[index] : ""; + return num_gamepads_ > 0 ? controller_names_[controller_index] : ""; } // Obten el número de mandos conectados int Input::getNumControllers() const { - return numGamepads; -} - -// Establece si ha de mostrar mensajes -void Input::setVerbose(bool value) -{ - verbose = value; -} - -// Deshabilita las entradas durante un periodo de tiempo -void Input::disableUntil(i_disable_e value) -{ - disabledUntil = value; - enabled = false; -} - -// Hablita las entradas -void Input::enable() -{ - enabled = true; - disabledUntil = d_notDisabled; + return num_gamepads_; } // Obtiene el indice del controlador a partir de un event.id int Input::getJoyIndex(int id) const { - for (int i = 0; i < numJoysticks; ++i) + for (int i = 0; i < num_joysticks_; ++i) { - if (SDL_JoystickInstanceID(joysticks[i]) == id) + if (SDL_JoystickInstanceID(joysticks_[i]) == id) { return i; } @@ -524,7 +495,7 @@ int Input::getJoyIndex(int id) const } // Muestra por consola los controles asignados -void Input::printBindings(int device, int index) const +void Input::printBindings(int device, int controller_index) const { if (device == INPUT_USE_ANY || device == INPUT_USE_KEYBOARD) { @@ -533,35 +504,35 @@ void Input::printBindings(int device, int index) const if (device == INPUT_USE_GAMECONTROLLER) { - if (index >= numGamepads) + if (controller_index >= num_gamepads_) { return; } // Muestra el nombre del mando std::cout << "\n" - << controllerNames[index] << std::endl; + << controller_names_[controller_index] << std::endl; // Muestra los botones asignados - for (auto bi : buttonInputs) + for (auto bi : button_inputs_) { - std::cout << to_string(bi) << " : " << gameControllerBindings[index][bi].button << std::endl; + std::cout << to_string(bi) << " : " << controller_bindings_[controller_index][static_cast(bi)].button << std::endl; } } } // Obtiene el SDL_GameControllerButton asignado a un input -SDL_GameControllerButton Input::getControllerBinding(int index, inputs_e input) const +SDL_GameControllerButton Input::getControllerBinding(int controller_index, InputType input) const { - return gameControllerBindings[index][input].button; + return controller_bindings_[controller_index][static_cast(input)].button; } // Obtiene el indice a partir del nombre del mando int Input::getIndexByName(std::string name) const { - for (int i = 0; i < numGamepads; ++i) + for (int i = 0; i < num_gamepads_; ++i) { - if (controllerNames[i] == name) + if (controller_names_[i] == name) { return i; } @@ -569,30 +540,30 @@ int Input::getIndexByName(std::string name) const return -1; } -// Convierte un inputs_e a std::string -std::string Input::to_string(inputs_e input) const +// Convierte un InputType a std::string +std::string Input::to_string(InputType input) const { - if (input == input_fire_left) + if (input == InputType::FIRE_LEFT) { return "input_fire_left"; } - if (input == input_fire_center) + if (input == InputType::FIRE_CENTER) { return "input_fire_center"; } - if (input == input_fire_right) + if (input == InputType::FIRE_RIGHT) { return "input_fire_right"; } - if (input == input_start) + if (input == InputType::START) { return "input_start"; } - if (input == input_service) + if (input == InputType::SERVICE) { return "input_service"; } @@ -600,76 +571,77 @@ std::string Input::to_string(inputs_e input) const return ""; } -// Convierte un std::string a inputs_e -inputs_e Input::to_inputs_e(std::string name) const +// Convierte un std::string a InputType +InputType Input::to_inputs_e(std::string name) const { if (name == "input_fire_left") { - return input_fire_left; + return InputType::FIRE_LEFT; } if (name == "input_fire_center") { - return input_fire_center; + return InputType::FIRE_CENTER; } if (name == "input_fire_right") { - return input_fire_right; + return InputType::FIRE_RIGHT; } if (name == "input_start") { - return input_start; + return InputType::START; } if (name == "input_service") { - return input_service; + return InputType::SERVICE; } - return input_null; + return InputType::NONE; } // Activa todos los inputs. Sirve para evitar inputs sin repeticiones pero que ya vienen pulsados cuando checkInput no estaba monitorizando -void Input::allActive(int index) +/*void Input::allActive(int controller_index) { - for (int i = 0; i < (int)buttonInputs.size(); ++i) + for (int i = 0; i < (int)button_inputs_.size(); ++i) { - gameControllerBindings[index][i].active = true; + controller_bindings_[controller_index][i].active = true; } } +*/ // Comprueba el eje del mando -bool Input::checkAxisInput(inputs_e input, int index) const +bool Input::checkAxisInput(InputType input, int controller_index) const { bool success = false; switch (input) { - case input_left: - if (SDL_GameControllerGetAxis(connectedControllers[index], SDL_CONTROLLER_AXIS_LEFTX) < -30000) + case InputType::LEFT: + if (SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTX) < -30000) { success = true; } break; - case input_right: - if (SDL_GameControllerGetAxis(connectedControllers[index], SDL_CONTROLLER_AXIS_LEFTX) > 30000) + case InputType::RIGHT: + if (SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTX) > 30000) { success = true; } break; - case input_up: - if (SDL_GameControllerGetAxis(connectedControllers[index], SDL_CONTROLLER_AXIS_LEFTY) < -30000) + case InputType::UP: + if (SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTY) < -30000) { success = true; } break; - case input_down: - if (SDL_GameControllerGetAxis(connectedControllers[index], SDL_CONTROLLER_AXIS_LEFTY) > 30000) + case InputType::DOWN: + if (SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTY) > 30000) { success = true; } diff --git a/source/input.h b/source/input.h index bb64189..f60659b 100644 --- a/source/input.h +++ b/source/input.h @@ -1,11 +1,11 @@ #pragma once -#include // for SDL_GameControllerButton, SDL_G... -#include // for SDL_Joystick -#include // for SDL_Scancode -#include // for Uint8 -#include // for string, basic_string -#include // for vector +#include // for SDL_GameControllerButton, SDL_G... +#include // for SDL_Joystick +#include // for SDL_Scancode +#include // for Uint8 +#include // for string, basic_string +#include // for vector /* connectedControllers es un vector donde estan todos los mandos encontrados [0 .. n] @@ -16,98 +16,89 @@ device contiene el tipo de dispositivo a comprobar: INPUT_USE_ANY mirará tanto el teclado como el PRIMER controlador */ -enum inputs_e +enum class InputType : int { // Inputs de movimiento - input_up, - input_down, - input_left, - input_right, + UP, + DOWN, + LEFT, + RIGHT, // Inputs personalizados - input_fire_left, - input_fire_center, - input_fire_right, - input_start, + FIRE_LEFT, + FIRE_CENTER, + FIRE_RIGHT, + START, // Inputs de control - input_exit, - input_pause, - input_service, - input_window_fullscreen, - input_window_inc_size, - input_window_dec_size, - input_video_shaders, - input_reset, - input_mute, - input_showinfo, - input_config, - input_swap_controllers, + EXIT, + PAUSE, + SERVICE, + WINDOW_FULLSCREEN, + WINDOW_INC_SIZE, + WINDOW_DEC_SIZE, + VIDEO_SHADERS, + RESET, + MUTE, + SHOWINFO, + CONFIG, + SWAP_CONTROLLERS, // Input obligatorio - input_null, - input_number_of_inputs, + NONE, + NUMBER_OF_INPUTS, }; -#define INPUT_ALLOW_REPEAT true -#define INPUT_DO_NOT_ALLOW_REPEAT false +constexpr bool INPUT_ALLOW_REPEAT = true; +constexpr bool INPUT_DO_NOT_ALLOW_REPEAT = false; -#define INPUT_USE_KEYBOARD 0 -#define INPUT_USE_GAMECONTROLLER 1 -#define INPUT_USE_ANY 2 - -enum i_disable_e -{ - d_notDisabled, - d_forever, - d_keyPressed -}; +constexpr int INPUT_USE_KEYBOARD = 0; +constexpr int INPUT_USE_GAMECONTROLLER = 1; +constexpr int INPUT_USE_ANY = 2; class Input { private: // [SINGLETON] Objeto screen privado para Don Melitón - static Input *input; + static Input *input_; - struct keyBindings_t + struct KeyBindings { Uint8 scancode; // Scancode asociado bool active; // Indica si está activo }; - struct GameControllerBindings_t + struct ControllerBindings { SDL_GameControllerButton button; // GameControllerButton asociado bool active; // Indica si está activo }; // Variables - std::vector connectedControllers; // Vector con todos los mandos conectados - std::vector joysticks; // Vector con todos los joysticks conectados - std::vector keyBindings; // Vector con las teclas asociadas a los inputs predefinidos - std::vector> gameControllerBindings; // Vector con los botones asociadas a los inputs predefinidos para cada mando - std::vector controllerNames; // Vector con los nombres de los mandos - std::vector gameInputs; // Inputs usados para jugar, normalmente direcciones y botones - std::vector buttonInputs; // Inputs asignados al jugador y a botones, excluyendo direcciones - int numJoysticks; // Número de joysticks conectados - int numGamepads; // Número de mandos conectados - std::string dbPath; // Ruta al archivo gamecontrollerdb.txt - bool verbose; // Indica si ha de mostrar mensajes - i_disable_e disabledUntil; // Tiempo que esta deshabilitado - bool enabled; // Indica si está habilitado + std::vector connected_controllers_; // Vector con todos los mandos conectados + std::vector joysticks_; // Vector con todos los joysticks conectados + std::vector key_bindings_; // Vector con las teclas asociadas a los inputs predefinidos + std::vector> controller_bindings_; // Vector con los botones asociadas a los inputs predefinidos para cada mando + std::vector controller_names_; // Vector con los nombres de los mandos + std::vector game_inputs_; // Inputs usados para jugar, normalmente direcciones y botones + std::vector button_inputs_; // Inputs asignados al jugador y a botones, excluyendo direcciones + int num_joysticks_; // Número de joysticks conectados + int num_gamepads_; // Número de mandos conectados + std::string game_controller_db_path_; // Ruta al archivo gamecontrollerdb.txt + bool enabled_; // Indica si está habilitado // Comprueba el eje del mando - bool checkAxisInput(inputs_e input, int index = 0) const; + bool checkAxisInput(InputType input, int controller_index = 0) const; // Constructor - Input(std::string dbPath); + Input(std::string game_controller_db_path); // Destructor - ~Input(); + ~Input() = default; public: // [SINGLETON] Crearemos el objeto screen con esta función estática - static void init(std::string dbPath); + static void init(std::string game_controller_db_path); // [SINGLETON] Destruiremos el objeto screen con esta función estática static void destroy(); @@ -115,24 +106,21 @@ public: // [SINGLETON] Con este método obtenemos el objeto screen y podemos trabajar con él static Input *get(); - // Actualiza el estado del objeto - void update(); - // Asigna inputs a teclas - void bindKey(inputs_e input, SDL_Scancode code); + void bindKey(InputType input, SDL_Scancode code); // Asigna inputs a botones del mando - void bindGameControllerButton(int index, inputs_e input, SDL_GameControllerButton button); - void bindGameControllerButton(int index, inputs_e inputTarget, inputs_e inputSource); + void bindGameControllerButton(int controller_index, InputType input, SDL_GameControllerButton button); + void bindGameControllerButton(int controller_index, InputType inputTarget, InputType inputSource); // Comprueba si un input esta activo - bool checkInput(inputs_e input, bool repeat = true, int device = INPUT_USE_ANY, int index = 0); + bool checkInput(InputType input, bool repeat = true, int device = INPUT_USE_ANY, int controller_index = 0); // Comprueba si un input con modificador esta activo - bool checkModInput(inputs_e inputMod, inputs_e input, bool repeat = true, int device = INPUT_USE_ANY, int index = 0); + bool checkModInput(InputType input_mod, InputType input, bool repeat = true, int device = INPUT_USE_ANY, int controller_index = 0); // Comprueba si hay almenos un input activo - bool checkAnyInput(int device = INPUT_USE_ANY, int index = 0); + bool checkAnyInput(int device = INPUT_USE_ANY, int controller_index = 0); // Comprueba si hay algún botón pulsado int checkAnyButtonPressed(bool repeat = INPUT_DO_NOT_ALLOW_REPEAT); @@ -147,35 +135,26 @@ public: int getNumControllers() const; // Obten el nombre de un mando de juego - std::string getControllerName(int index) const; - - // Establece si ha de mostrar mensajes - void setVerbose(bool value); - - // Deshabilita las entradas durante un periodo de tiempo - void disableUntil(i_disable_e value); - - // Hablita las entradas - void enable(); + std::string getControllerName(int controller_index) const; // Obtiene el indice del controlador a partir de un event.id int getJoyIndex(int id) const; // Muestra por consola los controles asignados - void printBindings(int device = INPUT_USE_KEYBOARD, int index = 0) const; + void printBindings(int device = INPUT_USE_KEYBOARD, int controller_index = 0) const; // Obtiene el SDL_GameControllerButton asignado a un input - SDL_GameControllerButton getControllerBinding(int index, inputs_e input) const; + SDL_GameControllerButton getControllerBinding(int controller_index, InputType input) const; - // Convierte un inputs_e a std::string - std::string to_string(inputs_e input) const; + // Convierte un InputType a std::string + std::string to_string(InputType input) const; - // Convierte un std::string a inputs_e - inputs_e to_inputs_e(std::string name) const; + // Convierte un std::string a InputType + InputType to_inputs_e(std::string name) const; // Obtiene el indice a partir del nombre del mando int getIndexByName(std::string name) const; // Activa todos los inputs. Sirve para evitar inputs sin repeticiones pero que ya vienen pulsados cuando checkInput no estaba monitorizando - void allActive(int index); + //void allActive(int index); }; \ No newline at end of file diff --git a/source/options.cpp b/source/options.cpp index 23739ab..0f2c1cb 100644 --- a/source/options.cpp +++ b/source/options.cpp @@ -57,11 +57,11 @@ void initOptions() // Inputs que se guardan en las opciones y, por tanto, a disco c.inputs.clear(); - c.inputs.push_back(input_fire_left); - c.inputs.push_back(input_fire_center); - c.inputs.push_back(input_fire_right); - c.inputs.push_back(input_start); - c.inputs.push_back(input_service); + c.inputs.push_back(InputType::FIRE_LEFT); + c.inputs.push_back(InputType::FIRE_CENTER); + c.inputs.push_back(InputType::FIRE_RIGHT); + c.inputs.push_back(InputType::START); + c.inputs.push_back(InputType::SERVICE); // Botones asociados a los inputs anteriores c.buttons.clear(); diff --git a/source/player.cpp b/source/player.cpp index 6348f69..12adf2d 100644 --- a/source/player.cpp +++ b/source/player.cpp @@ -77,7 +77,7 @@ void Player::init() } // Actua en consecuencia de la entrada recibida -void Player::setInput(int input) +void Player::setInput(InputType input) { switch (status_playing_) { @@ -99,37 +99,37 @@ void Player::setInput(int input) } // Procesa inputs para cuando está jugando -void Player::setInputPlaying(int input) +void Player::setInputPlaying(InputType input) { switch (input) { - case input_left: + case InputType::LEFT: { vel_x_ = -base_speed_; setWalkingStatus(PlayerStatus::WALKING_LEFT); break; } - case input_right: + case InputType::RIGHT: { vel_x_ = base_speed_; setWalkingStatus(PlayerStatus::WALKING_RIGHT); break; } - case input_fire_center: + case InputType::FIRE_CENTER: { setFiringStatus(PlayerStatus::FIRING_UP); break; } - case input_fire_left: + case InputType::FIRE_LEFT: { setFiringStatus(PlayerStatus::FIRING_LEFT); break; } - case input_fire_right: + case InputType::FIRE_RIGHT: { setFiringStatus(PlayerStatus::FIRING_RIGHT); break; @@ -145,27 +145,27 @@ void Player::setInputPlaying(int input) } // Procesa inputs para cuando está introduciendo el nombre -void Player::setInputEnteringName(int input) +void Player::setInputEnteringName(InputType input) { switch (input) { - case input_left: + case InputType::LEFT: enter_name_->decPos(); break; - case input_right: + case InputType::RIGHT: enter_name_->incPos(); break; - case input_up: + case InputType::UP: enter_name_->incIndex(); break; - case input_down: + case InputType::DOWN: enter_name_->decIndex(); break; - case input_start: + case InputType::START: setRecordName(enter_name_->getName()); break; diff --git a/source/player.h b/source/player.h index d5f4f30..45adb4f 100644 --- a/source/player.h +++ b/source/player.h @@ -121,13 +121,13 @@ public: void setPlayerTextures(std::vector> texture); // Actua en consecuencia de la entrada recibida - void setInput(int input); + void setInput(InputType input); // Procesa inputs para cuando está jugando - void setInputPlaying(int input); + void setInputPlaying(InputType input); // Procesa inputs para cuando está introduciendo el nombre - void setInputEnteringName(int input); + void setInputEnteringName(InputType input); // Mueve el jugador a la posición y animación que le corresponde void move(); diff --git a/source/screen.cpp b/source/screen.cpp index 67f03f7..87c6f1a 100644 --- a/source/screen.cpp +++ b/source/screen.cpp @@ -293,7 +293,7 @@ void Screen::checkInput() { #ifndef ARCADE // Comprueba el teclado para cambiar entre pantalla completa y ventana - if (Input::get()->checkInput(input_window_fullscreen, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD)) + if (Input::get()->checkInput(InputType::WINDOW_FULLSCREEN, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD)) { switchVideoMode(); const std::string mode = options.video.mode == ScreenVideoMode::WINDOW ? "Window" : "Fullscreen"; @@ -302,7 +302,7 @@ void Screen::checkInput() } // Comprueba el teclado para decrementar el tamaño de la ventana - if (Input::get()->checkInput(input_window_dec_size, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD)) + if (Input::get()->checkInput(InputType::WINDOW_DEC_SIZE, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD)) { decWindowSize(); const std::string size = std::to_string(options.video.window.size); @@ -311,7 +311,7 @@ void Screen::checkInput() } // Comprueba el teclado para incrementar el tamaño de la ventana - if (Input::get()->checkInput(input_window_inc_size, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD)) + if (Input::get()->checkInput(InputType::WINDOW_INC_SIZE, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD)) { incWindowSize(); const std::string size = std::to_string(options.video.window.size); @@ -321,7 +321,7 @@ void Screen::checkInput() #endif // Comprueba el teclado para activar o desactivar los shaders - if (Input::get()->checkInput(input_video_shaders, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD)) + if (Input::get()->checkInput(InputType::VIDEO_SHADERS, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD)) { switchShaders(); return; @@ -329,7 +329,7 @@ void Screen::checkInput() #ifdef DEBUG // Comprueba el teclado para mostrar la información de debug - if (Input::get()->checkInput(input_showinfo, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD)) + if (Input::get()->checkInput(InputType::SHOWINFO, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD)) { show_info_ = !show_info_; return; @@ -339,14 +339,14 @@ void Screen::checkInput() for (int i = 0; i < Input::get()->getNumControllers(); ++i) { // Comprueba los mandos para activar o desactivar los shaders - if (Input::get()->checkModInput(input_service, input_video_shaders, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i)) + if (Input::get()->checkModInput(InputType::SERVICE, InputType::VIDEO_SHADERS, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i)) { switchShaders(); return; } // Comprueba los mandos para mostrar la información de debug - if (Input::get()->checkModInput(input_service, input_showinfo, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i)) + if (Input::get()->checkModInput(InputType::SERVICE, InputType::SHOWINFO, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i)) { show_info_ = !show_info_; return; @@ -489,7 +489,7 @@ void Screen::displayInfo() // Resolution dbg_print(0, 0, info_resolution_.c_str(), 255, 255, 0); - dbg_print(0, 8, std::to_string(globalInputs::servicePressedCounter[0]).c_str(), 255, 255, 0); + dbg_print(0, 8, std::to_string(globalInputs::service_pressed_counter[0]).c_str(), 255, 255, 0); } } diff --git a/source/title.cpp b/source/title.cpp index 96d05fe..7e7344f 100644 --- a/source/title.cpp +++ b/source/title.cpp @@ -236,7 +236,7 @@ void Title::checkInput() if (!define_buttons_->isEnabled()) { // Comprueba el teclado para empezar a jugar - if (input_->checkInput(input_start, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD)) + if (input_->checkInput(InputType::START, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD)) { if (section::options == section::Options::TITLE_2 || ALLOW_TITLE_ANIMATION_SKIP) { @@ -249,24 +249,24 @@ void Title::checkInput() for (int i = 0; i < input_->getNumControllers(); ++i) { // Comprueba si se va a intercambiar la asignación de mandos a jugadores - if (input_->checkModInput(input_service, input_swap_controllers, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i)) + if (input_->checkModInput(InputType::SERVICE, InputType::SWAP_CONTROLLERS, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i)) { swapControllers(); return; } // Comprueba si algun mando quiere ser configurado - if (input_->checkModInput(input_service, input_config, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i)) + if (input_->checkModInput(InputType::SERVICE, InputType::CONFIG, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i)) { define_buttons_->enable(i); return; } // Comprueba el botón de START de los mandos - if (input_->checkInput(input_start, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i)) + if (input_->checkInput(InputType::START, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i)) { // Si no está el botón de servicio activo - if (!input_->checkInput(input_service, INPUT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i)) + if (!input_->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i)) { if (section::options == section::Options::TITLE_2 || ALLOW_TITLE_ANIMATION_SKIP) { diff --git a/source/utils.h b/source/utils.h index 4e1c7ff..f8f9903 100644 --- a/source/utils.h +++ b/source/utils.h @@ -126,7 +126,7 @@ struct OptionsController Uint8 device_type; // Indica si se utilizará teclado o mando o ambos std::string name; // Nombre del dispositivo bool plugged; // Indica si el mando se encuentra conectado - std::vector inputs; // Listado de inputs + std::vector inputs; // Listado de inputs std::vector buttons; // Listado de botones asignados a cada input };