jaildesigner-jailgames/coffee_crisis_arcade_edition
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 13 Wiki Activity

Variables renombrades en input.cpp

Browse Source
This commit is contained in:
Sergio
2024-10-12 11:01:42 +02:00
parent 4ef759772a
commit 101e375fd3
16 changed files with 467 additions and 523 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
source/define_buttons.cpp
View File

@@ -24,27 +24,27 @@ DefineButtons::DefineButtons(std::unique_ptr<Text> text_)
DefineButtonsButton button; DefineButtonsButton button;
button.label = lang::getText(95); button.label = lang::getText(95);
button.input = input_fire_left; button.input = InputType::FIRE_LEFT;
button.button = SDL_CONTROLLER_BUTTON_X; button.button = SDL_CONTROLLER_BUTTON_X;
buttons_.push_back(button); buttons_.push_back(button);
button.label = lang::getText(96); button.label = lang::getText(96);
button.input = input_fire_center; button.input = InputType::FIRE_CENTER;
button.button = SDL_CONTROLLER_BUTTON_Y; button.button = SDL_CONTROLLER_BUTTON_Y;
buttons_.push_back(button); buttons_.push_back(button);
button.label = lang::getText(97); button.label = lang::getText(97);
button.input = input_fire_right; button.input = InputType::FIRE_RIGHT;
button.button = SDL_CONTROLLER_BUTTON_RIGHTSHOULDER; button.button = SDL_CONTROLLER_BUTTON_RIGHTSHOULDER;
buttons_.push_back(button); buttons_.push_back(button);
button.label = lang::getText(98); button.label = lang::getText(98);
button.input = input_start; button.input = InputType::START;
button.button = SDL_CONTROLLER_BUTTON_START; button.button = SDL_CONTROLLER_BUTTON_START;
buttons_.push_back(button); buttons_.push_back(button);
button.label = lang::getText(99); button.label = lang::getText(99);
button.input = input_exit; button.input = InputType::EXIT;
button.button = SDL_CONTROLLER_BUTTON_BACK; button.button = SDL_CONTROLLER_BUTTON_BACK;
buttons_.push_back(button); buttons_.push_back(button);
@@ -155,7 +155,7 @@ void DefineButtons::incIndexButton()
// Guarda los cambios en las opciones // Guarda los cambios en las opciones
saveBindingsToOptions(); saveBindingsToOptions();
input_->allActive(index_controller_); //input_->allActive(index_controller_);
// Reinicia variables // Reinicia variables
index_button_ = 0; index_button_ = 0;

2
source/define_buttons.h
View File

@@ -11,7 +11,7 @@
struct DefineButtonsButton struct DefineButtonsButton
{ {
std::string label; // Texto en pantalla para el botón 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 SDL_GameControllerButton button; // Botón del mando correspondiente
}; };

92
source/director.cpp
View File

@@ -132,65 +132,59 @@ Director::~Director()
/// Inicializa el objeto input /// Inicializa el objeto input
void Director::initInput() 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 // Busca si hay mandos conectados
Input::get()->discoverGameControllers(); Input::get()->discoverGameControllers();
// Teclado - Movimiento del jugador // Teclado - Movimiento del jugador
Input::get()->bindKey(input_up, SDL_SCANCODE_UP); Input::get()->bindKey(InputType::UP, SDL_SCANCODE_UP);
Input::get()->bindKey(input_down, SDL_SCANCODE_DOWN); Input::get()->bindKey(InputType::DOWN, SDL_SCANCODE_DOWN);
Input::get()->bindKey(input_left, SDL_SCANCODE_LEFT); Input::get()->bindKey(InputType::LEFT, SDL_SCANCODE_LEFT);
Input::get()->bindKey(input_right, SDL_SCANCODE_RIGHT); Input::get()->bindKey(InputType::RIGHT, SDL_SCANCODE_RIGHT);
Input::get()->bindKey(input_fire_left, SDL_SCANCODE_Q); Input::get()->bindKey(InputType::FIRE_LEFT, SDL_SCANCODE_Q);
Input::get()->bindKey(input_fire_center, SDL_SCANCODE_W); Input::get()->bindKey(InputType::FIRE_CENTER, SDL_SCANCODE_W);
Input::get()->bindKey(input_fire_right, SDL_SCANCODE_E); 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 // Teclado - Control del programa
Input::get()->bindKey(input_service, SDL_SCANCODE_0); Input::get()->bindKey(InputType::SERVICE, SDL_SCANCODE_0);
Input::get()->bindKey(input_exit, SDL_SCANCODE_ESCAPE); Input::get()->bindKey(InputType::EXIT, SDL_SCANCODE_ESCAPE);
Input::get()->bindKey(input_pause, SDL_SCANCODE_P); Input::get()->bindKey(InputType::PAUSE, SDL_SCANCODE_P);
Input::get()->bindKey(input_window_dec_size, SDL_SCANCODE_F1); Input::get()->bindKey(InputType::WINDOW_DEC_SIZE, SDL_SCANCODE_F1);
Input::get()->bindKey(input_window_inc_size, SDL_SCANCODE_F2); Input::get()->bindKey(InputType::WINDOW_INC_SIZE, SDL_SCANCODE_F2);
Input::get()->bindKey(input_window_fullscreen, SDL_SCANCODE_F3); Input::get()->bindKey(InputType::WINDOW_FULLSCREEN, SDL_SCANCODE_F3);
Input::get()->bindKey(input_video_shaders, SDL_SCANCODE_F4); Input::get()->bindKey(InputType::VIDEO_SHADERS, SDL_SCANCODE_F4);
Input::get()->bindKey(input_mute, SDL_SCANCODE_F5); Input::get()->bindKey(InputType::MUTE, SDL_SCANCODE_F5);
Input::get()->bindKey(input_showinfo, SDL_SCANCODE_F6); Input::get()->bindKey(InputType::SHOWINFO, SDL_SCANCODE_F6);
Input::get()->bindKey(input_reset, SDL_SCANCODE_F10); Input::get()->bindKey(InputType::RESET, SDL_SCANCODE_F10);
// Asigna botones a inputs // Asigna botones a inputs
const int numGamePads = Input::get()->getNumControllers(); const int numGamePads = Input::get()->getNumControllers();
for (int i = 0; i < numGamePads; ++i) for (int i = 0; i < numGamePads; ++i)
{ {
// Mando - Movimiento del jugador // Mando - Movimiento del jugador
Input::get()->bindGameControllerButton(i, input_up, SDL_CONTROLLER_BUTTON_DPAD_UP); Input::get()->bindGameControllerButton(i, InputType::UP, SDL_CONTROLLER_BUTTON_DPAD_UP);
Input::get()->bindGameControllerButton(i, input_down, SDL_CONTROLLER_BUTTON_DPAD_DOWN); Input::get()->bindGameControllerButton(i, InputType::DOWN, SDL_CONTROLLER_BUTTON_DPAD_DOWN);
Input::get()->bindGameControllerButton(i, input_left, SDL_CONTROLLER_BUTTON_DPAD_LEFT); Input::get()->bindGameControllerButton(i, InputType::LEFT, SDL_CONTROLLER_BUTTON_DPAD_LEFT);
Input::get()->bindGameControllerButton(i, input_right, SDL_CONTROLLER_BUTTON_DPAD_RIGHT); 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, InputType::FIRE_LEFT, SDL_CONTROLLER_BUTTON_X);
Input::get()->bindGameControllerButton(i, input_fire_center, SDL_CONTROLLER_BUTTON_Y); Input::get()->bindGameControllerButton(i, InputType::FIRE_CENTER, SDL_CONTROLLER_BUTTON_Y);
Input::get()->bindGameControllerButton(i, input_fire_right, SDL_CONTROLLER_BUTTON_B); 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 // Mando - Control del programa
Input::get()->bindGameControllerButton(i, input_service, SDL_CONTROLLER_BUTTON_BACK); Input::get()->bindGameControllerButton(i, InputType::SERVICE, SDL_CONTROLLER_BUTTON_BACK);
Input::get()->bindGameControllerButton(i, input_exit, input_start); Input::get()->bindGameControllerButton(i, InputType::EXIT, InputType::START);
Input::get()->bindGameControllerButton(i, input_pause, input_fire_right); Input::get()->bindGameControllerButton(i, InputType::PAUSE, InputType::FIRE_RIGHT);
Input::get()->bindGameControllerButton(i, input_video_shaders, input_fire_left); Input::get()->bindGameControllerButton(i, InputType::VIDEO_SHADERS, InputType::FIRE_LEFT);
Input::get()->bindGameControllerButton(i, input_mute, input_left); Input::get()->bindGameControllerButton(i, InputType::MUTE, InputType::LEFT);
Input::get()->bindGameControllerButton(i, input_showinfo, input_right); Input::get()->bindGameControllerButton(i, InputType::SHOWINFO, InputType::RIGHT);
Input::get()->bindGameControllerButton(i, input_reset, input_fire_center); Input::get()->bindGameControllerButton(i, InputType::RESET, InputType::FIRE_CENTER);
Input::get()->bindGameControllerButton(i, input_config, input_down); Input::get()->bindGameControllerButton(i, InputType::CONFIG, InputType::DOWN);
Input::get()->bindGameControllerButton(i, input_swap_controllers, input_up); 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 // 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 // Asigna botones a inputs desde otros inputs
for (int i = 0; i < numGamePads; ++i) for (int i = 0; i < numGamePads; ++i)
{ {
Input::get()->bindGameControllerButton(i, input_exit, input_start); Input::get()->bindGameControllerButton(i, InputType::EXIT, InputType::START);
Input::get()->bindGameControllerButton(i, input_reset, input_fire_center); Input::get()->bindGameControllerButton(i, InputType::RESET, InputType::FIRE_CENTER);
Input::get()->bindGameControllerButton(i, input_pause, input_fire_right); Input::get()->bindGameControllerButton(i, InputType::PAUSE, InputType::FIRE_RIGHT);
Input::get()->bindGameControllerButton(i, input_video_shaders, input_fire_left); Input::get()->bindGameControllerButton(i, InputType::VIDEO_SHADERS, InputType::FIRE_LEFT);
Input::get()->bindGameControllerButton(i, input_mute, input_left); Input::get()->bindGameControllerButton(i, InputType::MUTE, InputType::LEFT);
Input::get()->bindGameControllerButton(i, input_showinfo, input_right); Input::get()->bindGameControllerButton(i, InputType::SHOWINFO, InputType::RIGHT);
Input::get()->bindGameControllerButton(i, input_config, input_down); Input::get()->bindGameControllerButton(i, InputType::CONFIG, InputType::DOWN);
Input::get()->bindGameControllerButton(i, input_swap_controllers, input_up); Input::get()->bindGameControllerButton(i, InputType::SWAP_CONTROLLERS, InputType::UP);
} }
// Guarda las asignaciones de botones en las opciones // Guarda las asignaciones de botones en las opciones

74
source/game.cpp
View File

@@ -1972,7 +1972,7 @@ void Game::checkInput()
for (int i = 0; i < input_->getNumControllers(); ++i) for (int i = 0; i < input_->getNumControllers(); ++i)
{ {
// Comprueba si se va a pausar el juego // 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_); pause(!paused_);
return; return;
@@ -1990,17 +1990,17 @@ void Game::checkInput()
// Comprueba direcciones // Comprueba direcciones
if (demo_.data_file[i][demo_.counter].left == 1) 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) 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) else if (demo_.data_file[i][demo_.counter].no_input == 1)
{ {
player->setInput(input_null); player->setInput(InputType::NONE);
} }
// Comprueba botones // Comprueba botones
@@ -2008,7 +2008,7 @@ void Game::checkInput()
{ {
if (player->canFire()) 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()); createBullet(player->getPosX() + (player->getWidth() / 2) - 4, player->getPosY() + (player->getHeight() / 2), BulletType::UP, player->isPowerUp(), player->getId());
player->setFireCooldown(10); player->setFireCooldown(10);
} }
@@ -2018,7 +2018,7 @@ void Game::checkInput()
{ {
if (player->canFire()) 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()); createBullet(player->getPosX() + (player->getWidth() / 2) - 4, player->getPosY() + (player->getHeight() / 2), BulletType::LEFT, player->isPowerUp(), player->getId());
player->setFireCooldown(10); player->setFireCooldown(10);
} }
@@ -2028,7 +2028,7 @@ void Game::checkInput()
{ {
if (player->canFire()) 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()); createBullet(player->getPosX() + (player->getWidth() / 2) - 4, player->getPosY() + (player->getHeight() / 2), BulletType::RIGHT, player->isPowerUp(), player->getId());
player->setFireCooldown(10); player->setFireCooldown(10);
} }
@@ -2064,9 +2064,9 @@ void Game::checkInput()
if (player->isPlaying()) if (player->isPlaying())
{ {
// Input a la izquierda // 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 #ifdef RECORDING
demo.keys.left = 1; demo.keys.left = 1;
#endif #endif
@@ -2074,9 +2074,9 @@ void Game::checkInput()
else else
{ {
// Input a la derecha // 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 #ifdef RECORDING
demo.keys.right = 1; demo.keys.right = 1;
#endif #endif
@@ -2084,18 +2084,18 @@ void Game::checkInput()
else else
{ {
// Ninguno de los dos inputs anteriores // Ninguno de los dos inputs anteriores
player->setInput(input_null); player->setInput(InputType::NONE);
#ifdef RECORDING #ifdef RECORDING
demo.keys.no_input = 1; demo.keys.no_input = 1;
#endif #endif
} }
} }
// Comprueba el input de disparar al centro // 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()) 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()); createBullet(player->getPosX() + (player->getWidth() / 2) - 4, player->getPosY() + (player->getHeight() / 2), BulletType::UP, player->isPowerUp(), player->getId());
player->setFireCooldown(10); player->setFireCooldown(10);
@@ -2108,11 +2108,11 @@ void Game::checkInput()
} }
// Comprueba el input de disparar a la izquierda // 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()) 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()); createBullet(player->getPosX() + (player->getWidth() / 2) - 4, player->getPosY() + (player->getHeight() / 2), BulletType::LEFT, player->isPowerUp(), player->getId());
player->setFireCooldown(10); player->setFireCooldown(10);
@@ -2125,11 +2125,11 @@ void Game::checkInput()
} }
// Comprueba el input de disparar a la derecha // 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()) 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()); createBullet(player->getPosX() + (player->getWidth() / 2) - 4, player->getPosY() + (player->getHeight() / 2), BulletType::RIGHT, player->isPowerUp(), player->getId());
player->setFireCooldown(10); player->setFireCooldown(10);
@@ -2153,15 +2153,15 @@ void Game::checkInput()
else if (player->isContinue() || player->isWaiting()) else if (player->isContinue() || player->isWaiting())
{ {
// Si no está jugando, el botón de start le permite continuar jugando // 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); player->setStatusPlaying(PlayerStatus::PLAYING);
} }
// Si está continuando, los botones de fuego hacen decrementar el contador // 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 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(input_fire_center, 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(input_fire_right, 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 (fire1 || fire2 || fire3)
{ {
player->decContinueCounter(); player->decContinueCounter();
@@ -2169,41 +2169,41 @@ void Game::checkInput()
} }
else if (player->isEnteringName()) 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 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(input_fire_center, 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(input_fire_right, 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 (fire1 || fire2 || fire3)
{ {
if (player->getRecordNamePos() == 7) if (player->getRecordNamePos() == 7)
{ {
player->setInput(input_start); player->setInput(InputType::START);
addScoreToScoreBoard(player->getRecordName(), player->getScore()); addScoreToScoreBoard(player->getRecordName(), player->getScore());
player->setStatusPlaying(PlayerStatus::CONTINUE); player->setStatusPlaying(PlayerStatus::CONTINUE);
} }
else 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()); addScoreToScoreBoard(player->getRecordName(), player->getScore());
player->setStatusPlaying(PlayerStatus::CONTINUE); player->setStatusPlaying(PlayerStatus::CONTINUE);
} }

42
source/global_inputs.cpp
View File

@@ -12,16 +12,16 @@
namespace globalInputs namespace globalInputs
{ {
// Variables // Variables
std::vector<int> servicePressedCounter; std::vector<int> service_pressed_counter;
// Inicializa variables // Inicializa variables
void init() void init()
{ {
const auto numInputs = Input::get()->getNumControllers() + 1; const auto num_inputs = Input::get()->getNumControllers() + 1;
servicePressedCounter.reserve(numInputs); service_pressed_counter.reserve(num_inputs);
for (int i = 0; i < numInputs; ++i) 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() void check()
{ {
// Comprueba si se sale con el teclado // 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); quit(section::Options::QUIT_NORMAL);
return; return;
} }
// Comprueba si se va a resetear el juego // 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(); reset();
return; 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(); switchAudio();
return; 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(); OnScreenHelp::get()->toggleState();
servicePressedCounter[0] = 0; service_pressed_counter[0] = 0;
} }
return; return;
} }
else else
{ {
servicePressedCounter[0] = 0; service_pressed_counter[0] = 0;
} }
for (int i = 0; i < Input::get()->getNumControllers(); ++i) for (int i = 0; i < Input::get()->getNumControllers(); ++i)
{ {
// Comprueba si se sale con el mando // 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); quit(section::Options::QUIT_SHUTDOWN);
return; return;
} }
// Comprueba si se va a resetear el juego // 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(); reset();
return; return;
} }
// Comprueba si se va a activar o desactivar el audio // 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(); switchAudio();
return; 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(); OnScreenHelp::get()->toggleState();
servicePressedCounter[i + 1] = 0; service_pressed_counter[i + 1] = 0;
} }
return; return;
} }
else else
{ {
servicePressedCounter[i + 1] = 0; service_pressed_counter[i + 1] = 0;
} }
} }
} }

2
source/global_inputs.h
View File

@@ -1,7 +1,7 @@
#include <vector> #include <vector>
namespace globalInputs namespace globalInputs
{ {
extern std::vector<int> servicePressedCounter; extern std::vector<int> service_pressed_counter;
// Inicializa variables // Inicializa variables
void init(); void init();

134
source/hiscore_table.cpp
View File

@@ -19,40 +19,39 @@
// Constructor // Constructor
HiScoreTable::HiScoreTable(JA_Music_t *music) HiScoreTable::HiScoreTable(JA_Music_t *music)
: music(music) : music_(music)
{ {
// Copia punteros // Copia punteros
renderer = Screen::get()->getRenderer(); renderer_ = Screen::get()->getRenderer();
// Objetos // Objetos
eventHandler = std::make_unique<SDL_Event>(); fade_ = std::make_unique<Fade>(renderer_);
fade = std::make_unique<Fade>(renderer); background_ = std::make_unique<Background>(renderer_);
background = std::make_unique<Background>(renderer); text_ = std::make_unique<Text>(Asset::get()->get("smb2.gif"), Asset::get()->get("smb2.txt"), renderer_);
text = std::make_unique<Text>(Asset::get()->get("smb2.gif"), Asset::get()->get("smb2.txt"), renderer);
// Crea un backbuffer para el renderizador // Crea un backbuffer para el renderizador
backbuffer = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height); backbuffer_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height);
SDL_SetTextureBlendMode(backbuffer, SDL_BLENDMODE_BLEND); SDL_SetTextureBlendMode(backbuffer_, SDL_BLENDMODE_BLEND);
// Inicializa variables // Inicializa variables
section::name = section::Name::HI_SCORE_TABLE; section::name = section::Name::HI_SCORE_TABLE;
ticks = 0; ticks_ = 0;
ticksSpeed = 15; ticks_speed_ = 15;
counter = 0; counter_ = 0;
counterEnd = 800; counter_end_ = 800;
viewArea = {0, 0, param.game.width, param.game.height}; view_area_ = {0, 0, param.game.width, param.game.height};
fadeMode = FadeMode::IN; fade_mode_ = FadeMode::IN;
// Inicializa objetos // Inicializa objetos
background->setPos(param.game.game_area.rect); background_->setPos(param.game.game_area.rect);
background->setCloudsSpeed(-0.1f); background_->setCloudsSpeed(-0.1f);
background->setGradientNumber(1); background_->setGradientNumber(1);
background->setTransition(0.8f); background_->setTransition(0.8f);
fade->setColor(fade_color.r, fade_color.g, fade_color.b); fade_->setColor(fade_color.r, fade_color.g, fade_color.b);
fade->setType(FadeType::RANDOM_SQUARE); fade_->setType(FadeType::RANDOM_SQUARE);
fade->setPost(param.fade.post_duration); fade_->setPost(param.fade.post_duration);
fade->setMode(fadeMode); fade_->setMode(fade_mode_);
fade->activate(); fade_->activate();
// Crea el contenido de la textura con la lista de puntuaciones // Crea el contenido de la textura con la lista de puntuaciones
fillTexture(); fillTexture();
@@ -61,45 +60,45 @@ HiScoreTable::HiScoreTable(JA_Music_t *music)
// Destructor // Destructor
HiScoreTable::~HiScoreTable() HiScoreTable::~HiScoreTable()
{ {
SDL_DestroyTexture(backbuffer); SDL_DestroyTexture(backbuffer_);
} }
// Actualiza las variables // Actualiza las variables
void HiScoreTable::update() void HiScoreTable::update()
{ {
// Actualiza las variables // Actualiza las variables
if (SDL_GetTicks() - ticks > ticksSpeed) if (SDL_GetTicks() - ticks_ > ticks_speed_)
{ {
// Actualiza el contador de ticks // Actualiza el contador de ticks
ticks = SDL_GetTicks(); ticks_ = SDL_GetTicks();
// Mantiene la música sonando // Mantiene la música sonando
if ((JA_GetMusicState() == JA_MUSIC_INVALID) || (JA_GetMusicState() == JA_MUSIC_STOPPED)) if ((JA_GetMusicState() == JA_MUSIC_INVALID) || (JA_GetMusicState() == JA_MUSIC_STOPPED))
{ {
JA_PlayMusic(music); JA_PlayMusic(music_);
} }
// Actualiza el objeto screen // Actualiza el objeto screen
Screen::get()->update(); Screen::get()->update();
// Actualiza el fondo // Actualiza el fondo
background->update(); background_->update();
// Gestiona el fade // Gestiona el fade
updateFade(); updateFade();
// Gestiona el contador y sus eventos // Gestiona el contador y sus eventos
counter++; counter_++;
if (counter == 150) if (counter_ == 150)
{ {
background->setColor({0, 0, 0}); background_->setColor({0, 0, 0});
background->setAlpha(96); 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 // Crea el contenido de la textura con la lista de puntuaciones
void HiScoreTable::fillTexture() void HiScoreTable::fillTexture()
{ {
// hay 27 letras - 7 de puntos quedan 20 caracteres 20 - nameLenght 0 numDots // hay 27 letras - 7 de puntos quedan 20 caracteres 20 - name_lenght 0 num_dots
constexpr auto maxNames = 10; constexpr auto max_names = 10;
constexpr auto spaceBetweenHeader = 32; constexpr auto space_between_header = 32;
const auto spaceBetweenLines = text->getCharacterSize() * 2.0f; const auto space_between_lines = text_->getCharacterSize() * 2.0f;
const auto size = spaceBetweenHeader + spaceBetweenLines * (maxNames - 1) + text->getCharacterSize(); const auto size = space_between_header + space_between_lines * (max_names - 1) + text_->getCharacterSize();
const auto firstLine = (param.game.height - size) / 2; const auto first_line = (param.game.height - size) / 2;
// Pinta en el backbuffer el texto y los sprites // Pinta en el backbuffer el texto y los sprites
auto temp = SDL_GetRenderTarget(renderer); auto temp = SDL_GetRenderTarget(renderer_);
SDL_SetRenderTarget(renderer, backbuffer); SDL_SetRenderTarget(renderer_, backbuffer_);
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0); SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 0);
SDL_RenderClear(renderer); SDL_RenderClear(renderer_);
// Escribe el texto: Mejores puntuaciones // 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 // 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 score = format(options.game.hi_score_table[i].score);
const auto scoreLenght = score.size(); const auto score_lenght = score.size();
const auto numDots = 25 - nameLenght - scoreLenght; const auto num_dots = 25 - name_lenght - score_lenght;
std::string dots = ""; std::string dots = "";
for (int j = 0; j < (int)numDots; ++j) for (int j = 0; j < (int)num_dots; ++j)
{ {
dots = dots + "."; dots = dots + ".";
} }
const auto line = options.game.hi_score_table[i].name + dots + score; 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 // Cambia el destino de renderizado
SDL_SetRenderTarget(renderer, temp); SDL_SetRenderTarget(renderer_, temp);
} }
// Pinta en pantalla // Pinta en pantalla
@@ -153,16 +152,16 @@ void HiScoreTable::render()
Screen::get()->clean(bg_color); Screen::get()->clean(bg_color);
// Pinta el fondo // Pinta el fondo
background->render(); background_->render();
// Establece la ventana del backbuffer // 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 // Copia el backbuffer al renderizador
SDL_RenderCopy(renderer, backbuffer, nullptr, &viewArea); SDL_RenderCopy(renderer_, backbuffer_, nullptr, &view_area_);
// Renderiza el fade // Renderiza el fade
fade->render(); fade_->render();
// Vuelca el contenido del renderizador en pantalla // Vuelca el contenido del renderizador en pantalla
Screen::get()->blit(); Screen::get()->blit();
@@ -171,7 +170,7 @@ void HiScoreTable::render()
// Recarga todas las texturas // Recarga todas las texturas
void HiScoreTable::reloadTextures() void HiScoreTable::reloadTextures()
{ {
text->reLoadTexture(); text_->reLoadTexture();
fillTexture(); fillTexture();
} }
@@ -179,19 +178,20 @@ void HiScoreTable::reloadTextures()
void HiScoreTable::checkEvents() void HiScoreTable::checkEvents()
{ {
// Comprueba los eventos que hay en la cola // 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 // Evento de salida de la aplicación
if (eventHandler->type == SDL_QUIT) if (event.type == SDL_QUIT)
{ {
section::name = section::Name::QUIT; section::name = section::Name::QUIT;
break; break;
} }
// Comprueba si se ha cambiado el tamaño de la ventana // 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(); reloadTextures();
} }
@@ -233,16 +233,16 @@ void HiScoreTable::run()
// Gestiona el fade // Gestiona el fade
void HiScoreTable::updateFade() void HiScoreTable::updateFade()
{ {
fade->update(); fade_->update();
if (fade->hasEnded() && fadeMode == FadeMode::IN) if (fade_->hasEnded() && fade_mode_ == FadeMode::IN)
{ {
fade->reset(); fade_->reset();
fadeMode = FadeMode::OUT; fade_mode_ = FadeMode::OUT;
fade->setMode(fadeMode); fade_->setMode(fade_mode_);
} }
if (fade->hasEnded() && fadeMode == FadeMode::OUT) if (fade_->hasEnded() && fade_mode_ == FadeMode::OUT)
{ {
section::name = section::Name::INSTRUCTIONS; section::name = section::Name::INSTRUCTIONS;
} }

25
source/hiscore_table.h
View File

@@ -28,22 +28,21 @@ class HiScoreTable
{ {
private: private:
// Objetos y punteros // Objetos y punteros
SDL_Renderer *renderer; // El renderizador de la ventana SDL_Renderer *renderer_; // El renderizador de la ventana
SDL_Texture *backbuffer; // Textura para usar como backbuffer SDL_Texture *backbuffer_; // Textura para usar como backbuffer
JA_Music_t *music; // Musica de fondo JA_Music_t *music_; // Musica de fondo
std::unique_ptr<Fade> fade; // Objeto para renderizar fades std::unique_ptr<Fade> fade_; // Objeto para renderizar fades
std::unique_ptr<Background> background; // Objeto para dibujar el fondo del juego std::unique_ptr<Background> background_; // Objeto para dibujar el fondo del juego
std::unique_ptr<SDL_Event> eventHandler; // Manejador de eventos std::unique_ptr<Text> text_; // Objeto para escribir texto
std::unique_ptr<Text> text; // Objeto para escribir texto
// Variables // Variables
Uint16 counter; // Contador Uint16 counter_; // Contador
Uint16 counterEnd; // Valor final para el contador Uint16 counter_end_; // Valor final para el contador
Uint32 ticks; // Contador de ticks para ajustar la velocidad del programa Uint32 ticks_; // Contador de ticks para ajustar la velocidad del programa
Uint32 ticksSpeed; // Velocidad a la que se repiten los bucles del programa Uint32 ticks_speed_; // Velocidad a la que se repiten los bucles del programa
SDL_Rect viewArea; // Parte de la textura que se muestra en pantalla SDL_Rect view_area_; // Parte de la textura que se muestra en pantalla
FadeMode fadeMode; // Modo de fade a utilizar FadeMode fade_mode_; // Modo de fade a utilizar
// Actualiza las variables // Actualiza las variables
void update(); void update();

384
source/input.cpp
View File

@@ -6,122 +6,108 @@
#include <iostream> // for basic_ostream, operator<<, cout, basi... #include <iostream> // for basic_ostream, operator<<, cout, basi...
// [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado // [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 // [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 // [SINGLETON] Destruiremos el objeto input con esta función estática
void Input::destroy() void Input::destroy()
{ {
delete Input::input; delete Input::input_;
} }
// [SINGLETON] Con este método obtenemos el objeto input y podemos trabajar con él // [SINGLETON] Con este método obtenemos el objeto input y podemos trabajar con él
Input *Input::get() Input *Input::get()
{ {
return Input::input; return Input::input_;
} }
// Constructor // Constructor
Input::Input(std::string dbPath) Input::Input(std::string game_controller_db_path)
: dbPath(dbPath) : game_controller_db_path_(game_controller_db_path)
{ {
// Inicializa variables // Inicializa variables
verbose = false; enabled_ = true;
enabled = true;
// Busca si hay mandos conectados // Busca si hay mandos conectados
discoverGameControllers(); discoverGameControllers();
// Inicializa las vectores // Inicializa las vectores
keyBindings_t kb; KeyBindings kb;
kb.scancode = 0; kb.scancode = 0;
kb.active = false; kb.active = false;
keyBindings.resize(input_number_of_inputs, kb); key_bindings_.resize(static_cast<int>(InputType::NUMBER_OF_INPUTS), kb);
GameControllerBindings_t gcb; ControllerBindings gcb;
gcb.button = SDL_CONTROLLER_BUTTON_INVALID; gcb.button = SDL_CONTROLLER_BUTTON_INVALID;
gcb.active = false; gcb.active = false;
gameControllerBindings.resize(numGamepads); controller_bindings_.resize(num_gamepads_);
for (int i = 0; i < numGamepads; ++i) for (int i = 0; i < num_gamepads_; ++i)
{ {
gameControllerBindings[i].resize(input_number_of_inputs, gcb); controller_bindings_[i].resize(static_cast<int>(InputType::NUMBER_OF_INPUTS), gcb);
} }
// Listado de los inputs usados para jugar, excluyendo botones para la interfaz // Listado de los inputs usados para jugar, excluyendo botones para la interfaz
gameInputs.clear(); game_inputs_.clear();
gameInputs.push_back(input_fire_left); game_inputs_.push_back(InputType::FIRE_LEFT);
gameInputs.push_back(input_fire_center); game_inputs_.push_back(InputType::FIRE_CENTER);
gameInputs.push_back(input_fire_right); game_inputs_.push_back(InputType::FIRE_RIGHT);
gameInputs.push_back(input_up); game_inputs_.push_back(InputType::UP);
gameInputs.push_back(input_down); game_inputs_.push_back(InputType::DOWN);
gameInputs.push_back(input_left); game_inputs_.push_back(InputType::LEFT);
gameInputs.push_back(input_right); game_inputs_.push_back(InputType::RIGHT);
// Listado de los inputs para jugar que utilizan botones, ni palancas ni crucetas // Listado de los inputs para jugar que utilizan botones, ni palancas ni crucetas
buttonInputs.clear(); button_inputs_.clear();
buttonInputs.push_back(input_fire_left); button_inputs_.push_back(InputType::FIRE_LEFT);
buttonInputs.push_back(input_fire_center); button_inputs_.push_back(InputType::FIRE_CENTER);
buttonInputs.push_back(input_fire_right); button_inputs_.push_back(InputType::FIRE_RIGHT);
buttonInputs.push_back(input_start); button_inputs_.push_back(InputType::START);
}
// Destructor
Input::~Input()
{
}
// Actualiza el estado del objeto
void Input::update()
{
if (disabledUntil == d_keyPressed && !checkAnyInput())
{
enable();
}
} }
// Asigna inputs a teclas // 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<int>(input)].scancode = code;
} }
// Asigna inputs a botones del mando // 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<int>(input)].button = button;
} }
} }
// Asigna inputs a botones del mando // 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<int>(input_target)].button = controller_bindings_[controller_index][static_cast<int>(input_source)].button;
} }
} }
// Comprueba si un input esta activo // 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; return false;
} }
bool successKeyboard = false; bool success_keyboard = false;
bool successGameController = false; bool success_controller = false;
const int input_index = static_cast<int>(input);
if (device == INPUT_USE_ANY) if (device == INPUT_USE_ANY)
{ {
index = 0; controller_index = 0;
} }
if (device == INPUT_USE_KEYBOARD || device == INPUT_USE_ANY) 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 (repeat)
{ {
if (keyStates[keyBindings[input].scancode] != 0) if (keyStates[key_bindings_[input_index].scancode] != 0)
{ {
successKeyboard = true; success_keyboard = true;
} }
else else
{ {
successKeyboard = false; success_keyboard = false;
} }
} }
else 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; key_bindings_[input_index].active = true;
successKeyboard = true; success_keyboard = true;
} }
else else
{ {
successKeyboard = false; success_keyboard = false;
} }
} }
else else
{ {
if (keyStates[keyBindings[input].scancode] == 0) if (keyStates[key_bindings_[input_index].scancode] == 0)
{ {
keyBindings[input].active = false; key_bindings_[input_index].active = false;
successKeyboard = false; success_keyboard = false;
} }
else 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)) if ((device == INPUT_USE_GAMECONTROLLER) || (device == INPUT_USE_ANY))
{ {
successGameController = checkAxisInput(input, index); success_controller = checkAxisInput(input, controller_index);
if (!successGameController) if (!success_controller)
{ {
if (repeat) 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 else
{ {
successGameController = false; success_controller = false;
} }
} }
else 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; controller_bindings_[controller_index][input_index].active = true;
successGameController = true; success_controller = true;
} }
else else
{ {
successGameController = false; success_controller = false;
} }
} }
else 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; controller_bindings_[controller_index][input_index].active = false;
successGameController = false; success_controller = false;
} }
else else
{ {
successGameController = false; success_controller = false;
} }
} }
} }
} }
} }
return (successKeyboard || successGameController); return (success_keyboard || success_controller);
} }
// Comprueba si un input con modificador esta activo // 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; return false;
} }
bool successKeyboard = false; bool success_keyboard = false;
bool successGameController = false; bool success_controller = false;
const int input_index = static_cast<int>(input);
if (device == INPUT_USE_ANY) if (device == INPUT_USE_ANY)
{ {
index = 0; controller_index = 0;
} }
if (device == INPUT_USE_KEYBOARD || device == INPUT_USE_ANY) 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 (repeat)
{ {
if (keyStates[keyBindings[input].scancode] != 0) if (keyStates[key_bindings_[input_index].scancode] != 0)
{ {
successKeyboard = true; success_keyboard = true;
} }
else else
{ {
successKeyboard = false; success_keyboard = false;
} }
} }
else 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; key_bindings_[input_index].active = true;
successKeyboard = true; success_keyboard = true;
} }
else else
{ {
successKeyboard = false; success_keyboard = false;
} }
} }
else else
{ {
if (keyStates[keyBindings[input].scancode] == 0) if (keyStates[key_bindings_[input_index].scancode] == 0)
{ {
keyBindings[input].active = false; key_bindings_[input_index].active = false;
successKeyboard = false; success_keyboard = false;
} }
else 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)) if ((device == INPUT_USE_GAMECONTROLLER) || (device == INPUT_USE_ANY))
{ {
successGameController = checkAxisInput(input, index); success_controller = checkAxisInput(input, controller_index);
if (!successGameController) if (!success_controller)
{ {
if (repeat) 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 else
{ {
successGameController = false; success_controller = false;
} }
} }
else 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; controller_bindings_[controller_index][input_index].active = true;
successGameController = true; success_controller = true;
} }
else else
{ {
successGameController = false; success_controller = false;
} }
} }
else 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; controller_bindings_[controller_index][input_index].active = false;
successGameController = false; success_controller = false;
} }
else else
{ {
successGameController = false; success_controller = false;
} }
} }
} }
} }
} }
return (successKeyboard || successGameController); return (success_keyboard || success_controller);
} }
// Comprueba si hay almenos un input activo // 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) if (device == INPUT_USE_ANY)
{ {
index = 0; controller_index = 0;
} }
if (device == INPUT_USE_KEYBOARD || device == INPUT_USE_ANY) if (device == INPUT_USE_KEYBOARD || device == INPUT_USE_ANY)
{ {
const Uint8 *mKeystates = SDL_GetKeyboardState(nullptr); 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; return true;
} }
} }
@@ -354,11 +341,11 @@ bool Input::checkAnyInput(int device, int index)
{ {
if (device == INPUT_USE_GAMECONTROLLER || device == INPUT_USE_ANY) 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; return true;
} }
} }
@@ -372,13 +359,13 @@ bool Input::checkAnyInput(int device, int index)
int Input::checkAnyButtonPressed(bool repeat) int Input::checkAnyButtonPressed(bool repeat)
{ {
// Si está pulsado el botón de servicio, ningún botón se puede considerar pulsado // 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; return 0;
} }
// Solo comprueba los botones definidos previamente // Solo comprueba los botones definidos previamente
for (auto bi : buttonInputs) for (auto bi : button_inputs_)
{ {
// Comprueba el teclado // Comprueba el teclado
if (checkInput(bi, repeat, INPUT_USE_KEYBOARD)) if (checkInput(bi, repeat, INPUT_USE_KEYBOARD))
@@ -387,7 +374,7 @@ int Input::checkAnyButtonPressed(bool repeat)
} }
// Comprueba los mandos // 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)) if (checkInput(bi, repeat, INPUT_USE_GAMECONTROLLER, i))
{ {
@@ -409,60 +396,64 @@ bool Input::discoverGameControllers()
SDL_InitSubSystem(SDL_INIT_GAMECONTROLLER); 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(); num_joysticks_ = SDL_NumJoysticks();
numGamepads = 0; num_gamepads_ = 0;
// Cuenta el número de mandos // Cuenta el número de mandos
joysticks.clear(); joysticks_.clear();
for (int i = 0; i < numJoysticks; ++i) for (int i = 0; i < num_joysticks_; ++i)
{ {
SDL_Joystick *joy = SDL_JoystickOpen(i); SDL_Joystick *joy = SDL_JoystickOpen(i);
joysticks.push_back(joy); joysticks_.push_back(joy);
if (SDL_IsGameController(i)) if (SDL_IsGameController(i))
{ {
numGamepads++; num_gamepads_++;
} }
} }
if (verbose) #ifdef VERBOSE
{ {
std::cout << "\nChecking for game controllers...\n"; 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; 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 // Abre el mando y lo añade a la lista
SDL_GameController *pad = SDL_GameControllerOpen(i); SDL_GameController *pad = SDL_GameControllerOpen(i);
if (SDL_GameControllerGetAttached(pad) == 1) if (SDL_GameControllerGetAttached(pad) == 1)
{ {
connectedControllers.push_back(pad); connected_controllers_.push_back(pad);
const std::string separator(" #"); const std::string separator(" #");
std::string name = SDL_GameControllerNameForIndex(i); std::string name = SDL_GameControllerNameForIndex(i);
if (verbose) #ifdef VERBOSE
{ {
std::cout << name << std::endl; std::cout << name << std::endl;
} }
controllerNames.push_back(name); #endif
controller_names_.push_back(name);
} }
else else
{ {
if (verbose) #ifdef VERBOSE
{ {
std::cout << "SDL_GetError() = " << SDL_GetError() << std::endl; std::cout << "SDL_GetError() = " << SDL_GetError() << std::endl;
} }
#endif
} }
} }
@@ -475,47 +466,27 @@ bool Input::discoverGameControllers()
// Comprueba si hay algun mando conectado // Comprueba si hay algun mando conectado
bool Input::gameControllerFound() bool Input::gameControllerFound()
{ {
return numGamepads > 0 ? true : false; return num_gamepads_ > 0 ? true : false;
} }
// Obten el nombre de un mando de juego // 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 // Obten el número de mandos conectados
int Input::getNumControllers() const int Input::getNumControllers() const
{ {
return numGamepads; return num_gamepads_;
}
// 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;
} }
// Obtiene el indice del controlador a partir de un event.id // Obtiene el indice del controlador a partir de un event.id
int Input::getJoyIndex(int id) const 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; return i;
} }
@@ -524,7 +495,7 @@ int Input::getJoyIndex(int id) const
} }
// Muestra por consola los controles asignados // 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) 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 (device == INPUT_USE_GAMECONTROLLER)
{ {
if (index >= numGamepads) if (controller_index >= num_gamepads_)
{ {
return; return;
} }
// Muestra el nombre del mando // Muestra el nombre del mando
std::cout << "\n" std::cout << "\n"
<< controllerNames[index] << std::endl; << controller_names_[controller_index] << std::endl;
// Muestra los botones asignados // 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<int>(bi)].button << std::endl;
} }
} }
} }
// Obtiene el SDL_GameControllerButton asignado a un input // 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<int>(input)].button;
} }
// Obtiene el indice a partir del nombre del mando // Obtiene el indice a partir del nombre del mando
int Input::getIndexByName(std::string name) const 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; return i;
} }
@@ -569,30 +540,30 @@ int Input::getIndexByName(std::string name) const
return -1; return -1;
} }
// Convierte un inputs_e a std::string // Convierte un InputType a std::string
std::string Input::to_string(inputs_e input) const std::string Input::to_string(InputType input) const
{ {
if (input == input_fire_left) if (input == InputType::FIRE_LEFT)
{ {
return "input_fire_left"; return "input_fire_left";
} }
if (input == input_fire_center) if (input == InputType::FIRE_CENTER)
{ {
return "input_fire_center"; return "input_fire_center";
} }
if (input == input_fire_right) if (input == InputType::FIRE_RIGHT)
{ {
return "input_fire_right"; return "input_fire_right";
} }
if (input == input_start) if (input == InputType::START)
{ {
return "input_start"; return "input_start";
} }
if (input == input_service) if (input == InputType::SERVICE)
{ {
return "input_service"; return "input_service";
} }
@@ -600,76 +571,77 @@ std::string Input::to_string(inputs_e input) const
return ""; return "";
} }
// Convierte un std::string a inputs_e // Convierte un std::string a InputType
inputs_e Input::to_inputs_e(std::string name) const InputType Input::to_inputs_e(std::string name) const
{ {
if (name == "input_fire_left") if (name == "input_fire_left")
{ {
return input_fire_left; return InputType::FIRE_LEFT;
} }
if (name == "input_fire_center") if (name == "input_fire_center")
{ {
return input_fire_center; return InputType::FIRE_CENTER;
} }
if (name == "input_fire_right") if (name == "input_fire_right")
{ {
return input_fire_right; return InputType::FIRE_RIGHT;
} }
if (name == "input_start") if (name == "input_start")
{ {
return input_start; return InputType::START;
} }
if (name == "input_service") 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 // 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 // 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; bool success = false;
switch (input) switch (input)
{ {
case input_left: case InputType::LEFT:
if (SDL_GameControllerGetAxis(connectedControllers[index], SDL_CONTROLLER_AXIS_LEFTX) < -30000) if (SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTX) < -30000)
{ {
success = true; success = true;
} }
break; break;
case input_right: case InputType::RIGHT:
if (SDL_GameControllerGetAxis(connectedControllers[index], SDL_CONTROLLER_AXIS_LEFTX) > 30000) if (SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTX) > 30000)
{ {
success = true; success = true;
} }
break; break;
case input_up: case InputType::UP:
if (SDL_GameControllerGetAxis(connectedControllers[index], SDL_CONTROLLER_AXIS_LEFTY) < -30000) if (SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTY) < -30000)
{ {
success = true; success = true;
} }
break; break;
case input_down: case InputType::DOWN:
if (SDL_GameControllerGetAxis(connectedControllers[index], SDL_CONTROLLER_AXIS_LEFTY) > 30000) if (SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTY) > 30000)
{ {
success = true; success = true;
} }

153
source/input.h
View File

@@ -1,11 +1,11 @@
#pragma once #pragma once
#include <SDL2/SDL_gamecontroller.h> // for SDL_GameControllerButton, SDL_G... #include <SDL2/SDL_gamecontroller.h> // for SDL_GameControllerButton, SDL_G...
#include <SDL2/SDL_joystick.h> // for SDL_Joystick #include <SDL2/SDL_joystick.h> // for SDL_Joystick
#include <SDL2/SDL_scancode.h> // for SDL_Scancode #include <SDL2/SDL_scancode.h> // for SDL_Scancode
#include <SDL2/SDL_stdinc.h> // for Uint8 #include <SDL2/SDL_stdinc.h> // for Uint8
#include <string> // for string, basic_string #include <string> // for string, basic_string
#include <vector> // for vector #include <vector> // for vector
/* /*
connectedControllers es un vector donde estan todos los mandos encontrados [0 .. n] 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 INPUT_USE_ANY mirará tanto el teclado como el PRIMER controlador
*/ */
enum inputs_e enum class InputType : int
{ {
// Inputs de movimiento // Inputs de movimiento
input_up, UP,
input_down, DOWN,
input_left, LEFT,
input_right, RIGHT,
// Inputs personalizados // Inputs personalizados
input_fire_left, FIRE_LEFT,
input_fire_center, FIRE_CENTER,
input_fire_right, FIRE_RIGHT,
input_start, START,
// Inputs de control // Inputs de control
input_exit, EXIT,
input_pause, PAUSE,
input_service, SERVICE,
input_window_fullscreen, WINDOW_FULLSCREEN,
input_window_inc_size, WINDOW_INC_SIZE,
input_window_dec_size, WINDOW_DEC_SIZE,
input_video_shaders, VIDEO_SHADERS,
input_reset, RESET,
input_mute, MUTE,
input_showinfo, SHOWINFO,
input_config, CONFIG,
input_swap_controllers, SWAP_CONTROLLERS,
// Input obligatorio // Input obligatorio
input_null, NONE,
input_number_of_inputs, NUMBER_OF_INPUTS,
}; };
#define INPUT_ALLOW_REPEAT true constexpr bool INPUT_ALLOW_REPEAT = true;
#define INPUT_DO_NOT_ALLOW_REPEAT false constexpr bool INPUT_DO_NOT_ALLOW_REPEAT = false;
#define INPUT_USE_KEYBOARD 0 constexpr int INPUT_USE_KEYBOARD = 0;
#define INPUT_USE_GAMECONTROLLER 1 constexpr int INPUT_USE_GAMECONTROLLER = 1;
#define INPUT_USE_ANY 2 constexpr int INPUT_USE_ANY = 2;
enum i_disable_e
{
d_notDisabled,
d_forever,
d_keyPressed
};
class Input class Input
{ {
private: private:
// [SINGLETON] Objeto screen privado para Don Melitón // [SINGLETON] Objeto screen privado para Don Melitón
static Input *input; static Input *input_;
struct keyBindings_t struct KeyBindings
{ {
Uint8 scancode; // Scancode asociado Uint8 scancode; // Scancode asociado
bool active; // Indica si está activo bool active; // Indica si está activo
}; };
struct GameControllerBindings_t struct ControllerBindings
{ {
SDL_GameControllerButton button; // GameControllerButton asociado SDL_GameControllerButton button; // GameControllerButton asociado
bool active; // Indica si está activo bool active; // Indica si está activo
}; };
// Variables // Variables
std::vector<SDL_GameController *> connectedControllers; // Vector con todos los mandos conectados std::vector<SDL_GameController *> connected_controllers_; // Vector con todos los mandos conectados
std::vector<SDL_Joystick *> joysticks; // Vector con todos los joysticks conectados std::vector<SDL_Joystick *> joysticks_; // Vector con todos los joysticks conectados
std::vector<keyBindings_t> keyBindings; // Vector con las teclas asociadas a los inputs predefinidos std::vector<KeyBindings> key_bindings_; // Vector con las teclas asociadas a los inputs predefinidos
std::vector<std::vector<GameControllerBindings_t>> gameControllerBindings; // Vector con los botones asociadas a los inputs predefinidos para cada mando std::vector<std::vector<ControllerBindings>> controller_bindings_; // Vector con los botones asociadas a los inputs predefinidos para cada mando
std::vector<std::string> controllerNames; // Vector con los nombres de los mandos std::vector<std::string> controller_names_; // Vector con los nombres de los mandos
std::vector<inputs_e> gameInputs; // Inputs usados para jugar, normalmente direcciones y botones std::vector<InputType> game_inputs_; // Inputs usados para jugar, normalmente direcciones y botones
std::vector<inputs_e> buttonInputs; // Inputs asignados al jugador y a botones, excluyendo direcciones std::vector<InputType> button_inputs_; // Inputs asignados al jugador y a botones, excluyendo direcciones
int numJoysticks; // Número de joysticks conectados int num_joysticks_; // Número de joysticks conectados
int numGamepads; // Número de mandos conectados int num_gamepads_; // Número de mandos conectados
std::string dbPath; // Ruta al archivo gamecontrollerdb.txt std::string game_controller_db_path_; // Ruta al archivo gamecontrollerdb.txt
bool verbose; // Indica si ha de mostrar mensajes bool enabled_; // Indica si está habilitado
i_disable_e disabledUntil; // Tiempo que esta deshabilitado
bool enabled; // Indica si está habilitado
// Comprueba el eje del mando // Comprueba el eje del mando
bool checkAxisInput(inputs_e input, int index = 0) const; bool checkAxisInput(InputType input, int controller_index = 0) const;
// Constructor // Constructor
Input(std::string dbPath); Input(std::string game_controller_db_path);
// Destructor // Destructor
~Input(); ~Input() = default;
public: public:
// [SINGLETON] Crearemos el objeto screen con esta función estática // [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 // [SINGLETON] Destruiremos el objeto screen con esta función estática
static void destroy(); static void destroy();
@@ -115,24 +106,21 @@ public:
// [SINGLETON] Con este método obtenemos el objeto screen y podemos trabajar con él // [SINGLETON] Con este método obtenemos el objeto screen y podemos trabajar con él
static Input *get(); static Input *get();
// Actualiza el estado del objeto
void update();
// Asigna inputs a teclas // 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 // Asigna inputs a botones del mando
void bindGameControllerButton(int index, inputs_e input, SDL_GameControllerButton button); void bindGameControllerButton(int controller_index, InputType input, SDL_GameControllerButton button);
void bindGameControllerButton(int index, inputs_e inputTarget, inputs_e inputSource); void bindGameControllerButton(int controller_index, InputType inputTarget, InputType inputSource);
// Comprueba si un input esta activo // 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 // 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 // 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 // Comprueba si hay algún botón pulsado
int checkAnyButtonPressed(bool repeat = INPUT_DO_NOT_ALLOW_REPEAT); int checkAnyButtonPressed(bool repeat = INPUT_DO_NOT_ALLOW_REPEAT);
@@ -147,35 +135,26 @@ public:
int getNumControllers() const; int getNumControllers() const;
// Obten el nombre de un mando de juego // Obten el nombre de un mando de juego
std::string getControllerName(int index) const; std::string getControllerName(int controller_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();
// Obtiene el indice del controlador a partir de un event.id // Obtiene el indice del controlador a partir de un event.id
int getJoyIndex(int id) const; int getJoyIndex(int id) const;
// Muestra por consola los controles asignados // 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 // 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 // Convierte un InputType a std::string
std::string to_string(inputs_e input) const; std::string to_string(InputType input) const;
// Convierte un std::string a inputs_e // Convierte un std::string a InputType
inputs_e to_inputs_e(std::string name) const; InputType to_inputs_e(std::string name) const;
// Obtiene el indice a partir del nombre del mando // Obtiene el indice a partir del nombre del mando
int getIndexByName(std::string name) const; 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 // 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);
}; };

10
source/options.cpp
View File

@@ -57,11 +57,11 @@ void initOptions()
// Inputs que se guardan en las opciones y, por tanto, a disco // Inputs que se guardan en las opciones y, por tanto, a disco
c.inputs.clear(); c.inputs.clear();
c.inputs.push_back(input_fire_left); c.inputs.push_back(InputType::FIRE_LEFT);
c.inputs.push_back(input_fire_center); c.inputs.push_back(InputType::FIRE_CENTER);
c.inputs.push_back(input_fire_right); c.inputs.push_back(InputType::FIRE_RIGHT);
c.inputs.push_back(input_start); c.inputs.push_back(InputType::START);
c.inputs.push_back(input_service); c.inputs.push_back(InputType::SERVICE);
// Botones asociados a los inputs anteriores // Botones asociados a los inputs anteriores
c.buttons.clear(); c.buttons.clear();

26
source/player.cpp
View File

@@ -77,7 +77,7 @@ void Player::init()
} }
// Actua en consecuencia de la entrada recibida // Actua en consecuencia de la entrada recibida
void Player::setInput(int input) void Player::setInput(InputType input)
{ {
switch (status_playing_) switch (status_playing_)
{ {
@@ -99,37 +99,37 @@ void Player::setInput(int input)
} }
// Procesa inputs para cuando está jugando // Procesa inputs para cuando está jugando
void Player::setInputPlaying(int input) void Player::setInputPlaying(InputType input)
{ {
switch (input) switch (input)
{ {
case input_left: case InputType::LEFT:
{ {
vel_x_ = -base_speed_; vel_x_ = -base_speed_;
setWalkingStatus(PlayerStatus::WALKING_LEFT); setWalkingStatus(PlayerStatus::WALKING_LEFT);
break; break;
} }
case input_right: case InputType::RIGHT:
{ {
vel_x_ = base_speed_; vel_x_ = base_speed_;
setWalkingStatus(PlayerStatus::WALKING_RIGHT); setWalkingStatus(PlayerStatus::WALKING_RIGHT);
break; break;
} }
case input_fire_center: case InputType::FIRE_CENTER:
{ {
setFiringStatus(PlayerStatus::FIRING_UP); setFiringStatus(PlayerStatus::FIRING_UP);
break; break;
} }
case input_fire_left: case InputType::FIRE_LEFT:
{ {
setFiringStatus(PlayerStatus::FIRING_LEFT); setFiringStatus(PlayerStatus::FIRING_LEFT);
break; break;
} }
case input_fire_right: case InputType::FIRE_RIGHT:
{ {
setFiringStatus(PlayerStatus::FIRING_RIGHT); setFiringStatus(PlayerStatus::FIRING_RIGHT);
break; break;
@@ -145,27 +145,27 @@ void Player::setInputPlaying(int input)
} }
// Procesa inputs para cuando está introduciendo el nombre // Procesa inputs para cuando está introduciendo el nombre
void Player::setInputEnteringName(int input) void Player::setInputEnteringName(InputType input)
{ {
switch (input) switch (input)
{ {
case input_left: case InputType::LEFT:
enter_name_->decPos(); enter_name_->decPos();
break; break;
case input_right: case InputType::RIGHT:
enter_name_->incPos(); enter_name_->incPos();
break; break;
case input_up: case InputType::UP:
enter_name_->incIndex(); enter_name_->incIndex();
break; break;
case input_down: case InputType::DOWN:
enter_name_->decIndex(); enter_name_->decIndex();
break; break;
case input_start: case InputType::START:
setRecordName(enter_name_->getName()); setRecordName(enter_name_->getName());
break; break;

6
source/player.h
View File

@@ -121,13 +121,13 @@ public:
void setPlayerTextures(std::vector<std::shared_ptr<Texture>> texture); void setPlayerTextures(std::vector<std::shared_ptr<Texture>> texture);
// Actua en consecuencia de la entrada recibida // Actua en consecuencia de la entrada recibida
void setInput(int input); void setInput(InputType input);
// Procesa inputs para cuando está jugando // Procesa inputs para cuando está jugando
void setInputPlaying(int input); void setInputPlaying(InputType input);
// Procesa inputs para cuando está introduciendo el nombre // 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 // Mueve el jugador a la posición y animación que le corresponde
void move(); void move();

16
source/screen.cpp
View File

@@ -293,7 +293,7 @@ void Screen::checkInput()
{ {
#ifndef ARCADE #ifndef ARCADE
// Comprueba el teclado para cambiar entre pantalla completa y ventana // 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(); switchVideoMode();
const std::string mode = options.video.mode == ScreenVideoMode::WINDOW ? "Window" : "Fullscreen"; 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 // 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(); decWindowSize();
const std::string size = std::to_string(options.video.window.size); 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 // 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(); incWindowSize();
const std::string size = std::to_string(options.video.window.size); const std::string size = std::to_string(options.video.window.size);
@@ -321,7 +321,7 @@ void Screen::checkInput()
#endif #endif
// Comprueba el teclado para activar o desactivar los shaders // 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(); switchShaders();
return; return;
@@ -329,7 +329,7 @@ void Screen::checkInput()
#ifdef DEBUG #ifdef DEBUG
// Comprueba el teclado para mostrar la información de 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_; show_info_ = !show_info_;
return; return;
@@ -339,14 +339,14 @@ void Screen::checkInput()
for (int i = 0; i < Input::get()->getNumControllers(); ++i) for (int i = 0; i < Input::get()->getNumControllers(); ++i)
{ {
// Comprueba los mandos para activar o desactivar los shaders // 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(); switchShaders();
return; return;
} }
// Comprueba los mandos para mostrar la información de debug // 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_; show_info_ = !show_info_;
return; return;
@@ -489,7 +489,7 @@ void Screen::displayInfo()
// Resolution // Resolution
dbg_print(0, 0, info_resolution_.c_str(), 255, 255, 0); 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);
} }
} }

10
source/title.cpp
View File

@@ -236,7 +236,7 @@ void Title::checkInput()
if (!define_buttons_->isEnabled()) if (!define_buttons_->isEnabled())
{ {
// Comprueba el teclado para empezar a jugar // 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) 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) for (int i = 0; i < input_->getNumControllers(); ++i)
{ {
// Comprueba si se va a intercambiar la asignación de mandos a jugadores // 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(); swapControllers();
return; return;
} }
// Comprueba si algun mando quiere ser configurado // 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); define_buttons_->enable(i);
return; return;
} }
// Comprueba el botón de START de los mandos // 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 // 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) if (section::options == section::Options::TITLE_2 || ALLOW_TITLE_ANIMATION_SKIP)
{ {

2
source/utils.h
View File

@@ -126,7 +126,7 @@ struct OptionsController
Uint8 device_type; // Indica si se utilizará teclado o mando o ambos Uint8 device_type; // Indica si se utilizará teclado o mando o ambos
std::string name; // Nombre del dispositivo std::string name; // Nombre del dispositivo
bool plugged; // Indica si el mando se encuentra conectado bool plugged; // Indica si el mando se encuentra conectado
std::vector<inputs_e> inputs; // Listado de inputs std::vector<InputType> inputs; // Listado de inputs
std::vector<SDL_GameControllerButton> buttons; // Listado de botones asignados a cada input std::vector<SDL_GameControllerButton> buttons; // Listado de botones asignados a cada input
}; };