607 lines
15 KiB
C++
607 lines
15 KiB
C++
#include "utils.h"
|
|
#include <stdlib.h> // for abs
|
|
#include <algorithm> // for find, transform
|
|
#include <cctype> // for tolower
|
|
#include <cmath> // for round, abs
|
|
#include <exception> // for exception
|
|
#include <filesystem> // for path
|
|
#include <iostream> // for basic_ostream, cout, basic_ios, ios, endl
|
|
#include <string> // for basic_string, string, char_traits, allocator
|
|
#include <unordered_map> // for unordered_map, operator==, _Node_const_iter...
|
|
#include <utility> // for pair
|
|
#include "jail_audio.h" // for JA_GetMusicState, JA_Music_state, JA_PlayMusic
|
|
#include "resource.h" // for 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_Rect &b)
|
|
{
|
|
// 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_Rect &a, const SDL_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_Point &p, const SDL_Rect &r)
|
|
{
|
|
// 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_Rect &r)
|
|
{
|
|
// 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_Rect &r)
|
|
{
|
|
// 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_Point &p)
|
|
{
|
|
// 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 {(int)round(x), (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 {(int)x, (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_Point &p, const LineDiagonal &l)
|
|
{
|
|
// 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 color
|
|
Color stringToColor(Palette pal, const std::string &str)
|
|
{
|
|
// Mapas de colores para cada paleta
|
|
static const std::unordered_map<std::string, Color> zxSpectrumColors = {
|
|
{"black", {0x00, 0x00, 0x00}},
|
|
{"bright_black", {0x00, 0x00, 0x00}},
|
|
{"blue", {0x00, 0x00, 0xD8}},
|
|
{"bright_blue", {0x00, 0x00, 0xFF}},
|
|
{"red", {0xD8, 0x00, 0x00}},
|
|
{"bright_red", {0xFF, 0x00, 0x00}},
|
|
{"magenta", {0xD8, 0x00, 0xD8}},
|
|
{"bright_magenta", {0xFF, 0x00, 0xFF}},
|
|
{"green", {0x00, 0xD8, 0x00}},
|
|
{"bright_green", {0x00, 0xFF, 0x00}},
|
|
{"cyan", {0x00, 0xD8, 0xD8}},
|
|
{"bright_cyan", {0x00, 0xFF, 0xFF}},
|
|
{"yellow", {0xD8, 0xD8, 0x00}},
|
|
{"bright_yellow", {0xFF, 0xFF, 0x00}},
|
|
{"white", {0xD8, 0xD8, 0xD8}},
|
|
{"bright_white", {0xFF, 0xFF, 0xFF}}};
|
|
|
|
static const std::unordered_map<std::string, Color> zxArneColors = {
|
|
{"black", {0x00, 0x00, 0x00}},
|
|
{"bright_black", {0x3C, 0x35, 0x1F}},
|
|
{"blue", {0x31, 0x33, 0x90}},
|
|
{"bright_blue", {0x15, 0x59, 0xDB}},
|
|
{"red", {0xA7, 0x32, 0x11}},
|
|
{"bright_red", {0xD8, 0x55, 0x25}},
|
|
{"magenta", {0xA1, 0x55, 0x89}},
|
|
{"bright_magenta", {0xCD, 0x7A, 0x50}},
|
|
{"green", {0x62, 0x9A, 0x31}},
|
|
{"bright_green", {0x9C, 0xD3, 0x3C}},
|
|
{"cyan", {0x28, 0xA4, 0xCB}},
|
|
{"bright_cyan", {0x65, 0xDC, 0xD6}},
|
|
{"yellow", {0xE8, 0xBC, 0x50}},
|
|
{"bright_yellow", {0xF1, 0xE7, 0x82}},
|
|
{"white", {0xBF, 0xBF, 0xBD}},
|
|
{"bright_white", {0xF2, 0xF1, 0xED}}};
|
|
|
|
// Selecciona el mapa de colores adecuado según la paleta
|
|
const std::unordered_map<std::string, Color> *paletteMap = nullptr;
|
|
|
|
if (pal == Palette::ZXSPECTRUM)
|
|
{
|
|
paletteMap = &zxSpectrumColors;
|
|
}
|
|
else if (pal == Palette::ZXARNE)
|
|
{
|
|
paletteMap = &zxArneColors;
|
|
}
|
|
else
|
|
{
|
|
// Paleta desconocida, devolvemos negro por defecto
|
|
return {0x00, 0x00, 0x00};
|
|
}
|
|
|
|
// 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 {0x00, 0x00, 0x00};
|
|
}
|
|
}
|
|
|
|
// 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", 1},
|
|
{"bright_black", 2},
|
|
{"blue", 3},
|
|
{"bright_blue", 4},
|
|
{"red", 5},
|
|
{"bright_red", 6},
|
|
{"magenta", 7},
|
|
{"bright_magenta", 8},
|
|
{"green", 9},
|
|
{"bright_green", 10},
|
|
{"cyan", 11},
|
|
{"bright_cyan", 12},
|
|
{"yellow", 13},
|
|
{"bright_yellow", 14},
|
|
{"white", 15},
|
|
{"bright_white", 16}};
|
|
|
|
// 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);
|
|
}
|
|
|
|
// Convierte una cadena a minúsculas
|
|
std::string toLower(std::string str)
|
|
{
|
|
for (char &c : str)
|
|
{
|
|
if (c >= 'A' && c <= 'Z')
|
|
{
|
|
c += 32; // Convierte a minúscula
|
|
}
|
|
}
|
|
return str;
|
|
}
|
|
|
|
// Convierte una cadena a mayúsculas
|
|
std::string toUpper(std::string str)
|
|
{
|
|
for (char &c : str)
|
|
{
|
|
if (c >= 'a' && c <= 'z')
|
|
{
|
|
c -= 32; // Convierte a mayúscula
|
|
}
|
|
}
|
|
return 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);
|
|
}
|
|
|
|
// Crea un SDL_Texture
|
|
SDL_Texture *createTexture(SDL_Renderer *renderer, int width, int height, Uint32 format, int access, bool logError)
|
|
{
|
|
// Crear la textura
|
|
SDL_Texture *texture = SDL_CreateTexture(renderer, format, access, width, height);
|
|
if (texture == nullptr)
|
|
{
|
|
// Registrar el error si está habilitado
|
|
if (logError)
|
|
{
|
|
std::cerr << "Error: Texture could not be created!\nSDL Error: " << SDL_GetError() << std::endl;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
return texture;
|
|
}
|