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
	{
		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 mText; // Variable con todos los objetos de texto

	struct menu
	{
		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 mMenu; // Variable con todos los objetos menus y sus variables

	struct intro
	{
		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 mIntro; // Contiene todas las variables de la sección 'Intro'

	struct game
	{
		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 stage;								 // Pantalla actual
		Uint8 stageCounter;							 // Contador para el tiempo visible del texto de Stage
		float stagePath[STAGE_COUNTER];				 // Vector con los puntos Y por donde pasará la etiqueta
		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 menaceLevelCurrent;					 // Nivel de amenaza actual
		Uint8 menaceLevelThreshold;					 // 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
		SmartSprite *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
		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
		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
	};
	game mGame; // Variable con todas las variables usadas durante el juego

	struct title
	{
		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 mTitle; // Variable con todas las variables de la pantalla de titulo

	struct demo
	{
		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 keys;						// Variable con las pulsaciones de teclas del modo demo
		DemoKeys dataFile[TOTAL_DEMO_DATA]; // Datos del fichero con los movimientos para la demo
	};
	demo mDemo; // Variable con todas las variables relacionadas con el modo demo

	struct options
	{
		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 mOptions; // Variable con todas las variables de las opciones del programa

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

	struct prog
	{
		bool debug;					// Indica si se va a mostrar la información de debug
		bool quit;					// Indica si hay que salir del programa
		Input keyboard;				// Almacena los códigos de teclado correspondientes
		Input 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 mProg; // Contiene todas las variables globales del programa

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

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

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

	struct resourceTexture
	{
		std::string file;  // Ruta al fichero
		LTexture *texture; // Variable con la textura
	};
	resourceTexture 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);

	// 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 el valor de la variable mStage
	void updateStage();

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

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

	// Mueve todos los globos activos
	void moveBalloons();

	// 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, Uint16 stoppedcounter, LTexture *texture);

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

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

	// Explosiona todos los globos
	void popAllBalloons();

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

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

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

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

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

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

	// Activa el modo Demo
	void enableDemoMode();

	// Desactiva el modo Demo
	void disableDemoMode();

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

#endif