redistribuida la carpeta source

source/utils/defines.hpp

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <SDL3/SDL.h>
+
+#include <string>
+
+#include "utils/utils.hpp"
+
+// Textos
+constexpr const char* WINDOW_CAPTION = "JailDoctor's Dilemma";
+constexpr const char* TEXT_COPYRIGHT = "@2022 JailDesigner";
+constexpr const char* VERSION = "1.10";
+
+// Velocidad del juego
+constexpr Uint32 GAME_SPEED = 15;
+
+// Tamaño de bloque
+constexpr int BLOCK = 8;
+constexpr int HALF_BLOCK = 4;
+
+// Tamaño de la pantalla virtual
+constexpr int GAMECANVAS_WIDTH = 256;
+constexpr int GAMECANVAS_HEIGHT = 192;
+
+// Zona de juego
+constexpr int PLAY_AREA_TOP = (0 * BLOCK);
+constexpr int PLAY_AREA_BOTTOM = (16 * BLOCK);
+constexpr int PLAY_AREA_LEFT = (0 * BLOCK);
+constexpr int PLAY_AREA_RIGHT = (32 * BLOCK);
+constexpr int PLAY_AREA_WIDTH = PLAY_AREA_RIGHT - PLAY_AREA_LEFT;
+constexpr int PLAY_AREA_HEIGHT = PLAY_AREA_BOTTOM - PLAY_AREA_TOP;
+constexpr int PLAY_AREA_CENTER_X = PLAY_AREA_LEFT + (PLAY_AREA_WIDTH / 2);
+constexpr int PLAY_AREA_CENTER_FIRST_QUARTER_X = (PLAY_AREA_WIDTH / 4);
+constexpr int PLAY_AREA_CENTER_THIRD_QUARTER_X = (PLAY_AREA_WIDTH / 4) * 3;
+constexpr int PLAY_AREA_CENTER_Y = PLAY_AREA_TOP + (PLAY_AREA_HEIGHT / 2);
+constexpr int PLAY_AREA_FIRST_QUARTER_Y = PLAY_AREA_HEIGHT / 4;
+constexpr int PLAY_AREA_THIRD_QUARTER_Y = (PLAY_AREA_HEIGHT / 4) * 3;
+
+// Anclajes de pantalla
+constexpr int GAMECANVAS_CENTER_X = GAMECANVAS_WIDTH / 2;
+constexpr int GAMECANVAS_FIRST_QUARTER_X = GAMECANVAS_WIDTH / 4;
+constexpr int GAMECANVAS_THIRD_QUARTER_X = (GAMECANVAS_WIDTH / 4) * 3;
+constexpr int GAMECANVAS_CENTER_Y = GAMECANVAS_HEIGHT / 2;
+constexpr int GAMECANVAS_FIRST_QUARTER_Y = GAMECANVAS_HEIGHT / 4;
+constexpr int GAMECANVAS_THIRD_QUARTER_Y = (GAMECANVAS_HEIGHT / 4) * 3;

source/utils/global_events.cpp

@@ -0,0 +1,24 @@
+#include "utils/global_events.hpp"
+#include "game/gameplay/options.hpp" // Para Options, options, OptionsGame, OptionsAudio
+#include "core/input/mouse.hpp"
+
+namespace globalEvents
+{
+    // Comprueba los eventos que se pueden producir en cualquier sección del juego
+    void check(const SDL_Event &event)
+    {
+        // Evento de salida de la aplicación
+        if (event.type == SDL_EVENT_QUIT)
+        {
+            options.section.section = Section::QUIT;
+            return;
+        }
+
+        if (event.type == SDL_EVENT_RENDER_DEVICE_RESET || event.type == SDL_EVENT_RENDER_TARGETS_RESET)
+        {
+            // reLoadTextures();
+        }
+
+        Mouse::handleEvent(event);
+    }
+}

source/utils/global_events.hpp

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <SDL3/SDL.h>  
+
+namespace globalEvents {
+// Comprueba los eventos que se pueden producir en cualquier sección del juego
+void check(const SDL_Event& event);
+}  // namespace globalEvents

source/utils/utils.cpp

@@ -0,0 +1,460 @@
+#include "utils/utils.hpp"
+
+#include <stdlib.h>  // Para abs
+
+#include <algorithm>      // Para find, transform
+#include <cctype>         // Para tolower
+#include <cmath>          // Para round, abs
+#include <exception>      // Para exception
+#include <filesystem>     // Para path
+#include <iostream>       // Para basic_ostream, cout, basic_ios, ios, endl
+#include <string>         // Para basic_string, string, char_traits, allocator
+#include <unordered_map>  // Para unordered_map, operator==, _Node_const_iter...
+#include <utility>        // Para pair
+
+#include "external/jail_audio.h"  // Para JA_GetMusicState, JA_Music_state, JA_PlayMusic
+#include "core/resources/resource.hpp"             // Para Resource
+
+// Calcula el cuadrado de la distancia entre dos puntos
+double distanceSquared(int x1, int y1, int x2, int y2) {
+    const int deltaX = x2 - x1;
+    const int deltaY = y2 - y1;
+    return deltaX * deltaX + deltaY * deltaY;
+}
+
+// Detector de colisiones entre dos circulos
+bool checkCollision(const Circle& a, const Circle& b) {
+    // Calcula el radio total al cuadrado
+    int totalRadiusSquared = a.r + b.r;
+    totalRadiusSquared = totalRadiusSquared * totalRadiusSquared;
+
+    // Si la distancia entre el centro de los circulos es inferior a la suma de sus radios
+    if (distanceSquared(a.x, a.y, b.x, b.y) < (totalRadiusSquared)) {
+        // Los circulos han colisionado
+        return true;
+    }
+
+    // En caso contrario
+    return false;
+}
+
+// Detector de colisiones entre un circulo y un rectangulo
+bool checkCollision(const Circle& a, const SDL_FRect& rect) {
+    SDL_Rect b = toSDLRect(rect);
+    // Closest point on collision box
+    int cX, cY;
+
+    // Find closest x offset
+    if (a.x < b.x) {
+        cX = b.x;
+    } else if (a.x > b.x + b.w) {
+        cX = b.x + b.w;
+    } else {
+        cX = a.x;
+    }
+
+    // Find closest y offset
+    if (a.y < b.y) {
+        cY = b.y;
+    } else if (a.y > b.y + b.h) {
+        cY = b.y + b.h;
+    } else {
+        cY = a.y;
+    }
+
+    // If the closest point is inside the circle_t
+    if (distanceSquared(a.x, a.y, cX, cY) < a.r * a.r) {
+        // This box and the circle_t have collided
+        return true;
+    }
+
+    // If the shapes have not collided
+    return false;
+}
+
+// Detector de colisiones entre dos rectangulos
+bool checkCollision(const SDL_FRect& rect_a, const SDL_FRect& rect_b) {
+    SDL_Rect a = toSDLRect(rect_a);
+    SDL_Rect b = toSDLRect(rect_b);
+    // Calcula las caras del rectangulo a
+    const int leftA = a.x;
+    const int rightA = a.x + a.w;
+    const int topA = a.y;
+    const int bottomA = a.y + a.h;
+
+    // Calcula las caras del rectangulo b
+    const int leftB = b.x;
+    const int rightB = b.x + b.w;
+    const int topB = b.y;
+    const int bottomB = b.y + b.h;
+
+    // Si cualquiera de las caras de a está fuera de b
+    if (bottomA <= topB) {
+        return false;
+    }
+
+    if (topA >= bottomB) {
+        return false;
+    }
+
+    if (rightA <= leftB) {
+        return false;
+    }
+
+    if (leftA >= rightB) {
+        return false;
+    }
+
+    // Si ninguna de las caras está fuera de b
+    return true;
+}
+
+// Detector de colisiones entre un punto y un rectangulo
+bool checkCollision(const SDL_FPoint& point, const SDL_FRect& rect) {
+    SDL_Rect r = toSDLRect(rect);
+    SDL_Point p = toSDLPoint(point);
+
+    // Comprueba si el punto está a la izquierda del rectangulo
+    if (p.x < r.x) {
+        return false;
+    }
+
+    // Comprueba si el punto está a la derecha del rectangulo
+    if (p.x > r.x + r.w) {
+        return false;
+    }
+
+    // Comprueba si el punto está por encima del rectangulo
+    if (p.y < r.y) {
+        return false;
+    }
+
+    // Comprueba si el punto está por debajo del rectangulo
+    if (p.y > r.y + r.h) {
+        return false;
+    }
+
+    // Si no está fuera, es que está dentro
+    return true;
+}
+
+// Detector de colisiones entre una linea horizontal y un rectangulo
+bool checkCollision(const LineHorizontal& l, const SDL_FRect& rect) {
+    SDL_Rect r = toSDLRect(rect);
+    // Comprueba si la linea esta por encima del rectangulo
+    if (l.y < r.y) {
+        return false;
+    }
+
+    // Comprueba si la linea esta por debajo del rectangulo
+    if (l.y >= r.y + r.h) {
+        return false;
+    }
+
+    // Comprueba si el inicio de la linea esta a la derecha del rectangulo
+    if (l.x1 >= r.x + r.w) {
+        return false;
+    }
+
+    // Comprueba si el final de la linea esta a la izquierda del rectangulo
+    if (l.x2 < r.x) {
+        return false;
+    }
+
+    // Si ha llegado hasta aquí, hay colisión
+    return true;
+}
+
+// Detector de colisiones entre una linea vertical y un rectangulo
+bool checkCollision(const LineVertical& l, const SDL_FRect& rect) {
+    SDL_Rect r = toSDLRect(rect);
+    // Comprueba si la linea esta por la izquierda del rectangulo
+    if (l.x < r.x) {
+        return false;
+    }
+
+    // Comprueba si la linea esta por la derecha del rectangulo
+    if (l.x >= r.x + r.w) {
+        return false;
+    }
+
+    // Comprueba si el inicio de la linea esta debajo del rectangulo
+    if (l.y1 >= r.y + r.h) {
+        return false;
+    }
+
+    // Comprueba si el final de la linea esta encima del rectangulo
+    if (l.y2 < r.y) {
+        return false;
+    }
+
+    // Si ha llegado hasta aquí, hay colisión
+    return true;
+}
+
+// Detector de colisiones entre una linea horizontal y un punto
+bool checkCollision(const LineHorizontal& l, const SDL_FPoint& point) {
+    SDL_Point p = toSDLPoint(point);
+
+    // Comprueba si el punto esta sobre la linea
+    if (p.y > l.y) {
+        return false;
+    }
+
+    // Comprueba si el punto esta bajo la linea
+    if (p.y < l.y) {
+        return false;
+    }
+
+    // Comprueba si el punto esta a la izquierda de la linea
+    if (p.x < l.x1) {
+        return false;
+    }
+
+    // Comprueba si el punto esta a la derecha de la linea
+    if (p.x > l.x2) {
+        return false;
+    }
+
+    // Si ha llegado aquí, hay colisión
+    return true;
+}
+
+// Detector de colisiones entre dos lineas
+SDL_Point checkCollision(const Line& l1, const Line& l2) {
+    const float x1 = l1.x1;
+    const float y1 = l1.y1;
+    const float x2 = l1.x2;
+    const float y2 = l1.y2;
+
+    const float x3 = l2.x1;
+    const float y3 = l2.y1;
+    const float x4 = l2.x2;
+    const float y4 = l2.y2;
+
+    // calculate the direction of the lines
+    float uA = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) / ((y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1));
+    float uB = ((x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3)) / ((y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1));
+
+    // if uA and uB are between 0-1, lines are colliding
+    if (uA >= 0 && uA <= 1 && uB >= 0 && uB <= 1) {
+        // Calcula la intersección
+        const float x = x1 + (uA * (x2 - x1));
+        const float y = y1 + (uA * (y2 - y1));
+
+        return {static_cast<int>(round(x)), static_cast<int>(round(y))};
+    }
+    return {-1, -1};
+}
+
+// Detector de colisiones entre dos lineas
+SDL_Point checkCollision(const LineDiagonal& l1, const LineVertical& l2) {
+    const float x1 = l1.x1;
+    const float y1 = l1.y1;
+    const float x2 = l1.x2;
+    const float y2 = l1.y2;
+
+    const float x3 = l2.x;
+    const float y3 = l2.y1;
+    const float x4 = l2.x;
+    const float y4 = l2.y2;
+
+    // calculate the direction of the lines
+    float uA = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) / ((y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1));
+    float uB = ((x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3)) / ((y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1));
+
+    // if uA and uB are between 0-1, lines are colliding
+    if (uA >= 0 && uA <= 1 && uB >= 0 && uB <= 1) {
+        // Calcula la intersección
+        const float x = x1 + (uA * (x2 - x1));
+        const float y = y1 + (uA * (y2 - y1));
+
+        return {static_cast<int>(x), static_cast<int>(y)};
+    }
+    return {-1, -1};
+}
+
+// Normaliza una linea diagonal
+void normalizeLine(LineDiagonal& l) {
+    // Las lineas diagonales van de izquierda a derecha
+    // x2 mayor que x1
+    if (l.x2 < l.x1) {
+        const int x = l.x1;
+        const int y = l.y1;
+        l.x1 = l.x2;
+        l.y1 = l.y2;
+        l.x2 = x;
+        l.y2 = y;
+    }
+}
+
+// Detector de colisiones entre un punto y una linea diagonal
+bool checkCollision(const SDL_FPoint& point, const LineDiagonal& l) {
+    SDL_Point p = toSDLPoint(point);
+
+    // Comprueba si el punto está en alineado con la linea
+    if (abs(p.x - l.x1) != abs(p.y - l.y1)) {
+        return false;
+    }
+
+    // Comprueba si está a la derecha de la linea
+    if (p.x > l.x1 && p.x > l.x2) {
+        return false;
+    }
+
+    // Comprueba si está a la izquierda de la linea
+    if (p.x < l.x1 && p.x < l.x2) {
+        return false;
+    }
+
+    // Comprueba si está por encima de la linea
+    if (p.y > l.y1 && p.y > l.y2) {
+        return false;
+    }
+
+    // Comprueba si está por debajo de la linea
+    if (p.y < l.y1 && p.y < l.y2) {
+        return false;
+    }
+
+    // En caso contrario, el punto está en la linea
+    return true;
+}
+
+// Convierte una cadena a un indice de la paleta
+Uint8 stringToColor(const std::string& str) {
+    // Mapas de colores para cada paleta
+    static const std::unordered_map<std::string, Uint8> paletteMap = {
+        {"black", 0},
+        {"bright_black", 1},
+
+        {"blue", 2},
+        {"bright_blue", 3},
+
+        {"red", 4},
+        {"bright_red", 5},
+
+        {"magenta", 6},
+        {"bright_magenta", 7},
+
+        {"green", 8},
+        {"bright_green", 9},
+
+        {"cyan", 10},
+        {"bright_cyan", 11},
+
+        {"yellow", 12},
+        {"bright_yellow", 13},
+
+        {"white", 14},
+        {"bright_white", 15},
+
+        {"transparent", 255}};
+
+    // Busca el color en el mapa
+    auto it = paletteMap.find(str);
+    if (it != paletteMap.end()) {
+        return it->second;
+    } else {
+        // Si no se encuentra el color, devolvemos negro por defecto
+        return 0;
+    }
+}
+
+// Convierte una cadena a un entero de forma segura
+int safeStoi(const std::string& value, int defaultValue) {
+    try {
+        return std::stoi(value);
+    } catch (const std::exception&) {
+        return defaultValue;
+    }
+}
+
+// Convierte una cadena a un booleano
+bool stringToBool(const std::string& str) {
+    std::string lowerStr = str;
+    std::transform(lowerStr.begin(), lowerStr.end(), lowerStr.begin(), ::tolower);
+    return (lowerStr == "true" || lowerStr == "1" || lowerStr == "yes" || lowerStr == "on");
+}
+
+// Convierte un booleano a una cadena
+std::string boolToString(bool value) {
+    return value ? "1" : "0";
+}
+
+// Compara dos colores
+bool colorAreEqual(Color color1, Color color2) {
+    const bool r = color1.r == color2.r;
+    const bool g = color1.g == color2.g;
+    const bool b = color1.b == color2.b;
+
+    return (r && g && b);
+}
+
+// Función para convertir un string a minúsculas
+std::string toLower(const std::string& str) {
+    std::string lower_str = str;
+    std::transform(lower_str.begin(), lower_str.end(), lower_str.begin(), ::tolower);
+    return lower_str;
+}
+
+// Función para convertir un string a mayúsculas
+std::string toUpper(const std::string& str) {
+    std::string upper_str = str;
+    std::transform(upper_str.begin(), upper_str.end(), upper_str.begin(), ::toupper);
+    return upper_str;
+}
+
+// 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();
+}
+
+// Imprime por pantalla una linea de texto de tamaño fijo rellena con puntos
+void printWithDots(const std::string& text1, const std::string& text2, const std::string& text3) {
+    std::cout.setf(std::ios::left, std::ios::adjustfield);
+    std::cout << text1;
+
+    std::cout.width(50 - text1.length() - text3.length());
+    std::cout.fill('.');
+    std::cout << text2;
+
+    std::cout << text3 << std::endl;
+}
+
+// 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();
+}
+
+// Hace sonar la música
+void playMusic(const std::string& music_path) {
+    // Si la música no está sonando
+    if (JA_GetMusicState() == JA_MUSIC_INVALID || JA_GetMusicState() == JA_MUSIC_STOPPED) {
+        JA_PlayMusic(Resource::get()->getMusic(music_path));
+    }
+}
+
+// Rellena una textura de un color
+void fillTextureWithColor(SDL_Renderer* renderer, SDL_Texture* texture, Uint8 r, Uint8 g, Uint8 b, Uint8 a) {
+    // Guardar el render target actual
+    SDL_Texture* previous_target = SDL_GetRenderTarget(renderer);
+
+    // Establecer la textura como el render target
+    SDL_SetRenderTarget(renderer, texture);
+
+    // Establecer el color deseado
+    SDL_SetRenderDrawColor(renderer, r, g, b, a);
+
+    // Pintar toda el área
+    SDL_RenderClear(renderer);
+
+    // Restaurar el render target previo
+    SDL_SetRenderTarget(renderer, previous_target);
+}

source/utils/utils.hpp

@@ -0,0 +1,171 @@
+#pragma once
+
+#include <SDL3/SDL.h>
+
+#include <string>  // Para string
+#include <vector>  // Para vector
+
+enum class PaletteColor : Uint8 {
+    BLACK = 0,
+    BRIGHT_BLACK = 1,
+
+    BLUE = 2,
+    BRIGHT_BLUE = 3,
+
+    RED = 4,
+    BRIGHT_RED = 5,
+
+    MAGENTA = 6,
+    BRIGHT_MAGENTA = 7,
+
+    GREEN = 8,
+    BRIGHT_GREEN = 9,
+
+    CYAN = 10,
+    BRIGHT_CYAN = 11,
+
+    YELLOW = 12,
+    BRIGHT_YELLOW = 13,
+
+    WHITE = 14,
+    BRIGHT_WHITE = 15,
+
+    TRANSPARENT = 255,
+};
+
+// Estructura para definir un circulo
+struct Circle {
+        int x;
+        int y;
+        int r;
+};
+
+// Estructura para definir una linea horizontal
+struct LineHorizontal {
+        int x1, x2, y;
+};
+
+// Estructura para definir una linea vertical
+struct LineVertical {
+        int x, y1, y2;
+};
+
+// Estructura para definir una linea diagonal
+struct LineDiagonal {
+        int x1, y1, x2, y2;
+};
+
+// Estructura para definir una linea
+struct Line {
+        int x1, y1, x2, y2;
+};
+
+// Estructura para definir un color
+struct Color {
+        Uint8 r;
+        Uint8 g;
+        Uint8 b;
+
+        // Constructor por defecto
+        Color()
+            : r(0),
+              g(0),
+              b(0) {}
+
+        // Constructor
+        Color(Uint8 red, Uint8 green, Uint8 blue)
+            : r(red),
+              g(green),
+              b(blue) {}
+};
+
+// Calcula el cuadrado de la distancia entre dos puntos
+double distanceSquared(int x1, int y1, int x2, int y2);
+
+// Detector de colisiones entre dos circulos
+bool checkCollision(const Circle& a, const Circle& b);
+
+// Detector de colisiones entre un circulo y un rectangulo
+bool checkCollision(const Circle& a, const SDL_FRect& b);
+
+// Detector de colisiones entre un dos rectangulos
+bool checkCollision(const SDL_FRect& a, const SDL_FRect& b);
+
+// Detector de colisiones entre un punto y un rectangulo
+bool checkCollision(const SDL_FPoint& p, const SDL_FRect& r);
+
+// Detector de colisiones entre una linea horizontal y un rectangulo
+bool checkCollision(const LineHorizontal& l, const SDL_FRect& r);
+
+// Detector de colisiones entre una linea vertical y un rectangulo
+bool checkCollision(const LineVertical& l, const SDL_FRect& r);
+
+// Detector de colisiones entre una linea horizontal y un punto
+bool checkCollision(const LineHorizontal& l, const SDL_FPoint& p);
+
+// Detector de colisiones entre dos lineas
+SDL_Point checkCollision(const Line& l1, const Line& l2);
+
+// Detector de colisiones entre dos lineas
+SDL_Point checkCollision(const LineDiagonal& l1, const LineVertical& l2);
+
+// Detector de colisiones entre un punto y una linea diagonal
+bool checkCollision(const SDL_FPoint& p, const LineDiagonal& l);
+
+// Normaliza una linea diagonal
+void normalizeLine(LineDiagonal& l);
+
+// Devuelve un Color a partir de un string
+Uint8 stringToColor(const std::string& str);
+
+// Convierte una cadena a un entero de forma segura
+int safeStoi(const std::string& value, int defaultValue = 0);
+
+// Convierte una cadena a un booleano
+bool stringToBool(const std::string& str);
+
+// Convierte un booleano a una cadena
+std::string boolToString(bool value);
+
+// Compara dos colores
+bool colorAreEqual(Color color1, Color color2);
+
+// Convierte una cadena a minusculas
+std::string toLower(const std::string& str);
+
+// Convierte una cadena a mayúsculas
+std::string toUpper(const std::string& str);
+
+// Obtiene el nombre de un fichero a partir de una ruta
+std::string getFileName(const std::string& path);
+
+// Obtiene la ruta eliminando el nombre del fichero
+std::string getPath(const std::string& full_path);
+
+// Imprime por pantalla una linea de texto de tamaño fijo rellena con puntos
+void printWithDots(const std::string& text1, const std::string& text2, const std::string& text3);
+
+// Comprueba si una vector contiene una cadena
+bool stringInVector(const std::vector<std::string>& vec, const std::string& str);
+
+// Hace sonar la música
+void playMusic(const std::string& music_path);
+
+// Rellena una textura de un color
+void fillTextureWithColor(SDL_Renderer* renderer, SDL_Texture* texture, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
+
+inline SDL_Rect toSDLRect(const SDL_FRect& frect) {
+    SDL_Rect rect;
+    rect.x = static_cast<int>(frect.x);
+    rect.y = static_cast<int>(frect.y);
+    rect.w = static_cast<int>(frect.w);
+    rect.h = static_cast<int>(frect.h);
+    return rect;
+}
+
+inline SDL_Point toSDLPoint(const SDL_FPoint& fpoint) {
+    SDL_Point point;
+    point.x = static_cast<int>(fpoint.x);
+    point.y = static_cast<int>(fpoint.y);
+    return point;
+}