#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 #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