coffee_crisis_arcade_edition/source/utils.h

#pragma once

#include <SDL2/SDL_gamecontroller.h> // para SDL_GameControllerButton
#include <SDL2/SDL_rect.h>			 // para SDL_Rect, SDL_Point
#include <SDL2/SDL_render.h>		 // para SDL_Renderer
#include <SDL2/SDL_stdinc.h>		 // para Uint8
#include <stdint.h>					 // para int32_t
#include <string>					 // para string
#include <vector>					 // para vector
enum class InputType : int;
enum class ScreenFilter;	// lines 14-14
enum class ScreenVideoMode; // lines 15-15
namespace lang
{
	enum class Code : int;
}
struct JA_Music_t; // lines 12-12
struct JA_Sound_t; // lines 13-13

// Constantes
constexpr int BLOCK = 8;
constexpr int TOTAL_DEMO_DATA = 2000;

// Dificultad del juego
enum class GameDifficulty
{
	EASY = 0,
	NORMAL = 1,
	HARD = 2,
};

// Variables para que los argumentos del programa tengan mas peso que los definidos en otros lugares
struct Overrides
{
	std::string param_file;	   // Fichero de parametros a utilizar
	bool clear_hi_score_table; // Reinicia la tabla de records
	bool set_v_sync;		   // Establece el vsync

	// Constructor por defecto
	Overrides()
		: param_file(""), clear_hi_score_table(false), set_v_sync(false) {}
};

extern Overrides overrides;

// Estructura para definir un circulo
struct Circle
{
	int x, y, r;

	// Constructor por defecto
	Circle() : x(0), y(0), r(0) {}

	// Constructor
	Circle(int xCoord, int yCoord, int radius)
		: x(xCoord), y(yCoord), r(radius) {}
};

// Estructura para definir un color
struct Color
{
	Uint8 r, g, b;
	constexpr Color() : r(0), g(0), b(0) {}
	explicit constexpr Color(int red, int green, int blue) : r(red), g(green), b(blue) {}
};

// Posiciones de las notificaciones
enum class NotifyPosition
{
	TOP,
	BOTTOM,
	LEFT,
	MIDDLE,
	RIGHT,
};

// Estructura para las entradas de la tabla de recirds
struct HiScoreEntry
{
	std::string name; // Nombre
	int score;		  // Puntuación

	// Constructor
	explicit HiScoreEntry(const std::string &n = "", int s = 0)
		: name(n), score(s) {}
};

struct DemoKeys
{
	Uint8 left;
	Uint8 right;
	Uint8 no_input;
	Uint8 fire;
	Uint8 fire_left;
	Uint8 fire_right;

	// Constructor que inicializa todos los campos
	explicit DemoKeys(Uint8 l = 0, Uint8 r = 0, Uint8 ni = 0, Uint8 f = 0, Uint8 fl = 0, Uint8 fr = 0)
		: left(l), right(r), no_input(ni), fire(f), fire_left(fl), fire_right(fr) {}
};

using DemoData = std::vector<DemoKeys>;

struct Demo
{
	bool enabled;				// Indica si está activo el modo demo
	bool recording;				// Indica si está activado el modo para grabar la demo
	int counter;				// Contador para el modo demo
	DemoKeys keys;				// Variable con las pulsaciones de teclas del modo demo
	std::vector<DemoData> data; // Vector con diferentes sets de datos con los movimientos para la demo

	// Constructor por defecto
	Demo()
		: enabled(false), recording(false), counter(0), keys(), data() {}

	// Constructor con parámetros
	Demo(bool e, bool r, int c, const DemoKeys &k, const std::vector<DemoData> &d)
		: enabled(e), recording(r), counter(c), keys(k), data(d) {}
};

// Estructura para las opciones de la ventana
struct OptionsWindow
{
	int size; // Contiene el valor por el que se multiplica el tamaño de la ventana
};

// Estructura con opciones para el video
struct OptionsVideo
{
	OptionsWindow window; // Opciones para la ventana del programa
	ScreenVideoMode mode; // Contiene el valor del modo de pantalla completa
	ScreenFilter filter;  // Filtro usado para el escalado de la imagen
	bool v_sync;		  // Indica si se quiere usar vsync o no
	bool integer_scale;	  // Indica si se va a usar el escalado entero
	bool shaders;		  // Indica si se van a usar shaders para los filtros de video
};

// Estructura para las opciones de musica
struct OptionsMusic
{
	bool enabled; // Indica si la musica suena o no
	int volume;	  // Volumen al que suena la música
};

// Estructura para las opciones de sonido
struct OptionsSound
{
	bool enabled; // Indica si los sonidos suenan o no
	int volume;	  // Volumen al que suenan los sonidos
};

// Estructura para las opciones de audio
struct OptionsAudio
{
	OptionsMusic music; // Opciones para la música
	OptionsSound sound; // Opciones para los efectos de sonido
};

// Estructura para las opciones del juego
struct OptionsGame
{
	GameDifficulty difficulty;				  // Dificultad del juego
	lang::Code language;					  // Idioma usado en el juego
	bool autofire;							  // Indica si el jugador ha de pulsar repetidamente para disparar o basta con mantener pulsado
	std::vector<HiScoreEntry> hi_score_table; // Tabla con las mejores puntuaciones
};

// Estructura para los controles del juego
struct OptionsController
{
	int index;									   // Indice en el vector de mandos
	int player_id;								   // Jugador asociado al mando
	Uint8 device_type;							   // Indica si se utilizará teclado o mando o ambos
	std::string name;							   // Nombre del dispositivo
	bool plugged;								   // Indica si el mando se encuentra conectado
	std::vector<InputType> inputs;				   // Listado de inputs
	std::vector<SDL_GameControllerButton> buttons; // Listado de botones asignados a cada input
};

// Estructura con todas las opciones de configuración del programa
struct Options
{
	OptionsGame game;						   // Opciones para el propio juego
	OptionsVideo video;						   // Opciones relativas a la clase screen
	OptionsAudio audio;						   // Opciones para el audio
	std::vector<OptionsController> controller; // Opciones con las asignaciones del mando para cada jugador
};

// Posiciones dentro de un rectangulo
struct Zone
{
	SDL_Rect rect;		 // Rectangulo que define la zona
	int center_x;		 // Anclaje al 50% del eje X
	int first_quarter_x; // Anclaje al 25% del eje X
	int third_quarter_x; // Anclaje al 75% del eje X
	int center_y;		 // Anclaje al 50% del eje Y
	int first_quarter_y; // Anclaje al 25% del eje Y
	int third_quarter_y; // Anclaje al 75% del eje X
};

// param.game
struct ParamGame
{
	int width;				// Ancho de la resolucion nativa del juego
	int height;				// Alto de la resolucion nativa del juego
	int item_size;			// Tamaño de los items del juego
	Zone play_area;			// Rectangulo con la posición de la zona de juego
	Zone game_area;			// Rectangulo con las dimensiones del juego
	int enter_name_seconds; // Duración en segundos para introducir el nombre al finalizar la partida
};

// param.fade
struct ParamFade
{
	int num_squares_width;	  // Cantidad total de cuadraditos en horizontal para el FadeType::RANDOM_SQUARE
	int num_squares_height;	  // Cantidad total de cuadraditos en vertical para el FadeType::RANDOM_SQUARE
	int random_squares_delay; // Duración entre cada pintado de cuadrados
	int random_squares_mult;  // Cantidad de cuadrados que se pintaran cada vez
	int post_duration;		  // Duración final del fade
	int venetian_size;		  // Altura de los rectangulos para FadeType::VENETIAN
};

// param.title
struct ParamTitle
{
	int press_start_position;	 // Posición del texto para empezar a jugar
	int title_duration;			 // Tiempo de inactividad del titulo
	int arcade_edition_position; // Posición del bitmap
	int title_c_c_position;		 // Posición del bitmap
};

// param.background
struct ParamBackground
{
	Color attenuate_color;
	int attenuate_alpha;
};

// Estructura para guardar los parametros de un globo
struct ParamBalloon
{
	float grav; // Aceleración en el eje Y. Modifica la velocidad
	float vel;	// Velocidad inicial que tienen al rebotar contra el suelo
};

// Estructura para las opciones de las notificaciones
struct ParamNotification
{
	NotifyPosition pos_h; // Ubicación de las notificaciones en pantalla
	NotifyPosition pos_v; // Ubicación de las notificaciones en pantalla
	bool sound;			  // Indica si las notificaciones suenan
	Color color;		  // Color de las notificaciones
};

// Estructura para almacenar todos los parámetros del juego
struct Param
{
	ParamGame game;											 // Parametros relacionados con el juego
	ParamFade fade;											 // Parametros para ajustar el fade
	SDL_Rect scoreboard;									 // Posición y tamaño del marcador
	ParamTitle title;										 // Parametros con ajustes para la sección Title
	ParamBackground background;								 // Parametros que afectan a la clase Background
	ParamBalloon balloon_1, balloon_2, balloon_3, balloon_4; // Parametros de velocidad y gravedad de cada tipo de globo
	ParamNotification notification;							 // Opciones para las notificaciones
};

// 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_Rect &b);

// Detector de colisiones entre un dos rectangulos
bool checkCollision(const SDL_Rect &a, const SDL_Rect &b);

// Detector de colisiones entre un punto y un rectangulo
bool checkCollision(const SDL_Point &p, const SDL_Rect &r);

// Convierte una cadena en un valor booleano
bool stringToBool(const std::string &str);

// Convierte un valor booleano en una cadena
std::string boolToString(bool value);

// Convierte un valor booleano en una cadena "on" o "off"
std::string boolToOnOff(bool value);

// Convierte una cadena a minusculas
std::string toLower(const std::string &str);

// Dibuja un circulo
void DrawCircle(SDL_Renderer *renderer, int32_t centerX, int32_t centerY, int32_t radius);

// Aclara el color
Color lightenColor(const Color &color, int amount);

// Oscurece el color
Color DarkenColor(const Color &color, int amount);

// Quita los espacioes en un string
std::string trim(const std::string &str);

// Función de suavizado
double easeOutQuint(double t);

// Función de suavizado
double easeInOutSine(double t);

// Comprueba si una vector contiene una cadena
bool stringInVector(const std::vector<std::string> &vec, const std::string &str);

// 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);

// Carga el fichero de datos para la demo
DemoData loadDemoDataFromFile(const std::string &file_path);

#ifdef RECORDING
// Guarda el fichero de datos para la demo
bool saveDemoFile(const std::string &file_path, const DemoData &dd);
#endif

// 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);

// Colores
extern const Color bg_color;
extern const Color no_color;
extern const Color shdw_txt_color;
extern const Color separator_color;
extern const Color scoreboard_easy_color;
extern const Color scoreboard_normal_color;
extern const Color scoreboard_hard_color;
extern const Color flash_color;
extern const Color fade_color;
extern const Color orange_color;