fix: amb el audio muted, al acabar la partida el fade per al roido de boles el tornava a deixar activat

Afegit reloadTextures a Resources

CMakeLists.txt

@@ -3,6 +3,9 @@
 cmake_minimum_required(VERSION 3.10)
 project(coffee_crisis_arcade_edition VERSION 0.01)
 
+# Establece las políticas
+cmake_policy(SET CMP0072 NEW)
+
 # Configuración de compilador para MinGW en Windows, si es necesario
 if(WIN32 AND NOT CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
     set(CMAKE_CXX_COMPILER "g++")

README.md

@@ -11,7 +11,7 @@ Coffee Crisis Arcade Edition és una versió ampliada i millorada del aclamat Co
 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="Títol" width="60%" />
+    <img src="https://php.sustancia.synology.me/images/ccae/ccae_title.png" alt="Títol" width="60%" />
 </p>
 
 ## Controls
@@ -25,26 +25,28 @@ El joc està optimitzat per a ser jugat amb un mando de jocs, encara que un dels
 > Nota: El joc suporta nomes un jugador amb teclat.
 
 <p align="center">
-    <img src="https://php.sustancia.synology.me/images/ccae1.png" alt="Joc" width="45%" />
-    <img src="https://php.sustancia.synology.me/images/ccae3.png" alt="Joc" width="45%" />
+    <img src="https://php.sustancia.synology.me/images/ccae/ccae1.png" alt="Joc" width="45%" />
+    <img src="https://php.sustancia.synology.me/images/ccae/ccae3.png" alt="Joc" width="45%" />
 </p>
 
 ## Altres tecles
 
-| Tecla       | Funció                                       |
-|-------------|----------------------------------------------|
-| **ESC**     | Tancar el joc                                |
-| **F1**      | Fa la finestra més xicoteta                 |
-| **F2**      | Fa la finestra més gran                     |
+| Tecla       | Funció                                             |
+|:-----------:|----------------------------------------------------|
+| **ESC**     | Tancar el joc                                      |
+| **P**       | Pausar 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                               |
+| **F4**      | Activa o desactiva el filtre de pantalla           |
+| **F5**      | Activa o desactiva el mode d'escalat sencer        |
+| **F6**      | Activa o desactiva l'àudio                         |
+| **F7**      | Activa o desactiva el dispar automàtic             |
+| **F8**      | Canvia l'idioma del joc (Provoca el reinici)       |
+| **F10**     | Reinicia el joc                                    |
 
 <p align="center">
-    <img src="https://php.sustancia.synology.me/images/ccae2.png" alt="Joc" width="50%" />
+    <img src="https://php.sustancia.synology.me/images/ccae/ccae2.png" alt="Joc" width="50%" />
 </p>
 
 ## Com instal·lar i jugar

data/lang/ba_BA.txt

@@ -101,10 +101,10 @@ Espera un moment...
 Si resulta que no tinc solt!
 
 ## 34 - INTRO
-MERDA DE MAQUINA!
+VAJA BIRRIA DE MAQUINA !!!
 
 ## 35 - INTRO
-Blop... blop... blop...
+blop... blop... blop...
 
 ## 36 - TEXTOS DEL JUEGO
 Temps detes: 
@@ -372,3 +372,36 @@ MUSICA COMPOSADA PER
 
 ## 124 - CREDITS
 EFECTES DE SO
+
+## 125 - NOTIFICACIONES
+Torna a polsar per reiniciar
+
+## 126 - NOTIFICACIONES
+Torna a polsar per canviar el idioma a
+
+## 127 - NOTIFICACIONES
+Idioma canviat a
+
+## 128 - VARIOS
+activat
+
+## 129 - VARIOS
+desactivat
+
+## 130 - VARIOS
+Dispar automatic
+
+## 131 - VARIOS
+Zoom de finestra
+
+## 132 - VARIOS
+Mode finestra
+
+## 133 - VARIOS
+Mode pantalla completa
+
+## 134 - VARIOS
+Mode d'escalat sencer
+
+## 135 - VARIOS
+Filtre

data/lang/en_UK.txt

@@ -372,3 +372,36 @@ MUSIC COMPOSED BY
 
 ## 124 - CREDITS
 SOUND EFFECTS
+
+## 125 - NOTIFICACIONES
+Press again to reset
+
+## 126 - NOTIFICACIONES
+Press again to change languaje to
+
+## 127 - NOTIFICACIONES
+Language set to
+
+## 128 - VARIOS
+on
+
+## 129 - VARIOS
+off
+
+## 130 - VARIOS
+Autofire
+
+## 131 - VARIOS
+Window zoom
+
+## 132 - VARIOS
+Window mode
+
+## 133 - VARIOS
+Fullscreen mode
+
+## 134 - VARIOS
+Integer scale
+
+## 135 - VARIOS
+Filter

data/lang/es_ES.txt

@@ -372,3 +372,36 @@ MUSICA COMPUESTA POR
 
 ## 124 - CREDITS
 EFECTOS DE SONIDO
+
+## 125 - NOTIFICACIONES
+Vuelve a pulsar para reiniciar
+
+## 126 - NOTIFICACIONES
+Vuelve a pulsar para cambiar el idioma a
+
+## 127 - NOTIFICACIONES
+Idioma cambiado a
+
+## 128 - VARIOS
+activado
+
+## 129 - VARIOS
+desactivado
+
+## 130 - VARIOS
+Disparo automático
+
+## 131 - VARIOS
+Zoom de ventana
+
+## 132 - VARIOS
+Modo ventana
+
+## 133 - VARIOS
+Modo pantalla completa
+
+## 134 - VARIOS
+Modo de escalado entero
+
+## 135 - VARIOS
+Filtro

source/animated_sprite.h

@@ -46,7 +46,7 @@ public:
         : MovingSprite(texture) {}
 
     // Destructor
-    virtual ~AnimatedSprite() = default;
+    virtual ~AnimatedSprite() override = default;
 
     // Actualiza las variables del objeto
     void update() override;

source/asset.h

@@ -56,13 +56,13 @@ private:
 	~Asset() = default;
 
 public:
-	// [SINGLETON] Crearemos el objeto screen con esta función estática
+	// [SINGLETON] Crearemos el objeto con esta función estática
 	static void init(const std::string &executable_path);
 
-	// [SINGLETON] Destruiremos el objeto screen con esta función estática
+	// [SINGLETON] Destruiremos el objeto con esta función estática
 	static void destroy();
 
-	// [SINGLETON] Con este método obtenemos el objeto screen y podemos trabajar con él
+	// [SINGLETON] Con este método obtenemos el objeto y podemos trabajar con él
 	static Asset *get();
 
 	// Añade un elemento a la lista

source/background.cpp

@@ -226,16 +226,6 @@ void Background::render()
     SDL_RenderCopy(renderer_, color_texture_, &src_rect_, &dst_rect_);
 }
 
-// Vuelve a cargar las texturas
-void Background::reloadTextures()
-{
-    buildings_texture_->reLoad();
-    top_clouds_texture_->reLoad();
-    bottom_clouds_texture_->reLoad();
-    grass_texture_->reLoad();
-    gradients_texture_->reLoad();
-}
-
 // Ajusta el valor de la variable
 void Background::setCloudsSpeed(float value)
 {

source/background.h

@@ -131,9 +131,6 @@ public:
   // Establece la posición del objeto
   void setPos(SDL_Rect pos);
 
-  // Vuelve a cargar las texturas
-  void reloadTextures();
-
   // Ajusta el valor de la variable
   void setCloudsSpeed(float value);
 

source/balloon.cpp

@@ -118,7 +118,7 @@ void Balloon::render()
 		if (!invulnerable_)
 		{
 			SDL_Point p = {24, 24};
-			sprite_->setRotatingCenter(&p);
+			sprite_->setRotatingCenter(p);
 			sprite_->render();
 		}
 

source/balloon_manager.cpp

@@ -9,9 +9,8 @@
 #include "param.h"              // Para Param, ParamGame, param
 #include "resource.h"           // Para Resource
 #include "screen.h"             // Para Screen
-#include "stage.h"              // Para power
-#include "texture.h"            // Para Texture
-#include "utils.h"              // Para Zone, BLOCK, Color, flash_color
+#include "stage.h"              // Para addPower
+#include "utils.h"              // Para Zone, Color, flash_color
 
 // Constructor
 BalloonManager::BalloonManager()
@@ -370,15 +369,6 @@ void BalloonManager::normalColorsToAllBalloons()
     }
 }
 
-// Recarga las texturas
-void BalloonManager::reLoad()
-{
-    for (auto &texture : balloon_textures_)
-    {
-        texture->reLoad();
-    }
-}
-
 // Crea dos globos gordos
 void BalloonManager::createTwoBigBalloons()
 {

source/balloon_manager.h

@@ -104,9 +104,6 @@ public:
     // Cambia el color de todos los globos
     void normalColorsToAllBalloons();
 
-    // Recarga las texturas
-    void reLoad();
-
     // Crea dos globos gordos
     void createTwoBigBalloons();
 

source/credits.cpp

@@ -9,13 +9,14 @@
 #include <stdexcept>            // Para runtime_error
 #include <string>               // Para basic_string, string
 #include <vector>               // Para vector
+#include <array>               // 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 "global_events.h"              // Para handleEvent
 #include "param.h"              // Para Param, ParamGame, param
 #include "player.h"             // Para Player, PlayerState
 #include "resource.h"           // Para Resource
@@ -86,13 +87,11 @@ void Credits::run()
 // Actualiza las variables
 void Credits::update()
 {
-    constexpr Uint32 TICKS_SPEED_ = 15;
-
-    if (SDL_GetTicks() - ticks_ > TICKS_SPEED_)
+    if (SDL_GetTicks() - ticks_ > param.game.speed)
     {
         ticks_ = SDL_GetTicks();
-        const int repeat = want_to_pass_ ? 4 : 1;
-        for (int i = 0; i < repeat; ++i)
+        const int REPEAT = want_to_pass_ ? 4 : 1;
+        for (int i = 0; i < REPEAT; ++i)
         {
             tiled_bg_->update();
             balloon_manager_->update();
@@ -105,6 +104,7 @@ void Credits::update()
             updateAllFades();
             ++counter_;
         }
+        
         Screen::get()->update();
         globalInputs::update();
 
@@ -128,22 +128,11 @@ void Credits::render()
 // Comprueba el manejador de eventos
 void Credits::checkEvents()
 {
-    SDL_Event event;
-
-    // Comprueba los eventos que hay en la cola
-    while (SDL_PollEvent(&event))
-    {
-        // Evento de salida de la aplicación
-        if (event.type == SDL_QUIT)
-        {
-            section::name = section::Name::QUIT;
-            section::options = section::Options::QUIT_FROM_EVENT;
-            break;
-        }
-
-        // Comprueba el cursor
-        Mouse::handleEvent(event);
-    }
+	SDL_Event event;
+	while (SDL_PollEvent(&event))
+	{
+		globalEvents::check(event);
+	}
 }
 
 // Comprueba las entradas
@@ -177,7 +166,7 @@ void Credits::fillTextTexture()
     SDL_SetRenderDrawColor(Screen::get()->getRenderer(), 0, 0, 0, 0);
     SDL_RenderClear(Screen::get()->getRenderer());
 
-    std::vector<std::string> texts = {
+    const std::array<std::string, 10> TEXTS = {
         lang::getText(121),
         lang::getText(122),
         lang::getText(123),
@@ -189,50 +178,50 @@ void Credits::fillTextTexture()
         "WWW.KENNEY.NL",
         "JAILDOCTOR"};
 
-    const int space_post_title = 3 + text->getCharacterSize();
-    const int space_pre_title = text->getCharacterSize() * 4;
-    const int texts_height = 1 * text->getCharacterSize() + 7 * space_post_title + 3 * space_pre_title;
-    credits_rect_dst_.h = credits_rect_src_.h = texts_height;
+    const int SPACE_POST_TITLE = 3 + text->getCharacterSize();
+    const int SPACE_PRE_TITLE = text->getCharacterSize() * 4;
+    const int TEXTS_HEIGHT = 1 * text->getCharacterSize() + 7 * SPACE_POST_TITLE + 3 * SPACE_PRE_TITLE;
+    credits_rect_dst_.h = credits_rect_src_.h = TEXTS_HEIGHT;
 
-    int y = (param.game.height - texts_height) / 2;
+    int y = (param.game.height - TEXTS_HEIGHT) / 2;
     y = 0;
     text->setPalette(1);
-    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, texts.at(0), 1, no_color, 1, shdw_txt_color);
+    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, TEXTS.at(0), 1, no_color, 1, shdw_txt_color);
 
     text->setPalette(0);
-    y += space_post_title;
-    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, texts.at(4), 1, no_color, 1, shdw_txt_color);
+    y += SPACE_POST_TITLE;
+    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, TEXTS.at(4), 1, no_color, 1, shdw_txt_color);
 
-    y += space_pre_title;
+    y += SPACE_PRE_TITLE;
     text->setPalette(1);
-    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, texts.at(1), 1, no_color, 1, shdw_txt_color);
+    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, TEXTS.at(1), 1, no_color, 1, shdw_txt_color);
     text->setPalette(0);
-    y += space_post_title;
-    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, texts.at(4), 1, no_color, 1, shdw_txt_color);
+    y += SPACE_POST_TITLE;
+    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, TEXTS.at(4), 1, no_color, 1, shdw_txt_color);
 
-    y += space_pre_title;
+    y += SPACE_PRE_TITLE;
     text->setPalette(1);
-    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, texts.at(2), 1, no_color, 1, shdw_txt_color);
+    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, TEXTS.at(2), 1, no_color, 1, shdw_txt_color);
     text->setPalette(0);
 
-    y += space_post_title;
-    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, texts.at(5), 1, no_color, 1, shdw_txt_color);
-    y += space_post_title;
-    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, texts.at(6), 1, no_color, 1, shdw_txt_color);
+    y += SPACE_POST_TITLE;
+    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, TEXTS.at(5), 1, no_color, 1, shdw_txt_color);
+    y += SPACE_POST_TITLE;
+    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, TEXTS.at(6), 1, no_color, 1, shdw_txt_color);
 
-    y += space_pre_title;
+    y += SPACE_PRE_TITLE;
     text->setPalette(1);
-    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, texts.at(3), 1, no_color, 1, shdw_txt_color);
+    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, TEXTS.at(3), 1, no_color, 1, shdw_txt_color);
     text->setPalette(0);
-    y += space_post_title;
-    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, texts.at(7), 1, no_color, 1, shdw_txt_color);
-    y += space_post_title;
-    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, texts.at(8), 1, no_color, 1, shdw_txt_color);
-    y += space_post_title;
-    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, texts.at(9), 1, no_color, 1, shdw_txt_color);
+    y += SPACE_POST_TITLE;
+    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, TEXTS.at(7), 1, no_color, 1, shdw_txt_color);
+    y += SPACE_POST_TITLE;
+    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, TEXTS.at(8), 1, no_color, 1, shdw_txt_color);
+    y += SPACE_POST_TITLE;
+    text->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, y, TEXTS.at(9), 1, no_color, 1, shdw_txt_color);
 
     // Mini logo
-    y += space_pre_title;
+    y += SPACE_PRE_TITLE;
     mini_logo_rect_src_.y = y;
     auto mini_logo_sprite = std::make_unique<Sprite>(Resource::get()->getTexture("logo_jailgames_mini.png"));
     mini_logo_sprite->setPosition(1 + param.game.game_area.center_x - mini_logo_sprite->getWidth() / 2, 1 + y);

source/define_buttons.cpp

@@ -4,7 +4,6 @@
 #include "options.h"  // Para OptionsController, Options, options
 #include "param.h"    // Para Param, param, ParamGame, ParamTitle
 #include "resource.h" // Para Resource
-#include "section.h"  // Para Name, Options, name, options
 #include "text.h"     // Para Text
 
 // Constructor
@@ -62,32 +61,11 @@ void DefineButtons::bindButtons()
 }
 
 // Comprueba los eventos
-void DefineButtons::checkEvents()
+void DefineButtons::checkEvents(const SDL_Event &event)
 {
-    if (enabled_)
+    if (enabled_ && event.type == SDL_CONTROLLERBUTTONDOWN)
     {
-        SDL_Event event;
-
-        // Comprueba los eventos que hay en la cola
-        while (SDL_PollEvent(&event))
-        {
-            switch (event.type)
-            {
-            case SDL_QUIT:
-            {
-                section::name = section::Name::QUIT;
-                section::options = section::Options::QUIT_WITH_KEYBOARD;
-                break;
-            }
-            case SDL_CONTROLLERBUTTONDOWN:
-            {
-                doControllerButtonDown(event.cbutton);
-                break;
-            }
-            default:
-                break;
-            }
-        }
+        doControllerButtonDown(event.cbutton);
     }
 }
 

source/define_buttons.h

@@ -67,7 +67,7 @@ public:
     void render();
 
     // Comprueba los eventos
-    void checkEvents();
+    void checkEvents(const SDL_Event &event);
 
     // Habilita el objeto
     bool enable(int index);

source/director.cpp

@@ -4,46 +4,49 @@
 #include <SDL2/SDL_audio.h>			 // Para AUDIO_S16
 #include <SDL2/SDL_blendmode.h>		 // Para SDL_BLENDMODE_BLEND
 #include <SDL2/SDL_error.h>			 // Para SDL_GetError
+#include <SDL2/SDL_events.h>		 // Para SDL_DISABLE
 #include <SDL2/SDL_gamecontroller.h> // Para SDL_CONTROLLER_BUTTON_B, SDL_CO...
 #include <SDL2/SDL_hints.h>			 // Para SDL_SetHint, SDL_HINT_RENDER_DR...
+#include <SDL2/SDL_mouse.h>			 // Para SDL_ShowCursor
 #include <SDL2/SDL_scancode.h>		 // Para SDL_SCANCODE_0, SDL_SCANCODE_DOWN
-#include <SDL2/SDL_stdinc.h>		 // Para SDL_bool, Uint32
+#include <SDL2/SDL_stdinc.h>		 // Para Uint32, SDL_bool
 #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 <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
+
 #ifndef _WIN32
 #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[])
@@ -55,6 +58,7 @@ Director::Director(int argc, const char *argv[])
 	section::name = section::Name::LOGO;
 #else // NORMAL GAME
 	section::name = section::Name::LOGO;
+	section::options = section::Options::NONE;
 	section::attract_mode = section::AttractMode::TITLE_TO_DEMO;
 #endif
 
@@ -97,6 +101,7 @@ void Director::init()
 
 	// Inicializa y crea el resto de objetos
 	initSDL();
+	SDL_ShowCursor(SDL_DISABLE);
 	initJailAudio();
 	dbg_init(renderer_);
 	lang::loadFromFile(getLangFile(static_cast<lang::Code>(options.game.language)));
@@ -177,16 +182,21 @@ void Director::bindInputs()
 	Input::get()->bindKey(InputType::SERVICE, SDL_SCANCODE_0);
 	Input::get()->bindKey(InputType::EXIT, SDL_SCANCODE_ESCAPE);
 	Input::get()->bindKey(InputType::PAUSE, SDL_SCANCODE_P);
+
 	Input::get()->bindKey(InputType::WINDOW_DEC_SIZE, SDL_SCANCODE_F1);
 	Input::get()->bindKey(InputType::WINDOW_INC_SIZE, SDL_SCANCODE_F2);
 	Input::get()->bindKey(InputType::WINDOW_FULLSCREEN, SDL_SCANCODE_F3);
 	Input::get()->bindKey(InputType::VIDEO_SHADERS, SDL_SCANCODE_F4);
-	Input::get()->bindKey(InputType::MUTE, SDL_SCANCODE_F5);
-	Input::get()->bindKey(InputType::AUTO_FIRE, SDL_SCANCODE_F6);
-	Input::get()->bindKey(InputType::CHANGE_LANG, SDL_SCANCODE_F7);
-	Input::get()->bindKey(InputType::SHOWINFO, SDL_SCANCODE_F8);
+	Input::get()->bindKey(InputType::VIDEO_INTEGER_SCALE, SDL_SCANCODE_F5);
+	
+	Input::get()->bindKey(InputType::MUTE, SDL_SCANCODE_F6);
+	Input::get()->bindKey(InputType::AUTO_FIRE, SDL_SCANCODE_F7);
+	Input::get()->bindKey(InputType::CHANGE_LANG, SDL_SCANCODE_F8);
+	
 	Input::get()->bindKey(InputType::RESET, SDL_SCANCODE_F10);
 	
+	Input::get()->bindKey(InputType::SHOWINFO, SDL_SCANCODE_F12);
+
 	// Asigna botones a inputs
 	const int num_gamepads = Input::get()->getNumControllers();
 	for (int i = 0; i < num_gamepads; ++i)
@@ -287,28 +297,17 @@ bool Director::initSDL()
 	}
 	else
 	{
-		/*
-		// Muestra información de la pantalla
-		std::cout << "\nDisplay modes list:" << std::endl;
-		for (int i = 0; i < SDL_GetNumDisplayModes(0); ++i)
-		{
-			SDL_DisplayMode DM;
-			SDL_GetDisplayMode(0,i,&DM);
-			std::cout << "  - " << DM.w << "x" << DM.h << " @ " << DM.refresh_rate << "Hz" << std::endl;
-		}
-		*/
-
 		// Obtiene información sobre la pantalla
 		SDL_DisplayMode DM;
 		SDL_GetCurrentDisplayMode(0, &DM);
 
 		// Calcula el máximo factor de zoom que se puede aplicar a la pantalla
-		options.video.window.max_size = std::min(DM.w / param.game.width, DM.h / param.game.height);
-		options.video.window.size = std::min(options.video.window.size, options.video.window.max_size);
+		options.video.window.max_zoom = std::min(DM.w / param.game.width, DM.h / param.game.height);
+		options.video.window.zoom = std::min(options.video.window.zoom, options.video.window.max_zoom);
 
 		// Muestra información sobre el tamaño de la pantalla y de la ventana de juego
 		std::cout << "\nCurrent display mode: " << DM.w << "x" << DM.h << " @ " << DM.refresh_rate << "Hz" << std::endl;
-		std::cout << "Window resolution   : " << param.game.width << "x" << param.game.height << " x" << options.video.window.size << std::endl;
+		std::cout << "Window resolution   : " << param.game.width << "x" << param.game.height << " x" << options.video.window.zoom << std::endl;
 
 		// Establece el filtro de la textura
 		if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, std::to_string(static_cast<int>(options.video.filter)).c_str()))
@@ -316,15 +315,13 @@ bool Director::initSDL()
 			std::cout << "Warning: texture filtering not enabled!\n";
 		}
 
-#ifndef NO_SHADERS
 		if (!SDL_SetHint(SDL_HINT_RENDER_DRIVER, "opengl"))
 		{
 			std::cout << "Warning: opengl not enabled!\n";
 		}
-#endif
 
 		// Crea la ventana
-		window_ = SDL_CreateWindow(WINDOW_CAPTION, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, param.game.width * options.video.window.size, param.game.height * options.video.window.size, SDL_WINDOW_HIDDEN);
+		window_ = SDL_CreateWindow(WINDOW_CAPTION, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, param.game.width * options.video.window.zoom, param.game.height * options.video.window.zoom, SDL_WINDOW_HIDDEN);
 		if (!window_)
 		{
 			std::cout << "Window could not be created!\nSDL Error: " << SDL_GetError() << std::endl;
@@ -339,10 +336,8 @@ bool Director::initSDL()
 				flags = SDL_RENDERER_PRESENTVSYNC;
 			}
 
-#ifndef NO_SHADERS
 			// La aceleración se activa según el define
 			flags = flags | SDL_RENDERER_ACCELERATED | SDL_RENDERER_TARGETTEXTURE;
-#endif
 
 			renderer_ = SDL_CreateRenderer(window_, -1, flags);
 
@@ -356,6 +351,7 @@ bool Director::initSDL()
 				SDL_SetRenderDrawColor(renderer_, 0x00, 0x00, 0x00, 0xFF);
 				SDL_RenderSetLogicalSize(renderer_, param.game.width, param.game.height);
 				SDL_RenderSetIntegerScale(renderer_, static_cast<SDL_bool>(options.video.integer_scale));
+				SDL_SetWindowFullscreen(window_, static_cast<Uint32>(options.video.mode));
 				SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_BLEND);
 			}
 		}
@@ -477,7 +473,12 @@ void Director::setFileList()
 	}
 
 	{ // Intro
-		Asset::get()->add(prefix + "/data/gfx/intro/intro.png", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/intro/intro1.png", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/intro/intro2.png", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/intro/intro3.png", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/intro/intro4.png", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/intro/intro5.png", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/intro/intro6.png", AssetType::BITMAP);
 	}
 
 	{ // Logo
@@ -553,7 +554,9 @@ void Director::setFileList()
 
 	// Si falta algun fichero, sale del programa
 	if (!Asset::get()->check())
+	{
 		throw std::runtime_error("Falta algun fichero");
+	}
 }
 
 // Comprueba los parametros del programa

source/enter_name.cpp

@@ -1,19 +1,17 @@
 #include "enter_name.h"
-#include "utils.h"
-#include <stddef.h>  // Para size_t
-#include <algorithm> // Para max, min
-#include <cassert>   // Para assert
-#include <iostream>
+#include <stddef.h> // Para size_t
+#include "utils.h"  // Para trim
 
 // Constructor
 EnterName::EnterName()
-    : character_list_(" ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-+-*/=?¿<>!\"#$%&/()") {}
+    : character_list_(" ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-+-*/=?¿<>!\"#$%&/()"),
+      character_index_{0} {}
 
 // Inicializa el objeto
 void EnterName::init(const std::string &name)
 {
     // No se pasa ningún nombre
-    if (name == "")
+    if (name.empty())
     {
         name_ = "A";
         position_ = 0;
@@ -24,7 +22,7 @@ void EnterName::init(const std::string &name)
     {
         name_ = name;
         position_ = name_.length();
-        position_overflow_ = position_ >= NAME_LENGHT ? true : false;
+        position_overflow_ = position_ >= MAX_NAME_LENGHT ? true : false;
     }
 
     // Inicializa el vector de indices con el nombre y espacios
@@ -42,28 +40,26 @@ void EnterName::incPosition()
 
     ++position_;
 
-    if (position_ >= NAME_LENGHT)
+    if (position_ >= MAX_NAME_LENGHT)
     {
-        position_ = NAME_LENGHT; // Mantenemos en el índice máximo válido.
-        position_overflow_ = true;    // Activamos el flag de overflow.
+        position_ = MAX_NAME_LENGHT; // Mantenemos en el índice máximo válido.
+        position_overflow_ = true;   // Activamos el flag de overflow.
+    }
+    else if (position_ > 0) // No es necesario verificar position_ < MAX_NAME_LENGHT
+    {
+        // Copiamos el índice del carácter anterior si es posible.
+        character_index_[position_] = character_index_[position_ - 1];
     }
     else
     {
-        // Copiamos el índice del carácter anterior si es posible.
-        if (position_ > 0 && position_ < NAME_LENGHT)
-        {
-            character_index_[position_] = character_index_[position_ - 1];
-        }
-        else
-        {
-            // Si position_ es 0, inicializamos el carácter actual.
-            character_index_[position_] = 0;
-        }
+        // Si position_ es 0, inicializamos el carácter actual.
+        character_index_[position_] = 0;
     }
 
     updateNameFromCharacterIndex();
 }
 
+
 // Decrementa la posición
 void EnterName::decPosition()
 {
@@ -71,7 +67,7 @@ void EnterName::decPosition()
     {
         // Si estaba en overflow, lo desactivamos y mantenemos position_ en el máximo.
         position_overflow_ = false;
-        position_ = NAME_LENGHT - 1;
+        position_ = MAX_NAME_LENGHT - 1;
     }
     else
     {
@@ -80,7 +76,7 @@ void EnterName::decPosition()
             --position_;
 
             // Limpiamos el carácter siguiente si el índice es válido.
-            if (position_ + 1 < NAME_LENGHT)
+            if (position_ + 1 < MAX_NAME_LENGHT)
             {
                 character_index_[position_ + 1] = 0;
             }
@@ -93,7 +89,7 @@ void EnterName::decPosition()
         }
 
         // Si position_ es menor que NAME_LENGHT, aseguramos que el overflow esté desactivado.
-        if (position_ < NAME_LENGHT)
+        if (position_ < MAX_NAME_LENGHT)
         {
             position_overflow_ = false;
         }
@@ -102,7 +98,6 @@ void EnterName::decPosition()
     updateNameFromCharacterIndex();
 }
 
-
 // Incrementa el índice
 void EnterName::incIndex()
 {
@@ -139,7 +134,7 @@ void EnterName::decIndex()
 void EnterName::updateNameFromCharacterIndex()
 {
     name_.clear();
-    for (int i = 0; i < NAME_LENGHT; ++i)
+    for (int i = 0; i < MAX_NAME_LENGHT; ++i)
     {
         name_.push_back(character_list_[character_index_[i]]);
     }
@@ -150,13 +145,13 @@ void EnterName::updateNameFromCharacterIndex()
 void EnterName::initCharacterIndex(const std::string &name)
 {
     // Rellena de espacios
-    for (size_t i = 0; i < NAME_LENGHT; ++i)
+    for (size_t i = 0; i < MAX_NAME_LENGHT; ++i)
     {
         character_index_[i] = 0;
     }
 
     // Coloca los índices en función de los caracteres que forman el nombre
-    for (size_t i = 0; i < name.substr(0, NAME_LENGHT).size(); ++i)
+    for (size_t i = 0; i < name.substr(0, MAX_NAME_LENGHT).size(); ++i)
     {
         character_index_[i] = findIndex(name.at(i));
     }
@@ -166,7 +161,11 @@ void EnterName::initCharacterIndex(const std::string &name)
 int EnterName::findIndex(char character) const
 {
     for (size_t i = 0; i < character_list_.size(); ++i)
+    {
         if (character == character_list_.at(i))
+        {
             return i;
+        }
+    }
     return 0;
 }

source/enter_name.h

@@ -1,9 +1,10 @@
 #pragma once
 
 #include <string>
+#include <array>
 #include "utils.h"
 
-constexpr int NAME_LENGHT = 6;
+constexpr int MAX_NAME_LENGHT = 6;
 
 /*
     Un array, "characterList", contiene la lista de caracteres
@@ -17,11 +18,11 @@ constexpr int NAME_LENGHT = 6;
 class EnterName
 {
 private:
-    std::string character_list_;       // Lista de todos los caracteres permitidos
-    std::string name_;                 // Nombre introducido
-    int position_ = 0;                 // Posición a editar del nombre
-    bool position_overflow_ = false;   // Indica si hemos incrementado la posición más allá del límite
-    int character_index_[NAME_LENGHT]; // Indice de la lista para cada uno de los caracteres que forman el nombre
+    std::string character_list_;                       // Lista de todos los caracteres permitidos
+    std::string name_;                                 // Nombre introducido
+    int position_ = 0;                                 // Posición a editar del nombre
+    bool position_overflow_ = false;                   // Indica si hemos incrementado la posición más allá del límite
+    std::array<int, MAX_NAME_LENGHT> character_index_; // Indice de la lista para cada uno de los caracteres que forman el nombre
 
     // Actualiza el nombre a partir de la lista de índices
     void updateNameFromCharacterIndex();

source/game.cpp

@@ -1,6 +1,6 @@
 #include "game.h"
 #include <SDL2/SDL_blendmode.h>	  // Para SDL_BLENDMODE_BLEND
-#include <SDL2/SDL_events.h>	  // Para SDL_PollEvent, SDL_Event, SDL_KEYDOWN
+#include <SDL2/SDL_events.h>	  // Para SDL_Event, SDL_PollEvent, SDL_KEYDOWN
 #include <SDL2/SDL_keycode.h>	  // Para SDLK_1, SDLK_2, SDLK_3, SDLK_4
 #include <SDL2/SDL_pixels.h>	  // Para SDL_PIXELFORMAT_RGBA8888
 #include <SDL2/SDL_timer.h>		  // Para SDL_GetTicks
@@ -14,15 +14,14 @@
 #include "balloon.h"			  // Para Balloon, BALLOON_SPEED
 #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, FadeMode
+#include "global_events.h"		  // Para check
 #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...
@@ -30,10 +29,10 @@
 #include "resource.h"			  // Para Resource
 #include "scoreboard.h"			  // Para Scoreboard, ScoreboardMode, SCOREB...
 #include "screen.h"				  // Para Screen
-#include "section.h"			  // Para Name, name, AttractMode, Options
+#include "section.h"			  // Para Name, name, AttractMode, attract_mode
 #include "smart_sprite.h"		  // Para SmartSprite
 #include "stage.h"				  // Para number, get, Stage, total_power
-#include "tabe.h"				  // Para Tabe
+#include "tabe.h"				  // Para Tabe, TabeState
 #include "text.h"				  // Para Text
 #include "texture.h"			  // Para Texture
 
@@ -329,8 +328,11 @@ void Game::updateGameStateGameOver()
 
 	if (fade_out_->isEnabled())
 	{
-		const float vol = static_cast<float>(64 * (100 - fade_out_->getValue())) / 100.0f;
-		JA_SetSoundVolume(to_JA_volume(static_cast<int>(vol)));
+		if (options.audio.enabled)
+		{
+			const float vol = static_cast<float>(64 * (100 - fade_out_->getValue())) / 100.0f;
+			JA_SetSoundVolume(to_JA_volume(static_cast<int>(vol)));
+		}
 	}
 
 	if (fade_out_->hasEnded())
@@ -345,8 +347,11 @@ void Game::updateGameStateGameOver()
 			// La partida ha terminado con la derrota de los jugadores
 			section::name = section::Name::HI_SCORE_TABLE;
 		}
-		JA_StopChannel(-1);
-		JA_SetSoundVolume(to_JA_volume(options.audio.sound.volume));
+		if (options.audio.enabled)
+		{
+			JA_StopChannel(-1);
+			JA_SetSoundVolume(to_JA_volume(options.audio.sound.volume));
+		}
 	}
 }
 
@@ -957,9 +962,7 @@ void Game::updateTimeStopped()
 // Actualiza el juego
 void Game::update()
 {
-	constexpr int TICKS_SPEED = 15;
-
-	if (SDL_GetTicks() - ticks_ > TICKS_SPEED)
+	if (SDL_GetTicks() - ticks_ > param.game.speed)
 	{
 		ticks_ = SDL_GetTicks();
 
@@ -1218,15 +1221,7 @@ void Game::checkEvents()
 	SDL_Event event;
 	while (SDL_PollEvent(&event))
 	{
-		// Evento de salida de la aplicación
-		if (event.type == SDL_QUIT)
-		{
-			section::name = section::Name::QUIT;
-			section::options = section::Options::QUIT_FROM_EVENT;
-			break;
-		}
-
-		else if (event.type == SDL_WINDOWEVENT)
+		if (event.type == SDL_WINDOWEVENT)
 		{
 			switch (event.window.event)
 			{
@@ -1240,109 +1235,19 @@ void Game::checkEvents()
 				pause(false);
 				break;
 			}
-			case SDL_WINDOWEVENT_SIZE_CHANGED:
-			{
-				reloadTextures();
-				break;
-			}
+
 			default:
 				break;
 			}
 		}
 
 #ifdef DEBUG
-		else if (event.type == SDL_KEYDOWN && event.key.repeat == 0)
-		{
-			switch (event.key.keysym.sym)
-			{
-			case SDLK_1: // Crea una powerball
-			{
-				balloon_manager_->createPowerBall();
-				break;
-			}
-			case SDLK_2: // Crea dos globos gordos
-			{
-				balloon_manager_->createTwoBigBalloons();
-			}
-			break;
-			case SDLK_3: // Activa el modo para pasar el juego automaticamente
-			{
-				auto_pop_balloons_ = !auto_pop_balloons_;
-				Notifier::get()->showText({"auto advance: " + boolToString(auto_pop_balloons_)});
-				if (auto_pop_balloons_)
-					balloon_manager_->destroyAllBalloons();
-				balloon_manager_->setDeployBalloons(!auto_pop_balloons_);
-				break;
-			}
-			case SDLK_4: // Suelta un item
-			{
-				createItem(ItemType::CLOCK, players_.at(0)->getPosX(), players_.at(0)->getPosY() - 40);
-				break;
-			}
-			case SDLK_5: // 5.000
-			{
-				const int x = players_.at(0)->getPosX() + (players_.at(0)->getWidth() - game_text_textures_[3]->getWidth()) / 2;
-				createItemText(x, game_text_textures_.at(2));
-				break;
-			}
-			case SDLK_6: // Crea un mensaje
-			{
-				createMessage({paths_.at(0), paths_.at(1)}, Resource::get()->getTexture("game_text_get_ready"));
-				break;
-			}
-			case SDLK_7: // 100.000
-			{
-				// screen_->flash(flash_color, 3);
-				// tabe_->setState(TabeState::HIT);
-				const int x = players_.at(0)->getPosX() + (players_.at(0)->getWidth() - game_text_textures_[3]->getWidth()) / 2;
-				createItemText(x, game_text_textures_.at(6));
-				break;
-				break;
-			}
-			case SDLK_8:
-			{
-				for (auto player : players_)
-				{
-					if (player->isPlaying())
-					{
-						createItem(ItemType::COFFEE_MACHINE, player->getPosX(), param.game.game_area.rect.y - param.game.coffee_machine_h);
-						break;
-					}
-				}
-				break;
-			}
-			case SDLK_9:
-			{
-				tabe_->enable();
-				break;
-			}
-			default:
-				break;
-			}
-		}
+		checkDebugEvents(event);
 #endif
-		// Comprueba el cursor
-		Mouse::handleEvent(event);
+		globalEvents::check(event);
 	}
 }
 
-// Recarga las texturas
-void Game::reloadTextures()
-{
-	for (auto &texture : item_textures_)
-		texture->reLoad();
-
-	for (auto &textures : player_textures_)
-		for (auto &texture : textures)
-			texture->reLoad();
-
-	for (auto &texture : game_text_textures_)
-		texture->reLoad();
-
-	bullet_texture_->reLoad();
-	background_->reloadTextures();
-}
-
 // Actualiza el marcador
 void Game::updateScoreboard()
 {
@@ -1455,12 +1360,14 @@ void Game::checkPauseInput()
 {
 	// Comprueba los mandos
 	for (int i = 0; i < input_->getNumControllers(); ++i)
+	{
 		if (input_->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i) &&
 			input_->checkInput(InputType::PAUSE, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i))
 		{
 			pause(!paused_);
 			return;
 		}
+	}
 
 	// Comprueba el teclado
 	if (input_->checkInput(InputType::PAUSE, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
@@ -1477,7 +1384,8 @@ void Game::handleDemoMode()
 	for (const auto &player : players_)
 	{
 		if (player->isPlaying())
-		{ // Maneja el input específico del jugador en modo demo.
+		{
+			// Maneja el input específico del jugador en modo demo.
 			handleDemoPlayerInput(player, index);
 		}
 
@@ -1555,7 +1463,7 @@ void Game::handlePlayersInput()
 			// Gestiona la continuación del jugador.
 			handlePlayerContinue(player);
 		}
-		else if (player->isEnteringName() || player->isEnteringNameGameCompleted())
+		else if (player->isEnteringName() || player->isEnteringNameGameCompleted() || player->isShowingName())
 		{
 			// Gestiona la introducción del nombre del jugador.
 			handleNameInput(player);
@@ -1650,7 +1558,11 @@ void Game::handleNameInput(const std::shared_ptr<Player> &player)
 		input_->checkInput(InputType::FIRE_CENTER, INPUT_DO_NOT_ALLOW_REPEAT, options.controllers[controllerIndex].type, options.controllers[controllerIndex].index) ||
 		input_->checkInput(InputType::FIRE_RIGHT, INPUT_DO_NOT_ALLOW_REPEAT, options.controllers[controllerIndex].type, options.controllers[controllerIndex].index))
 	{
-		if (player->getEnterNamePositionOverflow())
+		if (player->isShowingName())
+		{
+			player->setPlayingState(PlayerState::CONTINUE);
+		}
+		else if (player->getEnterNamePositionOverflow())
 		{
 			player->setInput(InputType::START);
 			addScoreToScoreBoard(player);
@@ -1939,7 +1851,7 @@ void Game::updateGameStateEnteringPlayer()
 	updatePlayers();
 	updateScoreboard();
 	updateBackground();
-	for (auto player : players_)
+	for (const auto &player : players_)
 	{
 		if (player->isPlaying())
 		{
@@ -2066,3 +1978,78 @@ void Game::setState(GameState state)
 	state_ = state;
 	counter_ = 0;
 }
+
+#ifdef DEBUG
+// Comprueba los eventos en el modo DEBUG
+void Game::checkDebugEvents(const SDL_Event &event)
+{
+	if (event.type == SDL_KEYDOWN && event.key.repeat == 0)
+	{
+		switch (event.key.keysym.sym)
+		{
+		case SDLK_1: // Crea una powerball
+		{
+			balloon_manager_->createPowerBall();
+			break;
+		}
+		case SDLK_2: // Crea dos globos gordos
+		{
+			balloon_manager_->createTwoBigBalloons();
+			break;
+		}
+		case SDLK_3: // Activa el modo para pasar el juego automaticamente
+		{
+			auto_pop_balloons_ = !auto_pop_balloons_;
+			Notifier::get()->show({"auto advance: " + boolToString(auto_pop_balloons_)});
+			if (auto_pop_balloons_)
+			{
+				balloon_manager_->destroyAllBalloons();
+			}
+			balloon_manager_->setDeployBalloons(!auto_pop_balloons_);
+			break;
+		}
+		case SDLK_4: // Suelta un item
+		{
+			createItem(ItemType::CLOCK, players_.at(0)->getPosX(), players_.at(0)->getPosY() - 40);
+			break;
+		}
+		case SDLK_5: // 5.000
+		{
+			const int X = players_.at(0)->getPosX() + (players_.at(0)->getWidth() - game_text_textures_[3]->getWidth()) / 2;
+			createItemText(X, game_text_textures_.at(2));
+			break;
+		}
+		case SDLK_6: // Crea un mensaje
+		{
+			createMessage({paths_.at(0), paths_.at(1)}, Resource::get()->getTexture("game_text_get_ready"));
+			break;
+		}
+		case SDLK_7: // 100.000
+		{
+			const int X = players_.at(0)->getPosX() + (players_.at(0)->getWidth() - game_text_textures_[3]->getWidth()) / 2;
+			createItemText(X, game_text_textures_.at(6));
+			break;
+		}
+		case SDLK_8:
+		{
+			for (const auto &player : players_)
+			{
+				if (player->isPlaying())
+				{
+					createItem(ItemType::COFFEE_MACHINE, player->getPosX(), param.game.game_area.rect.y - param.game.coffee_machine_h);
+					break;
+				}
+			}
+			break;
+		}
+		case SDLK_9:
+		{
+			tabe_->enable();
+			break;
+		}
+		default:
+			break;
+		}
+	}
+}
+#endif

source/game.h

@@ -2,6 +2,7 @@
 
 #include <SDL2/SDL_render.h>	  // Para SDL_Renderer, SDL_Texture
 #include <SDL2/SDL_stdinc.h>	  // Para Uint32, Uint8
+#include <SDL2/SDL_events.h>	  // Para SDL_PollEvent, SDL_Event, SDL_KEYDOWN
 #include <memory>				  // Para shared_ptr, unique_ptr
 #include <string>				  // Para string
 #include <vector>				  // Para vector
@@ -173,6 +174,9 @@ private:
 	GameState state_ = GameState::FADE_IN;				  // Estado
 #ifdef DEBUG
 	bool auto_pop_balloons_ = false; // Si es true, incrementa automaticamente los globos explotados
+
+	// Comprueba los eventos en el modo DEBUG
+	void checkDebugEvents(const SDL_Event &event);
 #endif
 
 	// Actualiza el juego
@@ -298,9 +302,6 @@ private:
 	// Comprueba si todos los jugadores han terminado de jugar
 	bool allPlayersAreNotPlaying();
 
-	// Recarga las texturas
-	void reloadTextures();
-
 	// Actualiza el marcador
 	void updateScoreboard();
 

source/game_logo.cpp

@@ -244,15 +244,6 @@ bool GameLogo::hasFinished() const
     return post_finished_counter_ == 0;
 }
 
-// Recarga las texturas
-void GameLogo::reLoad()
-{
-    dust_texture_->reLoad();
-    coffee_texture_->reLoad();
-    crisis_texture_->reLoad();
-    arcade_edition_texture_->reLoad();
-}
-
 // Calcula el desplazamiento vertical inicial
 int GameLogo::getInitialVerticalDesp()
 {

source/game_logo.h

@@ -25,7 +25,7 @@ private:
         int lenght = 8;         // Cantidad de desplazamientos a realizar
         int remaining = lenght; // Cantidad de desplazamientos pendientes a realizar
         int counter = delay;    // Contador para el retraso
-        int origin;             // Valor inicial de la pantalla para dejarla igual tras el desplazamiento
+        int origin = 0;             // Valor inicial de la pantalla para dejarla igual tras el desplazamiento
 
         // Constructor por defect
         Shake() = default;
@@ -61,9 +61,9 @@ private:
     std::unique_ptr<Sprite> arcade_edition_sprite_; // Sprite con los graficos de "Arcade Edition"
 
     // Variables
-    int x_;                           // Posición donde dibujar el logo
-    int y_;                           // Posición donde dibujar el logo
-    float zoom_;                      // Zoom aplicado al texto "ARCADE EDITION"
+    int x_;                         // Posición donde dibujar el logo
+    int y_;                         // Posición donde dibujar el logo
+    float zoom_ = 1.0f;             // Zoom aplicado al texto "ARCADE EDITION"
     int post_finished_counter_ = 1; // Contador final una vez terminada las animaciones de los logos
 
     Status coffee_crisis_status_ = Status::DISABLED;  // Estado en el que se encuentra el texto "COFFEE CRISIS"
@@ -94,7 +94,4 @@ public:
 
     // Indica si ha terminado la animación
     bool hasFinished() const;
-
-    // Recarga las texturas
-    void reLoad();
 };

source/gif.c

@@ -1,479 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <fcntl.h>
-
-#define EXTENSION_INTRODUCER   0x21
-#define IMAGE_DESCRIPTOR       0x2C
-#define TRAILER                0x3B
-
-#define GRAPHIC_CONTROL        0xF9
-#define APPLICATION_EXTENSION  0xFF
-#define COMMENT_EXTENSION      0xFE
-#define PLAINTEXT_EXTENSION    0x01
-
-#define READ(dst, size) memcpy(dst, buffer, size); buffer += size
-
-typedef struct
-{
-    unsigned short width;
-    unsigned short height;
-    unsigned char fields;
-    unsigned char background_color_index;
-    unsigned char pixel_aspect_ratio;
-}
-screen_descriptor_t;
-
-typedef struct
-{
-    unsigned char r;
-    unsigned char g;
-    unsigned char b;
-}
-rgb;
-
-typedef struct
-{
-    unsigned short image_left_position;
-    unsigned short image_top_position;
-    unsigned short image_width;
-    unsigned short image_height;
-    unsigned char fields;
-}
-image_descriptor_t;
-
-typedef struct
-{
-    unsigned char byte;
-    int prev;
-    int len;
-}
-dictionary_entry_t;
-
-typedef struct
-{
-    unsigned char extension_code;
-    unsigned char block_size;
-}
-extension_t;
-
-typedef struct
-{
-    unsigned char fields;
-    unsigned short delay_time;
-    unsigned char transparent_color_index;
-}
-graphic_control_extension_t;
-
-typedef struct
-{
-    unsigned char application_id[ 8 ];
-    unsigned char version[ 3 ];
-}
-application_extension_t;
-
-typedef struct
-{
-    unsigned short left;
-    unsigned short top;
-    unsigned short width;
-    unsigned short height;
-    unsigned char cell_width;
-    unsigned char cell_height;
-    unsigned char foreground_color;
-    unsigned char background_color;
-}
-plaintext_extension_t;
-
-//static unsigned short width = 0;
-//static unsigned short height = 0;
-//static unsigned char* uncompressed_data = NULL;
-
-void uncompress( int code_length,
-               const unsigned char *input,
-               int input_length,
-               unsigned char *out )
-{
-    //int maxbits;
-    int i, bit;
-    int code, prev = -1;
-    dictionary_entry_t *dictionary;
-    int dictionary_ind;
-    unsigned int mask = 0x01;
-    int reset_code_length;
-    int clear_code; // This varies depending on code_length
-    int stop_code;  // one more than clear code
-    int match_len;
-    
-
-    clear_code = 1 << ( code_length );
-    stop_code = clear_code + 1;
-    // To handle clear codes
-    reset_code_length = code_length;
-
-    // Create a dictionary large enough to hold "code_length" entries.
-    // Once the dictionary overflows, code_length increases
-    dictionary = ( dictionary_entry_t * )
-    malloc( sizeof( dictionary_entry_t ) * ( 1 << ( code_length + 1 ) ) );
-
-    // Initialize the first 2^code_len entries of the dictionary with their
-    // indices.  The rest of the entries will be built up dynamically.
-
-    // Technically, it shouldn't be necessary to initialize the
-    // dictionary.  The spec says that the encoder "should output a
-    // clear code as the first code in the image data stream".  It doesn't
-    // say must, though...
-    for ( dictionary_ind = 0;
-         dictionary_ind < ( 1 << code_length );
-         dictionary_ind++ )
-    {
-        dictionary[ dictionary_ind ].byte = dictionary_ind;
-        // XXX this only works because prev is a 32-bit int (> 12 bits)
-        dictionary[ dictionary_ind ].prev = -1;
-        dictionary[ dictionary_ind ].len = 1;
-    }
-
-    // 2^code_len + 1 is the special "end" code; don't give it an entry here
-    dictionary_ind++;
-    dictionary_ind++;
-
-    // TODO verify that the very last byte is clear_code + 1
-    while ( input_length )
-    {
-        code = 0x0;
-        // Always read one more bit than the code length
-        for ( i = 0; i < ( code_length + 1 ); ++i )
-        {
-            // This is different than in the file read example; that
-            // was a call to "next_bit"
-            bit = ( *input & mask ) ? 1 : 0;
-            mask <<= 1;
-
-            if ( mask == 0x100 )
-            {
-                mask = 0x01;
-                input++;
-                input_length--;
-            }
-
-            code = code | ( bit << i );
-        }
-
-        if ( code == clear_code )
-        {
-            code_length = reset_code_length;
-            dictionary = ( dictionary_entry_t * ) realloc( dictionary,
-                                                          sizeof( dictionary_entry_t ) * ( 1 << ( code_length + 1 ) ) );
-
-            for ( dictionary_ind = 0;
-                 dictionary_ind < ( 1 << code_length );
-                 dictionary_ind++ )
-            {
-                dictionary[ dictionary_ind ].byte = dictionary_ind;
-                // XXX this only works because prev is a 32-bit int (> 12 bits)
-                dictionary[ dictionary_ind ].prev = -1;
-                dictionary[ dictionary_ind ].len = 1;
-            }
-            dictionary_ind++;
-            dictionary_ind++;
-            prev = -1;
-            continue;
-        }
-        else if ( code == stop_code )
-        {
-            /*if ( input_length > 1 )
-            {
-                fprintf( stderr, "Malformed GIF (early stop code)\n" );
-                exit( 0 );
-            }*/
-            break;
-        }
-
-        // Update the dictionary with this character plus the _entry_
-        // (character or string) that came before it
-        if ( ( prev > -1 ) && ( code_length < 12 ) )
-        {
-            if ( code > dictionary_ind )
-            {
-                fprintf( stderr, "code = %.02x, but dictionary_ind = %.02x\n",
-                        code, dictionary_ind );
-                exit( 0 );
-            }
-
-            // Special handling for KwKwK
-            if ( code == dictionary_ind )
-            {
-                int ptr = prev;
-
-                while ( dictionary[ ptr ].prev != -1 )
-                {
-                    ptr = dictionary[ ptr ].prev;
-                }
-                dictionary[ dictionary_ind ].byte = dictionary[ ptr ].byte;
-            }
-            else
-            {
-                int ptr = code;
-                while ( dictionary[ ptr ].prev != -1 )
-                {
-                    ptr = dictionary[ ptr ].prev;
-                }
-                dictionary[ dictionary_ind ].byte = dictionary[ ptr ].byte;
-            }
-
-            dictionary[ dictionary_ind ].prev = prev;
-
-            dictionary[ dictionary_ind ].len = dictionary[ prev ].len + 1;
-
-            dictionary_ind++;
-
-            // GIF89a mandates that this stops at 12 bits
-            if ( ( dictionary_ind == ( 1 << ( code_length + 1 ) ) ) &&
-                ( code_length < 11 ) )
-            {
-                code_length++;
-
-                dictionary = ( dictionary_entry_t * ) realloc( dictionary,
-                                                              sizeof( dictionary_entry_t ) * ( 1 << ( code_length + 1 ) ) );
-            }
-        }
-
-        prev = code;
-
-        // Now copy the dictionary entry backwards into "out"
-        match_len = dictionary[ code ].len;
-        while ( code != -1 )
-        {
-            out[ dictionary[ code ].len - 1 ] = dictionary[ code ].byte;
-            if ( dictionary[ code ].prev == code )
-            {
-                fprintf( stderr, "Internal error; self-reference." );
-                exit( 0 );
-            }
-            code = dictionary[ code ].prev;
-        }
-
-        out += match_len;
-    }
-}
-
-static int read_sub_blocks( unsigned char* buffer, unsigned char **data )
-{
-    int data_length;
-    int index;
-    unsigned char block_size;
-
-    // Everything following are data sub-blocks, until a 0-sized block is
-    // encountered.
-    data_length = 0;
-    *data = NULL;
-    index = 0;
-
-    while ( 1 )
-    {
-		READ(&block_size, 1);
-
-        if ( block_size == 0 )  // end of sub-blocks
-        {
-            break;
-        }
-
-        data_length += block_size;
-        *data = (unsigned char*)realloc( *data, data_length );
-
-        // TODO this could be split across block size boundaries
-		READ(*data + index, block_size);
-
-        index += block_size;
-    }
-
-    return data_length;
-}
-
-unsigned char* process_image_descriptor( unsigned char* buffer,
-                                    rgb *gct,
-                                    int gct_size,
-                                    int resolution_bits )
-{
-    image_descriptor_t image_descriptor;
-    int compressed_data_length;
-    unsigned char *compressed_data = NULL;
-    unsigned char lzw_code_size;
-    int uncompressed_data_length = 0;
-    unsigned char *uncompressed_data = NULL;
-
-    // TODO there could actually be lots of these
-	READ(&image_descriptor, 9);
-
-    // TODO if LCT = true, read the LCT
-
-	READ(&lzw_code_size, 1);
-
-    compressed_data_length = read_sub_blocks( buffer, &compressed_data );
-
-//    width = image_descriptor.image_width;
-//    height = image_descriptor.image_height;
-    uncompressed_data_length = image_descriptor.image_width *
-    image_descriptor.image_height;
-    uncompressed_data = (unsigned char*)malloc( uncompressed_data_length );
-
-    uncompress( lzw_code_size, compressed_data, compressed_data_length,
-               uncompressed_data );
-
-    if ( compressed_data ) free( compressed_data );
-
-    //if ( uncompressed_data )
-    //    free( uncompressed_data );
-
-    return uncompressed_data;
-}
-
-/**
- * @param gif_file the file descriptor of a file containing a
- *  GIF-encoded file.  This should point to the first byte in
- *  the file when invoked.
- */
-#define rb (*(buffer++))
-
-uint32_t* LoadPalette(unsigned char *buffer) {
-	unsigned char header[7];
-	screen_descriptor_t screen_descriptor;
-	//int color_resolution_bits;
-
-	int global_color_table_size = 0;  // number of entries in global_color_table
-	uint32_t *global_color_table = NULL;
-
-	READ(header, 6);
-	READ(&screen_descriptor, 7);
-
-	//color_resolution_bits = ((screen_descriptor.fields & 0x70) >> 4) + 1;
-	global_color_table = (uint32_t *)calloc(1, 1024);
-
-	if (screen_descriptor.fields & 0x80) {
-		global_color_table_size = 1 << (((screen_descriptor.fields & 0x07) + 1));
-
-		//global_color_table = (rgb *)malloc(3 * global_color_table_size);
-		//READ(global_color_table, 3 * global_color_table_size);
-        for (int i=0; i<global_color_table_size;++i) {
-            global_color_table[i] = (buffer[0]<<16) + (buffer[1]<<8) + buffer[2];
-            buffer+=3;
-        }
-	}
-	return global_color_table;
-}
-
-static unsigned char* process_gif_stream(unsigned char *buffer, unsigned short* w, unsigned short* h)
-{
-    unsigned char header[ 7 ];
-    screen_descriptor_t screen_descriptor;
-    int color_resolution_bits;
-
-    int global_color_table_size =0;  // number of entries in global_color_table
-    rgb *global_color_table = NULL;
-
-    unsigned char block_type = 0x0;
-
-    // A GIF file starts with a Header (section 17)
-	READ(header, 6);
-    header[ 6 ] = 0x0;
-
-    // XXX there's another format, GIF87a, that you may still find
-    // floating around.
-    /*if ( strcmp( "GIF89a", (char*)header ) )
-    {
-        fprintf( stderr,
-                "Invalid GIF file (header is '%s', should be 'GIF89a')\n",
-                header );
-        return NULL;
-    }*/
-
-    // Followed by a logical screen descriptor
-    // Note that this works because GIFs specify little-endian order; on a
-    // big-endian machine, the height & width would need to be reversed.
-
-    // Can't use sizeof here since GCC does byte alignment;
-    // sizeof( screen_descriptor_t ) = 8!
-	READ(&screen_descriptor, 7);
-    *w = screen_descriptor.width;
-    *h = screen_descriptor.height;
-
-    color_resolution_bits = ( ( screen_descriptor.fields & 0x70 ) >> 4 ) + 1;
-
-    if ( screen_descriptor.fields & 0x80 )
-    {
-        //int i;
-        // If bit 7 is set, the next block is a global color table; read it
-        global_color_table_size = 1 << 
-        ( ( ( screen_descriptor.fields & 0x07 ) + 1 ) );
-        
-        global_color_table = ( rgb * ) malloc( 3 * global_color_table_size );
-        
-        // XXX this could conceivably return a short count...
-		READ(global_color_table, 3 * global_color_table_size);
-    }
-    
-    while ( block_type != TRAILER )
-    {
-		READ(&block_type, 1);
-        
-        unsigned char size;
-        switch ( block_type )
-        {
-            case IMAGE_DESCRIPTOR:
-				return process_image_descriptor(buffer,
-					global_color_table,
-					global_color_table_size,
-					color_resolution_bits);
-                break;
-            case EXTENSION_INTRODUCER:
-                buffer++;
-                size = *(buffer++);
-                buffer += size;
-                do {
-                    size = *(buffer++);
-                    buffer += size;
-                } while (size != 0);
-
-                /*if ( !process_extension( buffer ) )
-                {
-                    return NULL;
-                }*/
-                break;
-            case TRAILER:
-                break;
-            default:
-                fprintf( stderr, "Bailing on unrecognized block type %.02x\n",
-                        block_type );
-                return NULL;
-        }
-    }
-	return NULL;
-}
-
-
-unsigned char* LoadGif(unsigned char *buffer, unsigned short* w, unsigned short* h) {
-	return process_gif_stream(buffer, w, h);
-}
-
-/*int main( int argc, char *argv[] )
-{
-    FILE* gif_file;
-    
-    if ( argc < 2 )
-    {
-        fprintf( stderr, "Usage: %s <path-to-gif-file>\n", argv[ 0 ] );
-        exit( 0 );
-    }
-    
-    gif_file = fopen( argv[ 1 ], "rb" );
-    
-    if ( gif_file == NULL )
-    {
-        fprintf( stderr, "Unable to open file '%s'", argv[ 1 ] );
-        perror( ": " );
-    }
-    
-    process_gif_stream( gif_file );
-    
-    fclose( gif_file );
-}*/

source/gif.cpp

@@ -0,0 +1,261 @@
+#include "gif.h"
+#include <cstdio>  // Para NULL, fprintf, stderr
+#include <cstdlib> // Para malloc, realloc, exit, calloc, free
+
+void Gif::uncompress(int code_length, const uint8_t *input, int input_length, uint8_t *out)
+{
+    int i, bit;
+    int code, prev = -1;
+    std::vector<DictionaryEntry> dictionary;
+    int dictionary_ind;
+    unsigned int mask = 0x01;
+    int reset_code_length;
+    int clear_code;
+    int stop_code;
+    int match_len;
+
+    clear_code = 1 << (code_length);
+    stop_code = clear_code + 1;
+    reset_code_length = code_length;
+
+    dictionary.resize(1 << (code_length + 1));
+
+    for (dictionary_ind = 0; dictionary_ind < (1 << code_length); dictionary_ind++)
+    {
+        dictionary[dictionary_ind].byte = dictionary_ind;
+        dictionary[dictionary_ind].prev = -1;
+        dictionary[dictionary_ind].len = 1;
+    }
+
+    dictionary_ind += 2;
+
+    while (input_length)
+    {
+        code = 0x0;
+        for (i = 0; i < (code_length + 1); i++)
+        {
+            bit = (*input & mask) ? 1 : 0;
+            mask <<= 1;
+
+            if (mask == 0x100)
+            {
+                mask = 0x01;
+                input++;
+                input_length--;
+            }
+
+            code = code | (bit << i);
+        }
+
+        if (code == clear_code)
+        {
+            code_length = reset_code_length;
+            dictionary.resize(1 << (code_length + 1));
+
+            for (dictionary_ind = 0; dictionary_ind < (1 << code_length); dictionary_ind++)
+            {
+                dictionary[dictionary_ind].byte = dictionary_ind;
+                dictionary[dictionary_ind].prev = -1;
+                dictionary[dictionary_ind].len = 1;
+            }
+            dictionary_ind += 2;
+            prev = -1;
+            continue;
+        }
+        else if (code == stop_code)
+        {
+            break;
+        }
+
+        if ((prev > -1) && (code_length < 12))
+        {
+            if (code > dictionary_ind)
+            {
+                fprintf(stderr, "code = %.02x, but dictionary_ind = %.02x\n", code, dictionary_ind);
+                exit(0);
+            }
+
+            if (code == dictionary_ind)
+            {
+                int ptr = prev;
+                while (dictionary[ptr].prev != -1)
+                {
+                    ptr = dictionary[ptr].prev;
+                }
+                dictionary[dictionary_ind].byte = dictionary[ptr].byte;
+            }
+            else
+            {
+                int ptr = code;
+                while (dictionary[ptr].prev != -1)
+                {
+                    ptr = dictionary[ptr].prev;
+                }
+                dictionary[dictionary_ind].byte = dictionary[ptr].byte;
+            }
+
+            dictionary[dictionary_ind].prev = prev;
+            dictionary[dictionary_ind].len = dictionary[prev].len + 1;
+            dictionary_ind++;
+
+            if ((dictionary_ind == (1 << (code_length + 1))) && (code_length < 11))
+            {
+                code_length++;
+                dictionary.resize(1 << (code_length + 1));
+            }
+        }
+
+        prev = code;
+
+        match_len = dictionary[code].len;
+        while (code != -1)
+        {
+            out[dictionary[code].len - 1] = dictionary[code].byte;
+            if (dictionary[code].prev == code)
+            {
+                fprintf(stderr, "Internal error; self-reference.");
+                exit(0);
+            }
+            code = dictionary[code].prev;
+        }
+
+        out += match_len;
+    }
+}
+
+int Gif::read_sub_blocks(uint8_t *buffer, uint8_t **data)
+{
+    int data_length = 0;
+    int index = 0;
+    uint8_t block_size;
+
+    *data = nullptr;
+
+    while (true)
+    {
+        READ(&block_size, 1);
+
+        if (block_size == 0)
+        {
+            break;
+        }
+
+        data_length += block_size;
+        *data = (uint8_t *)realloc(*data, data_length);
+
+        READ(*data + index, block_size);
+        index += block_size;
+    }
+
+    return data_length;
+}
+
+uint8_t *Gif::process_image_descriptor(uint8_t *buffer, RGB *gct, int gct_size, int resolution_bits)
+{
+    ImageDescriptor image_descriptor;
+    int compressed_data_length;
+    uint8_t *compressed_data = nullptr;
+    uint8_t lzw_code_size;
+    int uncompressed_data_length = 0;
+    uint8_t *uncompressed_data = nullptr;
+
+    READ(&image_descriptor, 9);
+    READ(&lzw_code_size, 1);
+
+    compressed_data_length = read_sub_blocks(buffer, &compressed_data);
+    uncompressed_data_length = image_descriptor.image_width * image_descriptor.image_height;
+    uncompressed_data = (uint8_t *)malloc(uncompressed_data_length);
+
+    uncompress(lzw_code_size, compressed_data, compressed_data_length, uncompressed_data);
+
+    if (compressed_data)
+    {
+        free(compressed_data);
+    }
+
+    return uncompressed_data;
+}
+
+uint32_t *Gif::LoadPalette(uint8_t *buffer)
+{
+    uint8_t header[7];
+    ScreenDescriptor screen_descriptor;
+    int global_color_table_size = 0;
+    uint32_t *global_color_table = nullptr;
+
+    READ(header, 6);
+    READ(&screen_descriptor, 7);
+
+    global_color_table = (uint32_t *)calloc(1, 1024);
+
+    if (screen_descriptor.fields & 0x80)
+    {
+        global_color_table_size = 1 << (((screen_descriptor.fields & 0x07) + 1));
+
+        for (int i = 0; i < global_color_table_size; ++i)
+        {
+            global_color_table[i] = (buffer[0] << 16) + (buffer[1] << 8) + buffer[2];
+            buffer += 3;
+        }
+    }
+    return global_color_table;
+}
+
+uint8_t *Gif::process_gif_stream(uint8_t *buffer, uint16_t *w, uint16_t *h)
+{
+    uint8_t header[7];
+    ScreenDescriptor screen_descriptor;
+    int color_resolution_bits;
+    int global_color_table_size = 0;
+    RGB *global_color_table = nullptr;
+    uint8_t block_type = 0x0;
+
+    READ(header, 6);
+    header[6] = 0x0;
+
+    READ(&screen_descriptor, 7);
+    *w = screen_descriptor.width;
+    *h = screen_descriptor.height;
+
+    color_resolution_bits = ((screen_descriptor.fields & 0x70) >> 4) + 1;
+
+    if (screen_descriptor.fields & 0x80)
+    {
+        global_color_table_size = 1 << (((screen_descriptor.fields & 0x07) + 1));
+        global_color_table = (RGB *)malloc(3 * global_color_table_size);
+        READ(global_color_table, 3 * global_color_table_size);
+    }
+
+    while (block_type != TRAILER)
+    {
+        READ(&block_type, 1);
+
+        uint8_t size;
+        switch (block_type)
+        {
+        case IMAGE_DESCRIPTOR:
+            return process_image_descriptor(buffer, global_color_table, global_color_table_size, color_resolution_bits);
+        case EXTENSION_INTRODUCER:
+            buffer++;
+            size = *(buffer++);
+            buffer += size;
+            do
+            {
+                size = *(buffer++);
+                buffer += size;
+            } while (size != 0);
+            break;
+        case TRAILER:
+            break;
+        default:
+            fprintf(stderr, "Bailing on unrecognized block type %.02x\n", block_type);
+            return nullptr;
+        }
+    }
+    return nullptr;
+}
+
+uint8_t *Gif::LoadGif(uint8_t *buffer, uint16_t *w, uint16_t *h)
+{
+    return process_gif_stream(buffer, w, h);
+}

source/gif.h

@@ -0,0 +1,86 @@
+#pragma once
+
+#include <cstdint> // Para uint32_t
+#include <cstring> // Para memcpy
+#include <vector>
+
+#define EXTENSION_INTRODUCER 0x21
+#define IMAGE_DESCRIPTOR 0x2C
+#define TRAILER 0x3B
+#define GRAPHIC_CONTROL 0xF9
+#define APPLICATION_EXTENSION 0xFF
+#define COMMENT_EXTENSION 0xFE
+#define PLAINTEXT_EXTENSION 0x01
+
+#define READ(dst, size)        \
+    memcpy(dst, buffer, size); \
+    buffer += size
+
+struct ScreenDescriptor
+{
+    uint16_t width;
+    uint16_t height;
+    uint8_t fields;
+    uint8_t background_color_index;
+    uint8_t pixel_aspect_ratio;
+};
+
+struct RGB
+{
+    uint8_t r, g, b;
+};
+
+struct ImageDescriptor
+{
+    uint16_t image_left_position;
+    uint16_t image_top_position;
+    uint16_t image_width;
+    uint16_t image_height;
+    uint8_t fields;
+};
+
+struct DictionaryEntry
+{
+    uint8_t byte;
+    int prev;
+    int len;
+};
+
+struct Extension
+{
+    uint8_t extension_code;
+    uint8_t block_size;
+};
+
+struct GraphicControlExtension
+{
+    uint8_t fields;
+    uint16_t delay_time;
+    uint8_t transparent_color_index;
+};
+
+struct ApplicationExtension
+{
+    uint8_t application_id[8];
+    uint8_t version[3];
+};
+
+struct PlaintextExtension
+{
+    uint16_t left, top, width, height;
+    uint8_t cell_width, cell_height;
+    uint8_t foreground_color, background_color;
+};
+
+class Gif
+{
+public:
+    void uncompress(int code_length, const uint8_t *input, int input_length, uint8_t *out);
+    uint32_t *LoadPalette(uint8_t *buffer);
+    uint8_t *LoadGif(uint8_t *buffer, uint16_t *w, uint16_t *h);
+
+private:
+    int read_sub_blocks(uint8_t *buffer, uint8_t **data);
+    uint8_t *process_image_descriptor(uint8_t *buffer, RGB *gct, int gct_size, int resolution_bits);
+    uint8_t *process_gif_stream(uint8_t *buffer, uint16_t *w, uint16_t *h);
+};

source/global_events.cpp

@@ -0,0 +1,33 @@
+#include "global_events.h"
+#include <SDL2/SDL_video.h> // Para SDL_WINDOWEVENT_SIZE_CHANGED
+#include <iostream>         // Para char_traits, basic_ostream, operator<<
+#include "mouse.h"          // Para handleEvent
+#include "section.h"        // Para Name, Options, name, options
+
+namespace globalEvents
+{
+    // Comprueba los eventos que se pueden producir en cualquier sección del juego
+    void check(const SDL_Event &event)
+    {
+        switch (event.type)
+        {
+        case SDL_QUIT: // Evento de salida de la aplicación
+            section::name = section::Name::QUIT;
+            section::options = section::Options::QUIT_FROM_EVENT;
+            return;
+        case SDL_RENDER_DEVICE_RESET:
+        case SDL_RENDER_TARGETS_RESET:
+            std::cout << "SDL_RENDER_TARGETS_RESET" << std::endl;
+            break;
+        case SDL_WINDOWEVENT:
+            if (event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED)
+            {
+                std::cout << "SDL_WINDOWEVENT_SIZE_CHANGED" << std::endl;
+            }
+            break;
+        default:
+            break;
+        }
+        Mouse::handleEvent(event);
+    }
+}

source/global_events.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include <SDL2/SDL_events.h>
+
+namespace globalEvents
+{
+    // Comprueba los eventos que se pueden producir en cualquier sección del juego
+    void check(const SDL_Event &event);
+}

source/global_inputs.cpp

@@ -1,16 +1,18 @@
 #include "global_inputs.h"
-#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, options, OptionsGame, OptionsAudio
-#include "screen.h"         // Para Screen, ScreenVideoMode
-#include "section.h"        // Para Name, Options, name, options
-#include "utils.h"          // Para boolToOnOff, stringInVector
+#include <SDL2/SDL_render.h> // Para SDL_RenderSetIntegerScale
+#include <SDL2/SDL_stdinc.h> // Para SDL_FALSE, SDL_TRUE
+#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, INP...
+#include "jail_audio.h"      // Para JA_SetMusicVolume, JA_SetSoundVolume
+#include "lang.h"            // Para getText, Code, getNextLangCode, loadFro...
+#include "notifier.h"        // Para Notifier
+#include "on_screen_help.h"  // Para OnScreenHelp
+#include "options.h"         // Para Options, options, OptionsGame, OptionsV...
+#include "screen.h"          // Para Screen, ScreenVideoMode
+#include "section.h"         // Para Name, name, Options, options, AttractMode
+#include "utils.h"           // Para boolToOnOff
 
 namespace globalInputs
 {
@@ -21,9 +23,8 @@ namespace globalInputs
     // Termina
     void quit(section::Options code)
     {
-        const std::string exit_code = "QUIT";
-        auto code_found = stringInVector(Notifier::get()->getCodes(), exit_code);
-        if (code_found)
+        const std::string CODE = "QUIT";
+        if (Notifier::get()->checkCode(CODE))
         {
             // Si la notificación de salir está activa, cambia de sección
             section::name = section::Name::QUIT;
@@ -33,10 +34,10 @@ namespace globalInputs
         {
             // Si la notificación de salir no está activa, muestra la notificación
 #ifdef ARCADE
-            const int index = code == section::Options::QUIT_WITH_CONTROLLER ? 116 : 94;
-            Notifier::get()->showText({lang::getText(index), std::string()}, -1, exit_code);
+            const int INDEX = code == section::Options::QUIT_WITH_CONTROLLER ? 116 : 94;
+            Notifier::get()->show({lang::getText(INDEX), std::string()}, -1, CODE);
 #else
-            Notifier::get()->showText({lang::getText(94), std::string()}, -1, exit_code);
+            Notifier::get()->show({lang::getText(94), std::string()}, -1, CODE);
 #endif
         }
     }
@@ -44,8 +45,16 @@ namespace globalInputs
     // Reinicia
     void reset()
     {
-        section::name = section::Name::INIT;
-        Notifier::get()->showText({"Reset"});
+        const std::string CODE = "RESET";
+        if (Notifier::get()->checkCode(CODE))
+        {
+            section::name = section::Name::INIT;
+            Notifier::get()->show({lang::getText(111)});
+        }
+        else
+        {
+            Notifier::get()->show({lang::getText(125), std::string()}, -1, CODE);
+        }
     }
 
     // Activa o desactiva el audio
@@ -62,7 +71,23 @@ namespace globalInputs
             JA_SetMusicVolume(0);
             JA_SetSoundVolume(0);
         }
-        Notifier::get()->showText({"Audio " + boolToOnOff(options.audio.enabled)});
+        Notifier::get()->show({"Audio " + boolToOnOff(options.audio.enabled)});
+    }
+
+    // Cambia el modo de escalado entero
+    void toggleintegerScale()
+    {
+        options.video.integer_scale = !options.video.integer_scale;
+        SDL_RenderSetIntegerScale(Screen::get()->getRenderer(), options.video.integer_scale ? SDL_TRUE : SDL_FALSE);
+        Screen::get()->setVideoMode();
+        Notifier::get()->show({lang::getText(134) + " " + boolToOnOff(options.video.integer_scale)});
+    }
+
+    // Activa o desactiva los shaders
+    void toggleShaders()
+    {
+        Screen::get()->toggleShaders();
+        Notifier::get()->show({lang::getText(135) + " " + boolToOnOff(options.video.shaders)});
     }
 
     // Obtiene una fichero a partir de un lang::Code
@@ -88,13 +113,13 @@ namespace globalInputs
         switch (code)
         {
         case lang::Code::ba_BA:
-            return "ba_BA";
+            return " \"ba_BA\"";
             break;
         case lang::Code::es_ES:
-            return "es_ES";
+            return " \"es_ES\"";
             break;
         default:
-            return "en_UK";
+            return " \"en_UK\"";
             break;
         }
     }
@@ -102,18 +127,49 @@ namespace globalInputs
     // Cambia el idioma
     void changeLang()
     {
-        options.game.language = lang::change(options.game.language);
-        lang::loadFromFile(getLangFile(static_cast<lang::Code>(options.game.language)));
-        section::name = section::Name::INIT;
-        section::options = section::Options::RELOAD;
-        Notifier::get()->showText({getLangName(options.game.language)});
+        const std::string CODE = "LANG";
+        if (Notifier::get()->checkCode(CODE))
+        {
+            options.game.language = lang::getNextLangCode(options.game.language);
+            lang::loadFromFile(getLangFile(static_cast<lang::Code>(options.game.language)));
+            section::name = section::Name::INIT;
+            section::options = section::Options::RELOAD;
+            Notifier::get()->show({lang::getText(127) + getLangName(options.game.language)});
+        }
+        else
+        {
+            const auto NEXT = lang::getNextLangCode(options.game.language);
+            Notifier::get()->show({lang::getText(126) + getLangName(NEXT), std::string()}, -1, CODE);
+        }
     }
 
     // Cambia el modo de disparo
     void toggleFireMode()
     {
         options.game.autofire = !options.game.autofire;
-        Notifier::get()->showText({"Autofire " + boolToOnOff(options.game.autofire)});
+        Notifier::get()->show({lang::getText(130) + " " + boolToOnOff(options.game.autofire)});
+    }
+
+    // Salta una sección del juego
+    void skip_section()
+    {
+        switch (section::name)
+        {
+        case section::Name::INTRO:
+            JA_StopMusic();
+            /* Continua en el case de abajo */
+        case section::Name::LOGO:
+        case section::Name::HI_SCORE_TABLE:
+        case section::Name::INSTRUCTIONS:
+        {
+            section::name = section::Name::TITLE;
+            section::options = section::Options::TITLE_1;
+            section::attract_mode = section::AttractMode::TITLE_TO_DEMO;
+            break;
+        }
+        default:
+            break;
+        }
     }
 
     // Comprueba los inputs que se pueden introducir en cualquier sección del juego
@@ -121,34 +177,35 @@ namespace globalInputs
     {
         // Teclado
         {
-#ifndef ARCADE
             // Comprueba el teclado para cambiar entre pantalla completa y ventana
             if (Input::get()->checkInput(InputType::WINDOW_FULLSCREEN, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
             {
                 Screen::get()->toggleVideoMode();
-                const std::string mode = options.video.mode == ScreenVideoMode::WINDOW ? "Window" : "Fullscreen";
-                Notifier::get()->showText({mode + " mode"});
+                const std::string mode = options.video.mode == ScreenVideoMode::WINDOW ? lang::getText(132) : lang::getText(133);
+                Notifier::get()->show({mode});
                 return;
             }
 
             // Comprueba el teclado para decrementar el tamaño de la ventana
             if (Input::get()->checkInput(InputType::WINDOW_DEC_SIZE, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
             {
-                Screen::get()->decWindowSize();
-                const std::string size = std::to_string(options.video.window.size);
-                Notifier::get()->showText({"Window size x" + size});
+                if (Screen::get()->decWindowZoom())
+                {
+                    Notifier::get()->show({lang::getText(131) + " x" + std::to_string(options.video.window.zoom)});
+                }
                 return;
             }
 
             // Comprueba el teclado para incrementar el tamaño de la ventana
             if (Input::get()->checkInput(InputType::WINDOW_INC_SIZE, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
             {
-                Screen::get()->incWindowSize();
-                const std::string size = std::to_string(options.video.window.size);
-                Notifier::get()->showText({"Window size x" + size});
+                if (Screen::get()->incWindowZoom())
+                {
+                    Notifier::get()->show({lang::getText(131) + " x" + std::to_string(options.video.window.zoom)});
+                }
                 return;
             }
-#endif
+
             // Salir
             if (Input::get()->checkInput(InputType::EXIT, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
             {
@@ -156,6 +213,13 @@ namespace globalInputs
                 return;
             }
 
+            // Saltar sección
+            if (Input::get()->checkAnyButtonPressed())
+            {
+                skip_section();
+                return;
+            }
+
             // Reset
             if (Input::get()->checkInput(InputType::RESET, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
             {
@@ -187,7 +251,13 @@ namespace globalInputs
             // Shaders
             if (Input::get()->checkInput(InputType::VIDEO_SHADERS, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
             {
-                Screen::get()->toggleShaders();
+                toggleShaders();
+                return;
+            }
+
+            if (Input::get()->checkInput(InputType::VIDEO_INTEGER_SCALE, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
+            {
+                toggleintegerScale();
                 return;
             }
 
@@ -239,7 +309,7 @@ namespace globalInputs
                 if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i) &&
                     Input::get()->checkInput(InputType::VIDEO_SHADERS, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::CONTROLLER, i))
                 {
-                    Screen::get()->toggleShaders();
+                    toggleShaders();
                     return;
                 }
 #ifdef DEBUG

source/hiscore_table.cpp

@@ -1,31 +1,29 @@
 #include "hiscore_table.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_events.h>	  // Para SDL_PollEvent, SDL_Event
 #include <SDL2/SDL_pixels.h>	  // Para SDL_PIXELFORMAT_RGBA8888
 #include <SDL2/SDL_timer.h>		  // Para SDL_GetTicks
-#include <SDL2/SDL_video.h>		  // Para SDL_WINDOWEVENT_SIZE_CHANGED
-#include <stdlib.h>				  // Para rand
+#include <stdlib.h>				  // Para rand, size_t
 #include <algorithm>			  // Para max
 #include <functional>			  // Para function
 #include <vector>				  // Para vector
 #include "background.h"			  // Para Background
 #include "fade.h"				  // Para Fade, FadeMode, FadeType
+#include "global_events.h"		  // Para check
 #include "global_inputs.h"		  // Para check, update
-#include "input.h"				  // Para Input
 #include "jail_audio.h"			  // Para JA_GetMusicState, JA_Music_state
 #include "lang.h"				  // Para getText
 #include "manage_hiscore_table.h" // Para HiScoreEntry
-#include "mouse.h"				  // Para handleEvent
 #include "options.h"			  // Para Options, OptionsGame, options
 #include "param.h"				  // Para Param, param, ParamGame, ParamFade
 #include "path_sprite.h"		  // Para PathSprite, Path, PathType
 #include "resource.h"			  // Para Resource
 #include "screen.h"				  // Para Screen
-#include "section.h"			  // Para Name, name, Options, options, Attr...
+#include "section.h"			  // Para Name, name
 #include "sprite.h"				  // Para Sprite
-#include "text.h"				  // Para Text, TEXT_COLOR, TEXT_SHADOW
+#include "text.h"				  // Para Text, TEXT_SHADOW, TEXT_COLOR
 #include "texture.h"			  // Para Texture
-#include "utils.h"				  // Para Color, easeOutQuint, fade_color
+#include "utils.h"				  // Para Color, easeOutQuint, fade_color, Zone
 
 // Constructor
 HiScoreTable::HiScoreTable()
@@ -58,28 +56,17 @@ HiScoreTable::~HiScoreTable()
 // Actualiza las variables
 void HiScoreTable::update()
 {
-	constexpr int TICKS_SPEED = 15;
-
-	if (SDL_GetTicks() - ticks_ > TICKS_SPEED)
+	if (SDL_GetTicks() - ticks_ > param.game.speed)
 	{
 		// Actualiza el contador de ticks
 		ticks_ = SDL_GetTicks();
 
 		// Mantiene la música sonando
-		if ((JA_GetMusicState() == JA_MUSIC_INVALID) || (JA_GetMusicState() == JA_MUSIC_STOPPED))
-		{
-			JA_PlayMusic(Resource::get()->getMusic("title.ogg"));
-		}
+		updateMusic();
 
 		// Actualiza las posiciones de los sprites de texto
 		updateSprites();
 
-		// Actualiza el objeto screen
-		Screen::get()->update();
-
-		// Actualiza las variables de globalInputs
-		globalInputs::update();
-
 		// Actualiza el fondo
 		background_->update();
 
@@ -87,21 +74,16 @@ void HiScoreTable::update()
 		updateFade();
 
 		// Gestiona el contador y sus eventos
-		counter_++;
-
-		if (counter_ == 150)
-		{
-			background_->setColor(background_fade_color_.darken());
-			background_->setAlpha(96);
-		}
-
-		if (counter_ == COUNTER_END_)
-		{
-			fade_->activate();
-		}
+		updateCounter();
 
 		// Dibuja los sprites en la textura
 		fillTexture();
+
+		// Actualiza el objeto screen
+		Screen::get()->update();
+
+		// Actualiza las variables de globalInputs
+		globalInputs::update();
 	}
 }
 
@@ -152,54 +134,19 @@ void HiScoreTable::render()
 	Screen::get()->render();
 }
 
-// Recarga todas las texturas
-void HiScoreTable::reloadTextures()
-{
-}
-
 // Comprueba los eventos
 void HiScoreTable::checkEvents()
 {
-	// Comprueba los eventos que hay en la cola
 	SDL_Event event;
 	while (SDL_PollEvent(&event))
 	{
-		// Evento de salida de la aplicación
-		if (event.type == SDL_QUIT)
-		{
-			section::name = section::Name::QUIT;
-			section::options = section::Options::QUIT_FROM_EVENT;
-			break;
-		}
-
-		// Comprueba si se ha cambiado el tamaño de la ventana
-		else if (event.type == SDL_WINDOWEVENT)
-		{
-			if (event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED)
-			{
-				reloadTextures();
-			}
-		}
-
-		// Comprueba el cursor
-		Mouse::handleEvent(event);
+		globalEvents::check(event);
 	}
 }
 
 // Comprueba las entradas
 void HiScoreTable::checkInput()
 {
-	// Comprueba si se ha pulsado cualquier botón (de los usados para jugar)
-	if (Input::get()->checkAnyButtonPressed())
-	{
-		// JA_StopMusic();
-		section::name = section::Name::TITLE;
-		section::options = section::Options::TITLE_1;
-		section::attract_mode = section::AttractMode::TITLE_TO_DEMO;
-		return;
-	}
-
-	// Comprueba los inputs que se pueden introducir en cualquier sección del juego
 	globalInputs::check();
 }
 
@@ -456,12 +403,38 @@ void HiScoreTable::iniEntryColors()
 // Hace brillar los nombres de la tabla de records
 void HiScoreTable::glowEntryNames()
 {
-    const Color entry_color = getEntryColor(counter_ / 5);
-    for (const auto& entry_index : options.game.last_hi_score_entry)
-    {
-        if (entry_index != -1)
-        {
-            entry_names_.at(entry_index)->getTexture()->setColor(entry_color);
-        }
-    }
+	const Color entry_color = getEntryColor(counter_ / 5);
+	for (const auto &entry_index : options.game.last_hi_score_entry)
+	{
+		if (entry_index != -1)
+		{
+			entry_names_.at(entry_index)->getTexture()->setColor(entry_color);
+		}
+	}
+}
+
+// Gestiona la musica
+void HiScoreTable::updateMusic()
+{
+	if ((JA_GetMusicState() == JA_MUSIC_INVALID) || (JA_GetMusicState() == JA_MUSIC_STOPPED))
+	{
+		JA_PlayMusic(Resource::get()->getMusic("title.ogg"));
+	}
+}
+
+// Gestiona el contador
+void HiScoreTable::updateCounter()
+{
+	counter_++;
+
+	if (counter_ == 150)
+	{
+		background_->setColor(background_fade_color_.darken());
+		background_->setAlpha(96);
+	}
+
+	if (counter_ == COUNTER_END_)
+	{
+		fade_->activate();
+	}
 }

source/hiscore_table.h

@@ -67,9 +67,6 @@ private:
 	// Dibuja los sprites en la textura
 	void fillTexture();
 
-	// Recarga todas las texturas
-	void reloadTextures();
-
 	// Gestiona el fade
 	void updateFade();
 
@@ -94,6 +91,12 @@ private:
 	// Hace brillar los nombres de la tabla de records
 	void glowEntryNames();
 
+	// Gestiona la musica
+	void updateMusic();
+
+	// Gestiona el contador
+	void updateCounter();
+
 public:
 	// Constructor
 	HiScoreTable();

source/input.cpp

@@ -9,22 +9,22 @@
 #include <unordered_map>	   // Para unordered_map, operator==, _Node_cons...
 #include <utility>			   // Para pair
 
-// [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
+// [SINGLETON]
 Input *Input::input_ = nullptr;
 
-// [SINGLETON] Crearemos el objeto input con esta función estática
+// [SINGLETON] Crearemos el objeto con esta función estática
 void Input::init(const std::string &game_controller_db_path)
 {
 	Input::input_ = new Input(game_controller_db_path);
 }
 
-// [SINGLETON] Destruiremos el objeto input con esta función estática
+// [SINGLETON] Destruiremos el objeto con esta función estática
 void Input::destroy()
 {
 	delete Input::input_;
 }
 
-// [SINGLETON] Con este método obtenemos el objeto input y podemos trabajar con él
+// [SINGLETON] Con este método obtenemos el objeto y podemos trabajar con él
 Input *Input::get()
 {
 	return Input::input_;

source/input.h

@@ -38,6 +38,7 @@ enum class InputType : int
 	WINDOW_INC_SIZE,
 	WINDOW_DEC_SIZE,
 	VIDEO_SHADERS,
+	VIDEO_INTEGER_SCALE,
 	RESET,
 	MUTE,
 	CHANGE_LANG,
@@ -64,7 +65,7 @@ enum class InputDeviceToUse : int
 class Input
 {
 private:
-	// [SINGLETON] Objeto screen privado para Don Melitón
+	// [SINGLETON] Objeto privado
 	static Input *input_;
 
 	struct KeyBindings
@@ -109,13 +110,13 @@ private:
 	~Input() = default;
 
 public:
-	// [SINGLETON] Crearemos el objeto screen con esta función estática
+	// [SINGLETON] Crearemos el objeto con esta función estática
 	static void init(const std::string &game_controller_db_path);
 
-	// [SINGLETON] Destruiremos el objeto screen con esta función estática
+	// [SINGLETON] Destruiremos el objeto con esta función estática
 	static void destroy();
 
-	// [SINGLETON] Con este método obtenemos el objeto screen y podemos trabajar con él
+	// [SINGLETON] Con este método obtenemos el objeto y podemos trabajar con él
 	static Input *get();
 
 	// Asigna inputs a teclas

source/instructions.cpp

@@ -1,14 +1,14 @@
 #include "instructions.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_events.h>	// Para SDL_PollEvent, SDL_Event
 #include <SDL2/SDL_pixels.h>	// Para SDL_PIXELFORMAT_RGBA8888
 #include <SDL2/SDL_timer.h>		// Para SDL_GetTicks
-#include <SDL2/SDL_video.h>		// Para SDL_WINDOWEVENT_SIZE_CHANGED
 #include <algorithm>			// Para max
 #include <utility>				// Para move
+#include <vector>				// Para vector
 #include "fade.h"				// Para Fade, FadeMode, FadeType
-#include "global_inputs.h"		// Para check
-#include "input.h"				// Para Input
+#include "global_events.h"		// Para check
+#include "global_inputs.h"		// Para check, update
 #include "jail_audio.h"			// Para JA_GetMusicState, JA_Music_state
 #include "lang.h"				// Para getText
 #include "param.h"				// Para Param, param, ParamGame, ParamFade
@@ -17,14 +17,8 @@
 #include "section.h"			// Para Name, name, Options, options
 #include "sprite.h"				// Para Sprite
 #include "text.h"				// Para Text, TEXT_CENTER, TEXT_COLOR, TEXT_...
-#include "texture.h"			// Para Texture
 #include "tiled_bg.h"			// Para TiledBG, TiledBGMode
 #include "utils.h"				// Para Color, shdw_txt_color, Zone, no_color
-#include "mouse.h"
-
-#include <SDL2/SDL.h>
-#include <vector>
-#include <cmath>
 
 // Constructor
 Instructions::Instructions()
@@ -207,18 +201,13 @@ void Instructions::fillBackbuffer()
 // Actualiza las variables
 void Instructions::update()
 {
-	constexpr int TICKS_SPEED = 15;
-
-	if (SDL_GetTicks() - ticks_ > TICKS_SPEED)
+	if (SDL_GetTicks() - ticks_ > param.game.speed)
 	{
 		// Actualiza el contador de ticks
 		ticks_ = SDL_GetTicks();
 
 		// Mantiene la música sonando
-		if ((JA_GetMusicState() == JA_MUSIC_INVALID) || (JA_GetMusicState() == JA_MUSIC_STOPPED))
-		{
-			JA_PlayMusic(Resource::get()->getMusic("title.ogg"));
-		}
+		updateMusic();
 
 		// Actualiza el objeto screen
 		Screen::get()->update();
@@ -232,24 +221,8 @@ void Instructions::update()
 		// Actualiza los sprites
 		updateSprites();
 
-		// Establece la ventana del backbuffer
-		view_.y = std::max(0, param.game.height - counter_ + 100);
-
-		// Verifica si view_.y == 0 y gestiona el temporizador
-        if (view_.y == 0)
-        {
-            if (!start_delay_triggered_)
-            {
-                // Activa el temporizador si no ha sido activado
-                start_delay_triggered_ = true;
-                start_delay_time_ = SDL_GetTicks();
-            }
-            else if (SDL_GetTicks() - start_delay_time_ >= 4000)
-            {
-                // Han pasado tres segundos, mover líneas
-                all_lines_off_screen_ = moveLines(lines_, 320, 1.0f, 5);
-            }
-        }
+		// Gestiona la textura con los graficos
+		updateBackbuffer();
 
 		// Actualiza el mosaico de fondo
 		tiled_bg_->update();
@@ -259,13 +232,6 @@ void Instructions::update()
 
 		// Rellena el backbuffer
 		fillBackbuffer();
-
-		// Comprueba si el contador ha llegado al final
-		if (all_lines_off_screen_)
-		{
-			section::name = section::Name::TITLE;
-			section::options = section::Options::TITLE_1;
-		}
 	}
 }
 
@@ -293,60 +259,19 @@ void Instructions::render()
 	Screen::get()->render();
 }
 
-// Recarga todas las texturas
-void Instructions::reloadTextures()
-{
-	for (auto &texture : item_textures_)
-	{
-		texture->reLoad();
-	}
-	text_->reLoadTexture();
-	fillTexture();
-}
-
 // Comprueba los eventos
 void Instructions::checkEvents()
 {
-	// Comprueba los eventos que hay en la cola
 	SDL_Event event;
 	while (SDL_PollEvent(&event))
 	{
-		// Evento de salida de la aplicación
-		if (event.type == SDL_QUIT)
-		{
-			section::name = section::Name::QUIT;
-			section::options = section::Options::QUIT_FROM_EVENT;
-			break;
-		}
-
-		// Comprueba si se ha cambiado el tamaño de la ventana
-		else if (event.type == SDL_WINDOWEVENT)
-		{
-			if (event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED)
-			{
-				reloadTextures();
-			}
-		}
-
-		// Comprueba el cursor
-		Mouse::handleEvent(event);
+		globalEvents::check(event);
 	}
 }
 
 // Comprueba las entradas
 void Instructions::checkInput()
 {
-	// Comprueba si se ha pulsado cualquier botón (de los usados para jugar)
-	if (Input::get()->checkAnyButtonPressed())
-	{
-		// JA_StopMusic();
-		section::name = section::Name::TITLE;
-		section::options = section::Options::TITLE_1;
-		section::attract_mode = section::AttractMode::TITLE_TO_DEMO;
-		return;
-	}
-
-	// Comprueba los inputs que se pueden introducir en cualquier sección del juego
 	globalInputs::check();
 }
 
@@ -418,3 +343,42 @@ void Instructions::renderLines(SDL_Renderer *renderer, SDL_Texture *texture, con
 		SDL_RenderCopy(renderer, texture, &srcRect, &dstRect);
 	}
 }
+
+// Gestiona la musica
+void Instructions::updateMusic()
+{
+	if ((JA_GetMusicState() == JA_MUSIC_INVALID) || (JA_GetMusicState() == JA_MUSIC_STOPPED))
+	{
+		JA_PlayMusic(Resource::get()->getMusic("title.ogg"));
+	}
+}
+
+// Gestiona la textura con los graficos
+void Instructions::updateBackbuffer()
+{
+	// Establece la ventana del backbuffer
+	view_.y = std::max(0, param.game.height - counter_ + 100);
+
+	// Verifica si view_.y == 0 y gestiona el temporizador
+	if (view_.y == 0)
+	{
+		if (!start_delay_triggered_)
+		{
+			// Activa el temporizador si no ha sido activado
+			start_delay_triggered_ = true;
+			start_delay_time_ = SDL_GetTicks();
+		}
+		else if (SDL_GetTicks() - start_delay_time_ >= 4000)
+		{
+			// Han pasado tres segundos, mover líneas
+			all_lines_off_screen_ = moveLines(lines_, 320, 1.0f, 5);
+		}
+	}
+
+	// Comprueba si el contador ha llegado al final
+	if (all_lines_off_screen_)
+	{
+		section::name = section::Name::TITLE;
+		section::options = section::Options::TITLE_1;
+	}
+}

source/instructions.h

@@ -87,9 +87,6 @@ private:
 	// Actualiza los sprites
 	void updateSprites();
 
-	// Recarga todas las texturas
-	void reloadTextures();
-
 	// Método para inicializar las líneas
 	std::vector<Line> initializeLines(int height);
 
@@ -99,6 +96,12 @@ private:
 	// Método para renderizar las líneas
 	void renderLines(SDL_Renderer *renderer, SDL_Texture *texture, const std::vector<Line> &lines);
 
+	// Gestiona la musica
+	void updateMusic();
+
+	// Gestiona la textura con los graficos
+	void updateBackbuffer();
+
 public:
 	// Constructor
 	Instructions();

source/intro.cpp

@@ -1,243 +1,117 @@
 #include "intro.h"
-#include <SDL2/SDL_events.h> // Para SDL_PollEvent, SDL_Event, SDL_QUIT, SDL...
-#include <SDL2/SDL_timer.h>	 // Para SDL_GetTicks
-#include <SDL2/SDL_video.h>	 // Para SDL_WINDOWEVENT_SIZE_CHANGED
-#include <utility>			 // Para move
-#include "global_inputs.h"	 // Para check
-#include "input.h"			 // Para Input
-#include "jail_audio.h"		 // Para JA_StopMusic, JA_PlayMusic
-#include "lang.h"			 // Para getText
-#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 "smart_sprite.h"	 // Para SmartSprite
-#include "text.h"			 // Para Text
-#include "texture.h"		 // Para Texture
-#include "utils.h"			 // Para Zone, BLOCK, Color, bg_color
-#include "writer.h"			 // Para Writer
-#include "mouse.h"
+#include <SDL2/SDL_blendmode.h> // Para SDL_BLENDMODE_BLEND, SDL_BLENDMODE_MOD
+#include <SDL2/SDL_events.h>	// Para SDL_PollEvent, SDL_Event
+#include <SDL2/SDL_pixels.h>	// Para SDL_PIXELFORMAT_RGBA8888
+#include <SDL2/SDL_rect.h>		// Para SDL_Rect
+#include <SDL2/SDL_render.h>	// Para SDL_SetTextureBlendMode, SDL_GetRend...
+#include <SDL2/SDL_timer.h>		// Para SDL_GetTicks
+#include <array>				// Para array
+#include <functional>			// Para function
+#include <string>				// Para basic_string, string
+#include <utility>				// Para move
+#include "global_events.h"		// Para check
+#include "global_inputs.h"		// Para check, update
+#include "jail_audio.h"			// Para JA_PlayMusic, JA_StopMusic
+#include "lang.h"				// Para getText
+#include "param.h"				// Para Param, ParamGame, param
+#include "path_sprite.h"		// Para PathSprite, PathType
+#include "resource.h"			// Para Resource
+#include "screen.h"				// Para Screen
+#include "section.h"			// Para Name, name, Options, options
+#include "texture.h"			// Para Texture
+#include "tiled_bg.h"			// Para TiledBG, TiledBGMode
+#include "utils.h"				// Para Color, Zone, easeOutQuint, BLOCK
+#include "writer.h"				// Para Writer
 
 // Constructor
 Intro::Intro()
-	: texture_(Resource::get()->getTexture("intro.png")),
-	  text_(Resource::get()->getText("04b_25_metal"))
+	: tiled_bg_(std::make_unique<TiledBG>(param.game.game_area.rect, TiledBGMode::DIAGONAL))
 {
-
 	// Inicializa variables
 	section::name = section::Name::INTRO;
 	section::options = section::Options::NONE;
 
-	// Inicializa los bitmaps de la intro
-	constexpr int totalBitmaps = 6;
-	for (int i = 0; i < totalBitmaps; ++i)
-	{
-		auto ss = std::make_unique<SmartSprite>(texture_);
-		ss->setWidth(128);
-		ss->setHeight(96);
-		ss->setFinishedCounter(20);
-		ss->setDestX(param.game.game_area.center_x - 64);
-		ss->setDestY(param.game.game_area.first_quarter_y - 24);
-		bitmaps_.push_back(std::move(ss));
-	}
+	// Inicializa las imagens
+	initSprites();
 
-	bitmaps_[0]->setPosX(-128);
-	bitmaps_[0]->setPosY(param.game.game_area.first_quarter_y - 24);
-	bitmaps_[0]->setVelX(0.0f);
-	bitmaps_[0]->setVelY(0.0f);
-	bitmaps_[0]->setAccelX(0.6f);
-	bitmaps_[0]->setAccelY(0.0f);
-	bitmaps_[0]->setSpriteClip(0, 0, 128, 96);
+	// Inicializa los textos
+	initTexts();
 
-	bitmaps_[1]->setPosX(param.game.width);
-	bitmaps_[1]->setPosY(param.game.game_area.first_quarter_y - 24);
-	bitmaps_[1]->setVelX(-1.0f);
-	bitmaps_[1]->setVelY(0.0f);
-	bitmaps_[1]->setAccelX(-0.3f);
-	bitmaps_[1]->setAccelY(0.0f);
-	bitmaps_[1]->setSpriteClip(128, 0, 128, 96);
-
-	bitmaps_[2]->setPosX(param.game.game_area.center_x - 64);
-	bitmaps_[2]->setPosY(-96);
-	bitmaps_[2]->setVelX(0.0f);
-	bitmaps_[2]->setVelY(3.0f);
-	bitmaps_[2]->setAccelX(0.1f);
-	bitmaps_[2]->setAccelY(0.3f);
-	bitmaps_[2]->setSpriteClip(0, 96, 128, 96);
-	bitmaps_[2]->setFinishedCounter(250);
-
-	bitmaps_[3]->setPosX(param.game.game_area.center_x - 64);
-	bitmaps_[3]->setPosY(param.game.height);
-	bitmaps_[3]->setVelX(0.0f);
-	bitmaps_[3]->setVelY(-0.7f);
-	bitmaps_[3]->setAccelX(0.0f);
-	bitmaps_[3]->setAccelY(0.0f);
-	bitmaps_[3]->setSpriteClip(128, 96, 128, 96);
-
-	bitmaps_[4]->setPosX(param.game.game_area.center_x - 64);
-	bitmaps_[4]->setPosY(-96);
-	bitmaps_[4]->setVelX(0.0f);
-	bitmaps_[4]->setVelY(3.0f);
-	bitmaps_[4]->setAccelX(0.1f);
-	bitmaps_[4]->setAccelY(0.3f);
-	bitmaps_[4]->setSpriteClip(0, 192, 128, 96);
-
-	bitmaps_[5]->setPosX(param.game.width);
-	bitmaps_[5]->setPosY(param.game.game_area.first_quarter_y - 24);
-	bitmaps_[5]->setVelX(-0.7f);
-	bitmaps_[5]->setVelY(0.0f);
-	bitmaps_[5]->setAccelX(0.0f);
-	bitmaps_[5]->setAccelY(0.0f);
-	bitmaps_[5]->setSpriteClip(128, 192, 128, 96);
-
-	// Inicializa los textos de la intro
-	constexpr int totalTexts = 9;
-	for (int i = 0; i < totalTexts; ++i)
-	{
-		auto w = std::make_unique<Writer>(text_);
-		w->setPosX(BLOCK * 0);
-		w->setPosY(param.game.height - (BLOCK * 6));
-		w->setKerning(-2);
-		w->setEnabled(false);
-		w->setFinishedCounter(180);
-		texts_.push_back(std::move(w));
-	}
-
-	// Un dia qualsevol de l'any 2000
-	texts_[0]->setCaption(lang::getText(27));
-	texts_[0]->setSpeed(8);
-
-	// Tot esta tranquil a la UPV
-	texts_[1]->setCaption(lang::getText(28));
-	texts_[1]->setSpeed(8);
-
-	// Fins que un desaprensiu...
-	texts_[2]->setCaption(lang::getText(29));
-	texts_[2]->setSpeed(12);
-
-	// HEY! ME ANE A FERME UN CORTAET...
-	texts_[3]->setCaption(lang::getText(30));
-	texts_[3]->setSpeed(8);
-
-	// UAAAAAAAAAAAAA!!!
-	texts_[4]->setCaption(lang::getText(31));
-	texts_[4]->setSpeed(1);
-
-	// Espera un moment...
-	texts_[5]->setCaption(lang::getText(32));
-	texts_[5]->setSpeed(16);
-
-	// Si resulta que no tinc solt!
-	texts_[6]->setCaption(lang::getText(33));
-	texts_[6]->setSpeed(2);
-
-	// MERDA DE MAQUINA!
-	texts_[7]->setCaption(lang::getText(34));
-	texts_[7]->setSpeed(3);
-
-	// Blop... blop... blop...
-	texts_[8]->setCaption(lang::getText(35));
-	texts_[8]->setSpeed(16);
-
-	for (auto &text : texts_)
-		text->center(param.game.game_area.center_x);
-}
-
-// Recarga todas las texturas
-void Intro::reloadTextures()
-{
-	texture_->reLoad();
-	text_->reLoadTexture();
+	// Configura el fondo
+	tiled_bg_->setSpeed(0.3f);
+	tiled_bg_->setColor(Color(bg_color_, bg_color_, bg_color_));
 }
 
 // Comprueba los eventos
 void Intro::checkEvents()
 {
 	SDL_Event event;
-
-	// Comprueba los eventos que hay en la cola
 	while (SDL_PollEvent(&event))
 	{
-		switch (event.type)
-		{
-		case SDL_QUIT:
-		{
-			section::name = section::Name::QUIT;
-			section::options = section::Options::QUIT_FROM_EVENT;
-			break;
-		}
-
-		case SDL_WINDOWEVENT:
-		{
-			if (event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED)
-			{
-				reloadTextures();
-			}
-			break;
-		}
-
-		default:
-			break;
-		}
-
-		// Comprueba el cursor
-		Mouse::handleEvent(event);
+		globalEvents::check(event);
 	}
 }
 
 // Comprueba las entradas
-void Intro::checkInput()
-{
-	// Comprueba si se ha pulsado cualquier botón (de los usados para jugar)
-	if (Input::get()->checkAnyButtonPressed())
-	{
-		JA_StopMusic();
-		section::name = section::Name::TITLE;
-		section::options = section::Options::TITLE_1;
-		return;
-	}
-
-	// Comprueba los inputs que se pueden introducir en cualquier sección del juego
-	globalInputs::check();
-}
+void Intro::checkInput() { globalInputs::check(); }
 
 // Actualiza las escenas de la intro
 void Intro::updateScenes()
 {
 	switch (scene_)
 	{
-	case 1:
-	{ // Primera imagen - UPV
-		if (!bitmaps_[0]->hasFinished())
-		{
-			bitmaps_[0]->setEnabled(true);
-		}
+	case 0:
+	{
+		// Primera imagen - UPV
+		sprites_.at(0)->enable();
+		shadow_sprites_.at(0)->enable();
 
 		// Primer texto de la primera imagen
-		if (bitmaps_[0]->hasFinished() && !texts_[0]->hasFinished())
+		if (sprites_.at(0)->hasFinished() && !texts_.at(0)->hasFinished())
 		{
-			texts_[0]->setEnabled(true);
+			texts_.at(0)->setEnabled(true);
 		}
 
 		// Segundo texto de la primera imagen
-		if (texts_[0]->hasFinished() && !texts_[1]->hasFinished())
+		if (texts_.at(0)->hasFinished() && !texts_.at(1)->hasFinished())
 		{
-			texts_[0]->setEnabled(false);
-			texts_[1]->setEnabled(true);
+			texts_.at(0)->setEnabled(false);
+			texts_.at(1)->setEnabled(true);
 		}
 
 		// Tercer texto de la primera imagen
-		if (texts_[1]->hasFinished() && !texts_[2]->hasFinished())
+		if (texts_.at(1)->hasFinished() && !texts_.at(2)->hasFinished())
 		{
-			texts_[1]->setEnabled(false);
-			texts_[2]->setEnabled(true);
+			texts_.at(1)->setEnabled(false);
+			texts_.at(2)->setEnabled(true);
 		}
 
 		// Fin de la primera escena
-		if (texts_[2]->hasFinished())
+		if (texts_.at(2)->hasFinished())
 		{
-			bitmaps_[0]->setEnabled(false);
-			texts_[2]->setEnabled(false);
+			texts_.at(2)->setEnabled(false);
+			scene_++;
+		}
+
+		break;
+	}
+
+	case 1:
+	{
+		// Segunda imagen - Máquina
+		sprites_.at(1)->enable();
+		shadow_sprites_.at(1)->enable();
+
+		// Primer texto de la segunda imagen
+		if (sprites_.at(1)->hasFinished() && !texts_.at(3)->hasFinished())
+		{
+			texts_.at(3)->setEnabled(true);
+		}
+
+		// Fin de la segunda escena
+		if (texts_.at(3)->hasFinished())
+		{
+			texts_.at(3)->setEnabled(false);
 			scene_++;
 		}
 
@@ -245,41 +119,48 @@ void Intro::updateScenes()
 	}
 
 	case 2:
-	{ // Segunda imagen - Máquina
-		if (!bitmaps_[1]->hasFinished())
+	{
+		// Tercera imagen junto con primer texto - GRITO
+		if (!texts_.at(4)->hasFinished())
 		{
-			bitmaps_[1]->setEnabled(true);
+			sprites_.at(2)->enable();
+			shadow_sprites_.at(2)->enable();
+
+			texts_.at(4)->setEnabled(true);
 		}
 
-		// Primer texto de la segunda imagen
-		if (bitmaps_[1]->hasFinished() && !texts_[3]->hasFinished())
+		// Fin de la tercera escena
+		if (sprites_.at(2)->hasFinished() && texts_.at(4)->hasFinished())
 		{
-			texts_[3]->setEnabled(true);
-		}
-
-		// Fin de la segunda escena
-		if (texts_[3]->hasFinished())
-		{
-			bitmaps_[1]->setEnabled(false);
-			texts_[3]->setEnabled(false);
+			texts_.at(4)->setEnabled(false);
 			scene_++;
 		}
 
 		break;
 	}
+
 	case 3:
-	{ // Tercera imagen junto con primer texto - GRITO
-		if (!bitmaps_[2]->hasFinished() && !texts_[4]->hasFinished())
+	{
+		// Cuarta imagen junto con primer texto - Reflexión
+		sprites_.at(3)->enable();
+		shadow_sprites_.at(3)->enable();
+
+		if (!texts_.at(5)->hasFinished())
 		{
-			bitmaps_[2]->setEnabled(true);
-			texts_[4]->setEnabled(true);
+			texts_.at(5)->setEnabled(true);
 		}
 
-		// Fin de la tercera escena
-		if (bitmaps_[2]->hasFinished() && texts_[4]->hasFinished())
+		// Segundo texto de la cuarta imagen
+		if (texts_.at(5)->hasFinished() && !texts_.at(6)->hasFinished())
 		{
-			bitmaps_[2]->setEnabled(false);
-			texts_[4]->setEnabled(false);
+			texts_.at(5)->setEnabled(false);
+			texts_.at(6)->setEnabled(true);
+		}
+
+		// Fin de la cuarta escena
+		if (sprites_.at(3)->hasFinished() && texts_.at(6)->hasFinished())
+		{
+			texts_.at(6)->setEnabled(false);
 			scene_++;
 		}
 
@@ -287,25 +168,21 @@ void Intro::updateScenes()
 	}
 
 	case 4:
-	{ // Cuarta imagen junto con primer texto - Reflexión
-		if (!bitmaps_[3]->hasFinished() && !texts_[5]->hasFinished())
+	{
+		// Quinta imagen - Patada
+		sprites_.at(4)->enable();
+		shadow_sprites_.at(4)->enable();
+
+		// Primer texto de la quinta imagen
+		if (!texts_.at(7)->hasFinished())
 		{
-			bitmaps_[3]->setEnabled(true);
-			texts_[5]->setEnabled(true);
+			texts_.at(7)->setEnabled(true);
 		}
 
-		// Segundo texto de la cuarta imagen
-		if (texts_[5]->hasFinished() && !texts_[6]->hasFinished())
+		// Fin de la quinta escena
+		if (sprites_.at(4)->hasFinished() && texts_.at(7)->hasFinished())
 		{
-			texts_[5]->setEnabled(false);
-			texts_[6]->setEnabled(true);
-		}
-
-		// Fin de la cuarta escena
-		if (bitmaps_[3]->hasFinished() && texts_[6]->hasFinished())
-		{
-			bitmaps_[3]->setEnabled(false);
-			texts_[6]->setEnabled(false);
+			texts_.at(7)->setEnabled(false);
 			scene_++;
 		}
 
@@ -313,45 +190,27 @@ void Intro::updateScenes()
 	}
 
 	case 5:
-	{ // Quinta imagen - Patada
-		if (!bitmaps_[4]->hasFinished())
-		{
-			bitmaps_[4]->setEnabled(true);
-		}
+	{
+		// Sexta imagen junto con texto - Globos de café
+		sprites_.at(5)->enable();
+		shadow_sprites_.at(5)->enable();
 
-		// Primer texto de la quinta imagen
-		if (bitmaps_[4]->hasFinished() && !texts_[7]->hasFinished())
+		if (!texts_.at(8)->hasFinished())
 		{
-			texts_[7]->setEnabled(true);
-		}
-
-		// Fin de la quinta escena
-		if (bitmaps_[4]->hasFinished() && texts_[7]->hasFinished())
-		{
-			bitmaps_[4]->setEnabled(false);
-			texts_[7]->setEnabled(false);
-			scene_++;
-		}
-
-		break;
-	}
-
-	case 6:
-	{ // Sexta imagen junto con texto - Globos de café
-		if (!bitmaps_[5]->hasFinished() && !texts_[8]->hasFinished())
-		{
-			bitmaps_[5]->setEnabled(true);
-			texts_[8]->setEnabled(true);
+			texts_.at(8)->setEnabled(true);
 		}
 
 		// Acaba el último texto
-		if (bitmaps_[5]->hasFinished() && texts_[8]->hasFinished())
+		if (texts_.at(8)->hasFinished())
 		{
-			bitmaps_[5]->setEnabled(false);
-			texts_[8]->setEnabled(false);
-			JA_StopMusic();
-			section::name = section::Name::TITLE;
-			section::options = section::Options::TITLE_1;
+			texts_.at(8)->setEnabled(false);
+		}
+
+		// Acaba la ultima imagen
+		if (sprites_.at(5)->hasFinished() && texts_.at(8)->hasFinished())
+		{
+			state_ = IntroState::POST;
+			state_start_time_ = SDL_GetTicks();
 		}
 
 		break;
@@ -365,30 +224,30 @@ void Intro::updateScenes()
 // Actualiza las variables del objeto
 void Intro::update()
 {
-	constexpr int TICKS_SPEED = 15;
-
-	if (SDL_GetTicks() - ticks_ > TICKS_SPEED)
+	if (SDL_GetTicks() - ticks_ > param.game.speed)
 	{
 		// Actualiza el contador de ticks
 		ticks_ = SDL_GetTicks();
 
+		// Actualiza el fondo
+		tiled_bg_->update();
+
+		switch (state_)
+		{
+		case IntroState::SCENES:
+			updateSprites();
+			updateTexts();
+			updateScenes();
+			break;
+
+		case IntroState::POST:
+			updatePostState();
+			break;
+		}
+
 		// Actualiza el objeto screen
 		Screen::get()->update();
 
-		// Actualiza los objetos
-		for (auto &bitmap : bitmaps_)
-		{
-			bitmap->update();
-		}
-
-		for (auto &text : texts_)
-		{
-			text->update();
-		}
-
-		// Actualiza las escenas de la intro
-		updateScenes();
-
 		// Actualiza las variables de globalInputs
 		globalInputs::update();
 	}
@@ -403,15 +262,19 @@ void Intro::render()
 	// Limpia la pantalla
 	Screen::get()->clean(bg_color);
 
-	// Dibuja los objetos
-	for (const auto &bitmap : bitmaps_)
-	{
-		bitmap->render();
-	}
+	// Dibuja el fondo
+	tiled_bg_->render();
 
-	for (const auto &text : texts_)
+	switch (state_)
 	{
-		text->render();
+	case IntroState::SCENES:
+	{
+		renderSprites();
+		renderTexts();
+		break;
+	}
+	case IntroState::POST:
+		break;
 	}
 
 	// Vuelca el contenido del renderizador en pantalla
@@ -430,3 +293,236 @@ void Intro::run()
 		render();
 	}
 }
+
+// Inicializa las imagens
+void Intro::initSprites()
+{
+	// Listado de imagenes a usar
+	const std::array<std::string, 6> TEXTURE_LIST = {
+		"intro1.png",
+		"intro2.png",
+		"intro3.png",
+		"intro4.png",
+		"intro5.png",
+		"intro6.png"};
+
+	// Constantes
+	auto texture = Resource::get()->getTexture(TEXTURE_LIST.front());
+	const int SPRITE_WIDTH = texture->getWidth();
+	const int SPRITE_HEIGHT = texture->getHeight();
+	const int X_DEST = param.game.game_area.center_x - SPRITE_WIDTH / 2;
+	const int Y_DEST = param.game.game_area.first_quarter_y - (SPRITE_HEIGHT / 4);
+
+	// Inicializa los sprites de la intro
+	constexpr int TOTAL_SPRITES = 6;
+	for (int i = 0; i < TOTAL_SPRITES; ++i)
+	{
+		auto sprite = std::make_unique<PathSprite>(Resource::get()->getTexture(TEXTURE_LIST.at(i)));
+		sprite->setWidth(SPRITE_WIDTH);
+		sprite->setHeight(SPRITE_HEIGHT);
+		sprite->setSpriteClip(0, 0, SPRITE_WIDTH, SPRITE_HEIGHT);
+		sprites_.push_back(std::move(sprite));
+	}
+
+	sprites_.at(0)->addPath(-SPRITE_WIDTH - 10, X_DEST, PathType::HORIZONTAL, Y_DEST, 100, easeInOutExpo, 0);
+	sprites_.at(1)->addPath(param.game.width, X_DEST, PathType::HORIZONTAL, Y_DEST, 100, easeOutBounce, 0);
+	sprites_.at(2)->addPath(-SPRITE_HEIGHT, Y_DEST, PathType::VERTICAL, X_DEST, 40, easeOutQuint, 0);
+	sprites_.at(3)->addPath(param.game.height, Y_DEST, PathType::VERTICAL, X_DEST, 600, easeOutQuint, 0);
+	sprites_.at(4)->addPath(-SPRITE_HEIGHT, Y_DEST, PathType::VERTICAL, X_DEST, 70, easeOutElastic, 0);
+	sprites_.at(5)->addPath(param.game.width, X_DEST, PathType::HORIZONTAL, Y_DEST, 400, easeOutQuad, 300);
+	sprites_.at(5)->addPath(X_DEST, -SPRITE_WIDTH, PathType::HORIZONTAL, Y_DEST, 80, easeInElastic, 0);
+
+	// Constantes
+	const int BORDER = 4;
+	const int SHADOW_SPRITE_WIDTH = SPRITE_WIDTH + BORDER;
+	const int SHADOW_SPRITE_HEIGHT = SPRITE_HEIGHT + BORDER;
+	const int S_X_DEST = X_DEST - BORDER / 2;
+	const int S_Y_DEST = Y_DEST - BORDER / 2;
+
+	// Crea las texturas para las sombras
+	std::vector<std::shared_ptr<Texture>> shadow_textures;
+
+	for (int i = 0; i < TOTAL_SPRITES; ++i)
+	{
+		auto shadow_texture = std::make_shared<Texture>(Screen::get()->getRenderer());
+		shadow_texture->createBlank(SHADOW_SPRITE_WIDTH, SHADOW_SPRITE_HEIGHT, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET);
+		shadow_texture->setBlendMode(SDL_BLENDMODE_BLEND);
+
+		auto temp = SDL_GetRenderTarget(Screen::get()->getRenderer());
+		shadow_texture->setAsRenderTarget(Screen::get()->getRenderer());
+
+		SDL_SetRenderDrawColor(Screen::get()->getRenderer(), 0xFF, 0x00, 0x00, 0xFF);
+		SDL_RenderClear(Screen::get()->getRenderer());
+
+		SDL_Rect rect = {BORDER / 2, BORDER / 2, SPRITE_WIDTH, SPRITE_HEIGHT};
+		auto inner_texture = Resource::get()->getTexture(TEXTURE_LIST.at(i))->getSDLTexture();
+		SDL_SetTextureBlendMode(inner_texture, SDL_BLENDMODE_MOD);
+		SDL_RenderCopy(Screen::get()->getRenderer(), inner_texture, nullptr, &rect);
+		SDL_SetTextureBlendMode(inner_texture, SDL_BLENDMODE_NONE);
+
+		SDL_SetRenderTarget(Screen::get()->getRenderer(), temp);
+		shadow_textures.push_back(shadow_texture);
+	}
+
+	// Inicializa los sprites para la sombra
+	for (int i = 0; i < TOTAL_SPRITES; ++i)
+	{
+		auto sprite = std::make_unique<PathSprite>(shadow_textures.at(i));
+		sprite->setWidth(SHADOW_SPRITE_WIDTH);
+		sprite->setHeight(SHADOW_SPRITE_HEIGHT);
+		sprite->setSpriteClip(0, 0, SHADOW_SPRITE_WIDTH, SHADOW_SPRITE_HEIGHT);
+		shadow_sprites_.push_back(std::move(sprite));
+	}
+
+	shadow_sprites_.at(0)->addPath(param.game.height + 10, S_Y_DEST, PathType::VERTICAL, S_X_DEST, 100, easeInOutExpo, 0);
+	shadow_sprites_.at(1)->addPath(-SHADOW_SPRITE_HEIGHT, S_Y_DEST, PathType::VERTICAL, S_X_DEST, 100, easeOutBounce, 0);
+	shadow_sprites_.at(2)->addPath(-SHADOW_SPRITE_WIDTH, S_X_DEST, PathType::HORIZONTAL, S_Y_DEST, 40, easeOutQuint, 0);
+	shadow_sprites_.at(3)->addPath(param.game.width, S_X_DEST, PathType::HORIZONTAL, S_Y_DEST, 600, easeOutQuint, 0);
+	shadow_sprites_.at(4)->addPath(param.game.height, S_Y_DEST, PathType::VERTICAL, S_X_DEST, 70, easeOutElastic, 0);
+	shadow_sprites_.at(5)->addPath(-SHADOW_SPRITE_HEIGHT, S_Y_DEST, PathType::VERTICAL, S_X_DEST, 400, easeOutQuad, 300);
+	shadow_sprites_.at(5)->addPath(S_X_DEST, param.game.width, PathType::HORIZONTAL, S_Y_DEST, 80, easeInElastic, 0);
+}
+
+// Inicializa los textos
+void Intro::initTexts()
+{
+	constexpr int TOTAL_TEXTS = 9;
+	for (int i = 0; i < TOTAL_TEXTS; ++i)
+	{
+		auto w = std::make_unique<Writer>(Resource::get()->getText("04b_25_metal"));
+		w->setPosX(BLOCK * 0);
+		w->setPosY(param.game.height - (BLOCK * 6));
+		w->setKerning(-2);
+		w->setEnabled(false);
+		w->setFinishedCounter(180);
+		texts_.push_back(std::move(w));
+	}
+
+	// Un dia qualsevol de l'any 2000
+	texts_.at(0)->setCaption(lang::getText(27));
+	texts_.at(0)->setSpeed(8);
+
+	// Tot esta tranquil a la UPV
+	texts_.at(1)->setCaption(lang::getText(28));
+	texts_.at(1)->setSpeed(8);
+
+	// Fins que un desaprensiu...
+	texts_.at(2)->setCaption(lang::getText(29));
+	texts_.at(2)->setSpeed(12);
+
+	// HEY! ME ANE A FERME UN CORTAET...
+	texts_.at(3)->setCaption(lang::getText(30));
+	texts_.at(3)->setSpeed(8);
+
+	// UAAAAAAAAAAAAA!!!
+	texts_.at(4)->setCaption(lang::getText(31));
+	texts_.at(4)->setSpeed(1);
+
+	// Espera un moment...
+	texts_.at(5)->setCaption(lang::getText(32));
+	texts_.at(5)->setSpeed(16);
+
+	// Si resulta que no tinc solt!
+	texts_.at(6)->setCaption(lang::getText(33));
+	texts_.at(6)->setSpeed(2);
+
+	// MERDA DE MAQUINA!
+	texts_.at(7)->setCaption(lang::getText(34));
+	texts_.at(7)->setSpeed(3);
+
+	// Blop... blop... blop...
+	texts_.at(8)->setCaption(lang::getText(35));
+	texts_.at(8)->setSpeed(16);
+
+	for (auto &text : texts_)
+	{
+		text->center(param.game.game_area.center_x);
+	}
+}
+
+// Actualiza los sprites
+void Intro::updateSprites()
+{
+	for (auto &sprite : sprites_)
+	{
+		sprite->update();
+	}
+
+	for (auto &sprite : shadow_sprites_)
+	{
+		sprite->update();
+	}
+}
+
+// Actualiza los textos
+void Intro::updateTexts()
+{
+	for (auto &text : texts_)
+	{
+		text->update();
+	}
+}
+
+// Dibuja los sprites
+void Intro::renderSprites()
+{
+	shadow_sprites_.at(scene_)->render();
+	sprites_.at(scene_)->render();
+}
+
+// Dibuja los textos
+void Intro::renderTexts()
+{
+	for (const auto &text : texts_)
+	{
+		text->render();
+	}
+}
+
+// Actualiza el estado POST
+void Intro::updatePostState()
+{
+	const Uint32 ELAPSED_TIME = SDL_GetTicks() - state_start_time_;
+
+	switch (post_state_)
+	{
+	case IntroPostState::STOP_BG:
+		// EVENTO: Detiene el fondo después de 2 segundos
+		if (ELAPSED_TIME >= 1000)
+		{
+			tiled_bg_->stopGracefully();
+
+			// Modifica el color del fondo hasta llegar a blanco
+			if (bg_color_ <= 253) // Garantiza que no se exceda de 255 al incrementar de 2 en 2
+			{
+				bg_color_ += 2;
+			}
+			else
+			{
+				bg_color_ = 255; // Asegura que bg_color_ no exceda el límite máximo
+			}
+			tiled_bg_->setColor(Color(bg_color_, bg_color_, bg_color_));
+		}
+
+		// Cambia de estado si el fondo se ha detenido y recuperado el color
+		if (tiled_bg_->isStopped() && bg_color_ == 255)
+		{
+			post_state_ = IntroPostState::END;
+			state_start_time_ = SDL_GetTicks();
+		}
+		break;
+
+	case IntroPostState::END:
+		// Finaliza la intro después de 2 segundos
+		if (ELAPSED_TIME >= 2000)
+		{
+			JA_StopMusic();
+			section::name = section::Name::TITLE;
+			section::options = section::Options::TITLE_1;
+		}
+		break;
+
+	default:
+		break;
+	}
+}

source/intro.h

@@ -1,12 +1,11 @@
 #pragma once
 
-#include <SDL2/SDL_stdinc.h> // Para Uint32
-#include <memory>			 // Para unique_ptr, shared_ptr
+#include <SDL2/SDL_stdinc.h> // Para Uint32, Uint8
+#include <memory>			 // Para unique_ptr
 #include <vector>			 // Para vector
-#include "smart_sprite.h"	 // Para SmartSprite
+#include "path_sprite.h"	 // Para PathSprite
+#include "tiled_bg.h"		 // Para TiledBG
 #include "writer.h"			 // Para Writer
-class Text;					 // lines 8-8
-class Texture;				 // lines 9-9
 
 /*
 	Esta clase gestiona un estado del programa. Se encarga de mostrar la secuencia
@@ -17,16 +16,31 @@ class Texture;				 // lines 9-9
 class Intro
 {
 private:
-	// Objetos
-	std::shared_ptr<Texture> texture_; // Textura con los graficos
-	std::shared_ptr<Text> text_;	   // Textos de la intro
+	enum class IntroState
+	{
+		SCENES,
+		POST,
+	};
 
-	std::vector<std::unique_ptr<SmartSprite>> bitmaps_; // Vector con los sprites inteligentes para los dibujos de la intro
-	std::vector<std::unique_ptr<Writer>> texts_;		// Textos de la intro
+	enum class IntroPostState
+	{
+		STOP_BG,
+		END,
+	};
+
+	// Objetos
+	std::vector<std::unique_ptr<PathSprite>> sprites_;		  // Vector con los sprites inteligentes para los dibujos de la intro
+	std::vector<std::unique_ptr<PathSprite>> shadow_sprites_; // Vector con los sprites inteligentes para las sombras
+	std::vector<std::unique_ptr<Writer>> texts_;			  // Textos de la intro
+	std::unique_ptr<TiledBG> tiled_bg_;
 
 	// Variables
-	Uint32 ticks_ = 0; // Contador de ticks para ajustar la velocidad del programa
-	int scene_ = 1;	   // Indica que escena está activa
+	Uint32 ticks_ = 0;									  // Contador de ticks para ajustar la velocidad del programa
+	int scene_ = 0;										  // Indica que escena está activa
+	IntroState state_ = IntroState::SCENES;				  // Estado
+	IntroPostState post_state_ = IntroPostState::STOP_BG; // Estado
+	Uint32 state_start_time_;
+	Uint8 bg_color_ = 112;
 
 	// Actualiza las variables del objeto
 	void update();
@@ -43,8 +57,26 @@ private:
 	// Actualiza las escenas de la intro
 	void updateScenes();
 
-	// Recarga todas las texturas
-	void reloadTextures();
+	// Inicializa las imagens
+	void initSprites();
+
+	// Inicializa los textos
+	void initTexts();
+
+	// Actualiza los sprites
+	void updateSprites();
+
+	// Actualiza los textos
+	void updateTexts();
+
+	// Dibuja los sprites
+	void renderSprites();
+
+	// Dibuja los textos
+	void renderTexts();
+
+	// Actualiza el estado POST
+	void updatePostState();
 
 public:
 	// Constructor

source/jail_shader.cpp

@@ -1,5 +1,3 @@
-#ifndef NO_SHADERS
-
 #include "jail_shader.h"
 #include <SDL2/SDL_rect.h> // para SDL_Point
 #include <stdlib.h>        // para NULL, free, malloc, exit
@@ -248,4 +246,3 @@ namespace shader
         }
     }
 }
-#endif

source/jail_shader.h

@@ -1,5 +1,3 @@
-#ifndef NO_SHADERS
-
 #pragma once
 
 #include <SDL2/SDL_render.h> // para SDL_Texture
@@ -45,4 +43,3 @@ namespace shader
 
     void render();
 }
-#endif

source/lang.cpp

@@ -41,10 +41,10 @@ namespace lang
         return texts.at(index);
     }
 
-    // Cambia el idioma seleccionado al siguiente idioma disponible
-    Code change(Code current_lang)
+    // Obtiene el codigo del idioma del siguiente idioma
+    Code getNextLangCode(Code lang)
     {
-        auto index = static_cast<int>(current_lang);
+        auto index = static_cast<int>(lang);
         index = (index + 1) % 3;
         return static_cast<Code>(index);
     }

source/lang.h

@@ -17,6 +17,6 @@ namespace lang
     // Obtiene la cadena de texto del indice
     std::string getText(int index);
 
-    // Cambia el idioma seleccionado al siguiente idioma disponible
-    Code change(Code current_lang);
+    // Obtiene el codigo del idioma del siguiente idioma
+    Code getNextLangCode(Code lang);
 }

source/logo.cpp

@@ -1,45 +1,41 @@
 #include "logo.h"
-#include <SDL2/SDL_events.h> // Para SDL_PollEvent, SDL_Event, SDL_QUIT, SDL...
+#include <SDL2/SDL_events.h> // Para SDL_PollEvent, SDL_Event
 #include <SDL2/SDL_timer.h>	 // Para SDL_GetTicks
-#include <SDL2/SDL_video.h>	 // Para SDL_WINDOWEVENT_SIZE_CHANGED
 #include <utility>			 // Para move
-#include "global_inputs.h"	 // Para check
-#include "input.h"			 // Para Input
-#include "jail_audio.h"		 // Para JA_StopMusic
+#include "global_events.h"	 // Para check
+#include "global_inputs.h"	 // Para check, update
+#include "jail_audio.h"		 // Para JA_FadeOutMusic, JA_PlaySound, JA_StopC...
 #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 "section.h"		 // Para Name, name
 #include "sprite.h"			 // Para Sprite
 #include "texture.h"		 // Para Texture
 #include "utils.h"			 // Para Color, Zone
-#include "mouse.h"
 
 // Constructor
 Logo::Logo()
 	: since_texture_(Resource::get()->getTexture("logo_since_1998.png")),
 	  since_sprite_(std::make_unique<Sprite>(since_texture_)),
-	  jail_texture_(Resource::get()->getTexture("logo_jailgames.png")),
-	  ticks_(0)
+	  jail_texture_(Resource::get()->getTexture("logo_jailgames.png"))
 {
 
 	// Inicializa variables
-	counter_ = 0;
 	section::name = section::Name::LOGO;
 	dest_.x = param.game.game_area.center_x - jail_texture_->getWidth() / 2;
 	dest_.y = param.game.game_area.center_y - jail_texture_->getHeight() / 2;
 	since_sprite_->setPosition({(param.game.width - since_texture_->getWidth()) / 2, 83 + jail_texture_->getHeight() + 5, since_texture_->getWidth(), since_texture_->getHeight()});
 	since_sprite_->setY(dest_.y + jail_texture_->getHeight() + 5);
 	since_sprite_->setSpriteClip(0, 0, since_texture_->getWidth(), since_texture_->getHeight());
-	since_texture_->setColor(0x00, 0x00, 0x00); // Esto en linux no hace nada ??
+	since_texture_->setColor(0x00, 0x00, 0x00);
 
 	// Crea los sprites de cada linea
 	for (int i = 0; i < jail_texture_->getHeight(); ++i)
 	{
 		auto temp = std::make_unique<Sprite>(jail_texture_, 0, i, jail_texture_->getWidth(), 1);
 		temp->setSpriteClip(0, i, jail_texture_->getWidth(), 1);
-		const int posX = (i % 2 == 0) ? param.game.width + (i * 3) : -jail_texture_->getWidth() - (i * 3);
-		temp->setX(posX);
+		const int POS_X = (i % 2 == 0) ? param.game.width + (i * 3) : -jail_texture_->getWidth() - (i * 3);
+		temp->setX(POS_X);
 		temp->setY(dest_.y + i);
 		jail_sprite_.push_back(std::move(temp));
 	}
@@ -63,58 +59,23 @@ Logo::~Logo()
 	JA_StopChannel(-1);
 }
 
-// Recarga todas las texturas
-void Logo::reloadTextures()
-{
-	jail_texture_->reLoad();
-	since_texture_->reLoad();
-}
-
 // Comprueba el manejador de eventos
 void Logo::checkEvents()
 {
 	SDL_Event event;
-	// Comprueba los eventos que hay en la cola
 	while (SDL_PollEvent(&event))
 	{
-		// Evento de salida de la aplicación
-		if (event.type == SDL_QUIT)
-		{
-			section::name = section::Name::QUIT;
-			section::options = section::Options::QUIT_FROM_EVENT;
-			break;
-		}
-
-		// Comprueba si se ha cambiado el tamaño de la ventana
-		else if (event.type == SDL_WINDOWEVENT)
-		{
-			if (event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED)
-			{
-				reloadTextures();
-			}
-		}
-
-		// Comprueba el cursor
-		Mouse::handleEvent(event);
+		globalEvents::check(event);
 	}
 }
 
 // Comprueba las entradas
 void Logo::checkInput()
 {
-	// Comprueba si se ha pulsado cualquier botón (de los usados para jugar)
-	if (Input::get()->checkAnyButtonPressed())
-	{
-		section::name = section::Name::TITLE;
-		section::options = section::Options::TITLE_1;
-		return;
-	}
-
-	// Comprueba los inputs que se pueden introducir en cualquier sección del juego
 	globalInputs::check();
 }
 
-// Gestiona el logo de JAILGAME
+// Gestiona el logo de JAILGAMES
 void Logo::updateJAILGAMES()
 {
 	if (counter_ == 30)
@@ -147,6 +108,12 @@ void Logo::updateJAILGAMES()
 			}
 		}
 	}
+
+	// Comprueba si ha terminado el logo
+	if (counter_ == END_LOGO_COUNTER_MARK + POST_LOGO_DURATION)
+	{
+		section::name = section::Name::INTRO;
+	}
 }
 
 // Gestiona el color de las texturas
@@ -177,9 +144,7 @@ void Logo::updateTextureColors()
 // Actualiza las variables
 void Logo::update()
 {
-	constexpr int TICKS_SPEED = 15;
-
-	if (SDL_GetTicks() - ticks_ > TICKS_SPEED)
+	if (SDL_GetTicks() - ticks_ > param.game.speed)
 	{
 		// Actualiza el contador de ticks
 		ticks_ = SDL_GetTicks();
@@ -190,21 +155,12 @@ void Logo::update()
 		// Comprueba las entradas
 		checkInput();
 
-		// Gestiona el logo de JAILGAME
 		updateJAILGAMES();
-
-		// Gestiona el color de las texturas
 		updateTextureColors();
 
-		// Gestiona el contador y sus eventos
+		// Gestiona el contador
 		counter_++;
 
-		// Comprueba si ha terminado el logo
-		if (counter_ == END_LOGO_COUNTER_MARK + POST_LOGO_DURATION)
-		{
-			section::name = section::Name::INTRO;
-		}
-
 		// Actualiza las variables de globalInputs
 		globalInputs::update();
 	}
@@ -213,24 +169,11 @@ void Logo::update()
 // Dibuja en pantalla
 void Logo::render()
 {
-	// Prepara para empezar a dibujar en la textura de juego
 	Screen::get()->start();
-
-	// Limpia la pantalla
 	Screen::get()->clean();
 
-	// Dibuja los sprites
-	for (auto &sprite : jail_sprite_)
-	{
-		sprite->render();
-	}
+	renderJAILGAMES();
 
-	if (counter_ >= SHOW_SINCE_SPRITE_COUNTER_MARK)
-	{
-		since_sprite_->render();
-	}
-
-	// Vuelca el contenido del renderizador en pantalla
 	Screen::get()->render();
 }
 
@@ -248,3 +191,18 @@ void Logo::run()
 		render();
 	}
 }
+
+// Renderiza el logo de JAILGAMES
+void Logo::renderJAILGAMES()
+{
+	// Dibuja los sprites
+	for (auto &sprite : jail_sprite_)
+	{
+		sprite->render();
+	}
+
+	if (counter_ >= SHOW_SINCE_SPRITE_COUNTER_MARK)
+	{
+		since_sprite_->render();
+	}
+}

source/logo.h

@@ -4,9 +4,9 @@
 #include <SDL2/SDL_stdinc.h> // Para Uint32
 #include <memory>			 // Para shared_ptr, unique_ptr
 #include <vector>			 // Para vector
-class Sprite;
-class Texture; // lines 9-9
-struct Color;
+class Sprite;				 // lines 8-8
+class Texture;				 // lines 9-9
+struct Color;				 // lines 10-10
 
 /*
 	Esta clase gestiona un estado del programa. Se encarga de dibujar por pantalla el
@@ -35,8 +35,8 @@ private:
 
 	// Variables
 	std::vector<Color> color_; // Vector con los colores para el fade
-	int counter_;			   // Contador
-	Uint32 ticks_;			   // Contador de ticks para ajustar la velocidad del programa
+	int counter_ = 0;		   // Contador
+	Uint32 ticks_ = 0;		   // Contador de ticks para ajustar la velocidad del programa
 	SDL_Point dest_;		   // Posición X donde dibujar el logo
 
 	// Actualiza las variables
@@ -51,15 +51,15 @@ private:
 	// Comprueba las entradas
 	void checkInput();
 
-	// Gestiona el logo de JAILGAME
+	// Gestiona el logo de JAILGAMES
 	void updateJAILGAMES();
 
+	// Renderiza el logo de JAILGAMES
+	void renderJAILGAMES();
+
 	// Gestiona el color de las texturas
 	void updateTextureColors();
 
-	// Recarga todas las texturas
-	void reloadTextures();
-
 public:
 	// Constructor
 	Logo();

source/manage_hiscore_table.cpp

@@ -1,9 +1,10 @@
 #include "manage_hiscore_table.h"
 #include <SDL2/SDL_error.h> // Para SDL_GetError
 #include <SDL2/SDL_rwops.h> // Para SDL_RWread, SDL_RWwrite, SDL_RWFromFile
-#include <algorithm>        // Para sort
+#include <algorithm>        // Para find_if, sort
 #include <iostream>         // Para basic_ostream, operator<<, cout, endl
-#include "utils.h"          // Para HiScoreEntry, getFileName
+#include <iterator>         // Para distance
+#include "utils.h"          // Para getFileName
 
 // Resetea la tabla a los valores por defecto
 void ManageHiScoreTable::clear()

source/moving_sprite.cpp

@@ -1,5 +1,4 @@
 #include "moving_sprite.h"
-#include <algorithm> // Para max
 #include "texture.h" // Para Texture
 
 // Constructor
@@ -73,46 +72,7 @@ void MovingSprite::update()
 }
 
 // Muestra el sprite por pantalla
-void MovingSprite::render()
-{
-	texture_->render(pos_.x, pos_.y, &sprite_clip_, zoom_w_, zoom_h_, rotate_.angle, rotate_.center, flip_);
-}
-
-// Establece el valor de la variable
-void MovingSprite::setZoomW(float value)
-{
-	zoom_w_ = value;
-}
-
-// Establece el valor de la variable
-void MovingSprite::setZoomH(float value)
-{
-	zoom_h_ = value;
-}
-
-// Establece el valor de la variable
-void MovingSprite::setAngle(double value)
-{
-	rotate_.angle = value;
-}
-
-// Establece el valor de la variable
-void MovingSprite::setRotatingCenter(SDL_Point *point)
-{
-	rotate_.center = point;
-}
-
-// Incrementa el valor del ángulo
-void MovingSprite::updateAngle()
-{
-	rotate_.angle += rotate_.amount;
-}
-
-// Obtiene el valor de la variable
-bool MovingSprite::isRotating() const
-{
-	return rotate_.enabled;
-}
+void MovingSprite::render() { texture_->render(pos_.x, pos_.y, &sprite_clip_, zoom_w_, zoom_h_, rotate_.angle, &rotate_.center, flip_); }
 
 // Establece la rotacion
 void MovingSprite::rotate()
@@ -135,43 +95,6 @@ void MovingSprite::setRotate(bool enable)
 	rotate_.counter = 0;
 }
 
-// Establece el valor de la variable
-void MovingSprite::setRotateSpeed(int value)
-{
-	rotate_.speed = std::max(1, value);
-}
-
-// Establece el valor de la variable
-void MovingSprite::setRotateAmount(double value)
-{
-	rotate_.amount = value;
-}
-
-// Cambia el sentido de la rotación
-void MovingSprite::switchRotate()
-{
-	rotate_.amount *= -1;
-}
-
-// Establece el valor de la variable
-void MovingSprite::setFlip(SDL_RendererFlip flip)
-{
-	flip_ = flip;
-}
-
-// Gira el sprite horizontalmente
-void MovingSprite::flip()
-{
-	flip_ = (flip_ == SDL_FLIP_HORIZONTAL) ? SDL_FLIP_NONE : SDL_FLIP_HORIZONTAL;
-}
-
-// Obtiene el valor de la variable
-SDL_RendererFlip MovingSprite::getFlip()
-{
-	return flip_;
-}
-
-
 // Establece la posición y_ el tamaño del objeto
 void MovingSprite::setPos(SDL_Rect rect)
 {
@@ -204,27 +127,3 @@ void MovingSprite::setPosY(float value)
 	y_ = value;
 	pos_.y = static_cast<int>(y_);
 }
-
-// Establece el valor de la variable
-void MovingSprite::setVelX(float value)
-{
-	vx_ = value;
-}
-
-// Establece el valor de la variable
-void MovingSprite::setVelY(float value)
-{
-	vy_ = value;
-}
-
-// Establece el valor de la variable
-void MovingSprite::setAccelX(float value)
-{
-	ax_ = value;
-}
-
-// Establece el valor de la variable
-void MovingSprite::setAccelY(float value)
-{
-	ay_ = value;
-}

source/moving_sprite.h

@@ -3,8 +3,9 @@
 #include <SDL2/SDL_rect.h>   // Para SDL_Rect, SDL_Point
 #include <SDL2/SDL_render.h> // Para SDL_RendererFlip
 #include <memory>            // Para shared_ptr
-#include "sprite.h"          // Para Sprite
-class Texture;               // lines 8-8
+#include <algorithm>
+#include "sprite.h" // Para Sprite
+class Texture;      // lines 8-8
 
 // Clase MovingSprite. Añade movimiento y efectos de rotación, zoom y flip al sprite
 class MovingSprite : public Sprite
@@ -12,14 +13,14 @@ class MovingSprite : public Sprite
 public:
     struct Rotate
     {
-        bool enabled;      // Indica si ha de rotar
-        int counter;       // Contador
-        int speed;         // Velocidad de giro
-        double angle;      // Angulo para dibujarlo
-        float amount;      // Cantidad de grados a girar en cada iteración
-        SDL_Point *center; // Centro de rotación
+        bool enabled;     // Indica si ha de rotar
+        int counter;      // Contador
+        int speed;        // Velocidad de giro
+        double angle;     // Angulo para dibujarlo
+        float amount;     // Cantidad de grados a girar en cada iteración
+        SDL_Point center; // Centro de rotación
 
-        Rotate() : enabled(false), counter(0), speed(1), angle(0.0), amount(0.0f), center(nullptr) {}
+        Rotate() : enabled(false), counter(0), speed(1), angle(0.0), amount(0.0f), center({0, 0}) {}
     };
 
 protected:
@@ -38,7 +39,7 @@ protected:
     SDL_RendererFlip flip_; // Indica como se voltea el sprite
 
     // Incrementa el valor del ángulo
-    void updateAngle();
+    void updateAngle() { rotate_.angle += rotate_.amount; }
 
     // Mueve el sprite
     void move();
@@ -53,7 +54,7 @@ public:
     explicit MovingSprite(std::shared_ptr<Texture> texture);
 
     // Destructor
-    virtual ~MovingSprite() = default;
+    virtual ~MovingSprite() override = default;
 
     // Actualiza las variables internas del objeto
     virtual void update();
@@ -73,40 +74,40 @@ public:
     float getAccelY() const { return ay_; }
 
     // Establece la variable
-    void setVelX(float value);
-    void setVelY(float value);
-    void setAccelX(float value);
-    void setAccelY(float value);
+    void setVelX(float value) { vx_ = value; }
+    void setVelY(float value) { vy_ = value; }
+    void setAccelX(float value) { ax_ = value; }
+    void setAccelY(float value) { ay_ = value; }
 
     // Obten el valor de la variable
-    bool isRotating() const;
+    bool isRotating() const { return rotate_.enabled; }
 
     // Establece el valor de la variable
-    void setZoomW(float value);
-    void setZoomH(float value);
+    void setZoomW(float value) { zoom_w_ = value; }
+    void setZoomH(float value) { zoom_h_ = value; }
 
     // Establece el valor de la variable
-    void setAngle(double vaue);
-    void setRotatingCenter(SDL_Point *point);
+    void setAngle(double value) { rotate_.angle = value; }
+    void setRotatingCenter(SDL_Point point) { rotate_.center = point; }
 
     // Activa o desactiva el efecto de rotación
     void setRotate(bool enable);
 
     // Establece el valor de la variable
-    void setRotateSpeed(int value);
-    void setRotateAmount(double value);
+    void setRotateSpeed(int value) { rotate_.speed = std::max(1, value); }
+    void setRotateAmount(double value) { rotate_.amount = value; }
 
     // Cambia el sentido de la rotación
-    void switchRotate();
+    void switchRotate() { rotate_.amount *= -1; }
 
     // Establece el valor de la variable
-    void setFlip(SDL_RendererFlip flip);
+    void setFlip(SDL_RendererFlip flip) { flip_ = flip; }
 
     // Gira el sprite horizontalmente
-    void flip();
+    void flip() { flip_ = (flip_ == SDL_FLIP_HORIZONTAL) ? SDL_FLIP_NONE : SDL_FLIP_HORIZONTAL; }
 
     // Obtiene el valor de la variable
-    SDL_RendererFlip getFlip();
+    SDL_RendererFlip getFlip() { return flip_; }
 
     // Establece la posición y_ el tamaño del objeto
     void setPos(SDL_Rect rect);

source/notifier.cpp

@@ -12,22 +12,22 @@
 #include "texture.h"    // Para Texture
 #include "resource.h"
 
-// [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
+// [SINGLETON]
 Notifier *Notifier::notifier_ = nullptr;
 
-// [SINGLETON] Crearemos el objeto screen con esta función estática
+// [SINGLETON] Crearemos el objeto con esta función estática
 void Notifier::init(const std::string &icon_file, std::shared_ptr<Text> text)
 {
     Notifier::notifier_ = new Notifier(icon_file, text);
 }
 
-// [SINGLETON] Destruiremos el objeto screen con esta función estática
+// [SINGLETON] Destruiremos el objeto con esta función estática
 void Notifier::destroy()
 {
     delete Notifier::notifier_;
 }
 
-// [SINGLETON] Con este método obtenemos el objeto screen y podemos trabajar con él
+// [SINGLETON] Con este método obtenemos el objeto y podemos trabajar con él
 Notifier *Notifier::get()
 {
     return Notifier::notifier_;
@@ -153,7 +153,7 @@ void Notifier::clearFinishedNotifications()
     }
 }
 
-void Notifier::showText(std::vector<std::string> texts, int icon, const std::string &code)
+void Notifier::show(std::vector<std::string> texts, int icon, const std::string &code)
 {
     // Si no hay texto, acaba
     if (texts.empty())
@@ -164,7 +164,7 @@ void Notifier::showText(std::vector<std::string> texts, int icon, const std::str
     // Si las notificaciones no se apilan, elimina las anteriores
     if (!stack_)
     {
-        clearNotifications();
+        clearAllNotifications();
     }
 
     // Elimina las cadenas vacías
@@ -294,11 +294,8 @@ void Notifier::showText(std::vector<std::string> texts, int icon, const std::str
     notifications_.emplace_back(n);
 }
 
-// Indica si hay notificaciones activas
-bool Notifier::isActive() { return !notifications_.empty(); }
-
 // Finaliza y elimnina todas las notificaciones activas
-void Notifier::clearNotifications()
+void Notifier::clearAllNotifications()
 {
     for (auto &notification : notifications_)
     {

source/notifier.h

@@ -13,7 +13,7 @@ class Texture;				 // lines 11-11
 class Notifier
 {
 private:
-	// [SINGLETON] Objeto notifier privado para Don Melitón
+	// [SINGLETON] Objeto notifier
 	static Notifier *notifier_;
 
 	enum class NotificationStatus
@@ -66,7 +66,7 @@ private:
 	void clearFinishedNotifications();
 
 	// Finaliza y elimnina todas las notificaciones activas
-	void clearNotifications();
+	void clearAllNotifications();
 
 	// [SINGLETON] Ahora el constructor y el destructor son privados, para no poder crear objetos notifier desde fuera
 
@@ -77,13 +77,13 @@ private:
 	~Notifier() = default;
 
 public:
-	// [SINGLETON] Crearemos el objeto notifier con esta función estática
+	// [SINGLETON] Crearemos el objeto con esta función estática
 	static void init(const std::string &icon_file, std::shared_ptr<Text> text);
 
-	// [SINGLETON] Destruiremos el objeto notifier con esta función estática
+	// [SINGLETON] Destruiremos el objeto con esta función estática
 	static void destroy();
 
-	// [SINGLETON] Con este método obtenemos el objeto notifier y podemos trabajar con él
+	// [SINGLETON] Con este método obtenemos el objeto y podemos trabajar con él
 	static Notifier *get();
 
 	// Dibuja las notificaciones por pantalla
@@ -93,11 +93,14 @@ public:
 	void update();
 
 	// Muestra una notificación de texto por pantalla
-	void showText(std::vector<std::string> texts, int icon = -1, const std::string &code = std::string());
+	void show(std::vector<std::string> texts, int icon = -1, const std::string &code = std::string());
 
 	// Indica si hay notificaciones activas
-	bool isActive();
+	bool isActive() { return !notifications_.empty(); }
 
 	// Obtiene los códigos de las notificaciones
 	std::vector<std::string> getCodes();
+
+	// Comprueba si hay alguna notificacion con un código
+	bool checkCode(const std::string &code) { return stringInVector(getCodes(), code); }
 };

source/options.cpp

@@ -25,7 +25,7 @@ void initOptions()
 	options.video.window.size = 3;
 #else
 	options.video.mode = ScreenVideoMode::WINDOW;
-	options.video.window.size = 2;
+	options.video.window.zoom = 2;
 #endif
 	options.video.filter = ScreenFilter::NEAREST;
 	options.video.v_sync = true;
@@ -105,7 +105,7 @@ bool loadOptionsFile(std::string file_path)
 		options.video.mode = ScreenVideoMode::WINDOW;
 	}
 
-	options.video.window.size = std::clamp(options.video.window.size, 1, 4);
+	options.video.window.zoom = std::clamp(options.video.window.zoom, 1, 4);
 
 	if (options.game.language != lang::Code::en_UK &&
 		options.game.language != lang::Code::ba_BA &&
@@ -137,7 +137,7 @@ bool saveOptionsFile(std::string file_path)
 	file << "\n";
 
 	file << "video.mode=" << static_cast<int>(options.video.mode) << "\n";
-	file << "video.window.size=" << options.video.window.size << "\n";
+	file << "video.window.size=" << options.video.window.zoom << "\n";
 	file << "video.filter=" << static_cast<int>(options.video.filter) << "\n";
 	file << "video.v_sync=" << boolToString(options.video.v_sync) << "\n";
 	file << "video.integer_scale=" << boolToString(options.video.integer_scale) << "\n";
@@ -204,10 +204,10 @@ bool setOptions(const std::string &var, const std::string &value)
 	}
 	else if (var == "video.window.size")
 	{
-		options.video.window.size = std::stoi(value);
-		if ((options.video.window.size < 1) || (options.video.window.size > 4))
+		options.video.window.zoom = std::stoi(value);
+		if ((options.video.window.zoom < 1) || (options.video.window.zoom > 4))
 		{
-			options.video.window.size = 3;
+			options.video.window.zoom = 3;
 		}
 	}
 	else if (var == "video.filter")

source/options.h

@@ -1,16 +1,17 @@
 #pragma once
 
 #include <SDL2/SDL_gamecontroller.h> // Para SDL_CONTROLLER_BUTTON_B, SDL_CO...
+#include <SDL2/SDL_stdinc.h>		 // Para Uint32
 #include <string>					 // Para string
 #include <vector>					 // Para vector
 #include "input.h"					 // Para InputType, InputDeviceToUse
 #include "manage_hiscore_table.h"	 // Para HiScoreEntry
-enum class ScreenFilter : int;		 // lines 10-10
-enum class ScreenVideoMode : int;	 // lines 11-11
+enum class ScreenFilter : int;		 // lines 8-8
+enum class ScreenVideoMode : Uint32; // lines 9-9
 namespace lang
 {
 	enum class Code : int;
-} // lines 14-14
+} // lines 12-12
 
 // Dificultad del juego
 enum class GameDifficulty
@@ -23,8 +24,8 @@ enum class GameDifficulty
 // Estructura para las opciones de la ventana
 struct OptionsWindow
 {
-	int size = 1;	  // Contiene el valor por el que se multiplica el tamaño de la ventana
-	int max_size = 1; // Tamaño máximo para que el tamaño de la ventana no sea mayor que el tamaño de la pantalla
+	int zoom = 1;	  // Contiene el valor por el que se multiplica el tamaño de la ventana
+	int max_zoom = 1; // Tamaño máximo para que el tamaño de la ventana no sea mayor que el tamaño de la pantalla
 };
 
 // Estructura con opciones para el video
@@ -64,18 +65,18 @@ struct OptionsAudio
 // Estructura para las opciones del juego
 struct OptionsGame
 {
-    GameDifficulty difficulty;                  // Dificultad del juego
-    lang::Code language;                        // Idioma usado en el juego
-    bool autofire;                              // Indicador de autofire
-    std::vector<HiScoreEntry> hi_score_table;   // Tabla de mejores puntuaciones
-    std::vector<int> last_hi_score_entry = { -1, -1 }; // Inicialización directa con dos elementos en -1
+	GameDifficulty difficulty;						 // Dificultad del juego
+	lang::Code language;							 // Idioma usado en el juego
+	bool autofire;									 // Indicador de autofire
+	std::vector<HiScoreEntry> hi_score_table;		 // Tabla de mejores puntuaciones
+	std::vector<int> last_hi_score_entry = {-1, -1}; // Inicialización directa con dos elementos en -1
 
-    // Método para reiniciar las últimas entradas de puntuación
-    void clear_last_hi_score_entries()
-    {
-        last_hi_score_entry[0] = -1;
-        last_hi_score_entry[1] = -1;
-    }
+	// Método para reiniciar las últimas entradas de puntuación
+	void clear_last_hi_score_entries()
+	{
+		last_hi_score_entry[0] = -1;
+		last_hi_score_entry[1] = -1;
+	}
 };
 
 // Estructura para los controles del juego

source/param.cpp

@@ -26,6 +26,7 @@ void initParam()
 	param.game.game_area.rect = {0, 0, param.game.width, param.game.height};
 	param.game.play_area.rect = {0, 0, param.game.width, 216};
 	param.game.enter_name_seconds = 30;
+	param.game.speed = 15;
 	precalculateZones();
 
 	// SCOREBOARD

source/param.h

@@ -1,9 +1,10 @@
 #pragma once
 
-#include <SDL2/SDL_rect.h> // Para SDL_Rect
-#include <string>          // Para string
-#include <vector>          // Para vector
-#include "utils.h"         // Para Color, Zone
+#include <SDL2/SDL_rect.h>   // Para SDL_Rect
+#include <SDL2/SDL_stdinc.h> // Para Uint32
+#include <string>            // Para string
+#include <vector>            // Para vector
+#include "utils.h"           // Para Color, Zone
 
 // param.game
 struct ParamGame
@@ -16,6 +17,7 @@ struct ParamGame
     Zone play_area;         // Rectangulo con la posición de la zona de juego
     Zone game_area;         // Rectangulo con las dimensiones del juego
     int enter_name_seconds; // Duración en segundos para introducir el nombre al finalizar la partida
+    Uint32 speed;           // Velocidad a la que transcurre el juego
 };
 
 // param.fade
@@ -83,7 +85,5 @@ struct Param
 
 extern Param param;
 
-extern Param param;
-
 // Establece valores para los parametros a partir de un fichero de texto
 void loadParamsFromFile(const std::string &file_path);

source/path_sprite.cpp

@@ -15,13 +15,9 @@ std::vector<SDL_Point> createPath(int start, int end, PathType type, int fixed_p
 		double t = static_cast<double>(i) / (steps - 1);
 		double value = start + (end - start) * easingFunction(t);
 
-		if (start > 0 && end < 0)
+		if ((start > 0 && end < 0) || (start < 0 && end > 0))
 		{
-			value = start - std::abs(end - start) * easingFunction(t);
-		}
-		else if (start < 0 && end > 0)
-		{
-			value = start + std::abs(end - start) * easingFunction(t);
+			value = start + (end > 0 ? 1 : -1) * std::abs(end - start) * easingFunction(t);
 		}
 
 		switch (type)
@@ -43,13 +39,22 @@ std::vector<SDL_Point> createPath(int start, int end, PathType type, int fixed_p
 // Actualiza la posición y comprueba si ha llegado a su destino
 void PathSprite::update()
 {
-	if (enabled_)
+	if (enabled_ && !has_finished_)
 	{
 		moveThroughCurrentPath();
 		goToNextPathOrDie();
 	}
 }
 
+// Muestra el sprite por pantalla
+void PathSprite::render()
+{
+	if (enabled_)
+	{
+		Sprite::render();
+	}
+}
+
 // Añade un recorrido
 void PathSprite::addPath(Path path, bool centered)
 {
@@ -105,8 +110,8 @@ void PathSprite::enable()
 
 	// Establece la posición
 	auto &path = paths_.at(current_path_);
-	const auto &p = path.spots.at(path.counter);
-	setPosition(p);
+	const auto &P = path.spots.at(path.counter);
+	setPosition(P);
 }
 
 // Coloca el sprite en los diferentes puntos del recorrido
@@ -155,12 +160,10 @@ void PathSprite::goToNextPathOrDie()
 	// Comprueba si quedan mas recorridos
 	if (current_path_ >= static_cast<int>(paths_.size()))
 	{
-		enabled_ = false;
+		has_finished_ = true;
+		current_path_ = 0;
 	}
 }
 
 // Indica si ha terminado todos los recorridos
-bool PathSprite::hasFinished()
-{
-	return !enabled_;
-}
+bool PathSprite::hasFinished() { return has_finished_; }

source/path_sprite.h

@@ -42,9 +42,10 @@ class PathSprite : public Sprite
 {
 private:
 	// Variables
-	bool enabled_ = false;	  // Indica si el objeto está habilitado
-	int current_path_ = 0;	  // Path que se está recorriendo actualmente
-	std::vector<Path> paths_; // Caminos a recorrer por el sprite
+	bool enabled_ = false;		// Indica si el objeto está habilitado
+	bool has_finished_ = false; // Indica si el objeto ha finalizado el recorrido
+	int current_path_ = 0;		// Path que se está recorriendo actualmente
+	std::vector<Path> paths_;	// Caminos a recorrer por el sprite
 
 	// Coloca el sprite en los diferentes puntos del recorrido
 	void moveThroughCurrentPath();
@@ -58,11 +59,14 @@ public:
 		: Sprite(texture) {}
 
 	// Destructor
-	~PathSprite() = default;
+	~PathSprite() override = default;
 
 	// Actualiza la posición del sprite
 	void update();
 
+	// Muestra el sprite por pantalla
+	void render() override;
+
 	// Añade un recorrido
 	void addPath(Path path, bool centered = false);
 	void addPath(std::vector<SDL_Point> spots, int waiting_counter = 0);

source/player.cpp

@@ -11,6 +11,7 @@
 #include "resource.h"
 #include "jail_audio.h"
 #include "stage.h"
+#include <array>
 
 // Constructor
 Player::Player(int id, float x, int y, bool demo, SDL_Rect &play_area, std::vector<std::shared_ptr<Texture>> texture, const std::vector<std::vector<std::string>> &animations)
@@ -149,6 +150,11 @@ void Player::setInputEnteringName(InputType input)
 		break;
 	case InputType::START:
 		last_enter_name_ = getRecordName();
+		if (last_enter_name_.empty())
+		{
+			const std::array<std::string, 8> NAMES = {"BAL1", "TABE", "DOC", "MON", "SAM1", "JORDI", "JDES", "PEPE"};
+			last_enter_name_ = NAMES.at(rand() % NAMES.size());
+		}
 		break;
 	default:
 		break;
@@ -166,9 +172,9 @@ void Player::move()
 		pos_x_ += vel_x_;
 
 		// Si el jugador abandona el area de juego por los laterales, restaura su posición
-		const float min_x = play_area_.x - 5;
-		const float max_x = play_area_.w + 5 - WIDTH_;
-		pos_x_ = std::clamp(pos_x_, min_x, max_x);
+		const float MIN_X = play_area_.x - 5;
+		const float MAX_X = play_area_.w + 5 - WIDTH_;
+		pos_x_ = std::clamp(pos_x_, MIN_X, MAX_X);
 
 		shiftSprite();
 		break;
@@ -176,12 +182,12 @@ void Player::move()
 	case PlayerState::DYING:
 	{
 		// Si el cadaver abandona el area de juego por los laterales lo hace rebotar
-		const int x = player_sprite_->getPosX();
-		const int min_x = play_area_.x;
-		const int max_x = play_area_.x + play_area_.w - WIDTH_;
-		if ((x < min_x) || (x > max_x))
+		const int X = player_sprite_->getPosX();
+		const int MIN_X = play_area_.x;
+		const int MAX_X = play_area_.x + play_area_.w - WIDTH_;
+		if ((X < MIN_X) || (X > MAX_X))
 		{
-			player_sprite_->setPosX(std::clamp(x, min_x, max_x));
+			player_sprite_->setPosX(std::clamp(X, MIN_X, MAX_X));
 			player_sprite_->setVelX(-player_sprite_->getVelX());
 			playRandomBubbleSound();
 		}
@@ -287,7 +293,6 @@ void Player::move()
 			{
 				pos_x_ = param.game.game_area.rect.w - WIDTH_;
 				vel_x_ *= -1;
-				// setInputPlaying(InputType::LEFT);
 			}
 		}
 		else
@@ -297,7 +302,6 @@ void Player::move()
 			{
 				pos_x_ = param.game.game_area.rect.x;
 				vel_x_ *= -1;
-				// setInputPlaying(InputType::RIGHT);
 			}
 		}
 
@@ -356,17 +360,20 @@ void Player::setAnimation()
 
 		// Establece la animación a partir de las cadenas
 		if (firing_state_ == PlayerState::FIRING_NONE)
-		{ // No esta disparando
+		{
+			// No esta disparando
 			player_sprite_->setCurrentAnimation(a_walking);
 			player_sprite_->setFlip(flip_walk);
 		}
 		else if (isCooling())
-		{ // Acaba de disparar
+		{
+			// Acaba de disparar
 			player_sprite_->setCurrentAnimation(a_walking + "-" + a_cooling + "-cooldown");
 			player_sprite_->setFlip(flip_cooling);
 		}
 		else
-		{ // Está disparando
+		{
+			// Está disparando
 			player_sprite_->setCurrentAnimation(a_walking + "-" + a_firing);
 			// Si dispara de lado, invierte el sprite segun hacia donde dispara
 			// Si dispara recto, invierte el sprite segun hacia donde camina

source/player.h

@@ -208,6 +208,7 @@ public:
 	bool isContinue() const { return playing_state_ == PlayerState::CONTINUE; }
 	bool isDying() const { return playing_state_ == PlayerState::DYING; }
 	bool isEnteringName() const { return playing_state_ == PlayerState::ENTERING_NAME; }
+	bool isShowingName() const { return playing_state_ == PlayerState::SHOWING_NAME; }
 	bool isEnteringNameGameCompleted() const { return playing_state_ == PlayerState::ENTERING_NAME_GAME_COMPLETED; }
 	bool isLeavingScreen() const { return playing_state_ == PlayerState::LEAVING_SCREEN; }
 	bool isGameOver() const { return playing_state_ == PlayerState::GAME_OVER; }
@@ -237,7 +238,7 @@ public:
 	int getScoreBoardPanel() const { return scoreboard_panel_; }
 	int getWidth() const { return WIDTH_; }
 	PlayerState getPlayingState() const { return playing_state_; }
-	std::string getName() const { return name_; }
+	const std::string& getName() const { return name_; }
 	bool get1CC() const { return game_completed_ && credits_used_ == 1; }
 	bool getEnterNamePositionOverflow() const { return enter_name_->getPositionOverflow(); }
 

source/resource.cpp

@@ -2,14 +2,13 @@
 #include <algorithm>    // Para find_if
 #include <iostream>     // Para basic_ostream, operator<<, endl, cout, cerr
 #include <stdexcept>    // Para runtime_error
-#include <utility>      // Para pair
 #include "asset.h"      // Para Asset, AssetType
-#include "jail_audio.h" // Para JA_LoadMusic, JA_LoadSound
+#include "jail_audio.h" // Para JA_DeleteMusic, JA_DeleteSound, JA_LoadMusic
 #include "lang.h"       // Para getText
 #include "screen.h"     // Para Screen
 #include "text.h"       // Para Text, loadTextFile
-struct JA_Music_t;      // lines 10-10
-struct JA_Sound_t;      // lines 11-11
+struct JA_Music_t;      // lines 11-11
+struct JA_Sound_t;      // lines 12-12
 
 // [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
 Resource *Resource::resource_ = nullptr;
@@ -73,6 +72,14 @@ void Resource::reload()
     load();
 }
 
+// Recarga las texturas
+void Resource::reloadTextures()
+{
+    loadTextures();
+    addPalettes();
+    createTextures();
+}
+
 // Obtiene el sonido a partir de un nombre
 JA_Sound_t *Resource::getSound(const std::string &name)
 {

source/resource.h

@@ -170,4 +170,7 @@ public:
 
     // Recarga todos los recursos
     void reload();
+
+    // Recarga las texturas
+    void reloadTextures();
 };

source/scoreboard.cpp

@@ -5,13 +5,12 @@
 #include <math.h>				// Para roundf
 #include <iomanip>				// Para operator<<, setfill, setw
 #include <sstream>				// Para basic_ostream, basic_ostringstream
+#include "enter_name.h"			// Para MAX_NAME_LENGHT
 #include "lang.h"				// Para getText
 #include "resource.h"			// Para Resource
 #include "screen.h"				// Para Screen
 #include "sprite.h"				// Para Sprite
-#include "text.h"				// Para Text
-#include "enter_name.h"			// Para NAME_LENGHT
-#include <iostream>
+#include "text.h"				// Para Text, TEXT_CENTER, TEXT_COLOR
 
 // [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
 Scoreboard *Scoreboard::scoreboard_ = nullptr;
@@ -263,7 +262,7 @@ void Scoreboard::fillPanelTextures()
 				SDL_Rect rect = {enter_name_pos_.x, enter_name_pos_.y, 5, 7};
 
 				// Recorre todos los slots de letras del nombre
-				for (size_t j = 0; j < NAME_LENGHT; ++j)
+				for (size_t j = 0; j < MAX_NAME_LENGHT; ++j)
 				{
 					// Selecciona el color
 					const Color color = j < selector_pos_[i] ? orange_soft_color.lighten() : Color(0xFF, 0xFF, 0xEB);
@@ -296,7 +295,11 @@ void Scoreboard::fillPanelTextures()
 
 			// NAME
 			text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y, lang::getText(106));
-			text_scoreboard_->writeDX(TEXT_CENTER | TEXT_COLOR, slot4_4_.x, slot4_4_.y, record_name_[i], 1, getColorLikeKnightRider(name_colors_, loop_counter_ / 5));
+			/* TEXTO CENTRADO */
+			//text_scoreboard_->writeDX(TEXT_CENTER | TEXT_COLOR, slot4_4_.x, slot4_4_.y, record_name_[i], 1, getColorLikeKnightRider(name_colors_, loop_counter_ / 5));
+
+			/* TEXTO A LA IZQUIERDA */
+			text_scoreboard_->writeColored(enter_name_pos_.x, enter_name_pos_.y, record_name_[i], getColorLikeKnightRider(name_colors_, loop_counter_ / 5));
 			break;
 		}
 		case ScoreboardMode::GAME_COMPLETED:
@@ -380,7 +383,7 @@ void Scoreboard::recalculateAnchors()
 	slot4_4_ = {col, row4};
 
 	// Primer cuadrado para poner el nombre de record
-	const int enter_name_lenght = text_scoreboard_->lenght(std::string(NAME_LENGHT, 'A'));
+	const int enter_name_lenght = text_scoreboard_->lenght(std::string(MAX_NAME_LENGHT, 'A'));
 	enter_name_pos_.x = col - (enter_name_lenght / 2);
 	enter_name_pos_.y = row4;
 
@@ -439,9 +442,11 @@ void Scoreboard::renderSeparator()
 // Inicializa el vector de colores para el nombre
 void Scoreboard::iniNameColors()
 {
+	Color color = green_color;
+
 	name_colors_.clear();
-	name_colors_.emplace_back(green_color.lighten(50));
-	name_colors_.emplace_back(green_color.lighten(25));
-	name_colors_.emplace_back(green_color);
-	name_colors_.emplace_back(green_color.darken(25));
+	name_colors_.emplace_back(color.lighten(50));
+	name_colors_.emplace_back(color.lighten(25));
+	name_colors_.emplace_back(color);
+	name_colors_.emplace_back(color.darken(25));
 }

source/screen.cpp

@@ -1,9 +1,7 @@
 #include "screen.h"
-#include <SDL2/SDL_events.h> // Para SDL_DISABLE, SDL_ENABLE
-#include <SDL2/SDL_mouse.h>  // Para SDL_ShowCursor
 #include <SDL2/SDL_pixels.h> // Para SDL_PIXELFORMAT_RGBA8888
 #include <SDL2/SDL_timer.h>  // Para SDL_GetTicks
-#include <algorithm>         // Para clamp, max, min
+#include <algorithm>         // Para max, min
 #include <fstream>           // Para basic_ifstream, ifstream
 #include <iterator>          // Para istreambuf_iterator, operator==
 #include <string>            // Para allocator, operator+, char_traits, to_s...
@@ -11,35 +9,23 @@
 #include "asset.h"           // Para Asset
 #include "dbgtxt.h"          // Para dbg_print
 #include "global_inputs.h"   // Para service_pressed_counter
+#include "jail_shader.h"     // Para init, render
+#include "mouse.h"           // Para updateCursorVisibility
 #include "notifier.h"        // Para Notifier
 #include "on_screen_help.h"  // Para OnScreenHelp
 #include "options.h"         // Para Options, OptionsVideo, options, Options...
-#include "mouse.h"
 
-#ifndef NO_SHADERS
-#include "jail_shader.h" // para init, render
-#endif
-
-// [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
+// [SINGLETON]
 Screen *Screen::screen_ = nullptr;
 
-// [SINGLETON] Crearemos el objeto screen con esta función estática
-void Screen::init(SDL_Window *window, SDL_Renderer *renderer)
-{
-    Screen::screen_ = new Screen(window, renderer);
-}
+// [SINGLETON] Crearemos el objeto con esta función estática
+void Screen::init(SDL_Window *window, SDL_Renderer *renderer) { Screen::screen_ = new Screen(window, renderer); }
 
-// [SINGLETON] Destruiremos el objeto screen con esta función estática
-void Screen::destroy()
-{
-    delete Screen::screen_;
-}
+// [SINGLETON] Destruiremos el objeto con esta función estática
+void Screen::destroy() { delete Screen::screen_; }
 
-// [SINGLETON] Con este método obtenemos el objeto screen y podemos trabajar con él
-Screen *Screen::get()
-{
-    return Screen::screen_;
-}
+// [SINGLETON] Con este método obtenemos el objeto y podemos trabajar con él
+Screen *Screen::get() { return Screen::screen_; }
 
 // Constructor
 Screen::Screen(SDL_Window *window, SDL_Renderer *renderer)
@@ -53,19 +39,17 @@ Screen::Screen(SDL_Window *window, SDL_Renderer *renderer)
     SDL_DisplayMode DM;
     SDL_GetCurrentDisplayMode(0, &DM);
     info_resolution_ = std::to_string(DM.w) + " X " + std::to_string(DM.h) + " AT " + std::to_string(DM.refresh_rate) + " HZ";
+    adjustRenderLogicalSize();
 
-    // Establece el modo de video
-    setVideoMode(options.video.mode);
+    // Inicializa los shaders
+    initShaders();
 
     // Muestra la ventana
-    SDL_ShowWindow(window_);
+    show();
 }
 
 // Destructor
-Screen::~Screen()
-{
-    SDL_DestroyTexture(game_canvas_);
-}
+Screen::~Screen() { SDL_DestroyTexture(game_canvas_); }
 
 // Limpia la pantalla
 void Screen::clean(Color color)
@@ -75,24 +59,13 @@ void Screen::clean(Color color)
 }
 
 // Prepara para empezar a dibujar en la textura de juego
-void Screen::start()
-{
-    SDL_SetRenderTarget(renderer_, game_canvas_);
-}
+void Screen::start() { SDL_SetRenderTarget(renderer_, game_canvas_); }
 
 // Vuelca el contenido del renderizador en pantalla
 void Screen::render()
 {
-    // Actualiza el contador de FPS
-    ++fps_counter_;
-
-    // Dibuja efectos y elementos sobre el game_canvas_
-    renderFlash();
-    renderAttenuate();
-    renderShake();
-    OnScreenHelp::get()->render();
-    renderInfo();
-    Notifier::get()->render();
+    // Renderiza todos los overlays y efectos
+    renderOverlays();
 
     // Renderiza el contenido del game_canvas_
     renderScreen();
@@ -101,130 +74,90 @@ void Screen::render()
 // Renderiza el contenido del game_canvas_
 void Screen::renderScreen()
 {
-    // Restablece el objetivo de renderizado al buffer de pantalla predeterminado
     SDL_SetRenderTarget(renderer_, nullptr);
     clean();
 
-#ifdef NO_SHADERS
-    // Actualiza la pantalla con el contenido del buffer de renderizado
-    SDL_RenderCopy(renderer_, game_canvas_, nullptr, nullptr);
-    SDL_RenderPresent(renderer_);
-#else
     if (options.video.shaders)
     {
-        // Aplica shaders y renderiza el contenido
         shader::render();
     }
     else
     {
-        // Actualiza la pantalla con el contenido del buffer de renderizado
         SDL_RenderCopy(renderer_, game_canvas_, nullptr, nullptr);
         SDL_RenderPresent(renderer_);
     }
-#endif
 }
 
 // Establece el modo de video
-void Screen::setVideoMode(ScreenVideoMode videoMode)
+void Screen::setVideoMode(ScreenVideoMode video_mode)
 {
-#ifdef ARCADE
-    options.video.mode = ScreenVideoMode::WINDOW;
-#else
-    options.video.mode = videoMode;
-#endif
+    // Actualiza las opciones
+    options.video.mode = video_mode;
 
-    switch (options.video.mode)
+    // Configura el modo de pantalla
+    Uint32 flags = SDL_GetWindowFlags(window_);
+    if (flags != static_cast<Uint32>(options.video.mode))
     {
-    case ScreenVideoMode::WINDOW:
-    {
-        // Cambia a modo de ventana
-        SDL_SetWindowFullscreen(window_, 0);
-
-#ifdef ARCADE
-        // Oculta el puntero
-        SDL_ShowCursor(SDL_DISABLE);
-#else
-        // Muestra el puntero
-        SDL_ShowCursor(SDL_ENABLE);
-#endif
-        // Modifica el tamaño de la ventana
-        SDL_Point pos = getNewPosition();
-        SDL_SetWindowSize(window_, param.game.width * options.video.window.size, param.game.height * options.video.window.size);
-        SDL_SetWindowPosition(window_, pos.x, pos.y);
-
-        break;
+        SDL_SetWindowFullscreen(window_, static_cast<Uint32>(options.video.mode));
     }
 
-    // Si está activo el modo de pantalla completa añade el borde
-    case ScreenVideoMode::FULLSCREEN:
-    {
-        // Aplica el modo de video
-        SDL_SetWindowFullscreen(window_, SDL_WINDOW_FULLSCREEN_DESKTOP);
-
-        // Oculta el puntero
-        SDL_ShowCursor(SDL_DISABLE);
-
-        break;
-    }
-
-    default:
-        break;
-    }
-
-    // Reinicia los shaders
-    if (options.video.shaders)
-    {
-#ifndef NO_SHADERS
-        const std::string glsl_file = param.game.game_area.rect.h == 256 ? "crtpi_256.glsl" : "crtpi_240.glsl";
-        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_, game_canvas_, source.c_str());
-#endif
-    }
+    initShaders();
 }
 
 // Camibia entre pantalla completa y ventana
 void Screen::toggleVideoMode()
 {
     options.video.mode = options.video.mode == ScreenVideoMode::WINDOW ? ScreenVideoMode::FULLSCREEN : ScreenVideoMode::WINDOW;
-    setVideoMode(options.video.mode);
+    setVideoMode();
 }
 
 // Cambia el tamaño de la ventana
-void Screen::setWindowSize(int size)
+void Screen::setWindowZoom(int zoom)
 {
-    options.video.window.size = size;
-    setVideoMode(ScreenVideoMode::WINDOW);
+    options.video.window.zoom = zoom;
+    adjustWindowSize();
 }
 
 // Reduce el tamaño de la ventana
-void Screen::decWindowSize()
+bool Screen::decWindowZoom()
 {
-    --options.video.window.size;
-    options.video.window.size = std::max(options.video.window.size, 1);
-    setVideoMode(ScreenVideoMode::WINDOW);
+    if (options.video.mode == ScreenVideoMode::WINDOW)
+    {
+        const int PREVIOUS_ZOOM = options.video.window.zoom;
+        --options.video.window.zoom;
+        options.video.window.zoom = std::max(options.video.window.zoom, 1);
+
+        if (options.video.window.zoom != PREVIOUS_ZOOM)
+        {
+            adjustWindowSize();
+            return true;
+        }
+    }
+
+    return false;
 }
 
 // Aumenta el tamaño de la ventana
-void Screen::incWindowSize()
+bool Screen::incWindowZoom()
 {
-    ++options.video.window.size;
-    options.video.window.size = std::min(options.video.window.size, options.video.window.max_size);
-    setVideoMode(ScreenVideoMode::WINDOW);
-}
+    if (options.video.mode == ScreenVideoMode::WINDOW)
+    {
+        const int PREVIOUS_ZOOM = options.video.window.zoom;
+        ++options.video.window.zoom;
+        options.video.window.zoom = std::min(options.video.window.zoom, options.video.window.max_zoom);
 
-// Cambia el color del borde
-void Screen::setBorderColor(Color color)
-{
-    border_color_ = color;
+        if (options.video.window.zoom != PREVIOUS_ZOOM)
+        {
+            adjustWindowSize();
+            return true;
+        }
+    }
+
+    return false;
 }
 
 // Cambia el tipo de mezcla
-void Screen::setBlendMode(SDL_BlendMode blendMode)
-{
-    SDL_SetRenderDrawBlendMode(renderer_, blendMode);
-}
+void Screen::setBlendMode(SDL_BlendMode blendMode) { SDL_SetRenderDrawBlendMode(renderer_, blendMode); }
 
 // Actualiza la lógica de la clase
 void Screen::update()
@@ -284,10 +217,7 @@ void Screen::updateShakeEffect()
 }
 
 // Pone la pantalla de color
-void Screen::flash(Color color, int lenght, int delay)
-{
-    flash_effect_ = FlashEffect(true, lenght, delay, color);
-}
+void Screen::flash(Color color, int lenght, int delay) { flash_effect_ = FlashEffect(true, lenght, delay, color); }
 
 // Actualiza y dibuja el efecto de flash en la pantalla
 void Screen::renderFlash()
@@ -300,10 +230,7 @@ void Screen::renderFlash()
 }
 
 // Actualiza el efecto de flash
-void Screen::updateFlash()
-{
-    flash_effect_.update();
-}
+void Screen::updateFlash() { flash_effect_.update(); }
 
 // Atenua la pantalla
 void Screen::renderAttenuate()
@@ -346,28 +273,13 @@ void Screen::renderShake()
 void Screen::toggleShaders()
 {
     options.video.shaders = !options.video.shaders;
-    setVideoMode(options.video.mode);
-    const std::string value = options.video.shaders ? "on" : "off";
-    Notifier::get()->showText({"Shaders " + value});
 }
 
 // Activa / desactiva la información de debug
-void Screen::toggleDebugInfo()
-{
-    show_info_ = !show_info_;
-}
+void Screen::toggleDebugInfo() { show_debug_info_ = !show_debug_info_; }
 
 // Atenua la pantalla
-void Screen::attenuate(bool value)
-{
-    attenuate_effect_ = value;
-}
-
-// Obtiene el puntero al renderizador
-SDL_Renderer *Screen::getRenderer()
-{
-    return renderer_;
-}
+void Screen::attenuate(bool value) { attenuate_effect_ = value; }
 
 // Calcula los frames por segundo
 void Screen::updateFPS()
@@ -383,7 +295,7 @@ void Screen::updateFPS()
 // Muestra información por pantalla
 void Screen::renderInfo()
 {
-    if (show_info_)
+    if (show_debug_info_)
     {
         // FPS
         const std::string fpstext = std::to_string(fps_) + " FPS";
@@ -400,38 +312,84 @@ void Screen::renderInfo()
     }
 }
 
-// Calcula la nueva posición de la ventana a partir de la antigua al cambiarla de tamaño
-SDL_Point Screen::getNewPosition()
+// Carga el contenido del archivo GLSL
+void Screen::loadShaders()
 {
-    // Obtiene la posición actual de la ventana
-    SDL_Point current_position;
-    SDL_GetWindowPosition(window_, &current_position.x, &current_position.y);
+    const std::string GLSL_FILE = param.game.game_area.rect.h == 256 ? "crtpi_256.glsl" : "crtpi_240.glsl";
+    std::ifstream f(Asset::get()->get(GLSL_FILE).c_str());
+    shaderSource = std::string((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
+}
 
-    // Obtiene las dimensiones actuales de la ventana
-    int current_width, current_height;
-    SDL_GetWindowSize(window_, &current_width, &current_height);
+// Inicializa los shaders
+void Screen::initShaders()
+{
+    if (shaderSource.empty())
+    {
+        loadShaders();
+    }
+    shader::init(window_, game_canvas_, shaderSource.c_str());
+}
 
-    // Obtiene las dimesiones que tendrá la ventana
-    const int new_width = param.game.width * options.video.window.size;
-    const int new_height = param.game.height * options.video.window.size;
+// Calcula el tamaño de la ventana
+void Screen::adjustWindowSize()
+{
+    options.video.window.max_zoom = getMaxZoom();
 
-    // Obtiene el centro de la ventana actual
-    SDL_Point center;
-    center.x = current_position.x + current_width / 2;
-    center.y = current_position.y + current_height / 2;
+    // Establece el nuevo tamaño
+    if (options.video.mode == ScreenVideoMode::WINDOW)
+    {
+        const int WIDTH = param.game.width * options.video.window.zoom;
+        const int HEIGHT = param.game.height * options.video.window.zoom;
 
-    // Calcula la nueva posición a partir del centro y las nuevas diemsiones
-    SDL_Point new_pos;
-    new_pos.x = center.x - new_width / 2;
-    new_pos.y = center.y - new_height / 2;
+        int old_width, old_height;
+        SDL_GetWindowSize(window_, &old_width, &old_height);
 
-    // Obtiene las dimensiones del escritorio
+        int old_pos_x, old_pos_y;
+        SDL_GetWindowPosition(window_, &old_pos_x, &old_pos_y);
+
+        const int NEW_POS_X = old_pos_x + (old_width - WIDTH) / 2;
+        const int NEW_POS_Y = old_pos_y + (old_height - HEIGHT) / 2;
+
+        SDL_Rect viewport = {0, 0, WIDTH, HEIGHT};
+        SDL_RenderSetViewport(renderer_, &viewport);
+
+        SDL_SetWindowPosition(window_, std::max(NEW_POS_X, WINDOWS_DECORATIONS_), std::max(NEW_POS_Y, 0));
+        SDL_SetWindowSize(window_, WIDTH, HEIGHT);
+
+        initShaders();
+    }
+}
+
+// Ajusta el tamaño lógico del renderizador
+void Screen::adjustRenderLogicalSize() { SDL_RenderSetLogicalSize(renderer_, param.game.width, param.game.height); }
+
+// Obtiene el tamaño máximo de zoom posible para la ventana
+int Screen::getMaxZoom()
+{
+    // Obtiene información sobre la pantalla
     SDL_DisplayMode DM;
     SDL_GetCurrentDisplayMode(0, &DM);
 
-    // Evita que la ventana quede fuera del escritorio
-    new_pos.x = std::clamp(new_pos.x, 30, DM.w - new_width);
-    new_pos.y = std::clamp(new_pos.y, 30, DM.h - new_height);
+    // Calcula el máximo factor de zoom que se puede aplicar a la pantalla
+    const int MAX_ZOOM = std::min(DM.w / param.game.width, (DM.h - WINDOWS_DECORATIONS_) / param.game.height);
 
-    return new_pos;
+    // Normaliza los valores de zoom
+    options.video.window.zoom = std::min(options.video.window.zoom, MAX_ZOOM);
+
+    return MAX_ZOOM;
+}
+
+// Renderiza todos los overlays y efectos
+void Screen::renderOverlays()
+{
+    // Actualiza el contador de FPS
+    ++fps_counter_;
+
+    // Dibuja efectos y elementos sobre el game_canvas_
+    renderShake();
+    renderFlash();
+    renderAttenuate();
+    OnScreenHelp::get()->render();
+    renderInfo();
+    Notifier::get()->render();
 }

source/screen.h

@@ -8,6 +8,7 @@
 #include <string>				// Para string
 #include "param.h"				// Para Param, ParamGame, param
 #include "utils.h"				// Para Color
+#include "options.h"
 
 enum class ScreenFilter : int
 {
@@ -15,16 +16,19 @@ enum class ScreenFilter : int
 	LINEAL = 1,
 };
 
-enum class ScreenVideoMode : int
+enum class ScreenVideoMode : Uint32
 {
 	WINDOW = 0,
-	FULLSCREEN = 1,
+	FULLSCREEN = SDL_WINDOW_FULLSCREEN_DESKTOP,
 };
 
 class Screen
 {
 private:
-	// [SINGLETON] Objeto screen privado para Don Melitón
+	// Constantes
+	static constexpr int WINDOWS_DECORATIONS_ = 35;
+
+	// [SINGLETON] Objeto privado
 	static Screen *screen_;
 
 	// Objetos y punteros
@@ -35,16 +39,17 @@ private:
 	// Variables
 	SDL_Rect src_rect_;				// Coordenadas de donde va a pillar la textura del juego para dibujarla
 	SDL_Rect dst_rect_;				// Coordenadas donde se va a dibujar la textura del juego sobre la pantalla o ventana
-	Color border_color_ = Color();	// Color del borde añadido a la textura de juego para rellenar la pantalla
 	bool attenuate_effect_ = false; // Indica si la pantalla ha de estar atenuada
 	Uint32 fps_ticks_ = 0;			// Ticks para contar los frames por segundo
 	int fps_counter_ = 0;			// Contador de frames por segundo
 	int fps_ = 0;					// Frames calculados en el último segundo
 	std::string info_resolution_;	// Texto con la informacion de la pantalla
+	std::string shaderSource;		// Almacenar el contenido del archivo GLSL
+
 #ifdef DEBUG
-	bool show_info_ = false; // Indica si ha de mostrar/ocultar la información de la pantalla
+	bool show_debug_info_ = false; // Indica si ha de mostrar/ocultar la información de la pantalla
 #else
-	bool show_info_ = false; // Indica si ha de mostrar/ocultar la información de la pantalla
+	bool show_debug_info_ = false; // Indica si ha de mostrar/ocultar la información de la pantalla
 #endif
 
 	struct FlashEffect
@@ -107,16 +112,26 @@ private:
 	// Muestra información por pantalla
 	void renderInfo();
 
-	// 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
+	// Carga el contenido del archivo GLSL
+	void loadShaders();
+
+	// Inicializa los shaders
+	void initShaders();
+
+	// Calcula el tamaño de la ventana
+	void adjustWindowSize();
+
+	// Ajusta el tamaño lógico del renderizador
+	void adjustRenderLogicalSize();
+
+	// Obtiene el tamaño máximo de zoom posible para la ventana
+	int getMaxZoom();
+
+	// Renderiza todos los overlays y efectos
+	void renderOverlays();
 
 	// Constructor
 	Screen(SDL_Window *window, SDL_Renderer *renderer);
@@ -125,13 +140,13 @@ private:
 	~Screen();
 
 public:
-	// [SINGLETON] Crearemos el objeto screen con esta función estática
+	// [SINGLETON] Crearemos el objeto con esta función estática
 	static void init(SDL_Window *window, SDL_Renderer *renderer);
 
-	// [SINGLETON] Destruiremos el objeto screen con esta función estática
+	// [SINGLETON] Destruiremos el objeto con esta función estática
 	static void destroy();
 
-	// [SINGLETON] Con este método obtenemos el objeto screen y podemos trabajar con él
+	// [SINGLETON] Con este método obtenemos el objeto y podemos trabajar con él
 	static Screen *get();
 
 	// Actualiza la lógica de la clase
@@ -147,22 +162,19 @@ public:
 	void render();
 
 	// Establece el modo de video
-	void setVideoMode(ScreenVideoMode video_mode);
+	void setVideoMode(ScreenVideoMode video_mode = options.video.mode);
 
 	// Cambia entre pantalla completa y ventana
 	void toggleVideoMode();
 
 	// Cambia el tamaño de la ventana
-	void setWindowSize(int size);
+	void setWindowZoom(int size);
 
 	// Reduce el tamaño de la ventana
-	void decWindowSize();
+	bool decWindowZoom();
 
 	// Aumenta el tamaño de la ventana
-	void incWindowSize();
-
-	// Cambia el color del borde
-	void setBorderColor(Color color);
+	bool incWindowZoom();
 
 	// Cambia el tipo de mezcla
 	void setBlendMode(SDL_BlendMode blend_mode);
@@ -182,6 +194,12 @@ public:
 	// Atenua la pantalla
 	void attenuate(bool value);
 
-	// Obtiene el puntero al renderizador
-	SDL_Renderer *getRenderer();
+	// Getters
+	SDL_Renderer *getRenderer() { return renderer_; }
+
+	// Muestra la ventana
+	void show() { SDL_ShowWindow(window_); }
+
+	// Oculta la ventana
+	void hide() { SDL_HideWindow(window_); }
 };

source/smart_sprite.cpp

@@ -1,10 +1,5 @@
 #include "smart_sprite.h"
 #include "moving_sprite.h" // Para MovingSprite
-class Texture;			   // lines 2-2
-
-// Constructor
-SmartSprite::SmartSprite(std::shared_ptr<Texture> texture)
-	: AnimatedSprite(texture) {}
 
 // Actualiza la posición y comprueba si ha llegado a su destino
 void SmartSprite::update()
@@ -17,22 +12,13 @@ void SmartSprite::update()
 	}
 }
 
-// Establece el valor de la variable
-void SmartSprite::setFinishedCounter(int value)
+// Dibuja el sprite
+void SmartSprite::render()
 {
-	finished_counter_ = value;
-}
-
-// Establece el valor de la variable
-void SmartSprite::setDestX(int x)
-{
-	dest_x_ = x;
-}
-
-// Establece el valor de la variable
-void SmartSprite::setDestY(int y)
-{
-	dest_y_ = y;
+	if (enabled_)
+	{
+		MovingSprite::render();
+	}
 }
 
 // Comprueba el movimiento
@@ -115,21 +101,3 @@ void SmartSprite::checkFinished()
 		}
 	}
 }
-
-// Obtiene el valor de la variable
-bool SmartSprite::isOnDestination() const
-{
-	return on_destination_;
-}
-
-// Obtiene el valor de la variable
-bool SmartSprite::hasFinished() const
-{
-	return finished_;
-}
-
-// Habilita el objeto
-void SmartSprite::setEnabled(bool value)
-{
-	enabled_ = value;
-}

source/smart_sprite.h

@@ -24,35 +24,27 @@ private:
 
 public:
 	// Constructor
-	explicit SmartSprite(std::shared_ptr<Texture> texture);
+	explicit SmartSprite(std::shared_ptr<Texture> texture)
+		: AnimatedSprite(texture) {}
 
 	// Destructor
-	~SmartSprite() = default;
+	~SmartSprite() override = default;
 
 	// Actualiza la posición y comprueba si ha llegado a su destino
 	void update() override;
 
-	// Establece el valor de la variable
-	void setFinishedCounter(int value);
+	// Dibuja el sprite
+	void render() override;
 
-	// Establece el valor de la variable
-	void setDestX(int x);
+	// Getters
+	int getDestX() const { return dest_x_; }
+	int getDestY() const { return dest_y_; }
+	bool isOnDestination() const { return on_destination_; }
+	bool hasFinished() const { return finished_; }
 
-	// Establece el valor de la variable
-	void setDestY(int y);
-
-	// Obtiene el valor de la variable
-	int getDestX() const;
-
-	// Obtiene el valor de la variable
-	int getDestY() const;
-
-	// Obtiene el valor de la variable
-	bool isOnDestination() const;
-
-	// Obtiene el valor de la variable
-	bool hasFinished() const;
-
-	// Habilita el objeto
-	void setEnabled(bool value);
+	// Setters
+	void setFinishedCounter(int value) { finished_counter_ = value; }
+	void setDestX(int x) { dest_x_ = x; }
+	void setDestY(int y) { dest_y_ = y; }
+	void setEnabled(bool value) { enabled_ = value; }
 };

source/tabe.cpp

@@ -1,13 +1,12 @@
 // IWYU pragma: no_include <bits/std_abs.h>
 #include "tabe.h"
 #include <SDL2/SDL_render.h> // Para SDL_FLIP_HORIZONTAL, SDL_FLIP_NONE
-#include <SDL2/SDL.h>
-#include <stdlib.h>     // Para rand, abs
-#include <algorithm>    // Para max
-#include "jail_audio.h" // Para JA_PlaySound
-#include "param.h"      // Para Param, ParamGame, param
-#include "resource.h"   // Para Resource
-#include "utils.h"      // Para Zone
+#include <stdlib.h>          // Para rand, abs
+#include <algorithm>         // Para max
+#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()

source/tabe.h

@@ -1,7 +1,9 @@
 #pragma once
 
 #include <SDL2/SDL_rect.h>   // Para SDL_Rect
-#include <SDL2/SDL.h>
+#include <SDL2/SDL_stdinc.h> // Para Uint32
+#include <SDL2/SDL_timer.h>  // Para SDL_GetTicks
+#include <stdlib.h>          // Para rand
 #include <memory>            // Para unique_ptr
 #include "animated_sprite.h" // Para AnimatedSprite
 
@@ -28,9 +30,9 @@ struct TabeTimer
 
     // Constructor
     TabeTimer(float minTime, float maxTime)
-        : min_spawn_time(minTime * 60000), max_spawn_time(maxTime * 60000)
+        : min_spawn_time(minTime * 60000), max_spawn_time(maxTime * 60000),
+          current_time(SDL_GetTicks())
     {
-        current_time = SDL_GetTicks();
         reset();
     }
 
@@ -78,20 +80,20 @@ private:
     std::unique_ptr<AnimatedSprite> sprite_; // Sprite con los graficos y animaciones
 
     // Variables
-    float x_ = 0;                      // Posición del objeto
-    float y_ = 0;                      // Posición del objeto
-    float speed_ = 0.0f;               // Velocidad de movimiento del objeto
-    float accel_ = 0.0f;               // Aceleración del objeto
-    int fly_distance_ = 0;             // Distancia de vuelo
-    int waiting_counter_ = 0;          // Tiempo que pasa quieto el objeto
-    bool enabled_ = false;             // Indica si el objeto está activo
-    TabeDirection direction_;          // Dirección del objeto
-    TabeDirection destiny_;            // Destino del objeto
-    TabeState state_ = TabeState::FLY; // Estado
-    int hit_counter_ = 0;              // Contador para el estado HIT
-    int number_of_hits_ = 0;           // Cantidad de disparos que ha recibido
-    bool has_bonus_ = true;            // Indica si el Tabe aun tiene el bonus para soltar
-    TabeTimer timer_;                  // Temporizador para gestionar la aparición del Tabe
+    float x_ = 0;                                          // Posición del objeto
+    float y_ = 0;                                          // Posición del objeto
+    float speed_ = 0.0f;                                   // Velocidad de movimiento del objeto
+    float accel_ = 0.0f;                                   // Aceleración del objeto
+    int fly_distance_ = 0;                                 // Distancia de vuelo
+    int waiting_counter_ = 0;                              // Tiempo que pasa quieto el objeto
+    bool enabled_ = false;                                 // Indica si el objeto está activo
+    TabeDirection direction_ = TabeDirection::TO_THE_LEFT; // Dirección del objeto
+    TabeDirection destiny_ = TabeDirection::TO_THE_LEFT;   // Destino del objeto
+    TabeState state_ = TabeState::FLY;                     // Estado
+    int hit_counter_ = 0;                                  // Contador para el estado HIT
+    int number_of_hits_ = 0;                               // Cantidad de disparos que ha recibido
+    bool has_bonus_ = true;                                // Indica si el Tabe aun tiene el bonus para soltar
+    TabeTimer timer_;                                      // Temporizador para gestionar la aparición del Tabe
 
     // Mueve el objeto
     void move();

source/text.cpp

@@ -275,12 +275,6 @@ int Text::getCharacterSize() const
 	return box_width_;
 }
 
-// Recarga la textura
-void Text::reLoadTexture()
-{
-	sprite_->getTexture()->reLoad();
-}
-
 // Establece si se usa un tamaño fijo de letra
 void Text::setFixedWidth(bool value)
 {

source/text.h

@@ -76,9 +76,6 @@ public:
 	// Devuelve el valor de la variable
 	int getCharacterSize() const;
 
-	// Recarga la textura
-	void reLoadTexture();
-
 	// Establece si se usa un tamaño fijo de letra
 	void setFixedWidth(bool value);
 

source/texture.cpp

@@ -1,4 +1,3 @@
-
 #include "texture.h"
 #include <SDL2/SDL_error.h>	  // Para SDL_GetError
 #include <SDL2/SDL_surface.h> // Para SDL_CreateRGBSurfaceWithFormatFrom
@@ -7,7 +6,7 @@
 #include <stdexcept>		  // Para runtime_error
 #include <string>			  // Para char_traits, operator<<, operator+
 #include <vector>			  // Para vector
-#include "gif.c"			  // Para LoadGif, LoadPalette
+#include "gif.h"			  // Para LoadGif, LoadPalette
 #include "stb_image.h"		  // Para stbi_image_free, stbi_load, STBI_rgb_a...
 #include "utils.h"			  // Para getFileName, printWithDots
 
@@ -276,9 +275,10 @@ std::shared_ptr<Surface> Texture::loadSurface(const std::string &file_path)
 	// Cerrar el archivo (automáticamente manejado por std::ifstream)
 	file.close();
 
-	// Llamar a la función LoadGif
+	// Crear un objeto Gif y llamar a la función LoadGif
+	Gif gif;
 	Uint16 w, h;
-	Uint8 *rawPixels = LoadGif(buffer.data(), &w, &h);
+	Uint8 *rawPixels = gif.LoadGif(buffer.data(), &w, &h);
 	if (!rawPixels)
 	{
 		return nullptr;
@@ -348,15 +348,16 @@ std::vector<Uint32> Texture::loadPaletteFromFile(const std::string &file_path)
 		throw std::runtime_error("Error al leer el fichero: " + getFileName(file_path));
 	}
 
-	const auto pal = LoadPalette(buffer.data());
-	if (!pal)
+	Gif gif;
+	const auto *PAL = gif.LoadPalette(buffer.data());
+	if (!PAL)
 	{
 		return palette;
 	}
 
 	for (int i = 0; i < 256; ++i)
 	{
-		palette.push_back((pal[i] << 8) + 255);
+		palette.push_back((PAL[i] << 8) + 255);
 	}
 
 	return palette;
@@ -380,7 +381,4 @@ void Texture::setPalette(int palette)
 }
 
 // Obtiene el renderizador
-SDL_Renderer *Texture::getRenderer()
-{
-	return renderer_;
-}
+SDL_Renderer *Texture::getRenderer() { return renderer_; }

source/tiled_bg.cpp

@@ -11,9 +11,6 @@
 TiledBG::TiledBG(SDL_Rect pos, TiledBGMode mode)
     : renderer_(Screen::get()->getRenderer()),
       pos_(pos),
-      // Coloca la ventana que recorre el mosaico de fondo de manera que coincida
-      // con el mosaico que hay pintado en el titulo al iniciar
-      window_({128, 96, pos_.w, pos_.h}),
       mode_(mode == TiledBGMode::RANDOM ? static_cast<TiledBGMode>(rand() % 2) : mode)
 {
     // Crea la textura para el mosaico de fondo
@@ -22,6 +19,24 @@ TiledBG::TiledBG(SDL_Rect pos, TiledBGMode mode)
     // Rellena la textura con el contenido
     fillTexture();
 
+    // Inicializa variables
+    switch (mode_)
+    {
+    case TiledBGMode::STATIC:
+        window_ = {0, 0, pos_.w, pos_.h};
+        speed_ = 0.0f;
+        break;
+    case TiledBGMode::DIAGONAL:
+        window_ = {0, 0, pos_.w, pos_.h};
+        break;
+    case TiledBGMode::CIRCLE:
+        window_ = {128, 128, pos_.w, pos_.h};
+        break;
+    default:
+        window_ = {0, 0, pos_.w, pos_.h};
+        break;
+    }
+
     // Inicializa los valores del vector con los valores del seno
     for (int i = 0; i < 360; ++i)
     {
@@ -72,19 +87,26 @@ void TiledBG::render()
 // Actualiza la lógica de la clase
 void TiledBG::update()
 {
+    updateDesp();
+    updateStop();
+
     switch (mode_)
     {
     case TiledBGMode::DIAGONAL:
-    { // El tileado de fondo se desplaza en diagonal
-        ++window_.x %= TILE_WIDTH_;
-        ++window_.y %= TILE_HEIGHT_;
+    {
+        // El tileado de fondo se desplaza en diagonal
+        window_.x = static_cast<int>(desp_) % TILE_WIDTH_;
+        window_.y = static_cast<int>(desp_) % TILE_HEIGHT_;
+
         break;
     }
     case TiledBGMode::CIRCLE:
-    { // El tileado de fondo se desplaza en circulo
-        ++counter_ %= 360;
-        window_.x = 128 + (int(sin_[(counter_ + 270) % 360] * 128));
-        window_.y = 96 + (int(sin_[(360 - counter_) % 360] * 96));
+    {
+        // El tileado de fondo se desplaza en circulo
+        const int INDEX = static_cast<int>(desp_) % 360;
+
+        window_.x = 128 + (static_cast<int>(sin_[(INDEX + 270) % 360] * 128));
+        window_.y = 128 + (static_cast<int>(sin_[(360 - INDEX) % 360] * 96));
         break;
     }
     default:
@@ -92,8 +114,30 @@ void TiledBG::update()
     }
 }
 
-// Recarga las texturas
-void TiledBG::reLoad()
+// Detiene el desplazamiento de forma ordenada
+void TiledBG::updateStop()
 {
-    fillTexture();
+    if (stopping_)
+    {
+        const int UMBRAL = 20 * speed_; // Ajusta este valor según la precisión deseada
+
+        // Desacelerar si estamos cerca de completar el ciclo (ventana a punto de regresar a 0)
+        if (window_.x >= TILE_WIDTH_ - UMBRAL)
+        {
+            speed_ /= 1.05f; // Reduce gradualmente la velocidad
+
+            // Asegura que no baje demasiado
+            if (speed_ < 0.1f)
+            {
+                speed_ = 0.1f;
+            }
+        }
+
+        // Si estamos en 0, detener
+        if (window_.x == 0)
+        {
+            speed_ = 0.0f;
+            stopping_ = false; // Desactivamos el estado de "stopping"
+        }
+    }
 }

source/tiled_bg.h

@@ -2,6 +2,7 @@
 
 #include <SDL2/SDL_rect.h>   // Para SDL_Rect
 #include <SDL2/SDL_render.h> // Para SDL_Renderer, SDL_Texture
+#include "utils.h"
 
 // Modos de funcionamiento para el tileado de fondo
 enum class TiledBGMode : int
@@ -31,15 +32,23 @@ private:
     SDL_Texture *canvas_;    // Textura donde dibujar el fondo formado por tiles
 
     // Variables
-    SDL_Rect pos_;     // Posición y tamaño del mosaico
-    SDL_Rect window_;  // Ventana visible para la textura de fondo del titulo
-    int counter_ = 0;  // Contador
-    TiledBGMode mode_; // Tipo de movimiento del mosaico
-    double sin_[360];  // Vector con los valores del seno precalculados
+    SDL_Rect pos_;          // Posición y tamaño del mosaico
+    SDL_Rect window_;       // Ventana visible para la textura de fondo del titulo
+    TiledBGMode mode_;      // Tipo de movimiento del mosaico
+    double sin_[360];       // Vector con los valores del seno precalculados
+    float desp_ = 0.0f;     // Desplazamiento aplicado
+    float speed_ = 1.0f;    // Incremento que se añade al desplazamiento a cada bucle
+    bool stopping_ = false; // Indica si se está deteniendo
 
     // Rellena la textura con el contenido
     void fillTexture();
 
+    // Actualiza el desplazamiento
+    void updateDesp() { desp_ += speed_; }
+
+    // Detiene el desplazamiento de forma ordenada
+    void updateStop();
+
 public:
     // Constructor
     TiledBG(SDL_Rect pos, TiledBGMode mode);
@@ -53,6 +62,15 @@ public:
     // Actualiza la lógica de la clase
     void update();
 
-    // Recarga las texturas
-    void reLoad();
+    // Establece la velocidad
+    void setSpeed(float speed) { speed_ = speed; }
+
+    // Detiene el desplazamiento de forma ordenada
+    void stopGracefully() { stopping_ = true; }
+
+    // Cambia el color de la textura
+    void setColor(Color color) { SDL_SetTextureColorMod(canvas_, color.r, color.g, color.b); }
+
+    // Indica si está parado
+    bool isStopped() const { return speed_ == 0.0f; }
 };

source/title.cpp

@@ -12,7 +12,7 @@
 #include "input.h"			  // Para Input, InputType, INPUT_DO_NOT_ALLOW_R...
 #include "jail_audio.h"		  // Para JA_GetMusicState, JA_FadeOutMusic, JA_...
 #include "lang.h"			  // Para getText
-#include "mouse.h"			  // Para handleEvent
+#include "global_events.h"	  // Para handleEvent
 #include "notifier.h"		  // Para Notifier
 #include "options.h"		  // Para OptionsController, Options, options
 #include "param.h"			  // Para Param, param, ParamGame, ParamTitle
@@ -46,9 +46,9 @@ Title::Title()
 
 	// Asigna valores a otras variables
 	section::options = section::Options::TITLE_1;
-	const bool is_title_to_demo = (section::attract_mode == section::AttractMode::TITLE_TO_DEMO);
-	next_section_ = is_title_to_demo ? section::Name::GAME_DEMO : section::Name::LOGO;
-	section::attract_mode = is_title_to_demo ? section::AttractMode::TITLE_TO_LOGO : section::AttractMode::TITLE_TO_DEMO;
+	const bool IS_TITLE_TO_DEMO = (section::attract_mode == section::AttractMode::TITLE_TO_DEMO);
+	next_section_ = IS_TITLE_TO_DEMO ? section::Name::GAME_DEMO : section::Name::LOGO;
+	section::attract_mode = IS_TITLE_TO_DEMO ? section::AttractMode::TITLE_TO_LOGO : section::AttractMode::TITLE_TO_DEMO;
 }
 
 // Destructor
@@ -61,95 +61,22 @@ Title::~Title()
 // Actualiza las variables del objeto
 void Title::update()
 {
-	constexpr int TICKS_SPEED = 15;
-
-	if (SDL_GetTicks() - ticks_ > TICKS_SPEED)
+	if (SDL_GetTicks() - ticks_ > param.game.speed)
 	{
 		// Actualiza el contador de ticks_
 		ticks_ = SDL_GetTicks();
 
+		// Actualiza el fade
+		updateFade();
+
+		// Actualiza el estado
+		updateState();
+
 		// Actualiza el objeto screen
 		Screen::get()->update();
 
 		// Actualiza las variables de globalInputs
 		globalInputs::update();
-
-		// Comprueba el fundido
-		fade_->update();
-		if (fade_->hasEnded())
-		{
-			if (selection_ == section::Options::TITLE_TIME_OUT)
-			{
-				// El menu ha hecho time out
-				section::name = next_section_;
-			}
-			else
-			{
-				// Se ha pulsado para jugar
-				section::name = section::Name::GAME;
-				section::options = selection_;
-				JA_StopMusic();
-			}
-		}
-
-		// Establece la lógica según el estado
-		switch (state_)
-		{
-		case TitleState::LOGO_ANIMATING:
-		{
-			game_logo_->update();
-			if (game_logo_->hasFinished())
-			{
-				state_ = TitleState::LOGO_FINISHED;
-			}
-			break;
-		}
-		case TitleState::LOGO_FINISHED:
-		{
-			// El contador solo sube si no estamos definiendo botones
-			counter_ = define_buttons_->isEnabled() ? 0 : counter_ + 1;
-
-			// Reproduce la música
-			if ((JA_GetMusicState() == JA_MUSIC_INVALID) || (JA_GetMusicState() == JA_MUSIC_STOPPED))
-			{
-				JA_PlayMusic(Resource::get()->getMusic("title.ogg"));
-			}
-
-			// Actualiza el logo con el título del juego
-			game_logo_->update();
-
-			// Actualiza el mosaico de fondo
-			tiled_bg_->update();
-
-			if (counter_ == param.title.title_duration)
-			{
-				// El menu ha hecho time out
-				fade_->setPostDuration(0);
-				fade_->activate();
-				selection_ = section::Options::TITLE_TIME_OUT;
-			}
-
-			break;
-		}
-		case TitleState::START_HAS_BEEN_PRESSED:
-		{
-			// Actualiza el logo con el título del juego
-			game_logo_->update();
-
-			// Actualiza el mosaico de fondo
-			tiled_bg_->update();
-
-			if (counter_ == 100)
-			{
-				fade_->activate();
-			}
-			++counter_;
-			break;
-		}
-
-		default:
-			break;
-		}
 	}
 }
 
@@ -213,71 +140,51 @@ void Title::render()
 // Comprueba los eventos
 void Title::checkEvents()
 {
-	// Comprueba el input para el resto de objetos
-	define_buttons_->checkEvents();
-
-	// Si define_buttons_ está habilitado, es él quien gestiona los eventos
-	if (!define_buttons_->isEnabled())
+	SDL_Event event;
+	while (SDL_PollEvent(&event))
 	{
-		SDL_Event event;
-		while (SDL_PollEvent(&event))
+		if (event.type == SDL_KEYDOWN && event.key.repeat == 0)
 		{
-			// Evento de salida de la aplicación
-			if (event.type == SDL_QUIT)
+			bool should_reset = false;
+
+			switch (event.key.keysym.sym)
 			{
-				section::name = section::Name::QUIT;
-				section::options = section::Options::QUIT_FROM_EVENT;
+			case SDLK_1: // Redefine los botones del mando #0
+				should_reset = define_buttons_->enable(0);
+				break;
+
+			case SDLK_2: // Redefine los botones del mando #1
+				should_reset = define_buttons_->enable(1);
+				break;
+
+			case SDLK_3: // Intercambia los mandos entre los dos jugadores
+				swapControllers();
+				should_reset = true;
+				break;
+
+			case SDLK_4: // Intercambia la asignación del teclado
+				swapKeyboard();
+				should_reset = true;
+				break;
+
+			case SDLK_5: // Muestra la asignación de mandos y teclado
+				showControllers();
+				should_reset = true;
+				break;
+
+			default:
 				break;
 			}
 
-			// Recarga las texturas
-			else if (event.type == SDL_RENDER_DEVICE_RESET || event.type == SDL_RENDER_TARGETS_RESET)
+			// Resetear el contador si es necesario
+			if (should_reset)
 			{
-				reLoadTextures();
+				resetCounter();
 			}
-
-			else if (event.type == SDL_KEYDOWN && event.key.repeat == 0)
-			{
-				switch (event.key.keysym.sym)
-				{
-				case SDLK_1: // Redefine los botones del mando #0
-				{
-					if (define_buttons_->enable(0))
-						resetCounter();
-					break;
-				}
-				case SDLK_2: // Redefine los botones del mando #1
-				{
-					if (define_buttons_->enable(1))
-						resetCounter();
-					break;
-				}
-				case SDLK_3: // Intercambia los mandos entre los dos jugadores
-				{
-					swapControllers();
-					resetCounter();
-					break;
-				}
-				case SDLK_4: // Intercambia la asignación del teclado
-				{
-					swapKeyboard();
-					resetCounter();
-					break;
-				}
-				case SDLK_5: // Muestra la asignacion de mandos y teclado
-				{
-					showControllers();
-					resetCounter();
-					break;
-				}
-				default:
-					break;
-				}
-			}
-
-			// Comprueba el cursor
-			Mouse::handleEvent(event);
 		}
+
+		globalEvents::check(event);
+		define_buttons_->checkEvents(event);
 	}
 }
 
@@ -350,13 +257,6 @@ void Title::run()
 	}
 }
 
-// Recarga las texturas
-void Title::reLoadTextures()
-{
-	game_logo_->reLoad();
-	tiled_bg_->reLoad();
-}
-
 // Reinicia el contador interno
 void Title::resetCounter() { counter_ = 0; }
 
@@ -375,7 +275,7 @@ void Title::swapKeyboard()
 {
 	swapOptionsKeyboard();
 	std::string text = lang::getText(100) + std::to_string(getPlayerWhoUsesKeyboard()) + ": " + lang::getText(69);
-	Notifier::get()->showText({text});
+	Notifier::get()->show({text});
 }
 
 // Muestra información sobre los controles y los jugadores
@@ -404,5 +304,89 @@ void Title::showControllers()
 	}
 
 	// Muestra la notificación
-	Notifier::get()->showText({text.at(0), text.at(1)});
+	Notifier::get()->show({text.at(0), text.at(1)});
+}
+
+// Actualiza el fade
+void Title::updateFade()
+{
+	fade_->update();
+	if (fade_->hasEnded())
+	{
+		if (selection_ == section::Options::TITLE_TIME_OUT)
+		{
+			// El menu ha hecho time out
+			section::name = next_section_;
+		}
+		else
+		{
+			// Se ha pulsado para jugar
+			section::name = section::Name::GAME;
+			section::options = selection_;
+			JA_StopMusic();
+		}
+	}
+}
+
+// Actualiza el estado
+void Title::updateState()
+{
+	// Establece la lógica según el estado
+	switch (state_)
+	{
+	case TitleState::LOGO_ANIMATING:
+	{
+		game_logo_->update();
+		if (game_logo_->hasFinished())
+		{
+			state_ = TitleState::LOGO_FINISHED;
+		}
+		break;
+	}
+	case TitleState::LOGO_FINISHED:
+	{
+		// El contador solo sube si no estamos definiendo botones
+		counter_ = define_buttons_->isEnabled() ? 0 : counter_ + 1;
+
+		// Reproduce la música
+		if ((JA_GetMusicState() == JA_MUSIC_INVALID) || (JA_GetMusicState() == JA_MUSIC_STOPPED))
+		{
+			JA_PlayMusic(Resource::get()->getMusic("title.ogg"));
+		}
+
+		// Actualiza el logo con el título del juego
+		game_logo_->update();
+
+		// Actualiza el mosaico de fondo
+		tiled_bg_->update();
+
+		if (counter_ == param.title.title_duration)
+		{
+			// El menu ha hecho time out
+			fade_->setPostDuration(0);
+			fade_->activate();
+			selection_ = section::Options::TITLE_TIME_OUT;
+		}
+
+		break;
+	}
+	case TitleState::START_HAS_BEEN_PRESSED:
+	{
+		// Actualiza el logo con el título del juego
+		game_logo_->update();
+
+		// Actualiza el mosaico de fondo
+		tiled_bg_->update();
+
+		if (counter_ == 100)
+		{
+			fade_->activate();
+		}
+		++counter_;
+		break;
+	}
+
+	default:
+		break;
+	}
 }

source/title.h

@@ -72,9 +72,6 @@ private:
 	// Comprueba las entradas
 	void checkInput();
 
-	// Recarga las texturas
-	void reLoadTextures();
-
 	// Reinicia el contador interno
 	void resetCounter();
 
@@ -87,6 +84,12 @@ private:
 	// Muestra información sobre los controles y los jugadores
 	void showControllers();
 
+	// Actualiza el fade
+	void updateFade();
+
+	// Actualiza el estado
+	void updateState();
+
 public:
 	// Constructor
 	Title();

source/utils.cpp

@@ -1,13 +1,15 @@
 #include "utils.h"
 #include <SDL2/SDL_rwops.h> // Para SDL_RWFromFile, SDL_RWclose, SDL_RWread
+#include <stddef.h>         // Para size_t
 #include <algorithm>        // Para min, clamp, find_if_not, find, transform
 #include <cctype>           // Para tolower, isspace
-#include <cmath>            // Para cos, pow, M_PI
+#include <cmath>            // Para pow, sin, M_PI, cos
 #include <compare>          // Para operator<
 #include <filesystem>       // Para path
 #include <iostream>         // Para basic_ostream, cout, basic_ios, endl, ios
 #include <stdexcept>        // Para runtime_error
 #include <string>           // Para basic_string, string, char_traits, opera...
+#include "lang.h"
 
 // Variables
 Overrides overrides = Overrides();
@@ -32,20 +34,20 @@ const Color green_sky_color = Color(0X00, 0X79, 0X6B);
 // Obtiene un color del vector de colores imitando al Coche Fantástico
 Color getColorLikeKnightRider(const std::vector<Color> &colors, int counter_)
 {
-	int cycle_length = colors.size() * 2 - 2;
-	size_t n = counter_ % cycle_length;
+    int cycle_length = colors.size() * 2 - 2;
+    size_t n = counter_ % cycle_length;
 
-	size_t index;
-	if (n < colors.size())
-	{
-		index = n; // Avanza: 0,1,2,3
-	}
-	else
-	{
-		index = 2 * (colors.size() - 1) - n; // Retrocede: 2,1
-	}
+    size_t index;
+    if (n < colors.size())
+    {
+        index = n; // Avanza: 0,1,2,3
+    }
+    else
+    {
+        index = 2 * (colors.size() - 1) - n; // Retrocede: 2,1
+    }
 
-	return colors[index];
+    return colors[index];
 }
 
 // Calcula el cuadrado de la distancia entre dos puntos
@@ -120,7 +122,7 @@ std::string boolToString(bool value)
 // Convierte un valor booleano en una cadena "on" o "off"
 std::string boolToOnOff(bool value)
 {
-    return value ? "on" : "off";
+    return value ? lang::getText(128) : lang::getText(129);
 }
 
 // Convierte una cadena a minusculas
@@ -242,6 +244,54 @@ double easeInOut(double t)
     return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
 }
 
+// Función de suavizado
+double easeInOutExpo(double t)
+{
+    return t == 0 ? 0 : (t == 1 ? 1 : (t < 0.5 ? pow(2, 20 * t - 10) / 2 : (2 - pow(2, -20 * t + 10)) / 2));
+}
+
+// Función de suavizado (easeInElastic)
+double easeInElastic(double t)
+{
+    return t == 0 ? 0 : (t == 1 ? 1 : -pow(2, 10 * t - 10) * sin((t * 10 - 10.75) * (2 * M_PI) / 3));
+}
+
+// Función de suavizado
+double easeOutBounce(double t)
+{
+    if (t < 1 / 2.75)
+    {
+        return 7.5625 * t * t;
+    }
+    else if (t < 2 / 2.75)
+    {
+        t -= 1.5 / 2.75;
+        return 7.5625 * t * t + 0.75;
+    }
+    else if (t < 2.5 / 2.75)
+    {
+        t -= 2.25 / 2.75;
+        return 7.5625 * t * t + 0.9375;
+    }
+    else
+    {
+        t -= 2.625 / 2.75;
+        return 7.5625 * t * t + 0.984375;
+    }
+}
+
+// Función de suavizado
+double easeOutElastic(double t)
+{
+    const double c4 = (2 * M_PI) / 3; // Constante para controlar la elasticidad
+
+    return t == 0
+               ? 0
+               : (t == 1
+                      ? 1
+                      : pow(2, -10 * t) * sin((t * 10 - 0.75) * c4) + 1);
+}
+
 // Comprueba si una vector contiene una cadena
 bool stringInVector(const std::vector<std::string> &vec, const std::string &str)
 {

source/utils.h

@@ -4,6 +4,7 @@
 #include <SDL2/SDL_render.h> // Para SDL_Renderer
 #include <SDL2/SDL_stdinc.h> // Para Uint8
 #include <stdint.h>			 // Para int32_t
+#include <algorithm>		 // Para max, min
 #include <string>			 // Para string
 #include <vector>			 // Para vector
 
@@ -174,6 +175,10 @@ double easeInQuad(double t);
 double easeOutQuad(double t);
 double easeInOutSine(double t);
 double easeInOut(double t);
+double easeInOutExpo(double t);
+double easeOutBounce(double t);
+double easeOutElastic(double t);
+double easeInElastic(double t);
 
 // Comprueba si una vector contiene una cadena
 bool stringInVector(const std::vector<std::string> &vec, const std::string &str);