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

Ja es pot gastar el teclat com a control independent del primer mando

Browse Source 
Ja pot jugar un jugador amb teclat i altre amb mando
Es pot asignar el teclat a qualsevol dels dos jugadors
Continua podentse gastar mando i teclat a l'hora per al mateix jugador
This commit is contained in:
Sergio
2024-11-03 11:07:58 +01:00
parent a1ccb6102a
commit 86cd7b0f16
11 changed files with 306 additions and 293 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
source/define_buttons.cpp
View File

@@ -16,11 +16,7 @@ DefineButtons::DefineButtons(std::unique_ptr<Text> text_)
x_ = param.game.width / 2; x_ = param.game.width / 2;
y_ = param.title.press_start_position; y_ = param.title.press_start_position;
buttons_.emplace_back(lang::getText(95), InputType::FIRE_LEFT, SDL_CONTROLLER_BUTTON_INVALID); clearButtons();
buttons_.emplace_back(lang::getText(96), InputType::FIRE_CENTER, SDL_CONTROLLER_BUTTON_INVALID);
buttons_.emplace_back(lang::getText(97), InputType::FIRE_RIGHT, SDL_CONTROLLER_BUTTON_INVALID);
buttons_.emplace_back(lang::getText(98), InputType::START, SDL_CONTROLLER_BUTTON_INVALID);
buttons_.emplace_back(lang::getText(99), InputType::SERVICE, SDL_CONTROLLER_BUTTON_INVALID);
for (int i = 0; i < input_->getNumControllers(); ++i) for (int i = 0; i < input_->getNumControllers(); ++i)
{ {
@@ -33,7 +29,7 @@ void DefineButtons::render()
{ {
if (enabled_) if (enabled_)
{ {
text_->writeCentered(x_, y_ - 10, lang::getText(100) + std::to_string(options.controller.at(index_controller_).player_id)); text_->writeCentered(x_, y_ - 10, lang::getText(100) + std::to_string(options.controllers.at(index_controller_).player_id));
text_->writeCentered(x_, y_, controller_names_.at(index_controller_)); text_->writeCentered(x_, y_, controller_names_.at(index_controller_));
text_->writeCentered(x_, y_ + 10, buttons_.at(index_button_).label); text_->writeCentered(x_, y_ + 10, buttons_.at(index_button_).label);
} }
@@ -103,6 +99,7 @@ bool DefineButtons::enable(int index)
enabled_ = true; enabled_ = true;
index_controller_ = index; index_controller_ = index;
index_button_ = 0; index_button_ = 0;
clearButtons();
return true; return true;
} }
@@ -126,9 +123,9 @@ void DefineButtons::incIndexButton()
// Guarda los cambios en las opciones // Guarda los cambios en las opciones
saveBindingsToOptions(); saveBindingsToOptions();
// Reinicia variables // Deshabilita
index_button_ = 0; //index_controller_ = 0;
index_controller_ = 0; //index_button_ = 0;
enabled_ = false; enabled_ = false;
} }
} }
@@ -137,7 +134,7 @@ void DefineButtons::incIndexButton()
void DefineButtons::saveBindingsToOptions() void DefineButtons::saveBindingsToOptions()
{ {
// Modifica las opciones para colocar los valores asignados // Modifica las opciones para colocar los valores asignados
auto &controller = options.controller.at(index_controller_); auto &controller = options.controllers.at(index_controller_);
controller.name = input_->getControllerName(index_controller_); controller.name = input_->getControllerName(index_controller_);
for (size_t j = 0; j < controller.inputs.size(); ++j) for (size_t j = 0; j < controller.inputs.size(); ++j)
{ {
@@ -145,12 +142,6 @@ void DefineButtons::saveBindingsToOptions()
} }
} }
// Intercambia los jugadores asignados a los dos primeros mandos
void DefineButtons::swapControllers()
{
std::swap(options.controller[0].player_id, options.controller[1].player_id);
}
// Comprueba que un botón no esté ya asignado // Comprueba que un botón no esté ya asignado
bool DefineButtons::checkButtonNotInUse(SDL_GameControllerButton button) bool DefineButtons::checkButtonNotInUse(SDL_GameControllerButton button)
{ {
@@ -163,3 +154,14 @@ bool DefineButtons::checkButtonNotInUse(SDL_GameControllerButton button)
} }
return true; return true;
} }
// Limpia la asignación de botones
void DefineButtons::clearButtons()
{
buttons_.clear();
buttons_.emplace_back(lang::getText(95), InputType::FIRE_LEFT, SDL_CONTROLLER_BUTTON_INVALID);
buttons_.emplace_back(lang::getText(96), InputType::FIRE_CENTER, SDL_CONTROLLER_BUTTON_INVALID);
buttons_.emplace_back(lang::getText(97), InputType::FIRE_RIGHT, SDL_CONTROLLER_BUTTON_INVALID);
buttons_.emplace_back(lang::getText(98), InputType::START, SDL_CONTROLLER_BUTTON_INVALID);
buttons_.emplace_back(lang::getText(99), InputType::SERVICE, SDL_CONTROLLER_BUTTON_INVALID);
}

6
source/define_buttons.h
View File

@@ -52,6 +52,9 @@ private:
// Comprueba que un botón no esté ya asignado // Comprueba que un botón no esté ya asignado
bool checkButtonNotInUse(SDL_GameControllerButton button); bool checkButtonNotInUse(SDL_GameControllerButton button);
// Limpia la asignación de botones
void clearButtons();
public: public:
// Constructor // Constructor
explicit DefineButtons(std::unique_ptr<Text> text); explicit DefineButtons(std::unique_ptr<Text> text);
@@ -70,7 +73,4 @@ public:
// Comprueba si está habilitado // Comprueba si está habilitado
bool isEnabled(); bool isEnabled();
// Intercambia los jugadores asignados a los dos primeros mandos
void swapControllers();
}; };

26
source/director.cpp
View File

@@ -192,16 +192,16 @@ void Director::bindInputs()
} }
// 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
for (size_t i = 0; i < num_gamepads; ++i) const size_t max_controllers = std::min(2, num_gamepads);
for (size_t i = 0; i < max_controllers; ++i)
{ {
for (size_t index = 0; index < options.controller.size(); ++index) for (auto &controller : options.controllers)
{ {
if (Input::get()->getControllerName(i) == options.controller.at(index).name) if (Input::get()->getControllerName(i) == controller.name)
{ {
options.controller.at(index).plugged = true; for (size_t j = 0; j < controller.inputs.size(); ++j)
for (size_t j = 0; j < options.controller.at(index).inputs.size(); ++j)
{ {
Input::get()->bindGameControllerButton(i, options.controller.at(index).inputs.at(j), options.controller.at(index).buttons.at(j)); Input::get()->bindGameControllerButton(i, controller.inputs.at(j), controller.buttons.at(j));
} }
} }
} }
@@ -220,13 +220,17 @@ void Director::bindInputs()
Input::get()->bindGameControllerButton(i, InputType::SWAP_CONTROLLERS, InputType::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 de los dos primeros mandos
for (int i = 0; i < num_gamepads; ++i) for (size_t i = 0; i < max_controllers; ++i)
{ {
options.controller.at(i).name = Input::get()->getControllerName(i); // Variables asociadas al mando
for (size_t j = 0; j < options.controller.at(i).inputs.size(); ++j) options.controllers.at(i).index = i;
options.controllers.at(i).name = Input::get()->getControllerName(i);
options.controllers.at(i).plugged = true;
// Asignaciones de botones
for (size_t j = 0; j < options.controllers.at(i).inputs.size(); ++j)
{ {
options.controller.at(i).buttons.at(j) = Input::get()->getControllerBinding(i, options.controller.at(i).inputs.at(j)); options.controllers.at(i).buttons.at(j) = Input::get()->getControllerBinding(i, options.controllers.at(i).inputs.at(j));
} }
} }
} }

48
source/game.cpp
View File

@@ -1591,12 +1591,12 @@ std::shared_ptr<Player> Game::getPlayer(int id)
// Obtiene un controlador a partir del "id" del jugador // Obtiene un controlador a partir del "id" del jugador
int Game::getController(int player_id) int Game::getController(int player_id)
{ {
auto it = std::find_if(options.controller.begin(), options.controller.end(), [player_id](const auto &controller) auto it = std::find_if(options.controllers.begin(), options.controllers.end(), [player_id](const auto &controller)
{ return controller.player_id == player_id; }); { return controller.player_id == player_id; });
if (it != options.controller.end()) if (it != options.controllers.end())
{ {
return std::distance(options.controller.begin(), it); return std::distance(options.controllers.begin(), it);
} }
return -1; return -1;
@@ -1619,15 +1619,15 @@ void Game::checkPauseInput()
{ {
// Comprueba los mandos // Comprueba los mandos
for (int i = 0; i < input_->getNumControllers(); ++i) for (int i = 0; i < input_->getNumControllers(); ++i)
if (input_->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i) && if (input_->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i) &&
input_->checkInput(InputType::PAUSE, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i)) input_->checkInput(InputType::PAUSE, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i))
{ {
pause(!paused_); pause(!paused_);
return; return;
} }
// Comprueba el teclado // Comprueba el teclado
if (input_->checkInput(InputType::PAUSE, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD)) if (input_->checkInput(InputType::PAUSE, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
{ {
pause(!paused_); pause(!paused_);
return; return;
@@ -1723,17 +1723,17 @@ void Game::handlePlayersInput()
// Maneja las entradas de movimiento y disparo para un jugador en modo normal. // Maneja las entradas de movimiento y disparo para un jugador en modo normal.
void Game::handleNormalPlayerInput(const std::shared_ptr<Player> &player) void Game::handleNormalPlayerInput(const std::shared_ptr<Player> &player)
{ {
const auto controllerIndex = player->getController(); const auto &controller = options.controllers.at(player->getController());
const bool autofire = player->isPowerUp() || options.game.autofire; const bool autofire = player->isPowerUp() || options.game.autofire;
if (input_->checkInput(InputType::LEFT, INPUT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index)) if (input_->checkInput(InputType::LEFT, INPUT_ALLOW_REPEAT, controller.type, controller.index))
{ {
player->setInput(InputType::LEFT); player->setInput(InputType::LEFT);
#ifdef RECORDING #ifdef RECORDING
demo_.keys.left = 1; demo_.keys.left = 1;
#endif #endif
} }
else if (input_->checkInput(InputType::RIGHT, INPUT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index)) else if (input_->checkInput(InputType::RIGHT, INPUT_ALLOW_REPEAT, controller.type, controller.index))
{ {
player->setInput(InputType::RIGHT); player->setInput(InputType::RIGHT);
#ifdef RECORDING #ifdef RECORDING
@@ -1748,27 +1748,27 @@ void Game::handleNormalPlayerInput(const std::shared_ptr<Player> &player)
#endif #endif
} }
handleFireInputs(player, autofire, controllerIndex); // Verifica y maneja todas las posibles entradas de disparo. handleFireInputs(player, autofire, player->getController()); // Verifica y maneja todas las posibles entradas de disparo.
} }
// Procesa las entradas de disparo del jugador, permitiendo disparos automáticos si está habilitado. // Procesa las entradas de disparo del jugador, permitiendo disparos automáticos si está habilitado.
void Game::handleFireInputs(const std::shared_ptr<Player> &player, bool autofire, int controllerIndex) void Game::handleFireInputs(const std::shared_ptr<Player> &player, bool autofire, int controllerIndex)
{ {
if (input_->checkInput(InputType::FIRE_CENTER, autofire, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index)) if (input_->checkInput(InputType::FIRE_CENTER, autofire, options.controllers[controllerIndex].type, options.controllers[controllerIndex].index))
{ {
handleFireInput(player, BulletType::UP); handleFireInput(player, BulletType::UP);
#ifdef RECORDING #ifdef RECORDING
demo_.keys.fire = 1; demo_.keys.fire = 1;
#endif #endif
} }
else if (input_->checkInput(InputType::FIRE_LEFT, autofire, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index)) else if (input_->checkInput(InputType::FIRE_LEFT, autofire, options.controllers[controllerIndex].type, options.controllers[controllerIndex].index))
{ {
handleFireInput(player, BulletType::LEFT); handleFireInput(player, BulletType::LEFT);
#ifdef RECORDING #ifdef RECORDING
demo_.keys.fire_left = 1; demo_.keys.fire_left = 1;
#endif #endif
} }
else if (input_->checkInput(InputType::FIRE_RIGHT, autofire, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index)) else if (input_->checkInput(InputType::FIRE_RIGHT, autofire, options.controllers[controllerIndex].type, options.controllers[controllerIndex].index))
{ {
handleFireInput(player, BulletType::RIGHT); handleFireInput(player, BulletType::RIGHT);
#ifdef RECORDING #ifdef RECORDING
@@ -1781,15 +1781,15 @@ void Game::handleFireInputs(const std::shared_ptr<Player> &player, bool autofire
void Game::handlePlayerContinue(const std::shared_ptr<Player> &player) void Game::handlePlayerContinue(const std::shared_ptr<Player> &player)
{ {
const auto controllerIndex = player->getController(); const auto controllerIndex = player->getController();
if (input_->checkInput(InputType::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.controllers[controllerIndex].type, options.controllers[controllerIndex].index))
{ {
player->setPlayingState(PlayerState::PLAYING); player->setPlayingState(PlayerState::PLAYING);
} }
// Disminuye el contador de continuación si se presiona cualquier botón de disparo. // Disminuye el contador de continuación si se presiona cualquier botón de disparo.
if (input_->checkInput(InputType::FIRE_LEFT, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index) || if (input_->checkInput(InputType::FIRE_LEFT, INPUT_DO_NOT_ALLOW_REPEAT, options.controllers[controllerIndex].type, options.controllers[controllerIndex].index) ||
input_->checkInput(InputType::FIRE_CENTER, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index) || input_->checkInput(InputType::FIRE_CENTER, INPUT_DO_NOT_ALLOW_REPEAT, options.controllers[controllerIndex].type, options.controllers[controllerIndex].index) ||
input_->checkInput(InputType::FIRE_RIGHT, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index)) input_->checkInput(InputType::FIRE_RIGHT, INPUT_DO_NOT_ALLOW_REPEAT, options.controllers[controllerIndex].type, options.controllers[controllerIndex].index))
{ {
player->decContinueCounter(); player->decContinueCounter();
} }
@@ -1799,9 +1799,9 @@ void Game::handlePlayerContinue(const std::shared_ptr<Player> &player)
void Game::handleNameInput(const std::shared_ptr<Player> &player) void Game::handleNameInput(const std::shared_ptr<Player> &player)
{ {
const auto controllerIndex = player->getController(); const auto controllerIndex = player->getController();
if (input_->checkInput(InputType::FIRE_LEFT, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index) || if (input_->checkInput(InputType::FIRE_LEFT, INPUT_DO_NOT_ALLOW_REPEAT, options.controllers[controllerIndex].type, options.controllers[controllerIndex].index) ||
input_->checkInput(InputType::FIRE_CENTER, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index) || input_->checkInput(InputType::FIRE_CENTER, INPUT_DO_NOT_ALLOW_REPEAT, options.controllers[controllerIndex].type, options.controllers[controllerIndex].index) ||
input_->checkInput(InputType::FIRE_RIGHT, INPUT_DO_NOT_ALLOW_REPEAT, options.controller[controllerIndex].device_type, options.controller[controllerIndex].index)) input_->checkInput(InputType::FIRE_RIGHT, INPUT_DO_NOT_ALLOW_REPEAT, options.controllers[controllerIndex].type, options.controllers[controllerIndex].index))
{ {
if (player->getRecordNamePos() == 7) if (player->getRecordNamePos() == 7)
{ {
@@ -1815,15 +1815,15 @@ void Game::handleNameInput(const std::shared_ptr<Player> &player)
player->setInput(InputType::RIGHT); player->setInput(InputType::RIGHT);
} }
} }
else if (input_->checkInput(InputType::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.controllers[controllerIndex].type, options.controllers[controllerIndex].index))
{ {
player->setInput(InputType::UP); player->setInput(InputType::UP);
} }
else if (input_->checkInput(InputType::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.controllers[controllerIndex].type, options.controllers[controllerIndex].index))
{ {
player->setInput(InputType::DOWN); player->setInput(InputType::DOWN);
} }
else if (input_->checkInput(InputType::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.controllers[controllerIndex].type, options.controllers[controllerIndex].index))
{ {
player->setInput(InputType::LEFT); player->setInput(InputType::LEFT);
} }
@@ -1833,7 +1833,7 @@ void Game::handleNameInput(const std::shared_ptr<Player> &player)
player->setInput(InputType::RIGHT); player->setInput(InputType::RIGHT);
} }
*/ */
else if (input_->checkInput(InputType::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.controllers[controllerIndex].type, options.controllers[controllerIndex].index))
{ {
player->setInput(InputType::START); player->setInput(InputType::START);
addScoreToScoreBoard(player->getRecordName(), player->getScore()); addScoreToScoreBoard(player->getRecordName(), player->getScore());

40
source/global_inputs.cpp
View File

@@ -78,7 +78,7 @@ namespace globalInputs
{ {
#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(InputType::WINDOW_FULLSCREEN, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD)) if (Input::get()->checkInput(InputType::WINDOW_FULLSCREEN, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
{ {
Screen::get()->toggleVideoMode(); Screen::get()->toggleVideoMode();
const std::string mode = options.video.mode == ScreenVideoMode::WINDOW ? "Window" : "Fullscreen"; const std::string mode = options.video.mode == ScreenVideoMode::WINDOW ? "Window" : "Fullscreen";
@@ -87,7 +87,7 @@ namespace globalInputs
} }
// 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(InputType::WINDOW_DEC_SIZE, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD)) if (Input::get()->checkInput(InputType::WINDOW_DEC_SIZE, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
{ {
Screen::get()->decWindowSize(); Screen::get()->decWindowSize();
const std::string size = std::to_string(options.video.window.size); const std::string size = std::to_string(options.video.window.size);
@@ -96,7 +96,7 @@ namespace globalInputs
} }
// 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(InputType::WINDOW_INC_SIZE, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD)) if (Input::get()->checkInput(InputType::WINDOW_INC_SIZE, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
{ {
Screen::get()->incWindowSize(); Screen::get()->incWindowSize();
const std::string size = std::to_string(options.video.window.size); const std::string size = std::to_string(options.video.window.size);
@@ -105,28 +105,28 @@ namespace globalInputs
} }
#endif #endif
// Salir // Salir
if (Input::get()->checkInput(InputType::EXIT, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD)) if (Input::get()->checkInput(InputType::EXIT, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
{ {
quit(section::Options::QUIT_WITH_KEYBOARD); quit(section::Options::QUIT_WITH_KEYBOARD);
return; return;
} }
// Reset // Reset
if (Input::get()->checkInput(InputType::RESET, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD)) if (Input::get()->checkInput(InputType::RESET, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
{ {
reset(); reset();
return; return;
} }
// Audio // Audio
if (Input::get()->checkInput(InputType::MUTE, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD)) if (Input::get()->checkInput(InputType::MUTE, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
{ {
toggleAudio(); toggleAudio();
return; return;
} }
// Shaders // Shaders
if (Input::get()->checkInput(InputType::VIDEO_SHADERS, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD)) if (Input::get()->checkInput(InputType::VIDEO_SHADERS, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
{ {
Screen::get()->toggleShaders(); Screen::get()->toggleShaders();
return; return;
@@ -134,14 +134,14 @@ namespace globalInputs
#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(InputType::SHOWINFO, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD)) if (Input::get()->checkInput(InputType::SHOWINFO, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
{ {
Screen::get()->toggleDebugInfo(); Screen::get()->toggleDebugInfo();
return; return;
} }
#endif #endif
// OnScreenHelp // OnScreenHelp
if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, INPUT_USE_KEYBOARD)) if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
{ {
service_pressed_counter[0]++; service_pressed_counter[0]++;
@@ -161,47 +161,47 @@ namespace globalInputs
for (int i = 0; i < Input::get()->getNumControllers(); ++i) for (int i = 0; i < Input::get()->getNumControllers(); ++i)
{ {
// Salir // Salir
if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i) && if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i) &&
Input::get()->checkInput(InputType::EXIT, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i)) Input::get()->checkInput(InputType::EXIT, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i))
{ {
quit(section::Options::QUIT_WITH_CONTROLLER); quit(section::Options::QUIT_WITH_CONTROLLER);
return; return;
} }
// Reset // Reset
if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i) && if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i) &&
Input::get()->checkInput(InputType::RESET, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i)) Input::get()->checkInput(InputType::RESET, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i))
{ {
reset(); reset();
return; return;
} }
// Audio // Audio
if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i) && if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i) &&
Input::get()->checkInput(InputType::MUTE, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i)) Input::get()->checkInput(InputType::MUTE, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i))
{ {
toggleAudio(); toggleAudio();
return; return;
} }
// Shaders // Shaders
if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i) && if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i) &&
Input::get()->checkInput(InputType::VIDEO_SHADERS, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i)) Input::get()->checkInput(InputType::VIDEO_SHADERS, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i))
{ {
Screen::get()->toggleShaders(); Screen::get()->toggleShaders();
return; return;
} }
#ifdef DEBUG #ifdef DEBUG
// Debug Info // Debug Info
if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i) && if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i) &&
Input::get()->checkInput(InputType::SHOWINFO, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i)) Input::get()->checkInput(InputType::SHOWINFO, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i))
{ {
Screen::get()->toggleDebugInfo(); Screen::get()->toggleDebugInfo();
return; return;
} }
#endif #endif
// OnScreenHelp // OnScreenHelp
if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i)) if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i))
{ {
service_pressed_counter[i + 1]++; service_pressed_counter[i + 1]++;

39
source/input.cpp
View File

@@ -68,18 +68,13 @@ void Input::bindGameControllerButton(int controller_index, InputType input_targe
} }
// Comprueba si un input esta activo // Comprueba si un input esta activo
bool Input::checkInput(InputType input, bool repeat, int device, int controller_index) bool Input::checkInput(InputType input, bool repeat, InputDeviceToUse device, int controller_index)
{ {
bool success_keyboard = false; bool success_keyboard = false;
bool success_controller = false; bool success_controller = false;
const int input_index = static_cast<int>(input); const int input_index = static_cast<int>(input);
if (device == INPUT_USE_ANY) if (device == InputDeviceToUse::KEYBOARD || device == InputDeviceToUse::ANY)
{
controller_index = 0;
}
if (device == INPUT_USE_KEYBOARD || device == INPUT_USE_ANY)
{ {
const Uint8 *keyStates = SDL_GetKeyboardState(nullptr); const Uint8 *keyStates = SDL_GetKeyboardState(nullptr);
@@ -123,8 +118,8 @@ bool Input::checkInput(InputType input, bool repeat, int device, int controller_
} }
} }
if (gameControllerFound() && controller_index < num_gamepads_) if (gameControllerFound() && controller_index >= 0 && controller_index < num_gamepads_)
if ((device == INPUT_USE_GAMECONTROLLER) || (device == INPUT_USE_ANY)) if ((device == InputDeviceToUse::CONTROLLER) || (device == InputDeviceToUse::ANY))
{ {
success_controller = checkAxisInput(input, controller_index); success_controller = checkAxisInput(input, controller_index);
if (!success_controller) if (!success_controller)
@@ -174,14 +169,14 @@ bool Input::checkInput(InputType input, bool repeat, int device, int controller_
} }
// Comprueba si hay almenos un input activo // Comprueba si hay almenos un input activo
bool Input::checkAnyInput(int device, int controller_index) bool Input::checkAnyInput(InputDeviceToUse device, int controller_index)
{ {
if (device == INPUT_USE_ANY) if (device == InputDeviceToUse::ANY)
{ {
controller_index = 0; controller_index = 0;
} }
if (device == INPUT_USE_KEYBOARD || device == INPUT_USE_ANY) if (device == InputDeviceToUse::KEYBOARD || device == InputDeviceToUse::ANY)
{ {
const Uint8 *mKeystates = SDL_GetKeyboardState(nullptr); const Uint8 *mKeystates = SDL_GetKeyboardState(nullptr);
@@ -197,7 +192,7 @@ bool Input::checkAnyInput(int device, int controller_index)
if (gameControllerFound()) if (gameControllerFound())
{ {
if (device == INPUT_USE_GAMECONTROLLER || device == INPUT_USE_ANY) if (device == InputDeviceToUse::CONTROLLER || device == InputDeviceToUse::ANY)
{ {
for (int i = 0; i < (int)controller_bindings_.size(); ++i) for (int i = 0; i < (int)controller_bindings_.size(); ++i)
{ {
@@ -217,7 +212,7 @@ bool Input::checkAnyInput(int device, int controller_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(InputType::SERVICE, INPUT_ALLOW_REPEAT, INPUT_USE_ANY)) if (checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, InputDeviceToUse::ANY))
{ {
return 0; return 0;
} }
@@ -226,7 +221,7 @@ int Input::checkAnyButtonPressed(bool repeat)
for (auto bi : button_inputs_) for (auto bi : button_inputs_)
{ {
// Comprueba el teclado // Comprueba el teclado
if (checkInput(bi, repeat, INPUT_USE_KEYBOARD)) if (checkInput(bi, repeat, InputDeviceToUse::KEYBOARD))
{ {
return 1; return 1;
} }
@@ -234,7 +229,7 @@ int Input::checkAnyButtonPressed(bool repeat)
// Comprueba los mandos // Comprueba los mandos
for (int i = 0; i < num_gamepads_; ++i) for (int i = 0; i < num_gamepads_; ++i)
{ {
if (checkInput(bi, repeat, INPUT_USE_GAMECONTROLLER, i)) if (checkInput(bi, repeat, InputDeviceToUse::CONTROLLER, i))
{ {
return i + 1; return i + 1;
} }
@@ -328,14 +323,14 @@ int Input::getJoyIndex(int id) const
} }
// Muestra por consola los controles asignados // Muestra por consola los controles asignados
void Input::printBindings(int device, int controller_index) const void Input::printBindings(InputDeviceToUse device, int controller_index) const
{ {
if (device == INPUT_USE_ANY || device == INPUT_USE_KEYBOARD) if (device == InputDeviceToUse::ANY || device == InputDeviceToUse::KEYBOARD)
{ {
return; return;
} }
if (device == INPUT_USE_GAMECONTROLLER) if (device == InputDeviceToUse::CONTROLLER)
{ {
if (controller_index >= num_gamepads_) if (controller_index >= num_gamepads_)
{ {
@@ -417,3 +412,9 @@ bool Input::checkAxisInput(InputType input, int controller_index) const
return false; return false;
} }
} }
// Establece el indice de mando que usará el teclado
void Input::setKeyboardIndex(int index)
{
keyboard_index_ = index;
}

25
source/input.h
View File

@@ -11,9 +11,9 @@
connectedControllers es un vector donde estan todos los mandos encontrados [0 .. n] connectedControllers es un vector donde estan todos los mandos encontrados [0 .. n]
checkInput requiere de un indice para comprobar las pulsaciónes de un controlador en concreto [0 .. n] checkInput requiere de un indice para comprobar las pulsaciónes de un controlador en concreto [0 .. n]
device contiene el tipo de dispositivo a comprobar: device contiene el tipo de dispositivo a comprobar:
INPUT_USE_KEYBOARD solo mirará el teclado InputDeviceToUse::KEYBOARD solo mirará el teclado
INPUT_USE_GAMECONTROLLER solo mirará el controlador especificado (Si no se especifica, el primero) InputDeviceToUse::CONTROLLER solo mirará el controlador especificado (Si no se especifica, el primero)
INPUT_USE_ANY mirará tanto el teclado como el PRIMER controlador InputDeviceToUse::ANY mirará tanto el teclado como el PRIMER controlador
*/ */
enum class InputType : int enum class InputType : int
@@ -52,9 +52,12 @@ enum class InputType : int
constexpr bool INPUT_ALLOW_REPEAT = true; constexpr bool INPUT_ALLOW_REPEAT = true;
constexpr bool INPUT_DO_NOT_ALLOW_REPEAT = false; constexpr bool INPUT_DO_NOT_ALLOW_REPEAT = false;
constexpr int INPUT_USE_KEYBOARD = 0; enum class InputDeviceToUse : int
constexpr int INPUT_USE_GAMECONTROLLER = 1; {
constexpr int INPUT_USE_ANY = 2; KEYBOARD = 0,
CONTROLLER = 1,
ANY = 2,
};
class Input class Input
{ {
@@ -92,6 +95,7 @@ private:
int num_joysticks_ = 0; // Número de joysticks conectados int num_joysticks_ = 0; // Número de joysticks conectados
int num_gamepads_ = 0; // Número de mandos conectados int num_gamepads_ = 0; // Número de mandos conectados
std::string game_controller_db_path_; // Ruta al archivo gamecontrollerdb.txt std::string game_controller_db_path_; // Ruta al archivo gamecontrollerdb.txt
int keyboard_index_ = 0;
// Comprueba el eje del mando // Comprueba el eje del mando
bool checkAxisInput(InputType input, int controller_index = 0) const; bool checkAxisInput(InputType input, int controller_index = 0) const;
@@ -120,10 +124,10 @@ public:
void bindGameControllerButton(int controller_index, InputType inputTarget, InputType inputSource); void bindGameControllerButton(int controller_index, InputType inputTarget, InputType inputSource);
// Comprueba si un input esta activo // Comprueba si un input esta activo
bool checkInput(InputType input, bool repeat = true, int device = INPUT_USE_ANY, int controller_index = 0); bool checkInput(InputType input, bool repeat = true, InputDeviceToUse device = InputDeviceToUse::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 controller_index = 0); bool checkAnyInput(InputDeviceToUse device = InputDeviceToUse::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);
@@ -144,7 +148,7 @@ public:
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 controller_index = 0) const; void printBindings(InputDeviceToUse device = InputDeviceToUse::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 controller_index, InputType input) const; SDL_GameControllerButton getControllerBinding(int controller_index, InputType input) const;
@@ -157,4 +161,7 @@ public:
// Obtiene el indice a partir del nombre del mando // Obtiene el indice a partir del nombre del mando
int getIndexByName(const std::string &name) const; int getIndexByName(const std::string &name) const;
// Establece el indice de mando que usará el teclado
void setKeyboardIndex(int index);
}; };

253
source/options.cpp
View File

@@ -4,7 +4,7 @@
#include <fstream> // para basic_ostream, operator<<, basi... #include <fstream> // para basic_ostream, operator<<, basi...
#include <iostream> // para cout #include <iostream> // para cout
#include <vector> // para vector #include <vector> // para vector
#include "input.h" // para inputs_e, INPUT_USE_ANY, INPUT_... #include "input.h" // para inputs_e, InputDeviceToUse::ANY, INPUT_...
#include "lang.h" // para lang_e #include "lang.h" // para lang_e
#include "screen.h" // para ScreenVideoMode, ScreenFilter #include "screen.h" // para ScreenVideoMode, ScreenFilter
#include "utils.h" // para OptionsController, Options, op_... #include "utils.h" // para OptionsController, Options, op_...
@@ -45,37 +45,11 @@ void initOptions()
options.game.autofire = true; options.game.autofire = true;
// Opciones de control // Opciones de control
options.controller.clear(); options.controllers.clear();
OptionsController c; options.controllers.resize(2);
options.controllers.at(0).player_id = 1;
constexpr int num_players = 2; options.controllers.at(1).player_id = 2;
for (int index = 0; index < num_players; ++index) setKeyboardToPlayer(1);
{
c.index = index;
c.player_id = index + 1;
c.device_type = INPUT_USE_GAMECONTROLLER;
c.name = "NO NAME";
c.plugged = false;
// Inputs que se guardan en las opciones y, por tanto, a disco
c.inputs.clear();
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();
c.buttons.push_back(SDL_CONTROLLER_BUTTON_X);
c.buttons.push_back(SDL_CONTROLLER_BUTTON_Y);
c.buttons.push_back(SDL_CONTROLLER_BUTTON_B);
c.buttons.push_back(SDL_CONTROLLER_BUTTON_START);
c.buttons.push_back(SDL_CONTROLLER_BUTTON_BACK);
options.controller.push_back(c);
}
options.controller.at(0).device_type = INPUT_USE_ANY; // El primer jugador puede usar tanto el teclado como el primer mando
} }
// Carga el fichero de configuración // Carga el fichero de configuración
@@ -129,12 +103,11 @@ bool loadOptionsFile(std::string file_path)
options.video.mode = ScreenVideoMode::WINDOW; options.video.mode = ScreenVideoMode::WINDOW;
} }
if (options.video.window.size < 1 || options.video.window.size > 4) options.video.window.size = std::clamp(options.video.window.size, 1, 4);
{
options.video.window.size = 3;
}
if (options.game.language != lang::Code::en_UK && options.game.language != lang::Code::ba_BA && options.game.language != lang::Code::es_ES) if (options.game.language != lang::Code::en_UK &&
options.game.language != lang::Code::ba_BA &&
options.game.language != lang::Code::es_ES)
{ {
options.game.language = lang::Code::en_UK; options.game.language = lang::Code::en_UK;
} }
@@ -156,73 +129,54 @@ bool saveOptionsFile(std::string file_path)
std::cout << "Writing file: " << getFileName(file_path) << std::endl; std::cout << "Writing file: " << getFileName(file_path) << std::endl;
// Opciones de video // Opciones de video
const auto value_video_mode_winow = std::to_string(static_cast<int>(ScreenVideoMode::WINDOW));
const auto value_video_mode_fullscreen = std::to_string(static_cast<int>(ScreenVideoMode::FULLSCREEN));
const auto value_filter_nearest = std::to_string(static_cast<int>(ScreenFilter::NEAREST));
const auto value_filter_lineal = std::to_string(static_cast<int>(ScreenFilter::LINEAL));
file << "## VIDEO\n"; file << "## VIDEO\n";
file << "## video.mode [" << value_video_mode_winow << ": window, " << value_video_mode_fullscreen << ": fullscreen]\n"; file << "## video.mode [" << static_cast<int>(ScreenVideoMode::WINDOW) << ": window, " << static_cast<int>(ScreenVideoMode::FULLSCREEN) << ": fullscreen]\n";
file << "## video.filter [" << value_filter_nearest << ": nearest, " << value_filter_lineal << ": lineal]\n"; file << "## video.filter [" << static_cast<int>(ScreenFilter::NEAREST) << ": nearest, " << static_cast<int>(ScreenFilter::LINEAL) << ": lineal]\n";
file << "\n"; file << "\n";
const auto valueVideoMode = std::to_string(static_cast<int>(options.video.mode)); file << "video.mode=" << static_cast<int>(options.video.mode) << "\n";
file << "video.mode=" << valueVideoMode << "\n"; file << "video.window.size=" << options.video.window.size << "\n";
file << "video.filter=" << static_cast<int>(options.video.filter) << "\n";
file << "video.window.size=" + std::to_string(options.video.window.size) + "\n"; file << "video.v_sync=" << boolToString(options.video.v_sync) << "\n";
file << "video.integer_scale=" << boolToString(options.video.integer_scale) << "\n";
const auto valueFilter = std::to_string(static_cast<int>(options.video.filter)); file << "video.shaders=" << boolToString(options.video.shaders) << "\n";
file << "video.filter=" << valueFilter << "\n";
file << "video.v_sync=" + boolToString(options.video.v_sync) + "\n";
file << "video.integer_scale=" + boolToString(options.video.integer_scale) + "\n";
file << "video.shaders=" + boolToString(options.video.shaders) + "\n";
// Opciones de audio // Opciones de audio
file << "\n\n## AUDIO\n"; file << "\n\n## AUDIO\n";
file << "## volume [0 .. 100]\n"; file << "## volume [0 .. 100]\n";
file << "\n"; file << "\n";
file << "audio.enabled=" + boolToString(options.audio.enabled) + "\n"; file << "audio.enabled=" << boolToString(options.audio.enabled) << "\n";
file << "audio.volume=" + std::to_string(options.audio.volume) + "\n"; file << "audio.volume=" << options.audio.volume << "\n";
file << "audio.music.enabled=" + boolToString(options.audio.music.enabled) + "\n"; file << "audio.music.enabled=" << boolToString(options.audio.music.enabled) << "\n";
file << "audio.music.volume=" + std::to_string(options.audio.music.volume) + "\n"; file << "audio.music.volume=" << options.audio.music.volume << "\n";
file << "audio.sound.enabled=" + boolToString(options.audio.sound.enabled) + "\n"; file << "audio.sound.enabled=" << boolToString(options.audio.sound.enabled) << "\n";
file << "audio.sound.volume=" + std::to_string(options.audio.sound.volume) + "\n"; file << "audio.sound.volume=" << options.audio.sound.volume << "\n";
// Opciones del juego // Opciones del juego
const auto value_difficulty_easy = std::to_string(static_cast<int>(GameDifficulty::EASY));
const auto value_difficulty_normal = std::to_string(static_cast<int>(GameDifficulty::NORMAL));
const auto value_difficulty_hard = std::to_string(static_cast<int>(GameDifficulty::HARD));
file << "\n\n## GAME\n"; file << "\n\n## GAME\n";
file << "## game.language [0: spanish, 1: valencian, 2: english]\n"; file << "## game.language [0: spanish, 1: valencian, 2: english]\n";
file << "## game.difficulty [" << value_difficulty_easy << ": easy, " << value_difficulty_normal << ": normal, " << value_difficulty_hard << ": hard]\n"; file << "## game.difficulty [" << static_cast<int>(GameDifficulty::EASY) << ": easy, " << static_cast<int>(GameDifficulty::NORMAL) << ": normal, " << static_cast<int>(GameDifficulty::HARD) << ": hard]\n";
file << "\n"; file << "\n";
file << "game.language=" + std::to_string(static_cast<int>(options.game.language)) + "\n"; file << "game.language=" << static_cast<int>(options.game.language) << "\n";
file << "game.difficulty=" + std::to_string(static_cast<int>(options.game.difficulty)) + "\n"; file << "game.difficulty=" << static_cast<int>(options.game.difficulty) << "\n";
file << "game.autofire=" + boolToString(options.game.autofire) + "\n"; file << "game.autofire=" << boolToString(options.game.autofire) << "\n";
// Opciones de mandos // Opciones de mandos
file << "\n\n## CONTROLLERS\n"; file << "\n\n## CONTROLLERS\n";
file << "\n";
const int num_players = 2; for (const auto &controller : options.controllers)
for (int index = 0; index < num_players; ++index)
{ {
const std::string joyIndex = std::to_string(index + 1); file << "\n";
file << "controller" + joyIndex + ".name=" + options.controller[index].name + "\n"; file << "controller." << controller.index << ".name=" << controller.name << "\n";
file << "controller" + joyIndex + ".player=" + std::to_string(options.controller[index].player_id) + "\n"; file << "controller." << controller.index << ".player=" << controller.player_id << "\n";
file << "controller" + joyIndex + ".button.fire_left=" + std::to_string((int)options.controller[index].buttons[0]) + "\n"; file << "controller." << controller.index << ".type=" << static_cast<int>(controller.type) << "\n";
file << "controller" + joyIndex + ".button.fire_center=" + std::to_string((int)options.controller[index].buttons[1]) + "\n"; file << "controller." << controller.index << ".button.fire_left=" << controller.buttons.at(0) << "\n";
file << "controller" + joyIndex + ".button.fire_right=" + std::to_string((int)options.controller[index].buttons[2]) + "\n"; file << "controller." << controller.index << ".button.fire_center=" << controller.buttons.at(1) << "\n";
file << "controller" + joyIndex + ".button.start=" + std::to_string((int)options.controller[index].buttons[3]) + "\n"; file << "controller." << controller.index << ".button.fire_right=" << controller.buttons.at(2) << "\n";
file << "controller" + joyIndex + ".button.service=" + std::to_string((int)options.controller[index].buttons[4]) + "\n"; file << "controller." << controller.index << ".button.start=" << controller.buttons.at(3) << "\n";
file << "controller." << controller.index << ".button.service=" << controller.buttons.at(4) << "\n";
if (index < num_players - 1)
{
file << "\n";
}
} }
// Cierra el fichero // Cierra el fichero
@@ -242,7 +196,6 @@ bool setOptions(const std::string &var, const std::string &value)
{ {
options.video.mode = static_cast<ScreenVideoMode>(std::stoi(value)); options.video.mode = static_cast<ScreenVideoMode>(std::stoi(value));
} }
else if (var == "video.window.size") else if (var == "video.window.size")
{ {
options.video.window.size = std::stoi(value); options.video.window.size = std::stoi(value);
@@ -251,22 +204,18 @@ bool setOptions(const std::string &var, const std::string &value)
options.video.window.size = 3; options.video.window.size = 3;
} }
} }
else if (var == "video.filter") else if (var == "video.filter")
{ {
options.video.filter = static_cast<ScreenFilter>(std::stoi(value)); options.video.filter = static_cast<ScreenFilter>(std::stoi(value));
} }
else if (var == "video.shaders") else if (var == "video.shaders")
{ {
options.video.shaders = stringToBool(value); options.video.shaders = stringToBool(value);
} }
else if (var == "video.integer_scale") else if (var == "video.integer_scale")
{ {
options.video.integer_scale = stringToBool(value); options.video.integer_scale = stringToBool(value);
} }
else if (var == "video.v_sync") else if (var == "video.v_sync")
{ {
options.video.v_sync = stringToBool(value); options.video.v_sync = stringToBool(value);
@@ -277,7 +226,6 @@ bool setOptions(const std::string &var, const std::string &value)
{ {
options.audio.enabled = stringToBool(value); options.audio.enabled = stringToBool(value);
} }
else if (var == "audio.volume") else if (var == "audio.volume")
{ {
options.audio.volume = std::stoi(value); options.audio.volume = std::stoi(value);
@@ -286,17 +234,14 @@ bool setOptions(const std::string &var, const std::string &value)
{ {
options.audio.music.enabled = stringToBool(value); options.audio.music.enabled = stringToBool(value);
} }
else if (var == "audio.music.volume") else if (var == "audio.music.volume")
{ {
options.audio.music.volume = std::stoi(value); options.audio.music.volume = std::stoi(value);
} }
else if (var == "audio.sound.enabled") else if (var == "audio.sound.enabled")
{ {
options.audio.sound.enabled = stringToBool(value); options.audio.sound.enabled = stringToBool(value);
} }
else if (var == "audio.sound.volume") else if (var == "audio.sound.volume")
{ {
options.audio.sound.volume = std::stoi(value); options.audio.sound.volume = std::stoi(value);
@@ -307,93 +252,85 @@ bool setOptions(const std::string &var, const std::string &value)
{ {
options.game.language = static_cast<lang::Code>(std::stoi(value)); options.game.language = static_cast<lang::Code>(std::stoi(value));
} }
else if (var == "game.difficulty") else if (var == "game.difficulty")
{ {
options.game.difficulty = static_cast<GameDifficulty>(std::stoi(value)); options.game.difficulty = static_cast<GameDifficulty>(std::stoi(value));
} }
else if (var == "game.autofire") else if (var == "game.autofire")
{ {
options.game.autofire = stringToBool(value); options.game.autofire = stringToBool(value);
} }
// Opciones de mandos // Opciones de mandos
else if (var == "controller1.name") else if (var == "controller.0.name")
{ {
options.controller[0].name = value; options.controllers.at(0).name = value;
} }
else if (var == "controller.0.player")
else if (var == "controller1.player")
{ {
options.controller[0].player_id = std::max(1, std::min(2, std::stoi(value))); options.controllers.at(0).player_id = std::clamp(std::stoi(value), 1, 2);
} }
else if (var == "controller.0.type")
else if (var == "controller1.button.fire_left")
{ {
options.controller[0].buttons[0] = (SDL_GameControllerButton)std::stoi(value); options.controllers.at(0).type = static_cast<InputDeviceToUse>(std::stoi(value));
} }
else if (var == "controller.0.button.fire_left")
else if (var == "controller1.button.fire_center")
{ {
options.controller[0].buttons[1] = (SDL_GameControllerButton)std::stoi(value); options.controllers.at(0).buttons.at(0) = static_cast<SDL_GameControllerButton>(std::stoi(value));
} }
else if (var == "controller.0.button.fire_center")
else if (var == "controller1.button.fire_right")
{ {
options.controller[0].buttons[2] = (SDL_GameControllerButton)std::stoi(value); options.controllers.at(0).buttons.at(1) = static_cast<SDL_GameControllerButton>(std::stoi(value));
} }
else if (var == "controller.0.button.fire_right")
else if (var == "controller1.button.start")
{ {
options.controller[0].buttons[3] = (SDL_GameControllerButton)std::stoi(value); options.controllers.at(0).buttons.at(2) = static_cast<SDL_GameControllerButton>(std::stoi(value));
} }
else if (var == "controller.0.button.start")
else if (var == "controller1.button.service")
{ {
options.controller[0].buttons[4] = (SDL_GameControllerButton)std::stoi(value); options.controllers.at(0).buttons.at(3) = static_cast<SDL_GameControllerButton>(std::stoi(value));
} }
else if (var == "controller.0.button.service")
else if (var == "controller2.name")
{ {
options.controller[1].name = value; options.controllers.at(0).buttons.at(4) = static_cast<SDL_GameControllerButton>(std::stoi(value));
} }
else if (var == "controller.1.name")
else if (var == "controller2.player")
{ {
options.controller[1].player_id = std::max(1, std::min(2, std::stoi(value))); options.controllers.at(1).name = value;
} }
else if (var == "controller.1.player")
else if (var == "controller2.button.fire_left")
{ {
options.controller[1].buttons[0] = (SDL_GameControllerButton)std::stoi(value); options.controllers.at(1).player_id = std::clamp(std::stoi(value), 1, 2);
} }
else if (var == "controller.1.type")
else if (var == "controller2.button.fire_center")
{ {
options.controller[1].buttons[1] = (SDL_GameControllerButton)std::stoi(value); options.controllers.at(1).type = static_cast<InputDeviceToUse>(std::stoi(value));
} }
else if (var == "controller.1.button.fire_left")
else if (var == "controller2.button.fire_right")
{ {
options.controller[1].buttons[2] = (SDL_GameControllerButton)std::stoi(value); options.controllers.at(1).buttons.at(0) = static_cast<SDL_GameControllerButton>(std::stoi(value));
} }
else if (var == "controller.1.button.fire_center")
else if (var == "controller2.button.start")
{ {
options.controller[1].buttons[3] = (SDL_GameControllerButton)std::stoi(value); options.controllers.at(1).buttons.at(1) = static_cast<SDL_GameControllerButton>(std::stoi(value));
} }
else if (var == "controller.1.button.fire_right")
else if (var == "controller2.button.service")
{ {
options.controller[1].buttons[4] = (SDL_GameControllerButton)std::stoi(value); options.controllers.at(1).buttons.at(2) = static_cast<SDL_GameControllerButton>(std::stoi(value));
}
else if (var == "controller.1.button.start")
{
options.controllers.at(1).buttons.at(3) = static_cast<SDL_GameControllerButton>(std::stoi(value));
}
else if (var == "controller.1.button.service")
{
options.controllers.at(1).buttons.at(4) = static_cast<SDL_GameControllerButton>(std::stoi(value));
} }
// Lineas vacias o que empiezan por comentario // Lineas vacias o que empiezan por comentario
else if (var.empty() || var.starts_with("#")) else if (var.empty() || var.starts_with("#"))
{ {
} }
else else
{ {
success = false; success = false;
@@ -408,3 +345,45 @@ int to_JA_volume(int vol)
vol = vol * 1.28f; vol = vol * 1.28f;
return std::clamp(vol, 0, 128); return std::clamp(vol, 0, 128);
} }
// Asigna el teclado al jugador
void setKeyboardToPlayer(int player_id)
{
for (auto &controller : options.controllers)
{
if (controller.player_id == player_id)
{
controller.type = InputDeviceToUse::ANY;
}
else
{
controller.type = InputDeviceToUse::CONTROLLER;
}
}
}
// Intercambia el teclado de jugador
void swapOptionsKeyboard()
{
std::swap(options.controllers.at(0).type, options.controllers.at(1).type);
}
// Intercambia los jugadores asignados a los dos primeros mandos
void swapOptionsControllers()
{
std::swap(options.controllers.at(0).player_id, options.controllers.at(1).player_id);
std::swap(options.controllers.at(0).type, options.controllers.at(1).type);
}
// Averigua quien está usando el teclado
int getPlayerWhoUsesKeyboard()
{
for (auto &controller : options.controllers)
{
if (controller.type == InputDeviceToUse::ANY)
{
return controller.player_id;
}
}
return 0;
}

37
source/options.h
View File

@@ -4,6 +4,7 @@
#include <SDL2/SDL_stdinc.h> // Para Uint8 #include <SDL2/SDL_stdinc.h> // Para Uint8
#include "manage_hiscore_table.h" #include "manage_hiscore_table.h"
#include <vector> // Para vector #include <vector> // Para vector
#include "input.h"
#include <string> #include <string>
enum class InputType : int; enum class InputType : int;
enum class ScreenFilter : int; enum class ScreenFilter : int;
@@ -57,8 +58,8 @@ struct OptionsAudio
{ {
OptionsMusic music; // Opciones para la música OptionsMusic music; // Opciones para la música
OptionsSound sound; // Opciones para los efectos de sonido OptionsSound sound; // Opciones para los efectos de sonido
bool enabled; // Indica si el audio está activo o no bool enabled; // Indica si el audio está activo o no
int volume; // Volumen al que suenan el audio int volume; // Volumen al que suenan el audio
}; };
// Estructura para las opciones del juego // Estructura para las opciones del juego
@@ -75,25 +76,35 @@ struct OptionsController
{ {
int index; // Indice en el vector de mandos int index; // Indice en el vector de mandos
int player_id; // Jugador asociado al mando int player_id; // Jugador asociado al mando
Uint8 device_type; // Indica si se utilizará teclado o mando o ambos InputDeviceToUse 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<InputType> 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
// Constructor por defecto
OptionsController()
: index(-1), player_id(-1), type(InputDeviceToUse::CONTROLLER), name(""), plugged(false)
{
inputs = {InputType::FIRE_LEFT, InputType::FIRE_CENTER, InputType::FIRE_RIGHT, InputType::START, InputType::SERVICE};
buttons = {SDL_CONTROLLER_BUTTON_X, SDL_CONTROLLER_BUTTON_Y, SDL_CONTROLLER_BUTTON_B, SDL_CONTROLLER_BUTTON_START, SDL_CONTROLLER_BUTTON_BACK};
}
}; };
// Estructura con todas las opciones de configuración del programa // Estructura con todas las opciones de configuración del programa
struct Options struct Options
{ {
OptionsGame game; // Opciones para el propio juego OptionsGame game; // Opciones para el propio juego
OptionsVideo video; // Opciones relativas a la clase screen OptionsVideo video; // Opciones relativas a la clase screen
OptionsAudio audio; // Opciones para el audio OptionsAudio audio; // Opciones para el audio
std::vector<OptionsController> controller; // Opciones con las asignaciones del mando para cada jugador std::vector<OptionsController> controllers; // Opciones con las asignaciones del mando para cada jugador
}; };
// Variables // Variables
extern Options options; extern Options options;
void initOptions();
// Carga el fichero de configuración // Carga el fichero de configuración
bool loadOptionsFile(std::string file_path); bool loadOptionsFile(std::string file_path);
@@ -102,3 +113,15 @@ bool saveOptionsFile(std::string file_path);
// Convierte valores de 0 a 100 en valores de 0 a 128 // Convierte valores de 0 a 100 en valores de 0 a 128
int to_JA_volume(int vol); int to_JA_volume(int vol);
// Asigna el teclado al jugador
void setKeyboardToPlayer(int player_id);
// Intercambia el teclado de jugador
void swapOptionsKeyboard();
// Intercambia los jugadores asignados a los dos primeros mandos
void swapOptionsControllers();
// Averigua quien está usando el teclado
int getPlayerWhoUsesKeyboard();

82
source/title.cpp
View File

@@ -171,6 +171,9 @@ void Title::render()
// Comprueba los eventos // Comprueba los eventos
void Title::checkEvents() void Title::checkEvents()
{ {
// Comprueba el input para el resto de objetos
define_buttons_->checkEvents();
// Si define_buttons_ está habilitado, es él quien gestiona los eventos // Si define_buttons_ está habilitado, es él quien gestiona los eventos
if (!define_buttons_->isEnabled()) if (!define_buttons_->isEnabled())
{ {
@@ -195,32 +198,33 @@ void Title::checkEvents()
{ {
switch (event.key.keysym.sym) switch (event.key.keysym.sym)
{ {
case SDLK_1: case SDLK_1: // Redefine los botones del mando #0
{ {
if (define_buttons_->enable(0)) if (define_buttons_->enable(0))
resetCounter(); resetCounter();
break; break;
} }
case SDLK_2: // Redefine los botones del mando #1
case SDLK_2:
{ {
if (define_buttons_->enable(1)) if (define_buttons_->enable(1))
resetCounter(); resetCounter();
break; break;
} }
case SDLK_3: // Intercambia los mandos entre los dos jugadores
case SDLK_3:
{ {
swapControllers(); swapControllers();
break; break;
} }
case SDLK_4: // Muestra la asignacion de mandos
case SDLK_4:
{ {
showControllers(); showControllers();
break; break;
} }
case SDLK_5: // Intercambia la asignación del teclado
{
swapKeyboard();
break;
}
default: default:
break; break;
} }
@@ -235,55 +239,38 @@ void Title::checkInput()
// Comprueba los controladores solo si no se estan definiendo los botones // Comprueba los controladores solo si no se estan definiendo los botones
if (!define_buttons_->isEnabled()) if (!define_buttons_->isEnabled())
{ {
// Comprueba el teclado para empezar a jugar // Comprueba los métodos de control
if (Input::get()->checkInput(InputType::START, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD)) for (const auto &controller : options.controllers)
{ {
if (section::options == section::Options::TITLE_2 || ALLOW_TITLE_ANIMATION_SKIP) if (Input::get()->checkInput(InputType::START, INPUT_DO_NOT_ALLOW_REPEAT, controller.type, controller.index) &&
!Input::get()->checkInput(InputType::SERVICE, INPUT_DO_NOT_ALLOW_REPEAT, controller.type, controller.index))
{ {
fade_->activate(); if (section::options == section::Options::TITLE_2 || ALLOW_TITLE_ANIMATION_SKIP)
post_fade_ = options.controller[0].player_id; {
fade_->activate();
post_fade_ = controller.player_id;
return;
}
} }
}
// Comprueba los mandos
for (int i = 0; i < Input::get()->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::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i) && if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, controller.type, controller.index) &&
Input::get()->checkInput(InputType::SWAP_CONTROLLERS, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i)) Input::get()->checkInput(InputType::SWAP_CONTROLLERS, INPUT_DO_NOT_ALLOW_REPEAT, controller.type, controller.index))
{ {
swapControllers(); swapControllers();
return; return;
} }
// Comprueba si algun mando quiere ser configurado // Comprueba si algun mando quiere ser configurado
if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i) && if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, controller.type, controller.index) &&
Input::get()->checkInput(InputType::CONFIG, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i)) Input::get()->checkInput(InputType::CONFIG, INPUT_DO_NOT_ALLOW_REPEAT, controller.type, controller.index))
{ {
define_buttons_->enable(i); define_buttons_->enable(controller.index);
return; return;
} }
// Comprueba el botón de START de los mandos
if (Input::get()->checkInput(InputType::START, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
{
// Si no está el botón de servicio activo
if (!Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
{
if (section::options == section::Options::TITLE_2 || ALLOW_TITLE_ANIMATION_SKIP)
{
fade_->activate();
post_fade_ = options.controller[i].player_id;
return;
}
}
}
} }
} }
// Comprueba el input para el resto de objetos
define_buttons_->checkEvents();
// Comprueba los inputs que se pueden introducir en cualquier sección del juego // Comprueba los inputs que se pueden introducir en cualquier sección del juego
globalInputs::check(); globalInputs::check();
} }
@@ -316,10 +303,17 @@ void Title::swapControllers()
if (Input::get()->getNumControllers() == 0) if (Input::get()->getNumControllers() == 0)
return; return;
define_buttons_->swapControllers(); swapOptionsControllers();
showControllers(); showControllers();
} }
// Intercambia el teclado de jugador
void Title::swapKeyboard()
{
swapOptionsKeyboard();
Notifier::get()->showText("Teclat per al jugador " + std::to_string(getPlayerWhoUsesKeyboard()));
}
// Muestra información sobre los controles y los jugadores // Muestra información sobre los controles y los jugadores
void Title::showControllers() void Title::showControllers()
{ {
@@ -332,16 +326,16 @@ void Title::showControllers()
for (size_t i = 0; i < NUM_CONTROLLERS; ++i) for (size_t i = 0; i < NUM_CONTROLLERS; ++i)
{ {
// Ejemplo: el jugador 1 tiene el mando 2 // Ejemplo: el jugador 1 tiene el mando 2
playerControllerIndex.at(options.controller.at(i).player_id - 1) = i; playerControllerIndex.at(options.controllers.at(i).player_id - 1) = i;
} }
// Genera el texto correspondiente // Genera el texto correspondiente
for (size_t i = 0; i < NUM_CONTROLLERS; ++i) for (size_t i = 0; i < NUM_CONTROLLERS; ++i)
{ {
const size_t index = playerControllerIndex.at(i); const size_t index = playerControllerIndex.at(i);
if (options.controller.at(index).plugged) if (options.controllers.at(index).plugged)
{ {
text.at(i) = lang::getText(100) + std::to_string(i + 1) + ": " + options.controller.at(index).name; text.at(i) = lang::getText(100) + std::to_string(i + 1) + ": " + options.controllers.at(index).name;
} }
} }

3
source/title.h
View File

@@ -74,6 +74,9 @@ private:
// Intercambia la asignación de mandos a los jugadores // Intercambia la asignación de mandos a los jugadores
void swapControllers(); void swapControllers();
// Intercambia el teclado de jugador
void swapKeyboard();
// Muestra información sobre los controles y los jugadores // Muestra información sobre los controles y los jugadores
void showControllers(); void showControllers();