coffee_crisis/source/input.cpp

#include "input.h"

#include <SDL3/SDL.h>

#include <iostream>  // for basic_ostream, operator<<, cout, basi...

// Constructor
Input::Input(std::string file) {
    // Fichero gamecontrollerdb.txt
    dbPath = file;

    // Inicializa las variables
    keyBindings_t kb;
    kb.scancode = 0;
    kb.active = false;
    keyBindings.resize(input_number_of_inputs, kb);

    GameControllerBindings_t gcb;
    gcb.button = SDL_GAMEPAD_BUTTON_INVALID;
    gcb.active = false;
    gameControllerBindings.resize(input_number_of_inputs, gcb);

    verbose = true;
    enabled = true;
}

// Actualiza el estado del objeto
void Input::update() {
    if (disabledUntil == d_keyPressed && !checkAnyInput()) {
        enable();
    }
}

// Asigna inputs a teclas
void Input::bindKey(Uint8 input, SDL_Scancode code) {
    keyBindings[input].scancode = code;
}

// Asigna inputs a botones del mando
void Input::bindGameControllerButton(Uint8 input, SDL_GamepadButton button) {
    gameControllerBindings[input].button = button;
}

// Comprueba si un input esta activo
bool Input::checkInput(Uint8 input, bool repeat, int device, int index) {
    if (!enabled) {
        return false;
    }

    bool successKeyboard = false;
    bool successGameController = false;

    if (device == INPUT_USE_ANY) {
        index = 0;
    }

    if (device == INPUT_USE_KEYBOARD || device == INPUT_USE_ANY) {
        const bool *keyStates = SDL_GetKeyboardState(nullptr);

        if (repeat) {
            if (keyStates[keyBindings[input].scancode]) {
                successKeyboard = true;
            } else {
                successKeyboard = false;
            }
        } else {
            if (!keyBindings[input].active) {
                if (keyStates[keyBindings[input].scancode]) {
                    keyBindings[input].active = true;
                    successKeyboard = true;
                } else {
                    successKeyboard = false;
                }
            } else {
                if (!keyStates[keyBindings[input].scancode]) {
                    keyBindings[input].active = false;
                    successKeyboard = false;
                } else {
                    successKeyboard = false;
                }
            }
        }
    }

    if (gameControllerFound())
        if ((device == INPUT_USE_GAMECONTROLLER) || (device == INPUT_USE_ANY)) {
            if (repeat) {
                if (SDL_GetGamepadButton(connectedControllers[index], gameControllerBindings[input].button)) {
                    successGameController = true;
                } else {
                    successGameController = false;
                }
            } else {
                if (!gameControllerBindings[input].active) {
                    if (SDL_GetGamepadButton(connectedControllers[index], gameControllerBindings[input].button)) {
                        gameControllerBindings[input].active = true;
                        successGameController = true;
                    } else {
                        successGameController = false;
                    }
                } else {
                    if (!SDL_GetGamepadButton(connectedControllers[index], gameControllerBindings[input].button)) {
                        gameControllerBindings[input].active = false;
                        successGameController = false;
                    } else {
                        successGameController = false;
                    }
                }
            }
        }

    return (successKeyboard || successGameController);
}

// Comprueba si hay almenos un input activo
bool Input::checkAnyInput(int device, int index) {
    if (device == INPUT_USE_ANY) {
        index = 0;
    }

    if (device == INPUT_USE_KEYBOARD || device == INPUT_USE_ANY) {
        const bool *mKeystates = SDL_GetKeyboardState(nullptr);

        for (int i = 0; i < (int)keyBindings.size(); ++i) {
            if (mKeystates[keyBindings[i].scancode]) {
                return true;
            }
        }
    }

    if (gameControllerFound()) {
        if (device == INPUT_USE_GAMECONTROLLER || device == INPUT_USE_ANY) {
            for (int i = 0; i < (int)gameControllerBindings.size(); ++i) {
                if (SDL_GetGamepadButton(connectedControllers[index], gameControllerBindings[i].button)) {
                    return true;
                }
            }
        }
    }

    return false;
}

// Busca si hay un mando conectado
bool Input::discoverGameController() {
    bool found = false;

    if (SDL_WasInit(SDL_INIT_GAMEPAD) != SDL_INIT_GAMEPAD) {
        SDL_InitSubSystem(SDL_INIT_GAMEPAD);
    }

    if (SDL_AddGamepadMappingsFromFile(dbPath.c_str()) < 0) {
        if (verbose) {
            std::cout << "Error, could not load " << dbPath.c_str() << " file: " << SDL_GetError() << std::endl;
        }
    }

    int nJoysticks = 0;
    SDL_JoystickID *joysticks = SDL_GetJoysticks(&nJoysticks);
    numGamepads = 0;

    if (joysticks) {
        // Cuenta el numero de mandos
        for (int i = 0; i < nJoysticks; ++i) {
            if (SDL_IsGamepad(joysticks[i])) {
                numGamepads++;
            }
        }

        if (verbose) {
            std::cout << "\nChecking for game controllers...\n";
            std::cout << nJoysticks << " joysticks found, " << numGamepads << " are gamepads\n";
        }

        if (numGamepads > 0) {
            found = true;
            int padIndex = 0;

            for (int i = 0; i < nJoysticks; i++) {
                if (!SDL_IsGamepad(joysticks[i])) continue;

                // Abre el mando y lo añade a la lista
                SDL_Gamepad *pad = SDL_OpenGamepad(joysticks[i]);
                if (pad != nullptr) {
                    connectedControllers.push_back(pad);
                    const std::string separator(" #");
                    const char *padName = SDL_GetGamepadName(pad);
                    std::string name = padName ? padName : "Unknown";
                    name.resize(25);
                    name = name + separator + std::to_string(padIndex);
                    if (verbose) {
                        std::cout << name << std::endl;
                    }
                    controllerNames.push_back(name);
                    padIndex++;
                } else {
                    if (verbose) {
                        std::cout << "SDL_GetError() = " << SDL_GetError() << std::endl;
                    }
                }
            }

            SDL_SetGamepadEventsEnabled(true);
        }

        SDL_free(joysticks);
    }

    return found;
}

// Comprueba si hay algun mando conectado
bool Input::gameControllerFound() {
    if (numGamepads > 0) {
        return true;
    } else {
        return false;
    }
}

// Obten el nombre de un mando de juego
std::string Input::getControllerName(int index) {
    if (numGamepads > 0) {
        return controllerNames[index];
    } else {
        return "";
    }
}

// Obten el numero de mandos conectados
int Input::getNumControllers() {
    return numGamepads;
}

// Establece si ha de mostrar mensajes
void Input::setVerbose(bool value) {
    verbose = value;
}

// Deshabilita las entradas durante un periodo de tiempo
void Input::disableUntil(i_disable_e value) {
    disabledUntil = value;
    enabled = false;
}

// Hablita las entradas
void Input::enable() {
    enabled = true;
    disabledUntil = d_notDisabled;
}