Actualitzada la data de la versió

fix: es podia pulsar per a jugar mentre feia el fade cap a la demo
Screen: optimitzat el circuit de render en pantalla
2025-01-05 14:38:48 +01:00 · 2025-01-05 14:36:38 +01:00 · 2025-01-05 14:17:49 +01:00 · 2025-01-05 13:44:10 +01:00 · 2025-01-05 13:41:09 +01:00 · 2025-01-05 13:27:45 +01:00
40 changed files with 774 additions and 499 deletions
--- a/2
+++ b/2
@@ -11,7 +11,7 @@ APP_NAME       := Coffee Crisis Arcade Edition
 RELEASE_FOLDER := ccae_release
 RELEASE_FILE   := $(RELEASE_FOLDER)/$(TARGET_NAME)
 RESOURCE_FILE  := release/coffee.res
-VERSION        := 2024-12-31
+VERSION        := 2025-01-05

 # Nombres para los ficheros de lanzamiento
 WINDOWS_RELEASE             := $(TARGET_NAME)-$(VERSION)-win32-x64.zip
--- a/README.md
+++ b/README.md
@@ -1,45 +1,72 @@
 # Coffee Crisis Arcade Edition

-Coffee Crisis Arcade Edition es la versió ampliada i millorada del aclamat Coffee Crisis. Preparat per a jugar sense parar amn dos jugadors, nous gràfics i moltes sorpreses mes.
+**¡La batalla definitiva pel cafè està ací!**
+
+Coffee Crisis Arcade Edition és una versió ampliada i millorada del aclamat Coffee Crisis. Aquesta versió porta l'acció cooperativa al següent nivell, amb:
+
+- **Mode multijugador** per a dues persones.
+- **Nous gràfics** que revitalitzen l'experiència arcade clàssica.
+- **Moltes sorpreses** per descobrir en cada partida.
+
+Defensa el teu cafè contra les bambolles gegants en aquest trepidant joc d'arcade! 🍵

 <p align="center">
-    <img src="https://php.sustancia.synology.me/images/ccae_title.png" alt="Titol" 
+    <img src="https://php.sustancia.synology.me/images/ccae_title.png" alt="Títol" />
 </p>

 ## Controls
-El joc està optimitzat per a ser jugat amb un mando de jocs, encara que un dels jugadors pot utilitzar el teclat.
-Les tecles son les següents:

-* **Fletxes**: Mou al personatge
-* **Q, W, E**: Disparar a la esquerra, al centre i a la dreta respectivament
+El joc està optimitzat per a ser jugat amb un mando de jocs, encara que un dels jugadors pot utilitzar el teclat.
+
+### Controls del teclat:
+- **Fletxes**: Mou al personatge.
+- **Q, W, E**: Disparar a l'esquerra, al centre i a la dreta, respectivament.
+
+> Nota: El joc suporta nomes un jugador amb teclat.

 <p align="center">
-    <img src="https://php.sustancia.synology.me/images/ccae1.png" alt="Joc" 
+    <img src="https://php.sustancia.synology.me/images/ccae1.png" alt="Joc" />
 </p>

 ## Altres tecles
- **Tecla ESC**: Tancar el joc

- **Tecla F1**: Fa la finestra mes xicoteta
-
- **Tecla F2**: Fa la finestra mes gran
-
- **Tecla F3**: Alterna entre el mode de pantalla completa i el de finestra
-
- **Tecla F4**: Activa o desactiva els shaders
-
- **Tecla F5**: Activa o desactiva l'audio
-
- **Tecla F6**: Activa o desactiva el dispar automàtic
-
- **Tecla F7**: Canvia el idioma del joc i reinicia
-
- **Tecla F10**: Reset
+| Tecla       | Funció                                       |
+|-------------|----------------------------------------------|
+| **ESC**     | Tancar el joc                                |
+| **F1**      | Fa la finestra més xicoteta                 |
+| **F2**      | Fa la finestra més gran                     |
+| **F3**      | Alterna entre mode de pantalla completa i finestra |
+| **F4**      | Activa o desactiva els shaders              |
+| **F5**      | Activa o desactiva l'àudio                 |
+| **F6**      | Activa o desactiva el dispar automàtic      |
+| **F7**      | Canvia l'idioma del joc i reinicia         |
+| **F10**     | Reset del joc                               |

 <p align="center">
-    <img src="https://php.sustancia.synology.me/images/ccae2.png" alt="Joc" 
+    <img src="https://php.sustancia.synology.me/images/ccae2.png" alt="Joc" />
 </p>

+## Com instal·lar i jugar
+
+1. Descarrega el joc des de [l'apartat de llançaments](https://gitea.sustancia.synology.me/JailDesigner/coffee_crisis_arcade_edition/releases).
+2. Descomprimix i executa l'arxiu `coffee_crisis_arcade_edition.exe`.
+3. Gaudeix del joc!
+
+## Agraïments
+
+Vull expressar la meua gratitud a **ChatGPT** i **GitHub Copilot**. Gràcies per ser un suport constant en el desenvolupament d'aquest joc!
+
+També vull agrair a tots els jugadors que fan que aquest projecte valgui la pena. 🕹️❤️
+
+## Com contribuir
+
+Accepte contribucions! Si tens una idea o vols ajudar:
+
+1. Fes un fork d'aquest repositori.
+2. Crea una branca nova amb els teus canvis.
+3. Fes un pull request.
+
+## Llicència
+
+Aquest joc està subjecte a una llicència [MIT](https://opensource.org/licenses/MIT). Consulta el fitxer LICENSE per a més detalls.

-## Agraiments
-A chatGPT i sobretot a Copilot. Gracies per estar sempre quan vos he necesitat.
--- a/data/gfx/balloon/powerball.ani
+++ b/data/gfx/balloon/powerball.ani
@@ -1,9 +1,9 @@
-frame_width=46
-frame_height=46
+frame_width=49
+frame_height=49

 [animation]
 name=powerball
 speed=10
 loop=-1
-frames=0
+frames=1
 [/animation]
--- a/data/gfx/balloon/powerball.png
+++ b/data/gfx/balloon/powerball.png
--- a/data/gfx/game/game_clouds1.png
+++ b/data/gfx/game/game_clouds1.png
--- a/data/gfx/game/game_clouds2.png
+++ b/data/gfx/game/game_clouds2.png
--- a/data/gfx/game/game_moon.png
+++ b/data/gfx/game/game_moon.png
--- a/data/gfx/game/game_sun.png
+++ b/data/gfx/game/game_sun.png
--- a/source/background.cpp
+++ b/source/background.cpp
@@ -2,12 +2,13 @@
 #include <SDL2/SDL_blendmode.h> // Para SDL_BLENDMODE_BLEND
 #include <SDL2/SDL_pixels.h>    // Para SDL_PIXELFORMAT_RGBA8888
 #include <algorithm>            // Para clamp, max
-#include "moving_sprite.h"      // Para MovingSprite
-#include "param.h"              // Para Param, ParamBackground, param
-#include "resource.h"           // Para Resource
-#include "screen.h"             // Para Screen
-#include "sprite.h"             // Para Sprite
-#include "texture.h"            // Para Texture
+#include <cmath>
+#include "moving_sprite.h" // Para MovingSprite
+#include "param.h"         // Para Param, ParamBackground, param
+#include "resource.h"      // Para Resource
+#include "screen.h"        // Para Screen
+#include "sprite.h"        // Para Sprite
+#include "texture.h"       // Para Texture

 // Constructor
 Background::Background()
@@ -18,16 +19,22 @@ Background::Background()
      bottom_clouds_texture_(Resource::get()->getTexture("game_clouds2.png")),
      grass_texture_(Resource::get()->getTexture("game_grass.png")),
      gradients_texture_(Resource::get()->getTexture("game_sky_colors.png")),
+      sun_texture_(Resource::get()->getTexture("game_sun.png")),
+      moon_texture_(Resource::get()->getTexture("game_moon.png")),

      rect_({0, 0, gradients_texture_->getWidth() / 2, gradients_texture_->getHeight() / 2}),
      src_rect_({0, 0, 320, 240}),
      dst_rect_({0, 0, 320, 240}),
      base_(rect_.h),
-      color_(Color(param.background.attenuate_color.r, param.background.attenuate_color.g, param.background.attenuate_color.b)),
+      attenuate_color_(Color(param.background.attenuate_color.r, param.background.attenuate_color.g, param.background.attenuate_color.b)),
      alpha_color_text_(param.background.attenuate_alpha),
      alpha_color_text_temp_(param.background.attenuate_alpha)

 {
+    // Precalcula rutas
+    createSunPath();
+    createMoonPath();
+
    // Inicializa variables
    {
        gradient_rect_[0] = {0, 0, rect_.w, rect_.h};
@@ -55,9 +62,11 @@ Background::Background()
        bottom_clouds_sprite_a_ = std::make_unique<MovingSprite>(bottom_clouds_texture_, (SDL_Rect){0, bottom_clouds_y, rect_.w, bottom_clouds_texture_->getHeight()});
        bottom_clouds_sprite_b_ = std::make_unique<MovingSprite>(bottom_clouds_texture_, (SDL_Rect){rect_.w, bottom_clouds_y, rect_.w, bottom_clouds_texture_->getHeight()});

-        buildings_sprite_ = std::make_unique<Sprite>(buildings_texture_, 0, 0, buildings_texture_->getWidth(), buildings_texture_->getHeight());
+        buildings_sprite_ = std::make_unique<Sprite>(buildings_texture_);
        gradient_sprite_ = std::make_unique<Sprite>(gradients_texture_, 0, 0, rect_.w, rect_.h);
        grass_sprite_ = std::make_unique<Sprite>(grass_texture_, 0, 0, grass_texture_->getWidth(), grass_texture_->getHeight() / 2);
+        sun_sprite_ = std::make_unique<Sprite>(sun_texture_);
+        moon_sprite_ = std::make_unique<Sprite>(moon_texture_);
    }

    // Inicializa objetos
@@ -79,6 +88,8 @@ Background::Background()

        buildings_sprite_->setY(base_ - buildings_sprite_->getHeight());
        grass_sprite_->setY(base_ - grass_sprite_->getHeight());
+        sun_sprite_->setPosition(sun_path_.front());
+        moon_sprite_->setPosition(moon_path_.front());
    }

    // Crea la textura para componer el fondo
@@ -88,7 +99,7 @@ Background::Background()
    // Crea la textura para atenuar el fondo
    color_texture_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, rect_.w, rect_.h);
    SDL_SetTextureBlendMode(color_texture_, SDL_BLENDMODE_BLEND);
-    setColor(color_);
+    setColor(attenuate_color_);
    SDL_SetTextureAlphaMod(color_texture_, alpha_color_text_);
 }

@@ -103,7 +114,7 @@ Background::~Background()
 void Background::update()
 {
    // Actualiza el valor de alpha_
-    updateAlphaColorText();
+    updateAlphaColorTexture();

    // Actualiza las nubes
    updateClouds();
@@ -114,6 +125,10 @@ void Background::update()
    // Calcula el valor de alpha_
    alpha_ = std::max((255 - (int)(255 * transition_)), 0);

+    // Mueve el sol
+    sun_sprite_->setPosition(sun_path_.at(sun_index_));
+    moon_sprite_->setPosition(moon_path_.at(moon_index_));
+
    // Incrementa el contador
    ++counter_;

@@ -181,6 +196,10 @@ void Background::fillCanvas()
    // Dibuja el gradiente de fondo
    renderGradient();

+    // Dibuja los astros
+    sun_sprite_->render();
+    moon_sprite_->render();
+
    // Dibuja las nubes de arriba
    renderTopClouds();

@@ -250,13 +269,13 @@ void Background::setPos(SDL_Rect pos)
 // Establece el color_ de atenuación
 void Background::setColor(Color color)
 {
-    color_ = color;
+    attenuate_color_ = color;

    // Colorea la textura
    auto temp = SDL_GetRenderTarget(renderer_);
    SDL_SetRenderTarget(renderer_, color_texture_);

-    SDL_SetRenderDrawColor(renderer_, color_.r, color_.g, color_.b, 255);
+    SDL_SetRenderDrawColor(renderer_, attenuate_color_.r, attenuate_color_.g, attenuate_color_.b, 255);
    SDL_RenderClear(renderer_);

    SDL_SetRenderTarget(renderer_, temp);
@@ -274,7 +293,7 @@ void Background::setAlpha(int alpha)
 }

 // Actualiza el valor de alpha_
-void Background::updateAlphaColorText()
+void Background::updateAlphaColorTexture()
 {
    if (alpha_color_text_ == alpha_color_text_temp_)
    {
@@ -322,4 +341,58 @@ void Background::updateClouds()
    {
        bottom_clouds_sprite_b_->setPosX(bottom_clouds_sprite_b_->getWidth());
    }
+}
+
+// Precalcula el vector con el recorrido del sol
+void Background::createSunPath()
+{
+    constexpr int CENTER_X = 170;
+    const int center_y = base_ - 80;
+    constexpr int RADIUS = 120;
+
+    // Generar puntos de la curva desde 90 a 180 grados
+    for (double theta = M_PI / 2; theta <= M_PI; theta += 0.01)
+    {
+        int x = CENTER_X + static_cast<int>(RADIUS * cos(theta));
+        int y = center_y - static_cast<int>(RADIUS * sin(theta));
+        sun_path_.push_back({x, y});
+    }
+
+    // Agregar puntos en línea recta después de la curva
+    constexpr int EXTRA_PIXELS = 40;
+    SDL_Point last_point = sun_path_.back();
+    for (int i = 1; i <= EXTRA_PIXELS; ++i)
+    {
+        sun_path_.push_back({last_point.x, last_point.y + i});
+    }
+}
+
+// Precalcula el vector con el recorrido de la luna
+void Background::createMoonPath()
+{
+    constexpr int CENTER_X = 100;
+    const int center_y = base_ - 50;
+    constexpr int RADIUS = 140;
+
+    // Generar puntos de la curva desde 0 a 90 grados
+    for (double theta = 0; theta <= M_PI / 2; theta += 0.01)
+    {
+        int x = CENTER_X + static_cast<int>(RADIUS * cos(theta));
+        int y = center_y - static_cast<int>(RADIUS * sin(theta));
+        moon_path_.push_back({x, y});
+    }
+}
+
+// Establece la posición del sol
+void Background::setSunProgression(float progress)
+{
+    progress = std::clamp(progress, 0.0f, 1.0f);
+    sun_index_ = static_cast<size_t>(progress * (sun_path_.size() - 1));
+}
+
+// Establece la posición de la luna
+void Background::setMoonProgression(float progress)
+{
+    progress = std::clamp(progress, 0.0f, 1.0f);
+    moon_index_ = static_cast<size_t>(progress * (moon_path_.size() - 1));
 }
--- a/source/background.h
+++ b/source/background.h
@@ -1,12 +1,14 @@
 #pragma once

-#include <SDL2/SDL_rect.h>   // para SDL_Rect
-#include <SDL2/SDL_render.h> // para SDL_Renderer, SDL_Texture
-#include <memory>            // para unique_ptr, shared_ptr
-#include "utils.h"           // para Color
-class MovingSprite;
-class Sprite;
-class Texture;
+#include <SDL2/SDL_rect.h>   // Para SDL_Rect, SDL_Point
+#include <SDL2/SDL_render.h> // Para SDL_Texture, SDL_Renderer
+#include <stddef.h>          // Para size_t
+#include <memory>            // Para unique_ptr, shared_ptr
+#include <vector>            // Para vector
+#include "utils.h"           // Para Color
+class MovingSprite;          // lines 7-7
+class Sprite;                // lines 8-8
+class Texture;               // lines 9-9

 /*
    Esta clase es la encargada de dibujar el fondo que aparece durante la sección
@@ -51,6 +53,8 @@ private:
  std::shared_ptr<Texture> bottom_clouds_texture_; // Textura con las nubes de fondo
  std::shared_ptr<Texture> grass_texture_;         // Textura con la hierba del suelo
  std::shared_ptr<Texture> gradients_texture_;     // Textura con los diferentes colores de fondo del juego
+  std::shared_ptr<Texture> sun_texture_;           // Textura con el sol
+  std::shared_ptr<Texture> moon_texture_;          // Textura con la luna

  std::unique_ptr<MovingSprite> top_clouds_sprite_a_;    // Sprite para las nubes superiores
  std::unique_ptr<MovingSprite> top_clouds_sprite_b_;    // Sprite para las nubes superiores
@@ -60,26 +64,32 @@ private:
  std::unique_ptr<Sprite> buildings_sprite_; // Sprite con los edificios de fondo
  std::unique_ptr<Sprite> gradient_sprite_;  // Sprite con los graficos del degradado de color de fondo
  std::unique_ptr<Sprite> grass_sprite_;     // Sprite para la hierba
+  std::unique_ptr<Sprite> sun_sprite_;       // Sprite para el sol
+  std::unique_ptr<Sprite> moon_sprite_;      // Sprite para la luna

  SDL_Texture *canvas_;        // Textura para componer el fondo
  SDL_Texture *color_texture_; // Textura para atenuar el fondo

  // Variables
-  SDL_Rect gradient_rect_[4];      // Vector con las coordenadas de los 4 degradados para el cielo
-  SDL_Rect top_clouds_rect_[4];    // Vector con las coordenadas de los 4 nubes de arriba
-  SDL_Rect bottom_clouds_rect_[4]; // Vector con las coordenadas de los 4 nubes de abajo
-  int gradient_number_ = 0;        // Indica el número de degradado de fondo que se va a dibujar
-  int alpha_ = 0;                  // Transparencia entre los dos degradados
-  float clouds_speed_ = 0;         // Velocidad a la que se desplazan las nubes
-  float transition_ = 0;           // Nivel de transición del fondo 0..1
-  int counter_ = 0;                // Contador interno
-  SDL_Rect rect_;                  // Tamaño del objeto fondo
-  SDL_Rect src_rect_;              // Parte del objeto fondo que se va a dibujará en pantalla
-  SDL_Rect dst_rect_;              // 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 color_;                    // Color para atenuar el fondo
-  int alpha_color_text_;           // Alpha para atenuar el fondo
-  int alpha_color_text_temp_;      // Valor temporal para hacer la transición de alpha
+  SDL_Rect gradient_rect_[4];        // Vector con las coordenadas de los 4 degradados para el cielo
+  SDL_Rect top_clouds_rect_[4];      // Vector con las coordenadas de los 4 nubes de arriba
+  SDL_Rect bottom_clouds_rect_[4];   // Vector con las coordenadas de los 4 nubes de abajo
+  int gradient_number_ = 0;          // Indica el número de degradado de fondo que se va a dibujar
+  int alpha_ = 0;                    // Transparencia entre los dos degradados
+  float clouds_speed_ = 0;           // Velocidad a la que se desplazan las nubes
+  float transition_ = 0;             // Nivel de transición del fondo 0..1
+  int counter_ = 0;                  // Contador interno
+  SDL_Rect rect_;                    // Tamaño del objeto fondo
+  SDL_Rect src_rect_;                // Parte del objeto fondo que se va a dibujará en pantalla
+  SDL_Rect dst_rect_;                // 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 attenuate_color_;            // Color para atenuar el fondo
+  int alpha_color_text_;             // Alpha para atenuar el fondo
+  int alpha_color_text_temp_;        // Valor temporal para hacer la transición de alpha
+  std::vector<SDL_Point> sun_path_;  // Vector con el recorrido del sol
+  std::vector<SDL_Point> moon_path_; // Vector con el recorrido de la luna
+  size_t sun_index_ = 0;             // Posición del vector del recorrido del sol
+  size_t moon_index_ = 0;            // Posición del vector del recorrido de la luna

  // Dibuja el gradiente de fondo
  void renderGradient();
@@ -94,11 +104,17 @@ private:
  void fillCanvas();

  // Actualiza el valor de alpha
-  void updateAlphaColorText();
+  void updateAlphaColorTexture();

  // Actualiza las nubes
  void updateClouds();

+  // Precalcula el vector con el recorrido del sol
+  void createSunPath();
+
+  // Precalcula el vector con el recorrido de la luna
+  void createMoonPath();
+
 public:
  // Constructor
  Background();
@@ -132,4 +148,10 @@ public:

  // Establece la transparencia de la atenuación
  void setAlpha(int alpha);
+
+  // Establece la posición del sol
+  void setSunProgression(float progress);
+
+  // Establece la posición de la luna
+  void setMoonProgression(float progress);
 };
--- a/source/balloon.cpp
+++ b/source/balloon.cpp
@@ -107,15 +107,27 @@ void Balloon::render()
 {
 	if (type_ == BalloonType::POWERBALL)
 	{
-		// Renderizado para la PowerBall
-		SDL_Point p = {24, 24};
-		sprite_->setRotatingCenter(&p);
-		sprite_->render();
+		// Renderiza el fondo azul
+		{
+			auto sp = std::make_unique<Sprite>(sprite_->getTexture(), sprite_->getPosition());
+			sp->setSpriteClip(0, 0, BALLOON_SIZE[4], BALLOON_SIZE[4]);
+			sp->render();
+		}
+
+		// Renderiza la estrella
+		if (!invulnerable_)
+		{
+			SDL_Point p = {24, 24};
+			sprite_->setRotatingCenter(&p);
+			sprite_->render();
+		}

 		// Añade la máscara del borde y los reflejos
-		auto sp = std::make_unique<Sprite>(sprite_->getTexture(), sprite_->getPosition());
-		sp->setSpriteClip(BALLOON_SIZE[4], 0, BALLOON_SIZE[4], BALLOON_SIZE[4]);
-		sp->render();
+		{
+			auto sp = std::make_unique<Sprite>(sprite_->getTexture(), sprite_->getPosition());
+			sp->setSpriteClip(BALLOON_SIZE[4] * 2, 0, BALLOON_SIZE[4], BALLOON_SIZE[4]);
+			sp->render();
+		}
 	}
 	else
 	{
@@ -167,18 +179,6 @@ void Balloon::move()
 		// Mueve el globo en vertical
 		y_ += vy_ * speed_;

-		// Colisión en la parte superior de la zona de juego excepto para la PowerBall
-		/*if (type_ != BalloonType::POWERBALL)
-		{
-			const int min_y = play_area_.y;
-			if (y_ < min_y)
-			{
-				y_ = min_y;
-				vy_ = -vy_;
-				enableBounce();
-			}
-		}*/
-
 		// Colisión en la parte superior solo si el globo va de subida
 		if (vy_ < 0)
 		{
@@ -203,6 +203,10 @@ void Balloon::move()
 			{
 				enableBounce();
 			}
+			else
+			{
+				setInvulnerable(false);
+			}
 		}

 		/*
--- a/source/balloon_manager.cpp
+++ b/source/balloon_manager.cpp
@@ -180,49 +180,61 @@ int BalloonManager::calculateScreenPower()
 // Crea un globo nuevo en el vector de globos
 std::shared_ptr<Balloon> BalloonManager::createBalloon(float x, int y, BalloonType type, BalloonSize size, float velx, float speed, int creation_timer)
 {
-    const int index = static_cast<int>(size);
-    balloons_.emplace_back(std::make_shared<Balloon>(x, y, type, size, velx, speed, creation_timer, play_area_, balloon_textures_.at(index), balloon_animations_.at(index)));
-    return balloons_.back();
+    if (can_deploy_balloons_)
+    {
+        const int index = static_cast<int>(size);
+        balloons_.emplace_back(std::make_shared<Balloon>(x, y, type, size, velx, speed, creation_timer, play_area_, balloon_textures_.at(index), balloon_animations_.at(index)));
+        return balloons_.back();
+    }
+
+    return nullptr;
 }

 // Crea un globo a partir de otro globo
 void BalloonManager::createChildBalloon(const std::shared_ptr<Balloon> &balloon, const std::string &direction)
 {
-    const float vx = direction == "LEFT" ? BALLOON_VELX_NEGATIVE : BALLOON_VELX_POSITIVE;
-    const auto lower_size = static_cast<BalloonSize>(static_cast<int>(balloon->getSize()) - 1);
-    auto b = createBalloon(0, balloon->getPosY(), balloon->getType(), lower_size, vx, balloon_speed_, 0);
-    const int x = direction == "LEFT" ? balloon->getPosX() + (balloon->getWidth() / 3) : balloon->getPosX() + 2 * (balloon->getWidth() / 3);
-    b->alignTo(x);
-    b->setVelY(b->getType() == BalloonType::BALLOON ? -2.50f : BALLOON_VELX_NEGATIVE * 2.0f);
-    if (balloon->isStopped())
+    if (can_deploy_balloons_)
    {
-        b->stop();
-    }
-    if (balloon->isUsingReversedColor())
-    {
-        b->useReverseColor();
+        const float vx = direction == "LEFT" ? BALLOON_VELX_NEGATIVE : BALLOON_VELX_POSITIVE;
+        const auto lower_size = static_cast<BalloonSize>(static_cast<int>(balloon->getSize()) - 1);
+        auto b = createBalloon(0, balloon->getPosY(), balloon->getType(), lower_size, vx, balloon_speed_, 0);
+        const int x = direction == "LEFT" ? balloon->getPosX() + (balloon->getWidth() / 3) : balloon->getPosX() + 2 * (balloon->getWidth() / 3);
+        b->alignTo(x);
+        b->setVelY(b->getType() == BalloonType::BALLOON ? -2.50f : BALLOON_VELX_NEGATIVE * 2.0f);
+        if (balloon->isStopped())
+        {
+            b->stop();
+        }
+        if (balloon->isUsingReversedColor())
+        {
+            b->useReverseColor();
+        }
    }
 }

 // Crea una PowerBall
 void BalloonManager::createPowerBall()
 {
-    constexpr int values = 6;
-    constexpr int pos_y = -BALLOON_SIZE[4];
-    constexpr int creation_time = 0;
+    if (can_deploy_balloons_)
+    {
+        constexpr int values = 6;
+        constexpr int pos_y = -BALLOON_SIZE[4];
+        constexpr int creation_time = 0;

-    const auto left = param.game.play_area.rect.x;
-    const auto center = param.game.play_area.center_x - (BALLOON_SIZE[4] / 2);
-    const auto right = param.game.play_area.rect.w - BALLOON_SIZE[4];
+        const auto left = param.game.play_area.rect.x;
+        const auto center = param.game.play_area.center_x - (BALLOON_SIZE[4] / 2);
+        const auto right = param.game.play_area.rect.w - BALLOON_SIZE[4];

-    const auto luck = rand() % values;
-    const int x[values] = {left, left, center, center, right, right};
-    const float vx[values] = {BALLOON_VELX_POSITIVE, BALLOON_VELX_POSITIVE, BALLOON_VELX_POSITIVE, BALLOON_VELX_NEGATIVE, BALLOON_VELX_NEGATIVE, BALLOON_VELX_NEGATIVE};
+        const auto luck = rand() % values;
+        const int x[values] = {left, left, center, center, right, right};
+        const float vx[values] = {BALLOON_VELX_POSITIVE, BALLOON_VELX_POSITIVE, BALLOON_VELX_POSITIVE, BALLOON_VELX_NEGATIVE, BALLOON_VELX_NEGATIVE, BALLOON_VELX_NEGATIVE};

-    balloons_.emplace_back(std::make_unique<Balloon>(x[luck], pos_y, BalloonType::POWERBALL, BalloonSize::SIZE4, vx[luck], balloon_speed_, creation_time, play_area_, balloon_textures_[4], balloon_animations_[4]));
+        balloons_.emplace_back(std::make_unique<Balloon>(x[luck], pos_y, BalloonType::POWERBALL, BalloonSize::SIZE4, vx[luck], balloon_speed_, creation_time, play_area_, balloon_textures_[4], balloon_animations_[4]));
+        balloons_.back()->setInvulnerable(true);

-    power_ball_enabled_ = true;
-    power_ball_counter_ = POWERBALL_COUNTER;
+        power_ball_enabled_ = true;
+        power_ball_counter_ = POWERBALL_COUNTER;
+    }
 }

 // Establece la velocidad de los globos
--- a/source/balloon_manager.h
+++ b/source/balloon_manager.h
@@ -34,6 +34,7 @@ private:
    int last_balloon_deploy_ = 0;                    // Guarda cual ha sido la última formación desplegada para no repetir;
    SDL_Rect play_area_ = param.game.play_area.rect; // Zona por donde se moveran los globos
    bool creation_time_enabled_ = true;              // Indica si los globos se crean con tiempo
+    bool can_deploy_balloons_ = true;                // Indica si creará globos

    // Inicializa
    void init();
@@ -128,4 +129,5 @@ public:
    void resetBalloonSpeed() { setBalloonSpeed(default_balloon_speed_); }
    void setPlayArea(SDL_Rect play_area) { play_area_ = play_area; }
    void setCreationTimeEnabled(bool value) { creation_time_enabled_ = value; }
+    void setDeployBalloons(bool value) { can_deploy_balloons_ = value; }
 };
--- a/source/credits.cpp
+++ b/source/credits.cpp
@@ -1,28 +1,31 @@
+// IWYU pragma: no_include <bits/std_abs.h>
 #include "credits.h"
 #include <SDL2/SDL_blendmode.h> // Para SDL_BLENDMODE_BLEND
 #include <SDL2/SDL_events.h>    // Para SDL_PollEvent, SDL_Event, SDL_QUIT
 #include <SDL2/SDL_pixels.h>    // Para SDL_PIXELFORMAT_RGBA8888
-#include <SDL2/SDL_rect.h>      // Para SDL_Rect
 #include <SDL2/SDL_timer.h>     // Para SDL_GetTicks
-#include <algorithm>
-#include <cstdlib>
-#include <string>            // Para basic_string, string
-#include <vector>            // Para vector
-#include "balloon_manager.h" // Para BalloonManager
-#include "global_inputs.h"   // Para check
-#include "input.h"           // Para Input
-#include "jail_audio.h"      // Para JA_PlayMusic, JA_StopMusic
-#include "param.h"           // Para Param, ParamGame, param
-#include "resource.h"        // Para Resource
-#include "screen.h"          // Para Screen
-#include "section.h"         // Para Name, name, Options, options
-#include "text.h"            // Para Text, TEXT_CENTER, TEXT_SHADOW
-#include "tiled_bg.h"        // Para TiledBG, TiledBGMode
-#include "utils.h"           // Para Color, no_color, shdw_txt_color, Zone
-#include "player.h"
-#include "fade.h"
-#include "lang.h"
-#include "mouse.h"
+#include <algorithm>            // Para max, min, clamp
+#include <cstdlib>              // Para abs
+#include <stdexcept>            // Para runtime_error
+#include <string>               // Para basic_string, string
+#include <vector>               // Para vector
+#include "balloon_manager.h"    // Para BalloonManager
+#include "fade.h"               // Para Fade, FadeType, FadeMode
+#include "global_inputs.h"      // Para check, update
+#include "input.h"              // Para Input
+#include "jail_audio.h"         // Para JA_GetMusicState, JA_SetMusicVolume
+#include "lang.h"               // Para getText
+#include "mouse.h"              // Para handleEvent
+#include "param.h"              // Para Param, ParamGame, param
+#include "player.h"             // Para Player, PlayerState
+#include "resource.h"           // Para Resource
+#include "screen.h"             // Para Screen
+#include "section.h"            // Para Name, name, Options, options
+#include "sprite.h"             // Para Sprite
+#include "text.h"               // Para Text, TEXT_CENTER, TEXT_SHADOW
+#include "texture.h"            // Para Texture
+#include "tiled_bg.h"           // Para TiledBG, TiledBGMode
+#include "utils.h"              // Para Color, Zone, shdw_txt_color, no_color

 // Textos
 constexpr const char TEXT_COPYRIGHT[] = "@2020,2025 JailDesigner";
@@ -31,6 +34,7 @@ constexpr const char TEXT_COPYRIGHT[] = "@2020,2025 JailDesigner";
 Credits::Credits()
    : balloon_manager_(std::make_unique<BalloonManager>()),
      text_texture_(SDL_CreateTexture(Screen::get()->getRenderer(), SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height)),
+      canvas_(SDL_CreateTexture(Screen::get()->getRenderer(), SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height)),
      tiled_bg_(std::make_unique<TiledBG>(param.game.game_area.rect, TiledBGMode::DIAGONAL)),
      fade_in_(std::make_unique<Fade>()),
      fade_out_(std::make_unique<Fade>())
@@ -62,6 +66,7 @@ Credits::Credits()
 Credits::~Credits()
 {
    SDL_DestroyTexture(text_texture_);
+    SDL_DestroyTexture(canvas_);
    resetVolume();
 }

@@ -80,21 +85,29 @@ void Credits::run()
 // Actualiza las variables
 void Credits::update()
 {
-    if (SDL_GetTicks() - ticks_ > ticks_speed_)
+    constexpr Uint32 TICKS_SPEED_ = 15;
+
+    if (SDL_GetTicks() - ticks_ > TICKS_SPEED_)
    {
        ticks_ = SDL_GetTicks();
-        tiled_bg_->update();
-        balloon_manager_->update();
-        updateTextureDstRects();
-        throwBalloons();
-        for (auto &player : players_)
+        const int repeat = want_to_pass_ ? 4 : 1;
+        for (int i = 0; i < repeat; ++i)
        {
-            player->update();
+            tiled_bg_->update();
+            balloon_manager_->update();
+            updateTextureDstRects();
+            throwBalloons();
+            for (auto &player : players_)
+            {
+                player->update();
+            }
+            updateAllFades();
+            ++counter_;
        }
-        updateAllFades();
        Screen::get()->update();
        globalInputs::update();
-        ++counter_;
+
+        fillCanvas();
    }
 }

@@ -104,42 +117,11 @@ void Credits::render()
    // Prepara para empezar a dibujar en la textura de juego
    Screen::get()->start();

-    // Limpia la pantalla
-    Screen::get()->clean();
-
-    // Dibuja el fondo, los globos y los jugadores
-    tiled_bg_->render();
-    balloon_manager_->render();
-    for (auto const &player : players_)
-    {
-        player->render();
-    }
-
-    // Dibuja los titulos de credito
-    SDL_RenderCopy(Screen::get()->getRenderer(), text_texture_, &credits_rect_src_, &credits_rect_dst_);
-
-    // Dibuja el mini_logo
-    SDL_RenderCopy(Screen::get()->getRenderer(), text_texture_, &mini_logo_rect_src_, &mini_logo_rect_dst_);
-
-    // Dibuja los rectangulos negros
-    SDL_SetRenderDrawColor(Screen::get()->getRenderer(), 0, 0, 0, 255);
-    SDL_RenderFillRect(Screen::get()->getRenderer(), &top_black_rect_);
-    SDL_RenderFillRect(Screen::get()->getRenderer(), &bottom_black_rect_);
-    SDL_RenderFillRect(Screen::get()->getRenderer(), &left_black_rect_);
-    SDL_RenderFillRect(Screen::get()->getRenderer(), &right_black_rect_);
-
-    // Si el mini_logo está en su destino, lo dibuja encima de lo anterior
-    if (mini_logo_on_position_)
-    {
-        SDL_RenderCopy(Screen::get()->getRenderer(), text_texture_, &mini_logo_rect_src_, &mini_logo_rect_dst_);
-    }
-
-    // Dibuja el fade sobre el resto de elementos
-    fade_in_->render();
-    fade_out_->render();
+    // Copia la textura con la zona de juego a la pantalla
+    SDL_RenderCopy(Screen::get()->getRenderer(), canvas_, nullptr, nullptr);

    // Vuelca el contenido del renderizador en pantalla
-    Screen::get()->blit();
+    Screen::get()->render();
 }

 // Comprueba el manejador de eventos
@@ -178,7 +160,6 @@ void Credits::checkInput()
        {
            // Si todavía estan los creditos en marcha, se pasan solos a toda pastilla
            want_to_pass_ = true;
-            ticks_speed_ = 1;
        }
    }

@@ -275,6 +256,48 @@ void Credits::fillTextTexture()
    mini_logo_final_pos_ = param.game.game_area.center_y - mini_logo_rect_src_.h / 2;
 }

+// Dibuja todos los sprites en la textura
+void Credits::fillCanvas()
+{
+    // Cambia el destino del renderizador
+    auto temp = SDL_GetRenderTarget(Screen::get()->getRenderer());
+    SDL_SetRenderTarget(Screen::get()->getRenderer(), canvas_);
+
+    // Dibuja el fondo, los globos y los jugadores
+    tiled_bg_->render();
+    balloon_manager_->render();
+    for (auto const &player : players_)
+    {
+        player->render();
+    }
+
+    // Dibuja los titulos de credito
+    SDL_RenderCopy(Screen::get()->getRenderer(), text_texture_, &credits_rect_src_, &credits_rect_dst_);
+
+    // Dibuja el mini_logo
+    SDL_RenderCopy(Screen::get()->getRenderer(), text_texture_, &mini_logo_rect_src_, &mini_logo_rect_dst_);
+
+    // Dibuja los rectangulos negros
+    SDL_SetRenderDrawColor(Screen::get()->getRenderer(), 0, 0, 0, 255);
+    SDL_RenderFillRect(Screen::get()->getRenderer(), &top_black_rect_);
+    SDL_RenderFillRect(Screen::get()->getRenderer(), &bottom_black_rect_);
+    SDL_RenderFillRect(Screen::get()->getRenderer(), &left_black_rect_);
+    SDL_RenderFillRect(Screen::get()->getRenderer(), &right_black_rect_);
+
+    // Si el mini_logo está en su destino, lo dibuja encima de lo anterior
+    if (mini_logo_on_position_)
+    {
+        SDL_RenderCopy(Screen::get()->getRenderer(), text_texture_, &mini_logo_rect_src_, &mini_logo_rect_dst_);
+    }
+
+    // Dibuja el fade sobre el resto de elementos
+    fade_in_->render();
+    fade_out_->render();
+
+    // Deja el renderizador apuntando donde estaba
+    SDL_SetRenderTarget(Screen::get()->getRenderer(), temp);
+}
+
 // Actualiza el destino de los rectangulos de las texturas
 void Credits::updateTextureDstRects()
 {
--- a/source/credits.h
+++ b/source/credits.h
@@ -1,14 +1,17 @@
 #pragma once

+#include <SDL2/SDL_rect.h>   // Para SDL_Rect
 #include <SDL2/SDL_render.h> // Para SDL_Texture
 #include <SDL2/SDL_stdinc.h> // Para Uint32
-#include <memory>            // Para unique_ptr
-#include "param.h"
-#include "options.h"
-class BalloonManager;
-class TiledBG;
-class Player;
-class Fade;
+#include <memory>            // Para unique_ptr, shared_ptr
+#include <vector>            // Para vector
+#include "options.h"         // Para Options, OptionsAudio, OptionsMusic
+#include "param.h"           // Para Param, ParamGame, param
+#include "utils.h"           // Para Zone
+class BalloonManager;        // lines 8-8
+class Fade;                  // lines 11-11
+class Player;                // lines 10-10
+class TiledBG;               // lines 9-9

 constexpr int PLAY_AREA_HEIGHT = 200;

@@ -18,6 +21,7 @@ private:
    // Objetos
    std::unique_ptr<BalloonManager> balloon_manager_; // Objeto para gestionar los globos
    SDL_Texture *text_texture_;                       // Textura con el texto
+    SDL_Texture *canvas_;                             // Textura donde dibujarlo todo
    std::unique_ptr<TiledBG> tiled_bg_;               // Objeto para dibujar el mosaico animado de fondo
    std::unique_ptr<Fade> fade_in_;                   // Objeto para realizar el fundido de entrada
    std::unique_ptr<Fade> fade_out_;                  // Objeto para realizar el fundido de salida
@@ -25,7 +29,6 @@ private:

    // Variables
    Uint32 ticks_ = 0;                                                           // Contador de ticks para ajustar la velocidad del programa
-    Uint32 ticks_speed_ = 15;                                                    // Velocidad del bucle update
    Uint32 counter_ = 0;                                                         // Contador para la lógica de la clase
    Uint32 counter_pre_fade_ = 0;                                                // Contador para activar el fundido final
    Uint32 counter_prevent_endless_ = 0;                                         // Contador para evitar que el juego se quede para siempre en los creditos
@@ -67,6 +70,9 @@ private:
    // Crea la textura con el texto
    void fillTextTexture();

+    // Dibuja todos los sprites en la textura
+    void fillCanvas();
+
    // Actualiza el destino de los rectangulos de las texturas
    void updateTextureDstRects();

--- a/source/director.cpp
+++ b/source/director.cpp
@@ -8,44 +8,42 @@
 #include <SDL2/SDL_hints.h>			 // Para SDL_SetHint, SDL_HINT_RENDER_DR...
 #include <SDL2/SDL_scancode.h>		 // Para SDL_SCANCODE_0, SDL_SCANCODE_DOWN
 #include <SDL2/SDL_stdinc.h>		 // Para SDL_bool, Uint32
-#include <chrono>					 // Para duration, system_clock
 #include <errno.h>					 // Para errno, EEXIST, EACCES, ENAMETOO...
-#include <stdio.h>					 // Para printf, perror
-#include <sys/stat.h>				 // Para mkdir, stat, S_IRWXU
-#include <unistd.h>					 // Para getuid
-#include <algorithm>				 // Para min
-#include <cstdlib>					 // Para exit, EXIT_FAILURE, size_t, rand
-#include <iostream>					 // Para basic_ostream, operator<<, basi...
-#include <memory>					 // Para make_unique, unique_ptr
-#include <stdexcept>				 // Para runtime_error
-#include <string>					 // Para operator+, char_traits, allocator
-#include <vector>					 // Para vector
-#include "asset.h"					 // Para Asset, AssetType
-#include "credits.h"				 // Para Credits
-#include "dbgtxt.h"					 // Para dbg_init
-#include "game.h"					 // Para Game, GAME_MODE_DEMO_OFF, GAME_...
-#include "global_inputs.h"			 // Para init
-#include "hiscore_table.h"			 // Para HiScoreTable
-#include "input.h"					 // Para Input, InputType
-#include "instructions.h"			 // Para Instructions
-#include "intro.h"					 // Para Intro
-#include "jail_audio.h"				 // Para JA_SetMusicVolume, JA_SetSoundV...
-#include "lang.h"					 // Para Code, loadFromFile
-#include "logo.h"					 // Para Logo
-#include "manage_hiscore_table.h"	 // Para ManageHiScoreTable
-#include "notifier.h"				 // Para Notifier
-#include "on_screen_help.h"			 // Para OnScreenHelp
-#include "options.h"				 // Para Options, OptionsController, opt...
-#include "param.h"					 // Para Param, ParamGame, param, loadPa...
-#include "resource.h"				 // Para Resource
-#include "screen.h"					 // Para Screen
-#include "section.h"				 // Para Name, Options, name, options
-#include "title.h"					 // Para Title
-#include "utils.h"					 // Para Overrides, overrides
-
 #ifndef _WIN32
-#include <pwd.h> // para getpwuid, passwd
+#include <pwd.h> // Para getpwuid, passwd
 #endif
+#include <stdio.h>				  // Para printf, perror
+#include <sys/stat.h>			  // Para mkdir, stat, S_IRWXU
+#include <unistd.h>				  // Para getuid
+#include <algorithm>			  // Para min
+#include <chrono>				  // Para chrono
+#include <cstdlib>				  // Para exit, EXIT_FAILURE, size_t, rand
+#include <iostream>				  // Para basic_ostream, operator<<, basi...
+#include <memory>				  // Para make_unique, unique_ptr
+#include <stdexcept>			  // Para runtime_error
+#include <string>				  // Para operator+, char_traits, allocator
+#include <vector>				  // Para vector
+#include "asset.h"				  // Para Asset, AssetType
+#include "credits.h"			  // Para Credits
+#include "dbgtxt.h"				  // Para dbg_init
+#include "game.h"				  // Para Game, GAME_MODE_DEMO_OFF, GAME_...
+#include "hiscore_table.h"		  // Para HiScoreTable
+#include "input.h"				  // Para Input, InputType
+#include "instructions.h"		  // Para Instructions
+#include "intro.h"				  // Para Intro
+#include "jail_audio.h"			  // Para JA_SetMusicVolume, JA_SetSoundV...
+#include "lang.h"				  // Para Code, loadFromFile
+#include "logo.h"				  // Para Logo
+#include "manage_hiscore_table.h" // Para ManageHiScoreTable
+#include "notifier.h"			  // Para Notifier
+#include "on_screen_help.h"		  // Para OnScreenHelp
+#include "options.h"			  // Para Options, options, OptionsContro...
+#include "param.h"				  // Para Param, ParamGame, param, loadPa...
+#include "resource.h"			  // Para Resource
+#include "screen.h"				  // Para Screen
+#include "section.h"			  // Para Name, Options, name, options
+#include "title.h"				  // Para Title
+#include "utils.h"				  // Para Overrides, overrides

 // Constructor
 Director::Director(int argc, const char *argv[])
@@ -54,7 +52,7 @@ Director::Director(int argc, const char *argv[])
 	section::name = section::Name::GAME;
 	section::options = section::Options::GAME_PLAY_1P;
 #elif DEBUG
-	section::name = section::Name::CREDITS;
+	section::name = section::Name::LOGO;
 #else // NORMAL GAME
 	section::name = section::Name::LOGO;
 	section::attract_mode = section::AttractMode::TITLE_TO_DEMO;
@@ -467,6 +465,8 @@ void Director::setFileList()
 		Asset::get()->add(prefix + "/data/gfx/game/game_grass.png", AssetType::BITMAP);
 		Asset::get()->add(prefix + "/data/gfx/game/game_power_meter.png", AssetType::BITMAP);
 		Asset::get()->add(prefix + "/data/gfx/game/game_sky_colors.png", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/game/game_sun.png", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/game/game_moon.png", AssetType::BITMAP);
 	}

 	{ // Intro
--- a/source/fade.cpp
+++ b/source/fade.cpp
@@ -55,7 +55,7 @@ void Fade::reset()
 // Pinta una transición en pantalla
 void Fade::render()
 {
-	//if (state_ != FadeState::NOT_ENABLED)
+	if (state_ != FadeState::NOT_ENABLED)
 	{
 		SDL_RenderCopy(renderer_, backbuffer_, nullptr, nullptr);
 	}
@@ -132,9 +132,11 @@ void Fade::update()
 		{
 			if (counter_ % fade_random_squares_delay_ == 0)
 			{
-				// Dibuja sobre el backbuffer_
+				// Cambia el renderizador al backbuffer_ y modifica sus opciones
 				auto temp = SDL_GetRenderTarget(renderer_);
 				SDL_SetRenderTarget(renderer_, backbuffer_);
+				SDL_BlendMode blend_mode;
+				SDL_GetRenderDrawBlendMode(renderer_, &blend_mode);
 				SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_NONE);
 				SDL_SetRenderDrawColor(renderer_, r_, g_, b_, a_);

@@ -147,6 +149,7 @@ void Fade::update()
 				}

 				// Deja el renderizador como estaba
+				SDL_SetRenderDrawBlendMode(renderer_, blend_mode);
 				SDL_SetRenderTarget(renderer_, temp);
 			}

@@ -169,6 +172,8 @@ void Fade::update()
 				// Dibuja sobre el backbuffer_
 				auto temp = SDL_GetRenderTarget(renderer_);
 				SDL_SetRenderTarget(renderer_, backbuffer_);
+				SDL_BlendMode blend_mode;
+				SDL_GetRenderDrawBlendMode(renderer_, &blend_mode);
 				SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_NONE);
 				SDL_SetRenderDrawColor(renderer_, r_, g_, b_, a_);

@@ -179,6 +184,7 @@ void Fade::update()
 				}

 				// Deja el renderizador como estaba
+				SDL_SetRenderDrawBlendMode(renderer_, blend_mode);
 				SDL_SetRenderTarget(renderer_, temp);

 				// Modifica el tamaño de los rectangulos
--- a/source/game.cpp
+++ b/source/game.cpp
@@ -15,13 +15,14 @@
 #include "balloon_manager.h"	  // Para BalloonManager
 #include "bullet.h"				  // Para Bullet, BulletType, BulletMoveStatus
 #include "enter_name.h"			  // Para NAME_LENGHT
-#include "fade.h"				  // Para Fade, FadeType
-#include "global_inputs.h"		  // Para check
+#include "fade.h"				  // Para Fade, FadeType, FadeMode
+#include "global_inputs.h"		  // Para check, update
 #include "input.h"				  // Para InputType, Input, INPUT_DO_NOT_ALL...
 #include "item.h"				  // Para Item, ItemType
 #include "jail_audio.h"			  // Para JA_PlaySound, JA_GetMusicState
 #include "lang.h"				  // Para getText
 #include "manage_hiscore_table.h" // Para ManageHiScoreTable, HiScoreEntry
+#include "mouse.h"				  // Para handleEvent
 #include "notifier.h"			  // Para Notifier
 #include "param.h"				  // Para Param, param, ParamGame, ParamFade
 #include "path_sprite.h"		  // Para Path, PathSprite, createPath, Path...
@@ -29,14 +30,12 @@
 #include "resource.h"			  // Para Resource
 #include "scoreboard.h"			  // Para Scoreboard, ScoreboardMode, SCOREB...
 #include "screen.h"				  // Para Screen
-#include "section.h"			  // Para Name, name, Options, options
+#include "section.h"			  // Para Name, name, AttractMode, Options
 #include "smart_sprite.h"		  // Para SmartSprite
-#include "stage.h"				  // Para number, get, Stage, power, total_p...
+#include "stage.h"				  // Para number, get, Stage, total_power
 #include "tabe.h"				  // Para Tabe
 #include "text.h"				  // Para Text
 #include "texture.h"			  // Para Texture
-#include "mouse.h"
-struct JA_Sound_t; // lines 37-37

 // Constructor
 Game::Game(int player_id, int current_stage, bool demo)
@@ -401,7 +400,7 @@ void Game::updateGameStateCompleted()
 	// Si los jugadores ya no estan y no quedan mensajes en pantalla
 	if (allPlayersAreGameOver() && path_sprites_.size() == 0)
 	{
-		state_ = GameState::GAME_OVER;
+		setState(GameState::GAME_OVER);
 	}

 	// Incrementa el contador al final
@@ -413,12 +412,12 @@ void Game::checkState()
 {
 	if (state_ != GameState::COMPLETED && Stage::number == 10)
 	{
-		state_ = GameState::COMPLETED;
+		setState(GameState::COMPLETED);
 	}

 	if (state_ != GameState::GAME_OVER && allPlayersAreGameOver())
 	{
-		state_ = GameState::GAME_OVER;
+		setState(GameState::GAME_OVER);
 	}
 }

@@ -855,8 +854,8 @@ void Game::renderPathSprites()
 void Game::killPlayer(std::shared_ptr<Player> &player)
 {
 	if (!player->isPlaying() || player->isInvulnerable())
-	{ 
-		 // Si no está jugando o tiene inmunidad, no hace nada
+	{
+		// Si no está jugando o tiene inmunidad, no hace nada
 		return;
 	}

@@ -918,7 +917,6 @@ void Game::update()
 	if (SDL_GetTicks() - ticks_ > TICKS_SPEED)
 	{
 		ticks_ = SDL_GetTicks();
-		counter_++;

 		updateDemo();
 #ifdef RECORDING
@@ -928,15 +926,6 @@ void Game::update()
 		{
 			switch (state_)
 			{
-			case GameState::COMPLETED:
-				updateGameStateCompleted();
-				break;
-			case GameState::GAME_OVER:
-				updateGameStateGameOver();
-				break;
-			case GameState::PLAYING:
-				updateGameStatePlaying();
-				break;
 			case GameState::FADE_IN:
 				updateGameStateFadeIn();
 				break;
@@ -946,13 +935,20 @@ void Game::update()
 			case GameState::SHOWING_GET_READY_MESSAGE:
 				updateGameStateShowingGetReadyMessage();
 				break;
-
+			case GameState::PLAYING:
+				updateGameStatePlaying();
+				break;
+			case GameState::COMPLETED:
+				updateGameStateCompleted();
+				break;
+			case GameState::GAME_OVER:
+				updateGameStateGameOver();
+				break;
 			default:
 				break;
 			}
 		}

-		checkMusicStatus();
 		screen_->update();
 		globalInputs::update();
 		fillCanvas();
@@ -965,13 +961,13 @@ void Game::updateBackground()
 	// Si el juego está completado, se reduce la velocidad de las nubes
 	if (state_ == GameState::COMPLETED)
 	{
-		Stage::total_power = (Stage::total_power > 400) ? (Stage::total_power - 25) : 200;
+		Stage::total_power = (Stage::total_power > 200) ? (Stage::total_power - 25) : 200;
 	}

 	// Calcula la velocidad en función de los globos explotados y el total de globos a explotar para acabar el juego
-	constexpr float clouds_initial_speed = 0.05f;
-	constexpr float clouds_final_speed = 2.00f - clouds_initial_speed;
-	const float cloudsSpeed = (-clouds_initial_speed) + (-clouds_final_speed * (static_cast<float>(Stage::total_power) / total_power_to_complete_game_));
+	constexpr float CLOUDS_INITIAL_SPEED = 0.05f;
+	constexpr float CLOUDS_FINAL_SPEED = 2.00f - CLOUDS_INITIAL_SPEED;
+	const float cloudsSpeed = (-CLOUDS_INITIAL_SPEED) + (-CLOUDS_FINAL_SPEED * (static_cast<float>(Stage::total_power) / total_power_to_complete_game_));
 	background_->setCloudsSpeed(cloudsSpeed);

 	// Calcula la transición de los diferentes fondos
@@ -981,6 +977,11 @@ void Game::updateBackground()
 	background_->setGradientNumber(static_cast<int>(gradient_number));
 	background_->setTransition(percent);

+	// Calcula la posición del sol
+	constexpr float sun_final_power = num * 2;
+	background_->setSunProgression(Stage::total_power / sun_final_power);
+	background_->setMoonProgression(Stage::total_power / static_cast<float>(total_power_to_complete_game_));
+
 	// Actualiza el objeto
 	background_->update();
 }
@@ -1023,7 +1024,7 @@ void Game::render()
 	fade_out_->render();

 	// Vuelca el contenido del renderizador en pantalla
-	screen_->blit();
+	screen_->render();
 }

 // Habilita el efecto del item de detener el tiempo
@@ -1042,16 +1043,6 @@ void Game::disableTimeStopItem()
 	balloon_manager_->normalColorsToAllBalloons();
 }

-// Comprueba si la música ha de estar sonando
-void Game::checkMusicStatus()
-{
-	// Si se ha completado el juego o los jugadores han terminado, detiene la música
-	if (state_ == GameState::PLAYING || state_ == GameState::SHOWING_GET_READY_MESSAGE)
-	{
-		playMusic();
-	}
-}
-
 // Bucle para el juego
 void Game::run()
 {
@@ -1199,7 +1190,6 @@ void Game::checkEvents()
 				pause(!demo_.enabled);
 				break;
 			}
-
 			case SDL_WINDOWEVENT_FOCUS_GAINED:
 			{
 				pause(false);
@@ -1233,7 +1223,9 @@ void Game::checkEvents()
 			case SDLK_3: // Activa el modo para pasar el juego automaticamente
 			{
 				auto_pop_balloons_ = !auto_pop_balloons_;
-				Notifier::get()->showText({"auto_pop_balloons_ " + boolToString(auto_pop_balloons_)});
+				Notifier::get()->showText({"auto advance: " + boolToString(auto_pop_balloons_)});
+				balloon_manager_->destroyAllBalloons();
+				balloon_manager_->setDeployBalloons(!auto_pop_balloons_);
 				break;
 			}
 			case SDLK_4: // Suelta un item
@@ -1643,7 +1635,7 @@ void Game::initDemo(int player_id)
 	if (demo_.enabled)
 	{
 		// Cambia el estado del juego
-		state_ = GameState::PLAYING;
+		setState(GameState::PLAYING);

 		// Aleatoriza la asignación del fichero con los datos del modo demostracion
 		{
@@ -1690,9 +1682,6 @@ void Game::initDemo(int player_id)
 		// Configura los marcadores
 		scoreboard_->setMode(SCOREBOARD_LEFT_PANEL, ScoreboardMode::DEMO);
 		scoreboard_->setMode(SCOREBOARD_RIGHT_PANEL, ScoreboardMode::DEMO);
-
-		// Añade unos cuantos globos
-		// balloon_manager_->createRandomBalloons();
 	}

 	// Modo grabar demo
@@ -1885,7 +1874,7 @@ void Game::updateGameStateFadeIn()
 	updateBackground();
 	if (fade_in_->hasEnded())
 	{
-		state_ = GameState::ENTERING_PLAYER;
+		setState(GameState::ENTERING_PLAYER);
 		balloon_manager_->createTwoBigBalloons();
 		evaluateAndSetMenace();
 	}
@@ -1902,7 +1891,7 @@ void Game::updateGameStateEnteringPlayer()
 	{
 		if (player->isPlaying())
 		{
-			state_ = GameState::SHOWING_GET_READY_MESSAGE;
+			setState(GameState::SHOWING_GET_READY_MESSAGE);
 			createMessage({paths_.at(0), paths_.at(1)}, Resource::get()->getTexture("game_text_get_ready"));
 			JA_PlaySound(Resource::get()->getSound("voice_get_ready.wav"));
 		}
@@ -1921,8 +1910,13 @@ void Game::updateGameStateShowingGetReadyMessage()
 	freePathSprites();
 	if (path_sprites_.size() == 0)
 	{
-		state_ = GameState::PLAYING;
+		setState(GameState::PLAYING);
 	}
+	if (counter_ == 100)
+	{
+		playMusic();
+	}
+	++counter_;
 }

 // Actualiza las variables durante el transcurso normal del juego
@@ -1931,7 +1925,7 @@ void Game::updateGameStatePlaying()
 #ifdef DEBUG
 	if (auto_pop_balloons_)
 	{
-		Stage::addPower(20);
+		Stage::addPower(5);
 	}
 #endif
 	updatePlayers();
@@ -1952,6 +1946,7 @@ void Game::updateGameStatePlaying()
 	checkAndUpdateBalloonSpeed();
 	checkState();
 	cleanVectors();
+	playMusic();
 }

 // Vacía los vectores de elementos deshabilitados
@@ -2011,4 +2006,11 @@ void Game::checkAndUpdateBalloonSpeed()
 			break; // Salir del bucle una vez actualizada la velocidad y aplicada
 		}
 	}
+}
+
+// Cambia el estado del juego
+void Game::setState(GameState state)
+{
+	state_ = state;
+	counter_ = 0;
 }
--- a/source/game.h
+++ b/source/game.h
@@ -310,9 +310,6 @@ private:
 	// Pausa el juego
 	void pause(bool value);

-	// Comprueba si la música ha de estar sonando
-	void checkMusicStatus();
-
 	// Añade una puntuación a la tabla de records
 	void addScoreToScoreBoard(const std::string &name, int score);

@@ -421,6 +418,9 @@ private:
 	// Actualiza la velocidad de los globos en funcion del poder acumulado de la fase
 	void checkAndUpdateBalloonSpeed();

+	// Cambia el estado del juego
+	void setState(GameState state);
+
 public:
 	// Constructor
 	Game(int playerID, int current_stage, bool demo);
--- a/source/game_logo.cpp
+++ b/source/game_logo.cpp
@@ -1,15 +1,15 @@
 #include "game_logo.h"
-#include <SDL2/SDL.h>
 #include <SDL2/SDL_render.h> // Para SDL_FLIP_HORIZONTAL
 #include <algorithm>         // Para max
 #include "animated_sprite.h" // Para AnimatedSprite
 #include "jail_audio.h"      // Para JA_PlaySound
 #include "param.h"           // Para Param, param, ParamGame, ParamTitle
 #include "resource.h"        // Para Resource
+#include "screen.h"          // Para Screen
 #include "smart_sprite.h"    // Para SmartSprite
 #include "sprite.h"          // Para Sprite
 #include "texture.h"         // Para Texture
-#include "screen.h"
+#include "utils.h"           // Para Color

 constexpr int ZOOM_FACTOR = 5;
 constexpr int FLASH_DELAY = 3;
--- a/source/global_inputs.cpp
+++ b/source/global_inputs.cpp
@@ -1,15 +1,16 @@
 #include "global_inputs.h"
-#include <string>  // Para operator+, string
-#include "input.h" // Para Input, InputType, INPUT_DO_NOT_ALLOW_REPEAT
-#include "asset.h"
-#include "jail_audio.h"     // Para JA_EnableMusic, JA_EnableSound
-#include "lang.h"           // Para getText
+#include <string>           // Para operator+, string, to_string, basic_string
+#include <vector>           // Para vector
+#include "asset.h"          // Para Asset
+#include "input.h"          // Para Input, InputDeviceToUse, InputType, INPU...
+#include "jail_audio.h"     // Para JA_SetMusicVolume, JA_SetSoundVolume
+#include "lang.h"           // Para Code, getText, change, loadFromFile
 #include "notifier.h"       // Para Notifier
 #include "on_screen_help.h" // Para OnScreenHelp
-#include "options.h"        // Para Options, OptionsAudio, options, OptionsM...
+#include "options.h"        // Para Options, options, OptionsGame, OptionsAudio
+#include "screen.h"         // Para Screen, ScreenVideoMode
 #include "section.h"        // Para Name, Options, name, options
 #include "utils.h"          // Para boolToOnOff, stringInVector
-#include "screen.h"

 namespace globalInputs
 {
--- a/source/global_inputs.h
+++ b/source/global_inputs.h
@@ -1,4 +1,3 @@
-#include <vector>
 namespace globalInputs
 {
    extern int service_pressed_counter;
--- a/source/hiscore_table.cpp
+++ b/source/hiscore_table.cpp
@@ -43,6 +43,8 @@ HiScoreTable::HiScoreTable()
 	background_->setCloudsSpeed(-0.1f);
 	background_->setGradientNumber(1);
 	background_->setTransition(0.8f);
+	background_->setSunProgression(1.0f);
+	background_->setMoonProgression(0.6f);
 	fade_->setColor(fade_color.r, fade_color.g, fade_color.b);
 	fade_->setType(FadeType::RANDOM_SQUARE);
 	fade_->setPostDuration(param.fade.post_duration);
@@ -164,7 +166,7 @@ void HiScoreTable::render()
 	fade_->render();

 	// Vuelca el contenido del renderizador en pantalla
-	Screen::get()->blit();
+	Screen::get()->render();
 }

 // Recarga todas las texturas
--- a/source/instructions.cpp
+++ b/source/instructions.cpp
@@ -265,7 +265,7 @@ void Instructions::render()
 	fade_->render();

 	// Vuelca el contenido del renderizador en pantalla
-	Screen::get()->blit();
+	Screen::get()->render();
 }

 // Recarga todas las texturas
--- a/source/intro.cpp
+++ b/source/intro.cpp
@@ -415,7 +415,7 @@ void Intro::render()
 	}

 	// Vuelca el contenido del renderizador en pantalla
-	Screen::get()->blit();
+	Screen::get()->render();
 }

 // Bucle principal
--- a/source/jail_audio.cpp
+++ b/source/jail_audio.cpp
@@ -1,42 +1,48 @@
 #ifndef JA_USESDLMIXER
 #include "jail_audio.h"
-#include "stb_vorbis.c"
-#include <SDL2/SDL.h>
-#include <stdio.h>
+#include <SDL2/SDL_rwops.h> // Para SDL_RWFromMem
+#include <SDL2/SDL_timer.h> // Para SDL_GetTicks
+#include <stdint.h>         // Para uint8_t, uint32_t
+#include <stdio.h>          // Para NULL, fseek, fclose, fopen, fread, ftell
+#include <stdlib.h>         // Para free, malloc
+#include "stb_vorbis.c"     // Para stb_vorbis_decode_memory

 #define JA_MAX_SIMULTANEOUS_CHANNELS 20

-struct JA_Sound_t {
-    Uint32  length {0};
-    Uint8*  buffer {NULL};
+struct JA_Sound_t
+{
+    Uint32 length{0};
+    Uint8 *buffer{NULL};
 };

-struct JA_Channel_t {
-    JA_Sound_t          *sound;
-    int                 pos {0};
-    int                 times {0};
-    JA_Channel_state    state { JA_CHANNEL_FREE };
+struct JA_Channel_t
+{
+    JA_Sound_t *sound;
+    int pos{0};
+    int times{0};
+    JA_Channel_state state{JA_CHANNEL_FREE};
 };

-struct JA_Music_t {
-    int             samples {0};
-    Uint32          length {0};
-    int             pos {0};
-    int             times {0};
-    short*          output {NULL};
-    JA_Music_state  state {JA_MUSIC_INVALID};
+struct JA_Music_t
+{
+    int samples{0};
+    Uint32 length{0};
+    int pos{0};
+    int times{0};
+    short *output{NULL};
+    JA_Music_state state{JA_MUSIC_INVALID};
 };

-JA_Music_t      *current_music{NULL};
-JA_Channel_t    channels[JA_MAX_SIMULTANEOUS_CHANNELS];
+JA_Music_t *current_music{NULL};
+JA_Channel_t channels[JA_MAX_SIMULTANEOUS_CHANNELS];

-int             JA_freq {48000};
-SDL_AudioFormat JA_format {AUDIO_S16};
-Uint8           JA_channels {2};
-int             JA_musicVolume = 128;
-int             JA_soundVolume = 64;
-bool            JA_musicEnabled = true;
-bool            JA_soundEnabled = true;
+int JA_freq{48000};
+SDL_AudioFormat JA_format{AUDIO_S16};
+Uint8 JA_channels{2};
+int JA_musicVolume = 128;
+int JA_soundVolume = 64;
+bool JA_musicEnabled = true;
+bool JA_soundEnabled = true;
 SDL_AudioDeviceID sdlAudioDevice = 0;

 bool fading = false;
@@ -44,49 +50,67 @@ int fade_start_time;
 int fade_duration;
 int fade_initial_volume;

-void audioCallback(void * userdata, uint8_t * stream, int len) {
+void audioCallback(void *userdata, uint8_t *stream, int len)
+{
    SDL_memset(stream, 0, len);
-    if (current_music != NULL && current_music->state == JA_MUSIC_PLAYING) {
+    if (current_music != NULL && current_music->state == JA_MUSIC_PLAYING)
+    {
        int volume = JA_musicVolume;
-        if (fading) {
+        if (fading)
+        {
            int time = SDL_GetTicks();
-            if (time > (fade_start_time+fade_duration)) {
+            if (time > (fade_start_time + fade_duration))
+            {
                fading = false;
                current_music->pos = 0;
                current_music->state = JA_MUSIC_STOPPED;
                volume = 0;
-            } else {
+            }
+            else
+            {
                const int time_passed = time - fade_start_time;
                const float percent = (float)time_passed / (float)fade_duration;
                volume = JA_musicVolume * (1.0 - percent);
            }
        }
        const int size = SDL_min(len, current_music->length - current_music->pos);
-        SDL_MixAudioFormat(stream, (Uint8*)(current_music->output)+current_music->pos, AUDIO_S16, size, volume);
+        SDL_MixAudioFormat(stream, (Uint8 *)(current_music->output) + current_music->pos, AUDIO_S16, size, volume);
        current_music->pos += size;
-        if (size < len) {
-            if (current_music->times != 0) {
-                SDL_MixAudioFormat(stream+size, (Uint8*)current_music->output, AUDIO_S16, len-size, volume);
-                current_music->pos = len-size;
-                if (current_music->times > 0) current_music->times--;
-            } else {
+        if (size < len)
+        {
+            if (current_music->times != 0)
+            {
+                SDL_MixAudioFormat(stream + size, (Uint8 *)current_music->output, AUDIO_S16, len - size, volume);
+                current_music->pos = len - size;
+                if (current_music->times > 0)
+                    current_music->times--;
+            }
+            else
+            {
                current_music->pos = 0;
                current_music->state = JA_MUSIC_STOPPED;
            }
        }
    }
    // Mixar els channels mi amol
-    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
-        if (channels[i].state == JA_CHANNEL_PLAYING) {
+    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
+    {
+        if (channels[i].state == JA_CHANNEL_PLAYING)
+        {
            const int size = SDL_min(len, channels[i].sound->length - channels[i].pos);
            SDL_MixAudioFormat(stream, channels[i].sound->buffer + channels[i].pos, AUDIO_S16, size, JA_soundVolume);
            channels[i].pos += size;
-            if (size < len) {
-                if (channels[i].times != 0) {
-                    SDL_MixAudioFormat(stream + size, channels[i].sound->buffer, AUDIO_S16, len-size, JA_soundVolume);
-                    channels[i].pos = len-size;
-                    if (channels[i].times > 0) channels[i].times--;
-                } else {
+            if (size < len)
+            {
+                if (channels[i].times != 0)
+                {
+                    SDL_MixAudioFormat(stream + size, channels[i].sound->buffer, AUDIO_S16, len - size, JA_soundVolume);
+                    channels[i].pos = len - size;
+                    if (channels[i].times > 0)
+                        channels[i].times--;
+                }
+                else
+                {
                    JA_StopChannel(i);
                }
            }
@@ -100,36 +124,40 @@ void JA_Init(const int freq, const SDL_AudioFormat format, const int channels)
    JA_format = format;
    JA_channels = channels;
    SDL_AudioSpec audioSpec{JA_freq, JA_format, JA_channels, 0, 1024, 0, 0, audioCallback, NULL};
-    if (sdlAudioDevice != 0) SDL_CloseAudioDevice(sdlAudioDevice);
+    if (sdlAudioDevice != 0)
+        SDL_CloseAudioDevice(sdlAudioDevice);
    sdlAudioDevice = SDL_OpenAudioDevice(NULL, 0, &audioSpec, NULL, 0);
    SDL_PauseAudioDevice(sdlAudioDevice, 0);
 }

-void JA_Quit() {
+void JA_Quit()
+{
    SDL_PauseAudioDevice(sdlAudioDevice, 1);
-    if (sdlAudioDevice != 0) SDL_CloseAudioDevice(sdlAudioDevice);
+    if (sdlAudioDevice != 0)
+        SDL_CloseAudioDevice(sdlAudioDevice);
    sdlAudioDevice = 0;
 }

-JA_Music_t *JA_LoadMusic(Uint8* buffer, Uint32 length)
+JA_Music_t *JA_LoadMusic(Uint8 *buffer, Uint32 length)
 {
    int chan, samplerate;
    JA_Music_t *music = new JA_Music_t();

    music->samples = stb_vorbis_decode_memory(buffer, length, &chan, &samplerate, &music->output);
    // [RZC 28/08/22] Abans el descomprimiem mentre el teniem obert
-//    music->samples = stb_vorbis_decode_filename(filename, &chan, &samplerate, &music->output);
+    //    music->samples = stb_vorbis_decode_filename(filename, &chan, &samplerate, &music->output);

    SDL_AudioCVT cvt;
    SDL_BuildAudioCVT(&cvt, AUDIO_S16, chan, samplerate, JA_format, JA_channels, JA_freq);
-    if (cvt.needed) {
+    if (cvt.needed)
+    {
        cvt.len = music->samples * chan * 2;
        music->length = cvt.len;
-        cvt.buf = (Uint8 *) SDL_malloc(cvt.len * cvt.len_mult);
+        cvt.buf = (Uint8 *)SDL_malloc(cvt.len * cvt.len_mult);
        SDL_memcpy(cvt.buf, music->output, cvt.len);
        SDL_ConvertAudio(&cvt);
        free(music->output);
-        music->output = (short*)cvt.buf;
+        music->output = (short *)cvt.buf;
    }
    music->length = music->samples * chan * 2;
    music->pos = 0;
@@ -138,15 +166,16 @@ JA_Music_t *JA_LoadMusic(Uint8* buffer, Uint32 length)
    return music;
 }

-JA_Music_t *JA_LoadMusic(const char* filename)
+JA_Music_t *JA_LoadMusic(const char *filename)
 {
    // [RZC 28/08/22] Carreguem primer el arxiu en memòria i després el descomprimim. Es algo més rapid.
    FILE *f = fopen(filename, "rb");
    fseek(f, 0, SEEK_END);
    long fsize = ftell(f);
    fseek(f, 0, SEEK_SET);
-    Uint8 *buffer = (Uint8*)malloc(fsize + 1);
-    if (fread(buffer, fsize, 1, f)!=1) return NULL;
+    Uint8 *buffer = (Uint8 *)malloc(fsize + 1);
+    if (fread(buffer, fsize, 1, f) != 1)
+        return NULL;
    fclose(f);

    JA_Music_t *music = JA_LoadMusic(buffer, fsize);
@@ -158,9 +187,11 @@ JA_Music_t *JA_LoadMusic(const char* filename)

 void JA_PlayMusic(JA_Music_t *music, const int loop)
 {
-    if (!JA_musicEnabled) return;
+    if (!JA_musicEnabled)
+        return;

-    if (current_music != NULL) {
+    if (current_music != NULL)
+    {
        current_music->pos = 0;
        current_music->state = JA_MUSIC_STOPPED;
    }
@@ -172,33 +203,41 @@ void JA_PlayMusic(JA_Music_t *music, const int loop)

 void JA_PauseMusic()
 {
-    if (!JA_musicEnabled) return;
+    if (!JA_musicEnabled)
+        return;

-    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return;
+    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID)
+        return;
    current_music->state = JA_MUSIC_PAUSED;
 }

 void JA_ResumeMusic()
 {
-    if (!JA_musicEnabled) return;
+    if (!JA_musicEnabled)
+        return;

-    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return;
+    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID)
+        return;
    current_music->state = JA_MUSIC_PLAYING;
 }

 void JA_StopMusic()
 {
-    if (!JA_musicEnabled) return;
+    if (!JA_musicEnabled)
+        return;

-    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return;
+    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID)
+        return;
    current_music->pos = 0;
    current_music->state = JA_MUSIC_STOPPED;
 }

 void JA_FadeOutMusic(const int milliseconds)
 {
-    if (!JA_musicEnabled) return;
-    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return;
+    if (!JA_musicEnabled)
+        return;
+    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID)
+        return;

    fading = true;
    fade_start_time = SDL_GetTicks();
@@ -206,64 +245,71 @@ void JA_FadeOutMusic(const int milliseconds)
    fade_initial_volume = JA_musicVolume;
 }

-JA_Music_state JA_GetMusicState() {
-    if (!JA_musicEnabled) return JA_MUSIC_DISABLED;
+JA_Music_state JA_GetMusicState()
+{
+    if (!JA_musicEnabled)
+        return JA_MUSIC_DISABLED;

-    if (current_music == NULL) return JA_MUSIC_INVALID;
+    if (current_music == NULL)
+        return JA_MUSIC_INVALID;
    return current_music->state;
 }

-void JA_DeleteMusic(JA_Music_t *music) {
-    if (current_music == music) current_music = NULL;
+void JA_DeleteMusic(JA_Music_t *music)
+{
+    if (current_music == music)
+        current_music = NULL;
    free(music->output);
    delete music;
 }

 int JA_SetMusicVolume(int volume)
 {
-    JA_musicVolume = volume > 128 ? 128 : volume < 0 ? 0 : volume;
+    JA_musicVolume = volume > 128 ? 128 : volume < 0 ? 0
+                                                     : volume;
    return JA_musicVolume;
 }

 void JA_SetMusicPosition(float value)
 {
-    if (!current_music) return;
+    if (!current_music)
+        return;
    current_music->pos = value * JA_freq;
 }

 float JA_GetMusicPosition()
 {
-    if (!current_music) return 0;
-    return float(current_music->pos)/float(JA_freq);
+    if (!current_music)
+        return 0;
+    return float(current_music->pos) / float(JA_freq);
 }

 void JA_EnableMusic(const bool value)
 {
-    if (!value && current_music != NULL && current_music->state==JA_MUSIC_PLAYING) JA_StopMusic();
+    if (!value && current_music != NULL && current_music->state == JA_MUSIC_PLAYING)
+        JA_StopMusic();

    JA_musicEnabled = value;
 }

-
-
-
-
-JA_Sound_t *JA_NewSound(Uint8* buffer, Uint32 length) {
+JA_Sound_t *JA_NewSound(Uint8 *buffer, Uint32 length)
+{
    JA_Sound_t *sound = new JA_Sound_t();
    sound->buffer = buffer;
    sound->length = length;
    return sound;
 }

-JA_Sound_t *JA_LoadSound(uint8_t* buffer, uint32_t size) {
+JA_Sound_t *JA_LoadSound(uint8_t *buffer, uint32_t size)
+{
    JA_Sound_t *sound = new JA_Sound_t();
    SDL_AudioSpec wavSpec;
-    SDL_LoadWAV_RW(SDL_RWFromMem(buffer, size),1, &wavSpec, &sound->buffer, &sound->length);
-    
+    SDL_LoadWAV_RW(SDL_RWFromMem(buffer, size), 1, &wavSpec, &sound->buffer, &sound->length);
+
    SDL_AudioCVT cvt;
    SDL_BuildAudioCVT(&cvt, wavSpec.format, wavSpec.channels, wavSpec.freq, JA_format, JA_channels, JA_freq);
    cvt.len = sound->length;
-    cvt.buf = (Uint8 *) SDL_malloc(cvt.len * cvt.len_mult);
+    cvt.buf = (Uint8 *)SDL_malloc(cvt.len * cvt.len_mult);
    SDL_memcpy(cvt.buf, sound->buffer, sound->length);
    SDL_ConvertAudio(&cvt);
    SDL_FreeWAV(sound->buffer);
@@ -273,7 +319,8 @@ JA_Sound_t *JA_LoadSound(uint8_t* buffer, uint32_t size) {
    return sound;
 }

-JA_Sound_t *JA_LoadSound(const char* filename) {
+JA_Sound_t *JA_LoadSound(const char *filename)
+{
    JA_Sound_t *sound = new JA_Sound_t();
    SDL_AudioSpec wavSpec;
    SDL_LoadWAV(filename, &wavSpec, &sound->buffer, &sound->length);
@@ -281,7 +328,7 @@ JA_Sound_t *JA_LoadSound(const char* filename) {
    SDL_AudioCVT cvt;
    SDL_BuildAudioCVT(&cvt, wavSpec.format, wavSpec.channels, wavSpec.freq, JA_format, JA_channels, JA_freq);
    cvt.len = sound->length;
-    cvt.buf = (Uint8 *) SDL_malloc(cvt.len * cvt.len_mult);
+    cvt.buf = (Uint8 *)SDL_malloc(cvt.len * cvt.len_mult);
    SDL_memcpy(cvt.buf, sound->buffer, sound->length);
    SDL_ConvertAudio(&cvt);
    SDL_FreeWAV(sound->buffer);
@@ -293,11 +340,16 @@ JA_Sound_t *JA_LoadSound(const char* filename) {

 int JA_PlaySound(JA_Sound_t *sound, const int loop)
 {
-    if (!JA_soundEnabled) return -1;
+    if (!JA_soundEnabled)
+        return -1;

    int channel = 0;
-    while (channel < JA_MAX_SIMULTANEOUS_CHANNELS && channels[channel].state != JA_CHANNEL_FREE) { channel++; }
-    if (channel == JA_MAX_SIMULTANEOUS_CHANNELS) channel = 0;
+    while (channel < JA_MAX_SIMULTANEOUS_CHANNELS && channels[channel].state != JA_CHANNEL_FREE)
+    {
+        channel++;
+    }
+    if (channel == JA_MAX_SIMULTANEOUS_CHANNELS)
+        channel = 0;

    channels[channel].sound = sound;
    channels[channel].times = loop;
@@ -308,9 +360,11 @@ int JA_PlaySound(JA_Sound_t *sound, const int loop)

 int JA_PlaySoundOnChannel(JA_Sound_t *sound, const int channel, const int loop)
 {
-    if (!JA_soundEnabled) return -1;
+    if (!JA_soundEnabled)
+        return -1;

-    if (channel >= JA_MAX_SIMULTANEOUS_CHANNELS) return -1;
+    if (channel >= JA_MAX_SIMULTANEOUS_CHANNELS)
+        return -1;

    channels[channel].sound = sound;
    channels[channel].times = loop;
@@ -321,8 +375,10 @@ int JA_PlaySoundOnChannel(JA_Sound_t *sound, const int channel, const int loop)

 void JA_DeleteSound(JA_Sound_t *sound)
 {
-    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
-        if (channels[i].sound == sound) JA_StopChannel(i);
+    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
+    {
+        if (channels[i].sound == sound)
+            JA_StopChannel(i);
    }
    SDL_free(sound->buffer);
    delete sound;
@@ -330,41 +386,60 @@ void JA_DeleteSound(JA_Sound_t *sound)

 void JA_PauseChannel(const int channel)
 {
-    if (!JA_soundEnabled) return;
+    if (!JA_soundEnabled)
+        return;

-    if (channel == -1) {
-        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
-            if (channels[i].state == JA_CHANNEL_PLAYING) channels[i].state = JA_CHANNEL_PAUSED;
+    if (channel == -1)
+    {
+        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
+        {
+            if (channels[i].state == JA_CHANNEL_PLAYING)
+                channels[i].state = JA_CHANNEL_PAUSED;
        }
-    } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
-        if (channels[channel].state == JA_CHANNEL_PLAYING) channels[channel].state = JA_CHANNEL_PAUSED;
+    }
+    else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS)
+    {
+        if (channels[channel].state == JA_CHANNEL_PLAYING)
+            channels[channel].state = JA_CHANNEL_PAUSED;
    }
 }

 void JA_ResumeChannel(const int channel)
 {
-    if (!JA_soundEnabled) return;
+    if (!JA_soundEnabled)
+        return;

-    if (channel == -1) {
-        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
-            if (channels[i].state == JA_CHANNEL_PAUSED) channels[i].state = JA_CHANNEL_PLAYING;
+    if (channel == -1)
+    {
+        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
+        {
+            if (channels[i].state == JA_CHANNEL_PAUSED)
+                channels[i].state = JA_CHANNEL_PLAYING;
        }
-    } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
-        if (channels[channel].state == JA_CHANNEL_PAUSED) channels[channel].state = JA_CHANNEL_PLAYING;
+    }
+    else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS)
+    {
+        if (channels[channel].state == JA_CHANNEL_PAUSED)
+            channels[channel].state = JA_CHANNEL_PLAYING;
    }
 }

 void JA_StopChannel(const int channel)
 {
-    if (!JA_soundEnabled) return;
+    if (!JA_soundEnabled)
+        return;

-    if (channel == -1) {
-        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
+    if (channel == -1)
+    {
+        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
+        {
            channels[i].state = JA_CHANNEL_FREE;
            channels[i].pos = 0;
            channels[i].sound = NULL;
        }
-    } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
+    }
+    else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS)
+    {
        channels[channel].state = JA_CHANNEL_FREE;
        channels[channel].pos = 0;
        channels[channel].sound = NULL;
@@ -373,15 +448,18 @@ void JA_StopChannel(const int channel)

 JA_Channel_state JA_GetChannelState(const int channel)
 {
-    if (!JA_soundEnabled) return JA_SOUND_DISABLED;
+    if (!JA_soundEnabled)
+        return JA_SOUND_DISABLED;

-    if (channel < 0 || channel >= JA_MAX_SIMULTANEOUS_CHANNELS) return JA_CHANNEL_INVALID;
+    if (channel < 0 || channel >= JA_MAX_SIMULTANEOUS_CHANNELS)
+        return JA_CHANNEL_INVALID;
    return channels[channel].state;
 }

 int JA_SetSoundVolume(int volume)
 {
-    JA_soundVolume = volume > 128 ? 128 : volume < 0 ? 0 : volume;
+    JA_soundVolume = volume > 128 ? 128 : volume < 0 ? 0
+                                                     : volume;
    return JA_soundVolume;
 }

@@ -389,15 +467,17 @@ void JA_EnableSound(const bool value)
 {
    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
    {
-        if (channels[i].state == JA_CHANNEL_PLAYING) JA_StopChannel(i);
+        if (channels[i].state == JA_CHANNEL_PLAYING)
+            JA_StopChannel(i);
    }
    JA_soundEnabled = value;
 }

 int JA_SetVolume(int volume)
 {
-    JA_musicVolume = volume > 128 ? 128 : volume < 0 ? 0 : volume;
-    JA_soundVolume = JA_musicVolume/2;
+    JA_musicVolume = volume > 128 ? 128 : volume < 0 ? 0
+                                                     : volume;
+    JA_soundVolume = JA_musicVolume / 2;
    return JA_musicVolume;
 }

--- a/source/jail_audio.h
+++ b/source/jail_audio.h
@@ -1,17 +1,32 @@
 #pragma once
-#include <SDL2/SDL.h>

-enum JA_Channel_state { JA_CHANNEL_INVALID, JA_CHANNEL_FREE, JA_CHANNEL_PLAYING, JA_CHANNEL_PAUSED, JA_SOUND_DISABLED };
-enum JA_Music_state { JA_MUSIC_INVALID, JA_MUSIC_PLAYING, JA_MUSIC_PAUSED, JA_MUSIC_STOPPED, JA_MUSIC_DISABLED };
+#include <SDL2/SDL_audio.h>  // Para SDL_AudioFormat
+#include <SDL2/SDL_stdinc.h> // Para Uint32, Uint8
+struct JA_Music_t;           // lines 4-4
+struct JA_Sound_t;           // lines 5-5

-struct JA_Sound_t;
-struct JA_Music_t;
+enum JA_Channel_state
+{
+    JA_CHANNEL_INVALID,
+    JA_CHANNEL_FREE,
+    JA_CHANNEL_PLAYING,
+    JA_CHANNEL_PAUSED,
+    JA_SOUND_DISABLED
+};
+enum JA_Music_state
+{
+    JA_MUSIC_INVALID,
+    JA_MUSIC_PLAYING,
+    JA_MUSIC_PAUSED,
+    JA_MUSIC_STOPPED,
+    JA_MUSIC_DISABLED
+};

 void JA_Init(const int freq, const SDL_AudioFormat format, const int channels);
 void JA_Quit();

-JA_Music_t *JA_LoadMusic(const char* filename);
-JA_Music_t *JA_LoadMusic(Uint8* buffer, Uint32 length);
+JA_Music_t *JA_LoadMusic(const char *filename);
+JA_Music_t *JA_LoadMusic(Uint8 *buffer, Uint32 length);
 void JA_PlayMusic(JA_Music_t *music, const int loop = -1);
 void JA_PauseMusic();
 void JA_ResumeMusic();
@@ -24,9 +39,9 @@ void JA_SetMusicPosition(float value);
 float JA_GetMusicPosition();
 void JA_EnableMusic(const bool value);

-JA_Sound_t *JA_NewSound(Uint8* buffer, Uint32 length);
-JA_Sound_t *JA_LoadSound(Uint8* buffer, Uint32 length);
-JA_Sound_t *JA_LoadSound(const char* filename);
+JA_Sound_t *JA_NewSound(Uint8 *buffer, Uint32 length);
+JA_Sound_t *JA_LoadSound(Uint8 *buffer, Uint32 length);
+JA_Sound_t *JA_LoadSound(const char *filename);
 int JA_PlaySound(JA_Sound_t *sound, const int loop = 0);
 int JA_PlaySoundOnChannel(JA_Sound_t *sound, const int channel, const int loop = 0);
 void JA_PauseChannel(const int channel);
--- a/source/logo.cpp
+++ b/source/logo.cpp
@@ -231,7 +231,7 @@ void Logo::render()
 	}

 	// Vuelca el contenido del renderizador en pantalla
-	Screen::get()->blit();
+	Screen::get()->render();
 }

 // Bucle para el logo del juego
--- a/source/mouse.cpp
+++ b/source/mouse.cpp
@@ -1,5 +1,6 @@
 #include "mouse.h"
-#include <SDL.h>
+#include <SDL2/SDL_mouse.h> // Para SDL_ShowCursor
+#include <SDL2/SDL_timer.h> // Para SDL_GetTicks

 namespace Mouse
 {
@@ -14,7 +15,9 @@ namespace Mouse
            last_mouse_move_time = SDL_GetTicks();
            if (!cursor_visible)
            {
+#ifndef ARCADE
                SDL_ShowCursor(SDL_ENABLE);
+#endif
                cursor_visible = true;
            }
        }
--- a/source/mouse.h
+++ b/source/mouse.h
@@ -1,5 +1,7 @@
 #pragma once
-#include <SDL.h>
+
+#include <SDL2/SDL_events.h> // Para SDL_Event
+#include <SDL2/SDL_stdinc.h> // Para Uint32

 namespace Mouse
 {
--- a/source/notifier.h
+++ b/source/notifier.h
@@ -1,15 +1,14 @@
 #pragma once

-#include <SDL2/SDL_rect.h>	 // para SDL_Rect
-#include <SDL2/SDL_render.h> // para SDL_Renderer
-#include <memory>			 // para shared_ptr, unique_ptr
-#include <string>			 // para string, basic_string
-#include <vector>			 // para vector
-#include "utils.h"			 // para Color
-class Sprite;
-class Text;
-class Texture;
-struct JA_Sound_t; // lines 12-12
+#include <SDL2/SDL_rect.h>	 // Para SDL_Rect
+#include <SDL2/SDL_render.h> // Para SDL_Renderer
+#include <memory>			 // Para shared_ptr
+#include <string>			 // Para string, basic_string
+#include <vector>			 // Para vector
+#include "utils.h"			 // Para Color
+class Sprite;				 // lines 9-9
+class Text;					 // lines 10-10
+class Texture;				 // lines 11-11

 class Notifier
 {
--- a/source/path_sprite.cpp
+++ b/source/path_sprite.cpp
@@ -1,3 +1,4 @@
+// IWYU pragma: no_include <bits/std_abs.h>
 #include "path_sprite.h"
 #include <cstdlib>	  // Para abs
 #include <functional> // Para function
@@ -101,7 +102,7 @@ void PathSprite::enable()
 	}

 	enabled_ = true;
-	
+
 	// Establece la posición
 	auto &path = paths_.at(current_path_);
 	const auto &p = path.spots.at(path.counter);
--- a/source/screen.cpp
+++ b/source/screen.cpp
@@ -46,7 +46,6 @@ Screen::Screen(SDL_Window *window, SDL_Renderer *renderer)
    : window_(window),
      renderer_(renderer),
      game_canvas_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height)),
-      shader_canvas_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height)),
      src_rect_({0, 0, param.game.width, param.game.height}),
      dst_rect_({0, 0, param.game.width, param.game.height})
 {
@@ -66,7 +65,6 @@ Screen::Screen(SDL_Window *window, SDL_Renderer *renderer)
 Screen::~Screen()
 {
    SDL_DestroyTexture(game_canvas_);
-    SDL_DestroyTexture(shader_canvas_);
 }

 // Limpia la pantalla
@@ -83,69 +81,41 @@ void Screen::start()
 }

 // Vuelca el contenido del renderizador en pantalla
-void Screen::blit()
+void Screen::render()
 {
    // Actualiza el contador de FPS
-    fps_counter_++;
+    ++fps_counter_;

-    // Actualiza y dibuja el efecto de flash en la pantalla
+    // Dibuja efectos y elementos sobre el game_canvas_
    renderFlash();
-
-    // Atenua la pantalla
    renderAttenuate();
-
-    // Muestra la ayuda por pantalla
    OnScreenHelp::get()->render();
-
-    // Muestra información por pantalla
    renderInfo();
-
-    // Muestra las notificaciones
    Notifier::get()->render();

-#ifdef NO_SHADERS
-    // Vuelve a dejar el renderizador en modo normal
+    // Restablece el objetivo de renderizado al buffer de pantalla predeterminado
    SDL_SetRenderTarget(renderer_, nullptr);

-    // Borra el contenido previo
-    SDL_SetRenderDrawColor(renderer_, border_color_.r, border_color_.g, border_color_.b, 0xFF);
-    SDL_RenderClear(renderer_);
+    // Renderiza el contenido del game_canvas_ o aplica shaders según configuración
+    renderScreen();
+}

-    // Copia la textura de juego en el renderizador en la posición adecuada
-    if (shake_effect_.enabled)
-        SDL_RenderCopy(renderer_, game_canvas_, nullptr, nullptr);
-    SDL_RenderCopy(renderer_, game_canvas_, &src_rect_, &dst_rect_);
-
-    // Muestra por pantalla el renderizador
-    SDL_RenderPresent(renderer_);
+// Selecciona y ejecuta el método de renderizado adecuado basado en la configuración de shaders
+void Screen::renderScreen()
+{
+#ifdef NO_SHADERS
+    // Actualiza la pantalla con el contenido del game_canvas_
+    presentGameCanvas();
 #else
    if (options.video.shaders)
    {
-        SDL_SetRenderTarget(renderer_, shader_canvas_);
-        SDL_SetRenderDrawColor(renderer_, 0x00, 0x00, 0x00, 0xFF);
-        SDL_RenderClear(renderer_);
-        if (shake_effect_.enabled)
-            SDL_RenderCopy(renderer_, game_canvas_, nullptr, nullptr);
-        SDL_RenderCopy(renderer_, game_canvas_, &src_rect_, &dst_rect_);
-        SDL_SetRenderTarget(renderer_, nullptr);
+        // Aplica shaders y renderiza el contenido
        shader::render();
    }
    else
    {
-        // Vuelve a dejar el renderizador en modo normal
-        SDL_SetRenderTarget(renderer_, nullptr);
-
-        // Borra el render
-        SDL_SetRenderDrawColor(renderer_, 0x00, 0x00, 0x00, 0xFF);
-        SDL_RenderClear(renderer_);
-
-        // Copia la textura de juego en el renderizador en la posición adecuada
-        if (shake_effect_.enabled)
-            SDL_RenderCopy(renderer_, game_canvas_, nullptr, nullptr); // Esta copia es para evitar que se vea negro por los laterales
-        SDL_RenderCopy(renderer_, game_canvas_, &src_rect_, &dst_rect_);
-
-        // Muestra por pantalla el renderizador
-        SDL_RenderPresent(renderer_);
+        // Actualiza la pantalla con el contenido del game_canvas_
+        presentGameCanvas();
    }
 #endif
 }
@@ -205,7 +175,7 @@ void Screen::setVideoMode(ScreenVideoMode videoMode)
        std::ifstream f(Asset::get()->get(glsl_file).c_str());
        std::string source((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());

-        shader::init(window_, shader_canvas_, source.c_str());
+        shader::init(window_, game_canvas_, source.c_str());
 #endif
    }
 }
@@ -394,6 +364,9 @@ void Screen::renderInfo()
        // Contador de service_pressed_counter
        if (const int counter = globalInputs::service_pressed_counter; counter > 0)
            dbg_print(0, 8, std::to_string(counter).c_str(), 255, 0, 255);
+
+        const std::string atten = attenuate_effect_ ? "ATTEN YES" : "ATTEN NO";
+        dbg_print(0, 16, atten.c_str(), 255, 0, 0);
    }
 }

@@ -431,4 +404,19 @@ SDL_Point Screen::getNewPosition()
    new_pos.y = std::clamp(new_pos.y, 30, DM.h - new_height);

    return new_pos;
+}
+
+// Actualiza la pantalla con el contenido del game_canvas_
+void Screen::presentGameCanvas()
+{
+    // Copia la textura de juego en el renderizador en la posición adecuada
+    if (shake_effect_.enabled)
+    {
+        // Esta copia es para evitar que se vea negro por los laterales
+        SDL_RenderCopy(renderer_, game_canvas_, nullptr, nullptr);
+    }
+    SDL_RenderCopy(renderer_, game_canvas_, &src_rect_, &dst_rect_);
+
+    // Actualiza la pantalla con el contenido del buffer de renderizado
+    SDL_RenderPresent(renderer_);
 }
--- a/source/screen.h
+++ b/source/screen.h
@@ -31,7 +31,6 @@ private:
 	SDL_Window *window_;		 // Ventana de la aplicación
 	SDL_Renderer *renderer_;	 // El renderizador de la ventana
 	SDL_Texture *game_canvas_;	 // Textura donde se dibuja todo antes de volcarse al renderizador
-	SDL_Texture *shader_canvas_; // Textura para pasarle al shader desde gameCanvas

 	// Variables
 	SDL_Rect src_rect_;				// Coordenadas de donde va a pillar la textura del juego para dibujarla
@@ -108,6 +107,12 @@ private:
 	// Calcula la nueva posición de la ventana a partir de la antigua al cambiarla de tamaño
 	SDL_Point getNewPosition();

+	// Actualiza la pantalla con el contenido del game_canvas_
+	void presentGameCanvas();
+
+	// Selecciona y ejecuta el método de renderizado adecuado basado en la configuración de shaders
+	void renderScreen();
+
 	// [SINGLETON] Ahora el constructor y el destructor son privados, para no poder crear objetos screen desde fuera

 	// Constructor
@@ -136,7 +141,7 @@ public:
 	void start();

 	// Vuelca el contenido del renderizador en pantalla
-	void blit();
+	void render();

 	// Establece el modo de video
 	void setVideoMode(ScreenVideoMode video_mode);
--- a/source/sprite.cpp
+++ b/source/sprite.cpp
@@ -1,4 +1,5 @@
 #include "sprite.h"
+#include "texture.h" // Para Texture

 // Constructor
 Sprite::Sprite(std::shared_ptr<Texture> texture, int x, int y, int w, int h)
--- a/source/sprite.h
+++ b/source/sprite.h
@@ -1,8 +1,8 @@
 #pragma once

-#include <SDL2/SDL_rect.h> // para SDL_Rect, SDL_Point
-#include "texture.h"
-#include <memory>
+#include <SDL2/SDL_rect.h> // Para SDL_Rect, SDL_Point
+#include <memory>          // Para shared_ptr
+class Texture;

 // Clase sprite
 class Sprite
--- a/source/stage.cpp
+++ b/source/stage.cpp
@@ -17,6 +17,7 @@ namespace Stage
    // Inicializa las variables del namespace Stage
    void init()
    {
+        stages.clear();
        stages.emplace_back(Stage(200, 7 + (4 * 1), 7 + (4 * 3)));
        stages.emplace_back(Stage(300, 7 + (4 * 2), 7 + (4 * 4)));
        stages.emplace_back(Stage(600, 7 + (4 * 3), 7 + (4 * 5)));
--- a/source/tabe.cpp
+++ b/source/tabe.cpp
@@ -1,8 +1,11 @@
+// IWYU pragma: no_include <bits/std_abs.h>
 #include "tabe.h"
-#include "resource.h"
-#include "param.h"
-#include "jail_audio.h"
-#include <algorithm>
+#include <SDL2/SDL_render.h> // Para SDL_FLIP_HORIZONTAL, SDL_FLIP_NONE
+#include <stdlib.h>          // Para rand, abs
+#include "jail_audio.h"      // Para JA_PlaySound
+#include "param.h"           // Para Param, ParamGame, param
+#include "resource.h"        // Para Resource
+#include "utils.h"           // Para Zone

 // Constructor
 Tabe::Tabe()
--- a/source/title.cpp
+++ b/source/title.cpp
@@ -1,7 +1,6 @@
 #include "title.h"
 #include <SDL2/SDL_events.h>  // Para SDL_PollEvent, SDL_Event, SDL_KEYDOWN
 #include <SDL2/SDL_keycode.h> // Para SDLK_1, SDLK_2, SDLK_3, SDLK_4, SDLK_5
-#include <SDL2/SDL_rect.h>	  // Para SDL_Rect
 #include <SDL2/SDL_timer.h>	  // Para SDL_GetTicks
 #include <stddef.h>			  // Para size_t
 #include <string>			  // Para char_traits, operator+, basic_string
@@ -9,22 +8,22 @@
 #include "define_buttons.h"	  // Para DefineButtons
 #include "fade.h"			  // Para Fade, FadeType
 #include "game_logo.h"		  // Para GameLogo
-#include "global_inputs.h"	  // Para check
+#include "global_inputs.h"	  // Para check, update
 #include "input.h"			  // Para Input, InputType, INPUT_DO_NOT_ALLOW_R...
-#include "jail_audio.h"		  // Para JA_GetMusicState, JA_Music_state, JA_P...
+#include "jail_audio.h"		  // Para JA_GetMusicState, JA_FadeOutMusic, JA_...
 #include "lang.h"			  // Para getText
+#include "mouse.h"			  // Para handleEvent
 #include "notifier.h"		  // Para Notifier
 #include "options.h"		  // Para OptionsController, Options, options
 #include "param.h"			  // Para Param, param, ParamGame, ParamTitle
 #include "resource.h"		  // Para Resource
 #include "screen.h"			  // Para Screen
-#include "section.h"		  // Para Options, options, Name, name, AttractMode
+#include "section.h"		  // Para Options, Name, name, AttractMode, options
 #include "sprite.h"			  // Para Sprite
 #include "text.h"			  // Para TEXT_CENTER, TEXT_SHADOW, Text
 #include "texture.h"		  // Para Texture
 #include "tiled_bg.h"		  // Para TiledBG, TiledBGMode
 #include "utils.h"			  // Para Color, Zone, fade_color, no_color, BLOCK
-#include "mouse.h"

 // Constructor
 Title::Title()
@@ -208,7 +207,7 @@ void Title::render()
 	fade_->render();

 	// Vuelca el contenido del renderizador en pantalla
-	Screen::get()->blit();
+	Screen::get()->render();
 }

 // Comprueba los eventos
@@ -295,7 +294,7 @@ void Title::checkInput()
 			if (Input::get()->checkInput(InputType::START, INPUT_DO_NOT_ALLOW_REPEAT, controller.type, controller.index) &&
 				!Input::get()->checkInput(InputType::SERVICE, INPUT_DO_NOT_ALLOW_REPEAT, controller.type, controller.index))
 			{
-				if (state_ == TitleState::LOGO_FINISHED || ALLOW_TITLE_ANIMATION_SKIP)
+				if ((state_ == TitleState::LOGO_FINISHED || ALLOW_TITLE_ANIMATION_SKIP) && !fade_->isEnabled())
 				{
 					JA_PlaySound(Resource::get()->getSound("game_start.wav"));
 					JA_FadeOutMusic(1500);
--- a/source/title.h
+++ b/source/title.h
@@ -2,14 +2,13 @@

 #include <SDL2/SDL_stdinc.h> // Para Uint32
 #include <memory>			 // Para unique_ptr, shared_ptr
-class DefineButtons;		 // lines 6-6
-class Fade;					 // lines 7-7
-class GameLogo;				 // lines 8-8
-class Sprite;				 // lines 9-9
-class Text;					 // lines 10-10
-class Texture;				 // lines 11-11
-class TiledBG;				 // lines 12-12
-#include "section.h"
+#include "section.h"		 // Para Options
+class DefineButtons;		 // lines 5-5
+class Fade;					 // lines 6-6
+class GameLogo;				 // lines 7-7
+class Sprite;				 // lines 8-8
+class Text;					 // lines 9-9
+class TiledBG;				 // lines 11-11

 // Textos
 constexpr const char TEXT_COPYRIGHT[] = "@2020,2025 JailDesigner";
Author	SHA1	Message	Date
Sergio Valor	28b37af31d	Actualitzada la data de la versió	2025-01-05 14:38:48 +01:00
Sergio Valor	4d590f79f5	fix: es podia pulsar per a jugar mentre feia el fade cap a la demo	2025-01-05 14:36:38 +01:00
Sergio Valor	91c8797d7f	Screen: optimitzat el circuit de render en pantalla	2025-01-05 14:17:49 +01:00
Sergio Valor	f207985180	Retocs en el punter del ratolí per al mode ARCADE	2025-01-05 13:44:10 +01:00
Sergio Valor	a16131335b	hi_score_table: actualitzat el fondo amb els elements nous	2025-01-05 13:41:09 +01:00
Sergio Valor	871e8da642	Corregit el timing de la música en la animació inicial del joc	2025-01-05 13:27:45 +01:00
Sergio Valor	90b3db8f06	El atenuat de pantalla torna a funcionar. Fade feia dos SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_NONE); que mai tornava a restaurar	2025-01-05 13:07:20 +01:00
Sergio Valor	668e8e237a	Actualitzat README.md	2025-01-05 12:52:14 +01:00
Sergio Valor	768f466b20	canviat blit() per render()	2025-01-05 10:45:05 +01:00
Sergio Valor	1f8f9b11ed	Segona pasaeta de IWYU	2025-01-05 10:36:17 +01:00
Sergio Valor	39f61884b0	Pasaeta de IWYU	2025-01-05 10:22:20 +01:00
Sergio Valor	b1193bd8fd	fix: error en la seqüència final de retrocedir en el temps	2025-01-05 09:51:33 +01:00
Sergio Valor	7f9e2e53e3	Optimitzat el renderitzat dels credits	2025-01-05 09:44:08 +01:00
Sergio Valor	4cf4c8db6f	fix: arreglada la acceleració dels credits sense dependre de vsync	2025-01-05 09:31:57 +01:00
Sergio Valor	cd806363e8	Modificat el color dels nuvols de la última pantalla debug: opció de no crear mes globos	2025-01-05 09:22:30 +01:00
Sergio Valor	198aa45d59	Afegida una lluna i un sol al fondo	2025-01-05 07:32:30 +01:00
Sergio Valor	0711c8dada	fix: al fer el init de stage no es buidava el vector i cada volta afegia mes stages	2025-01-05 07:29:33 +01:00
Sergio Valor	e1aaad0903	fix: Havia deixat comentat un IF fent proves	2025-01-04 17:01:24 +01:00
Sergio Valor	b53ee12f56	La powerball ja no es pot destruir fins que no ha fet un rebot	2025-01-04 16:57:50 +01:00