Retocada y vuelta a añadir la hierba al fondo

data/config/param.txt

@@ -1,9 +1,9 @@
-#GAME
+# GAME
 gameWidth 320
 gameHeight 240
 itemSize 20
 
-#FADE
+# FADE
 numSquaresWidth 160
 numSquaresHeight 120
 fadeRandomSquaresDelay 1
@@ -11,12 +11,18 @@ fadeRandomSquaresMult 500
 fadePostDuration 80
 venetianSize 16
 
-#SCOREBOARD
+# SCOREBOARD
 scoreboard.x 0
 scoreboard.y 200
 scoreboard.w 320
 scoreboard.h 40
 
-#TITLE
+# TITLE
 pressStart 160
-titleCounter 800
+titleCounter 800
+
+# BACKGROUND
+backgroundAttenuateColor.r 255
+backgroundAttenuateColor.g 255
+backgroundAttenuateColor.b 255
+backgroundAttenuateColor.a 0

source/background.cpp

@@ -19,6 +19,8 @@ Background::Background(SDL_Renderer *renderer, Screen *screen, Asset *asset, par
     srcRect = {playArea.x, rect.h - playArea.h, playArea.w, playArea.h};
     dstRect = {0, 0, playArea.w, playArea.h};
     base = rect.h;
+    color = {param->backgroundAttenuateColor.r, param->backgroundAttenuateColor.g, param->backgroundAttenuateColor.b};
+    alphaColorText = alphaColorTextTemp = param->backgroundAttenuateAlpha;
 
     gradientRect[0] = {0, 0, rect.w, rect.h};
     gradientRect[1] = {rect.w, 0, rect.w, rect.h};
@@ -40,7 +42,7 @@ Background::Background(SDL_Renderer *renderer, Screen *screen, Asset *asset, par
 
     buildingsSprite = new Sprite(0, 0, rect.w, 135, buildingsTexture, renderer);
     gradientSprite = new Sprite(0, 0, rect.w, rect.h, gradientsTexture, renderer);
-    grassSprite = new Sprite(0, 0, 256, 6, grassTexture, renderer);
+    grassSprite = new Sprite(0, 0, 320, 10, grassTexture, renderer);
 
     // Inicializa objetos
     clouds1A->setSpriteClip(0, 0, cloudsTexture->getWidth(), 52);
@@ -53,6 +55,12 @@ Background::Background(SDL_Renderer *renderer, Screen *screen, Asset *asset, par
     // Crea la textura para componer el fondo
     canvas = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, rect.w, rect.h);
     SDL_SetTextureBlendMode(canvas, SDL_BLENDMODE_BLEND);
+
+    // Crea la textura para atenuar el fondo
+    colorText = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, rect.w, rect.h);
+    SDL_SetTextureBlendMode(colorText, SDL_BLENDMODE_BLEND);
+    setColor(color);
+    SDL_SetTextureAlphaMod(colorText, alphaColorText);
 }
 
 // Destructor
@@ -78,52 +86,28 @@ Background::~Background()
     delete gradientSprite;
     delete grassSprite;
     SDL_DestroyTexture(canvas);
+    SDL_DestroyTexture(colorText);
 }
 
 // Actualiza la lógica del objeto
 void Background::update()
 {
-    // Aplica la velocidad calculada a las nubes
+    // Actualiza el valor de alpha
-    clouds1A->setVelX(cloudsSpeed);
+    updateAlphaColorText();
-    clouds1B->setVelX(cloudsSpeed);
-    clouds2A->setVelX(cloudsSpeed / 2);
-    clouds2B->setVelX(cloudsSpeed / 2);
 
-    // Mueve las nubes
+    // Actualiza las nubes
-    clouds1A->move();
+    updateCLouds();
-    clouds1B->move();
-    clouds2A->move();
-    clouds2B->move();
-
-    // Calcula el offset de las nubes
-    if (clouds1A->getPosX() < -clouds1A->getWidth())
-    {
-        clouds1A->setPosX(clouds1A->getWidth());
-    }
-
-    if (clouds1B->getPosX() < -clouds1B->getWidth())
-    {
-        clouds1B->setPosX(clouds1B->getWidth());
-    }
-
-    if (clouds2A->getPosX() < -clouds2A->getWidth())
-    {
-        clouds2A->setPosX(clouds2A->getWidth());
-    }
-
-    if (clouds2B->getPosX() < -clouds2B->getWidth())
-    {
-        clouds2B->setPosX(clouds2B->getWidth());
-    }
 
     // Calcula el frame de la hierba
-    grassSprite->setSpriteClip(0, (6 * (counter / 20 % 2)), 256, 6);
+    grassSprite->setSpriteClip(0, (10 * (counter / 20 % 2)), 320, 10);
 
     // Calcula el valor de alpha
     alpha = std::max((255 - (int)(255 * transition)), 0);
 
     // Incrementa el contador
     counter++;
+
+    fillCanvas();
 }
 
 // Compone todos los elementos del fondo en la textura
@@ -153,7 +137,7 @@ void Background::fillCanvas()
     buildingsSprite->render();
 
     // Dibuja la hierba
-    //grassSprite->render();
+    grassSprite->render();
 
     // Deja el renderizador apuntando donde estaba
     SDL_SetRenderTarget(renderer, temp);
@@ -162,8 +146,11 @@ void Background::fillCanvas()
 // Dibuja el objeto
 void Background::render()
 {
-    fillCanvas();
+    // Fondo
     SDL_RenderCopy(renderer, canvas, &srcRect, &dstRect);
+
+    // Atenuación
+    SDL_RenderCopy(renderer, colorText, &srcRect, &dstRect);
 }
 
 // Vuelve a cargar las texturas
@@ -213,4 +200,80 @@ void Background::setSrcDest(SDL_Rect value)
 void Background::setDstDest(SDL_Rect value)
 {
     dstRect = value;
+}
+
+// Establece el color de atenuación
+void Background::setColor(color_t color)
+{
+    this->color = color;
+
+    // Colorea la textura
+    SDL_Texture *temp = SDL_GetRenderTarget(renderer);
+    SDL_SetRenderTarget(renderer, colorText);
+
+    SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, 255);
+    SDL_RenderClear(renderer);
+
+    SDL_SetRenderTarget(renderer, temp);
+}
+
+// Establece la transparencia de la atenuación
+void Background::setAlpha(int alpha)
+{
+    // Guarda el valor actual
+    alphaColorTextTemp = alphaColorText;
+
+    // Establece el nuevo valor
+    alphaColorText = alpha;
+}
+
+// Actualiza el valor de alpha
+void Background::updateAlphaColorText()
+{
+    if (alphaColorText == alphaColorTextTemp)
+    {
+        return;
+    }
+    else
+    {
+        alphaColorText > alphaColorTextTemp ? alphaColorTextTemp++ : alphaColorTextTemp--;
+        SDL_SetTextureAlphaMod(colorText, alphaColorTextTemp);
+    }
+}
+
+// Actualiza las nubes
+void Background::updateCLouds()
+{
+    // Aplica la velocidad calculada a las nubes
+    clouds1A->setVelX(cloudsSpeed);
+    clouds1B->setVelX(cloudsSpeed);
+    clouds2A->setVelX(cloudsSpeed / 2);
+    clouds2B->setVelX(cloudsSpeed / 2);
+
+    // Mueve las nubes
+    clouds1A->move();
+    clouds1B->move();
+    clouds2A->move();
+    clouds2B->move();
+
+    // Calcula el offset de las nubes
+    if (clouds1A->getPosX() < -clouds1A->getWidth())
+    {
+        clouds1A->setPosX(clouds1A->getWidth());
+    }
+
+    if (clouds1B->getPosX() < -clouds1B->getWidth())
+    {
+        clouds1B->setPosX(clouds1B->getWidth());
+    }
+
+    if (clouds2A->getPosX() < -clouds2A->getWidth())
+    {
+        clouds2A->setPosX(clouds2A->getWidth());
+    }
+
+    if (clouds2B->getPosX() < -clouds2B->getWidth())
+    {
+        clouds2B->setPosX(clouds2B->getWidth());
+    }
 }

source/background.h

@@ -17,20 +17,6 @@ private:
     Screen *screen;         // Objeto encargado de dibujar en pantalla
     Asset *asset;           // Objeto que gestiona todos los ficheros de recursos
 
-    // Variables
-    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
-    int alpha;                // Transparencia entre los dos degradados
-    float cloudsSpeed;        // Velocidad a la que se desplazan las nubes
-    float transition;         // Nivel de transición del fondo 0..1
-    int counter;              // Contador interno
-    SDL_Rect rect;            // Tamaño del objeto fondo
-    SDL_Rect srcRect;         // Parte del objeto fondo que se va a dibujará en pantalla
-    SDL_Rect dstRect;         // Posición donde dibujar la parte del objeto fondo que se dibujará en pantalla
-    SDL_Texture *canvas;      // Textura para componer el fondo
-    int base;                 // Linea de fondo coincidente con el area inferior de la zona de juego
-    param_t *param;           // Puntero con todos los parametros del programa
-
     Texture *buildingsTexture; // Textura con los edificios de fondo
     Texture *cloudsTexture;    // Textura con las nubes de fondo
     Texture *grassTexture;     // Textura con la hierba del suelo
@@ -45,9 +31,35 @@ private:
     Sprite *gradientSprite;  // Sprite con los graficos del degradado de color de fondo
     Sprite *grassSprite;     // Sprite para la hierba
 
+    SDL_Texture *canvas;    // Textura para componer el fondo
+    SDL_Texture *colorText; // Textura para atenuar el fondo
+
+    param_t *param; // Puntero con todos los parametros del programa
+
+    // Variables
+    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
+    int alpha;                // Transparencia entre los dos degradados
+    float cloudsSpeed;        // Velocidad a la que se desplazan las nubes
+    float transition;         // Nivel de transición del fondo 0..1
+    int counter;              // Contador interno
+    SDL_Rect rect;            // Tamaño del objeto fondo
+    SDL_Rect srcRect;         // Parte del objeto fondo que se va a dibujará en pantalla
+    SDL_Rect dstRect;         // Posición donde dibujar la parte del objeto fondo que se dibujará en pantalla
+    int base;                 // Linea de fondo coincidente con el area inferior de la zona de juego
+    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
     void fillCanvas();
 
+    // Actualiza el valor de alpha
+    void updateAlphaColorText();
+
+    // Actualiza las nubes
+    void updateCLouds();
+
 public:
     // Constructor
     Background(SDL_Renderer *renderer, Screen *screen, Asset *asset, param_t *param);
@@ -81,6 +93,12 @@ public:
 
     // Ajusta el valor de la variable
     void setDstDest(SDL_Rect value);
+
+    // Establece el color de atenuación
+    void setColor(color_t color);
+
+    // Establece la transparencia de la atenuación
+    void setAlpha(int alpha);
 };
 
 #endif

source/common/utils.h

@@ -169,12 +169,12 @@ struct options_t
 // Estructura para almacenar todos los parámetros del juego
 struct param_t
 {
+	// GAME
 	int gameWidth;	// Ancho de la resolucion nativa del juego
 	int gameHeight; // Alto de la resolucion nativa del juego
-	int itemSize; // Tamañoi de los items del juego
+	int itemSize;	// Tamañoi de los items del juego
-
-	SDL_Rect scoreboard; // Posición y tamaño del marcador
 
+	// FADE
 	int numSquaresWidth;		// Cantidad total de cuadraditos en horizontal para el FADE_RANDOM_SQUARE
 	int numSquaresHeight;		// Cantidad total de cuadraditos en vertical para el FADE_RANDOM_SQUARE
 	int fadeRandomSquaresDelay; // Duración entre cada pintado de cuadrados
@@ -182,8 +182,16 @@ struct param_t
 	int fadePostDuration;		// Duración final del fade
 	int venetianSize;			// Altura de los rectangulos para FADE_VENETIAN
 
+	// SCOREBOARD
+	SDL_Rect scoreboard; // Posición y tamaño del marcador
+
+	// TITLE
 	int pressStart;	  // Posición del texto para empezar a jugar
 	int titleCounter; // Tiempo de inactividad del titulo
+
+	// BACKGROUND
+	color_t backgroundAttenuateColor;
+	int backgroundAttenuateAlpha;
 };
 
 // Estructura para almacenar ficheros de sonido y su nombre

source/hiscore_table.cpp

@@ -76,6 +76,12 @@ void HiScoreTable::update()
 
 		counter++;
 
+		if (counter == 150)
+		{
+			background->setColor({0, 0, 0});
+			background->setAlpha(96);
+		}
+
 		if (counter == counterEnd)
 		{
 			fade->activate();
@@ -254,7 +260,7 @@ std::string HiScoreTable::scoreToString(Uint32 num)
 void HiScoreTable::updateFade()
 {
 	fade->update();
-	
+
 	if (fade->hasEnded() && fadeMode == FADE_IN)
 	{
 		fade->reset();

source/load_param.cpp

@@ -8,24 +8,29 @@ bool setOptions(param_t *param, std::string var, std::string value);
 // Establece valores por defecto a las variables
 void initParam(param_t *param)
 {
-	// Tamaño original del juego
+	// GAME
 	param->gameWidth = 320;
 	param->gameHeight = 240;
 	param->itemSize = 20;
 
-	// Tamaño para el marcador
+	// SCOREBOARD
-	param->scoreboard = {0, 208, 320, 32};
+	param->scoreboard = {0, 200, 320, 40};
 
-	// Valores para el FADE_RANDOM_SQUARE
+	// FADE
-	param->numSquaresWidth = 80;
+	param->numSquaresWidth = 160;
-	param->numSquaresHeight = 60;
+	param->numSquaresHeight = 120;
 	param->fadeRandomSquaresDelay = 1;
-	param->fadeRandomSquaresMult = 8;
+	param->fadeRandomSquaresMult = 500;
-	param->fadePostDuration = 20;
+	param->fadePostDuration = 80;
 	param->venetianSize = 16;
 
-	// Posició del texto para empezar a jugar
+	// TITLE
-	param->pressStart = 180;
+	param->pressStart = 160;
+	param->titleCounter = 800;
+
+	// BACKGROUND
+	param->backgroundAttenuateColor = {255, 255, 255};
+	param->backgroundAttenuateAlpha = 32;
 }
 
 // Establece valores para los parametros a partir de un fichero de texto
@@ -121,7 +126,7 @@ bool setOptions(param_t *param, std::string var, std::string value)
 	// Indicador de éxito en la asignación
 	bool success = true;
 
-	// Opciones de video
+	// GAME
 	if (var == "gameWidth")
 	{
 		param->gameWidth = std::stoi(value);
@@ -137,6 +142,7 @@ bool setOptions(param_t *param, std::string var, std::string value)
 		param->itemSize = std::stoi(value);
 	}
 
+	// FADE
 	else if (var == "numSquaresWidth")
 	{
 		param->numSquaresWidth = std::stoi(value);
@@ -167,6 +173,7 @@ bool setOptions(param_t *param, std::string var, std::string value)
 		param->venetianSize = std::stoi(value);
 	}
 
+	// SCOREBOARD
 	else if (var == "scoreboard.x")
 	{
 		param->scoreboard.x = std::stoi(value);
@@ -187,6 +194,7 @@ bool setOptions(param_t *param, std::string var, std::string value)
 		param->scoreboard.h = std::stoi(value);
 	}
 
+	// TITLE
 	else if (var == "pressStart")
 	{
 		param->pressStart = std::stoi(value);
@@ -197,6 +205,28 @@ bool setOptions(param_t *param, std::string var, std::string value)
 		param->titleCounter = std::stoi(value);
 	}
 
+	// BACKGROUND
+	else if (var == "backgroundAttenuateColor.r")
+	{
+		param->backgroundAttenuateColor.r = std::stoi(value);
+	}
+
+	else if (var == "backgroundAttenuateColor.g")
+	{
+		param->backgroundAttenuateColor.g = std::stoi(value);
+	}
+
+	else if (var == "backgroundAttenuateColor.b")
+	{
+		param->backgroundAttenuateColor.b = std::stoi(value);
+	}
+
+	else if (var == "backgroundAttenuateColor.a")
+	{
+		param->backgroundAttenuateAlpha = std::stoi(value);
+	}
+
+	// RESTO
 	else
 	{
 		success = false;