136 lines
5.2 KiB
C++
136 lines
5.2 KiB
C++
#pragma once
|
|
#include <fstream>
|
|
#include <string>
|
|
#include <unordered_map>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include "external/json.hpp"
|
|
#include "input_types.h" // Solo incluimos los tipos compartidos
|
|
|
|
// --- Estructuras ---
|
|
struct GamepadConfig {
|
|
std::string name; // Nombre del dispositivo
|
|
std::string path; // Ruta física del dispositivo
|
|
std::unordered_map<InputAction, SDL_GamepadButton> bindings; // Asociación acción-botón
|
|
|
|
GamepadConfig(std::string name, std::string path)
|
|
: name(std::move(name)),
|
|
path(std::move(path)),
|
|
bindings{
|
|
{InputAction::FIRE_LEFT, SDL_GAMEPAD_BUTTON_WEST},
|
|
{InputAction::FIRE_CENTER, SDL_GAMEPAD_BUTTON_NORTH},
|
|
{InputAction::FIRE_RIGHT, SDL_GAMEPAD_BUTTON_EAST},
|
|
{InputAction::START, SDL_GAMEPAD_BUTTON_START},
|
|
{InputAction::SERVICE, SDL_GAMEPAD_BUTTON_BACK}} {}
|
|
|
|
// Reasigna un botón a una acción
|
|
void rebindAction(InputAction action, SDL_GamepadButton new_button) {
|
|
bindings[action] = new_button;
|
|
}
|
|
};
|
|
|
|
// --- Tipos ---
|
|
using GamepadConfigs = std::vector<GamepadConfig>; // Vector de configuraciones de gamepad
|
|
|
|
// --- Clase GamepadConfigManager: gestor de configuraciones de gamepad ---
|
|
class GamepadConfigManager {
|
|
public:
|
|
// --- Métodos estáticos ---
|
|
static auto writeToJson(const GamepadConfigs& configs, const std::string& filename) -> bool { // Escribir configuraciones a JSON
|
|
try {
|
|
nlohmann::json j;
|
|
j["gamepads"] = nlohmann::json::array();
|
|
|
|
for (const auto& config : configs) {
|
|
nlohmann::json gamepad_json;
|
|
gamepad_json["name"] = config.name;
|
|
gamepad_json["path"] = config.path;
|
|
gamepad_json["bindings"] = nlohmann::json::object();
|
|
|
|
// Convertir bindings a JSON
|
|
for (const auto& [action, button] : config.bindings) {
|
|
auto action_it = ACTION_TO_STRING.find(action);
|
|
auto button_it = BUTTON_TO_STRING.find(button);
|
|
|
|
if (action_it != ACTION_TO_STRING.end() && button_it != BUTTON_TO_STRING.end()) {
|
|
gamepad_json["bindings"][action_it->second] = button_it->second;
|
|
}
|
|
}
|
|
|
|
j["gamepads"].push_back(gamepad_json);
|
|
}
|
|
|
|
// Escribir al archivo
|
|
std::ofstream file(filename);
|
|
if (!file.is_open()) {
|
|
return false;
|
|
}
|
|
|
|
file << j.dump(4); // Formato con indentación de 4 espacios
|
|
file.close();
|
|
return true;
|
|
|
|
} catch (const std::exception& e) {
|
|
// Log del error si tienes sistema de logging
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Leer vector de GamepadConfig desde archivo JSON
|
|
static auto readFromJson(GamepadConfigs& configs, const std::string& filename) -> bool {
|
|
try {
|
|
std::ifstream file(filename);
|
|
if (!file.is_open()) {
|
|
return false;
|
|
}
|
|
|
|
nlohmann::json j;
|
|
file >> j;
|
|
file.close();
|
|
|
|
configs.clear();
|
|
|
|
if (!j.contains("gamepads") || !j["gamepads"].is_array()) {
|
|
return false;
|
|
}
|
|
|
|
for (const auto& gamepad_json : j["gamepads"]) {
|
|
if (!gamepad_json.contains("name") || !gamepad_json.contains("bindings")) {
|
|
continue; // Saltar configuraciones malformadas
|
|
}
|
|
|
|
// Leer el campo path si existe, si no dejarlo vacío
|
|
std::string path = gamepad_json.contains("path") ? gamepad_json["path"].get<std::string>() : "";
|
|
GamepadConfig config(gamepad_json["name"], path);
|
|
|
|
// Limpiar bindings por defecto para cargar los del archivo
|
|
config.bindings.clear();
|
|
|
|
// Cargar bindings desde JSON
|
|
for (const auto& [actionStr, buttonStr] : gamepad_json["bindings"].items()) {
|
|
auto action_it = STRING_TO_ACTION.find(actionStr);
|
|
auto button_it = STRING_TO_BUTTON.find(buttonStr);
|
|
|
|
if (action_it != STRING_TO_ACTION.end() && button_it != STRING_TO_BUTTON.end()) {
|
|
config.bindings[action_it->second] = button_it->second;
|
|
}
|
|
}
|
|
|
|
configs.push_back(config);
|
|
}
|
|
|
|
return true;
|
|
|
|
} catch (const std::exception& e) {
|
|
// Log del error si tienes sistema de logging
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Método auxiliar para verificar si un archivo existe
|
|
static auto fileExists(const std::string& filename) -> bool {
|
|
std::ifstream file(filename);
|
|
return file.good();
|
|
}
|
|
}; |