jaildesigner-jailgames/coffee-crisis
1
0
Fork 1
Code Issues Pull Requests Projects Releases 14 Wiki Activity

treball en curs: correccions de tidy

Browse Source
This commit is contained in:
Sergio Valor
2026-05-16 14:53:54 +02:00
parent be18f51735
commit b1392d0c00
6 changed files with 2101 additions and 2128 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/game/game.h
+139 -137
View File
@@ -54,14 +54,14 @@ class Game {
struct EnemyInit {
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
float vel_x; // Velocidad inicial en el eje X
Uint8 kind; // Tipo de enemigo
Uint16 creationCounter; // Temporizador para la creación del enemigo
Uint16 creation_counter; // Temporizador para la creación del enemigo
};
struct EnemyFormation // Contiene la información de una formación enemiga
{
Uint8 numberOfEnemies; // Cantidad de enemigos que forman la formación
Uint8 number_of_enemies; // Cantidad de enemigos que forman la formación
EnemyInit init[MAX_NUMBER_OF_ENEMIES_IN_A_FORMATION]; // Vector con todas las inicializaciones de los enemigos de la formación
};
@@ -71,51 +71,53 @@ class Game {
struct Stage // Contiene todas las variables relacionadas con una fase
{
EnemyPool *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
EnemyPool *enemy_pool; // El conjunto de formaciones enemigas de la fase
Uint16 current_power; // Cantidad actual de poder
Uint16 power_to_complete; // Cantidad de poder que se necesita para completar la fase
Uint8 max_menace; // Umbral máximo de amenaza de la fase
Uint8 min_menace; // Umbral mínimo de amenaza de la fase
Uint8 number; // Numero de fase
};
struct Effect {
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
Uint8 shake_counter; // Contador para medir el tiempo que dura el efecto
};
// Estado para el efecto de agitación intensa (muerte del jugador)
struct DeathShake {
bool active; // Indica si el efecto está activo
Uint8 step; // Paso actual del efecto (0-7)
Uint32 lastStepTicks; // Ticks del último paso
Uint32 last_step_ticks; // Ticks del último paso
};
// Fases de la secuencia de muerte del jugador
enum class DeathPhase : std::uint8_t { None,
Shaking,
Waiting,
Done };
enum class DeathPhase : std::uint8_t {
NONE,
SHAKING,
WAITING,
DONE
};
// Estado de la secuencia de muerte del jugador
struct DeathSequence {
DeathPhase phase; // Fase actual
Uint32 phaseStartTicks; // Ticks del inicio de la fase actual
Uint32 phase_start_ticks; // Ticks del inicio de la fase actual
Player *player; // Jugador que está muriendo
};
struct Helper {
bool needCoffee; // Indica si se necesitan cafes
bool needCoffeeMachine; // Indica si se necesita PowerUp
bool needPowerBall; // Indica si se necesita una PowerBall
bool need_coffee; // Indica si se necesitan cafes
bool need_coffee_machine; // Indica si se necesita PowerUp
bool need_power_ball; // Indica si se necesita una PowerBall
int counter; // Contador para no dar ayudas consecutivas
int itemPoints1Odds; // Probabilidad de aparición del objeto
int itemPoints2Odds; // Probabilidad de aparición del objeto
int itemPoints3Odds; // Probabilidad de aparición del objeto
int itemClockOdds; // Probabilidad de aparición del objeto
int itemCoffeeOdds; // Probabilidad de aparición del objeto
int itemCoffeeMachineOdds; // Probabilidad de aparición del objeto
int item_disk_odds; // Probabilidad de aparición del objeto
int item_gavina_odds; // Probabilidad de aparición del objeto
int item_paco_odds; // Probabilidad de aparición del objeto
int item_clock_odds; // Probabilidad de aparición del objeto
int item_coffee_odds; // Probabilidad de aparición del objeto
int item_coffee_machine_odds; // Probabilidad de aparición del objeto
};
struct Demo {
@@ -123,133 +125,133 @@ class Game {
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
DemoKeys data_file[TOTAL_DEMO_DATA]; // Datos del fichero con los movimientos para la demo
};
// Objetos y punteros
SDL_Renderer *renderer; // El renderizador de la ventana
Section *section; // Seccion actual dentro del juego
SDL_Renderer *renderer_; // El renderizador de la ventana
Section *section_; // Seccion actual dentro del juego
std::vector<Player *> players; // Vector con los jugadores
std::vector<Balloon *> balloons; // Vector con los globos
std::vector<Bullet *> bullets; // Vector con las balas
std::vector<Item *> items; // Vector con los items
std::vector<SmartSprite *> smartSprites; // Vector con los smartsprites
std::vector<Player *> players_; // Vector con los jugadores
std::vector<Balloon *> balloons_; // Vector con los globos
std::vector<Bullet *> bullets_; // Vector con las balas
std::vector<Item *> items_; // Vector con los items
std::vector<SmartSprite *> smart_sprites_; // Vector con los smartsprites
Texture *bulletTexture; // Textura para las balas
std::vector<Texture *> itemTextures; // Vector con las texturas de los items
std::vector<Texture *> balloonTextures; // Vector con las texturas de los globos
std::vector<Texture *> player1Textures; // Vector con las texturas del jugador
std::vector<Texture *> player2Textures; // Vector con las texturas del jugador
std::vector<std::vector<Texture *>> playerTextures; // Vector con todas las texturas de los jugadores;
Texture *bullet_texture_; // Textura para las balas
std::vector<Texture *> item_textures_; // Vector con las texturas de los items
std::vector<Texture *> balloon_textures_; // Vector con las texturas de los globos
std::vector<Texture *> player1_textures_; // Vector con las texturas del jugador
std::vector<Texture *> player2_textures_; // Vector con las texturas del jugador
std::vector<std::vector<Texture *>> player_textures_; // Vector con todas las texturas de los jugadores;
Texture *gameBuildingsTexture; // Textura con los edificios de fondo
Texture *gameCloudsTexture; // Textura con las nubes de fondo
Texture *gameGrassTexture; // Textura con la hierba del suelo
Texture *gamePowerMeterTexture; // Textura con el marcador de poder de la fase
Texture *gameSkyColorsTexture; // Textura con los diferentes colores de fondo del juego
Texture *gameTextTexture; // Textura para los sprites con textos
Texture *gameOverTexture; // Textura para la pantalla de game over
Texture *gameOverEndTexture; // Textura para la pantalla de game over de acabar el juego
Texture *game_buildings_texture_; // Textura con los edificios de fondo
Texture *game_clouds_texture_; // Textura con las nubes de fondo
Texture *game_grass_texture_; // Textura con la hierba del suelo
Texture *game_power_meter_texture_; // Textura con el marcador de poder de la fase
Texture *game_sky_colors_texture_; // Textura con los diferentes colores de fondo del juego
Texture *game_text_texture_; // Textura para los sprites con textos
Texture *game_over_texture_; // Textura para la pantalla de game over
Texture *game_over_end_texture_; // Textura para la pantalla de game over de acabar el juego
std::vector<std::vector<std::string> *> itemAnimations; // Vector con las animaciones de los items
std::vector<std::vector<std::string> *> playerAnimations; // Vector con las animaciones del jugador
std::vector<std::vector<std::string> *> balloonAnimations; // Vector con las animaciones de los globos
std::vector<std::vector<std::string> *> item_animations_; // Vector con las animaciones de los items
std::vector<std::vector<std::string> *> player_animations_; // Vector con las animaciones del jugador
std::vector<std::vector<std::string> *> balloon_animations_; // Vector con las animaciones de los globos
Text *text; // Fuente para los textos del juego
Text *textBig; // Fuente de texto grande
Text *textScoreBoard; // Fuente para el marcador del juego
Text *textNokia2; // Otra fuente de texto para mensajes
Text *textNokiaBig2; // Y la versión en grande
Text *text_; // Fuente para los textos del juego
Text *text_big_; // Fuente de texto grande
Text *text_scoreboard_; // Fuente para el marcador del juego
Text *text_nokia2_; // Otra fuente de texto para mensajes
Text *text_nokia_big2_; // Y la versión en grande
Menu *gameOverMenu; // Menú de la pantalla de game over
Menu *pauseMenu; // Menú de la pantalla de pausa
Menu *game_over_menu_; // Menú de la pantalla de game over
Menu *pause_menu_; // Menú de la pantalla de pausa
Fade *fade; // Objeto para renderizar fades
SDL_Event *eventHandler; // Manejador de eventos
Fade *fade_; // Objeto para renderizar fades
SDL_Event *event_handler_; // Manejador de eventos
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
SmartSprite *n1000Sprite; // Sprite con el texto 1.000
SmartSprite *n2500Sprite; // Sprite con el texto 2.500
SmartSprite *n5000Sprite; // Sprite con el texto 5.000
MovingSprite *clouds1_a_; // Sprite para las nubes superiores
MovingSprite *clouds1_b_; // Sprite para las nubes superiores
MovingSprite *clouds2_a_; // Sprite para las nubes inferiores
MovingSprite *clouds2_b_; // Sprite para las nubes inferiores
SmartSprite *n1000_sprite_; // Sprite con el texto 1.000
SmartSprite *n2500_sprite_; // Sprite con el texto 2.500
SmartSprite *n5000_sprite_; // Sprite con el texto 5.000
Sprite *buildingsSprite; // Sprite con los edificios de fondo
Sprite *skyColorsSprite; // Sprite con los graficos del degradado de color de fondo
Sprite *grassSprite; // Sprite para la hierba
Sprite *powerMeterSprite; // Sprite para el medidor de poder de la fase
Sprite *gameOverSprite; // Sprite para dibujar los graficos del game over
Sprite *gameOverEndSprite; // Sprite para dibujar los graficos del game over de acabar el juego
Sprite *buildings_sprite_; // Sprite con los edificios de fondo
Sprite *sky_colors_sprite_; // Sprite con los graficos del degradado de color de fondo
Sprite *grass_sprite_; // Sprite para la hierba
Sprite *power_meter_sprite_; // Sprite para el medidor de poder de la fase
Sprite *game_over_sprite_; // Sprite para dibujar los graficos del game over
Sprite *game_over_end_sprite_; // Sprite para dibujar los graficos del game over de acabar el juego
JA_Sound_t *balloonSound; // Sonido para la explosión del globo
JA_Sound_t *bulletSound; // Sonido para los disparos
JA_Sound_t *playerCollisionSound; // Sonido para la colisión del jugador con un enemigo
JA_Sound_t *hiScoreSound; // Sonido para cuando se alcanza la máxima puntuación
JA_Sound_t *itemDropSound; // Sonido para cuando se genera un item
JA_Sound_t *itemPickUpSound; // Sonido para cuando se recoge un item
JA_Sound_t *coffeeOutSound; // Sonido para cuando el jugador pierde el café al recibir un impacto
JA_Sound_t *stageChangeSound; // Sonido para cuando se cambia de fase
JA_Sound_t *bubble1Sound; // Sonido para cuando el jugador muere
JA_Sound_t *bubble2Sound; // Sonido para cuando el jugador muere
JA_Sound_t *bubble3Sound; // Sonido para cuando el jugador muere
JA_Sound_t *bubble4Sound; // Sonido para cuando el jugador muere
JA_Sound_t *clockSound; // Sonido para cuando se detiene el tiempo con el item reloj
JA_Sound_t *powerBallSound; // Sonido para cuando se explota una Power Ball
JA_Sound_t *coffeeMachineSound; // Sonido para cuando la máquina de café toca el suelo
JA_Sound_t *balloon_sound_; // Sonido para la explosión del globo
JA_Sound_t *bullet_sound_; // Sonido para los disparos
JA_Sound_t *player_collision_sound_; // Sonido para la colisión del jugador con un enemigo
JA_Sound_t *hi_score_sound_; // Sonido para cuando se alcanza la máxima puntuación
JA_Sound_t *item_drop_sound_; // Sonido para cuando se genera un item
JA_Sound_t *item_pick_up_sound_; // Sonido para cuando se recoge un item
JA_Sound_t *coffee_out_sound_; // Sonido para cuando el jugador pierde el café al recibir un impacto
JA_Sound_t *stage_change_sound_; // Sonido para cuando se cambia de fase
JA_Sound_t *bubble1_sound_; // Sonido para cuando el jugador muere
JA_Sound_t *bubble2_sound_; // Sonido para cuando el jugador muere
JA_Sound_t *bubble3_sound_; // Sonido para cuando el jugador muere
JA_Sound_t *bubble4_sound_; // Sonido para cuando el jugador muere
JA_Sound_t *clock_sound_; // Sonido para cuando se detiene el tiempo con el item reloj
JA_Sound_t *power_ball_sound_; // Sonido para cuando se explota una Power Ball
JA_Sound_t *coffee_machine_sound_; // Sonido para cuando la máquina de café toca el suelo
JA_Music_t *gameMusic; // Musica de fondo
JA_Music_t *game_music_; // Musica de fondo
// Variables
int numPlayers; // Numero de jugadores
Uint32 ticks; // Contador de ticks para ajustar la velocidad del programa
Uint8 ticksSpeed; // Velocidad a la que se repiten los bucles del programa
Uint32 hiScore; // Puntuación máxima
bool hiScoreAchieved; // Indica si se ha superado la puntuación máxima
std::string hiScoreName; // Nombre del jugador que ostenta la máxima puntuación
Stage stage[10]; // Variable con los datos de cada pantalla
Uint8 currentStage; // Indica la fase actual
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 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
Uint32 counter; // Contador para el juego
Uint32 scoreDataFile[TOTAL_SCORE_DATA]; // Datos del fichero de puntos
SDL_Rect skyColorsRect[4]; // Vector con las coordenadas de los 4 colores de cielo
Uint16 balloonsPopped; // Lleva la cuenta de los globos explotados
Uint8 lastEnemyDeploy; // Guarda cual ha sido la última formación desplegada para no repetir;
int 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
float defaultEnemySpeed; // Velocidad base de los enemigos, sin incrementar
Effect effect; // Variable para gestionar los efectos visuales
DeathShake deathShake; // Variable para gestionar el efecto de agitación intensa
DeathSequence deathSequence; // Variable para gestionar la secuencia de muerte
Helper helper; // Variable para gestionar las ayudas
bool powerBallEnabled; // Indica si hay una powerball ya activa
Uint8 powerBallCounter; // Contador de formaciones enemigas entre la aparicion de una PowerBall y otra
bool coffeeMachineEnabled; // Indica si hay una máquina de café en el terreno de juego
bool gameCompleted; // Indica si se ha completado la partida, llegando al final de la ultima pantalla
int gameCompletedCounter; // Contador para el tramo final, cuando se ha completado la partida y ya no aparecen más enemigos
Uint8 difficulty; // Dificultad del juego
float difficultyScoreMultiplier; // Multiplicador de puntos en función de la dificultad
Color difficultyColor; // Color asociado a la dificultad
Uint8 onePlayerControl; // Variable para almacenar el valor de las opciones
EnemyFormation enemyFormation[NUMBER_OF_ENEMY_FORMATIONS]; // Vector con todas las formaciones enemigas
EnemyPool enemyPool[10]; // Variable con los diferentes conjuntos de formaciones enemigas
Uint8 lastStageReached; // Contiene el numero de la última pantalla que se ha alcanzado
Demo demo; // Variable con todas las variables relacionadas con el modo demo
int totalPowerToCompleteGame; // La suma del poder necesario para completar todas las fases
int cloudsSpeed{0}; // Velocidad a la que se desplazan las nubes
int pauseCounter; // Contador para salir del menu de pausa y volver al juego
bool leavingPauseMenu; // Indica si esta saliendo del menu de pausa para volver al juego
bool pauseInitialized; // Indica si la pausa ha sido inicializada
bool gameOverInitialized; // Indica si el game over ha sido inicializado
int gameOverPostFade; // Opción a realizar cuando termina el fundido del game over
int num_players_; // Numero de jugadores
Uint32 ticks_; // Contador de ticks para ajustar la velocidad del programa
Uint8 ticks_speed_; // Velocidad a la que se repiten los bucles del programa
Uint32 hi_score_; // Puntuación máxima
bool hi_score_achieved_; // Indica si se ha superado la puntuación máxima
std::string hi_score_name_; // Nombre del jugador que ostenta la máxima puntuación
Stage stage_[10]; // Variable con los datos de cada pantalla
Uint8 current_stage_; // Indica la fase actual
Uint8 stage_bitmap_counter_; // Contador para el tiempo visible del texto de Stage
float stage_bitmap_path_[STAGE_COUNTER]; // Vector con los puntos Y por donde se desplaza el texto
float get_ready_bitmap_path_[STAGE_COUNTER]; // Vector con los puntos X por donde se desplaza el texto
Uint16 death_counter_; // Contador para la animación de muerte del jugador
Uint8 menace_current_; // Nivel de amenaza actual
Uint8 menace_threshold_; // 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 time_stopped_; // Indica si el tiempo está detenido
Uint16 time_stopped_counter_; // Temporizador para llevar la cuenta del tiempo detenido
Uint32 counter_; // Contador para el juego
Uint32 score_data_file_[TOTAL_SCORE_DATA]; // Datos del fichero de puntos
SDL_Rect sky_colors_rect_[4]; // Vector con las coordenadas de los 4 colores de cielo
Uint16 balloons_popped_; // Lleva la cuenta de los globos explotados
Uint8 last_enemy_deploy_; // Guarda cual ha sido la última formación desplegada para no repetir;
int enemy_deploy_counter_; // Cuando se lanza una formación, se le da un valor y no sale otra hasta que llegue a cero
float enemy_speed_; // Velocidad a la que se mueven los enemigos
float default_enemy_speed_; // Velocidad base de los enemigos, sin incrementar
Effect effect_; // Variable para gestionar los efectos visuales
DeathShake death_shake_; // Variable para gestionar el efecto de agitación intensa
DeathSequence death_sequence_; // Variable para gestionar la secuencia de muerte
Helper helper_; // Variable para gestionar las ayudas
bool power_ball_enabled_; // Indica si hay una powerball ya activa
Uint8 power_ball_counter_; // Contador de formaciones enemigas entre la aparicion de una PowerBall y otra
bool coffee_machine_enabled_; // Indica si hay una máquina de café en el terreno de juego
bool game_completed_; // Indica si se ha completado la partida, llegando al final de la ultima pantalla
int game_completed_counter_; // Contador para el tramo final, cuando se ha completado la partida y ya no aparecen más enemigos
Uint8 difficulty_; // Dificultad del juego
float difficulty_score_multiplier_; // Multiplicador de puntos en función de la dificultad
Color difficulty_color_; // Color asociado a la dificultad
Uint8 player_one_control_; // Variable para almacenar el valor de las opciones
EnemyFormation enemy_formation_[NUMBER_OF_ENEMY_FORMATIONS]; // Vector con todas las formaciones enemigas
EnemyPool enemy_pool_[10]; // Variable con los diferentes conjuntos de formaciones enemigas
Uint8 last_stage_reached_; // Contiene el numero de la última pantalla que se ha alcanzado
Demo demo_; // Variable con todas las variables relacionadas con el modo demo
int total_power_to_complete_game_; // La suma del poder necesario para completar todas las fases
int clouds_speed_{0}; // Velocidad a la que se desplazan las nubes
int pause_counter_; // Contador para salir del menu de pausa y volver al juego
bool leaving_pause_menu_; // Indica si esta saliendo del menu de pausa para volver al juego
bool pause_initialized_; // Indica si la pausa ha sido inicializada
bool game_over_initialized_; // Indica si el game over ha sido inicializado
int game_over_post_fade_; // Opción a realizar cuando termina el fundido del game over
#ifdef PAUSE
bool pause;
#endif
@@ -375,7 +377,7 @@ class Game {
void renderBullets();
// Crea un objeto bala
void createBullet(int x, int y, Bullet::Kind kind, bool poweredUp, int owner);
void createBullet(int x, int y, Bullet::Kind kind, bool powered_up, int owner);
// Vacia el vector de balas
void freeBullets();
@@ -520,7 +522,7 @@ class Game {
public:
// Constructor
Game(int numPlayers, int currentStage, SDL_Renderer *renderer, bool demo, Section *section);
Game(int num_players, int current_stage, SDL_Renderer *renderer, bool demo, Section *section);
// Destructor
~Game();