jailers/jaildoctors_dilemma
5
0
Fork 0
forked from jaildesigner-jailgames/jaildoctors_dilemma
Code Pull Requests Activity

afegit soport per a axis del mando

Browse Source
This commit is contained in:
Sergio
2025-03-16 17:45:07 +01:00
parent 64ee2d1e45
commit 0a5996f220
6 changed files with 273 additions and 217 deletions
Download Patch File Download Diff File Expand all files Collapse all files

339
source/input.cpp
View File

@@ -2,9 +2,12 @@
#include <SDL2/SDL.h> // Para SDL_INIT_GAMECONTROLLER, SDL_InitSubS...
#include <SDL2/SDL_error.h> // Para SDL_GetError
#include <SDL2/SDL_events.h> // Para SDL_ENABLE
#include <SDL2/SDL_joystick.h> // Para SDL_NumJoysticks
#include <SDL2/SDL_keyboard.h> // Para SDL_GetKeyboardState
#include <iostream> // Para basic_ostream, operator<<, cout, basi...
#include <algorithm> // Para find
#include <iostream> // Para basic_ostream, operator<<, cout, endl
#include <iterator> // Para distance
#include <unordered_map> // Para unordered_map, operator==, _Node_cons...
#include <utility> // Para pair
// [SINGLETON]
Input *Input::input_ = nullptr;
@@ -29,18 +32,17 @@ Input *Input::get()
// Constructor
Input::Input(const std::string &game_controller_db_path)
: db_path_(game_controller_db_path)
: game_controller_db_path_(game_controller_db_path)
{
// Inicializa las variables
KeyBindings kb;
kb.scancode = 0;
kb.active = false;
key_bindings_.resize(static_cast<int>(InputAction::SIZE), kb);
// Busca si hay mandos conectados
discoverGameControllers();
GameControllerBindings gcb;
gcb.button = SDL_CONTROLLER_BUTTON_INVALID;
gcb.active = false;
game_controller_bindings_.resize(static_cast<int>(InputAction::SIZE), gcb);
// Inicializa los vectores
key_bindings_.resize(static_cast<int>(InputAction::SIZE), KeyBindings());
controller_bindings_.resize(num_gamepads_, std::vector<ControllerBindings>(static_cast<int>(InputAction::SIZE), ControllerBindings()));
// Listado de los inputs para jugar que utilizan botones, ni palancas ni crucetas
button_inputs_ = {InputAction::JUMP};
}
// Asigna inputs a teclas
@@ -50,133 +52,117 @@ void Input::bindKey(InputAction input, SDL_Scancode code)
}
// Asigna inputs a botones del mando
void Input::bindGameControllerButton(InputAction input, SDL_GameControllerButton button)
void Input::bindGameControllerButton(int controller_index, InputAction input, SDL_GameControllerButton button)
{
game_controller_bindings_.at(static_cast<int>(input)).button = button;
if (controller_index < num_gamepads_)
{
controller_bindings_.at(controller_index).at(static_cast<int>(input)).button = button;
}
}
// Asigna inputs a botones del mando
void Input::bindGameControllerButton(int controller_index, InputAction input_target, InputAction input_source)
{
if (controller_index < num_gamepads_)
{
controller_bindings_.at(controller_index).at(static_cast<int>(input_target)).button = controller_bindings_.at(controller_index).at(static_cast<int>(input_source)).button;
}
}
// Comprueba si un input esta activo
bool Input::checkInput(InputAction input, bool repeat, int device, int index)
bool Input::checkInput(InputAction input, bool repeat, InputDeviceToUse device, int controller_index)
{
if (!enabled_)
{
return false;
}
bool success_keyboard = false;
bool success_controller = false;
const int input_index = static_cast<int>(input);
bool successKeyboard = false;
bool successGameController = false;
if (device == INPUT_USE_ANY)
{
index = 0;
}
if (device == INPUT_USE_KEYBOARD || device == INPUT_USE_ANY)
if (device == InputDeviceToUse::KEYBOARD || device == InputDeviceToUse::ANY)
{
const Uint8 *keyStates = SDL_GetKeyboardState(nullptr);
if (repeat)
{
if (keyStates[key_bindings_.at(static_cast<int>(input)).scancode] != 0)
{
successKeyboard = true;
}
else
{
successKeyboard = false;
}
success_keyboard = keyStates[key_bindings_[input_index].scancode] != 0;
}
else
{
if (!key_bindings_.at(static_cast<int>(input)).active)
if (!key_bindings_[input_index].active)
{
if (keyStates[key_bindings_.at(static_cast<int>(input)).scancode] != 0)
if (keyStates[key_bindings_[input_index].scancode] != 0)
{
key_bindings_.at(static_cast<int>(input)).active = true;
successKeyboard = true;
key_bindings_[input_index].active = true;
success_keyboard = true;
}
else
{
successKeyboard = false;
success_keyboard = false;
}
}
else
{
if (keyStates[key_bindings_.at(static_cast<int>(input)).scancode] == 0)
if (keyStates[key_bindings_[input_index].scancode] == 0)
{
key_bindings_.at(static_cast<int>(input)).active = false;
successKeyboard = false;
key_bindings_[input_index].active = false;
}
success_keyboard = false;
}
}
}
if (gameControllerFound() && controller_index >= 0 && controller_index < num_gamepads_)
{
if ((device == InputDeviceToUse::CONTROLLER) || (device == InputDeviceToUse::ANY))
{
success_controller = checkAxisInput(input, controller_index, repeat);
if (!success_controller)
{
if (repeat)
{
success_controller = SDL_GameControllerGetButton(connected_controllers_.at(controller_index), controller_bindings_.at(controller_index).at(input_index).button) != 0;
}
else
{
successKeyboard = false;
if (!controller_bindings_.at(controller_index).at(input_index).active)
{
if (SDL_GameControllerGetButton(connected_controllers_.at(controller_index), controller_bindings_.at(controller_index).at(input_index).button) != 0)
{
controller_bindings_.at(controller_index).at(input_index).active = true;
success_controller = true;
}
else
{
success_controller = false;
}
}
else
{
if (SDL_GameControllerGetButton(connected_controllers_.at(controller_index), controller_bindings_.at(controller_index).at(input_index).button) == 0)
{
controller_bindings_.at(controller_index).at(input_index).active = false;
}
success_controller = false;
}
}
}
}
}
if (gameControllerFound())
if ((device == INPUT_USE_GAMECONTROLLER) || (device == INPUT_USE_ANY))
{
if (repeat)
{
if (SDL_GameControllerGetButton(connected_controllers_.at(index), game_controller_bindings_.at(static_cast<int>(input)).button) != 0)
{
successGameController = true;
}
else
{
successGameController = false;
}
}
else
{
if (!game_controller_bindings_.at(static_cast<int>(input)).active)
{
if (SDL_GameControllerGetButton(connected_controllers_.at(index), game_controller_bindings_.at(static_cast<int>(input)).button) != 0)
{
game_controller_bindings_.at(static_cast<int>(input)).active = true;
successGameController = true;
}
else
{
successGameController = false;
}
}
else
{
if (SDL_GameControllerGetButton(connected_controllers_.at(index), game_controller_bindings_.at(static_cast<int>(input)).button) == 0)
{
game_controller_bindings_.at(static_cast<int>(input)).active = false;
successGameController = false;
}
else
{
successGameController = false;
}
}
}
}
return (successKeyboard || successGameController);
return (success_keyboard || success_controller);
}
// Comprueba si hay almenos un input activo
bool Input::checkAnyInput(int device, int index)
bool Input::checkAnyInput(InputDeviceToUse device, int controller_index)
{
if (device == INPUT_USE_ANY)
{
index = 0;
}
if (device == INPUT_USE_KEYBOARD || device == INPUT_USE_ANY)
if (device == InputDeviceToUse::KEYBOARD || device == InputDeviceToUse::ANY)
{
const Uint8 *mKeystates = SDL_GetKeyboardState(nullptr);
for (int i = 0; i < (int)key_bindings_.size(); ++i)
{
if (mKeystates[key_bindings_[i].scancode] != 0)
if (mKeystates[key_bindings_[i].scancode] != 0 && !key_bindings_[i].active)
{
key_bindings_[i].active = true;
return true;
}
}
@@ -184,12 +170,13 @@ bool Input::checkAnyInput(int device, int index)
if (gameControllerFound())
{
if (device == INPUT_USE_GAMECONTROLLER || device == INPUT_USE_ANY)
if (device == InputDeviceToUse::CONTROLLER || device == InputDeviceToUse::ANY)
{
for (int i = 0; i < (int)game_controller_bindings_.size(); ++i)
for (int i = 0; i < (int)controller_bindings_.size(); ++i)
{
if (SDL_GameControllerGetButton(connected_controllers_.at(index), game_controller_bindings_[i].button) != 0)
if (SDL_GameControllerGetButton(connected_controllers_[controller_index], controller_bindings_[controller_index][i].button) != 0 && !controller_bindings_[controller_index][i].active)
{
controller_bindings_[controller_index][i].active = true;
return true;
}
}
@@ -199,8 +186,8 @@ bool Input::checkAnyInput(int device, int index)
return false;
}
// Busca si hay un mando conectado
bool Input::discoverGameController()
// Busca si hay mandos conectados
bool Input::discoverGameControllers()
{
bool found = false;
@@ -209,30 +196,35 @@ bool Input::discoverGameController()
SDL_InitSubSystem(SDL_INIT_GAMECONTROLLER);
}
if (SDL_GameControllerAddMappingsFromFile(db_path_.c_str()) < 0)
if (SDL_GameControllerAddMappingsFromFile(game_controller_db_path_.c_str()) < 0)
{
if (verbose_)
{
std::cout << "Error, could not load " << db_path_.c_str() << " file: " << SDL_GetError() << std::endl;
}
std::cout << "Error, could not load " << game_controller_db_path_.c_str() << " file: " << SDL_GetError() << std::endl;
}
const int nJoysticks = SDL_NumJoysticks();
num_joysticks_ = SDL_NumJoysticks();
num_gamepads_ = 0;
// Cuenta el numero de mandos
for (int i = 0; i < nJoysticks; ++i)
// Cuenta el número de mandos
joysticks_.clear();
for (int i = 0; i < num_joysticks_; ++i)
{
auto joy = SDL_JoystickOpen(i);
joysticks_.push_back(joy);
if (SDL_IsGameController(i))
{
num_gamepads_++;
}
}
if (verbose_)
std::cout << "\n** LOOKING FOR GAME CONTROLLERS" << std::endl;
if (num_joysticks_ != num_gamepads_)
{
std::cout << "\nChecking for game controllers...\n";
std::cout << nJoysticks << " joysticks found, " << num_gamepads_ << " are gamepads\n";
std::cout << "Joysticks found: " << num_joysticks_ << std::endl;
std::cout << "Gamepads found : " << num_gamepads_ << std::endl;
}
else
{
std::cout << "Gamepads found: " << num_gamepads_ << std::endl;
}
if (num_gamepads_ > 0)
@@ -242,69 +234,110 @@ bool Input::discoverGameController()
for (int i = 0; i < num_gamepads_; i++)
{
// Abre el mando y lo añade a la lista
SDL_GameController *pad = SDL_GameControllerOpen(i);
auto pad = SDL_GameControllerOpen(i);
if (SDL_GameControllerGetAttached(pad) == 1)
{
connected_controllers_.push_back(pad);
const std::string separator(" #");
std::string name = SDL_GameControllerNameForIndex(i);
name.resize(25);
name = name + separator + std::to_string(i);
if (verbose_)
{
std::cout << name << std::endl;
}
const std::string name = SDL_GameControllerNameForIndex(i);
std::cout << "#" << i << ": " << name << std::endl;
controller_names_.push_back(name);
}
else
{
if (verbose_)
{
std::cout << "SDL_GetError() = " << SDL_GetError() << std::endl;
}
std::cout << "SDL_GetError() = " << SDL_GetError() << std::endl;
}
}
SDL_GameControllerEventState(SDL_ENABLE);
}
std::cout << "\n** FINISHED LOOKING FOR GAME CONTROLLERS" << std::endl;
return found;
}
// Comprueba si hay algun mando conectado
bool Input::gameControllerFound()
{
if (num_gamepads_ > 0)
{
return true;
}
else
{
return false;
}
}
bool Input::gameControllerFound() { return num_gamepads_ > 0 ? true : false; }
// Obten el nombre de un mando de juego
std::string Input::getControllerName(int index)
std::string Input::getControllerName(int controller_index) const { return num_gamepads_ > 0 ? controller_names_.at(controller_index) : std::string(); }
// Obten el número de mandos conectados
int Input::getNumControllers() const { return num_gamepads_; }
// Obtiene el indice del controlador a partir de un event.id
int Input::getJoyIndex(int id) const
{
if (num_gamepads_ > 0)
for (int i = 0; i < num_joysticks_; ++i)
{
return controller_names_[index];
if (SDL_JoystickInstanceID(joysticks_[i]) == id)
{
return i;
}
}
return -1;
}
// Obtiene el SDL_GameControllerButton asignado a un input
SDL_GameControllerButton Input::getControllerBinding(int controller_index, InputAction input) const
{
return controller_bindings_[controller_index][static_cast<int>(input)].button;
}
// Obtiene el indice a partir del nombre del mando
int Input::getIndexByName(const std::string &name) const
{
auto it = std::find(controller_names_.begin(), controller_names_.end(), name);
return it != controller_names_.end() ? std::distance(controller_names_.begin(), it) : -1;
}
// Comprueba el eje del mando
bool Input::checkAxisInput(InputAction input, int controller_index, bool repeat)
{
// Umbral para considerar el eje como activo
const Sint16 threshold = 30000;
bool axis_active_now = false;
switch (input)
{
case InputAction::LEFT:
axis_active_now = SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTX) < -threshold;
break;
case InputAction::RIGHT:
axis_active_now = SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTX) > threshold;
break;
case InputAction::UP:
axis_active_now = SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTY) < -threshold;
break;
case InputAction::DOWN:
axis_active_now = SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTY) > threshold;
break;
default:
return false;
}
// Referencia al binding correspondiente
auto &binding = controller_bindings_.at(controller_index).at(static_cast<int>(input));
if (repeat)
{
// Si se permite repetir, simplemente devolvemos el estado actual
return axis_active_now;
}
else
{
return "";
// Si no se permite repetir, aplicamos la lógica de transición
if (axis_active_now && !binding.axis_active)
{
// Transición de inactivo a activo
binding.axis_active = true;
return true;
}
else if (!axis_active_now && binding.axis_active)
{
// Transición de activo a inactivo
binding.axis_active = false;
}
// Mantener el estado actual
return false;
}
}
// Obten el numero de mandos conectados
int Input::getNumControllers()
{
return num_gamepads_;
}
// Establece si ha de mostrar mensajes
void Input::setVerbose(bool value)
{
verbose_ = value;
}