Demana confirmació per a canviar el idioma amb les tecles ràpides

Demana confirmació per reiniciar

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++")

Makefile

@@ -11,7 +11,7 @@ APP_NAME       := Coffee Crisis Arcade Edition
 RELEASE_FOLDER := ccae_release
 RELEASE_FILE   := $(RELEASE_FOLDER)/$(TARGET_NAME)
 RESOURCE_FILE  := release/coffee.res
-VERSION        := 2025-01-05
+VERSION        := 2025-02-07
 
 # Nombres para los ficheros de lanzamiento
 WINDOWS_RELEASE             := $(TARGET_NAME)-$(VERSION)-win32-x64.zip

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" />
+    <img src="https://php.sustancia.synology.me/images/ccae/ccae_title.png" alt="Títol" width="60%" />
 </p>
 
 ## Controls
@@ -25,7 +25,8 @@ 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" />
+    <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
@@ -43,7 +44,7 @@ El joc està optimitzat per a ser jugat amb un mando de jocs, encara que un dels
 | **F10**     | Reset del joc                               |
 
 <p align="center">
-    <img src="https://php.sustancia.synology.me/images/ccae2.png" alt="Joc" />
+    <img src="https://php.sustancia.synology.me/images/ccae/ccae2.png" alt="Joc" width="50%" />
 </p>
 
 ## Com instal·lar i jugar

data/font/nokia.txt

@@ -1,194 +0,0 @@
-# box width
-10
-# box height
-10
-# 32 espacio ( )
-5
-# 33 !
-4
-# 34 "
-5
-# 35 #
-7
-# 36 $
-7
-# 37 %
-8
-# 38 &
-8
-# 39 '
-3
-# 40 (
-5
-# 41 )
-5
-# 42 *
-7         
-# 43 +
-7
-# 44 ,
-4
-# 45 -
-6
-# 46 .
-4
-# 47 /
-5
-# 48 0
-7
-# 49 1
-5
-# 50 2
-7
-# 51 3
-7
-# 52 4
-7
-# 53 5
-7
-# 54 6
-7
-# 55 7
-7
-# 56 8
-7
-# 57 9
-7
-# 58 :
-4
-# 59 ;
-4
-# 60 <
-6
-# 61 =
-6
-# 62 >
-6
-# 63 ?
-7
-# 64 @
-8
-# 65 A
-7
-# 66 B
-7
-# 67 C
-7
-# 68 D
-7
-# 69 E
-7
-# 70 F
-7
-# 71 G
-7
-# 72 H
-7
-# 73 I
-4
-# 74 J
-6
-# 75 K
-8
-# 76 L
-6
-# 77 M
-9
-# 78 N
-8
-# 79 O
-8
-# 80 P
-7
-# 81 Q
-8
-# 82 R
-7
-# 83 S
-6
-# 84 T
-8
-# 85 U
-7
-# 86 V
-8
-# 87 W
-9
-# 88 X
-8
-# 89 Y
-8
-# 90 Z
-7
-# 91 [
-4
-# 92 \
-5
-# 93 ]
-4
-# 94 ^
-5
-# 95 _
-8
-# 96 `
-4
-# 97 a
-7
-# 98 b
-7
-# 99 c
-6
-# 100 d
-7
-# 101 e
-7
-# 102 f
-5
-# 103 g
-7
-# 104 h
-7
-# 105 i
-4
-# 106 j
-5
-# 107 k
-7
-# 108 l
-4
-# 109 m
-10
-# 110 n
-7
-# 111 o
-7
-# 112 p
-7
-# 113 q
-7
-# 114 r
-6
-# 115 s
-6
-# 116 t
-5
-# 117 u
-7
-# 118 v
-7
-# 119 w
-9
-# 120 x
-7
-# 121 y
-7
-# 122 z
-7
-# 123 { -> ñ
-7
-# 124 | -> ç
-7
-# 125 }
-0
-# 126 ~
-0

data/gfx/item/item_debian.ani

@@ -0,0 +1,9 @@
+frame_width=20
+frame_height=20
+
+[animation]
+name=default
+speed=10
+loop=0
+frames=0,1
+[/animation]

data/gfx/tabe/tabe.ani

@@ -2,8 +2,15 @@ frame_width=32
 frame_height=32
 
 [animation]
-name=default
+name=fly
 speed=2
 loop=0
 frames=0,1
 [/animation]
+
+[animation]
+name=hit
+speed=2
+loop=0
+frames=2,3
+[/animation]

data/lang/ba_BA.txt

@@ -32,7 +32,7 @@ IDIOMA
 [ CANCELAR ]
 
 ## 11 - INSTRUCCIONES
-OBJECTIU
+Objectiu
 
 ## 12 - INSTRUCCIONES
 HAS D'EXPLOTAR
@@ -47,7 +47,7 @@ LA DIFICULTAT AUGMENTA
 A MESURA QUE VAS PUNTUANT
 
 ## 16 - INSTRUCCIONES
-OBJECTES
+Objectes
 
 ## 17 - INSTRUCCIONES
 1.000 PUNTS
@@ -371,4 +371,13 @@ GRAFICS DIBUIXATS PER
 MUSICA COMPOSADA PER
 
 ## 124 - CREDITS
-EFECTES DE SO
+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

data/lang/en_UK.txt

@@ -371,4 +371,13 @@ PIXELART DRAWN BY
 MUSIC COMPOSED BY
 
 ## 124 - CREDITS
-SOUND EFFECTS
+SOUND EFFECTS
+
+## 125 - NOTIFICACIONES
+Press again to reset
+
+## 126 - NOTIFICACIONES
+Press again to change languaje to
+
+## 127 - NOTIFICACIONES
+Language set to

data/lang/es_ES.txt

@@ -371,4 +371,13 @@ GRAFICOS DIBUJADOS POR
 MUSICA COMPUESTA POR
 
 ## 124 - CREDITS
-EFECTOS DE SONIDO
+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

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/balloon_manager.cpp

@@ -321,7 +321,7 @@ int BalloonManager::destroyAllBalloons()
     }
 
     balloon_deploy_counter_ = 300;
-    JA_PlaySound(Resource::get()->getSound("powerball.wav"));
+    JA_PlaySound(Resource::get()->getSound("power_ball_explosion.wav"));
     Screen::get()->flash(flash_color, 3);
     Screen::get()->shake();
 

source/credits.cpp

@@ -68,6 +68,7 @@ Credits::~Credits()
     SDL_DestroyTexture(text_texture_);
     SDL_DestroyTexture(canvas_);
     resetVolume();
+    JA_StopMusic();
 }
 
 // Bucle principal
@@ -477,7 +478,7 @@ void Credits::updateAllFades()
     fade_out_->update();
     if (fade_out_->hasEnded())
     {
-        section::name = section::Name::LOGO;
+        section::name = section::Name::HI_SCORE_TABLE;
     }
 }
 

source/director.cpp

@@ -101,6 +101,7 @@ void Director::init()
 	dbg_init(renderer_);
 	lang::loadFromFile(getLangFile(static_cast<lang::Code>(options.game.language)));
 	Screen::init(window_, renderer_);
+	SDL_ShowCursor(SDL_DISABLE);
 	Resource::init();
 	Input::init(Asset::get()->get("gamecontrollerdb.txt"));
 	bindInputs();
@@ -126,6 +127,10 @@ void Director::close()
 	SDL_DestroyWindow(window_);
 
 	SDL_Quit();
+
+#ifdef ARCADE
+	shutdownSystem(section::options == section::Options::QUIT_WITH_CONTROLLER);
+#endif
 }
 
 // Carga los parametros
@@ -312,12 +317,10 @@ 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);
@@ -335,10 +338,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);
 
@@ -393,16 +394,16 @@ void Director::setFileList()
 	Asset::get()->add(prefix + "/data/sound/bubble4.wav", AssetType::SOUND);
 	Asset::get()->add(prefix + "/data/sound/bullet.wav", AssetType::SOUND);
 	Asset::get()->add(prefix + "/data/sound/clock.wav", AssetType::SOUND);
-	Asset::get()->add(prefix + "/data/sound/coffeeout.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/coffee_out.wav", AssetType::SOUND);
 	Asset::get()->add(prefix + "/data/sound/continue_clock.wav", AssetType::SOUND);
 	Asset::get()->add(prefix + "/data/sound/game_start.wav", AssetType::SOUND);
-	Asset::get()->add(prefix + "/data/sound/hiscore.wav", AssetType::SOUND);
-	Asset::get()->add(prefix + "/data/sound/itemdrop.wav", AssetType::SOUND);
-	Asset::get()->add(prefix + "/data/sound/itempickup.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/hi_score_achieved.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/item_drop.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/item_pickup.wav", AssetType::SOUND);
 	Asset::get()->add(prefix + "/data/sound/logo.wav", AssetType::SOUND);
 	Asset::get()->add(prefix + "/data/sound/notify.wav", AssetType::SOUND);
 	Asset::get()->add(prefix + "/data/sound/player_collision.wav", AssetType::SOUND);
-	Asset::get()->add(prefix + "/data/sound/powerball.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/power_ball_explosion.wav", AssetType::SOUND);
 	Asset::get()->add(prefix + "/data/sound/stage_change.wav", AssetType::SOUND);
 	Asset::get()->add(prefix + "/data/sound/tabe.wav", AssetType::SOUND);
 	Asset::get()->add(prefix + "/data/sound/title.wav", AssetType::SOUND);
@@ -411,6 +412,9 @@ void Director::setFileList()
 	Asset::get()->add(prefix + "/data/sound/voice_no.wav", AssetType::SOUND);
 	Asset::get()->add(prefix + "/data/sound/voice_power_up.wav", AssetType::SOUND);
 	Asset::get()->add(prefix + "/data/sound/walk.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/debian_drop.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/debian_pickup.wav", AssetType::SOUND);
+	Asset::get()->add(prefix + "/data/sound/tabe_hit.wav", AssetType::SOUND);
 
 	// Shaders
 	Asset::get()->add(prefix + "/data/shaders/crtpi_256.glsl", AssetType::DATA);
@@ -470,7 +474,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
@@ -490,6 +499,8 @@ void Director::setFileList()
 		Asset::get()->add(prefix + "/data/gfx/item/item_clock.ani", AssetType::ANIMATION);
 		Asset::get()->add(prefix + "/data/gfx/item/item_coffee.png", AssetType::BITMAP);
 		Asset::get()->add(prefix + "/data/gfx/item/item_coffee.ani", AssetType::ANIMATION);
+		Asset::get()->add(prefix + "/data/gfx/item/item_debian.png", AssetType::BITMAP);
+		Asset::get()->add(prefix + "/data/gfx/item/item_debian.ani", AssetType::ANIMATION);
 		Asset::get()->add(prefix + "/data/gfx/item/item_coffee_machine.png", AssetType::BITMAP);
 		Asset::get()->add(prefix + "/data/gfx/item/item_coffee_machine.ani", AssetType::ANIMATION);
 	}
@@ -527,8 +538,6 @@ void Director::setFileList()
 	// Fuentes de texto
 	Asset::get()->add(prefix + "/data/font/8bithud.png", AssetType::BITMAP);
 	Asset::get()->add(prefix + "/data/font/8bithud.txt", AssetType::FONT);
-	Asset::get()->add(prefix + "/data/font/nokia.png", AssetType::BITMAP);
-	Asset::get()->add(prefix + "/data/font/nokia.txt", AssetType::FONT);
 	Asset::get()->add(prefix + "/data/font/smb2.gif", AssetType::BITMAP);
 	Asset::get()->add(prefix + "/data/font/smb2_palette1.pal", AssetType::PALETTE);
 	Asset::get()->add(prefix + "/data/font/smb2.txt", AssetType::FONT);
@@ -536,6 +545,8 @@ void Director::setFileList()
 	Asset::get()->add(prefix + "/data/font/04b_25.txt", AssetType::FONT);
 	Asset::get()->add(prefix + "/data/font/04b_25_2x.png", AssetType::BITMAP);
 	Asset::get()->add(prefix + "/data/font/04b_25_2x.txt", AssetType::FONT);
+	Asset::get()->add(prefix + "/data/font/04b_25_metal.png", AssetType::BITMAP);
+	Asset::get()->add(prefix + "/data/font/04b_25_grey.png", AssetType::BITMAP);
 
 	// Textos
 	Asset::get()->add(prefix + "/data/lang/es_ES.txt", AssetType::LANG);
@@ -544,7 +555,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
@@ -762,11 +775,6 @@ int Director::run()
 	// Habilita de nuevo los std::cout
 	std::cout.rdbuf(orig_buf);
 #endif
-#ifdef ARCADE
-	// Comprueba si ha de apagar el sistema
-	if (section::options == section::Options::QUIT_WITH_CONTROLLER)
-		shutdownSystem();
-#endif
 
 	return (section::options == section::Options::QUIT_WITH_CONTROLLER) ? 1 : 0;
 }
@@ -794,20 +802,23 @@ std::string Director::getLangFile(lang::Code code)
 
 #ifdef ARCADE
 // Apaga el sistema
-void Director::shutdownSystem()
+void Director::shutdownSystem(bool shouldShutdown)
 {
+	if (shouldShutdown)
+	{
 #ifdef _WIN32
-	// Apaga el sistema en Windows
-	system("shutdown /s /t 0");
+		// Apaga el sistema en Windows
+		system("shutdown /s /t 5");
 #elif __APPLE__
-	// Apaga el sistema en macOS
-	system("sudo shutdown -h now");
+		// Apaga el sistema en macOS
+		system("sudo shutdown -h +0.1");
 #elif __linux__
-	// Apaga el sistema en Linux
-	system("shutdown -h now");
+		// Apaga el sistema en Linux
+		system("sleep 5; shutdown -h now");
 #else
 // Sistema operativo no compatible
 #error "Sistema operativo no soportado"
 #endif
+	}
 }
 #endif // ARCADE

source/director.h

@@ -74,7 +74,7 @@ private:
 	std::string getLangFile(lang::Code code);
 #ifdef ARCADE
 	// Apaga el sistema
-	void shutdownSystem();
+	void shutdownSystem(bool shouldShutdown);
 #endif
 
 	// Inicializa todo

source/enter_name.cpp

@@ -1,93 +1,163 @@
 #include "enter_name.h"
+#include "utils.h"
 #include <stddef.h>  // Para size_t
 #include <algorithm> // Para max, min
+#include <cassert>   // Para assert
+#include <iostream>
 
 // Constructor
 EnterName::EnterName()
-{
-    init();
-}
+    : character_list_(" ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-+-*/=?¿<>!\"#$%&/()") {}
 
 // Inicializa el objeto
-void EnterName::init()
+void EnterName::init(const std::string &name)
 {
-    // Obtiene el puntero al nombre
-    name_ = "A";
+    // No se pasa ningún nombre
+    if (name.empty())
+    {
+        name_ = "A";
+        position_ = 0;
+        position_overflow_ = false;
+    }
+    // Se pasa un nombre
+    else
+    {
+        name_ = name;
+        position_ = name_.length();
+        position_overflow_ = position_ >= MAX_NAME_LENGHT ? true : false;
+    }
 
-    // Inicia la lista de caracteres permitidos
-    character_list_ = " ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-+-*/=?¿<>!\"#$%&/()";
-    position_ = 0;
-    num_characters_ = static_cast<int>(character_list_.size());
-
-    // Pone la lista de indices para que refleje el nombre
-    updateCharacterIndex();
-
-    // Actualiza el nombre para que ocupe 8 espacios
-    updateName();
+    // Inicializa el vector de indices con el nombre y espacios
+    initCharacterIndex(name_);
 }
 
 // Incrementa la posición
 void EnterName::incPosition()
 {
-    position_++;
-    position_ = std::min(position_, NAME_LENGHT - 1);
-    checkIfPositionHasBeenUsed();
+    if (position_overflow_)
+    {
+        // Si ya estamos en overflow, no incrementamos más.
+        return;
+    }
+
+    ++position_;
+
+    if (position_ >= MAX_NAME_LENGHT)
+    {
+        position_ = MAX_NAME_LENGHT; // Mantenemos en el índice máximo válido.
+        position_overflow_ = true;   // Activamos el flag de overflow.
+    }
+    else
+    {
+        // Copiamos el índice del carácter anterior si es posible.
+        if (position_ > 0 && position_ < MAX_NAME_LENGHT)
+        {
+            character_index_[position_] = character_index_[position_ - 1];
+        }
+        else
+        {
+            // Si position_ es 0, inicializamos el carácter actual.
+            character_index_[position_] = 0;
+        }
+    }
+
+    updateNameFromCharacterIndex();
 }
 
 // Decrementa la posición
 void EnterName::decPosition()
 {
-    --position_;
-    position_ = std::max(position_, 0);
+    if (position_overflow_)
+    {
+        // Si estaba en overflow, lo desactivamos y mantenemos position_ en el máximo.
+        position_overflow_ = false;
+        position_ = MAX_NAME_LENGHT - 1;
+    }
+    else
+    {
+        if (position_ > 0)
+        {
+            --position_;
+
+            // Limpiamos el carácter siguiente si el índice es válido.
+            if (position_ + 1 < MAX_NAME_LENGHT)
+            {
+                character_index_[position_ + 1] = 0;
+            }
+        }
+        else
+        {
+            // Si position_ es 0, aseguramos que no vaya a ser negativo y limpiamos el carácter actual.
+            position_ = 0;
+            character_index_[position_] = 0;
+        }
+
+        // Si position_ es menor que NAME_LENGHT, aseguramos que el overflow esté desactivado.
+        if (position_ < MAX_NAME_LENGHT)
+        {
+            position_overflow_ = false;
+        }
+    }
+
+    updateNameFromCharacterIndex();
 }
 
 // Incrementa el índice
 void EnterName::incIndex()
 {
+    if (position_overflow_)
+    {
+        return;
+    }
+
     ++character_index_[position_];
-    if (character_index_[position_] >= num_characters_)
+    if (character_index_[position_] >= static_cast<int>(character_list_.size()))
     {
         character_index_[position_] = 0;
     }
-    updateName();
+    updateNameFromCharacterIndex();
 }
 
 // Decrementa el índice
 void EnterName::decIndex()
 {
+    if (position_overflow_)
+    {
+        return;
+    }
+
     --character_index_[position_];
     if (character_index_[position_] < 0)
     {
-        character_index_[position_] = num_characters_ - 1;
+        character_index_[position_] = character_list_.size() - 1;
     }
-    updateName();
+    updateNameFromCharacterIndex();
 }
 
 // Actualiza el nombre a partir de la lista de índices
-void EnterName::updateName()
+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]]);
     }
+    name_ = trim(name_);
 }
 
 // Actualiza la variable
-void EnterName::updateCharacterIndex()
+void EnterName::initCharacterIndex(const std::string &name)
 {
-    // Rellena de espacios y marca como no usados
-    for (size_t i = 0; i < NAME_LENGHT; ++i)
+    // Rellena de espacios
+    for (size_t i = 0; i < MAX_NAME_LENGHT; ++i)
     {
         character_index_[i] = 0;
-        position_has_been_used_[i] = false;
     }
 
     // Coloca los índices en función de los caracteres que forman el nombre
-    for (size_t i = 0; i < name_.size(); ++i)
+    for (size_t i = 0; i < name.substr(0, MAX_NAME_LENGHT).size(); ++i)
     {
-        character_index_[i] = findIndex(name_.at(i));
-        position_has_been_used_[i] = true;
+        character_index_[i] = findIndex(name.at(i));
     }
 }
 
@@ -95,31 +165,11 @@ void EnterName::updateCharacterIndex()
 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;
-}
-
-// Obtiene el nombre
-std::string EnterName::getName() const
-{
-    return name_;
-}
-
-// Obtiene la posición que se está editando
-int EnterName::getPosition() const
-{
-    return position_;
-}
-
-// Comprueba la posición y copia el caracter si es necesario
-void EnterName::checkIfPositionHasBeenUsed()
-{
-    auto used = position_has_been_used_[position_];
-
-    if (!used && position_ > 0)
-        character_index_[position_] = character_index_[position_ - 1];
-
-    position_has_been_used_[position_] = true;
-    updateName();
 }

source/enter_name.h

@@ -1,8 +1,9 @@
 #pragma once
 
 #include <string>
+#include "utils.h"
 
-constexpr int NAME_LENGHT = 6;
+constexpr int MAX_NAME_LENGHT = 6;
 
 /*
     Un array, "characterList", contiene la lista de caracteres
@@ -16,25 +17,21 @@ 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_;                             // Posición a editar del nombre
-    int num_characters_;                       // Cantidad de caracteres de la lista de caracteres
-    int character_index_[NAME_LENGHT];         // Indice de la lista para cada uno de los caracteres que forman el nombre
-    bool position_has_been_used_[NAME_LENGHT]; // Indica si en esa posición se ha puesto ya alguna letra. Se utiliza para replicar la letra anterior la primera vez
+    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_[MAX_NAME_LENGHT]; // 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 updateName();
+    void updateNameFromCharacterIndex();
 
     // Actualiza la variable
-    void updateCharacterIndex();
+    void initCharacterIndex(const std::string &name);
 
     // Encuentra el indice de un caracter en "characterList"
     int findIndex(char character) const;
 
-    // Comprueba la posición y copia el caracter si es necesario
-    void checkIfPositionHasBeenUsed();
-
 public:
     // Constructor
     EnterName();
@@ -43,7 +40,7 @@ public:
     ~EnterName() = default;
 
     // Inicializa el objeto
-    void init();
+    void init(const std::string &name = "");
 
     // Incrementa la posición
     void incPosition();
@@ -57,9 +54,9 @@ public:
     // Decrementa el índice
     void decIndex();
 
-    // Obtiene el nombre
-    std::string getName() const;
-
-    // Obtiene la posición que se está editando
-    int getPosition() const;
+    // Getters
+    std::string getFinalName() const { return trim(name_.substr(0, position_)); }
+    std::string getCurrentName() const { return trim(name_); }
+    int getPosition() const { return position_; }
+    bool getPositionOverflow() const { return position_overflow_; }
 };

source/game.cpp

@@ -140,6 +140,7 @@ void Game::setResources()
 		game_text_textures_.emplace_back(Resource::get()->getTexture("game_text_powerup"));
 		game_text_textures_.emplace_back(Resource::get()->getTexture("game_text_one_hit"));
 		game_text_textures_.emplace_back(Resource::get()->getTexture("game_text_stop"));
+		game_text_textures_.emplace_back(Resource::get()->getTexture("game_text_100000_points"));
 	}
 
 	// Texturas - Items
@@ -149,6 +150,7 @@ void Game::setResources()
 		item_textures_.emplace_back(Resource::get()->getTexture("item_points3_pacmar.png"));
 		item_textures_.emplace_back(Resource::get()->getTexture("item_clock.png"));
 		item_textures_.emplace_back(Resource::get()->getTexture("item_coffee.png"));
+		item_textures_.emplace_back(Resource::get()->getTexture("item_debian.png"));
 		item_textures_.emplace_back(Resource::get()->getTexture("item_coffee_machine.png"));
 	}
 
@@ -181,6 +183,7 @@ void Game::setResources()
 		item_animations_.emplace_back(Resource::get()->getAnimation("item_points3_pacmar.ani"));
 		item_animations_.emplace_back(Resource::get()->getAnimation("item_clock.ani"));
 		item_animations_.emplace_back(Resource::get()->getAnimation("item_coffee.ani"));
+		item_animations_.emplace_back(Resource::get()->getAnimation("item_debian.ani"));
 		item_animations_.emplace_back(Resource::get()->getAnimation("item_coffee_machine.ani"));
 	}
 }
@@ -202,7 +205,7 @@ void Game::updateHiScore()
 			if (hi_score_achieved_ == false)
 			{
 				hi_score_achieved_ = true;
-				JA_PlaySound(Resource::get()->getSound("hiscore.wav"));
+				JA_PlaySound(Resource::get()->getSound("hi_score_achieved.wav"));
 			}
 		}
 	}
@@ -280,6 +283,13 @@ void Game::updateStage()
 				createMessage(paths, text->writeToTexture(caption, 1, -4));
 			}
 		}
+
+		// Modifica el color de fondo al llegar a la Fase 10
+		if (Stage::number == 9)
+		{
+			background_->setColor(Color(0xdd, 0x19, 0x1d).darken());
+			background_->setAlpha(96);
+		}
 	}
 }
 
@@ -297,7 +307,7 @@ void Game::updateGameStateGameOver()
 	updateSmartSprites();
 	updatePathSprites();
 	updateTimeStopped();
-	checkBulletBalloonCollision();
+	checkBulletCollision();
 	cleanVectors();
 
 	if (game_over_counter_ > 0)
@@ -362,6 +372,7 @@ void Game::updateGameStateCompleted()
 		balloon_manager_->destroyAllBalloons(); // Destruye a todos los globos
 		destroyAllItems();						// Destruye todos los items
 		Stage::power = 0;						// Vuelve a dejar el poder a cero, por lo que hubiera podido subir al destruir todos los globos
+		background_->setAlpha(0);				// Elimina el tono rojo de las últimas pantallas
 	}
 
 	// Comienza las celebraciones
@@ -462,37 +473,41 @@ void Game::checkPlayerItemCollision(std::shared_ptr<Player> &player)
 				case ItemType::DISK:
 				{
 					player->addScore(1000);
-					const auto x =
-						item->getPosX() +
-						(item->getWidth() - game_text_textures_[0]->getWidth()) / 2;
-					createItemText(x, game_text_textures_[0]);
+					const auto x = item->getPosX() + (item->getWidth() - game_text_textures_.at(0)->getWidth()) / 2;
+					createItemText(x, game_text_textures_.at(0));
+					JA_PlaySound(Resource::get()->getSound("item_pickup.wav"));
 					break;
 				}
 				case ItemType::GAVINA:
 				{
 					player->addScore(2500);
-					const auto x =
-						item->getPosX() +
-						(item->getWidth() - game_text_textures_[1]->getWidth()) / 2;
-					createItemText(x, game_text_textures_[1]);
+					const auto x = item->getPosX() + (item->getWidth() - game_text_textures_.at(1)->getWidth()) / 2;
+					createItemText(x, game_text_textures_.at(1));
+					JA_PlaySound(Resource::get()->getSound("item_pickup.wav"));
 					break;
 				}
 				case ItemType::PACMAR:
 				{
 					player->addScore(5000);
-					const auto x =
-						item->getPosX() +
-						(item->getWidth() - game_text_textures_[2]->getWidth()) / 2;
-					createItemText(x, game_text_textures_[2]);
+					const auto x = item->getPosX() + (item->getWidth() - game_text_textures_.at(2)->getWidth()) / 2;
+					createItemText(x, game_text_textures_.at(2));
+					JA_PlaySound(Resource::get()->getSound("item_pickup.wav"));
+					break;
+				}
+				case ItemType::DEBIAN:
+				{
+					player->addScore(100000);
+					const auto x = item->getPosX() + (item->getWidth() - game_text_textures_.at(6)->getWidth()) / 2;
+					createItemText(x, game_text_textures_.at(6));
+					JA_PlaySound(Resource::get()->getSound("debian_pickup.wav"));
 					break;
 				}
 				case ItemType::CLOCK:
 				{
 					enableTimeStopItem();
-					const auto x =
-						item->getPosX() +
-						(item->getWidth() - game_text_textures_[5]->getWidth()) / 2;
-					createItemText(x, game_text_textures_[5]);
+					const auto x = item->getPosX() + (item->getWidth() - game_text_textures_.at(5)->getWidth()) / 2;
+					createItemText(x, game_text_textures_.at(5));
+					JA_PlaySound(Resource::get()->getSound("item_pickup.wav"));
 					break;
 				}
 				case ItemType::COFFEE:
@@ -500,18 +515,14 @@ void Game::checkPlayerItemCollision(std::shared_ptr<Player> &player)
 					if (player->getCoffees() == 2)
 					{
 						player->addScore(5000);
-						const auto x =
-							item->getPosX() +
-							(item->getWidth() - game_text_textures_[2]->getWidth()) / 2;
-						createItemText(x, game_text_textures_[2]);
+						const auto x = item->getPosX() + (item->getWidth() - game_text_textures_.at(2)->getWidth()) / 2;
+						createItemText(x, game_text_textures_.at(2));
 					}
 					else
 					{
 						player->giveExtraHit();
-						const auto x =
-							item->getPosX() +
-							(item->getWidth() - game_text_textures_[4]->getWidth()) / 2;
-						createItemText(x, game_text_textures_[4]);
+						const auto x = item->getPosX() + (item->getWidth() - game_text_textures_.at(4)->getWidth()) / 2;
+						createItemText(x, game_text_textures_.at(4));
 					}
 					JA_PlaySound(Resource::get()->getSound("voice_coffee.wav"));
 					break;
@@ -520,10 +531,8 @@ void Game::checkPlayerItemCollision(std::shared_ptr<Player> &player)
 				{
 					player->setPowerUp();
 					coffee_machine_enabled_ = false;
-					const auto x =
-						item->getPosX() +
-						(item->getWidth() - game_text_textures_[3]->getWidth()) / 2;
-					createItemText(x, game_text_textures_[3]);
+					const auto x = item->getPosX() + (item->getWidth() - game_text_textures_.at(3)->getWidth()) / 2;
+					createItemText(x, game_text_textures_.at(3));
 					JA_PlaySound(Resource::get()->getSound("voice_power_up.wav"));
 					break;
 				}
@@ -532,18 +541,46 @@ void Game::checkPlayerItemCollision(std::shared_ptr<Player> &player)
 				}
 
 				updateHiScore();
-				JA_PlaySound(Resource::get()->getSound("itempickup.wav"));
 				item->disable();
 			}
 		}
 	}
 }
 
-// Comprueba y procesa la colisión entre las balas y los globos
-void Game::checkBulletBalloonCollision()
+// Comprueba y procesa la colisión de las balas
+void Game::checkBulletCollision()
 {
 	for (auto &bullet : bullets_)
 	{
+		// Comprueba la colisión con el Tabe
+		if (bullet->isEnabled() && tabe_->isEnabled())
+			if (checkCollision(bullet->getCollider(), tabe_->getCollider()))
+			{
+				tabe_->setState(TabeState::HIT);
+				bullet->disable();
+				auto pos = tabe_->getCollider();
+				if (tabe_->tryToGetBonus())
+				{
+					createItem(ItemType::DEBIAN, pos.x, pos.y);
+					JA_PlaySound(Resource::get()->getSound("debian_drop.wav"));
+				}
+				else
+				{
+					if (rand() % 3 == 0)
+					{
+						createItem(ItemType::COFFEE, pos.x, pos.y);
+						// JA_PlaySound(Resource::get()->getSound("item_drop.wav"));
+					}
+					else
+					{
+						// JA_PlaySound(Resource::get()->getSound("tabe_hit.wav"));
+					}
+					JA_PlaySound(Resource::get()->getSound("tabe_hit.wav"));
+				}
+				break;
+			}
+
+		// Comprueba la colisión con los globos
 		for (auto &balloon : balloon_manager_->getBalloons())
 		{
 			if (balloon->isEnabled() && (!balloon->isInvulnerable()) && bullet->isEnabled())
@@ -560,7 +597,7 @@ void Game::checkBulletBalloonCollision()
 						if (dropped_item != ItemType::COFFEE_MACHINE)
 						{
 							createItem(dropped_item, balloon->getPosX(), balloon->getPosY());
-							JA_PlaySound(Resource::get()->getSound("itemdrop.wav"));
+							JA_PlaySound(Resource::get()->getSound("item_drop.wav"));
 						}
 						else
 						{
@@ -745,7 +782,7 @@ void Game::createItemText(int x, std::shared_ptr<Texture> texture)
 	const auto h = texture->getHeight();
 
 	const int y0 = param.game.play_area.rect.h - h;
-	const int y1 = 155;
+	const int y1 = 160 - (h / 2);
 	const int y2 = -h;
 
 	// Ajusta para que no se dibuje fuera de pantalla
@@ -865,7 +902,7 @@ void Game::killPlayer(std::shared_ptr<Player> &player)
 		// Lo pierde
 		player->removeExtraHit();
 		throwCoffee(player->getPosX() + (player->getWidth() / 2), player->getPosY() + (player->getHeight() / 2));
-		JA_PlaySound(Resource::get()->getSound("coffeeout.wav"));
+		JA_PlaySound(Resource::get()->getSound("coffee_out.wav"));
 		screen_->shake();
 	}
 	else
@@ -893,20 +930,28 @@ void Game::updateTimeStopped()
 		if (time_stopped_counter_ > 120)
 		{
 			if (time_stopped_counter_ % 30 == 0)
+			{
 				JA_PlaySound(Resource::get()->getSound("clock.wav"));
+			}
 		}
 		else
 		{
-			if (time_stopped_counter_ % 15 == 0)
-				JA_PlaySound(Resource::get()->getSound("clock.wav"));
 			if (time_stopped_counter_ % 30 == 0)
+			{
 				balloon_manager_->normalColorsToAllBalloons();
-			if (time_stopped_counter_ % 30 == 15)
+				JA_PlaySound(Resource::get()->getSound("clock.wav"));
+			}
+			else if (time_stopped_counter_ % 30 == 15)
+			{
 				balloon_manager_->reverseColorsToAllBalloons();
+				JA_PlaySound(Resource::get()->getSound("clock.wav"));
+			}
 		}
 	}
 	else
+	{
 		disableTimeStopItem();
+	}
 }
 
 // Actualiza el juego
@@ -1223,8 +1268,11 @@ void Game::checkEvents()
 			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_)});
-				balloon_manager_->destroyAllBalloons();
+				Notifier::get()->show({"auto advance: " + boolToString(auto_pop_balloons_)});
+				if (auto_pop_balloons_)
+				{
+					balloon_manager_->destroyAllBalloons();
+				}
 				balloon_manager_->setDeployBalloons(!auto_pop_balloons_);
 				break;
 			}
@@ -1233,10 +1281,10 @@ void Game::checkEvents()
 				createItem(ItemType::CLOCK, players_.at(0)->getPosX(), players_.at(0)->getPosY() - 40);
 				break;
 			}
-			case SDLK_5: // Crea un PathSprite
+			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(3));
+				createItemText(x, game_text_textures_.at(2));
 				break;
 			}
 			case SDLK_6: // Crea un mensaje
@@ -1244,9 +1292,13 @@ void Game::checkEvents()
 				createMessage({paths_.at(0), paths_.at(1)}, Resource::get()->getTexture("game_text_get_ready"));
 				break;
 			}
-			case SDLK_7: // Flash
+			case SDLK_7: // 100.000
 			{
-				screen_->flash(flash_color, 3);
+				// 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:
@@ -1320,11 +1372,11 @@ void Game::pause(bool value)
 }
 
 // Añade una puntuación a la tabla de records
-void Game::addScoreToScoreBoard(const std::string &name, int score)
+void Game::addScoreToScoreBoard(const std::shared_ptr<Player> &player)
 {
-	const auto entry = HiScoreEntry(trim(name), score);
+	const auto entry = HiScoreEntry(trim(player->getRecordName()), player->getScore(), player->get1CC());
 	auto manager = std::make_unique<ManageHiScoreTable>(options.game.hi_score_table);
-	manager->add(entry);
+	options.game.last_hi_score_entry.at(player->getId() - 1) = manager->add(entry);
 	manager->saveToFile(asset_->get("score.bin"));
 	hi_score_.name = options.game.hi_score_table.front().name;
 }
@@ -1505,7 +1557,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);
@@ -1577,6 +1629,7 @@ void Game::handlePlayerContinue(const std::shared_ptr<Player> &player)
 	if (input_->checkInput(InputType::START, INPUT_DO_NOT_ALLOW_REPEAT, options.controllers[controllerIndex].type, options.controllers[controllerIndex].index))
 	{
 		player->setPlayingState(PlayerState::PLAYING);
+		player->addCredit();
 	}
 
 	// Disminuye el contador de continuación si se presiona cualquier botón de disparo.
@@ -1584,7 +1637,10 @@ void Game::handlePlayerContinue(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))
 	{
-		player->decContinueCounter();
+		if (player->getContinueCounter() < 7)
+		{
+			player->decContinueCounter();
+		}
 	}
 }
 
@@ -1596,12 +1652,15 @@ 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->getRecordNamePos() == NAME_LENGHT - 1)
+		if (player->isShowingName())
+		{
+			player->setPlayingState(PlayerState::CONTINUE);
+		}
+		else if (player->getEnterNamePositionOverflow())
 		{
 			player->setInput(InputType::START);
-			addScoreToScoreBoard(player->getRecordName(), player->getScore());
-			const auto state = player->getPlayingState();
-			player->setPlayingState(state == PlayerState::ENTERING_NAME ? PlayerState::CONTINUE : PlayerState::LEAVING_SCREEN);
+			addScoreToScoreBoard(player);
+			player->setPlayingState(PlayerState::SHOWING_NAME);
 		}
 		else
 		{
@@ -1623,9 +1682,8 @@ void Game::handleNameInput(const std::shared_ptr<Player> &player)
 	else if (input_->checkInput(InputType::START, INPUT_DO_NOT_ALLOW_REPEAT, options.controllers[controllerIndex].type, options.controllers[controllerIndex].index))
 	{
 		player->setInput(InputType::START);
-		addScoreToScoreBoard(player->getRecordName(), player->getScore());
-		const auto state = player->getPlayingState();
-		player->setPlayingState(state == PlayerState::ENTERING_NAME ? PlayerState::CONTINUE : PlayerState::LEAVING_SCREEN);
+		addScoreToScoreBoard(player);
+		player->setPlayingState(PlayerState::SHOWING_NAME);
 	}
 }
 
@@ -1941,7 +1999,7 @@ void Game::updateGameStatePlaying()
 	updatePathSprites();
 	updateTimeStopped();
 	updateHelper();
-	checkBulletBalloonCollision();
+	checkBulletCollision();
 	updateMenace();
 	checkAndUpdateBalloonSpeed();
 	checkState();

source/game.h

@@ -211,8 +211,8 @@ private:
 	// Comprueba la colisión entre el jugador y los items
 	void checkPlayerItemCollision(std::shared_ptr<Player> &player);
 
-	// Comprueba la colisión entre las balas y los globos
-	void checkBulletBalloonCollision();
+	// Comprueba y procesa la colisión de las balas
+	void checkBulletCollision();
 
 	// Mueve las balas activas
 	void updateBullets();
@@ -311,7 +311,7 @@ private:
 	void pause(bool value);
 
 	// Añade una puntuación a la tabla de records
-	void addScoreToScoreBoard(const std::string &name, int score);
+	void addScoreToScoreBoard(const std::shared_ptr<Player> &player);
 
 	// Saca del estado de GAME OVER al jugador si el otro está activo
 	void checkAndUpdatePlayerStatus(int active_player_index, int inactive_player_index);

source/global_inputs.cpp

@@ -21,9 +21,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 +32,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()->showText({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 +43,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({"Reset"});
+        }
+        else
+        {
+            Notifier::get()->show({lang::getText(125), std::string()}, -1, CODE);
+        }
     }
 
     // Activa o desactiva el audio
@@ -62,7 +69,7 @@ namespace globalInputs
             JA_SetMusicVolume(0);
             JA_SetSoundVolume(0);
         }
-        Notifier::get()->showText({"Audio " + boolToOnOff(options.audio.enabled)});
+        Notifier::get()->show({"Audio " + boolToOnOff(options.audio.enabled)});
     }
 
     // Obtiene una fichero a partir de un lang::Code
@@ -88,13 +95,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 +109,27 @@ 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({"Autofire " + boolToOnOff(options.game.autofire)});
     }
 
     // Comprueba los inputs que se pueden introducir en cualquier sección del juego
@@ -127,7 +143,7 @@ namespace globalInputs
             {
                 Screen::get()->toggleVideoMode();
                 const std::string mode = options.video.mode == ScreenVideoMode::WINDOW ? "Window" : "Fullscreen";
-                Notifier::get()->showText({mode + " mode"});
+                Notifier::get()->show({mode + " mode"});
                 return;
             }
 
@@ -136,7 +152,7 @@ namespace globalInputs
             {
                 Screen::get()->decWindowSize();
                 const std::string size = std::to_string(options.video.window.size);
-                Notifier::get()->showText({"Window size x" + size});
+                Notifier::get()->show({"Window size x" + size});
                 return;
             }
 
@@ -145,7 +161,7 @@ namespace globalInputs
             {
                 Screen::get()->incWindowSize();
                 const std::string size = std::to_string(options.video.window.size);
-                Notifier::get()->showText({"Window size x" + size});
+                Notifier::get()->show({"Window size x" + size});
                 return;
             }
 #endif

source/hiscore_table.cpp

@@ -4,23 +4,28 @@
 #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 <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_inputs.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
-#include "text.h"				  // Para Text, TEXT_CENTER, TEXT_SHADOW
-#include "utils.h"				  // Para Color, Zone, fade_color, orange_color
-#include "mouse.h"
+#include "section.h"			  // Para Name, name, Options, options, Attr...
+#include "sprite.h"				  // Para Sprite
+#include "text.h"				  // Para Text, TEXT_COLOR, TEXT_SHADOW
+#include "texture.h"			  // Para Texture
+#include "utils.h"				  // Para Color, easeOutQuint, fade_color
 
 // Constructor
 HiScoreTable::HiScoreTable()
@@ -28,37 +33,26 @@ HiScoreTable::HiScoreTable()
 	  backbuffer_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height)),
 	  fade_(std::make_unique<Fade>()),
 	  background_(std::make_unique<Background>()),
-	  text_(Resource::get()->getText("smb2")),
 	  counter_(0),
 	  ticks_(0),
 	  view_area_({0, 0, param.game.width, param.game.height}),
-	  fade_mode_(FadeMode::IN)
+	  fade_mode_(FadeMode::IN),
+	  background_fade_color_(Color(0, 0, 0))
 {
-	// Inicializa el resto de variables
+	// Inicializa el resto
 	section::name = section::Name::HI_SCORE_TABLE;
-
-	// Inicializa objetos
 	SDL_SetTextureBlendMode(backbuffer_, SDL_BLENDMODE_BLEND);
-	background_->setPos(param.game.game_area.rect);
-	background_->setCloudsSpeed(-0.1f);
-	background_->setGradientNumber(1);
-	background_->setTransition(0.8f);
-	background_->setSunProgression(1.0f);
-	background_->setMoonProgression(0.6f);
-	fade_->setColor(fade_color.r, fade_color.g, fade_color.b);
-	fade_->setType(FadeType::RANDOM_SQUARE);
-	fade_->setPostDuration(param.fade.post_duration);
-	fade_->setMode(fade_mode_);
-	fade_->activate();
-
-	// Crea el contenido de la textura con la lista de puntuaciones
-	fillTexture();
+	initFade();
+	initBackground();
+	iniEntryColors();
+	createSprites();
 }
 
 // Destructor
 HiScoreTable::~HiScoreTable()
 {
 	SDL_DestroyTexture(backbuffer_);
+	options.game.clear_last_hi_score_entries();
 }
 
 // Actualiza las variables
@@ -77,6 +71,9 @@ void HiScoreTable::update()
 			JA_PlayMusic(Resource::get()->getMusic("title.ogg"));
 		}
 
+		// Actualiza las posiciones de los sprites de texto
+		updateSprites();
+
 		// Actualiza el objeto screen
 		Screen::get()->update();
 
@@ -94,7 +91,7 @@ void HiScoreTable::update()
 
 		if (counter_ == 150)
 		{
-			background_->setColor(Color(0, 0, 0));
+			background_->setColor(background_fade_color_.darken());
 			background_->setAlpha(96);
 		}
 
@@ -102,19 +99,15 @@ void HiScoreTable::update()
 		{
 			fade_->activate();
 		}
+
+		// Dibuja los sprites en la textura
+		fillTexture();
 	}
 }
 
-// Crea el contenido de la textura con la lista de puntuaciones
+// Dibuja los sprites en la textura
 void HiScoreTable::fillTexture()
 {
-	// hay 27 letras - 7 de puntos quedan 20 caracteres 20 - name_lenght 0 num_dots
-	constexpr auto max_names = 10;
-	constexpr auto space_between_header = 32;
-	const auto space_between_lines = text_->getCharacterSize() * 2.0f;
-	const auto size = space_between_header + space_between_lines * (max_names - 1) + text_->getCharacterSize();
-	const auto first_line = (param.game.height - size) / 2;
-
 	// Pinta en el backbuffer el texto y los sprites
 	auto temp = SDL_GetRenderTarget(renderer_);
 	SDL_SetRenderTarget(renderer_, backbuffer_);
@@ -122,22 +115,12 @@ void HiScoreTable::fillTexture()
 	SDL_RenderClear(renderer_);
 
 	// Escribe el texto: Mejores puntuaciones
-	text_->writeDX(TEXT_CENTER | TEXT_COLOR | TEXT_SHADOW, param.game.game_area.center_x, first_line, lang::getText(42), 1, orange_color, 1, shdw_txt_color);
+	header_->render();
 
 	// Escribe los nombres de la tabla de puntuaciones
-	for (int i = 0; i < max_names; ++i)
+	for (auto const &entry : entry_names_)
 	{
-		const auto name_lenght = options.game.hi_score_table[i].name.length();
-		const auto score = format(options.game.hi_score_table[i].score);
-		const auto score_lenght = score.size();
-		const auto num_dots = 25 - name_lenght - score_lenght;
-		std::string dots;
-		for (int j = 0; j < (int)num_dots; ++j)
-		{
-			dots = dots + ".";
-		}
-		const auto line = options.game.hi_score_table[i].name + dots + score;
-		text_->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, (i * space_between_lines) + first_line + space_between_header, line, 1, orange_color, 1, shdw_txt_color);
+		entry->render();
 	}
 
 	// Cambia el destino de renderizado
@@ -172,8 +155,6 @@ void HiScoreTable::render()
 // Recarga todas las texturas
 void HiScoreTable::reloadTextures()
 {
-	text_->reLoadTexture();
-	fillTexture();
 }
 
 // Comprueba los eventos
@@ -274,4 +255,213 @@ std::string HiScoreTable::format(int number)
 	}
 
 	return result;
-}
+}
+
+// Crea los sprites con los textos
+void HiScoreTable::createSprites()
+{
+	auto header_text = Resource::get()->getText("04b_25_grey");
+	auto entry_text = Resource::get()->getText("smb2");
+
+	// Obtiene el tamaño de la textura
+	int backbuffer_width;
+	int backbuffer_height;
+	SDL_QueryTexture(backbuffer_, nullptr, nullptr, &backbuffer_width, &backbuffer_height);
+
+	constexpr int entry_lenght = 22;
+	constexpr int max_names = 10;
+	const int space_between_header = entry_text->getCharacterSize() * 4;
+	const int space_between_lines = entry_text->getCharacterSize() * 2;
+	const int size = space_between_header + space_between_lines * (max_names - 1) + entry_text->getCharacterSize();
+	const int first_line = (param.game.height - size) / 2;
+
+	// Crea el sprite para el texto de cabecera
+	header_ = std::make_unique<Sprite>(header_text->writeDXToTexture(TEXT_COLOR, lang::getText(42), -2, background_fade_color_.getInverse().lighten(25)));
+	header_->setPosition(param.game.game_area.center_x - (header_->getWidth() / 2), first_line);
+
+	// Crea los sprites para las entradas en la tabla de puntuaciones
+	const int animation = rand() % 4;
+	const std::string sample_line(entry_lenght + 3, ' ');
+	auto sample_entry = std::make_unique<Sprite>(entry_text->writeDXToTexture(TEXT_SHADOW, sample_line, 1, orange_color, 1, shdw_txt_color));
+	const auto entry_width = sample_entry->getWidth();
+	for (int i = 0; i < max_names; ++i)
+	{
+		const auto table_position = format(i + 1) + ". ";
+		const auto score = format(options.game.hi_score_table.at(i).score);
+		const auto num_dots = entry_lenght - options.game.hi_score_table.at(i).name.size() - score.size();
+		const auto one_cc = options.game.hi_score_table.at(i).one_credit_complete ? " }" : "";
+		std::string dots;
+		for (int j = 0; j < (int)num_dots; ++j)
+		{
+			dots = dots + ".";
+		}
+		const auto line = table_position + options.game.hi_score_table.at(i).name + dots + score + one_cc;
+
+		entry_names_.emplace_back(std::make_shared<PathSprite>(entry_text->writeDXToTexture(TEXT_SHADOW, line, 1, orange_color, 1, shdw_txt_color)));
+		const int default_pos_x = (backbuffer_width - entry_width) / 2;
+		const int pos_x = (i < 9) ? default_pos_x : default_pos_x - entry_text->getCharacterSize();
+		const int pos_y = (i * space_between_lines) + first_line + space_between_header;
+		constexpr int steps = 80;
+		switch (animation)
+		{
+		case 0: // Ambos lados alternativamente
+		{
+			if (i % 2 == 0)
+			{
+				entry_names_.back()->addPath(-entry_names_.back()->getWidth(), pos_x, PathType::HORIZONTAL, pos_y, steps, easeOutQuint);
+				entry_names_.back()->setPosition(-entry_names_.back()->getWidth(), 0);
+			}
+			else
+			{
+				entry_names_.back()->addPath(backbuffer_width, pos_x, PathType::HORIZONTAL, pos_y, steps, easeOutQuint);
+				entry_names_.back()->setPosition(backbuffer_width, 0);
+			}
+			break;
+		}
+
+		case 1: // Entran por la izquierda
+		{
+			entry_names_.back()->addPath(-entry_names_.back()->getWidth(), pos_x, PathType::HORIZONTAL, pos_y, steps, easeOutQuint);
+			entry_names_.back()->setPosition(-entry_names_.back()->getWidth(), 0);
+			break;
+		}
+
+		case 2: // Entran por la derecha
+		{
+			entry_names_.back()->addPath(backbuffer_width, pos_x, PathType::HORIZONTAL, pos_y, steps, easeOutQuint);
+			entry_names_.back()->setPosition(backbuffer_width, 0);
+			break;
+		}
+
+		case 3: // Entran desde la parte inferior
+		{
+			entry_names_.back()->addPath(backbuffer_height, pos_y, PathType::VERTICAL, pos_x, steps, easeOutQuint);
+			entry_names_.back()->setPosition(0, backbuffer_height);
+		}
+
+		default:
+			break;
+		}
+	}
+}
+
+// Actualiza las posiciones de los sprites de texto
+void HiScoreTable::updateSprites()
+{
+	constexpr int init_counter = 190;
+	const int counter_between_entries = 16;
+	if (counter_ >= init_counter)
+	{
+		const int counter2 = counter_ - init_counter;
+		if (counter2 % counter_between_entries == 0)
+		{
+			int index = counter2 / counter_between_entries;
+			if (index < static_cast<int>(entry_names_.size()))
+			{
+				entry_names_.at(index)->enable();
+			}
+		}
+	}
+	for (auto const &entry : entry_names_)
+	{
+		entry->update();
+	}
+
+	glowEntryNames();
+}
+
+// Inicializa el fade
+void HiScoreTable::initFade()
+{
+	fade_->setColor(fade_color.r, fade_color.g, fade_color.b);
+	fade_->setType(FadeType::RANDOM_SQUARE);
+	fade_->setPostDuration(param.fade.post_duration);
+	fade_->setMode(fade_mode_);
+	fade_->activate();
+}
+
+// Inicializa el fondo
+void HiScoreTable::initBackground()
+{
+	background_->setPos(param.game.game_area.rect);
+	background_->setCloudsSpeed(-0.1f);
+
+	const int lucky = rand() % 3;
+	switch (lucky)
+	{
+	case 0: // Fondo verde
+	{
+		background_->setGradientNumber(2);
+		background_->setTransition(0.0f);
+		background_->setSunProgression(1.0f);
+		background_->setMoonProgression(0.0f);
+		background_fade_color_ = green_sky_color;
+		break;
+	}
+
+	case 1: // Fondo naranja
+	{
+		background_->setGradientNumber(1);
+		background_->setTransition(0.0f);
+		background_->setSunProgression(0.65f);
+		background_->setMoonProgression(0.0f);
+		background_fade_color_ = pink_sky_color;
+		break;
+	}
+
+	case 2: // Fondo azul
+	{
+		background_->setGradientNumber(0);
+		background_->setTransition(0.0f);
+		background_->setSunProgression(0.0f);
+		background_->setMoonProgression(0.0f);
+		background_fade_color_ = blue_sky_color;
+		break;
+	}
+
+	default:
+		break;
+	}
+}
+
+// Obtiene un color del vector de colores de entradas
+Color HiScoreTable::getEntryColor(int counter_)
+{
+	int cycle_length = entry_colors_.size() * 2 - 2;
+	size_t n = counter_ % cycle_length;
+
+	size_t index;
+	if (n < entry_colors_.size())
+	{
+		index = n; // Avanza: 0,1,2,3
+	}
+	else
+	{
+		index = 2 * (entry_colors_.size() - 1) - n; // Retrocede: 2,1
+	}
+
+	return entry_colors_[index];
+}
+
+// Inicializa los colores de las entradas
+void HiScoreTable::iniEntryColors()
+{
+	entry_colors_.clear();
+	entry_colors_.emplace_back(background_fade_color_.getInverse().lighten(75));
+	entry_colors_.emplace_back(background_fade_color_.getInverse().lighten(50));
+	entry_colors_.emplace_back(background_fade_color_.getInverse().lighten(25));
+	entry_colors_.emplace_back(background_fade_color_.getInverse());
+}
+
+// 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);
+        }
+    }
+}

source/hiscore_table.h

@@ -1,14 +1,18 @@
 #pragma once
 
-#include <SDL2/SDL_rect.h>	 // para SDL_Rect
-#include <SDL2/SDL_render.h> // para SDL_Renderer, SDL_Texture
-#include <SDL2/SDL_stdinc.h> // para Uint16, Uint32, Uint8
-#include <memory>			 // para unique_ptr
-#include <string>			 // para string
-class Background;			 // lines 8-8
-class Fade;					 // lines 9-9
-class Text;					 // lines 10-10
-enum class FadeMode : Uint8; // lines 11-11
+#include <SDL2/SDL_rect.h>	 // Para SDL_Rect
+#include <SDL2/SDL_render.h> // Para SDL_Renderer, SDL_Texture
+#include <SDL2/SDL_stdinc.h> // Para Uint16, Uint32, Uint8
+#include <memory>			 // Para unique_ptr, shared_ptr
+#include <string>			 // Para string
+#include <vector>			 // Para vector
+#include "utils.h"
+class Background; // lines 10-10
+class Fade;		  // lines 11-11
+class PathSprite;
+class Sprite;
+enum class FadeMode : Uint8; // lines 13-13
+struct Path;
 
 /*
 	Esta clase gestiona un estado del programa. Se encarga de mostrar la tabla con las puntuaciones
@@ -31,15 +35,19 @@ private:
 	SDL_Renderer *renderer_;  // El renderizador de la ventana
 	SDL_Texture *backbuffer_; // Textura para usar como backbuffer
 
-	std::unique_ptr<Fade> fade_;			 // Objeto para renderizar fades
-	std::unique_ptr<Background> background_; // Objeto para dibujar el fondo del juego
-	std::shared_ptr<Text> text_;			 // Objeto para escribir texto
+	std::unique_ptr<Fade> fade_;						   // Objeto para renderizar fades
+	std::unique_ptr<Background> background_;			   // Objeto para dibujar el fondo del juego
+	std::unique_ptr<Sprite> header_;					   // Sprite con la cabecera del texto
+	std::vector<std::shared_ptr<PathSprite>> entry_names_; // Lista con los spritres de cada uno de los nombres de la tabla de records
+	std::vector<Path> paths_;							   // Vector con los recorridos precalculados
 
 	// Variables
-	Uint16 counter_;	 // Contador
-	Uint32 ticks_;		 // Contador de ticks para ajustar la velocidad del programa
-	SDL_Rect view_area_; // Parte de la textura que se muestra en pantalla
-	FadeMode fade_mode_; // Modo de fade a utilizar
+	Uint16 counter_ = 0;			  // Contador
+	Uint32 ticks_;					  // Contador de ticks para ajustar la velocidad del programa
+	SDL_Rect view_area_;			  // Parte de la textura que se muestra en pantalla
+	FadeMode fade_mode_;			  // Modo de fade a utilizar
+	Color background_fade_color_;	  // Color de atenuación del fondo
+	std::vector<Color> entry_colors_; // Colores para destacar las entradas en la tabla
 
 	// Actualiza las variables
 	void update();
@@ -56,7 +64,7 @@ private:
 	// Convierte un entero a un string con separadores de miles
 	std::string format(int number);
 
-	// Crea el contenido de la textura con la lista de puntuaciones
+	// Dibuja los sprites en la textura
 	void fillTexture();
 
 	// Recarga todas las texturas
@@ -65,6 +73,27 @@ private:
 	// Gestiona el fade
 	void updateFade();
 
+	// Crea los sprites con los textos
+	void createSprites();
+
+	// Actualiza las posiciones de los sprites de texto
+	void updateSprites();
+
+	// Inicializa el fade
+	void initFade();
+
+	// Inicializa el fondo
+	void initBackground();
+
+	// Obtiene un color del vector de colores de entradas
+	Color getEntryColor(int counter_);
+
+	// Inicializa los colores de las entradas
+	void iniEntryColors();
+
+	// Hace brillar los nombres de la tabla de records
+	void glowEntryNames();
+
 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_;
@@ -110,9 +110,11 @@ bool Input::checkInput(InputType input, bool repeat, InputDeviceToUse device, in
 	}
 
 	if (gameControllerFound() && controller_index >= 0 && controller_index < num_gamepads_)
+	{
 		if ((device == InputDeviceToUse::CONTROLLER) || (device == InputDeviceToUse::ANY))
 		{
-			success_controller = checkAxisInput(input, controller_index);
+			success_controller = checkAxisInput(input, controller_index, repeat);
+
 			if (!success_controller)
 			{
 				if (repeat)
@@ -144,6 +146,7 @@ bool Input::checkInput(InputType input, bool repeat, InputDeviceToUse device, in
 				}
 			}
 		}
+	}
 
 	return (success_keyboard || success_controller);
 }
@@ -379,19 +382,53 @@ InputType Input::to_inputs_e(const std::string &name) const
 }
 
 // Comprueba el eje del mando
-bool Input::checkAxisInput(InputType input, int controller_index) const
+bool Input::checkAxisInput(InputType input, int controller_index, bool repeat)
 {
+	// Umbral para considerar el eje como activo
+	const Sint16 threshold = 30000;
+	bool axis_active_now = false;
+
 	switch (input)
 	{
 	case InputType::LEFT:
-		return SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTX) < -30000;
+		axis_active_now = SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTX) < -threshold;
+		break;
 	case InputType::RIGHT:
-		return SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTX) > 30000;
+		axis_active_now = SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTX) > threshold;
+		break;
 	case InputType::UP:
-		return SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTY) < -30000;
+		axis_active_now = SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTY) < -threshold;
+		break;
 	case InputType::DOWN:
-		return SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTY) > 30000;
+		axis_active_now = SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTY) > threshold;
+		break;
 	default:
 		return false;
 	}
+
+	// Referencia al binding correspondiente
+	auto &binding = controller_bindings_.at(controller_index).at(static_cast<int>(input));
+
+	if (repeat)
+	{
+		// Si se permite repetir, simplemente devolvemos el estado actual
+		return axis_active_now;
+	}
+	else
+	{
+		// Si no se permite repetir, aplicamos la lógica de transición
+		if (axis_active_now && !binding.axis_active)
+		{
+			// Transición de inactivo a activo
+			binding.axis_active = true;
+			return true;
+		}
+		else if (!axis_active_now && binding.axis_active)
+		{
+			// Transición de activo a inactivo
+			binding.axis_active = false;
+		}
+		// Mantener el estado actual
+		return false;
+	}
 }

source/input.h

@@ -64,7 +64,7 @@ enum class InputDeviceToUse : int
 class Input
 {
 private:
-	// [SINGLETON] Objeto screen privado para Don Melitón
+	// [SINGLETON] Objeto privado
 	static Input *input_;
 
 	struct KeyBindings
@@ -81,10 +81,11 @@ private:
 	{
 		SDL_GameControllerButton button; // GameControllerButton asociado
 		bool active;					 // Indica si está activo
+		bool axis_active;				 // Estado del eje
 
 		// Constructor
-		explicit ControllerBindings(SDL_GameControllerButton btn = SDL_CONTROLLER_BUTTON_INVALID, bool act = false)
-			: button(btn), active(act) {}
+		explicit ControllerBindings(SDL_GameControllerButton btn = SDL_CONTROLLER_BUTTON_INVALID, bool act = false, bool axis_act = false)
+			: button(btn), active(act), axis_active(axis_act) {}
 	};
 
 	// Variables
@@ -99,7 +100,7 @@ private:
 	std::string game_controller_db_path_;							   // Ruta al archivo gamecontrollerdb.txt
 
 	// Comprueba el eje del mando
-	bool checkAxisInput(InputType input, int controller_index = 0) const;
+	bool checkAxisInput(InputType input, int controller_index, bool repeat);
 
 	// Constructor
 	explicit Input(const std::string &game_controller_db_path);
@@ -108,13 +109,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

@@ -22,6 +22,10 @@
 #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()
 	: renderer_(Screen::get()->getRenderer()),
@@ -46,6 +50,9 @@ Instructions::Instructions()
 	fade_->setMode(FadeMode::IN);
 	fade_->activate();
 
+	// Inicializa las líneas con un retraso progresivo de 50 ms
+	lines_ = initializeLines(256);
+
 	// Rellena la textura de texto
 	fillTexture();
 
@@ -159,7 +166,6 @@ void Instructions::fillTexture()
 	text_->writeDX(TEXT_CENTER | TEXT_COLOR | TEXT_SHADOW, param.game.game_area.center_x, anchor2, lang::getText(16), 1, orange_color, 1, shdw_txt_color);
 
 	const int anchor3 = anchor2 + space_post_header;
-	// const int anchor4 = anchor3 + ((param.game.item_size + text->getCharacterSize()) / 2);
 	text_->writeShadowed(anchor_item + desp_x, anchor3 + space_between_item_lines * 0, lang::getText(17), shdw_txt_color);
 	text_->writeShadowed(anchor_item + desp_x, anchor3 + space_between_item_lines * 1, lang::getText(18), shdw_txt_color);
 	text_->writeShadowed(anchor_item + desp_x, anchor3 + space_between_item_lines * 2, lang::getText(19), shdw_txt_color);
@@ -226,14 +232,36 @@ 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);
+            }
+        }
+
 		// Actualiza el mosaico de fondo
 		tiled_bg_->update();
 
 		// Actualiza el objeto "fade"
 		fade_->update();
 
+		// Rellena el backbuffer
+		fillBackbuffer();
+
 		// Comprueba si el contador ha llegado al final
-		if (counter_ == counter_end_)
+		if (all_lines_off_screen_)
 		{
 			section::name = section::Name::TITLE;
 			section::options = section::Options::TITLE_1;
@@ -244,9 +272,6 @@ void Instructions::update()
 // Pinta en pantalla
 void Instructions::render()
 {
-	// Rellena el backbuffer
-	fillBackbuffer();
-
 	// Prepara para empezar a dibujar en la textura de juego
 	Screen::get()->start();
 
@@ -256,11 +281,11 @@ void Instructions::render()
 	// Dibuja el mosacico de fondo
 	tiled_bg_->render();
 
-	// Establece la ventana del backbuffer
-	view_.y = std::max(0, param.game.height - counter_ + 100);
-
 	// Copia la textura y el backbuffer al renderizador
-	SDL_RenderCopy(renderer_, backbuffer_, nullptr, &view_);
+	if (view_.y == 0)
+		renderLines(renderer_, backbuffer_, lines_);
+	else
+		SDL_RenderCopy(renderer_, backbuffer_, nullptr, &view_);
 
 	fade_->render();
 
@@ -335,4 +360,61 @@ void Instructions::run()
 		checkEvents(); // Tiene que ir antes del render
 		render();
 	}
+}
+
+// Método para inicializar las líneas
+std::vector<Line> Instructions::initializeLines(int height)
+{
+	std::vector<Line> lines;
+	for (int y = 0; y < height; y++)
+	{
+		int direction = (y % 2 == 0) ? -1 : 1; // Pares a la izquierda, impares a la derecha
+		lines.emplace_back(y, 0.0f, direction);
+	}
+	return lines;
+}
+
+// Método para mover las líneas con suavizado
+bool Instructions::moveLines(std::vector<Line> &lines, int width, float duration, Uint32 startDelay)
+{
+	Uint32 currentTime = SDL_GetTicks();
+	bool allLinesOffScreen = true;
+
+	for (auto &line : lines)
+	{
+		// Establecer startTime en el primer cuadro de animación
+		if (line.startTime == 0)
+		{
+			line.startTime = currentTime + line.y * startDelay;
+		}
+
+		float elapsedTime = (currentTime - line.startTime) / 1000.0f; // Convertir a segundos
+		if (elapsedTime < 0)
+		{
+			allLinesOffScreen = false; // Si aún no se debe mover esta línea, no están todas fuera de pantalla
+			continue;
+		}
+		if (elapsedTime >= duration)
+		{
+			continue; // Si la línea ha salido de los límites, no la muevas más
+		}
+
+		float t = elapsedTime / duration;
+		float smoothFactor = easeInOutQuint(t);
+		line.x = line.direction * smoothFactor * width;
+		allLinesOffScreen = false; // Si alguna línea aún se está moviendo, no están todas fuera de pantalla
+	}
+
+	return allLinesOffScreen;
+}
+
+// Método para renderizar las líneas
+void Instructions::renderLines(SDL_Renderer *renderer, SDL_Texture *texture, const std::vector<Line> &lines)
+{
+	for (const auto &line : lines)
+	{
+		SDL_Rect srcRect = {0, line.y, 320, 1};
+		SDL_Rect dstRect = {static_cast<int>(line.x), line.y, 320, 1};
+		SDL_RenderCopy(renderer, texture, &srcRect, &dstRect);
+	}
 }

source/instructions.h

@@ -24,6 +24,19 @@ class TiledBG;				 // lines 12-12
 	por la pantalla sobre el mosaico de fondo (gestionado por el correspondiente objeto)
 */
 
+// Estructura para almacenar información de línea
+struct Line
+{
+	int y;			  // Coordenada Y de la línea
+	float x;		  // Coordenada X inicial (usamos float para mayor precisión en el suavizado)
+	int direction;	  // Dirección de movimiento: -1 para izquierda, 1 para derecha
+	Uint32 startTime; // Tiempo de inicio del movimiento
+
+	// Constructor de Line
+	Line(int y, float x, int direction)
+		: y(y), x(x), direction(direction), startTime(0) {}
+};
+
 // Clase Instructions
 class Instructions
 {
@@ -40,12 +53,15 @@ private:
 	std::unique_ptr<Fade> fade_;						  // Objeto para renderizar fades
 
 	// Variables
-	int counter_ = 0;				// Contador
-	int counter_end_ = 700;			// Valor final para el contador
-	Uint32 ticks_ = 0;				// Contador de ticks para ajustar la velocidad del programa
-	SDL_Rect view_;					// Vista del backbuffer que se va amostrar por pantalla
-	SDL_Point sprite_pos_ = {0, 0}; // Posición del primer sprite
-	int item_space_ = 2;			// Espacio entre los items
+	int counter_ = 0;					 // Contador para manejar el progreso en la pantalla de instrucciones
+	Uint32 ticks_ = 0;					 // Contador de ticks para ajustar la velocidad del programa
+	SDL_Rect view_;						 // Vista del backbuffer que se va a mostrar por pantalla
+	SDL_Point sprite_pos_ = {0, 0};		 // Posición del primer sprite en la lista
+	int item_space_ = 2;				 // Espacio entre los items en pantalla
+	std::vector<Line> lines_;			 // Vector que contiene las líneas animadas en la pantalla
+	bool all_lines_off_screen_ = false;	 // Indica si todas las líneas han salido de la pantalla
+	Uint32 start_delay_time_ = 0;		 // Tiempo de inicio del retraso para mover las líneas
+	bool start_delay_triggered_ = false; // Bandera para determinar si el retraso ha comenzado
 
 	// Actualiza las variables
 	void update();
@@ -74,6 +90,15 @@ private:
 	// Recarga todas las texturas
 	void reloadTextures();
 
+	// Método para inicializar las líneas
+	std::vector<Line> initializeLines(int height);
+
+	// Método para mover las líneas
+	bool moveLines(std::vector<Line> &lines, int width, float duration, Uint32 startDelay);
+
+	// Método para renderizar las líneas
+	void renderLines(SDL_Renderer *renderer, SDL_Texture *texture, const std::vector<Line> &lines);
+
 public:
 	// Constructor
 	Instructions();

source/intro.cpp

@@ -17,137 +17,137 @@
 #include "utils.h"			 // Para Zone, BLOCK, Color, bg_color
 #include "writer.h"			 // Para Writer
 #include "mouse.h"
+#include <array>
 
 // Constructor
 Intro::Intro()
-	: texture_(Resource::get()->getTexture("intro.png")),
-	  text_(Resource::get()->getText("nokia"))
 {
-
 	// Inicializa variables
 	section::name = section::Name::INTRO;
 	section::options = section::Options::NONE;
 
+	const std::array<std::string, 6> BITMAP_LIST = {
+		"intro1.png",
+		"intro2.png",
+		"intro3.png",
+		"intro4.png",
+		"intro5.png",
+		"intro6.png"};
+
+	auto texture = Resource::get()->getTexture(BITMAP_LIST.front());
+	const int BITMAP_WIDTH = texture->getWidth();
+	const int BITMAP_HEIGHT = texture->getHeight();
+
 	// Inicializa los bitmaps de la intro
-	constexpr int totalBitmaps = 6;
-	for (int i = 0; i < totalBitmaps; ++i)
+	constexpr int TOTAL_BITMAPS = 6;
+	for (int i = 0; i < TOTAL_BITMAPS; ++i)
 	{
-		auto ss = std::make_unique<SmartSprite>(texture_);
-		ss->setWidth(128);
-		ss->setHeight(96);
+		auto ss = std::make_unique<SmartSprite>(Resource::get()->getTexture(BITMAP_LIST.at(i)));
+		ss->setWidth(BITMAP_WIDTH);
+		ss->setHeight(BITMAP_HEIGHT);
+		ss->setSpriteClip(0, 0, BITMAP_WIDTH, BITMAP_HEIGHT);
 		ss->setFinishedCounter(20);
-		ss->setDestX(param.game.game_area.center_x - 64);
-		ss->setDestY(param.game.game_area.first_quarter_y - 24);
+		ss->setDestX(param.game.game_area.center_x - (BITMAP_WIDTH / 2));
+		ss->setDestY(param.game.game_area.first_quarter_y - (BITMAP_HEIGHT / 4));
 		bitmaps_.push_back(std::move(ss));
 	}
 
-	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);
+	bitmaps_.at(0)->setPosX(-BITMAP_WIDTH);
+	bitmaps_.at(0)->setPosY(param.game.game_area.first_quarter_y - (BITMAP_HEIGHT / 4));
+	bitmaps_.at(0)->setVelX(0.0f);
+	bitmaps_.at(0)->setVelY(0.0f);
+	bitmaps_.at(0)->setAccelX(0.6f);
+	bitmaps_.at(0)->setAccelY(0.0f);
 
-	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_.at(1)->setPosX(param.game.width);
+	bitmaps_.at(1)->setPosY(param.game.game_area.first_quarter_y - (BITMAP_HEIGHT / 4));
+	bitmaps_.at(1)->setVelX(-1.0f);
+	bitmaps_.at(1)->setVelY(0.0f);
+	bitmaps_.at(1)->setAccelX(-0.3f);
+	bitmaps_.at(1)->setAccelY(0.0f);
 
-	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_.at(2)->setPosX(param.game.game_area.center_x - (BITMAP_WIDTH / 2));
+	bitmaps_.at(2)->setPosY(-BITMAP_HEIGHT);
+	bitmaps_.at(2)->setVelX(0.0f);
+	bitmaps_.at(2)->setVelY(3.0f);
+	bitmaps_.at(2)->setAccelX(0.1f);
+	bitmaps_.at(2)->setAccelY(0.3f);
+	bitmaps_.at(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_.at(3)->setPosX(param.game.game_area.center_x - (BITMAP_WIDTH / 2));
+	bitmaps_.at(3)->setPosY(param.game.height);
+	bitmaps_.at(3)->setVelX(0.0f);
+	bitmaps_.at(3)->setVelY(-0.7f);
+	bitmaps_.at(3)->setAccelX(0.0f);
+	bitmaps_.at(3)->setAccelY(0.0f);
 
-	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_.at(4)->setPosX(param.game.game_area.center_x - (BITMAP_WIDTH / 2));
+	bitmaps_.at(4)->setPosY(-BITMAP_HEIGHT);
+	bitmaps_.at(4)->setVelX(0.0f);
+	bitmaps_.at(4)->setVelY(3.0f);
+	bitmaps_.at(4)->setAccelX(0.1f);
+	bitmaps_.at(4)->setAccelY(0.3f);
 
-	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);
+	bitmaps_.at(5)->setPosX(param.game.width);
+	bitmaps_.at(5)->setPosY(param.game.game_area.first_quarter_y - (BITMAP_HEIGHT / 4));
+	bitmaps_.at(5)->setVelX(-0.7f);
+	bitmaps_.at(5)->setVelY(0.0f);
+	bitmaps_.at(5)->setAccelX(0.0f);
+	bitmaps_.at(5)->setAccelY(0.0f);
 
 	// Inicializa los textos de la intro
-	constexpr int totalTexts = 9;
-	for (int i = 0; i < totalTexts; ++i)
+	constexpr int TOTAL_TEXTS = 9;
+	for (int i = 0; i < TOTAL_TEXTS; ++i)
 	{
-		auto w = std::make_unique<Writer>(text_);
+		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(-1);
+		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);
+	texts_.at(0)->setCaption(lang::getText(27));
+	texts_.at(0)->setSpeed(8);
 
 	// Tot esta tranquil a la UPV
-	texts_[1]->setCaption(lang::getText(28));
-	texts_[1]->setSpeed(8);
+	texts_.at(1)->setCaption(lang::getText(28));
+	texts_.at(1)->setSpeed(8);
 
 	// Fins que un desaprensiu...
-	texts_[2]->setCaption(lang::getText(29));
-	texts_[2]->setSpeed(12);
+	texts_.at(2)->setCaption(lang::getText(29));
+	texts_.at(2)->setSpeed(12);
 
 	// HEY! ME ANE A FERME UN CORTAET...
-	texts_[3]->setCaption(lang::getText(30));
-	texts_[3]->setSpeed(8);
+	texts_.at(3)->setCaption(lang::getText(30));
+	texts_.at(3)->setSpeed(8);
 
 	// UAAAAAAAAAAAAA!!!
-	texts_[4]->setCaption(lang::getText(31));
-	texts_[4]->setSpeed(1);
+	texts_.at(4)->setCaption(lang::getText(31));
+	texts_.at(4)->setSpeed(1);
 
 	// Espera un moment...
-	texts_[5]->setCaption(lang::getText(32));
-	texts_[5]->setSpeed(16);
+	texts_.at(5)->setCaption(lang::getText(32));
+	texts_.at(5)->setSpeed(16);
 
 	// Si resulta que no tinc solt!
-	texts_[6]->setCaption(lang::getText(33));
-	texts_[6]->setSpeed(2);
+	texts_.at(6)->setCaption(lang::getText(33));
+	texts_.at(6)->setSpeed(2);
 
 	// MERDA DE MAQUINA!
-	texts_[7]->setCaption(lang::getText(34));
-	texts_[7]->setSpeed(3);
+	texts_.at(7)->setCaption(lang::getText(34));
+	texts_.at(7)->setSpeed(3);
 
 	// Blop... blop... blop...
-	texts_[8]->setCaption(lang::getText(35));
-	texts_[8]->setSpeed(16);
+	texts_.at(8)->setCaption(lang::getText(35));
+	texts_.at(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();
+	}
 }
 
 // Comprueba los eventos
@@ -171,7 +171,7 @@ void Intro::checkEvents()
 		{
 			if (event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED)
 			{
-				reloadTextures();
+				// reloadTextures();
 			}
 			break;
 		}

source/intro.h

@@ -18,9 +18,6 @@ class Intro
 {
 private:
 	// Objetos
-	std::shared_ptr<Texture> texture_; // Textura con los graficos
-	std::shared_ptr<Text> text_;	   // Textos de la intro
-
 	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
 
@@ -43,9 +40,6 @@ private:
 	// Actualiza las escenas de la intro
 	void updateScenes();
 
-	// Recarga todas las texturas
-	void reloadTextures();
-
 public:
 	// Constructor
 	Intro();

source/item.h

@@ -22,8 +22,9 @@ enum class ItemType : int
     PACMAR = 3,        /**< Pacman */
     CLOCK = 4,         /**< Reloj */
     COFFEE = 5,        /**< Café */
-    COFFEE_MACHINE = 6,/**< Máquina de café */
-    NONE = 7,          /**< Ninguno */
+    DEBIAN = 6,        /**< Debian */
+    COFFEE_MACHINE = 7,/**< Máquina de café */
+    NONE = 8,          /**< Ninguno */
 };
 
 /**

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
@@ -247,5 +245,4 @@ namespace shader
             SDL_RenderPresent(renderer);
         }
     }
-}
-#endif
+}

source/jail_shader.h

@@ -1,5 +1,3 @@
-#ifndef NO_SHADERS
-
 #pragma once
 
 #include <SDL2/SDL_render.h> // para SDL_Texture
@@ -44,5 +42,4 @@ namespace shader
                     const char *vertexShader, const char *fragmentShader = nullptr);
 
     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

@@ -3,24 +3,24 @@
 #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 "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 "sprite.h"			 // Para Sprite
-#include "texture.h"		 // Para Texture
-#include "utils.h"			 // Para Color, Zone
+#include <iostream>
+#include "global_inputs.h" // Para check
+#include "input.h"		   // Para Input
+#include "jail_audio.h"	   // Para JA_StopMusic
+#include "param.h"		   // Para Param, ParamGame, param
+#include "resource.h"	   // Para Resource
+#include "screen.h"		   // Para Screen
+#include "section.h"	   // Para Name, name, Options, options
+#include "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
@@ -114,7 +114,7 @@ void Logo::checkInput()
 	globalInputs::check();
 }
 
-// Gestiona el logo de JAILGAME
+// Gestiona el logo de JAILGAMES
 void Logo::updateJAILGAMES()
 {
 	if (counter_ == 30)
@@ -147,6 +147,19 @@ void Logo::updateJAILGAMES()
 			}
 		}
 	}
+
+	// Comprueba si ha terminado el logo
+	if (counter_ == END_LOGO_COUNTER_MARK + POST_LOGO_DURATION)
+	{
+		state_ = LogoState::RETROWEEKEND;
+		ticks_start_ = SDL_GetTicks();
+	}
+}
+
+// Gestiona el logo de RETROWEEKEND
+void Logo::updateRETROWEEKEND()
+{
+	section::name = section::Name::INTRO;
 }
 
 // Gestiona el color de las texturas
@@ -190,21 +203,24 @@ 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
-		counter_++;
-
-		// Comprueba si ha terminado el logo
-		if (counter_ == END_LOGO_COUNTER_MARK + POST_LOGO_DURATION)
+		switch (state_)
 		{
-			section::name = section::Name::INTRO;
+		case LogoState::JAILGAMES:
+			updateJAILGAMES();
+			updateTextureColors();
+			break;
+
+		case LogoState::RETROWEEKEND:
+			updateRETROWEEKEND();
+			break;
+
+		default:
+			break;
 		}
 
+		// Gestiona el contador
+		counter_++;
+
 		// Actualiza las variables de globalInputs
 		globalInputs::update();
 	}
@@ -213,24 +229,23 @@ 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_)
+	switch (state_)
 	{
-		sprite->render();
+	case LogoState::JAILGAMES:
+		renderJAILGAMES();
+		break;
+
+	case LogoState::RETROWEEKEND:
+		renderRETROWEEKEND();
+		break;
+
+	default:
+		break;
 	}
 
-	if (counter_ >= SHOW_SINCE_SPRITE_COUNTER_MARK)
-	{
-		since_sprite_->render();
-	}
-
-	// Vuelca el contenido del renderizador en pantalla
 	Screen::get()->render();
 }
 
@@ -247,4 +262,133 @@ void Logo::run()
 		checkEvents(); // Tiene que ir antes del render
 		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();
+	}
+}
+
+// Renderiza el logo de RETROWEEKEND
+void Logo::renderRETROWEEKEND()
+{
+	// SDL_RenderCopy(Screen::get()->getRenderer(), mi_textura, nullptr, nullptr);
+
+	// SDL_RenderCopy(Screen::get()->getRenderer(), Resource::get()->getTexture("logo_retroweekend.png")->getSDLTexture(), nullptr, nullptr);
+	// Dibujar y evaporar los píxeles
+	renderAndEvaporate(Screen::get()->getRenderer(), pixels_);
+}
+
+std::vector<Pixel> Logo::extractPixels(SDL_Texture *texture)
+{
+	std::vector<Pixel> pixels;
+
+	// Obtener el formato y tamaño de la textura
+	Uint32 format;
+	int access, width, height;
+	SDL_QueryTexture(texture, &format, &access, &width, &height);
+
+	// Imprimir el nombre del formato de la textura
+	std::cout << "Texture format: " << SDL_GetPixelFormatName(format) << std::endl;
+
+	// Crear una superficie temporal para leer los píxeles
+	SDL_Surface *temp_surface = SDL_CreateRGBSurfaceWithFormat(0, width, height, 32, format);
+	if (!temp_surface)
+	{
+		std::cout << "Error: SDL_CreateRGBSurfaceWithFormat failed - " << SDL_GetError() << std::endl;
+		return pixels;
+	}
+
+	SDL_Renderer *renderer = Screen::get()->getRenderer();
+	SDL_SetRenderTarget(renderer, nullptr); // Dibujar en pantalla principal
+	SDL_RenderClear(renderer);				// Limpiar pantalla
+	SDL_RenderCopy(renderer, texture, nullptr, nullptr);
+	SDL_RenderPresent(renderer); // Mostrar en pantalla
+
+	std::cout << "Se ha dibujado la textura en pantalla." << std::endl;
+
+	if (SDL_RenderReadPixels(Screen::get()->getRenderer(), nullptr, format, temp_surface->pixels, temp_surface->pitch) != 0)
+	{
+		std::cout << "Error: SDL_RenderReadPixels failed - " << SDL_GetError() << std::endl;
+		SDL_FreeSurface(temp_surface);
+		return pixels;
+	}
+	else
+	{
+		std::cout << "SDL_RenderReadPixels se ejecutó correctamente." << std::endl;
+	}
+
+	// Leer los píxeles de la textura
+	if (SDL_RenderReadPixels(Screen::get()->getRenderer(), nullptr, format, temp_surface->pixels, temp_surface->pitch) != 0)
+	{
+		std::cout << "Error: SDL_RenderReadPixels failed - " << SDL_GetError() << std::endl;
+		SDL_FreeSurface(temp_surface);
+		return pixels;
+	}
+
+	// Extraer los píxeles y almacenarlos en el vector
+	SDL_PixelFormat *pixel_format = SDL_AllocFormat(format);
+	Uint8 r, g, b, a;
+	/*for (int y = 0; y < height; ++y)
+	{
+		for (int x = 0; x < width; ++x)
+		{
+			Uint32 pixel_value = ((Uint32 *)temp_surface->pixels)[y * (temp_surface->pitch / 4) + x];
+			SDL_GetRGBA(pixel_value, pixel_format, &r, &g, &b, &a);
+			if (a > 0)
+			{
+				pixels.push_back({x, y, r, g, b, a});
+			}
+		}
+	}*/
+
+	for (int y = 0; y < height; ++y)
+	{
+		for (int x = 0; x < width; ++x)
+		{
+			Uint32 pixel_value = ((Uint32 *)temp_surface->pixels)[y * (temp_surface->pitch / 4) + x];
+			SDL_GetRGBA(pixel_value, pixel_format, &r, &g, &b, &a);
+
+			// Imprimir algunos píxeles para depuración
+			if (x < 5 && y < 5)
+			{
+				std::cout << "Pixel (" << x << "," << y << ") - RGBA("
+						  << (int)r << "," << (int)g << "," << (int)b << "," << (int)a << ")" << std::endl;
+			}
+
+			// No filtrar por alfa por ahora
+			pixels.push_back({x, y, r, g, b, a});
+		}
+	}
+
+	std::cout << "Cantidad de píxeles a renderizar: " << pixels.size() << std::endl;
+
+	// Liberar recursos
+	SDL_FreeFormat(pixel_format);
+	SDL_FreeSurface(temp_surface);
+
+	return pixels;
+}
+
+void Logo::renderAndEvaporate(SDL_Renderer *renderer, std::vector<Pixel> &pixels)
+{
+	for (auto &pixel : pixels)
+	{
+		// Establecer el color para el píxel actual
+		SDL_SetRenderDrawColor(renderer, pixel.r, pixel.g, pixel.b, pixel.a);
+		// Dibujar el píxel
+		SDL_RenderDrawPoint(renderer, pixel.x, pixel.y);
+		// Evaporar el píxel
+		// pixel.evaporate();
+	}
+}

source/logo.h

@@ -2,8 +2,9 @@
 
 #include <SDL2/SDL_rect.h>	 // Para SDL_Point
 #include <SDL2/SDL_stdinc.h> // Para Uint32
-#include <memory>			 // Para shared_ptr, unique_ptr
-#include <vector>			 // Para vector
+#include <SDL2/SDL.h>
+#include <memory> // Para shared_ptr, unique_ptr
+#include <vector> // Para vector
 class Sprite;
 class Texture; // lines 9-9
 struct Color;
@@ -16,10 +17,31 @@ struct Color;
 	ZX Spectrum
 */
 
+struct Pixel
+{
+	int x, y;		  // Coordenadas del píxel
+	Uint8 r, g, b, a; // Color del píxel
+
+	// Método para ascender y desvanecerse
+	void evaporate()
+	{
+		y -= 1;					 // Asciende hacia arriba
+		a = (a > 5) ? a - 5 : 0; // Desvanece el alfa (transparencia)
+		// Añadir movimiento zig-zag aleatorio
+		x += (rand() % 3 - 1); // Movimiento horizontal aleatorio (-1, 0, 1)
+	}
+};
+
 // Clase Logo
 class Logo
 {
 private:
+	enum class LogoState
+	{
+		JAILGAMES,
+		RETROWEEKEND,
+	};
+
 	// Constantes
 	static constexpr int SHOW_SINCE_SPRITE_COUNTER_MARK = 70; // Tiempo del contador en el que empieza a verse el sprite de "SINCE 1998"
 	static constexpr int INIT_FADE_COUNTER_MARK = 300;		  // Tiempo del contador cuando inicia el fade a negro
@@ -34,10 +56,13 @@ private:
 	std::vector<std::unique_ptr<Sprite>> jail_sprite_; // Vector con los sprites de cada linea que forman el bitmap JAILGAMES
 
 	// 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
-	SDL_Point dest_;		   // Posición X donde dibujar el logo
+	std::vector<Color> color_;				 // Vector con los colores para el fade
+	int counter_;							 // Contador
+	Uint32 ticks_ = 0;						 // Contador de ticks para ajustar la velocidad del programa
+	SDL_Point dest_;						 // Posición X donde dibujar el logo
+	LogoState state_ = LogoState::JAILGAMES; // El estado indica qué logo se está procesando
+	Uint32 ticks_start_ = 0;				 // Almacena el valor actual de los ticks de SDL
+	std::vector<Pixel> pixels_;				 // Vector con los pixels que forman el logo de "RETROWEEKEND"
 
 	// Actualiza las variables
 	void update();
@@ -51,15 +76,28 @@ private:
 	// Comprueba las entradas
 	void checkInput();
 
-	// Gestiona el logo de JAILGAME
+	// Gestiona el logo de JAILGAMES
 	void updateJAILGAMES();
 
+	// Gestiona el logo de RETROWEEKEND
+	void updateRETROWEEKEND();
+
+	// Renderiza el logo de JAILGAMES
+	void renderJAILGAMES();
+
+	// Renderiza el logo de RETROWEEKEND
+	void renderRETROWEEKEND();
+
 	// Gestiona el color de las texturas
 	void updateTextureColors();
 
 	// Recarga todas las texturas
 	void reloadTextures();
 
+	std::vector<Pixel> extractPixels(SDL_Texture *texture);
+
+	void renderAndEvaporate(SDL_Renderer *renderer, std::vector<Pixel> &pixels);
+
 public:
 	// Constructor
 	Logo();

source/manage_hiscore_table.cpp

@@ -27,7 +27,7 @@ void ManageHiScoreTable::clear()
 }
 
 // Añade un elemento a la tabla
-void ManageHiScoreTable::add(HiScoreEntry entry)
+int ManageHiScoreTable::add(const HiScoreEntry &entry)
 {
     // Añade la entrada a la tabla
     table_.push_back(entry);
@@ -35,8 +35,32 @@ void ManageHiScoreTable::add(HiScoreEntry entry)
     // Ordena la tabla
     sort();
 
+    // Encontrar la posición del nuevo elemento
+    auto it = std::find_if(table_.begin(), table_.end(), [&](const HiScoreEntry &e)
+                           { return e.name == entry.name &&
+                                    e.score == entry.score &&
+                                    e.one_credit_complete == entry.one_credit_complete; });
+
+    int position = -1;
+    if (it != table_.end())
+    {
+        position = std::distance(table_.begin(), it);
+    }
+
     // Deja solo las 10 primeras entradas
-    table_.resize(10);
+    if (table_.size() > 10)
+    {
+        table_.resize(10);
+
+        // Si el nuevo elemento quedó fuera del top 10
+        if (position >= 10)
+        {
+            position = -1; // No entró en el top 10
+        }
+    }
+
+    // Devuelve la posición
+    return position;
 }
 
 // Ordena la tabla
@@ -50,52 +74,55 @@ void ManageHiScoreTable::sort()
     std::sort(table_.begin(), table_.end(), scoreDescendingComparator);
 }
 
-// Carga la tabla con los datos de un fichero
+// Carga la tabla desde un fichero
 bool ManageHiScoreTable::loadFromFile(const std::string &file_path)
 {
     clear();
     auto success = true;
-    auto file = SDL_RWFromFile(file_path.c_str(), "r+b");
+    auto file = SDL_RWFromFile(file_path.c_str(), "rb");
 
     if (file)
     {
-        std::cout << "Reading file: " << getFileName(file_path) << std::endl;
+        table_.clear(); // Limpia la tabla actual
 
-        for (auto &entry : table_)
+        // Lee el número de entradas en la tabla
+        int tableSize = 0;
+        SDL_RWread(file, &tableSize, sizeof(int), 1);
+
+        // Lee los datos de cada entrada
+        for (int i = 0; i < tableSize; ++i)
         {
+            HiScoreEntry entry;
+
+            // Lee la puntuación
+            SDL_RWread(file, &entry.score, sizeof(int), 1);
+
+            // Lee el tamaño del nombre y luego el nombre
             int nameSize = 0;
-
-            if (SDL_RWread(file, &entry.score, sizeof(int), 1) == 0)
-            {
-                success = false;
-                break;
-            }
-
-            if (SDL_RWread(file, &nameSize, sizeof(int), 1) == 0)
-            {
-                success = false;
-                break;
-            }
+            SDL_RWread(file, &nameSize, sizeof(int), 1);
 
             std::vector<char> nameBuffer(nameSize + 1);
-            if (SDL_RWread(file, nameBuffer.data(), sizeof(char) * nameSize, 1) == 0)
-            {
-                success = false;
-                break;
-            }
-
-            nameBuffer[nameSize] = '\0';
+            SDL_RWread(file, nameBuffer.data(), nameSize, 1);
+            nameBuffer[nameSize] = '\0'; // Asegurar el fin de la cadena
             entry.name = std::string(nameBuffer.data());
+
+            // Lee el valor de one_credit_complete
+            int occValue = 0;
+            SDL_RWread(file, &occValue, sizeof(int), 1);
+            entry.one_credit_complete = (occValue != 0);
+
+            // Añade la entrada a la tabla
+            table_.push_back(entry);
         }
 
+        std::cout << "Reading file: " << getFileName(file_path) << std::endl;
         SDL_RWclose(file);
     }
-
-    if (!success)
+    else
     {
-        clear();
+        std::cout << "Error: Unable to load " << getFileName(file_path) << " file! " << SDL_GetError() << std::endl;
+        success = false;
     }
-
     return success;
 }
 
@@ -107,21 +134,35 @@ bool ManageHiScoreTable::saveToFile(const std::string &file_path)
 
     if (file)
     {
-        // Guarda los datos
-        for (int i = 0; i < (int)table_.size(); ++i)
+        // Guarda el número de entradas en la tabla
+        int tableSize = static_cast<int>(table_.size());
+        SDL_RWwrite(file, &tableSize, sizeof(int), 1);
+
+        // Guarda los datos de cada entrada
+        for (int i = 0; i < tableSize; ++i)
         {
-            SDL_RWwrite(file, &table_.at(i).score, sizeof(int), 1);
-            const int nameSize = (int)table_.at(i).name.size();
+            const HiScoreEntry &entry = table_.at(i);
+
+            // Guarda la puntuación
+            SDL_RWwrite(file, &entry.score, sizeof(int), 1);
+
+            // Guarda el tamaño del nombre y luego el nombre
+            int nameSize = static_cast<int>(entry.name.size());
             SDL_RWwrite(file, &nameSize, sizeof(int), 1);
-            SDL_RWwrite(file, table_.at(i).name.c_str(), nameSize, 1);
+            SDL_RWwrite(file, entry.name.c_str(), nameSize, 1);
+
+            // Guarda el valor de one_credit_complete como un entero (0 o 1)
+            int occValue = entry.one_credit_complete ? 1 : 0;
+            SDL_RWwrite(file, &occValue, sizeof(int), 1);
         }
 
-        std::cout << "Writing file: " << getFileName(file_path).c_str() << std::endl;
+        std::cout << "Writing file: " << getFileName(file_path) << std::endl;
         SDL_RWclose(file);
     }
     else
     {
-        std::cout << "Error: Unable to save " << getFileName(file_path).c_str() << " file! " << SDL_GetError() << std::endl;
+        std::cout << "Error: Unable to save " << getFileName(file_path) << " file! " << SDL_GetError() << std::endl;
+        success = false;
     }
     return success;
 }

source/manage_hiscore_table.h

@@ -14,12 +14,13 @@
 // Estructura para las entradas de la tabla de recirds
 struct HiScoreEntry
 {
-	std::string name; // Nombre
-	int score;		  // Puntuación
+    std::string name;         // Nombre
+    int score;                // Puntuación
+    bool one_credit_complete; // Indica si se ha conseguido 1CC
 
-	// Constructor
-	explicit HiScoreEntry(const std::string &n = "", int s = 0)
-		: name(n), score(s) {}
+    // Constructor
+    explicit HiScoreEntry(const std::string &n = "", int s = 0, bool occ = false)
+        : name(n.substr(0, 6)), score(s), one_credit_complete(occ) {}
 };
 
 // Clase ManageHiScoreTable
@@ -44,7 +45,7 @@ public:
     void clear();
 
     // Añade un elemento a la tabla
-    void add(HiScoreEntry entry);
+    int add(const HiScoreEntry& entry);
 
     // Carga la tabla con los datos de un fichero
     bool loadFromFile(const std::string &file_path);

source/moving_sprite.cpp

@@ -28,7 +28,7 @@ MovingSprite::MovingSprite(std::shared_ptr<Texture> texture)
 	  rotate_(Rotate()),
 	  zoom_w_(1.0f),
 	  zoom_h_(1.0f),
-	  flip_(SDL_FLIP_NONE) { Sprite::clear(); }
+	  flip_(SDL_FLIP_NONE) {Sprite::clear(); }
 
 // Reinicia todas las variables
 void MovingSprite::clear()
@@ -73,46 +73,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 +96,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)
 {
@@ -203,28 +127,4 @@ 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,6 +3,7 @@
 #include <SDL2/SDL_rect.h>   // Para SDL_Rect, SDL_Point
 #include <SDL2/SDL_render.h> // Para SDL_RendererFlip
 #include <memory>            // Para shared_ptr
+#include <algorithm>
 #include "sprite.h"          // Para Sprite
 class Texture;               // lines 8-8
 
@@ -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();
@@ -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
@@ -298,7 +298,7 @@ void Notifier::showText(std::vector<std::string> texts, int icon, const std::str
 bool Notifier::isActive() { return !notifications_.empty(); }
 
 // Finaliza y elimnina todas las notificaciones activas
-void Notifier::clearNotifications()
+void Notifier::clearAllNotifications()
 {
     for (auto &notification : notifications_)
     {
@@ -317,4 +317,10 @@ std::vector<std::string> Notifier::getCodes()
         codes.emplace_back(notification.code);
     }
     return codes;
+}
+
+// Comprueba si hay alguna notificacion con un código
+bool Notifier::checkCode(std::string code)
+{
+    return stringInVector(getCodes(), code);
 }

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();
 
 	// Obtiene los códigos de las notificaciones
 	std::vector<std::string> getCodes();
+
+	// Comprueba si hay alguna notificacion con un código
+	bool checkCode(std::string code);
 };

source/options.cpp

@@ -44,6 +44,7 @@ void initOptions()
 	options.game.difficulty = GameDifficulty::NORMAL;
 	options.game.language = lang::Code::ba_BA;
 	options.game.autofire = true;
+	options.game.clear_last_hi_score_entries();
 
 	// Opciones de control
 	options.controllers.clear();

source/options.h

@@ -64,10 +64,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;							  // Indica si el jugador ha de pulsar repetidamente para disparar o basta con mantener pulsado
-	std::vector<HiScoreEntry> hi_score_table; // Tabla con las mejores puntuaciones
+    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;
+    }
 };
 
 // Estructura para los controles del juego

source/path_sprite.cpp

@@ -96,7 +96,7 @@ void PathSprite::addPath(std::vector<SDL_Point> spots, int waiting_counter)
 // Habilita el objeto
 void PathSprite::enable()
 {
-	if (paths_.size() == 0)
+	if (paths_.size() == 0 || enabled_)
 	{
 		return;
 	}
@@ -133,9 +133,13 @@ void PathSprite::moveThroughCurrentPath()
 	if (path.on_destination)
 	{
 		if (path.waiting_counter == 0)
+		{
 			path.finished = true;
+		}
 		else
+		{
 			--path.waiting_counter;
+		}
 	}
 }
 
@@ -144,11 +148,15 @@ void PathSprite::goToNextPathOrDie()
 {
 	// Comprueba si ha terminado el recorrdo actual
 	if (paths_.at(current_path_).finished)
+	{
 		++current_path_;
+	}
 
 	// Comprueba si quedan mas recorridos
 	if (current_path_ >= static_cast<int>(paths_.size()))
+	{
 		enabled_ = false;
+	}
 }
 
 // Indica si ha terminado todos los recorridos

source/path_sprite.h

@@ -65,8 +65,8 @@ public:
 
 	// Añade un recorrido
 	void addPath(Path path, bool centered = false);
-	void addPath(std::vector<SDL_Point> spots, int waiting_counter);
-	void addPath(int start, int end, PathType type, int fixed_pos, int steps, const std::function<double(double)> &easingFunction, int waiting_counter);
+	void addPath(std::vector<SDL_Point> spots, int waiting_counter = 0);
+	void addPath(int start, int end, PathType type, int fixed_pos, int steps, const std::function<double(double)> &easingFunction, int waiting_counter = 0);
 
 	// Habilita el objeto
 	void enable();

source/player.cpp

@@ -58,7 +58,7 @@ void Player::init()
 	score_ = 0;
 	score_multiplier_ = 1.0f;
 	cool_down_ = 10;
-	enter_name_->init();
+	enter_name_->init(last_enter_name_);
 
 	// Establece la posición del sprite
 	player_sprite_->clear();
@@ -148,6 +148,12 @@ void Player::setInputEnteringName(InputType input)
 		enter_name_->decIndex();
 		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;
@@ -165,9 +171,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;
@@ -175,12 +181,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();
 		}
@@ -286,7 +292,6 @@ void Player::move()
 			{
 				pos_x_ = param.game.game_area.rect.w - WIDTH_;
 				vel_x_ *= -1;
-				// setInputPlaying(InputType::LEFT);
 			}
 		}
 		else
@@ -296,7 +301,6 @@ void Player::move()
 			{
 				pos_x_ = param.game.game_area.rect.x;
 				vel_x_ *= -1;
-				// setInputPlaying(InputType::RIGHT);
 			}
 		}
 
@@ -355,17 +359,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
@@ -449,6 +456,7 @@ void Player::update()
 	updateInvulnerable();
 	updateContinueCounter();
 	updateEnterNameCounter();
+	updateShowingName();
 	updateScoreboard();
 }
 
@@ -474,7 +482,7 @@ void Player::updateScoreboard()
 	case PlayerState::ENTERING_NAME:
 	case PlayerState::ENTERING_NAME_GAME_COMPLETED:
 	{
-		Scoreboard::get()->setRecordName(getScoreBoardPanel(), enter_name_->getName());
+		Scoreboard::get()->setRecordName(getScoreBoardPanel(), enter_name_->getCurrentName());
 		Scoreboard::get()->setSelectorPos(getScoreBoardPanel(), getRecordNamePos());
 		break;
 	}
@@ -525,12 +533,19 @@ void Player::setPlayingState(PlayerState state)
 		setScoreboardMode(ScoreboardMode::ENTER_NAME);
 		break;
 	}
+	case PlayerState::SHOWING_NAME:
+	{
+		showing_name_ticks_ = SDL_GetTicks();
+		setScoreboardMode(ScoreboardMode::SHOW_NAME);
+		Scoreboard::get()->setRecordName(scoreboard_panel_, last_enter_name_);
+		break;
+	}
 	case PlayerState::DYING:
 	{
 		// Activa la animación de morir
 		player_sprite_->setAccelY(0.2f);
 		player_sprite_->setVelY(-6.6f);
-		rand() % 2 == 0 ? player_sprite_->setVelX(3.3f) : player_sprite_->setVelX(-3.3f);
+		(rand() % 2 == 0) ? player_sprite_->setVelX(3.3f) : player_sprite_->setVelX(-3.3f);
 		break;
 	}
 	case PlayerState::DIED:
@@ -546,6 +561,7 @@ void Player::setPlayingState(PlayerState state)
 	}
 	case PlayerState::CELEBRATING:
 	{
+		game_completed_ = true;
 		setScoreboardMode(ScoreboardMode::SCORE);
 		break;
 	}
@@ -711,6 +727,19 @@ void Player::updateEnterNameCounter()
 	}
 }
 
+// Actualiza el estado de SHOWING_NAME
+void Player::updateShowingName()
+{
+	if (playing_state_ == PlayerState::SHOWING_NAME)
+	{
+		constexpr int TICKS_SPEED = 5000;
+		if (SDL_GetTicks() - enter_name_ticks_ > TICKS_SPEED)
+		{
+			game_completed_ ? setPlayingState(PlayerState::LEAVING_SCREEN) : setPlayingState(PlayerState::CONTINUE);
+		}
+	}
+}
+
 // Decrementa el contador de continuar
 void Player::decContinueCounter()
 {

source/player.h

@@ -34,6 +34,7 @@ enum class PlayerState
 	CONTINUE,					  // Está con la cuenta atras para continuar
 	WAITING,					  // No está jugando pero puede entrar a jugar
 	ENTERING_NAME,				  // Introduciendo nombre
+	SHOWING_NAME,				  // Mostrando el nombre introducido
 	DYING,						  // El cadaver está volando por ahi
 	DIED,						  // El cadaver ha desaparecido por el fondo
 	GAME_OVER,					  // No está jugando y no puede entrar a jugar
@@ -92,7 +93,11 @@ private:
 	bool demo_;												// Para que el jugador sepa si está en el modo demostración
 	int enter_name_counter_;								// Contador para poner nombre
 	Uint32 enter_name_ticks_ = 0;							// Variable para poder cambiar el contador de poner nombre en función del tiempo
+	Uint32 showing_name_ticks_ = 0;							// Tiempo en el que se entra al estado SHOWING_NAME
 	int step_counter_ = 0;									// Cuenta los pasos para los estados en los que camina automáticamente
+	bool game_completed_ = false;							// Indica si ha completado el juego
+	int credits_used_ = 1;									// Indica el numero de veces que ha continuado
+	std::string last_enter_name_;							// Ultimo nombre introducido en la tabla de puntuaciones
 
 	// Actualiza el circulo de colisión a la posición del jugador
 	void shiftColliders();
@@ -109,6 +114,9 @@ private:
 	// Actualiza el contador de entrar nombre
 	void updateEnterNameCounter();
 
+	// Actualiza el estado de SHOWING_NAME
+	void updateShowingName();
+
 	// Decrementa el contador de entrar nombre
 	void decEnterNameCounter();
 
@@ -200,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; }
@@ -224,12 +233,14 @@ public:
 	int getPosX() const { return static_cast<int>(pos_x_); }
 	int getPosY() const { return pos_y_; }
 	int getPowerUpCounter() const { return power_up_counter_; }
-	std::string getRecordName() const { return enter_name_->getName(); }
+	std::string getRecordName() const { return enter_name_->getFinalName(); }
 	int getScore() const { return score_; }
 	int getScoreBoardPanel() const { return scoreboard_panel_; }
 	int getWidth() const { return WIDTH_; }
 	PlayerState getPlayingState() const { return playing_state_; }
 	std::string getName() const { return name_; }
+	bool get1CC() const { return game_completed_ && credits_used_ == 1; }
+	bool getEnterNamePositionOverflow() const { return enter_name_->getPositionOverflow(); }
 
 	// Setters
 	void setController(int index) { controller_index_ = index; }
@@ -242,4 +253,5 @@ public:
 	void setScoreBoardPanel(int panel) { scoreboard_panel_ = panel; }
 	void setScoreMultiplier(float value) { score_multiplier_ = value; }
 	void setWalkingState(PlayerState state) { walking_state_ = state; }
+	void addCredit() { ++credits_used_; }
 };

source/resource.cpp

@@ -301,6 +301,7 @@ void Resource::createTextures()
 
     // Tamaño doble
     std::vector<NameAndText> strings2X = {
+        NameAndText("game_text_100000_points", "100.000"),
         NameAndText("game_text_get_ready", lang::getText(75)),
         NameAndText("game_text_last_stage", lang::getText(79)),
         NameAndText("game_text_congratulations", lang::getText(50)),
@@ -314,22 +315,35 @@ void Resource::createTextures()
     }
 }
 
-// Crea los objetos de texto
 void Resource::createText()
 {
+    struct ResourceInfo
+    {
+        std::string key;         // Identificador del recurso
+        std::string textureFile; // Nombre del archivo de textura
+        std::string textFile;    // Nombre del archivo de texto
+
+        // Constructor para facilitar la creación de objetos ResourceInfo
+        ResourceInfo(const std::string &k, const std::string &tFile, const std::string &txtFile)
+            : key(k), textureFile(tFile), textFile(txtFile) {}
+    };
+
     std::cout << "\n>> CREATING TEXT_OBJECTS" << std::endl;
 
-    std::vector<std::pair<std::string, std::string>> resources = {
-        {"04b_25", "04b_25.png"},
-        {"04b_25_2x", "04b_25_2x.png"},
-        {"8bithud", "8bithud.png"},
-        {"nokia", "nokia.png"},
-        {"smb2", "smb2.gif"}};
+    std::vector<ResourceInfo> resources = {
+        {"04b_25", "04b_25.png", "04b_25.txt"},
+        {"04b_25_2x", "04b_25_2x.png", "04b_25_2x.txt"},
+        {"04b_25_metal", "04b_25_metal.png", "04b_25.txt"},
+        {"04b_25_grey", "04b_25_grey.png", "04b_25.txt"},
+        {"8bithud", "8bithud.png", "8bithud.txt"},
+        {"smb2", "smb2.gif", "smb2.txt"}};
 
     for (const auto &resource : resources)
     {
-        texts_.emplace_back(ResourceText(resource.first, std::make_shared<Text>(getTexture(resource.second), getTextFile(resource.first + ".txt"))));
-        printWithDots("Text : ", resource.first, "[  DONE  ]");
+        texts_.emplace_back(ResourceText(resource.key, std::make_shared<Text>(
+                                                           getTexture(resource.textureFile),
+                                                           getTextFile(resource.textFile))));
+        printWithDots("Text : ", resource.key, "[  DONE  ]");
     }
 }
 

source/scoreboard.cpp

@@ -10,7 +10,8 @@
 #include "screen.h"				// Para Screen
 #include "sprite.h"				// Para Sprite
 #include "text.h"				// Para Text
-#include "enter_name.h"
+#include "enter_name.h"			// Para NAME_LENGHT
+#include <iostream>
 
 // [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
 Scoreboard *Scoreboard::scoreboard_ = nullptr;
@@ -68,6 +69,9 @@ Scoreboard::Scoreboard()
 
 	// Rellena la textura de fondo
 	fillBackgroundTexture();
+
+	// Inicializa el vector de colores para el nombre
+	iniNameColors();
 }
 
 Scoreboard::~Scoreboard()
@@ -86,23 +90,23 @@ Scoreboard::~Scoreboard()
 	}
 }
 
-// Transforma un valor numérico en una cadena de 6 cifras
+// Transforma un valor numérico en una cadena de 7 cifras
 std::string Scoreboard::updateScoreText(int num)
 {
 	std::ostringstream oss;
-	oss << std::setw(8) << std::setfill('0') << num;
+	oss << std::setw(7) << std::setfill('0') << num;
 	return oss.str();
 }
 
 // Actualiza el contador
-void Scoreboard::updateCounter()
+void Scoreboard::updateTimeCounter()
 {
 	constexpr int TICKS_SPEED = 100;
 
 	if (SDL_GetTicks() - ticks_ > TICKS_SPEED)
 	{
 		ticks_ = SDL_GetTicks();
-		counter_++;
+		++time_counter_;
 	}
 }
 
@@ -110,7 +114,8 @@ void Scoreboard::updateCounter()
 void Scoreboard::update()
 {
 	fillBackgroundTexture();
-	updateCounter();
+	updateTimeCounter();
+	++loop_counter_;
 }
 
 // Pinta el marcador
@@ -150,7 +155,7 @@ void Scoreboard::fillPanelTextures()
 	// Guarda a donde apunta actualmente el renderizador
 	auto temp = SDL_GetRenderTarget(renderer_);
 
-	// Genera el contenidoi de cada panel_
+	// Genera el contenido de cada panel_
 	for (size_t i = 0; i < SCOREBOARD_MAX_PANELS; ++i)
 	{
 		// Cambia el destino del renderizador
@@ -180,7 +185,7 @@ void Scoreboard::fillPanelTextures()
 			text_scoreboard_->writeCentered(slot4_1_.x, slot4_1_.y + 4, lang::getText(101));
 
 			// PRESS START TO PLAY
-			if (counter_ % 10 < 8)
+			if (time_counter_ % 10 < 8)
 			{
 				text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y - 2, lang::getText(103));
 				text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y - 2, lang::getText(104));
@@ -194,7 +199,7 @@ void Scoreboard::fillPanelTextures()
 			text_scoreboard_->writeCentered(slot4_1_.x, slot4_1_.y + 4, lang::getText(102));
 
 			// PRESS START TO PLAY
-			if (counter_ % 10 < 8)
+			if (time_counter_ % 10 < 8)
 			{
 				text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y - 2, lang::getText(103));
 				text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y - 2, lang::getText(104));
@@ -208,7 +213,7 @@ void Scoreboard::fillPanelTextures()
 			text_scoreboard_->writeCentered(slot4_1_.x, slot4_1_.y + 4, lang::getText(102));
 
 			// PLEASE WAIT
-			if (counter_ % 10 < 8)
+			if (time_counter_ % 10 < 8)
 			{
 				text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y - 2, lang::getText(114));
 				text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y - 2, lang::getText(115));
@@ -253,27 +258,54 @@ void Scoreboard::fillPanelTextures()
 			text_scoreboard_->writeCentered(slot4_2_.x, slot4_2_.y, updateScoreText(score_[i]));
 
 			// ENTER NAME
-			text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y, lang::getText(106));
-			SDL_Rect rect = {enter_name_pos_.x, enter_name_pos_.y, 5, 7};
-			SDL_SetRenderDrawColor(renderer_, 0xFF, 0xFF, 0xEB, 255);
-			for (size_t j = 0; j < record_name_[i].size(); ++j)
 			{
-				if (j != selector_pos_[i] || counter_ % 3 == 0)
+				text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y, lang::getText(106));
+				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 < MAX_NAME_LENGHT; ++j)
 				{
-					SDL_RenderDrawLine(renderer_, rect.x, rect.y + rect.h, rect.x + rect.w, rect.y + rect.h);
-					text_scoreboard_->write(rect.x, rect.y, record_name_[i].substr(j, 1));
+					// Selecciona el color
+					const Color color = j < selector_pos_[i] ? orange_soft_color.lighten() : Color(0xFF, 0xFF, 0xEB);
+
+					if (j != selector_pos_[i] || time_counter_ % 3 == 0)
+					{
+						// Dibuja la linea
+						if (j >= selector_pos_[i])
+						{
+							SDL_SetRenderDrawColor(renderer_, color.r, color.g, color.b, 255);
+							SDL_RenderDrawLine(renderer_, rect.x, rect.y + rect.h, rect.x + rect.w, rect.y + rect.h);
+						}
+
+						// Dibuja la letra
+						if (j < record_name_->size())
+						{
+							text_scoreboard_->writeColored(rect.x, rect.y, record_name_[i].substr(j, 1), color);
+						}
+					}
+					rect.x += 7;
 				}
-				rect.x += 7;
 			}
 			break;
 		}
+		case ScoreboardMode::SHOW_NAME:
+		{
+			// SCORE
+			text_scoreboard_->writeCentered(slot4_1_.x, slot4_1_.y, name_[i]);
+			text_scoreboard_->writeCentered(slot4_2_.x, slot4_2_.y, updateScoreText(score_[i]));
+
+			// 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));
+			break;
+		}
 		case ScoreboardMode::GAME_COMPLETED:
 		{
 			// GAME OVER
 			text_scoreboard_->writeCentered(slot4_1_.x, slot4_1_.y + 4, lang::getText(102));
 
 			// SCORE
-			if (counter_ % 10 < 8)
+			if (time_counter_ % 10 < 8)
 			{
 				text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y - 2, lang::getText(120));
 				text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y - 2, updateScoreText(score_[i]));
@@ -319,27 +351,27 @@ void Scoreboard::fillBackgroundTexture()
 void Scoreboard::recalculateAnchors()
 {
 	// Recalcula la posición y el tamaño de los paneles
-	const float panelWidth = (float)rect_.w / (float)SCOREBOARD_MAX_PANELS;
+	const float panel_width = (float)rect_.w / (float)SCOREBOARD_MAX_PANELS;
 	for (int i = 0; i < SCOREBOARD_MAX_PANELS; ++i)
 	{
-		panel_[i].pos.x = roundf(panelWidth * i);
+		panel_[i].pos.x = roundf(panel_width * i);
 		panel_[i].pos.y = 0;
-		panel_[i].pos.w = roundf(panelWidth * (i + 1)) - panel_[i].pos.x;
+		panel_[i].pos.w = roundf(panel_width * (i + 1)) - panel_[i].pos.x;
 		panel_[i].pos.h = rect_.h;
 	}
 
 	// Constantes para definir las zonas del panel_: 4 filas y 1 columna
-	const int rowSize = rect_.h / 4;
-	const int textHeight = 7;
+	const int row_size = rect_.h / 4;
+	const int text_height = 7;
 
 	// Filas
-	const int row1 = (rowSize * 0) + (textHeight / 2);
-	const int row2 = (rowSize * 1) + (textHeight / 2) - 1;
-	const int row3 = (rowSize * 2) + (textHeight / 2) - 2;
-	const int row4 = (rowSize * 3) + (textHeight / 2) - 3;
+	const int row1 = (row_size * 0) + (text_height / 2);
+	const int row2 = (row_size * 1) + (text_height / 2) - 1;
+	const int row3 = (row_size * 2) + (text_height / 2) - 2;
+	const int row4 = (row_size * 3) + (text_height / 2) - 3;
 
 	// Columna
-	const int col = panelWidth / 2;
+	const int col = panel_width / 2;
 
 	// Slots de 4
 	slot4_1_ = {col, row1};
@@ -348,8 +380,8 @@ void Scoreboard::recalculateAnchors()
 	slot4_4_ = {col, row4};
 
 	// Primer cuadrado para poner el nombre de record
-	const int enterNameLenght = NAME_LENGHT * 7;
-	enter_name_pos_.x = (panelWidth - enterNameLenght) / 2;
+	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;
 
 	// Recoloca los sprites
@@ -402,4 +434,14 @@ void Scoreboard::renderSeparator()
 	// Dibuja la linea que separa el marcador de la zona de juego
 	SDL_SetRenderDrawColor(renderer_, separator_color.r, separator_color.g, separator_color.b, 255);
 	SDL_RenderDrawLine(renderer_, 0, 0, rect_.w, 0);
+}
+
+// Inicializa el vector de colores para el nombre
+void Scoreboard::iniNameColors()
+{
+	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));
 }

source/scoreboard.h

@@ -29,6 +29,7 @@ enum class ScoreboardMode : int
 	GAME_OVER,
 	DEMO,
 	ENTER_NAME,
+	SHOW_NAME,
 	GAME_COMPLETED,
 	NUM_MODES,
 };
@@ -72,7 +73,9 @@ private:
 	Color color_ = Color();								  // Color del marcador
 	SDL_Rect rect_ = {0, 0, 320, 40};					  // Posición y dimensiones del marcador
 	Uint32 ticks_ = SDL_GetTicks();						  // Variable donde almacenar el valor de SDL_GetTiks()
-	int counter_ = 0;									  // Contador
+	int time_counter_ = 0;								  // Contador de segundos
+	int loop_counter_ = 0;								  // Contador de bucle
+	std::vector<Color> name_colors_;					  // Colores para destacar el nombre una vez introducido
 
 	// Puntos predefinidos para colocar elementos en los paneles
 	SDL_Point slot4_1_, slot4_2_, slot4_3_, slot4_4_;
@@ -81,7 +84,7 @@ private:
 	// Recalcula las anclas de los elementos
 	void recalculateAnchors();
 
-	// Transforma un valor numérico en una cadena de 6 cifras
+	// Transforma un valor numérico en una cadena de 7 cifras
 	std::string updateScoreText(int num);
 
 	// Crea la textura de fondo
@@ -97,11 +100,14 @@ private:
 	void fillBackgroundTexture();
 
 	// Actualiza el contador
-	void updateCounter();
+	void updateTimeCounter();
 
 	// Dibuja la linea que separa la zona de juego del marcador
 	void renderSeparator();
 
+	// Inicializa el vector de colores para el nombre
+	void iniNameColors();
+
 	// [SINGLETON] Ahora el constructor y el destructor son privados
 
 	// Constructor

source/screen.cpp

@@ -15,27 +15,24 @@
 #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
+// [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
+// [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
+// [SINGLETON] Con este método obtenemos el objeto y podemos trabajar con él
 Screen *Screen::get()
 {
     return Screen::screen_;
@@ -89,24 +86,22 @@ void Screen::render()
     // Dibuja efectos y elementos sobre el game_canvas_
     renderFlash();
     renderAttenuate();
+    renderShake();
     OnScreenHelp::get()->render();
     renderInfo();
     Notifier::get()->render();
 
-    // Restablece el objetivo de renderizado al buffer de pantalla predeterminado
-    SDL_SetRenderTarget(renderer_, nullptr);
-
-    // Renderiza el contenido del game_canvas_ o aplica shaders según configuración
+    // Renderiza el contenido del game_canvas_
     renderScreen();
 }
 
-// Selecciona y ejecuta el método de renderizado adecuado basado en la configuración de shaders
+// Renderiza el contenido del game_canvas_
 void Screen::renderScreen()
 {
-#ifdef NO_SHADERS
-    // Actualiza la pantalla con el contenido del game_canvas_
-    presentGameCanvas();
-#else
+    // Restablece el objetivo de renderizado al buffer de pantalla predeterminado
+    SDL_SetRenderTarget(renderer_, nullptr);
+    clean();
+
     if (options.video.shaders)
     {
         // Aplica shaders y renderiza el contenido
@@ -114,10 +109,10 @@ void Screen::renderScreen()
     }
     else
     {
-        // Actualiza la pantalla con el contenido del game_canvas_
-        presentGameCanvas();
+        // 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
@@ -170,13 +165,11 @@ void Screen::setVideoMode(ScreenVideoMode videoMode)
     // 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
     }
 }
 
@@ -311,13 +304,40 @@ void Screen::renderAttenuate()
     }
 }
 
+// Aplica el efecto de agitar la pantalla
+void Screen::renderShake()
+{
+    if (shake_effect_.enabled)
+    {
+        // Guarda el renderizador actual para dejarlo despues como estaba
+        auto current_target = SDL_GetRenderTarget(renderer_);
+
+        // Crea una textura temporal
+        auto temp_texture = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height);
+
+        // Vuelca game_canvas_ a la textura temporal
+        SDL_SetRenderTarget(renderer_, temp_texture);
+        SDL_RenderCopy(renderer_, game_canvas_, nullptr, nullptr);
+
+        // Vuelca textura temporal a game_canvas_
+        SDL_SetRenderTarget(renderer_, game_canvas_);
+        SDL_RenderCopy(renderer_, temp_texture, &src_rect_, &dst_rect_);
+
+        // Elimina la textura temporal
+        SDL_DestroyTexture(temp_texture);
+
+        // Restaura el renderizador de destino original
+        SDL_SetRenderTarget(renderer_, current_target);
+    }
+}
+
 // Activa / desactiva los shaders
 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});
+    Notifier::get()->show({"Shaders " + value});
 }
 
 // Activa / desactiva la información de debug
@@ -332,12 +352,6 @@ void Screen::attenuate(bool value)
     attenuate_effect_ = value;
 }
 
-// Obtiene el puntero al renderizador
-SDL_Renderer *Screen::getRenderer()
-{
-    return renderer_;
-}
-
 // Calcula los frames por segundo
 void Screen::updateFPS()
 {
@@ -363,10 +377,9 @@ void Screen::renderInfo()
 
         // Contador de service_pressed_counter
         if (const int counter = globalInputs::service_pressed_counter; counter > 0)
+        {
             dbg_print(0, 8, std::to_string(counter).c_str(), 255, 0, 255);
-
-        const std::string atten = attenuate_effect_ ? "ATTEN YES" : "ATTEN NO";
-        dbg_print(0, 16, atten.c_str(), 255, 0, 0);
+        }
     }
 }
 
@@ -404,19 +417,4 @@ SDL_Point Screen::getNewPosition()
     new_pos.y = std::clamp(new_pos.y, 30, DM.h - new_height);
 
     return new_pos;
-}
-
-// Actualiza la pantalla con el contenido del game_canvas_
-void Screen::presentGameCanvas()
-{
-    // Copia la textura de juego en el renderizador en la posición adecuada
-    if (shake_effect_.enabled)
-    {
-        // Esta copia es para evitar que se vea negro por los laterales
-        SDL_RenderCopy(renderer_, game_canvas_, nullptr, nullptr);
-    }
-    SDL_RenderCopy(renderer_, game_canvas_, &src_rect_, &dst_rect_);
-
-    // Actualiza la pantalla con el contenido del buffer de renderizado
-    SDL_RenderPresent(renderer_);
 }

source/screen.h

@@ -24,13 +24,13 @@ enum class ScreenVideoMode : int
 class Screen
 {
 private:
-	// [SINGLETON] Objeto screen privado para Don Melitón
+	// [SINGLETON] Objeto privado
 	static Screen *screen_;
 
 	// Objetos y punteros
-	SDL_Window *window_;		 // Ventana de la aplicación
-	SDL_Renderer *renderer_;	 // El renderizador de la ventana
-	SDL_Texture *game_canvas_;	 // Textura donde se dibuja todo antes de volcarse al renderizador
+	SDL_Window *window_;	   // Ventana de la aplicación
+	SDL_Renderer *renderer_;   // El renderizador de la ventana
+	SDL_Texture *game_canvas_; // Textura donde se dibuja todo antes de volcarse al renderizador
 
 	// Variables
 	SDL_Rect src_rect_;				// Coordenadas de donde va a pillar la textura del juego para dibujarla
@@ -98,6 +98,9 @@ private:
 	// Atenua la pantalla
 	void renderAttenuate();
 
+	// Aplica el efecto de agitar la pantalla
+	void renderShake();
+
 	// Calcula los frames por segundo
 	void updateFPS();
 
@@ -107,14 +110,9 @@ private:
 	// Calcula la nueva posición de la ventana a partir de la antigua al cambiarla de tamaño
 	SDL_Point getNewPosition();
 
-	// Actualiza la pantalla con el contenido del game_canvas_
-	void presentGameCanvas();
-
 	// Selecciona y ejecuta el método de renderizado adecuado basado en la configuración de shaders
 	void renderScreen();
 
-	// [SINGLETON] Ahora el constructor y el destructor son privados, para no poder crear objetos screen desde fuera
-
 	// Constructor
 	Screen(SDL_Window *window, SDL_Renderer *renderer);
 
@@ -122,13 +120,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
@@ -179,6 +177,6 @@ public:
 	// Atenua la pantalla
 	void attenuate(bool value);
 
-	// Obtiene el puntero al renderizador
-	SDL_Renderer *getRenderer();
+	// Getters
+	SDL_Renderer *getRenderer() { return renderer_; }
 };

source/smart_sprite.cpp

@@ -2,10 +2,6 @@
 #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 +13,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
@@ -114,22 +101,4 @@ void SmartSprite::checkFinished()
 			--finished_counter_;
 		}
 	}
-}
-
-// 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,7 +24,8 @@ private:
 
 public:
 	// Constructor
-	explicit SmartSprite(std::shared_ptr<Texture> texture);
+	explicit SmartSprite(std::shared_ptr<Texture> texture)
+		: AnimatedSprite(texture) {}
 
 	// Destructor
 	~SmartSprite() = default;
@@ -32,27 +33,18 @@ public:
 	// 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/sprite.h

@@ -37,6 +37,7 @@ public:
 
     // Devuelve el rectangulo donde está el sprite
     SDL_Rect getPosition() const { return pos_; }
+    SDL_Rect &getRect() { return pos_; }
 
     // Establece la posición y el tamaño
     void setX(int x) { pos_.x = x; }

source/tabe.cpp

@@ -1,15 +1,18 @@
 // IWYU pragma: no_include <bits/std_abs.h>
 #include "tabe.h"
 #include <SDL2/SDL_render.h> // Para SDL_FLIP_HORIZONTAL, SDL_FLIP_NONE
-#include <stdlib.h>          // Para rand, abs
-#include "jail_audio.h"      // Para JA_PlaySound
-#include "param.h"           // Para Param, ParamGame, param
-#include "resource.h"        // Para Resource
-#include "utils.h"           // Para Zone
+#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
 
 // Constructor
 Tabe::Tabe()
-    : sprite_(std::make_unique<AnimatedSprite>(Resource::get()->getTexture("tabe.png"), Resource::get()->getAnimation("tabe.ani"))) {}
+    : sprite_(std::make_unique<AnimatedSprite>(Resource::get()->getTexture("tabe.png"), Resource::get()->getAnimation("tabe.ani"))),
+      timer_(TabeTimer(2.5f, 4.0f)) {}
 
 // Actualiza la lógica
 void Tabe::update()
@@ -18,6 +21,12 @@ void Tabe::update()
     {
         sprite_->update();
         move();
+        updateState();
+    }
+    timer_.update();
+    if (timer_.should_spawn())
+    {
+        enable();
     }
 }
 
@@ -47,7 +56,7 @@ void Tabe::move()
     {
         if (x_ < min_x)
         {
-            enabled_ = false;
+            disable();
         }
         if (x_ > param.game.game_area.rect.x + param.game.game_area.rect.w - WIDTH_ && direction_ == TabeDirection::TO_THE_RIGHT)
         {
@@ -61,7 +70,7 @@ void Tabe::move()
     {
         if (x_ > max_x)
         {
-            enabled_ = false;
+            disable();
         }
         if (x_ < param.game.game_area.rect.x && direction_ == TabeDirection::TO_THE_LEFT)
         {
@@ -100,7 +109,10 @@ void Tabe::enable()
     if (!enabled_)
     {
         enabled_ = true;
-        y_ = 20.0f;
+        has_bonus_ = true;
+        hit_counter_ = 0;
+        number_of_hits_ = 0;
+        y_ = param.game.game_area.rect.y + 20.0f;
 
         // Establece una dirección aleatoria
         destiny_ = direction_ = rand() % 2 == 0 ? TabeDirection::TO_THE_LEFT : TabeDirection::TO_THE_RIGHT;
@@ -145,4 +157,68 @@ void Tabe::setRandomFlyPath(TabeDirection direction, int lenght)
     default:
         break;
     }
+}
+
+// Establece el estado
+void Tabe::setState(TabeState state)
+{
+    if (enabled_)
+    {
+        state_ = state;
+
+        switch (state)
+        {
+        case TabeState::FLY:
+            sprite_->setCurrentAnimation("fly");
+            break;
+
+        case TabeState::HIT:
+            sprite_->setCurrentAnimation("hit");
+            hit_counter_ = 5;
+            ++number_of_hits_;
+            break;
+
+        default:
+            break;
+        }
+    }
+}
+
+// Actualiza el estado
+void Tabe::updateState()
+{
+    if (state_ == TabeState::HIT)
+    {
+        --hit_counter_;
+        if (hit_counter_ == 0)
+        {
+            setState(TabeState::FLY);
+        }
+    }
+}
+
+// Intenta obtener el bonus
+bool Tabe::tryToGetBonus()
+{
+    if (has_bonus_ && rand() % std::max(1, 15 - number_of_hits_) == 0)
+    {
+        has_bonus_ = false;
+        return true;
+    }
+    return false;
+}
+
+// Actualiza el temporizador
+void Tabe::updateTimer()
+{
+    timer_.current_time = SDL_GetTicks();
+    timer_.delta_time = timer_.current_time - timer_.last_time;
+    timer_.last_time = timer_.current_time;
+}
+
+// Deshabilita el objeto
+void Tabe::disable()
+{
+    enabled_ = false;
+    timer_.reset();
 }

source/tabe.h

@@ -1,7 +1,9 @@
 #pragma once
 
-#include "animated_sprite.h"
-#include <memory>
+#include <SDL2/SDL_rect.h>   // Para SDL_Rect
+#include <SDL2/SDL.h>
+#include <memory>            // Para unique_ptr
+#include "animated_sprite.h" // Para AnimatedSprite
 
 enum class TabeDirection : int
 {
@@ -9,6 +11,61 @@ enum class TabeDirection : int
     TO_THE_RIGHT = 1,
 };
 
+enum class TabeState : int
+{
+    FLY = 0,
+    HIT = 1,
+};
+
+struct TabeTimer
+{
+    Uint32 time_until_next_spawn; // Tiempo restante para la próxima aparición
+    Uint32 min_spawn_time;        // Tiempo mínimo entre apariciones
+    Uint32 max_spawn_time;        // Tiempo máximo entre apariciones
+    Uint32 current_time;          // Tiempo actual
+    Uint32 delta_time;            // Diferencia de tiempo desde la última actualización
+    Uint32 last_time;             // Tiempo de la última actualización
+
+    // Constructor
+    TabeTimer(float minTime, float maxTime)
+        : min_spawn_time(minTime * 60000), max_spawn_time(maxTime * 60000)
+    {
+        current_time = SDL_GetTicks();
+        reset();
+    }
+
+    // Restablece el temporizador con un nuevo tiempo hasta la próxima aparición
+    void reset()
+    {
+        Uint32 range = max_spawn_time - min_spawn_time;
+        time_until_next_spawn = min_spawn_time + rand() % (range + 1);
+        last_time = SDL_GetTicks();
+    }
+
+    // Actualiza el temporizador, decrementando el tiempo hasta la próxima aparición
+    void update()
+    {
+        current_time = SDL_GetTicks();
+        delta_time = current_time - last_time;
+        last_time = current_time;
+
+        if (time_until_next_spawn > delta_time)
+        {
+            time_until_next_spawn -= delta_time;
+        }
+        else
+        {
+            time_until_next_spawn = 0;
+        }
+    }
+
+    // Indica si el temporizador ha finalizado
+    bool should_spawn() const
+    {
+        return time_until_next_spawn == 0;
+    }
+};
+
 // Clase Tabe
 class Tabe
 {
@@ -21,15 +78,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
+    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
 
     // Mueve el objeto
     void move();
@@ -40,6 +102,15 @@ private:
     // Establece un vuelo aleatorio
     void setRandomFlyPath(TabeDirection direction, int lenght);
 
+    // Actualiza el estado
+    void updateState();
+
+    // Actualiza el temporizador
+    void updateTimer();
+
+    // Deshabilita el objeto
+    void disable();
+
 public:
     // Constructor
     Tabe();
@@ -55,4 +126,16 @@ public:
 
     // Habilita el objeto
     void enable();
+
+    // Establece el estado
+    void setState(TabeState state);
+
+    // Intenta obtener el bonus
+    bool tryToGetBonus();
+
+    // Obtiene el area de colisión
+    SDL_Rect &getCollider() { return sprite_->getRect(); }
+
+    // Getters
+    bool isEnabled() const { return enabled_; }
 };

source/text.cpp

@@ -173,6 +173,25 @@ std::shared_ptr<Texture> Text::writeToTexture(const std::string &text, int zoom,
 	return texture;
 }
 
+// Escribe el texto con extras en una textura
+std::shared_ptr<Texture> Text::writeDXToTexture(Uint8 flags, const std::string &text, int kerning, Color textColor, Uint8 shadow_distance, Color shadow_color, int lenght)
+{
+	auto renderer = Screen::get()->getRenderer();
+	auto texture = std::make_shared<Texture>(renderer);
+	auto width = Text::lenght(text, kerning) + shadow_distance;
+	auto height = box_height_ + shadow_distance;
+	auto temp = SDL_GetRenderTarget(renderer);
+	texture->createBlank(width, height, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET);
+	texture->setBlendMode(SDL_BLENDMODE_BLEND);
+	texture->setAsRenderTarget(renderer);
+	SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
+	SDL_RenderClear(renderer);
+	writeDX(flags, 0, 0, text, kerning, textColor, shadow_distance, shadow_color, lenght);
+	SDL_SetRenderTarget(renderer, temp);
+
+	return texture;
+}
+
 // Escribe el texto con colores
 void Text::writeColored(int x, int y, const std::string &text, Color color, int kerning, int lenght)
 {
@@ -272,7 +291,7 @@ void Text::setFixedWidth(bool value)
 void Text::setPalette(int number)
 {
 	auto temp = SDL_GetRenderTarget(Screen::get()->getRenderer());
-    SDL_SetRenderTarget(Screen::get()->getRenderer(), nullptr);
+	SDL_SetRenderTarget(Screen::get()->getRenderer(), nullptr);
 	sprite_->getTexture()->setPalette(number);
-    SDL_SetRenderTarget(Screen::get()->getRenderer(), temp);
+	SDL_SetRenderTarget(Screen::get()->getRenderer(), temp);
 }

source/text.h

@@ -55,6 +55,9 @@ public:
 	// Escribe el texto en una textura
 	std::shared_ptr<Texture> writeToTexture(const std::string &text, int zoom = 1, int kerning = 1);
 
+	// Escribe el texto con extras en una textura
+	std::shared_ptr<Texture> writeDXToTexture(Uint8 flags, const std::string &text, int kerning = 1, Color textColor = Color(), Uint8 shadow_distance = 1, Color shadow_color = Color(), int lenght = -1);
+
 	// Escribe el texto con colores
 	void writeColored(int x, int y, const std::string &text, Color color, int kerning = 1, int lenght = -1);
 

source/texture.cpp

@@ -164,6 +164,10 @@ void Texture::setColor(Uint8 red, Uint8 green, Uint8 blue)
 {
 	SDL_SetTextureColorMod(texture_, red, green, blue);
 }
+void Texture::setColor(Color color)
+{
+	SDL_SetTextureColorMod(texture_, color.r, color.g, color.b);
+}
 
 // Establece el blending
 void Texture::setBlendMode(SDL_BlendMode blending)

source/texture.h

@@ -1,13 +1,14 @@
 #pragma once
 
-#include <SDL2/SDL_blendmode.h> // para SDL_BlendMode
-#include <SDL2/SDL_pixels.h>    // para SDL_PIXELFORMAT_RGBA8888, SDL_PixelF...
-#include <SDL2/SDL_rect.h>      // para SDL_Point, SDL_Rect
-#include <SDL2/SDL_render.h>    // para SDL_Renderer, SDL_FLIP_NONE, SDL_TEX...
-#include <SDL2/SDL_stdinc.h>    // para Uint8, Uint32, Uint16
-#include <string>               // para string, basic_string
-#include <vector>               // para vector
-#include <memory>
+#include <SDL2/SDL_blendmode.h> // Para SDL_BlendMode
+#include <SDL2/SDL_pixels.h>    // Para SDL_PIXELFORMAT_RGBA8888, SDL_PixelF...
+#include <SDL2/SDL_rect.h>      // Para SDL_Point, SDL_Rect
+#include <SDL2/SDL_render.h>    // Para SDL_Renderer, SDL_FLIP_NONE, SDL_TEX...
+#include <SDL2/SDL_stdinc.h>    // Para Uint8, Uint16, Uint32
+#include <memory>               // Para shared_ptr
+#include <string>               // Para string
+#include <vector>               // Para vector
+struct Color;
 
 // Definiciones de tipos
 struct Surface
@@ -65,6 +66,7 @@ public:
 
     // Establece el color para la modulacion
     void setColor(Uint8 red, Uint8 green, Uint8 blue);
+    void setColor(Color color);
 
     // Establece el blending
     void setBlendMode(SDL_BlendMode blending);

source/title.cpp

@@ -375,7 +375,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 +404,5 @@ 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)});
 }

source/utils.cpp

@@ -13,16 +13,40 @@
 Overrides overrides = Overrides();
 
 // Colores
-const Color bg_color = Color(0x27, 0x27, 0x36);
-const Color no_color = Color(0xFF, 0xFF, 0xFF);
-const Color shdw_txt_color = Color(0x43, 0x43, 0x4F);
-const Color separator_color = Color(0x0D, 0x1A, 0x2B);
-const Color scoreboard_easy_color = Color(0x4B, 0x69, 0x2F);
-const Color scoreboard_normal_color = Color(0x2E, 0x3F, 0x47);
-const Color scoreboard_hard_color = Color(0x76, 0x42, 0x8A);
-const Color flash_color = Color(0xFF, 0xFF, 0xFF);
-const Color fade_color = Color(0x27, 0x27, 0x36);
-const Color orange_color = Color(0xFF, 0x7A, 0x00);
+const Color bg_color = Color(0X27, 0X27, 0X36);
+const Color no_color = Color(0XFF, 0XFF, 0XFF);
+const Color shdw_txt_color = Color(0X43, 0X43, 0X4F);
+const Color separator_color = Color(0X0D, 0X1A, 0X2B);
+const Color scoreboard_easy_color = Color(0X4B, 0X69, 0X2F);
+const Color scoreboard_normal_color = Color(0X2E, 0X3F, 0X47);
+const Color scoreboard_hard_color = Color(0X76, 0X42, 0X8A);
+const Color flash_color = Color(0XFF, 0XFF, 0XFF);
+const Color fade_color = Color(0X27, 0X27, 0X36);
+const Color orange_color = Color(0XFF, 0X7A, 0X00);
+const Color orange_soft_color = Color(0XFF, 0XA0, 0X33);
+const Color green_color = Color(0X5B, 0XEC, 0X95);
+const Color blue_sky_color = Color(0X02, 0X88, 0XD1);
+const Color pink_sky_color = Color(0XFF, 0X6B, 0X97);
+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;
+
+    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];
+}
 
 // Calcula el cuadrado de la distancia entre dos puntos
 double distanceSquared(int x1, int y1, int x2, int y2)
@@ -212,6 +236,12 @@ double easeInOutSine(double t)
     return -0.5 * (std::cos(M_PI * t) - 1);
 }
 
+// Función de suavizado
+double easeInOut(double t)
+{
+    return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
+}
+
 // Comprueba si una vector contiene una cadena
 bool stringInVector(const std::vector<std::string> &vec, const std::string &str)
 {
@@ -309,4 +339,4 @@ std::string getPath(const std::string &full_path)
 {
     std::filesystem::path path(full_path);
     return path.parent_path().string();
-}
+}

source/utils.h

@@ -44,6 +44,30 @@ struct Color
 	Uint8 r, g, b;
 	constexpr Color() : r(0), g(0), b(0) {}
 	explicit constexpr Color(int red, int green, int blue) : r(red), g(green), b(blue) {}
+
+	// Método para obtener el color inverso
+	constexpr Color getInverse() const
+	{
+		return Color(255 - r, 255 - g, 255 - b);
+	}
+
+	// Método para aclarar el color
+	Color lighten(int amount = 50) const
+	{
+		return Color(
+			std::min(255, r + amount),
+			std::min(255, g + amount),
+			std::min(255, b + amount));
+	}
+
+	// Método para oscurecer el color
+	Color darken(int amount = 50) const
+	{
+		return Color(
+			std::max(0, r - amount),
+			std::max(0, g - amount),
+			std::max(0, b - amount));
+	}
 };
 
 // Posiciones de las notificaciones
@@ -100,6 +124,9 @@ struct Zone
 	int third_quarter_y; // Anclaje al 75% del eje X
 };
 
+// Obtiene un color del vector de colores imitando al Coche Fantástico
+Color getColorLikeKnightRider(const std::vector<Color> &colors, int counter_);
+
 // Calcula el cuadrado de la distancia entre dos puntos
 double distanceSquared(int x1, int y1, int x2, int y2);
 
@@ -146,6 +173,7 @@ double easeInOutQuint(double t);
 double easeInQuad(double t);
 double easeOutQuad(double t);
 double easeInOutSine(double t);
+double easeInOut(double t);
 
 // Comprueba si una vector contiene una cadena
 bool stringInVector(const std::vector<std::string> &vec, const std::string &str);
@@ -177,4 +205,9 @@ extern const Color scoreboard_normal_color;
 extern const Color scoreboard_hard_color;
 extern const Color flash_color;
 extern const Color fade_color;
-extern const Color orange_color;
+extern const Color orange_color;
+extern const Color orange_soft_color;
+extern const Color green_color;
+extern const Color blue_sky_color;
+extern const Color pink_sky_color;
+extern const Color green_sky_color;