coffee_crisis_arcade_edition/source/utils.h

#pragma once

#include <SDL2/SDL.h>
#include "texture.h"
#include "jail_audio.h"
#include "input.h"
#include <string>
#include <vector>

// Dificultad del juego
#define DIFFICULTY_EASY 0
#define DIFFICULTY_NORMAL 1
#define DIFFICULTY_HARD 2

// Estructura para definir un circulo
struct circle_t
{
	int x;
	int y;
	int r;
};

// Estructura para definir una linea horizontal
struct h_line_t
{
	int x1, x2, y;
};

// Estructura para definir una linea vertical
struct v_line_t
{
	int x, y1, y2;
};

// Estructura para definir una linea diagonal
struct d_line_t
{
	int x1, y1, x2, y2;
};

// Estructura para definir una linea
struct line_t
{
	int x1, y1, x2, y2;
};

// Estructura para definir un color
struct color_t
{
	Uint8 r;
	Uint8 g;
	Uint8 b;
};

// Posiciones de las notificaciones
enum not_pos_e
{
	pos_top,
	pos_bottom,
	pos_left,
	pos_middle,
	pos_right
};

// Estructura para saber la seccion y subseccion del programa
struct section_t
{
	Uint8 name;
	Uint8 options;
};

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

// Estructura para mapear el teclado usado en la demo
struct demoKeys_t
{
	Uint8 left;
	Uint8 right;
	Uint8 noInput;
	Uint8 fire;
	Uint8 fireLeft;
	Uint8 fireRight;
};

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

// Estructura con opciones para el video
struct op_video_t
{
	int gameWidth;		// Ancho de la resolucion nativa del juego
	int gameHeight;		// Alto de la resolucion nativa del juego
	op_window_t window; // Opciones para la ventana del programa
	Uint32 mode;		// Contiene el valor del modo de pantalla completa
	Uint32 filter;		// Filtro usado para el escalado de la imagen
	bool vSync;			// Indica si se quiere usar vsync o no
	bool integerScale;	// Indica si el escalado de la imagen ha de ser entero en el modo a pantalla completa
	bool keepAspect;	// Indica si se ha de mantener la relación de aspecto al poner el modo a pantalla completa
	bool shaders;		// Indica si se van a usar shaders para los filtros de video
};

// Estructura para las opciones de musica
struct op_music_t
{
	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 op_sound_t
{
	bool enabled; // Indica si los sonidos suenan o no
	int volume;	  // Volumen al que suenan los sonidos
};

// Estructura para las opciones de audio
struct op_audio_t
{
	op_music_t music; // Opciones para la música
	op_sound_t sound; // Opciones para los efectos de sonido
};

// Estructura para las opciones del juego
struct op_game_t
{
	Uint8 difficulty;						  // Dificultad del juego
	Uint8 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_t> hiScoreTable; // Tabla con las mejores puntuaciones
};

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

// Estructura para las opciones de las notificaciones
struct op_notification_t
{
	not_pos_e posH; // Ubicación de las notificaciones en pantalla
	not_pos_e posV; // Ubicación de las notificaciones en pantalla
	bool sound;		// Indica si las notificaciones suenan
	color_t color;	// Color de las notificaciones
};

// Estructura con todas las opciones de configuración del programa
struct options_t
{
	bool console;							 // Indica si ha de mostrar información por la consola de texto
	op_game_t game;							 // Opciones para el propio juego
	op_video_t video;						 // Opciones relativas a la clase screen
	op_audio_t audio;						 // Opciones para el audio
	op_notification_t notification;			 // Opciones para las notificaciones
	std::vector<op_controller_t> controller; // Opciones con las asignaciones del mando para cada jugador
};

// Posiciones dentro de un rectangulo
struct zone_t
{
	SDL_Rect rect;	   // Rectangulo que define la zona
	int centerX;	   // Anclaje al 50% del eje X
	int firstQuarterX; // Anclaje al 25% del eje X
	int thirdQuarterX; // Anclaje al 75% del eje X
	int centerY;	   // Anclaje al 50% del eje Y
	int firstQuarterY; // Anclaje al 25% del eje Y
	int thirdQuarterY; // Anclaje al 75% del eje X
};

// param.game
struct paramGame_t
{
	int width;		 // Ancho de la resolucion nativa del juego
	int height;		 // Alto de la resolucion nativa del juego
	int itemSize;	 // Tamaño de los items del juego
	zone_t playArea; // Rectangulo con la posición de la zona de juego
	zone_t gameArea; // Rectangulo con las dimensiones del juego
};

// param.fade
struct paramFade_t
{
	int numSquaresWidth;	// Cantidad total de cuadraditos en horizontal para el FADE_RANDOM_SQUARE
	int numSquaresHeight;	// Cantidad total de cuadraditos en vertical para el FADE_RANDOM_SQUARE
	int randomSquaresDelay; // Duración entre cada pintado de cuadrados
	int randomSquaresMult;	// Cantidad de cuadrados que se pintaran cada vez
	int postDuration;		// Duración final del fade
	int venetianSize;		// Altura de los rectangulos para FADE_VENETIAN
};

// param.title
struct paramTitle_t
{
	int pressStartPosition;	   // Posición del texto para empezar a jugar
	int titleDuration;		   // Tiempo de inactividad del titulo
	int arcadeEditionPosition; // Posición del bitmap
	int titleCCPosition;	   // Posición del bitmap
};

// param.background
struct paramBackground_t
{
	color_t attenuateColor;
	int attenuateAlpha;
};

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

// Estructura para almacenar todos los parámetros del juego
struct param_t
{
	paramGame_t game;									   // Parametros relacionados con el juego
	paramFade_t fade;									   // Parametros para ajustar el fade
	SDL_Rect scoreboard;								   // Posición y tamaño del marcador
	paramTitle_t title;									   // Parametros con ajustes para la sección Title
	paramBackground_t background;						   // Parametros que afectan a la clase Background
	paramBalloon_t balloon1, balloon2, balloon3, balloon4; // Parametros de velocidad y gravedad de cada tipo de globo
};

// Estructura para almacenar ficheros de sonido y su nombre
struct sound_file_t
{
	std::string name; // Nombre del sonido
	JA_Sound_t *file; // Fichero con el sonido
};

// Estructura para almacenar ficheros musicales y su nombre
struct music_file_t
{
	std::string name; // Nombre de la musica
	JA_Music_t *file; // Fichero con la música
};

// 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(circle_t &a, circle_t &b);

// Detector de colisiones entre un circulo y un rectangulo
bool checkCollision(circle_t &a, SDL_Rect &b);

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

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

// Convierte una cadena en un valor booleano
bool stringToBool(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(std::string str);

// Obtiene el fichero de sonido a partir de un nombre
JA_Sound_t *getSound(std::vector<sound_file_t> sounds, std::string name);

// Obtiene el fichero de música a partir de un nombre
JA_Music_t *getMusic(std::vector<music_file_t> music, std::string name);

// Ordena las entradas de la tabla de records
hiScoreEntry_t sortHiScoreTable(hiScoreEntry_t entry1, hiScoreEntry_t entry2);

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