Añadido cambio de color en las nubes

source/background.cpp

@@ -1,11 +1,10 @@
 #include "background.h"
 
 // Constructor
-Background::Background(SDL_Renderer *renderer, Screen *screen, Asset *asset, param_t *param)
+Background::Background(SDL_Renderer *renderer, Asset *asset, param_t *param)
 {
     // Copia los punteros
     this->renderer = renderer;
-    this->screen = screen;
     this->asset = asset;
     this->param = param;
 
@@ -22,38 +21,46 @@ Background::Background(SDL_Renderer *renderer, Screen *screen, Asset *asset, par
     color = {param->backgroundAttenuateColor.r, param->backgroundAttenuateColor.g, param->backgroundAttenuateColor.b};
     alphaColorText = alphaColorTextTemp = param->backgroundAttenuateAlpha;
 
+    // Carga las texturas
+    buildingsTexture = new Texture(renderer, asset->get("game_buildings.png"));
+    topCloudsTexture = new Texture(renderer, asset->get("game_clouds1.png"));
+    bottomCloudsTexture = new Texture(renderer, asset->get("game_clouds2.png"));
+    grassTexture = new Texture(renderer, asset->get("game_grass.png"));
+    gradientsTexture = new Texture(renderer, asset->get("game_sky_colors.png"));
+
     gradientRect[0] = {0, 0, rect.w, rect.h};
     gradientRect[1] = {rect.w, 0, rect.w, rect.h};
     gradientRect[2] = {0, rect.h, rect.w, rect.h};
     gradientRect[3] = {rect.w, rect.h, rect.w, rect.h};
 
-    // Carga las texturas
+    const int topCloudsTextureHeight = topCloudsTexture->getHeight() / 4;
-    buildingsTexture = new Texture(renderer, asset->get("game_buildings.png"));
+    const int bottomCloudsTextureHeight = bottomCloudsTexture->getHeight() / 4;
-    clouds1Texture = new Texture(renderer, asset->get("game_clouds1.png"));
+    for (int i = 0; i < 4; ++i)
-    clouds2Texture = new Texture(renderer, asset->get("game_clouds2.png"));
+    {
-    grassTexture = new Texture(renderer, asset->get("game_grass.png"));
+        topCloudsRect[i] = {0, i * topCloudsTextureHeight, topCloudsTexture->getWidth(), topCloudsTextureHeight};
-    gradientsTexture = new Texture(renderer, asset->get("game_sky_colors.png"));
+        bottomCloudsRect[i] = {0, i * bottomCloudsTextureHeight, bottomCloudsTexture->getWidth(), bottomCloudsTextureHeight};
+    }
 
     // Crea los sprites
     const int clouds1y = base - 165;
     const int clouds2y = base - 101;
     const float clouds1speed = 0.1f;
     const float clouds2speed = 0.05f;
-    clouds1A = new MovingSprite(0, clouds1y, rect.w, clouds1Texture->getHeight(), -clouds1speed, 0.0f, 0.0f, 0.0f, clouds1Texture);
+    topCloudsSprite_A = new MovingSprite(0, clouds1y, rect.w, topCloudsTexture->getHeight(), -clouds1speed, 0.0f, 0.0f, 0.0f, topCloudsTexture);
-    clouds1B = new MovingSprite(rect.w, clouds1y, rect.w, clouds1Texture->getHeight(), -clouds1speed, 0.0f, 0.0f, 0.0f, clouds1Texture);
+    topCloudsSprite_B = new MovingSprite(rect.w, clouds1y, rect.w, topCloudsTexture->getHeight(), -clouds1speed, 0.0f, 0.0f, 0.0f, topCloudsTexture);
 
-    clouds2A = new MovingSprite(0, clouds2y, rect.w, clouds2Texture->getHeight(), -clouds2speed, 0.0f, 0.0f, 0.0f, clouds2Texture);
+    bottomCloudsSprite_A = new MovingSprite(0, clouds2y, rect.w, bottomCloudsTexture->getHeight(), -clouds2speed, 0.0f, 0.0f, 0.0f, bottomCloudsTexture);
-    clouds2B = new MovingSprite(rect.w, clouds2y, rect.w, clouds2Texture->getHeight(), -clouds2speed, 0.0f, 0.0f, 0.0f, clouds2Texture);
+    bottomCloudsSprite_B = new MovingSprite(rect.w, clouds2y, rect.w, bottomCloudsTexture->getHeight(), -clouds2speed, 0.0f, 0.0f, 0.0f, bottomCloudsTexture);
 
     buildingsSprite = new Sprite(0, 0, buildingsTexture->getWidth(), buildingsTexture->getHeight(), buildingsTexture);
     gradientSprite = new Sprite(0, 0, rect.w, rect.h, gradientsTexture);
     grassSprite = new Sprite(0, 0, grassTexture->getWidth(), grassTexture->getHeight() / 2, grassTexture);
 
     // Inicializa objetos
-    clouds1A->setSpriteClip(0, 0, clouds1Texture->getWidth(), clouds1Texture->getHeight());
+    topCloudsSprite_A->setSpriteClip(0, 0, topCloudsTexture->getWidth(), topCloudsTexture->getHeight());
-    clouds1B->setSpriteClip(0, 0, clouds1Texture->getWidth(), clouds1Texture->getHeight());
+    topCloudsSprite_B->setSpriteClip(0, 0, topCloudsTexture->getWidth(), topCloudsTexture->getHeight());
-    clouds2A->setSpriteClip(0, 0, clouds2Texture->getWidth(), clouds2Texture->getHeight());
+    bottomCloudsSprite_A->setSpriteClip(0, 0, bottomCloudsTexture->getWidth(), bottomCloudsTexture->getHeight());
-    clouds2B->setSpriteClip(0, 0, clouds2Texture->getWidth(), clouds2Texture->getHeight());
+    bottomCloudsSprite_B->setSpriteClip(0, 0, bottomCloudsTexture->getWidth(), bottomCloudsTexture->getHeight());
     buildingsSprite->setPosY(base - buildingsSprite->getHeight());
     grassSprite->setPosY(base - grassSprite->getHeight());
 
@@ -72,15 +79,15 @@ Background::Background(SDL_Renderer *renderer, Screen *screen, Asset *asset, par
 Background::~Background()
 {
     delete buildingsTexture;
-    delete clouds1Texture;
+    delete topCloudsTexture;
-    delete clouds2Texture;
+    delete bottomCloudsTexture;
     delete grassTexture;
     delete gradientsTexture;
 
-    delete clouds1A;
+    delete topCloudsSprite_A;
-    delete clouds1B;
+    delete topCloudsSprite_B;
-    delete clouds2A;
+    delete bottomCloudsSprite_A;
-    delete clouds2B;
+    delete bottomCloudsSprite_B;
     delete buildingsSprite;
     delete gradientSprite;
     delete grassSprite;
@@ -95,7 +102,7 @@ void Background::update()
     updateAlphaColorText();
 
     // Actualiza las nubes
-    updateCLouds();
+    updateClouds();
 
     // Calcula el frame de la hierba
     grassSprite->setSpriteClip(0, (10 * (counter / 20 % 2)), 320, 10);
@@ -109,6 +116,56 @@ void Background::update()
     fillCanvas();
 }
 
+// Dibuja el gradiente de fondo
+void Background::renderGradient()
+{
+    // Dibuja el gradiente 2
+    gradientsTexture->setAlpha(255);
+    gradientSprite->setSpriteClip(gradientRect[(gradientNumber + 1) % 4]);
+    gradientSprite->render();
+
+    // Dibuja el gradiente 1 con una opacidad cada vez menor
+    gradientsTexture->setAlpha(alpha);
+    gradientSprite->setSpriteClip(gradientRect[gradientNumber]);
+    gradientSprite->render();
+}
+
+// Dibuja las nubes de arriba
+void Background::renderTopClouds()
+{
+    // Dibuja el primer conjunto de nubes
+    topCloudsTexture->setAlpha(255);
+    topCloudsSprite_A->setSpriteClip(topCloudsRect[(gradientNumber + 1) % 4]);
+    topCloudsSprite_A->render();
+    topCloudsSprite_B->setSpriteClip(topCloudsRect[(gradientNumber + 1) % 4]);
+    topCloudsSprite_B->render();
+
+    // Dibuja el segundo conjunto de nubes
+    topCloudsTexture->setAlpha(alpha);
+    topCloudsSprite_A->setSpriteClip(topCloudsRect[gradientNumber]);
+    topCloudsSprite_A->render();
+    topCloudsSprite_B->setSpriteClip(topCloudsRect[gradientNumber]);
+    topCloudsSprite_B->render();
+}
+
+// Dibuja las nubes de abajo
+void Background::renderBottomClouds()
+{
+    // Dibuja el primer conjunto de nubes
+    bottomCloudsTexture->setAlpha(255);
+    bottomCloudsSprite_A->setSpriteClip(bottomCloudsRect[(gradientNumber + 1) % 4]);
+    bottomCloudsSprite_A->render();
+    bottomCloudsSprite_B->setSpriteClip(bottomCloudsRect[(gradientNumber + 1) % 4]);
+    bottomCloudsSprite_B->render();
+
+    // Dibuja el segundo conjunto de nubes
+    bottomCloudsTexture->setAlpha(alpha);
+    bottomCloudsSprite_A->setSpriteClip(bottomCloudsRect[gradientNumber]);
+    bottomCloudsSprite_A->render();
+    bottomCloudsSprite_B->setSpriteClip(bottomCloudsRect[gradientNumber]);
+    bottomCloudsSprite_B->render();
+}
+
 // Compone todos los elementos del fondo en la textura
 void Background::fillCanvas()
 {
@@ -116,21 +173,14 @@ void Background::fillCanvas()
     SDL_Texture *temp = SDL_GetRenderTarget(renderer);
     SDL_SetRenderTarget(renderer, canvas);
 
-    // Dibuja el gradiente 2
+    // Dibuja el gradiente de fondo
-    gradientSprite->setSpriteClip(gradientRect[(gradientNumber + 1) % 4]);
+    renderGradient();
-    gradientsTexture->setAlpha(255);
-    gradientSprite->render();
 
-    // Dibuja el gradiente 1 con una opacidad cada vez menor
+    // Dibuja las nubes de arriba
-    gradientSprite->setSpriteClip(gradientRect[gradientNumber]);
+    renderTopClouds();
-    gradientsTexture->setAlpha(alpha);
-    gradientSprite->render();
 
-    // Dibuja las nubes
+    // Dibuja las nubes de abajo
-    clouds1A->render();
+    renderBottomClouds();
-    clouds1B->render();
-    clouds2A->render();
-    clouds2B->render();
 
     // Dibuja los edificios
     buildingsSprite->render();
@@ -156,8 +206,8 @@ void Background::render()
 void Background::reloadTextures()
 {
     buildingsTexture->reLoad();
-    clouds1Texture->reLoad();
+    topCloudsTexture->reLoad();
-    clouds2Texture->reLoad();
+    bottomCloudsTexture->reLoad();
     grassTexture->reLoad();
     gradientsTexture->reLoad();
 }
@@ -248,38 +298,38 @@ void Background::updateAlphaColorText()
 }
 
 // Actualiza las nubes
-void Background::updateCLouds()
+void Background::updateClouds()
 {
     // Aplica la velocidad calculada a las nubes
-    clouds1A->setVelX(cloudsSpeed);
+    topCloudsSprite_A->setVelX(cloudsSpeed);
-    clouds1B->setVelX(cloudsSpeed);
+    topCloudsSprite_B->setVelX(cloudsSpeed);
-    clouds2A->setVelX(cloudsSpeed / 2);
+    bottomCloudsSprite_A->setVelX(cloudsSpeed / 2);
-    clouds2B->setVelX(cloudsSpeed / 2);
+    bottomCloudsSprite_B->setVelX(cloudsSpeed / 2);
 
     // Mueve las nubes
-    clouds1A->move();
+    topCloudsSprite_A->move();
-    clouds1B->move();
+    topCloudsSprite_B->move();
-    clouds2A->move();
+    bottomCloudsSprite_A->move();
-    clouds2B->move();
+    bottomCloudsSprite_B->move();
 
     // Calcula el offset de las nubes
-    if (clouds1A->getPosX() < -clouds1A->getWidth())
+    if (topCloudsSprite_A->getPosX() < -topCloudsSprite_A->getWidth())
     {
-        clouds1A->setPosX(clouds1A->getWidth());
+        topCloudsSprite_A->setPosX(topCloudsSprite_A->getWidth());
     }
 
-    if (clouds1B->getPosX() < -clouds1B->getWidth())
+    if (topCloudsSprite_B->getPosX() < -topCloudsSprite_B->getWidth())
     {
-        clouds1B->setPosX(clouds1B->getWidth());
+        topCloudsSprite_B->setPosX(topCloudsSprite_B->getWidth());
     }
 
-    if (clouds2A->getPosX() < -clouds2A->getWidth())
+    if (bottomCloudsSprite_A->getPosX() < -bottomCloudsSprite_A->getWidth())
     {
-        clouds2A->setPosX(clouds2A->getWidth());
+        bottomCloudsSprite_A->setPosX(bottomCloudsSprite_A->getWidth());
     }
 
-    if (clouds2B->getPosX() < -clouds2B->getWidth())
+    if (bottomCloudsSprite_B->getPosX() < -bottomCloudsSprite_B->getWidth())
     {
-        clouds2B->setPosX(clouds2B->getWidth());
+        bottomCloudsSprite_B->setPosX(bottomCloudsSprite_B->getWidth());
     }
 }

source/background.h

@@ -14,7 +14,7 @@
 
     El objeto tiene un tamaño total definido en la variable "rect". En principio este
     tamaño coincide con el tamaño de la ventana o resolución del juego, pero se pinta
-    solo el rectangulo definido en srcRect en la posición de la pantalla definida en 
+    solo el rectangulo definido en srcRect en la posición de la pantalla definida en
     dstRect.
 
     Utiliza varios métodos para definir su comportamiento:
@@ -44,92 +44,102 @@
 class Background
 {
 private:
-    // Objetos y punteros
+  // Objetos y punteros
-    SDL_Renderer *renderer; // El renderizador de la ventana
+  SDL_Renderer *renderer; // El renderizador de la ventana
-    Screen *screen;         // Objeto encargado de dibujar en pantalla
+  Asset *asset;           // Objeto que gestiona todos los ficheros de recursos
-    Asset *asset;           // Objeto que gestiona todos los ficheros de recursos
 
-    Texture *buildingsTexture; // Textura con los edificios de fondo
+  Texture *buildingsTexture;    // Textura con los edificios de fondo
-    Texture *clouds1Texture;   // Textura con las nubes de fondo
+  Texture *topCloudsTexture;    // Textura con las nubes de fondo
-    Texture *clouds2Texture;   // Textura con las nubes de fondo
+  Texture *bottomCloudsTexture; // Textura con las nubes de fondo
-    Texture *grassTexture;     // Textura con la hierba del suelo
+  Texture *grassTexture;        // Textura con la hierba del suelo
-    Texture *gradientsTexture; // Textura con los diferentes colores de fondo del juego
+  Texture *gradientsTexture;    // Textura con los diferentes colores de fondo del juego
 
-    MovingSprite *clouds1A; // Sprite para las nubes superiores
+  MovingSprite *topCloudsSprite_A;    // Sprite para las nubes superiores
-    MovingSprite *clouds1B; // Sprite para las nubes superiores
+  MovingSprite *topCloudsSprite_B;    // Sprite para las nubes superiores
-    MovingSprite *clouds2A; // Sprite para las nubes inferiores
+  MovingSprite *bottomCloudsSprite_A; // Sprite para las nubes inferiores
-    MovingSprite *clouds2B; // Sprite para las nubes inferiores
+  MovingSprite *bottomCloudsSprite_B; // Sprite para las nubes inferiores
 
-    Sprite *buildingsSprite; // Sprite con los edificios de fondo
+  Sprite *buildingsSprite; // Sprite con los edificios de fondo
-    Sprite *gradientSprite;  // Sprite con los graficos del degradado de color de fondo
+  Sprite *gradientSprite;  // Sprite con los graficos del degradado de color de fondo
-    Sprite *grassSprite;     // Sprite para la hierba
+  Sprite *grassSprite;     // Sprite para la hierba
 
-    SDL_Texture *canvas;       // Textura para componer el fondo
+  SDL_Texture *canvas;       // Textura para componer el fondo
-    SDL_Texture *colorTexture; // Textura para atenuar el fondo
+  SDL_Texture *colorTexture; // Textura para atenuar el fondo
 
-    param_t *param; // Puntero con todos los parametros del programa
+  param_t *param; // Puntero con todos los parametros del programa
 
-    // Variables
+  // Variables
-    SDL_Rect gradientRect[4]; // Vector con las coordenadas de los 4 degradados para el cielo
+  SDL_Rect gradientRect[4];     // Vector con las coordenadas de los 4 degradados para el cielo
-    int gradientNumber;       // Indica el número de degradado de fondo que se va a dibujar
+  SDL_Rect topCloudsRect[4];    // Vector con las coordenadas de los 4 nubes de arriba
-    int alpha;                // Transparencia entre los dos degradados
+  SDL_Rect bottomCloudsRect[4]; // Vector con las coordenadas de los 4 nubes de abajo
-    float cloudsSpeed;        // Velocidad a la que se desplazan las nubes
+  int gradientNumber;           // Indica el número de degradado de fondo que se va a dibujar
-    float transition;         // Nivel de transición del fondo 0..1
+  int alpha;                    // Transparencia entre los dos degradados
-    int counter;              // Contador interno
+  float cloudsSpeed;            // Velocidad a la que se desplazan las nubes
-    SDL_Rect rect;            // Tamaño del objeto fondo
+  float transition;             // Nivel de transición del fondo 0..1
-    SDL_Rect srcRect;         // Parte del objeto fondo que se va a dibujará en pantalla
+  int counter;                  // Contador interno
-    SDL_Rect dstRect;         // Posición donde dibujar la parte del objeto fondo que se dibujará en pantalla
+  SDL_Rect rect;                // Tamaño del objeto fondo
-    int base;                 // Linea de fondo coincidente con el area inferior de la zona de juego
+  SDL_Rect srcRect;             // Parte del objeto fondo que se va a dibujará en pantalla
-    color_t color;            // Color para atenuar el fondo
+  SDL_Rect dstRect;             // Posición donde dibujar la parte del objeto fondo que se dibujará en pantalla
-    int alphaColorText;       // Alpha para atenuar el fondo
+  int base;                     // Linea de fondo coincidente con el area inferior de la zona de juego
-    int alphaColorTextTemp;   // Valor temporal para hacer la transición de alpha
+  color_t color;                // Color para atenuar el fondo
+  int alphaColorText;           // Alpha para atenuar el fondo
+  int alphaColorTextTemp;       // Valor temporal para hacer la transición de alpha
 
-    // Compone todos los elementos del fondo en la textura
+  // Dibuja el gradiente de fondo
-    void fillCanvas();
+  void renderGradient();
 
-    // Actualiza el valor de alpha
+  // Dibuja las nubes de arriba
-    void updateAlphaColorText();
+  void renderTopClouds();
 
-    // Actualiza las nubes
+  // Dibuja las nubes de abajo
-    void updateCLouds();
+  void renderBottomClouds();
+
+  // Compone todos los elementos del fondo en la textura
+  void fillCanvas();
+
+  // Actualiza el valor de alpha
+  void updateAlphaColorText();
+
+  // Actualiza las nubes
+  void updateClouds();
 
 public:
-    // Constructor
+  // Constructor
-    Background(SDL_Renderer *renderer, Screen *screen, Asset *asset, param_t *param);
+  Background(SDL_Renderer *renderer, Asset *asset, param_t *param);
 
-    // Destructor
+  // Destructor
-    ~Background();
+  ~Background();
 
-    // Actualiza la lógica del objeto
+  // Actualiza la lógica del objeto
-    void update();
+  void update();
 
-    // Dibuja el objeto
+  // Dibuja el objeto
-    void render();
+  void render();
 
-    // Establece la posición del objeto
+  // Establece la posición del objeto
-    void setPos(SDL_Rect);
+  void setPos(SDL_Rect);
 
-    // Vuelve a cargar las texturas
+  // Vuelve a cargar las texturas
-    void reloadTextures();
+  void reloadTextures();
 
-    // Ajusta el valor de la variable
+  // Ajusta el valor de la variable
-    void setCloudsSpeed(float value);
+  void setCloudsSpeed(float value);
 
-    // Ajusta el valor de la variable
+  // Ajusta el valor de la variable
-    void setGradientNumber(int value);
+  void setGradientNumber(int value);
 
-    // Ajusta el valor de la variable
+  // Ajusta el valor de la variable
-    void setTransition(float value);
+  void setTransition(float value);
 
-    // Ajusta el valor de la variable
+  // Ajusta el valor de la variable
-    void setSrcRect(SDL_Rect value);
+  void setSrcRect(SDL_Rect value);
 
-    // Ajusta el valor de la variable
+  // Ajusta el valor de la variable
-    void setDstRect(SDL_Rect value);
+  void setDstRect(SDL_Rect value);
 
-    // Establece el color de atenuación
+  // Establece el color de atenuación
-    void setColor(color_t color);
+  void setColor(color_t color);
 
-    // Establece la transparencia de la atenuación
+  // Establece la transparencia de la atenuación
-    void setAlpha(int alpha);
+  void setAlpha(int alpha);
 };

source/director.cpp

@@ -156,7 +156,7 @@ void Director::initInput()
 		input->bindGameControllerButton(i, input_exit, SDL_CONTROLLER_BUTTON_BACK);
 	}
 
-	// Comprueba si ha de modificar las asignaciones por las que hay en las opciones en caso de coincidir el nombre del mando
+	// Mapea las asignaciones a los botones desde el archivo de configuración, si se da el caso
 	for (int i = 0; i < numGamePads; ++i)
 		for (int index = 0; index < (int)options->controller.size(); ++index)
 			if (input->getControllerName(i) == options->controller[index].name)

source/game.cpp

@@ -25,8 +25,8 @@ Game::Game(int playerID, int currentStage, Screen *screen, Asset *asset, Lang *l
 	// Crea los objetos
 	fade = new Fade(renderer, param);
 	eventHandler = new SDL_Event();
-	scoreboard = new Scoreboard(renderer, screen, asset, lang, options);
+	scoreboard = new Scoreboard(renderer, asset, lang, options);
-	background = new Background(renderer, screen, asset, param);
+	background = new Background(renderer, asset, param);
 	explosions = new Explosions();
 	enemyFormations = new EnemyFormations();
 
@@ -2592,14 +2592,17 @@ void Game::checkEvents()
 		{
 			switch (eventHandler->key.keysym.sym)
 			{
+			// CREA UN SPRITE DE 1000 PUNTOS
 			case SDLK_h:
 				createItemScoreSprite(param->gameWidth / 2, param->gameWidth / 2, n1000Sprite);
 				break;
 
+			// CREA UNA POWERBALL
 			case SDLK_1:
 				createPowerBall();
 				break;
 
+			// CREA DOS BALLON4
 			case SDLK_2:
 			{
 				const int set = 0;
@@ -2617,6 +2620,7 @@ void Game::checkEvents()
 			}
 			break;
 
+			// ACTIVA EL MODO PARA PASAR EL JUEGO AUTOMATICAMENTE
 			case SDLK_3:
 				autoPopBalloons = !autoPopBalloons;
 				screen->showNotification("autoPopBalloons " + boolToString(autoPopBalloons));

source/hiscore_table.cpp

@@ -18,7 +18,7 @@ HiScoreTable::HiScoreTable(Screen *screen, Asset *asset, Input *input, Lang *lan
 	// Objetos
 	eventHandler = new SDL_Event();
 	fade = new Fade(renderer, param);
-	background = new Background(renderer, screen, asset, param);
+	background = new Background(renderer, asset, param);
 	text = new Text(asset->get("smb2.gif"), asset->get("smb2.txt"), renderer);
 
 	// Crea un backbuffer para el renderizador