coffee_crisis_arcade_edition/source/utils.cpp

#define _USE_MATH_DEFINES
#include "utils.h"

#include <SDL3/SDL.h>  // Para SDL_RenderPoint, SDL_FRect, SDL_CloseIO, SDL_I...

#include <algorithm>   // Para min, clamp, find_if_not, find, transform
#include <cctype>      // Para tolower, isspace
#include <cmath>       // Para pow, sinf, fmaxf, fminf, M_PI, fmodf, roundf, sin
#include <compare>     // Para operator<
#include <filesystem>  // Para path
#include <stdexcept>   // Para runtime_error
#include <string>      // Para basic_string, allocator, string, char_traits

#include "lang.h"  // Para getText

// Variables
Overrides overrides = Overrides();

// Obtiene un color del vector de colores imitando al Coche Fantástico
auto getColorLikeKnightRider(const std::vector<Color> &colors, int counter) -> Color {
    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
auto distanceSquared(int x1, int y1, int x2, int y2) -> double {
    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
auto checkCollision(const Circle &a, const Circle &b) -> bool {
    // 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
auto checkCollision(const Circle &a, const SDL_FRect &b) -> bool {
    // Encuentra el punto más cercano en el rectángulo
    float c_x = std::clamp(static_cast<float>(a.x), b.x, b.x + b.w);
    float c_y = 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), c_x, c_y) < static_cast<float>(a.r) * a.r;
}

// Detector de colisiones entre dos rectangulos
auto checkCollision(const SDL_FRect &a, const SDL_FRect &b) -> bool {
    const int LEFT_A = a.x;
    const int RIGHT_A = a.x + a.w;
    const int TOP_A = a.y;
    const int BOTTOM_A = a.y + a.h;
    const int LEFT_B = b.x;
    const int RIGHT_B = b.x + b.w;
    const int TOP_B = b.y;
    const int BOTTOM_B = b.y + b.h;

    if (BOTTOM_A <= TOP_B) {
        return false;
    }
    if (TOP_A >= BOTTOM_B) {
        return false;
    }
    if (RIGHT_A <= LEFT_B) {
        return false;
    }
    if (LEFT_A >= RIGHT_B) {
        return false;
    }

    return true;
}

// Detector de colisiones entre un punto y un rectangulo
auto checkCollision(const SDL_FPoint &p, const SDL_FRect &r) -> bool {
    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
auto stringToBool(const std::string &str) -> bool {
    std::string s = trim(toLower(str));
    return (s == "true" || s == "1" || s == "yes" || s == "on");
}

// Convierte un valor booleano en una cadena
auto boolToString(bool value) -> std::string {
    return value ? "true" : "false";
}

// Convierte un valor booleano en una cadena "on" o "off"
auto boolToOnOff(bool value) -> std::string {
    return value ? Lang::getText("[NOTIFICATIONS] 06") : Lang::getText("[NOTIFICATIONS] 07");
}

// Convierte una cadena a minusculas
auto toLower(const std::string &str) -> std::string {
    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 center_x, int32_t center_y, 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, center_x + x, center_y - y);
        SDL_RenderPoint(renderer, center_x + x, center_y + y);
        SDL_RenderPoint(renderer, center_x - x, center_y - y);
        SDL_RenderPoint(renderer, center_x - x, center_y + y);
        SDL_RenderPoint(renderer, center_x + y, center_y - x);
        SDL_RenderPoint(renderer, center_x + y, center_y + x);
        SDL_RenderPoint(renderer, center_x - y, center_y - x);
        SDL_RenderPoint(renderer, center_x - y, center_y + x);

        if (error <= 0) {
            ++y;
            error += ty;
            ty += 2;
        }

        if (error > 0) {
            --x;
            tx += 2;
            error += (tx - DIAMETER);
        }
    }
}

// Aclara el color
auto lightenColor(const Color &color, int amount) -> Color {
    Color new_color;
    new_color.r = std::min(255, color.r + amount);
    new_color.g = std::min(255, color.g + amount);
    new_color.b = std::min(255, color.b + amount);
    return new_color;
}

// Oscurece el color
auto darkenColor(const Color &color, int amount) -> Color {
    Color new_color;
    new_color.r = std::min(255, color.r - +amount);
    new_color.g = std::min(255, color.g - +amount);
    new_color.b = std::min(255, color.b - +amount);
    return new_color;
}

// Quita los espacioes en un string
auto trim(const std::string &str) -> std::string {
    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
auto easeOutQuint(double time) -> double {
    return 1 - std::pow(1 - time, 5);
}

// Función de suavizado
auto easeInQuint(double time) -> double {
    return pow(time, 5);
}

// Función de suavizado
auto easeInOutQuint(double time) -> double {
    return time < 0.5 ? 16 * pow(time, 5) : 1 - pow(-2 * time + 2, 5) / 2;
}

// Función de suavizado
auto easeInQuad(double time) -> double {
    return time * time;
}

// Función de suavizado
auto easeOutQuad(double time) -> double {
    return 1 - (1 - time) * (1 - time);
}

// Función de suavizado
auto easeInOutSine(double time) -> double {
    return -0.5 * (std::cos(M_PI * time) - 1);
}

// Función de suavizado
auto easeInOut(double time) -> double {
    return time < 0.5 ? 2 * time * time : -1 + (4 - 2 * time) * time;
}

// Función de suavizado (easeInOutExpo)
auto easeInOutExpo(double time) -> double {
    if (time == 0) {
        return 0;
    }

    if (time == 1) {
        return 1;
    }

    if (time < 0.5) {
        return pow(2, 20 * time - 10) / 2;
    }

    return (2 - pow(2, -20 * time + 10)) / 2;
}

// Función de suavizado (easeInElastic)
auto easeInElastic(double time) -> double {
    if (time == 0) {
        return 0;
    }
    
    if (time == 1) {
        return 1;
    }

    const double C4 = (2 * M_PI) / 3;
    return -pow(2, 10 * time - 10) * sin((time * 10 - 10.75) * C4);
}

// Función de suavizado
auto easeOutBounce(double time) -> double {
    if (time < 1 / 2.75) {
        return 7.5625 * time * time;
    }
    if (time < 2 / 2.75) {
        time -= 1.5 / 2.75;
        return 7.5625 * time * time + 0.75;
    }
    if (time < 2.5 / 2.75) {
        time -= 2.25 / 2.75;
        return 7.5625 * time * time + 0.9375;
    }
    time -= 2.625 / 2.75;
    return 7.5625 * time * time + 0.984375;
}

// Función de suavizado (easeOutElastic)
auto easeOutElastic(double time) -> double {
    if (time == 0) {
        return 0;
    }
    
    if (time == 1) {
        return 1;
    }
    
    const double C4 = (2 * M_PI) / 3;  // Constante para controlar la elasticidad
    return pow(2, -10 * time) * sin((time * 10 - 0.75) * C4) + 1;
}

// Comprueba si una vector contiene una cadena
auto stringInVector(const std::vector<std::string> &vec, const std::string &str) -> bool {
    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
auto loadDemoDataFromFile(const std::string &file_path) -> DemoData {
    DemoData dd;

    // Indicador de éxito en la carga
    auto *file = SDL_IOFromFile(file_path.c_str(), "r+b");
    if (file == nullptr) {
        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error: Fichero no encontrado %s", file_path.c_str());
        throw std::runtime_error("Fichero no encontrado: " + file_path);
    }
    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
auto getFileName(const std::string &path) -> std::string {
    return std::filesystem::path(path).filename().string();
}

// Obtiene la ruta eliminando el nombre del fichero
auto getPath(const std::string &full_path) -> std::string {
    std::filesystem::path path(full_path);
    return path.parent_path().string();
}

constexpr auto rgbToHsv(Color color) -> HSV {
    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 auto hsvToRgb(HSV hsv) -> Color {
    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;
    float g = 0;
    float 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)));
}

auto generateMirroredCycle(Color base, ColorCycleStyle style) -> ColorCycle {
    ColorCycle result{};
    HSV base_hsv = 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 hue_shift = 0.0F;
        float sat_shift = 0.0F;
        float val_shift = 0.0F;

        switch (style) {
            case ColorCycleStyle::SUBTLE_PULSE:
                // Solo brillo suave
                val_shift = 0.07F * sinf(t * M_PI);
                break;

            case ColorCycleStyle::HUE_WAVE:
                // Oscilación leve de tono
                hue_shift = 15.0F * (t - 0.5F) * 2.0F;
                val_shift = 0.05F * sinf(t * M_PI);
                break;

            case ColorCycleStyle::VIBRANT:
                // Cambios fuertes en tono y brillo
                hue_shift = 35.0F * sinf(t * M_PI);
                val_shift = 0.2F * sinf(t * M_PI);
                sat_shift = -0.2F * sinf(t * M_PI);
                break;

            case ColorCycleStyle::DARKEN_GLOW:
                // Se oscurece al centro
                val_shift = -0.15F * sinf(t * M_PI);
                break;

            case ColorCycleStyle::LIGHT_FLASH:
                // Se ilumina al centro
                val_shift = 0.25F * sinf(t * M_PI);
                break;
        }

        HSV adjusted = {
            fmodf(base_hsv.h + hue_shift + 360.0F, 360.0F),
            fminf(1.0F, fmaxf(0.0F, base_hsv.s + sat_shift)),
            fminf(1.0F, fmaxf(0.0F, base_hsv.v + val_shift))};

        Color c = hsvToRgb(adjusted);
        result[i] = c;
        result[2 * COLOR_CYCLE_SIZE - 1 - i] = c;  // espejo
    }

    return result;
}