v1.4

source/gamedirector.h

@@ -39,7 +39,7 @@ private:
 	CoffeeDrop *mCoffeeDrop[MAX_COFFEE_DROPS]; // Vector con todas ls gotas de café;
 #endif
 
-	struct text
+	struct text_t
 	{
 		Text *white;   // Texto blanco de 8x8
 		Text *whiteX2; // Texto blanco de 16x16
@@ -47,9 +47,9 @@ private:
 		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
+	text_t mText; // Variable con todos los objetos de texto
 
-	struct menu
+	struct menu_t
 	{
 		Menu *title;	 // Menu de la pantalla de título
 		Menu *pause;	 // Menú de la pantalla de pausa
@@ -58,29 +58,70 @@ private:
 		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
+	menu_t mMenu; // Variable con todos los objetos menus y sus variables
 
-	struct intro
+	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 mIntro; // Contiene todas las variables de la sección 'Intro'
+	intro_t mIntro; // Contiene todas las variables de la sección 'Intro'
 
-	struct game
+	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 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
+		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 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
+		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
@@ -88,26 +129,34 @@ private:
 		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
+		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 mGame; // Variable con todas las variables usadas durante el juego
+	game_t mGame; // Variable con todas las variables usadas durante el juego
 
-	struct title
+	struct title_t
 	{
 		Uint16 counter;					  // Temporizador para la pantalla de titulo
 		Uint16 backgroundCounter;		  // Temporizador para el fondo de tiles de la pantalla de titulo
@@ -124,19 +173,19 @@ private:
 		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
+	title_t mTitle; // Variable con todas las variables de la pantalla de titulo
 
-	struct demo
+	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 keys;						// Variable con las pulsaciones de teclas del modo demo
-		DemoKeys dataFile[TOTAL_DEMO_DATA]; // Datos del fichero con los movimientos para la 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_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 mDemo; // Variable con todas las variables relacionadas con el modo demo
+	demo_t mDemo; // Variable con todas las variables relacionadas con el modo demo
 
-	struct options
+	struct options_t
 	{
 		Uint32 fullScreenMode; // Contiene el valor del modo de pantalla completa
 		Uint32 fullScreenModePrevious;
@@ -144,55 +193,63 @@ private:
 		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
+	options_t mOptions; // Variable con todas las variables de las opciones del programa
 
-	struct logo
+	struct logo_t
 	{
 		Uint16 counter; // Contador
 		Sprite *sprite; // Sprite con la textura del logo
 	};
-	logo mLogo; // Variable con las variables para el logo
+	logo_t mLogo; // Variable con las variables para el logo
 
-	struct prog
+	struct prog_t
 	{
-		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
+		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 mProg; // Contiene todas las variables globales del programa
+	prog_t mProg; // Contiene todas las variables globales del programa
 
-	struct resourceBinFile
+	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 mBinFile[TOTAL_BINFILE]; // Todos los ficheros binarios
+	resourceBinFile_t mBinFile[TOTAL_BINFILE]; // Todos los ficheros binarios
 
-	struct resourceSound
+	struct resourceSound_t
 	{
 		std::string file; // Ruta al fichero
 		JA_Sound sound;	  // Variable con el sonido
 	};
-	resourceSound mSound[TOTAL_SOUND]; // Todos los sonidos
+	resourceSound_t mSound[TOTAL_SOUND]; // Todos los sonidos
 
-	struct resourceMusic
+	struct resourceMusic_t
 	{
 		std::string file; // Ruta al fichero
 		JA_Music music;	  // Variable con la música
 	};
-	resourceMusic mMusic[TOTAL_MUSIC]; // Todas las músicas
+	resourceMusic_t mMusic[TOTAL_MUSIC]; // Todas las músicas
 
-	struct resourceTexture
+	struct resourceTexture_t
 	{
 		std::string file;  // Ruta al fichero
 		LTexture *texture; // Variable con la textura
 	};
-	resourceTexture mTexture[TOTAL_TEXTURE]; // Todos los gráficos
+	resourceTexture_t mTexture[TOTAL_TEXTURE]; // Todos los gráficos
 
 public:
 	// Constructor
@@ -294,6 +351,21 @@ public:
 	// 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);
 
@@ -309,7 +381,10 @@ public:
 	// Pinta el marcador en pantalla usando un objeto texto
 	void renderScoreBoard();
 
-	// Actualiza el valor de la variable mStage
+	// Actualiza las variables del jugador
+	void updatePlayer();
+
+	// Actualiza las variables de la fase
 	void updateStage();
 
 	// Actualiza el estado de muerte
@@ -318,8 +393,8 @@ public:
 	// Renderiza el fade final cuando se acaba la partida
 	void renderDeathFade();
 
-	// Mueve todos los globos activos
-	void moveBalloons();
+	// Actualiza los globos
+	void updateBalloons();
 
 	// Pinta en pantalla todos los globos activos
 	void renderBalloons();
@@ -328,17 +403,38 @@ public:
 	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);
+	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);
 
@@ -393,6 +489,15 @@ public:
 	// 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);
 
@@ -434,10 +539,10 @@ public:
 	Uint8 getSubsection();
 
 	// Calcula y establece el valor de amenaza en funcion de los globos activos
-	void setMenaceLevel();
+	void setMenace();
 
 	// Obtiene el valor de la variable
-	Uint8 getMenaceLevel();
+	Uint8 getMenace();
 
 	// Establece el valor de la variable
 	void setTimeStopped(bool value);
@@ -448,6 +553,9 @@ public:
 	// 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();
 
@@ -464,7 +572,10 @@ public:
 	void updateRemainingExplosionsCounter();
 
 	// Gestiona el nivel de amenaza
-	void updateMenaceLevel();
+	void old_updateMenace();
+
+	// Gestiona el nivel de amenaza
+	void updateMenace();
 
 	// Actualiza el campo de juego
 	void updatePlayField();
@@ -514,6 +625,9 @@ public:
 	// Agita la pantalla
 	void shakeScreen();
 
+	// Agita la pantalla
+	void shakeScreen2();
+
 	// Bucle para el logo del juego
 	void runLogo();
 
@@ -535,9 +649,6 @@ public:
 	// Bucle para la pantalla de game over
 	void runGameOverScreen();
 
-	// Dibuja la informacion de debug en pantalla
-	void renderDebugInfo();
-
 	// Activa el modo Demo
 	void enableDemoMode();
 
@@ -546,6 +657,9 @@ public:
 
 	// Intercambia el proximo estado del juego despues del titulo
 	void toogleTitleNextGS();
+
+	// Dibuja la informacion de debug en pantalla
+	void renderDebugInfo();
 };
 
 #endif