coffee_crisis_opendingux_dev/source/gamedirector.h

#pragma once
#include "ifdefs.h"
#include "sprite.h"
#include "movingsprite.h"
#include "smartsprite.h"
#include "player.h"
#include "balloon.h"
#include "bullet.h"
#include "coffeedrop.h"
#include "item.h"
#include "text.h"
#include "text2.h"
#include "menu.h"
#include "const.h"
#include "jail_audio.h"
#include "utils.h"
#include <math.h>

#ifndef GAMEDIRECTOR_H
#define GAMEDIRECTOR_H

// GameDirector
class GameDirector
{
private:
	SDL_Window *mWindow;	  // La ventana donde dibujamos
	SDL_Renderer *mRenderer;  // El renderizador de la ventana
	SDL_Event *mEventHandler; // Manejador de eventos

	SDL_Texture *mBackbuffer;		   // Textura para usar como backbuffer
	SDL_Texture *mTitleSurface;		   // Textura para dibujar el fondo de la pantalla de título
	SDL_Texture *mInstructionsSurface; // Textura donde dibujar las instrucciones

	SDL_Joystick *mGameController; // Manejador para el mando 1
	SDL_Haptic *mControllerHaptic; // Manejador para el mando con vibración
	bool mGameControllerFound;	   // Variable para saber si hay un mando conectado

#ifndef UNUSED
	CoffeeDrop *mCoffeeDrop[MAX_COFFEE_DROPS]; // Vector con todas ls gotas de café;
#endif

	struct text_t
	{
		Text *white;   // Texto blanco de 8x8
		Text *whiteX2; // Texto blanco de 16x16
		Text *black;   // Texto negro de 8x8
		Text *blackX2; // Texto negro de 16x16
		Text *nokia;   // Texto de anchura variable y 10px de alto
	};
	text_t mText; // Variable con todos los objetos de texto

	struct menu_t
	{
		Menu *title;	 // Menu de la pantalla de título
		Menu *pause;	 // Menú de la pantalla de pausa
		Menu *gameOver;	 // Menú de la pantalla de game over
		Menu *options;	 // Menú de la pantalla de opciones
		Menu *active;	 // Menu activo (de momento para la pantalla del titulo)
		bool keyPressed; // Variable para evitar la repetición de teclas en los menus
	};
	menu_t mMenu; // Variable con todos los objetos menus y sus variables

	struct intro_t
	{
		SmartSprite *bitmap[INTRO_TOTAL_BITMAPS]; // Vector con los sprites inteligentes para los dibujos de la intro
		Text2 *text[INTRO_TOTAL_TEXTS];			  // Textos de la intro
		Uint8 events[INTRO_TOTAL_EVENTS];		  // Vector para coordinar los eventos de la intro
	};
	intro_t mIntro; // Contiene todas las variables de la sección 'Intro'

	struct enemyInits_t
	{
		int x;					// Posición en el eje X donde crear al enemigo
		int y;					// Posición en el eje Y donde crear al enemigo
		float velX;				// Velocidad inicial en el eje X
		Uint8 kind;				// Tipo de enemigo
		Uint16 creationCounter; // Temporizador para la creación del enemigo
	};

	struct enemyFormation_t // Contiene la información de una formación enemiga
	{
		Uint8 numberOfEnemies; // Cantidad de enemigos que forman la formación
		enemyInits_t init[50]; // Vector con todas las inicializaciones de los enemigos de la formación
	};
	enemyFormation_t mEnemyFormation[100]; // Vector con todas las formaciones enemigas

	struct enemyPool_t
	{
		enemyFormation_t *set[10]; // Conjunto de formaciones enemigas
	};
	enemyPool_t mEnemyPool[10]; // Variable con los diferentes conjuntos de formaciones enemigas

	struct stage_t // Contiene todas las variables relacionadas con una fase
	{
		enemyPool_t *enemyPool; // El conjunto de formaciones enemigas de la fase
		Uint16 currentPower;	// Cantidad actual de poder
		Uint16 powerToComplete; // Cantidad de poder que se necesita para completar la fase
		Uint8 maxMenace;		// Umbral máximo de amenaza de la fase
		Uint8 minMenace;		// Umbral mínimo de amenaza de la fase
		Uint8 number;			// Numero de fase
	};

	struct effect_t
	{
		bool flash;			// Indica si se ha de pintar la pantalla de blanco
		bool shake;			// Indica si se ha de agitar la pantalla
		Uint8 shakeCounter; // Contador para medir el tiempo que dura el efecto
	};

	struct game_t
	{
		Uint32 score;								 // Puntuación actual
		Uint32 hiScore;								 // Puntuación máxima
		Uint8 section;								 // Seccion actual dentro del juego
		bool hiScoreAchieved;						 // Indica si se ha superado la puntuación máxima
		Uint8 currentStage;							 // Indica la fase actual
		stage_t stage[10];							 // Variable con los datos de cada pantalla
		Uint8 stageBitmapCounter;					 // Contador para el tiempo visible del texto de Stage
		float stageBitmapPath[STAGE_COUNTER];		 // Vector con los puntos Y por donde se desplaza el texto
		float getReadyBitmapPath[STAGE_COUNTER];	 // Vector con los puntos X por donde se desplaza el texto
		Uint16 deathCounter;						 // Contador para la animación de muerte del jugador
		Uint8 deathIndex;							 // Indice del vector de smartsprites que contiene el sprite del jugador
		Uint8 menaceCurrent;						 // Nivel de amenaza actual
		Uint8 menaceThreshold;						 // Umbral del nivel de amenaza. Si el nivel de amenaza cae por debajo del umbral, se generan más globos. Si el umbral aumenta, aumenta el numero de globos
		bool timeStopped;							 // Indica si el tiempo está detenido
		Uint16 timeStoppedCounter;					 // Temporizador para llevar la cuenta del tiempo detenido
		Uint8 remainingExplosions;					 // Cantidad de explosiones restantes
		Uint16 remainingExplosionsCounter;			 // Temporizador para la cantidad de explosiones restantes
		bool explosionTime;							 // Indica si las explosiones estan en marcha
		Uint32 counter;								 // Contador para el juego
		Uint32 scoreDataFile[TOTAL_SCORE_DATA];		 // Datos del fichero de puntos
		Sprite *getReadyBitmap;						 // Sprite para el texto de GetReady del principio de la partida
		SmartSprite *_1000Bitmap;					 // Sprite con el texto 1.000
		SmartSprite *_2500Bitmap;					 // Sprite con el texto 2.500
		SmartSprite *_5000Bitmap;					 // Sprite con el texto 5.000
		Sprite *background;							 // Sprite con los graficos frontales del fondo
		Sprite *gradient;							 // Sprite con los graficos del degradado de color de fondo
		SDL_Rect gradientRect[4];					 // Vector con las coordenadas de los 4 gradientes
		Uint16 balloonsPopped;						 // Lleva la cuenta de los globos explotados
		MovingSprite *clouds1a;						 // Sprite para las nubes superiores
		MovingSprite *clouds1b;						 // Sprite para las nubes superiores
		MovingSprite *clouds2a;						 // Sprite para las nubes inferiores
		MovingSprite *clouds2b;						 // Sprite para las nubes inferiores
		Sprite *grass;								 // Sprite para la hierba
		Sprite *scoreBoard;							 // Sprite para el fondo del marcador
		Sprite *powerMeter;							 // Sprite para el medidor de poder de la fase
		Player *player;								 // El jugador
		Balloon *balloon[MAX_BALLOONS];				 // Vector con los objetos globo
		Bullet *bullet[MAX_BULLETS];				 // Vector con los objetos bala
		Item *item[MAX_ITEMS];						 // Vector con los objetos item
		SmartSprite *smartSprite[MAX_SMART_SPRITES]; // Vector para almacenar y gestionar SmartSprites
		Uint8 lastEnemyDeploy;						 // Guarda cual ha sido la última formación desplegada para no repetir;
		Uint8 enemyDeployCounter;					 // Cuando se lanza una formación, se le da un valor y no sale otra hasta que llegue a cero
		float enemySpeed;							 // Velocidad a la que se mueven los enemigos
		effect_t effect;							 // Variable para gestionar los efectos visuales
	};
	game_t mGame; // Variable con todas las variables usadas durante el juego

	struct title_t
	{
		Uint16 counter;					  // Temporizador para la pantalla de titulo
		Uint16 backgroundCounter;		  // Temporizador para el fondo de tiles de la pantalla de titulo
		Uint8 backgroundMode;			  // Variable para almacenar el tipo de efecto que hará el fondo de la pantalla de titulo
		bool menuVisible;				  // Indicador para saber si se muestra el menu del titulo o la frase intermitente
		Sprite *tile;					  // Sprite para dibujar el fondo de pantalla del título
		SDL_Rect backgroundWindow;		  // Ventana visible para la textura de fondo del titulo
		Uint8 section;					  // Indicador para el bucle del titulo
		Uint8 nextProgSection;			  // Indica cual es la siguiente sección a cargar cuando termine el contador del titulo
		Uint8 events[TITLE_TOTAL_EVENTS]; // Vector para coordinar los eventos de la pantalla de titulo
		Uint16 instructionsCounter;		  // Contador para las instrucciones
		SmartSprite *coffeeBitmap;		  // Sprite con la palabra COFFEE para la pantalla de titulo
		SmartSprite *crisisBitmap;		  // Sprite con la palabra CRISIS para la pantalla de titulo
		AnimatedSprite *dustBitmapL;	  // Sprite con la el polvo que aparece al colisionar el texto de la pantalla de titulo
		AnimatedSprite *dustBitmapR;	  // Sprite con la el polvo que aparece al colisionar el texto de la pantalla de titulo
	};
	title_t mTitle; // Variable con todas las variables de la pantalla de titulo

	struct demo_t
	{
		bool enabled;						  // Indica si está activo el modo demo
		bool recording;						  // Indica si está activado el modo para grabar la demo
		Uint16 counter;						  // Contador para el modo demo
		demoKeys_t keys;					  // Variable con las pulsaciones de teclas del modo demo
		demoKeys_t dataFile[TOTAL_DEMO_DATA]; // Datos del fichero con los movimientos para la demo
	};
	demo_t mDemo; // Variable con todas las variables relacionadas con el modo demo

	struct options_t
	{
		Uint32 fullScreenMode; // Contiene el valor del modo de pantalla completa
		Uint32 fullScreenModePrevious;
		Uint8 windowSize; // Contiene el valor del tamaño de la ventana
		Uint8 windowSizePrevious;
		bool displayCoffeeDrops; // Indica si se han de mostar las gotas de cafe
	};
	options_t mOptions; // Variable con todas las variables de las opciones del programa

	struct logo_t
	{
		Uint16 counter; // Contador
		Sprite *sprite; // Sprite con la textura del logo
	};
	logo_t mLogo; // Variable con las variables para el logo

	struct prog_t
	{
		bool quit;					// Indica si hay que salir del programa
		input_t keyboard;			// Almacena los códigos de teclado correspondientes
		input_t keyboardBuffer;		// Buffer para teclas pulsadas
		std::string executablePath; // Path del ejecutable
		Uint32 ticks;				// Contador de ticks para ajustar la velocidad del programa
		Uint8 section;				// Sección actual del programa;
		Uint8 subsection;			// Subseccion dentro de la sección;
		Uint8 ticksSpeed;			// Velocidad a la que se repiten los bucles del programa
	};
	prog_t mProg; // Contiene todas las variables globales del programa

	struct debug_t
	{
		bool enabled;			   // Indica si se va a mostrar la información de debug
		Uint8 enemySet;			   // Escoge el set enemigo a generar
		Uint8 gradR, gradG, gradB; // Colores RGB para modificar el color del gradiente de fondo
		float hudW, hudH;		   // Multiplica el tamaño del hud de debug;
	};
	debug_t mDebug;

	struct resourceBinFile_t
	{
		std::string file; // Ruta al fichero
	};
	resourceBinFile_t mBinFile[TOTAL_BINFILE]; // Todos los ficheros binarios

	struct resourceSound_t
	{
		std::string file; // Ruta al fichero
		JA_Sound sound;	  // Variable con el sonido
	};
	resourceSound_t mSound[TOTAL_SOUND]; // Todos los sonidos

	struct resourceMusic_t
	{
		std::string file; // Ruta al fichero
		JA_Music music;	  // Variable con la música
	};
	resourceMusic_t mMusic[TOTAL_MUSIC]; // Todas las músicas

	struct resourceTexture_t
	{
		std::string file;  // Ruta al fichero
		LTexture *texture; // Variable con la textura
	};
	resourceTexture_t mTexture[TOTAL_TEXTURE]; // Todos los gráficos

public:
	// Constructor
	GameDirector(std::string path);

	// Destructor
	~GameDirector();

	// Inicia las variables necesarias para arrancar el programa
	void initProg();

	// Carga los recursos necesarios para el programa
	bool loadMediaProg();

	// Libera las variables del programa
	void quitProg();

	// Inicializa jail_audio
	void initJailAudio();

	// Arranca SDL y crea la ventana
	bool initSDL();

	// Inicializa el vector con los valores del seno
	void initSin();

	// Inicializa las variables que contienen puntos de ruta para mover objetos
	void initPaths();

	// Inicializa las variables necesarias para la sección 'Logo'
	void initLogo();

	// Carga los recursos necesarios para la sección 'Logo'
	bool loadMediaLogo();

	// Libera las variables necesarias para la sección 'Logo'
	void quitLogo();

	// Inicializa las variables necesarias para la sección 'Intro'
	void initIntro();

	// Carga los recursos necesarios para la sección 'Intro'
	bool loadMediaIntro();

	// Libera las variables necesarias para la sección 'Intro'
	void quitIntro();

	// Inicializa las variables necesarias para la sección 'Title'
	void initTitle(Uint8 subsection = TITLE_SECTION_1);

	// Carga los recursos necesarios para la sección 'Title'
	bool loadMediaTitle();

	// Libera las variables necesarias para la sección 'Title'
	void quitTitle();

	// Inicializa las variables necesarias para la sección 'Game'
	void initGame();

	// Inicializa las variables especificas de la sección 'Game' para empezar una nueva partida
	void resetGame();

	// Carga los recursos necesarios para la sección 'Game'
	bool loadMediaGame();

	// Libera las variables necesarias para la sección 'Game'
	void quitGame();

	// Crea el indice de ficheros
	void setFileList();

	// Comprueba que todos los ficheros existen
	bool checkFileList();

	// Carga el fichero de puntos
	bool loadScoreFile();

	// Carga el fichero de configuración
	bool loadConfigFile();

	// Carga el fichero de datos para la demo
	bool loadDemoFile();

	// Guarda el fichero de puntos
	bool saveScoreFile();

	// Guarda el fichero de configuración
	bool saveConfigFile();

	// Guarda el fichero de datos para la demo
	bool saveDemoFile();

	// Carga un archivo de imagen en una textura
	bool loadTextureFromFile(LTexture *texture, std::string path, SDL_Renderer *renderer);

	// Comprueba el valor de la variable 'quit'
	bool exit();

	// Establece el valor de la variable
	void setExecutablePath(std::string path);

	// Inicializa las formaciones enemigas
	void initEnemyFormations();

	// Inicializa los conjuntos de formaciones
	void initEnemyPools();

	// Inicializa las fases del juego
	void initGameStages();

	// Crea una formación de enemigos
	void deployEnemyFormation();

	// Aumenta el poder de la fase
	void increaseStageCurrentPower();

	// Establece el valor de la variable
	void setScore(Uint32 score);

	// Establece el valor de la variable
	void setHiScore(Uint32 score);

	// Actualiza el valor de HiScore en caso necesario
	void updateHiScore();

	// Transforma un valor numérico en una cadena de 6 cifras
	std::string updateScoreText(Uint32 num);

	// Pinta el marcador en pantalla usando un objeto texto
	void renderScoreBoard();

	// Actualiza las variables del jugador
	void updatePlayer();

	// Actualiza las variables de la fase
	void updateStage();

	// Actualiza el estado de muerte
	void updateDeath();

	// Renderiza el fade final cuando se acaba la partida
	void renderDeathFade();

	// Actualiza los globos
	void updateBalloons();

	// Pinta en pantalla todos los globos activos
	void renderBalloons();

	// Devuelve el primer indice no activo del vector de globos
	Uint8 getBalloonFreeIndex();

	// Crea un globo nuevo en el vector de globos
	Uint8 createNewBalloon(float x, int y, Uint8 kind, float velx, float speed, Uint16 stoppedcounter, LTexture *texture);

	// Crea una PowerBall
	void createPowerBall();

	// Establece a cero todos los valores del vector de objetos globo
	void resetBalloons();

	// Establece la velocidad de los globos
	void setBalloonSpeed(float speed);

	// Incrementa la velocidad de los globos
	void incBalloonSpeed();

	// Decrementa la velocidad de los globos
	void decBalloonSpeed();

	// Actualiza la velocidad de los globos en funcion del poder acumulado de la fase
	void updateBalloonSpeed();

	// Explosiona un globo. Lo destruye y crea otros dos si es el caso
	void popBalloon(Uint8 index);

	// Explosiona un globo. Lo destruye
	void destroyBalloon(Uint8 index);

	// Explosiona todos los globos
	void popAllBalloons();

	// Destruye todos los globos
	void destroyAllBalloons();

	// Detiene todos los globos
	void stopAllBalloons(Uint16 time);

	// Pone en marcha todos los globos
	void startAllBalloons();

	// Obtiene el numero de globos activos
	Uint8 countBalloons();

	// Comprueba la colisión entre el jugador y los globos activos
	bool checkPlayerBalloonCollision();

	// Comprueba la colisión entre el jugador y los items
	void checkPlayerItemCollision();

	// Comprueba la colisión entre las balas y los globos
	void checkBulletBalloonCollision();

	// Mueve las balas activas
	void moveBullets();

	// Pinta las balas activas
	void renderBullets();

	// Devuelve el primer indice no activo del vector de balas
	Uint8 getBulletFreeIndex();

	// Establece a cero todos los valores del vector de objetos bala
	void resetBullets();

	// Crea un objeto bala
	void createBullet(int x, int y, Uint8 kind);

	// Actualiza los items
	void updateItems();

	// Pinta los items activos
	void renderItems();

	// Devuelve el primer indice no activo del vector de items
	Uint8 getItemFreeIndex();

	// Establece a cero todos los valores del vector de objetos item
	void resetItems();

	// Devuelve un item en función del azar
	Uint8 dropItem();

	// Crea un objeto item
	void createItem(int x, int y, Uint8 kind);

	// Crea un objeto SmartSprite
	void createItemScoreSprite(int x, int y, SmartSprite *sprite);

	// Crea un objeto de bonus en función del azar
	void dropBonus();

	// Dibuja el efecto de flash
	void renderFlashEffect();

	// Actualiza el efecto de agitar la pantalla
	void updateShakeEffect();

	// Crea un SmartSprite para arrojar el item café al recibir un impacto
	void throwCoffee(int x, int y);

	// Crea un SmartSprite para arrojar al jugador al morir
	void throwPlayer(int x, int y);

	// Actualiza los SmartSprites
	void updateSmartSprites();

	// Pinta los SmartSprites activos
	void renderSmartSprites();

	// Devuelve el primer indice no activo del vector de SmartSprites
	Uint8 getSmartSpriteFreeIndex();

	// Establece a cero todos los valores del vector de objetos SmafrtSprite
	void resetSmartSprites();

#ifndef UNUSED
	// Deshabilita todas las gotas de café
	void resetCoffeeDrops();

	// Actualiza las gotas de cafe
	void updateCoffeeDrops();

	// Dibuja las gotas de cafe
	void renderCoffeeDrops();

	// Devuelve el primer indice libre del vector de CoffeeDrops
	Uint8 getCoffeDropFreeIndex();

	// Crea un numero de gotas de cafe
	void createCoffeDrops(Uint8 num, int x, int y);
#endif
	// Acciones a realizar cuando el jugador muere
	void killPlayer();

	// Obtiene el valor de la variable
	Uint8 getSubsection();

	// Calcula y establece el valor de amenaza en funcion de los globos activos
	void setMenace();

	// Obtiene el valor de la variable
	Uint8 getMenace();

	// Establece el valor de la variable
	void setTimeStopped(bool value);

	// Obtiene el valor de la variable
	bool isTimeStopped();

	// Establece el valor de la variable
	void setTimeStoppedCounter(Uint16 value);

	// Actualiza la variable EnemyDeployCounter
	void updateEnemyDeployCounter();

	// Actualiza y comprueba el valor de la variable
	void updateTimeStoppedCounter();

	// Establece el valor de la variable
	void setExplosionTime(bool value);

	// Obtiene el valor de la variable
	bool isExplosionTime();

	// Establece el valor de la variable
	void setRemainingExplosions(Uint8 value);

	// Actualiza y comprueba el valor de la variable
	void updateRemainingExplosionsCounter();

	// Gestiona el nivel de amenaza
	void old_updateMenace();

	// Gestiona el nivel de amenaza
	void updateMenace();

	// Actualiza el campo de juego
	void updatePlayField();

	// Actualiza el fondo
	void updateBackground();

	// Dibuja el fondo
	void renderBackground();

	// Dibuja el campo de juego
	void renderPlayField();

	// Gestiona las entradas desde el mando de juego
	bool checkGameController(Uint8 state);

	// Gestiona la entrada durante el juego
	void checkGameInput();

	// Gestiona la entrada de teclado y mando durante el menu
	void checkMenuInput(Menu *menu);

	// Obtiene el valor de la variable
	Uint8 getProgSection();

	// Establece el valor de la variable
	void setProgSection(Uint8 section, Uint8 subsection = 0);

	// Pinta una transición en pantalla
	void renderFade(Uint8 index);

	// Pinta diferentes mensajes en la pantalla
	void renderMessages();

	// Habilita el efecto del item de detener el tiempo
	void enableTimeStopItem();

	// Deshabilita el efecto del item de detener el tiempo
	void disableTimeStopItem();

	// Cambia el valor de la variable de modo de pantalla completa
	void changeFullScreenMode();

	// Actualiza los elementos del menu de opciones
	void updateOptionsMenu();

	// Agita la pantalla
	void shakeScreen();

	// Agita la pantalla
	void shakeScreen2();

	// Bucle para el logo del juego
	void runLogo();

	// Bucle para la intro del juego
	void runIntro();

	// Bucle para el titulo del juego
	void runTitle(Uint8 subsection = TITLE_SECTION_1);

	// Bucle para el juego
	void runGame();

	// Bucle para el menu de pausa del juego
	void runPausedGame();

	// Bucle para la pantalla de instrucciones
	void runInstructions();

	// Bucle para la pantalla de game over
	void runGameOverScreen();

	// Activa el modo Demo
	void enableDemoMode();

	// Desactiva el modo Demo
	void disableDemoMode();

	// Intercambia el proximo estado del juego despues del titulo
	void toogleTitleNextGS();

	// Dibuja la informacion de debug en pantalla
	void renderDebugInfo();
};

#endif