EnterName: si has plenat tots els slots de lletres, apretar una volta mes el de fixar lletra fixa el nom

Pos pense que ja està tot apanyat lo de EnterName i Scoreboard
Afegit position_overflow_ per a EnterName i poder plenar tots els slots de lletres
2025-02-07 14:15:18 +01:00 · 2025-02-07 13:45:07 +01:00 · 2025-02-07 12:31:59 +01:00 · 2025-02-06 20:58:15 +01:00 · 2025-02-06 14:59:25 +01:00 · 2025-02-06 12:36:16 +01:00
59 changed files with 1332 additions and 616 deletions
--- a/2
+++ b/2
@@ -11,7 +11,7 @@ APP_NAME       := Coffee Crisis Arcade Edition
 RELEASE_FOLDER := ccae_release
 RELEASE_FILE   := $(RELEASE_FOLDER)/$(TARGET_NAME)
 RESOURCE_FILE  := release/coffee.res
-VERSION        := 2025-01-05
+VERSION        := 2025-02-07

 # Nombres para los ficheros de lanzamiento
 WINDOWS_RELEASE             := $(TARGET_NAME)-$(VERSION)-win32-x64.zip
--- a/README.md
+++ b/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_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/ccae1.png" alt="Joc" width="45%" />
+    <img src="https://php.sustancia.synology.me/images/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/ccae2.png" alt="Joc" width="50%" />
 </p>

 ## Com instal·lar i jugar
--- a/data/font/04b_25_grey.png
+++ b/data/font/04b_25_grey.png
--- a/data/font/04b_25_metal.png
+++ b/data/font/04b_25_metal.png
--- a/data/font/nokia.png
+++ b/data/font/nokia.png
--- a/data/font/nokia.txt
+++ b/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
--- a/data/font/smb2.gif
+++ b/data/font/smb2.gif
--- a/data/gfx/item/item_debian.ani
+++ b/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]
--- a/data/gfx/item/item_debian.png
+++ b/data/gfx/item/item_debian.png
--- a/data/gfx/tabe/tabe.ani
+++ b/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]
--- a/data/gfx/tabe/tabe.png
+++ b/data/gfx/tabe/tabe.png
--- a/data/lang/ba_BA.txt
+++ b/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
--- a/data/sound/coffee_out.wav
+++ b/data/sound/coffee_out.wav
--- a/data/sound/debian_drop.wav
+++ b/data/sound/debian_drop.wav
--- a/data/sound/debian_pickup.wav
+++ b/data/sound/debian_pickup.wav
--- a/data/sound/hi_score_achieved.wav
+++ b/data/sound/hi_score_achieved.wav
--- a/data/sound/item_drop.wav
+++ b/data/sound/item_drop.wav
--- a/data/sound/item_pickup.wav
+++ b/data/sound/item_pickup.wav
--- a/data/sound/power_ball_explosion.wav
+++ b/data/sound/power_ball_explosion.wav
--- a/data/sound/tabe_hit.wav
+++ b/data/sound/tabe_hit.wav
--- a/data/sound/tnt.wav
+++ b/data/sound/tnt.wav
--- a/source/balloon_manager.cpp
+++ b/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();

--- a/source/credits.cpp
+++ b/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;
    }
 }

--- a/source/director.cpp
+++ b/source/director.cpp
@@ -126,6 +126,10 @@ void Director::close()
 	SDL_DestroyWindow(window_);

 	SDL_Quit();
+
+#ifdef ARCADE
+	shutdownSystem(section::options == section::Options::QUIT_WITH_CONTROLLER);
+#endif
 }

 // Carga los parametros
@@ -393,16 +397,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 +415,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);
@@ -490,6 +497,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 +536,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 +543,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);
@@ -762,11 +771,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 +798,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
--- a/source/director.h
+++ b/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
--- a/source/enter_name.cpp
+++ b/source/enter_name.cpp
@@ -1,93 +1,164 @@
 #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 == "")
+    {
+        name_ = "A";
+        position_ = 0;
+        position_overflow_ = false;
+    }
+    // Se pasa un nombre
+    else
+    {
+        name_ = name;
+        position_ = name_.length();
+        position_overflow_ = position_ >= 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_ >= NAME_LENGHT)
+    {
+        position_ = 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_ < 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_ = NAME_LENGHT - 1;
+    }
+    else
+    {
+        if (position_ > 0)
+        {
+            --position_;
+
+            // Limpiamos el carácter siguiente si el índice es válido.
+            if (position_ + 1 < 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_ < 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)
    {
        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
+    // Rellena de espacios
    for (size_t i = 0; i < 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, NAME_LENGHT).size(); ++i)
    {
-        character_index_[i] = findIndex(name_.at(i));
-        position_has_been_used_[i] = true;
+        character_index_[i] = findIndex(name.at(i));
    }
 }

@@ -98,28 +169,4 @@ int EnterName::findIndex(char character) const
        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();
 }
--- a/source/enter_name.h
+++ b/source/enter_name.h
@@ -1,6 +1,7 @@
 #pragma once

 #include <string>
+#include "utils.h"

 constexpr int NAME_LENGHT = 6;

@@ -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_[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_; }
 };
--- a/source/game.cpp
+++ b/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
@@ -1224,7 +1269,8 @@ void Game::checkEvents()
 			{
 				auto_pop_balloons_ = !auto_pop_balloons_;
 				Notifier::get()->showText({"auto advance: " + boolToString(auto_pop_balloons_)});
-				balloon_manager_->destroyAllBalloons();
+				if (auto_pop_balloons_)
+					balloon_manager_->destroyAllBalloons();
 				balloon_manager_->setDeployBalloons(!auto_pop_balloons_);
 				break;
 			}
@@ -1233,10 +1279,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 +1290,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 +1370,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;
 }
@@ -1577,6 +1627,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 +1635,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 +1650,11 @@ void Game::handleNameInput(const std::shared_ptr<Player> &player)
 		input_->checkInput(InputType::FIRE_CENTER, INPUT_DO_NOT_ALLOW_REPEAT, options.controllers[controllerIndex].type, options.controllers[controllerIndex].index) ||
 		input_->checkInput(InputType::FIRE_RIGHT, INPUT_DO_NOT_ALLOW_REPEAT, options.controllers[controllerIndex].type, options.controllers[controllerIndex].index))
 	{
-		if (player->getRecordNamePos() == NAME_LENGHT - 1)
+		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 +1676,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 +1993,7 @@ void Game::updateGameStatePlaying()
 	updatePathSprites();
 	updateTimeStopped();
 	updateHelper();
-	checkBulletBalloonCollision();
+	checkBulletCollision();
 	updateMenace();
 	checkAndUpdateBalloonSpeed();
 	checkState();
--- a/source/game.h
+++ b/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);
--- a/source/hiscore_table.cpp
+++ b/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);
+        }
+    }
+}
--- a/source/hiscore_table.h
+++ b/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();
--- a/source/input.cpp
+++ b/source/input.cpp
@@ -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;
+	}
 }
--- a/source/input.h
+++ b/source/input.h
@@ -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);
--- a/source/instructions.cpp
+++ b/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);
+	}
 }
--- a/source/instructions.h
+++ b/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();
--- a/source/intro.cpp
+++ b/source/intro.cpp
@@ -21,7 +21,7 @@
 // Constructor
 Intro::Intro()
 	: texture_(Resource::get()->getTexture("intro.png")),
-	  text_(Resource::get()->getText("nokia"))
+	  text_(Resource::get()->getText("04b_25_metal"))
 {

 	// Inicializa variables
@@ -97,7 +97,7 @@ Intro::Intro()
 		auto w = std::make_unique<Writer>(text_);
 		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));
--- a/source/item.h
+++ b/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 */
 };

 /**
--- a/source/manage_hiscore_table.cpp
+++ b/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;
 }
--- a/source/manage_hiscore_table.h
+++ b/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);
--- a/source/options.cpp
+++ b/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();
--- a/source/options.h
+++ b/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
--- a/source/path_sprite.cpp
+++ b/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
--- a/source/path_sprite.h
+++ b/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();
--- a/source/player.cpp
+++ b/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,7 @@ void Player::setInputEnteringName(InputType input)
 		enter_name_->decIndex();
 		break;
 	case InputType::START:
+		last_enter_name_ = getRecordName();
 		break;
 	default:
 		break;
@@ -449,6 +450,7 @@ void Player::update()
 	updateInvulnerable();
 	updateContinueCounter();
 	updateEnterNameCounter();
+	updateShowingName();
 	updateScoreboard();
 }

@@ -474,7 +476,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 +527,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 +555,7 @@ void Player::setPlayingState(PlayerState state)
 	}
 	case PlayerState::CELEBRATING:
 	{
+		game_completed_ = true;
 		setScoreboardMode(ScoreboardMode::SCORE);
 		break;
 	}
@@ -711,6 +721,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()
 {
--- a/source/player.h
+++ b/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();

@@ -224,12 +232,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 +252,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_; }
 };
--- a/source/resource.cpp
+++ b/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  ]");
    }
 }

--- a/source/scoreboard.cpp
+++ b/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 < 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(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));
 }
--- a/source/scoreboard.h
+++ b/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
--- a/source/screen.cpp
+++ b/source/screen.cpp
@@ -89,23 +89,26 @@ 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()
 {
+    // Restablece el objetivo de renderizado al buffer de pantalla predeterminado
+    SDL_SetRenderTarget(renderer_, nullptr);
+    clean();
+
 #ifdef NO_SHADERS
-    // Actualiza la pantalla con el contenido del game_canvas_
-    presentGameCanvas();
+    // Actualiza la pantalla con el contenido del buffer de renderizado
+    SDL_RenderCopy(renderer_, game_canvas_, nullptr, nullptr);
+    SDL_RenderPresent(renderer_);
 #else
    if (options.video.shaders)
    {
@@ -114,8 +117,9 @@ 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
 }
@@ -311,6 +315,33 @@ 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()
 {
@@ -363,10 +394,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 +434,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_);
 }
--- a/source/screen.h
+++ b/source/screen.h
@@ -28,9 +28,9 @@ private:
 	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();

--- a/source/sprite.h
+++ b/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; }
--- a/source/tabe.cpp
+++ b/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();
 }
--- a/source/tabe.h
+++ b/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_; }
 };
--- a/source/text.cpp
+++ b/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);
 }
--- a/source/text.h
+++ b/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);

--- a/source/texture.cpp
+++ b/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)
--- a/source/texture.h
+++ b/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);
--- a/source/utils.cpp
+++ b/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)
 {
--- a/source/utils.h
+++ b/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;
Author	SHA1	Message	Date
Sergio Valor	84595da13a	EnterName: si has plenat tots els slots de lletres, apretar una volta mes el de fixar lletra fixa el nom	2025-02-07 14:15:18 +01:00
Sergio Valor	01591175ef	Pos pense que ja està tot apanyat lo de EnterName i Scoreboard	2025-02-07 13:45:07 +01:00
Sergio Valor	29bc4a64fd	Afegit position_overflow_ per a EnterName i poder plenar tots els slots de lletres	2025-02-07 12:31:59 +01:00
Sergio Valor	559210652f	Treballant en scoreboard::fillPanelTextures	2025-02-06 20:58:15 +01:00
Sergio Valor Martínez	44e4ca490d	canvi de pc treballant en enter name	2025-02-06 14:59:25 +01:00
Sergio Valor Martínez	3cebee2ae4	Implementat control de repetició per als eixos del joystick	2025-02-06 12:36:16 +01:00
Sergio Valor Martínez	270d7d1848	Duplicada la font 04b_25 per a tindre versió gris i versió negra. La gris es la que es por modular amb colors. Eliminada la font nokia que ja no s'estava utilitzant. Optimitzada la càrrega de fonts al permetre reutilitzar fitxers .txt de altres fonts	2025-02-06 10:31:32 +01:00
Sergio Valor Martínez	ccf005dce1	Afegit el disparador per a la aparició del enemic nou	2025-02-06 09:59:58 +01:00
Sergio Valor Martínez	5755947ff7	La tabla de puntuació ja mostra amb altre color la puntuació que s'acaba d'afegir fix: la tabla de punts no guardava a disc el estat de 1CC de cada entrada	2025-02-05 22:52:19 +01:00
Sergio Valor Martínez	6f594b9a1f	La tabla de puntuacions ja mostra aquelles aconseguides amb 1CC	2025-02-05 15:15:48 +01:00
Sergio Valor	7e2021da70	canvi de pc	2025-02-05 10:17:49 +01:00
Sergio Valor	0a9a92d4b7	El text de la tabla de puntuacion ja ix centrat i el "diferent" es el que fa 10	2025-02-05 09:45:30 +01:00
Sergio Valor	b01763b749	Dels credits ja passa a la tabla de puntuacions	2025-01-26 21:15:13 +01:00
Sergio Valor	59b9f61d69	Font nova per a la intro	2025-01-26 21:05:43 +01:00
Sergio Valor	b9f194a2b1	Afegit efecte d'eixida a les instruccions	2025-01-26 20:16:43 +01:00
Sergio Valor	59936f13eb	Arreglos estetics i de colorets en hiscore_table.cpp	2025-01-26 17:48:10 +01:00
Sergio Valor	bad0a10328	Ja es mouen els sprites en hiscore_table.cpp, falta decidir-se per un disseny concret	2025-01-25 22:57:49 +01:00
Sergio Valor	52a0c2b91f	Treballant en la nova tabla de records: ja pinta amb sprites	2025-01-25 21:17:45 +01:00
Sergio Valor	f12a456017	Alguns arreglos en updateTimeStopped()	2025-01-25 18:51:39 +01:00
Sergio Valor	f39e65afaf	Ja no se que he tocat i qué no, cosetes del malo nou	2025-01-25 18:47:06 +01:00
Sergio Valor	d3183237df	Estandaritzats els noms dels fitxers de audio Eliminat el soroll de TNT que feia ANYS que no existía	2025-01-25 18:15:49 +01:00
Sergio Valor	60302004f4	Afegits efectes de audio nous Retocats alguns efectes de audio al afagar items per a no solapar dos audios	2025-01-25 18:11:24 +01:00
Sergio Valor	e60938cb19	El malo nou ja suca cosetes, falta ajustar un poc els paràmetres	2025-01-25 17:41:45 +01:00
Sergio Valor	2b3cc719ba	Fix del fix: aaaara si que lleva el garbage de la zona negra. Havia posat el clean() on no tocava	2025-01-25 13:14:25 +01:00
Sergio Valor	d01c91ebde	Fix: m'havia carregat el shakeEffect() de la pantalla quan havia shaders, i de paso he vist que el que tenbia fet shakejava també les notificacions i els menus de debug. Ale, ja està tot arreglaet. Fix: tampoc estava netejant la pantalla, pensava que no feia falta, pero quan SDL replena de negre la finestra en pantalla completa, havia gorrinades	2025-01-24 20:20:50 +01:00
Sergio Valor	7130f2298a	Merge branch 'main' of https://gitea.sustancia.synology.me/JailDesigner/coffee_crisis_arcade_edition	2025-01-24 10:44:58 +01:00
Sergio Valor	380cc17861	Fix: ara apaga el sistem al final del tot, almenys quan ja ha escrit la configuració a disc	2025-01-24 10:43:00 +01:00
Sergio	a5388873e3	Actualizar README.md	2025-01-05 15:47:51 +01:00