533 lines
14 KiB
C++
533 lines
14 KiB
C++
#define _USE_MATH_DEFINES
|
|
#include "utils.h"
|
|
#include <SDL3/SDL_iostream.h> // Para SDL_CloseIO, SDL_IOFromFile, SDL_ReadIO
|
|
#include <SDL3/SDL_log.h> // Para SDL_LogCategory, SDL_LogError, SDL_Lo...
|
|
#include <stddef.h> // Para size_t
|
|
#include <algorithm> // Para min, clamp, find_if_not, find, transform
|
|
#include <cctype> // Para tolower, isspace
|
|
#include <cmath> // Para pow, sin, M_PI, cos
|
|
#include <compare> // Para operator<
|
|
#include <filesystem> // Para path
|
|
#include <stdexcept> // Para runtime_error
|
|
#include <string> // Para basic_string, string, operator==, ope...
|
|
#include "lang.h" // Para getText
|
|
|
|
// Variables
|
|
Overrides overrides = Overrides();
|
|
|
|
// Obtiene un color del vector de colores imitando al Coche Fantástico
|
|
Color getColorLikeKnightRider(const std::vector<Color> &colors, int counter_)
|
|
{
|
|
int cycle_length = colors.size() * 2 - 2;
|
|
size_t n = counter_ % cycle_length;
|
|
|
|
size_t index;
|
|
if (n < colors.size())
|
|
{
|
|
index = n; // Avanza: 0,1,2,3
|
|
}
|
|
else
|
|
{
|
|
index = 2 * (colors.size() - 1) - n; // Retrocede: 2,1
|
|
}
|
|
|
|
return colors[index];
|
|
}
|
|
|
|
// Calcula el cuadrado de la distancia entre dos puntos
|
|
double distanceSquared(int x1, int y1, int x2, int y2)
|
|
{
|
|
const int delta_x = x2 - x1;
|
|
const int delta_y = y2 - y1;
|
|
return delta_x * delta_x + delta_y * delta_y;
|
|
}
|
|
|
|
// Detector de colisiones entre dos circulos
|
|
bool checkCollision(const Circle &a, const Circle &b)
|
|
{
|
|
// Calcula el radio total al cuadrado
|
|
int total_radius_squared = (a.r + b.r) * (a.r + b.r);
|
|
|
|
// Comprueba si la distancia entre los centros de los círculos es inferior a la suma de sus radios
|
|
return distanceSquared(a.x, a.y, b.x, b.y) < total_radius_squared;
|
|
}
|
|
|
|
// Detector de colisiones entre un circulo y un rectangulo
|
|
bool checkCollision(const Circle &a, const SDL_FRect &b)
|
|
{
|
|
// Encuentra el punto más cercano en el rectángulo
|
|
float cX = std::clamp(static_cast<float>(a.x), b.x, b.x + b.w);
|
|
float cY = std::clamp(static_cast<float>(a.y), b.y, b.y + b.h);
|
|
|
|
// Si el punto más cercano está dentro del círculo
|
|
return distanceSquared(static_cast<float>(a.x), static_cast<float>(a.y), cX, cY) < static_cast<float>(a.r) * a.r;
|
|
}
|
|
|
|
// Detector de colisiones entre dos rectangulos
|
|
bool checkCollision(const SDL_FRect &a, const SDL_FRect &b)
|
|
{
|
|
const int leftA = a.x, rightA = a.x + a.w, topA = a.y, bottomA = a.y + a.h;
|
|
const int leftB = b.x, rightB = b.x + b.w, topB = b.y, bottomB = b.y + b.h;
|
|
|
|
if (bottomA <= topB)
|
|
return false;
|
|
if (topA >= bottomB)
|
|
return false;
|
|
if (rightA <= leftB)
|
|
return false;
|
|
if (leftA >= rightB)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
// Detector de colisiones entre un punto y un rectangulo
|
|
bool checkCollision(const SDL_FPoint &p, const SDL_FRect &r)
|
|
{
|
|
if (p.x < r.x || p.x > r.x + r.w)
|
|
return false;
|
|
if (p.y < r.y || p.y > r.y + r.h)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
// Convierte una cadena en un valor booleano
|
|
bool stringToBool(const std::string &str)
|
|
{
|
|
std::string s = trim(toLower(str));
|
|
return (s == "true" || s == "1" || s == "yes" || s == "on");
|
|
}
|
|
|
|
// Convierte un valor booleano en una cadena
|
|
std::string boolToString(bool value)
|
|
{
|
|
return value ? "true" : "false";
|
|
}
|
|
|
|
// Convierte un valor booleano en una cadena "on" o "off"
|
|
std::string boolToOnOff(bool value)
|
|
{
|
|
return value ? Lang::getText("[NOTIFICATIONS] 06") : Lang::getText("[NOTIFICATIONS] 07");
|
|
}
|
|
|
|
// Convierte una cadena a minusculas
|
|
std::string toLower(const std::string &str)
|
|
{
|
|
std::string result = str;
|
|
std::transform(result.begin(), result.end(), result.begin(),
|
|
[](unsigned char c)
|
|
{ return std::tolower(c); });
|
|
return result;
|
|
}
|
|
|
|
// Dibuja un circulo
|
|
void DrawCircle(SDL_Renderer *renderer, int32_t centerX, int32_t centerY, int32_t radius)
|
|
{
|
|
const int32_t diameter = (radius * 2);
|
|
|
|
int32_t x = (radius - 1);
|
|
int32_t y = 0;
|
|
int32_t tx = 1;
|
|
int32_t ty = 1;
|
|
int32_t error = (tx - diameter);
|
|
|
|
while (x >= y)
|
|
{
|
|
// Each of the following renders an octant of the circle
|
|
SDL_RenderPoint(renderer, centerX + x, centerY - y);
|
|
SDL_RenderPoint(renderer, centerX + x, centerY + y);
|
|
SDL_RenderPoint(renderer, centerX - x, centerY - y);
|
|
SDL_RenderPoint(renderer, centerX - x, centerY + y);
|
|
SDL_RenderPoint(renderer, centerX + y, centerY - x);
|
|
SDL_RenderPoint(renderer, centerX + y, centerY + x);
|
|
SDL_RenderPoint(renderer, centerX - y, centerY - x);
|
|
SDL_RenderPoint(renderer, centerX - y, centerY + x);
|
|
|
|
if (error <= 0)
|
|
{
|
|
++y;
|
|
error += ty;
|
|
ty += 2;
|
|
}
|
|
|
|
if (error > 0)
|
|
{
|
|
--x;
|
|
tx += 2;
|
|
error += (tx - diameter);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Aclara el color
|
|
Color lightenColor(const Color &color, int amount)
|
|
{
|
|
Color newColor;
|
|
newColor.r = std::min(255, color.r + amount);
|
|
newColor.g = std::min(255, color.g + amount);
|
|
newColor.b = std::min(255, color.b + amount);
|
|
return newColor;
|
|
}
|
|
|
|
// Oscurece el color
|
|
Color DarkenColor(const Color &color, int amount)
|
|
{
|
|
Color newColor;
|
|
newColor.r = std::min(255, color.r - +amount);
|
|
newColor.g = std::min(255, color.g - +amount);
|
|
newColor.b = std::min(255, color.b - +amount);
|
|
return newColor;
|
|
}
|
|
|
|
// Quita los espacioes en un string
|
|
std::string trim(const std::string &str)
|
|
{
|
|
auto start = std::find_if_not(str.begin(), str.end(), ::isspace);
|
|
auto end = std::find_if_not(str.rbegin(), str.rend(), ::isspace).base();
|
|
return (start < end ? std::string(start, end) : std::string());
|
|
}
|
|
|
|
// Función de suavizado
|
|
double easeOutQuint(double t)
|
|
{
|
|
return 1 - std::pow(1 - t, 5);
|
|
}
|
|
|
|
// Función de suavizado
|
|
double easeInQuint(double t)
|
|
{
|
|
return pow(t, 5);
|
|
}
|
|
|
|
// Función de suavizado
|
|
double easeInOutQuint(double t)
|
|
{
|
|
return t < 0.5 ? 16 * pow(t, 5) : 1 - pow(-2 * t + 2, 5) / 2;
|
|
}
|
|
|
|
// Función de suavizado
|
|
double easeInQuad(double t)
|
|
{
|
|
return t * t;
|
|
}
|
|
|
|
// Función de suavizado
|
|
double easeOutQuad(double t)
|
|
{
|
|
return 1 - (1 - t) * (1 - t);
|
|
}
|
|
|
|
// Función de suavizado
|
|
double easeInOutSine(double t)
|
|
{
|
|
return -0.5 * (std::cos(M_PI * t) - 1);
|
|
}
|
|
|
|
// Función de suavizado
|
|
double easeInOut(double t)
|
|
{
|
|
return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
|
|
}
|
|
|
|
// Función de suavizado
|
|
double easeInOutExpo(double t)
|
|
{
|
|
return t == 0 ? 0 : (t == 1 ? 1 : (t < 0.5 ? pow(2, 20 * t - 10) / 2 : (2 - pow(2, -20 * t + 10)) / 2));
|
|
}
|
|
|
|
// Función de suavizado (easeInElastic)
|
|
double easeInElastic(double t)
|
|
{
|
|
return t == 0 ? 0 : (t == 1 ? 1 : -pow(2, 10 * t - 10) * sin((t * 10 - 10.75) * (2 * M_PI) / 3));
|
|
}
|
|
|
|
// Función de suavizado
|
|
double easeOutBounce(double t)
|
|
{
|
|
if (t < 1 / 2.75)
|
|
{
|
|
return 7.5625 * t * t;
|
|
}
|
|
else if (t < 2 / 2.75)
|
|
{
|
|
t -= 1.5 / 2.75;
|
|
return 7.5625 * t * t + 0.75;
|
|
}
|
|
else if (t < 2.5 / 2.75)
|
|
{
|
|
t -= 2.25 / 2.75;
|
|
return 7.5625 * t * t + 0.9375;
|
|
}
|
|
else
|
|
{
|
|
t -= 2.625 / 2.75;
|
|
return 7.5625 * t * t + 0.984375;
|
|
}
|
|
}
|
|
|
|
// Función de suavizado
|
|
double easeOutElastic(double t)
|
|
{
|
|
const double c4 = (2 * M_PI) / 3; // Constante para controlar la elasticidad
|
|
|
|
return t == 0
|
|
? 0
|
|
: (t == 1
|
|
? 1
|
|
: pow(2, -10 * t) * sin((t * 10 - 0.75) * c4) + 1);
|
|
}
|
|
|
|
// Comprueba si una vector contiene una cadena
|
|
bool stringInVector(const std::vector<std::string> &vec, const std::string &str)
|
|
{
|
|
return std::find(vec.begin(), vec.end(), str) != vec.end();
|
|
}
|
|
|
|
// Imprime por pantalla una línea de texto de tamaño fijo rellena con puntos
|
|
void printWithDots(const std::string &text1, const std::string &text2, const std::string &text3)
|
|
{
|
|
constexpr size_t TOTAL_WIDTH = 52;
|
|
|
|
// Calcula el ancho del campo para text2 restando la longitud de text1 y text3
|
|
size_t field_width = TOTAL_WIDTH > (text1.size() + text3.size())
|
|
? TOTAL_WIDTH - text1.size() - text3.size()
|
|
: 0;
|
|
|
|
// Prepara el bloque a imprimir a partir de text2
|
|
std::string field_text;
|
|
if (text2.size() < field_width)
|
|
{
|
|
// Si text2 es más corto, lo rellenamos a la derecha con puntos
|
|
field_text = text2 + std::string(field_width - text2.size(), '.');
|
|
}
|
|
else
|
|
{
|
|
// Si es demasiado largo, lo cortamos
|
|
field_text = text2.substr(0, field_width);
|
|
}
|
|
|
|
// Concatena todo
|
|
std::string formatted_text = text1 + field_text + text3;
|
|
|
|
// Imprime la línea formateada usando SDL_LogInfo
|
|
SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "%s", formatted_text.c_str());
|
|
}
|
|
|
|
// Carga el fichero de datos para la demo
|
|
DemoData loadDemoDataFromFile(const std::string &file_path)
|
|
{
|
|
DemoData dd;
|
|
|
|
// Indicador de éxito en la carga
|
|
auto file = SDL_IOFromFile(file_path.c_str(), "r+b");
|
|
if (!file)
|
|
{
|
|
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error: Fichero no encontrado %s", file_path.c_str());
|
|
throw std::runtime_error("Fichero no encontrado: " + file_path);
|
|
}
|
|
else
|
|
{
|
|
printWithDots("DemoData : ", getFileName(file_path), "[ LOADED ]");
|
|
|
|
// Lee todos los datos del fichero y los deja en el destino
|
|
for (int i = 0; i < TOTAL_DEMO_DATA; ++i)
|
|
{
|
|
DemoKeys dk = DemoKeys();
|
|
SDL_ReadIO(file, &dk, sizeof(DemoKeys));
|
|
dd.push_back(dk);
|
|
}
|
|
|
|
// Cierra el fichero
|
|
SDL_CloseIO(file);
|
|
}
|
|
|
|
return dd;
|
|
}
|
|
|
|
#ifdef RECORDING
|
|
// Guarda el fichero de datos para la demo
|
|
bool saveDemoFile(const std::string &file_path, const DemoData &dd)
|
|
{
|
|
auto success = true;
|
|
auto file = SDL_IOFromFile(file_path.c_str(), "w+b");
|
|
|
|
if (file)
|
|
{
|
|
// Guarda los datos
|
|
for (const auto &data : dd)
|
|
{
|
|
if (SDL_RWwrite(file, &data, sizeof(DemoKeys), 1) != 1)
|
|
{
|
|
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error al escribir el fichero %s", getFileName(file_path).c_str());
|
|
success = false;
|
|
break;
|
|
}
|
|
}
|
|
if (success)
|
|
{
|
|
SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "Writing file %s", getFileName(file_path).c_str());
|
|
}
|
|
// Cierra el fichero
|
|
SDL_CloseIO(file);
|
|
}
|
|
else
|
|
{
|
|
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error: Unable to save %s file! %s", getFileName(file_path).c_str(), SDL_GetError());
|
|
success = false;
|
|
}
|
|
|
|
return success;
|
|
}
|
|
#endif // RECORDING
|
|
|
|
// Obtiene el nombre de un fichero a partir de una ruta completa
|
|
std::string getFileName(const std::string &path)
|
|
{
|
|
return std::filesystem::path(path).filename().string();
|
|
}
|
|
|
|
// Obtiene la ruta eliminando el nombre del fichero
|
|
std::string getPath(const std::string &full_path)
|
|
{
|
|
std::filesystem::path path(full_path);
|
|
return path.parent_path().string();
|
|
}
|
|
|
|
constexpr HSV rgbToHsv(Color color)
|
|
{
|
|
float r = color.r / 255.0f;
|
|
float g = color.g / 255.0f;
|
|
float b = color.b / 255.0f;
|
|
|
|
float max = fmaxf(fmaxf(r, g), b);
|
|
float min = fminf(fminf(r, g), b);
|
|
float delta = max - min;
|
|
|
|
float h = 0.0f;
|
|
if (delta > 0.00001f)
|
|
{
|
|
if (max == r)
|
|
h = fmodf((g - b) / delta, 6.0f);
|
|
else if (max == g)
|
|
h = ((b - r) / delta) + 2.0f;
|
|
else
|
|
h = ((r - g) / delta) + 4.0f;
|
|
h *= 60.0f;
|
|
if (h < 0.0f)
|
|
h += 360.0f;
|
|
}
|
|
|
|
float s = (max <= 0.0f) ? 0.0f : delta / max;
|
|
float v = max;
|
|
|
|
return {h, s, v};
|
|
}
|
|
|
|
constexpr Color hsvToRgb(HSV hsv)
|
|
{
|
|
float c = hsv.v * hsv.s;
|
|
float x = c * (1 - std::abs(std::fmod(hsv.h / 60.0f, 2) - 1));
|
|
float m = hsv.v - c;
|
|
|
|
float r = 0, g = 0, b = 0;
|
|
|
|
if (hsv.h < 60)
|
|
{
|
|
r = c;
|
|
g = x;
|
|
b = 0;
|
|
}
|
|
else if (hsv.h < 120)
|
|
{
|
|
r = x;
|
|
g = c;
|
|
b = 0;
|
|
}
|
|
else if (hsv.h < 180)
|
|
{
|
|
r = 0;
|
|
g = c;
|
|
b = x;
|
|
}
|
|
else if (hsv.h < 240)
|
|
{
|
|
r = 0;
|
|
g = x;
|
|
b = c;
|
|
}
|
|
else if (hsv.h < 300)
|
|
{
|
|
r = x;
|
|
g = 0;
|
|
b = c;
|
|
}
|
|
else
|
|
{
|
|
r = c;
|
|
g = 0;
|
|
b = x;
|
|
}
|
|
|
|
return Color(
|
|
static_cast<uint8_t>(roundf((r + m) * 255)),
|
|
static_cast<uint8_t>(roundf((g + m) * 255)),
|
|
static_cast<uint8_t>(roundf((b + m) * 255)));
|
|
}
|
|
|
|
ColorCycle generateMirroredCycle(Color base, ColorCycleStyle style)
|
|
{
|
|
ColorCycle result{};
|
|
HSV baseHSV = rgbToHsv(base);
|
|
|
|
for (size_t i = 0; i < COLOR_CYCLE_SIZE; ++i)
|
|
{
|
|
float t = static_cast<float>(i) / (COLOR_CYCLE_SIZE - 1); // 0 → 1
|
|
float hueShift = 0.0f;
|
|
float satShift = 0.0f;
|
|
float valShift = 0.0f;
|
|
|
|
switch (style)
|
|
{
|
|
case ColorCycleStyle::SubtlePulse:
|
|
// Solo brillo suave
|
|
valShift = 0.07f * sinf(t * M_PI);
|
|
break;
|
|
|
|
case ColorCycleStyle::HueWave:
|
|
// Oscilación leve de tono
|
|
hueShift = 15.0f * (t - 0.5f) * 2.0f;
|
|
valShift = 0.05f * sinf(t * M_PI);
|
|
break;
|
|
|
|
case ColorCycleStyle::Vibrant:
|
|
// Cambios fuertes en tono y brillo
|
|
hueShift = 35.0f * sinf(t * M_PI);
|
|
valShift = 0.2f * sinf(t * M_PI);
|
|
satShift = -0.2f * sinf(t * M_PI);
|
|
break;
|
|
|
|
case ColorCycleStyle::DarkenGlow:
|
|
// Se oscurece al centro
|
|
valShift = -0.15f * sinf(t * M_PI);
|
|
break;
|
|
|
|
case ColorCycleStyle::LightFlash:
|
|
// Se ilumina al centro
|
|
valShift = 0.25f * sinf(t * M_PI);
|
|
break;
|
|
}
|
|
|
|
HSV adjusted = {
|
|
fmodf(baseHSV.h + hueShift + 360.0f, 360.0f),
|
|
fminf(1.0f, fmaxf(0.0f, baseHSV.s + satShift)),
|
|
fminf(1.0f, fmaxf(0.0f, baseHSV.v + valShift))
|
|
};
|
|
|
|
Color c = hsvToRgb(adjusted);
|
|
result[i] = c;
|
|
result[2 * COLOR_CYCLE_SIZE - 1 - i] = c; // espejo
|
|
}
|
|
|
|
return result;
|
|
}
|