Els items reboten al tocar el piso

Afegits els grafics de caure derrotat per al segon jugador
Afegits rebots en la animació de morir
2024-11-20 21:55:55 +01:00 · 2024-11-19 19:30:30 +01:00 · 2024-11-19 18:59:35 +01:00 · 2024-11-19 18:59:22 +01:00 · 2024-11-19 18:33:52 +01:00 · 2024-11-17 08:43:24 +01:00
46 changed files with 1868 additions and 1834 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -0,0 +1,85 @@
+# CMakeLists.txt
+
+cmake_minimum_required(VERSION 3.10)
+project(coffee_crisis_arcade_edition VERSION 0.01)
+
+# Configuración de compilador para MinGW en Windows, si es necesario
+if(WIN32 AND NOT CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
+    set(CMAKE_CXX_COMPILER "g++")
+    set(CMAKE_C_COMPILER "gcc")
+endif()
+
+# Establecer estándar de C++
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED True)
+
+# Configuración global de flags de compilación
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
+set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -Os -ffunction-sections -fdata-sections")
+
+# Define el directorio de los archivos fuente
+set(DIR_SOURCES "${CMAKE_SOURCE_DIR}/source")
+
+# Cargar todos los archivos fuente en DIR_SOURCES
+file(GLOB SOURCES "${DIR_SOURCES}/*.cpp")
+
+# Verificar si se encontraron archivos fuente
+if(NOT SOURCES)
+    message(FATAL_ERROR "No se encontraron archivos fuente en ${DIR_SOURCES}. Verifica que el directorio existe y contiene archivos .cpp.")
+endif()
+
+# Configuración de SDL2
+find_package(SDL2 REQUIRED)
+if(SDL2_FOUND)
+    message(STATUS "SDL2 encontrado: ${SDL2_INCLUDE_DIRS}")
+    include_directories(${SDL2_INCLUDE_DIRS})
+    link_directories(${SDL2_LIBDIR})
+else()
+    message(FATAL_ERROR "SDL2 no encontrado")
+endif()
+
+# Incluye rutas de SDL2 obtenidas con pkg-config
+include_directories(/usr/local/include /usr/local/include/SDL2)
+link_directories(/usr/local/lib)
+
+# Definir las bibliotecas comunes
+set(LIBS SDL2)
+
+# Configuración común de salida de ejecutables en el directorio raíz
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR})
+
+# Añadir ejecutable principal
+add_executable(${PROJECT_NAME} ${SOURCES})
+
+# Añadir definiciones de compilación dependiendo del tipo de build
+target_compile_definitions(${PROJECT_NAME} PRIVATE $<$<CONFIG:DEBUG>:DEBUG VERBOSE>)
+
+# Enlazar bibliotecas
+target_link_libraries(${PROJECT_NAME} ${LIBS})
+
+# Configuración específica para cada plataforma
+if(WIN32)
+    target_compile_definitions(${PROJECT_NAME} PRIVATE WINDOWS_BUILD)
+    target_link_libraries(${PROJECT_NAME} mingw32 opengl32 gdi32 winmm imm32 ole32 version)
+elseif(APPLE)
+    set(LIBS ${LIBS} "-framework OpenGL")
+    target_compile_definitions(${PROJECT_NAME} PRIVATE MACOS_BUILD)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated")
+    # Configurar compilación para Apple Silicon
+    set(CMAKE_OSX_ARCHITECTURES "arm64")
+elseif(UNIX AND NOT APPLE)
+    set(LIBS ${LIBS} GL)
+    target_compile_definitions(${PROJECT_NAME} PRIVATE LINUX_BUILD)
+    target_link_libraries(${PROJECT_NAME} ${LIBS})
+endif()
+
+# Añadir OpenGL a las bibliotecas enlazadas
+if(NOT WIN32)
+    find_package(OpenGL REQUIRED)
+    if(OPENGL_FOUND)
+        message(STATUS "OpenGL encontrado: ${OPENGL_LIBRARIES}")
+        target_link_libraries(${PROJECT_NAME} ${OPENGL_LIBRARIES})
+    else()
+        message(FATAL_ERROR "OpenGL no encontrado")
+    endif()
+endif()
--- a/91
+++ b/91
@@ -50,84 +50,7 @@ else
    endif
 endif

-OBJECTS     := $(subst $(DIR_SOURCES), $(DIR_BUILD), $(SOURCES))
-OBJECTS     := $(OBJECTS:.cpp=.o)
-DEPENDENCIES:= $(OBJECTS:.o=.d)
-
-
-###############################################################################
-#                                                                             #
-#     RULES                                                                   #
-#                                                                             #
-###############################################################################
-
-.PHONY: all a1
-
-all: a1
-
-a1: $(TARGET_FILE)
-
-$(TARGET_FILE): $(OBJECTS)
-	$(MKD) $(@D)
-	$(CXX) $(OBJECTS) $(LDFLAGS) -o $(TARGET_FILE)
-
-$(DIR_BUILD)%.o: $(DIR_SOURCES)%.cpp
-	$(MKD) $(@D)
-	$(CXX) -c $< $(CXXFLAGS) $(INCLUDES) -o $@
-
-include $(DEPENDENCIES)
-
-###############################################################################
-#                                                                             #
-#     CLEAN                                                                   #
-#                                                                             #
-###############################################################################
-
-.PHONY: clean
-
-clean:
-	$(RM) $(call FixPath,$(DIR_BUILD))
-
-###############################################################################
-#                                                                             #
-#     PRINT-VARIABLES                                                         #
-#                                                                             #
-###############################################################################
-
-.PHONY: print-variables
-
-print-variables:
-	@echo MAKEFILE_LIST: $(MAKEFILE_LIST)
-	
-	@echo "DIR_ROOT  :" $(DIR_ROOT)
-	@echo "DIR_SOURCES:" $(DIR_SOURCES)
-	@echo "DIR_BIN   :" $(DIR_BIN)
-	@echo "DIR_BUILD :" $(DIR_BUILD)
-
-	@echo "DIR_IMGUI     :" $(DIR_IMGUI)
-	@echo "DIR_IMGUI_SFML:" $(DIR_IMGUI_SFML)
-	@echo "INCLUDES      :" $(INCLUDES)
-
-	@echo CXX: $(CXX)
-	@echo CXXFLAGS: $(CXXFLAGS)
-	@echo LDFLAGS: $(LDFLAGS)
-
-	@echo SOURCES: $(SOURCES)
-	@echo OBJECTS: $(OBJECTS)
-	@echo DEPENDENCIES: $(DEPENDENCIES)
-
-	@echo TARGET_NAME: $(TARGET_NAME)
-	@echo TARGET_FILE: $(TARGET_FILE)
-
-	@echo RM: $(RM)
-
-raspi:
-	$(CXX) $(SOURCES) -D ARCADE -D VERBOSE $(CXXFLAGS) $(LDFLAGS) -o $(TARGET_FILE)
-	strip -s -R .comment -R .gnu.version $(TARGET_FILE) --strip-unneeded
-
-raspi_debug:
-	$(CXX) $(SOURCES) -D ARCADE -D VERBOSE -D DEBUG $(CXXFLAGS_DEBUG) $(LDFLAGS) -o "$(TARGET_FILE)_debug"
-
+# Rules
 windows:
 	@echo off
 	$(CXX) $(SOURCES) $(CXXFLAGS) $(LDFLAGS) -o "$(TARGET_FILE).exe"
@@ -249,6 +172,13 @@ linux_release:
 # Elimina la carpeta temporal
 	$(RM) "$(RELEASE_FOLDER)"

+raspi:
+	$(CXX) $(SOURCES) -D ARCADE -D VERBOSE $(CXXFLAGS) $(LDFLAGS) -o $(TARGET_FILE)
+	strip -s -R .comment -R .gnu.version $(TARGET_FILE) --strip-unneeded
+
+raspi_debug:
+	$(CXX) $(SOURCES) -D ARCADE -D VERBOSE -D DEBUG $(CXXFLAGS_DEBUG) $(LDFLAGS) -o "$(TARGET_FILE)_debug"
+
 anbernic:
 # Elimina carpetas previas
 	$(RM) "$(RELEASE_FOLDER)"_anbernic
@@ -259,6 +189,5 @@ anbernic:
 # Copia ficheros
 	cp -R data "$(RELEASE_FOLDER)"_anbernic

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

 [animation]
-name=death
+name=dying
 speed=10
 loop=0
 frames=32,33,34,35
 [/animation]

+[animation]
+name=dead
+speed=3
+loop=0
+frames=44,45,46,47,48,49,50
+[/animation]
+
 [animation]
 name=celebration
 speed=10
--- a/data/gfx/player/player1.gif
+++ b/data/gfx/player/player1.gif
--- a/data/gfx/player/player1_one_coffee_palette.pal
+++ b/data/gfx/player/player1_one_coffee_palette.pal
--- a/data/gfx/player/player2.gif
+++ b/data/gfx/player/player2.gif
--- a/data/lang/ba_BA.txt
+++ b/data/lang/ba_BA.txt
@@ -158,19 +158,19 @@ Felicitats!!
 2 JUGADORS

 ## 53 MARCADOR
-jugador 1
+Jugador 1

 ## 54 MARCADOR
-jugador 2
+Jugador 2

 ## 55 MARCADOR
-mult
+Multiplicador

 ## 56 MARCADOR
-max. puntuacio
+Max. puntuacio

 ## 57 MARCADOR
-fase 
+Fase 

 ## 58 - MENU DE OPCIONES
 MODE DE VISUALITZACIO
--- a/data/lang/en_UK.txt
+++ b/data/lang/en_UK.txt
@@ -158,19 +158,19 @@ Congratulations!!
 2 PLAYERS

 ## 53 - MARCADOR
-player 1
+Player 1

 ## 54 - MARCADOR
-player 2
+Player 2

 ## 55 - MARCADOR
-mult
+Multiplier

 ## 56 - MARCADOR
-high score
+High Score

 ## 57 - MARCADOR
-stage 
+Stage 

 ## 58 - MENU DE OPCIONES
 DISPLAY MODE
--- a/data/lang/es_ES.txt
+++ b/data/lang/es_ES.txt
@@ -158,19 +158,19 @@ Felicidades!!
 2 JUGADORES

 ## 53 - MARCADOR
-jugador 1
+Jugador 1

 ## 54 - MARCADOR
-jugador 2
+Jugador 2

 ## 55 - MARCADOR
-mult
+Multiplicador

 ## 56 - MARCADOR
-max. puntuacion
+Max. puntuacion

 ## 57 - MARCADOR
-FASE 
+Fase 

 ## 58 - MENU DE OPCIONES
 MODO DE VISUALIZACION
--- a/source/balloon.cpp
+++ b/source/balloon.cpp
@@ -56,7 +56,7 @@ Balloon::Balloon(float x, float y, BalloonType type, BalloonSize size, float vel
 	case BalloonType::POWERBALL:
 	{
 		const int index = 3;
-		h_ = w_ = BALLOON_SIZE[index];
+		h_ = w_ = BALLOON_SIZE[4];
 		power_ = score_ = menace_ = 0;

 		vy_ = 0;
@@ -64,8 +64,7 @@ Balloon::Balloon(float x, float y, BalloonType type, BalloonSize size, float vel
 		gravity_ = param.balloon.at(index).grav;
 		default_vy_ = param.balloon.at(index).vel;

-		sprite_->disableRotate();
-		sprite_->setRotateSpeed(0);
+		sprite_->setRotate(creation_timer <= 0);
 		sprite_->setRotateAmount(vx_ > 0.0f ? 2.0 : -2.0);

 		break;
@@ -100,32 +99,42 @@ void Balloon::alignTo(int x)
 // Pinta el globo en la pantalla
 void Balloon::render()
 {
-	if (isBeingCreated())
+	if (type_ == BalloonType::POWERBALL)
 	{
-		// Aplica alpha blending
-		sprite_->getTexture()->setAlpha(255 - (int)((float)creation_counter_ * (255.0f / (float)creation_counter_ini_)));
+		// Renderizado para la PowerBall
+		SDL_Point p = {24, 24};
+		sprite_->setRotatingCenter(&p);
 		sprite_->render();
-		sprite_->getTexture()->setAlpha(255);
+		// Añade la máscara del borde y los reflejos
+		auto sp = std::make_unique<Sprite>(sprite_->getTexture(), sprite_->getPosition());
+		sp->setSpriteClip(BALLOON_SIZE[4], 0, BALLOON_SIZE[4], BALLOON_SIZE[4]);
+		sp->render();
 	}
 	else
 	{
-		if (bouncing_.enabled)
+		// Renderizado para el resto de globos
+		if (isBeingCreated())
 		{
-			// Aplica efecto de bouncing
-			sprite_->setPos(x_ + bouncing_.despX, y_ + bouncing_.despY);
+			// Renderizado con transparencia
+			sprite_->getTexture()->setAlpha(255 - (int)((float)creation_counter_ * (255.0f / (float)creation_counter_ini_)));
 			sprite_->render();
-			sprite_->setPos(x_ - bouncing_.despX, y_ - bouncing_.despY);
+			sprite_->getTexture()->setAlpha(255);
 		}
 		else
-			sprite_->render();
-	}
-
-	// Añade la máscara del borde a la PowerBall
-	if (type_ == BalloonType::POWERBALL && !isBeingCreated())
-	{
-		auto sp = std::make_unique<Sprite>(sprite_->getTexture(), sprite_->getPosition());
-		sp->setSpriteClip(BALLOON_SIZE[3], 0, BALLOON_SIZE[3], BALLOON_SIZE[3]);
-		sp->render();
+		{
+			if (bouncing_.enabled)
+			{
+				// Renderizado con efecto de bouncing
+				sprite_->setPos(x_ + bouncing_.despX, y_ + bouncing_.despY);
+				sprite_->render();
+				// sprite_->setPos(x_ - bouncing_.despX, y_ - bouncing_.despY);
+			}
+			else
+			{
+				// Renderizado normal
+				sprite_->render();
+			}
+		}
 	}
 }

@@ -148,22 +157,28 @@ void Balloon::move()
 			vx_ = -vx_;
 			// Activa el efecto de rebote o invierte la rotación
 			if (type_ == BalloonType::POWERBALL)
+			{
 				sprite_->switchRotate();
+			}
 			else
+			{
 				enableBounce();
+			}
 		}

 		// Mueve el globo en vertical
 		y_ += vy_ * speed_;

-		// Colisión en la parte superior de la zona de juego
-		const int min_y = param.game.play_area.rect.y;
-		if (y_ < min_y)
+		// Colisión en la parte superior de la zona de juego excepto para la PowerBall
+		if (type_ != BalloonType::POWERBALL)
 		{
-			y_ = min_y;
-			vy_ = -vy_;
-			if (type_ != BalloonType::POWERBALL)
+			const int min_y = param.game.play_area.rect.y;
+			if (y_ < min_y)
+			{
+				y_ = min_y;
+				vy_ = -vy_;
 				enableBounce();
+			}
 		}

 		// Colisión en la parte inferior de la zona de juego
@@ -173,7 +188,9 @@ void Balloon::move()
 			y_ = max_y;
 			vy_ = -default_vy_;
 			if (type_ != BalloonType::POWERBALL)
+			{
 				enableBounce();
+			}
 		}

 		/*
@@ -294,16 +311,20 @@ void Balloon::setAnimation()
 void Balloon::stop()
 {
 	stopped_ = true;
-	if (type_ == BalloonType::POWERBALL)
-		sprite_->disableRotate();
+	if (isPowerBall())
+	{
+		sprite_->setRotate(!stopped_);
+	}
 }

 // Pone el globo en movimiento
 void Balloon::start()
 {
 	stopped_ = false;
-	if (type_ == BalloonType::POWERBALL)
-		sprite_->enableRotate();
+	if (isPowerBall())
+	{
+		sprite_->setRotate(!stopped_);
+	}
 }

 // Alinea el circulo de colisión con la posición del objeto globo
@@ -378,27 +399,4 @@ void Balloon::useNormalColor()
 {
 	use_reversed_colors_ = false;
 	setAnimation();
-}
-
-// Getters
-float Balloon::getPosX() const { return x_; }
-float Balloon::getPosY() const { return y_; }
-int Balloon::getWidth() const { return w_; }
-int Balloon::getHeight() const { return h_; }
-BalloonSize Balloon::getSize() const { return size_; }
-BalloonType Balloon::getType() const { return type_; }
-Uint16 Balloon::getScore() const { return score_; }
-Circle &Balloon::getCollider() { return collider_; }
-Uint8 Balloon::getMenace() const { return isEnabled() ? menace_ : 0; }
-Uint8 Balloon::getPower() const { return power_; }
-bool Balloon::isStopped() const { return stopped_; }
-bool Balloon::isInvulnerable() const { return invulnerable_; }
-bool Balloon::isBeingCreated() const { return being_created_; }
-bool Balloon::isEnabled() const { return enabled_; }
-bool Balloon::isUsingReversedColor() { return use_reversed_colors_; }
-bool Balloon::canBePopped() const { return !isBeingCreated(); }
-
-// Setters
-void Balloon::setVelY(float vel_y) { vy_ = vel_y; }
-void Balloon::setSpeed(float speed) { speed_ = speed; }
-void Balloon::setInvulnerable(bool value) { invulnerable_ = value; }
+}
--- a/source/balloon.h
+++ b/source/balloon.h
@@ -15,7 +15,7 @@ constexpr int MAX_BOUNCE = 10;
 constexpr int BALLOON_SCORE[] = {50, 100, 200, 400};
 constexpr int BALLOON_POWER[] = {1, 3, 7, 15};
 constexpr int BALLOON_MENACE[] = {1, 2, 4, 8};
-constexpr int BALLOON_SIZE[] = {10, 16, 26, 46};
+constexpr int BALLOON_SIZE[] = {10, 16, 26, 48, 49};

 // Tamaños de globo
 enum class BalloonSize : Uint8
@@ -174,25 +174,26 @@ public:
 	void useNormalColor();

 	// Getters
-	float getPosX() const;
-	float getPosY() const;
-	int getWidth() const;
-	int getHeight() const;
-	BalloonSize getSize() const;
-	BalloonType getType() const;
-	Uint16 getScore() const;
-	Circle &getCollider();
-	Uint8 getMenace() const;
-	Uint8 getPower() const;
-	bool isStopped() const;
-	bool isInvulnerable() const;
-	bool isBeingCreated() const;
-	bool isEnabled() const;
-	bool isUsingReversedColor();
-	bool canBePopped() const;
+	float getPosX() const { return x_; }
+	float getPosY() const { return y_; }
+	int getWidth() const { return w_; }
+	int getHeight() const { return h_; }
+	BalloonSize getSize() const { return size_; }
+	BalloonType getType() const { return type_; }
+	Uint16 getScore() const { return score_; }
+	Circle &getCollider() { return collider_; }
+	Uint8 getMenace() const { return isEnabled() ? menace_ : 0; }
+	Uint8 getPower() const { return power_; }
+	bool isStopped() const { return stopped_; }
+	bool isPowerBall() const { return type_ == BalloonType::POWERBALL; }
+	bool isInvulnerable() const { return invulnerable_; }
+	bool isBeingCreated() const { return being_created_; }
+	bool isEnabled() const { return enabled_; }
+	bool isUsingReversedColor() { return use_reversed_colors_; }
+	bool canBePopped() const { return !isBeingCreated(); }

 	// Setters
-	void setVelY(float vel_y);
-	void setSpeed(float speed);
-	void setInvulnerable(bool value);
+	void setVelY(float vel_y) { vy_ = vel_y; }
+	void setSpeed(float speed) { speed_ = speed; }
+	void setInvulnerable(bool value) { invulnerable_ = value; }
 };
--- a/source/balloon_formations.cpp
+++ b/source/balloon_formations.cpp
--- a/source/balloon_formations.h
+++ b/source/balloon_formations.h
@@ -1,13 +1,13 @@
 #pragma once

-#include "balloon.h"
+#include "balloon.h" // para BALLOON_VELX_NEGATIVE, BALLOON_VELX_POSITIVE
+#include <vector>

 constexpr int NUMBER_OF_BALLOON_FORMATIONS = 100;
 constexpr int MAX_NUMBER_OF_BALLOONS_IN_A_FORMATION = 50;
 constexpr int NUMBER_OF_SETS_PER_POOL = 10;
 constexpr int NUMBER_OF_STAGES = 10;

-// Estructuras
 struct BalloonFormationParams
 {
    int x = 0;                               // Posición en el eje X donde crear el globo
@@ -25,34 +25,27 @@ struct BalloonFormationParams
        : x(x_val), y(y_val), vel_x(vel_x_val), type(type_val), size(size_val), creation_counter(creation_counter_val) {}
 };

-struct BalloonFormationUnit // Contiene la información de una formación enemiga
+struct BalloonFormationUnit
 {
-    int number_of_balloons;                                             // Cantidad de globos que forman la formación
-    BalloonFormationParams init[MAX_NUMBER_OF_BALLOONS_IN_A_FORMATION]; // Vector con todas las inicializaciones de los globos de la formación
+    int number_of_balloons;                   // Cantidad de globos que forman la formación
+    std::vector<BalloonFormationParams> init; // Vector con todas las inicializaciones de los globos de la formación
+
+    // Constructor
+    BalloonFormationUnit(int num_balloons, const std::vector<BalloonFormationParams> &init_params)
+        : number_of_balloons(num_balloons), init(init_params) {}
+
+    // Default constructor
+    BalloonFormationUnit() : number_of_balloons(0), init() {}
 };

-struct BalloonFormationPool
-{
-    BalloonFormationUnit set[NUMBER_OF_SETS_PER_POOL]; // Conjunto de formaciones de globos
-};

-struct Stage // Contiene todas las variables relacionadas con una fase
-{
-    BalloonFormationPool balloon_pool; // El conjunto de formaciones de globos de la fase
-    int power_to_complete;             // Cantidad de poder que se necesita para completar la fase
-    int max_menace;                    // Umbral máximo de amenaza de la fase
-    int min_menace;                    // Umbral mínimo de amenaza de la fase
-    int number;                        // Número de fase
-};
+using BalloonFormationPool = std::vector<const BalloonFormationUnit *>;

-// Clase BalloonFormations, para gestionar las formaciones de globos
 class BalloonFormations
 {
 private:
-    // Variables
-    Stage stage_[NUMBER_OF_STAGES];                                        // Variable con los datos de cada pantalla
-    BalloonFormationUnit balloon_formation_[NUMBER_OF_BALLOON_FORMATIONS]; // Vector con todas las formaciones enemigas
-    BalloonFormationPool balloon_formation_pool_[NUMBER_OF_STAGES];        // Variable con los diferentes conjuntos de formaciones enemigas
+    std::vector<BalloonFormationUnit> balloon_formation_;      // Vector con todas las formaciones enemigas
+    std::vector<BalloonFormationPool> balloon_formation_pool_; // Variable con los diferentes conjuntos de formaciones enemigas

    // Inicializa las formaciones enemigas
    void initBalloonFormations();
@@ -60,16 +53,18 @@ private:
    // Inicializa los conjuntos de formaciones
    void initBalloonFormationPools();

-    // Inicializa las fases del juego
-    void initGameStages();
-
 public:
    // Constructor
-    BalloonFormations();
+    BalloonFormations()
+    {
+        initBalloonFormations();
+        initBalloonFormationPools();
+    }

    // Destructor
    ~BalloonFormations() = default;

-    // Devuelve una fase
-    Stage getStage(int index) const;
-};
+    // Getters
+    const BalloonFormationPool &getPool(int pool) { return balloon_formation_pool_.at(pool); }
+    const BalloonFormationUnit &getSet(int pool, int set) { return *balloon_formation_pool_.at(pool).at(set); }
+};
--- a/source/balloon_manager.cpp
+++ b/source/balloon_manager.cpp
@@ -0,0 +1,356 @@
+#include "balloon_manager.h"
+#include <stdlib.h>             // Para rand
+#include <algorithm>            // Para remove_if
+#include <numeric>              // Para accumulate
+#include "balloon.h"            // Para Balloon, BALLOON_SCORE, BALLOON_VELX...
+#include "balloon_formations.h" // Para BalloonFormationParams, BalloonForma...
+#include "explosions.h"         // Para Explosions
+#include "jail_audio.h"         // Para JA_PlaySound
+#include "param.h"              // Para Param, ParamGame, param
+#include "resource.h"           // Para Resource
+#include "screen.h"             // Para Screen
+#include "stage.h"              // Para power
+#include "texture.h"            // Para Texture
+#include "utils.h"              // Para Zone, BLOCK, Color, flash_color
+
+// Constructor
+BalloonManager::BalloonManager()
+    : explosions_(std::make_unique<Explosions>()),
+      balloon_formations_(std::make_unique<BalloonFormations>()) { init(); }
+
+// Inicializa
+void BalloonManager::init()
+{
+    // Texturas - Globos
+    balloon_textures_.emplace_back(Resource::get()->getTexture("balloon1.png"));
+    balloon_textures_.emplace_back(Resource::get()->getTexture("balloon2.png"));
+    balloon_textures_.emplace_back(Resource::get()->getTexture("balloon3.png"));
+    balloon_textures_.emplace_back(Resource::get()->getTexture("balloon4.png"));
+    balloon_textures_.emplace_back(Resource::get()->getTexture("powerball.png"));
+
+    // Animaciones -- Globos
+    balloon_animations_.emplace_back(Resource::get()->getAnimation("balloon1.ani"));
+    balloon_animations_.emplace_back(Resource::get()->getAnimation("balloon2.ani"));
+    balloon_animations_.emplace_back(Resource::get()->getAnimation("balloon3.ani"));
+    balloon_animations_.emplace_back(Resource::get()->getAnimation("balloon4.ani"));
+    balloon_animations_.emplace_back(Resource::get()->getAnimation("powerball.ani"));
+
+    // Texturas - Explosiones
+    explosions_textures_.emplace_back(Resource::get()->getTexture("explosion1.png"));
+    explosions_textures_.emplace_back(Resource::get()->getTexture("explosion2.png"));
+    explosions_textures_.emplace_back(Resource::get()->getTexture("explosion3.png"));
+    explosions_textures_.emplace_back(Resource::get()->getTexture("explosion4.png"));
+
+    // Animaciones -- Explosiones
+    explosions_animations_.emplace_back(Resource::get()->getAnimation("explosion1.ani"));
+    explosions_animations_.emplace_back(Resource::get()->getAnimation("explosion2.ani"));
+    explosions_animations_.emplace_back(Resource::get()->getAnimation("explosion3.ani"));
+    explosions_animations_.emplace_back(Resource::get()->getAnimation("explosion4.ani"));
+
+    // Añade texturas
+    explosions_->addTexture(1, explosions_textures_[0], explosions_animations_[0]);
+    explosions_->addTexture(2, explosions_textures_[1], explosions_animations_[1]);
+    explosions_->addTexture(3, explosions_textures_[2], explosions_animations_[2]);
+    explosions_->addTexture(4, explosions_textures_[3], explosions_animations_[3]);
+}
+
+// Actualiza
+void BalloonManager::update()
+{
+    for (auto balloon : balloons_)
+    {
+        balloon->update();
+    }
+    updateBalloonDeployCounter();
+    explosions_->update();
+}
+
+// Renderiza los objetos
+void BalloonManager::render()
+{
+    for (auto &balloon : balloons_)
+    {
+        balloon->render();
+    }
+    explosions_->render();
+}
+
+// Crea una formación de enemigos
+void BalloonManager::deployBalloonFormation(int stage)
+{
+    // Solo despliega una formación enemiga si ha pasado cierto tiempo desde la última
+    if (balloon_deploy_counter_ == 0)
+    {
+        // En este punto se decide entre crear una powerball o una formación enemiga
+        if ((rand() % 100 < 15) && (canPowerBallBeCreated()))
+        {
+            // Crea una powerball
+            createPowerBall();
+
+            // Da un poco de margen para que se creen mas enemigos
+            balloon_deploy_counter_ = 10;
+        }
+        else
+        {
+            // Decrementa el contador de despliegues enemigos de la PowerBall
+            power_ball_counter_ = (power_ball_counter_ > 0) ? (power_ball_counter_ - 1) : 0;
+
+            // Elige una formación enemiga la azar
+            auto formation = rand() % 10;
+
+            // Evita repetir la ultima formación enemiga desplegada
+            if (formation == last_balloon_deploy_)
+            {
+                ++formation %= 10;
+            }
+
+            last_balloon_deploy_ = formation;
+
+            const auto set = balloon_formations_->getSet(stage, formation);
+            const auto numEnemies = set.number_of_balloons;
+            for (int i = 0; i < numEnemies; ++i)
+            {
+                auto p = set.init[i];
+                createBalloon(p.x, p.y, p.type, p.size, p.vel_x, balloon_speed_, p.creation_counter);
+            }
+
+            balloon_deploy_counter_ = 300;
+        }
+    }
+}
+
+// Vacia del vector de globos los globos que ya no sirven
+void BalloonManager::freeBalloons()
+{
+    auto it = std::remove_if(balloons_.begin(), balloons_.end(), [](const auto &balloon)
+                             { return !balloon->isEnabled(); });
+    balloons_.erase(it, balloons_.end());
+}
+
+// Actualiza la variable enemyDeployCounter
+void BalloonManager::updateBalloonDeployCounter()
+{
+    if (balloon_deploy_counter_ > 0)
+    {
+        --balloon_deploy_counter_;
+    }
+}
+
+// Indica si se puede crear una powerball
+bool BalloonManager::canPowerBallBeCreated() { return (!power_ball_enabled_) && (calculateScreenPower() > POWERBALL_SCREENPOWER_MINIMUM) && (power_ball_counter_ == 0); }
+
+// Calcula el poder actual de los globos en pantalla
+int BalloonManager::calculateScreenPower()
+{
+    return std::accumulate(balloons_.begin(), balloons_.end(), 0, [](int sum, const auto &balloon)
+                           { return sum + (balloon->isEnabled() ? balloon->getPower() : 0); });
+}
+
+// Crea un globo nuevo en el vector de globos
+std::shared_ptr<Balloon> BalloonManager::createBalloon(float x, int y, BalloonType type, BalloonSize size, float velx, float speed, int creation_timer)
+{
+    const int index = static_cast<int>(size);
+    balloons_.emplace_back(std::make_shared<Balloon>(x, y, type, size, velx, speed, creation_timer, balloon_textures_.at(index), balloon_animations_.at(index)));
+    return balloons_.back();
+}
+
+// Crea un globo a partir de otro globo
+void BalloonManager::createChildBalloon(const std::shared_ptr<Balloon> &balloon, const std::string &direction)
+{
+    const float vx = direction == "LEFT" ? BALLOON_VELX_NEGATIVE : BALLOON_VELX_POSITIVE;
+    const auto lower_size = static_cast<BalloonSize>(static_cast<int>(balloon->getSize()) - 1);
+    auto b = createBalloon(0, balloon->getPosY(), balloon->getType(), lower_size, vx, balloon_speed_, 0);
+    const int x = direction == "LEFT" ? balloon->getPosX() + (balloon->getWidth() / 3) : balloon->getPosX() + 2 * (balloon->getWidth() / 3);
+    b->alignTo(x);
+    b->setVelY(b->getType() == BalloonType::BALLOON ? -2.50f : BALLOON_VELX_NEGATIVE * 2.0f);
+    if (balloon->isStopped())
+    {
+        b->stop();
+    }
+    if (balloon->isUsingReversedColor())
+    {
+        b->useReverseColor();
+    }
+}
+
+// Crea una PowerBall
+void BalloonManager::createPowerBall()
+{
+    constexpr int values = 6;
+    constexpr int pos_y = -BALLOON_SIZE[4];
+    constexpr int creation_time = 0;
+
+    const auto left = param.game.play_area.rect.x;
+    const auto center = param.game.play_area.center_x - (BALLOON_SIZE[4] / 2);
+    const auto right = param.game.play_area.rect.w - BALLOON_SIZE[4];
+
+    const auto luck = rand() % values;
+    const int x[values] = {left, left, center, center, right, right};
+    const float vx[values] = {BALLOON_VELX_POSITIVE, BALLOON_VELX_POSITIVE, BALLOON_VELX_POSITIVE, BALLOON_VELX_NEGATIVE, BALLOON_VELX_NEGATIVE, BALLOON_VELX_NEGATIVE};
+
+    balloons_.emplace_back(std::make_unique<Balloon>(x[luck], pos_y, BalloonType::POWERBALL, BalloonSize::SIZE4, vx[luck], balloon_speed_, creation_time, balloon_textures_[4], balloon_animations_[4]));
+
+    power_ball_enabled_ = true;
+    power_ball_counter_ = POWERBALL_COUNTER;
+}
+
+// Establece la velocidad de los globos
+void BalloonManager::setBalloonSpeed(float speed)
+{
+    balloon_speed_ = speed;
+    for (auto &balloon : balloons_)
+    {
+        balloon->setSpeed(speed);
+    }
+}
+
+// Explosiona un globo. Lo destruye y crea otros dos si es el caso
+int BalloonManager::popBalloon(std::shared_ptr<Balloon> balloon)
+{
+    Stage::addPower(1);
+    int score = 0;
+
+    if (balloon->getType() == BalloonType::POWERBALL)
+    {
+        score = destroyAllBalloons();
+        power_ball_enabled_ = false;
+        balloon_deploy_counter_ = 20;
+    }
+    else
+    {
+        score = balloon->getScore();
+        if (balloon->getSize() != BalloonSize::SIZE1)
+        {
+            createChildBalloon(balloon, "LEFT");
+            createChildBalloon(balloon, "RIGHT");
+        }
+
+        // Agrega la explosión y elimina el globo
+        explosions_->add(balloon->getPosX(), balloon->getPosY(), static_cast<int>(balloon->getSize()));
+        balloon->pop();
+    }
+
+    return score;
+}
+
+// Explosiona un globo. Lo destruye = no crea otros globos
+int BalloonManager::destroyBalloon(std::shared_ptr<Balloon> &balloon)
+{
+    int score = 0;
+
+    // Calcula la puntuación y el poder que generaria el globo en caso de romperlo a él y a sus hijos
+    switch (balloon->getSize())
+    {
+    case BalloonSize::SIZE4:
+        score = BALLOON_SCORE[3] + (2 * BALLOON_SCORE[2]) + (4 * BALLOON_SCORE[1]) + (8 * BALLOON_SCORE[0]);
+        break;
+    case BalloonSize::SIZE3:
+        score = BALLOON_SCORE[2] + (2 * BALLOON_SCORE[1]) + (4 * BALLOON_SCORE[0]);
+        break;
+    case BalloonSize::SIZE2:
+        score = BALLOON_SCORE[1] + (2 * BALLOON_SCORE[0]);
+        break;
+    case BalloonSize::SIZE1:
+        score = BALLOON_SCORE[0];
+        break;
+    default:
+        score = 0;
+        break;
+    }
+
+    // Aumenta el poder de la fase
+    Stage::addPower(balloon->getPower());
+
+    // Destruye el globo
+    explosions_->add(balloon->getPosX(), balloon->getPosY(), static_cast<int>(balloon->getSize()));
+    balloon->pop();
+
+    return score;
+}
+
+// Destruye todos los globos
+int BalloonManager::destroyAllBalloons()
+{
+    int score = 0;
+    for (auto &balloon : balloons_)
+    {
+        score += destroyBalloon(balloon);
+    }
+
+    balloon_deploy_counter_ = 300;
+    JA_PlaySound(Resource::get()->getSound("powerball.wav"));
+    Screen::get()->flash(flash_color, 100);
+    Screen::get()->shake();
+
+    return score;
+}
+
+// Detiene todos los globos
+void BalloonManager::stopAllBalloons()
+{
+    for (auto &balloon : balloons_)
+    {
+        balloon->stop();
+    }
+}
+
+// Pone en marcha todos los globos
+void BalloonManager::startAllBalloons()
+{
+    for (auto &balloon : balloons_)
+    {
+        if (!balloon->isBeingCreated())
+        {
+            balloon->start();
+        }
+    }
+}
+
+// Cambia el color de todos los globos
+void BalloonManager::reverseColorsToAllBalloons()
+{
+    for (auto &balloon : balloons_)
+    {
+        if (balloon->isStopped())
+        {
+            balloon->useReverseColor();
+        }
+    }
+}
+
+// Cambia el color de todos los globos
+void BalloonManager::normalColorsToAllBalloons()
+{
+    for (auto &balloon : balloons_)
+    {
+        balloon->useNormalColor();
+    }
+}
+
+// Recarga las texturas
+void BalloonManager::reLoad()
+{
+    for (auto &texture : balloon_textures_)
+    {
+        texture->reLoad();
+    }
+}
+
+// Crea dos globos gordos
+void BalloonManager::createTwoBigBalloons()
+{
+    const auto set = balloon_formations_->getSet(0, 1);
+    const auto numEnemies = set.number_of_balloons;
+    for (int i = 0; i < numEnemies; ++i)
+    {
+        auto p = set.init[i];
+        createBalloon(p.x, p.y, p.type, p.size, p.vel_x, balloon_speed_, p.creation_counter);
+    }
+}
+
+// Obtiene el nivel de ameza actual generado por los globos
+int BalloonManager::getMenace()
+{
+    return std::accumulate(balloons_.begin(), balloons_.end(), 0, [](int sum, const auto &balloon)
+                           { return sum + (balloon->isEnabled() ? balloon->getMenace() : 0); });
+}
--- a/source/balloon_manager.h
+++ b/source/balloon_manager.h
@@ -0,0 +1,113 @@
+#pragma once
+
+#include <memory>               // Para shared_ptr, unique_ptr
+#include <string>               // Para string
+#include <vector>               // Para vector
+#include "balloon.h"            // Para BALLOON_SPEED, Balloon
+#include "balloon_formations.h" // Para BalloonFormations
+#include "explosions.h"         // Para Explosions
+class Texture;
+
+using Balloons = std::vector<std::shared_ptr<Balloon>>;
+
+class BalloonManager
+{
+private:
+    Balloons balloons_;                                     // Vector con los globos
+    std::unique_ptr<Explosions> explosions_;                // Objeto para dibujar explosiones
+    std::unique_ptr<BalloonFormations> balloon_formations_; // Objeto para gestionar las oleadas enemigas
+
+    std::vector<std::shared_ptr<Texture>> balloon_textures_;    // Vector con las texturas de los globos
+    std::vector<std::shared_ptr<Texture>> explosions_textures_; // Vector con las texturas de las explosiones
+
+    std::vector<std::vector<std::string>> balloon_animations_;    // Vector con las animaciones de los globos
+    std::vector<std::vector<std::string>> explosions_animations_; // Vector con las animaciones de las explosiones
+
+    float balloon_speed_ = BALLOON_SPEED[0];         // Velocidad a la que se mueven los enemigos
+    float default_balloon_speed_ = BALLOON_SPEED[0]; // Velocidad base de los enemigos, sin incrementar
+    int balloon_deploy_counter_ = 0;                 // Cuando se lanza una formación, se le da un valor y no sale otra hasta que llegue a cero
+    bool power_ball_enabled_ = false;                // Indica si hay una powerball ya activa
+    int power_ball_counter_ = 0;                     // Contador de formaciones enemigas entre la aparicion de una PowerBall y otra
+    int last_balloon_deploy_ = 0;                    // Guarda cual ha sido la última formación desplegada para no repetir;
+
+    // Inicializa
+    void init();
+
+public:
+    // Constructor
+    BalloonManager();
+
+    // Destructor
+    ~BalloonManager() = default;
+
+    // Actualiza
+    void update();
+
+    // Renderiza los globos
+    void render();
+
+    // Vacia del vector de globos los globos que ya no sirven
+    void freeBalloons();
+
+    // Crea una formación de enemigos
+    void deployBalloonFormation(int stage);
+
+    // Actualiza la variable enemyDeployCounter
+    void updateBalloonDeployCounter();
+
+    // Indica si se puede crear una powerball
+    bool canPowerBallBeCreated();
+
+    // Calcula el poder actual de los globos en pantalla
+    int calculateScreenPower();
+
+    // Crea un globo nuevo en el vector de globos
+    std::shared_ptr<Balloon> createBalloon(float x, int y, BalloonType type, BalloonSize size, float velx, float speed, int creation_timer);
+
+    // Crea un globo a partir de otro globo
+    void createChildBalloon(const std::shared_ptr<Balloon> &balloon, const std::string &direction);
+
+    // Crea una PowerBall
+    void createPowerBall();
+
+    // Establece la velocidad de los globos
+    void setBalloonSpeed(float speed);
+
+    // Explosiona un globo. Lo destruye y crea otros dos si es el caso
+    int popBalloon(std::shared_ptr<Balloon> balloon);
+
+    // Explosiona un globo. Lo destruye = no crea otros globos
+    int destroyBalloon(std::shared_ptr<Balloon> &balloon);
+
+    // Destruye todos los globos
+    int destroyAllBalloons();
+
+    // Detiene todos los globos
+    void stopAllBalloons();
+
+    // Pone en marcha todos los globos
+    void startAllBalloons();
+
+    // Cambia el color de todos los globos
+    void reverseColorsToAllBalloons();
+
+    // Cambia el color de todos los globos
+    void normalColorsToAllBalloons();
+
+    // Recarga las texturas
+    void reLoad();
+
+    // Crea dos globos gordos
+    void createTwoBigBalloons();
+
+    // Obtiene el nivel de ameza actual generado por los globos
+    int getMenace();
+
+    // Getters
+    float getBalloonSpeed() const { return balloon_speed_; }
+    Balloons &getBalloons() { return balloons_; }
+
+    // Setters
+    void setDefaultBalloonSpeed(float speed) { default_balloon_speed_ = speed; }
+    void resetBalloonSpeed() { setBalloonSpeed(default_balloon_speed_); }
+};
--- a/source/define_buttons.cpp
+++ b/source/define_buttons.cpp
@@ -1,16 +1,16 @@
 #include "define_buttons.h"
-#include <utility>   // Para move
-#include "input.h"   // Para Input, InputType
-#include "lang.h"    // Para getText
-#include "options.h" // Para OptionsController, Options, options
-#include "param.h"   // Para Param, param, ParamGame, ParamTitle
-#include "section.h" // Para Name, Options, name, options
-#include "text.h"    // Para Text
+#include "input.h"    // Para Input, InputType
+#include "lang.h"     // Para getText
+#include "options.h"  // Para OptionsController, Options, options
+#include "param.h"    // Para Param, param, ParamGame, ParamTitle
+#include "resource.h" // Para Resource
+#include "section.h"  // Para Name, Options, name, options
+#include "text.h"     // Para Text

 // Constructor
-DefineButtons::DefineButtons(std::unique_ptr<Text> text_)
+DefineButtons::DefineButtons()
    : input_(Input::get()),
-      text_(std::move(text_))
+      text_(Resource::get()->getText("8bithud"))
 {
    // Inicializa variables
    x_ = param.game.width / 2;
--- a/source/define_buttons.h
+++ b/source/define_buttons.h
@@ -58,7 +58,7 @@ private:

 public:
    // Constructor
-    explicit DefineButtons(std::unique_ptr<Text> text);
+    DefineButtons();

    // Destructor
    ~DefineButtons() = default;
--- a/source/director.cpp
+++ b/source/director.cpp
@@ -15,7 +15,7 @@
 #include <algorithm>				 // Para min
 #include <cstdlib>					 // Para exit, EXIT_FAILURE, size_t, rand
 #include <iostream>					 // Para basic_ostream, operator<<, basi...
-#include <memory>					 // Para make_unique, unique_ptr, make_s...
+#include <memory>					 // Para make_unique, unique_ptr
 #include <stdexcept>				 // Para runtime_error
 #include <string>					 // Para operator+, char_traits, allocator
 #include <vector>					 // Para vector
@@ -38,7 +38,6 @@
 #include "resource.h"				 // Para Resource
 #include "screen.h"					 // Para Screen
 #include "section.h"				 // Para Name, Options, name, options
-#include "text.h"					 // Para Text
 #include "title.h"					 // Para Title
 #include "utils.h"					 // Para Overrides, overrides

@@ -118,8 +117,7 @@ Director::Director(int argc, const char *argv[])
 	Resource::init();
 	Input::init(Asset::get()->get("gamecontrollerdb.txt"));
 	bindInputs();
-	auto notifier_text = std::make_shared<Text>(Resource::get()->getTexture("8bithud.png"), Resource::get()->getTextFile("8bithud.txt"));
-	Notifier::init(std::string(), notifier_text, Asset::get()->get("notify.wav"));
+	Notifier::init(std::string(), Resource::get()->getText("8bithud"), Asset::get()->get("notify.wav"));
 	OnScreenHelp::init();
 	globalInputs::init();
 }
@@ -496,6 +494,8 @@ void Director::setFileList()
 	Asset::get()->add(prefix + "/data/font/smb2.txt", AssetType::FONT);
 	Asset::get()->add(prefix + "/data/font/04b_25.png", AssetType::BITMAP);
 	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);

 	// Textos
 	Asset::get()->add(prefix + "/data/lang/es_ES.txt", AssetType::LANG);
@@ -615,7 +615,7 @@ void Director::runGame()
 {
 	const auto player_id = section::options == section::Options::GAME_PLAY_1P ? 1 : 2;
 #ifdef DEBUG
-	constexpr auto current_stage = 9;
+	constexpr auto current_stage = 0;
 #else
 	constexpr auto current_stage = 0;
 #endif
--- a/source/enter_name.h
+++ b/source/enter_name.h
@@ -2,7 +2,7 @@

 #include <string>

-constexpr int NAME_LENGHT = 8;
+constexpr int NAME_LENGHT = 6;

 /*
    Un array, "characterList", contiene la lista de caracteres
--- a/source/game.cpp
+++ b/source/game.cpp
--- a/source/game.h
+++ b/source/game.h
@@ -5,27 +5,25 @@
 #include <memory>				  // Para shared_ptr, unique_ptr
 #include <string>				  // Para string
 #include <vector>				  // Para vector
-#include "balloon.h"			  // Para Balloon
 #include "manage_hiscore_table.h" // Para HiScoreEntry
 #include "options.h"			  // Para Options, OptionsGame, options
 #include "player.h"				  // Para Player
 #include "utils.h"				  // Para Demo
-class Asset;					  // lines 14-14
-class Background;				  // lines 15-15
-class BalloonFormations;		  // lines 16-16
-class Bullet;					  // lines 17-17
-class Explosions;				  // lines 18-18
-class Fade;						  // lines 19-19
-class Input;					  // lines 20-20
-class Item;						  // lines 21-21
-class PathSprite;				  // lines 22-22
-class Scoreboard;				  // lines 23-23
-class Screen;					  // lines 24-24
-class SmartSprite;				  // lines 25-25
-class Texture;					  // lines 27-27
-enum class BulletType : Uint8;	  // lines 28-28
-enum class ItemType;			  // lines 29-29
-struct Path;
+class Asset;					  // lines 13-13
+class Background;				  // lines 14-14
+class BalloonManager;
+class Bullet;				   // lines 15-15
+class Fade;					   // lines 16-16
+class Input;				   // lines 17-17
+class Item;					   // lines 18-18
+class PathSprite;			   // lines 19-19
+class Scoreboard;			   // lines 20-20
+class Screen;				   // lines 21-21
+class SmartSprite;			   // lines 22-22
+class Texture;				   // lines 23-23
+enum class BulletType : Uint8; // lines 24-24
+enum class ItemType;		   // lines 25-25
+struct Path;				   // lines 26-26

 // Modo demo
 constexpr bool GAME_MODE_DEMO_OFF = false;
@@ -123,14 +121,11 @@ private:
 	Input *input_;			 // Manejador de entrada
 	Scoreboard *scoreboard_; // Objeto para dibujar el marcador

-	std::unique_ptr<Background> background_;				// Objeto para dibujar el fondo del juego
-	std::unique_ptr<Explosions> explosions_;				// Objeto para dibujar explosiones
-	std::unique_ptr<BalloonFormations> balloon_formations_; // Objeto para gestionar las oleadas enemigas
+	std::unique_ptr<Background> background_; // Objeto para dibujar el fondo del juego

 	SDL_Texture *canvas_; // Textura para dibujar la zona de juego

 	std::vector<std::shared_ptr<Player>> players_;			  // Vector con los jugadores
-	std::vector<std::shared_ptr<Balloon>> balloons_;		  // Vector con los globos
 	std::vector<std::unique_ptr<Bullet>> bullets_;			  // Vector con las balas
 	std::vector<std::unique_ptr<Item>> items_;				  // Vector con los items
 	std::vector<std::unique_ptr<SmartSprite>> smart_sprites_; // Vector con los smartsprites
@@ -138,26 +133,22 @@ private:

 	std::shared_ptr<Texture> bullet_texture_;							 // Textura para las balas
 	std::vector<std::shared_ptr<Texture>> item_textures_;				 // Vector con las texturas de los items
-	std::vector<std::shared_ptr<Texture>> balloon_textures_;			 // Vector con las texturas de los globos
-	std::vector<std::shared_ptr<Texture>> explosions_textures_;			 // Vector con las texturas de las explosiones
 	std::vector<std::vector<std::shared_ptr<Texture>>> player_textures_; // Vector con todas las texturas de los jugadores;

 	std::vector<std::shared_ptr<Texture>> game_text_textures_; // Vector con las texturas para los sprites con textos

-	std::vector<std::vector<std::string>> item_animations_;		  // Vector con las animaciones de los items
-	std::vector<std::vector<std::string>> player_animations_;	  // Vector con las animaciones del jugador
-	std::vector<std::vector<std::string>> balloon_animations_;	  // Vector con las animaciones de los globos
-	std::vector<std::vector<std::string>> explosions_animations_; // Vector con las animaciones de las explosiones
+	std::vector<std::vector<std::string>> item_animations_;	  // Vector con las animaciones de los items
+	std::vector<std::vector<std::string>> player_animations_; // Vector con las animaciones del jugador

-	std::unique_ptr<Fade> fade_; // Objeto para renderizar fades
-	std::vector<Path> paths_;	 // Vector con los recorridos precalculados almacenados
+	std::unique_ptr<Fade> fade_;					  // Objeto para renderizar fades
+	std::unique_ptr<BalloonManager> balloon_manager_; // Objeto para gestionar los globos
+	std::vector<Path> paths_;						  // Vector con los recorridos precalculados almacenados

 	// Variables
 	HiScoreEntry hi_score_ = HiScoreEntry(
 		options.game.hi_score_table[0].name,
 		options.game.hi_score_table[0].score); // Máxima puntuación y nombre de quien la ostenta

-	int current_stage_;									  // Indica la fase actual
 	Demo demo_;											  // Variable con todas las variables relacionadas con el modo demo
 	GameDifficulty difficulty_ = options.game.difficulty; // Dificultad del juego
 	Helper helper_;										  // Variable para gestionar las ayudas
@@ -165,22 +156,14 @@ private:
 	bool coffee_machine_enabled_ = false;				  // Indica si hay una máquina de café en el terreno de juego
 	bool hi_score_achieved_ = false;					  // Indica si se ha superado la puntuación máxima
 	bool paused_ = false;								  // Indica si el juego está pausado (no se deberia de poder utilizar en el modo arcade)
-	bool power_ball_enabled_ = false;					  // Indica si hay una powerball ya activa
-	float balloon_speed_;								  // Velocidad a la que se mueven los enemigos
-	float default_balloon_speed_;						  // Velocidad base de los enemigos, sin incrementar
 	float difficulty_score_multiplier_;					  // Multiplicador de puntos en función de la dificultad
-	int balloon_deploy_counter_ = 0;					  // Cuando se lanza una formación, se le da un valor y no sale otra hasta que llegue a cero
-	int balloons_popped_ = 0;							  // Lleva la cuenta de los globos explotados
 	int counter_ = 0;									  // Contador para el juego
-	int current_power_ = 0;								  // Poder actual almacenado para completar la fase
 	int game_completed_counter_ = 0;					  // Contador para el tramo final, cuando se ha completado la partida y ya no aparecen más enemigos
 	int game_over_counter_ = GAME_OVER_COUNTER_;		  // Contador para el estado de fin de partida
-	int last_balloon_deploy_ = 0;						  // Guarda cual ha sido la última formación desplegada para no repetir;
-	int menace_current_ = 0;							  // Nivel de amenaza actual
-	int menace_threshold_ = 0;							  // Umbral del nivel de amenaza. Si el nivel de amenaza cae por debajo del umbral, se generan más globos. Si el umbral aumenta, aumenta el número de globos
-	int power_ball_counter_ = 0;						  // Contador de formaciones enemigas entre la aparicion de una PowerBall y otra
 	int time_stopped_counter_ = 0;						  // Temporizador para llevar la cuenta del tiempo detenido
 	int total_power_to_complete_game_;					  // La suma del poder necesario para completar todas las fases
+	int menace_current_ = 0;							  // Nivel de amenaza actual
+	int menace_threshold_ = 0;							  // Umbral del nivel de amenaza. Si el nivel de amenaza cae por debajo del umbral, se generan más globos. Si el umbral aumenta, aumenta el número de globos
 	GameState state_ = GameState::PLAYING;				  // Estado
 #ifdef DEBUG
 	bool auto_pop_balloons_ = false; // Si es true, incrementa automaticamente los globos explotados
@@ -198,12 +181,6 @@ private:
 	// Asigna texturas y animaciones
 	void setResources();

-	// Crea una formación de enemigos
-	void deployBalloonFormation();
-
-	// Aumenta el poder de la fase
-	void increaseStageCurrentPower(int power);
-
 	// Actualiza el valor de HiScore en caso necesario
 	void updateHiScore();

@@ -219,54 +196,9 @@ private:
 	// Actualiza el estado de fin de la partida
 	void updateGameOverState();

-	// Actualiza los globos
-	void updateBalloons();
-
-	// Pinta en pantalla todos los globos activos
-	void renderBalloons();
-
-	// Crea un globo nuevo en el vector de globos
-	std::shared_ptr<Balloon> createBalloon(float x, int y, BalloonType type, BalloonSize size, float velx, float speed, int stopped_counter);
-
-	// Crea un globo a partir de otro globo
-	void createChildBalloon(const std::shared_ptr<Balloon> &balloon, const std::string &direction);
-
-	// Crea una PowerBall
-	void createPowerBall();
-
-	// Establece la velocidad de los globos
-	void setBalloonSpeed(float speed);
-
-	// Actualiza la velocidad de los globos en funcion del poder acumulado de la fase
-	void checkAndUpdateBalloonSpeed();
-
-	// Explosiona un globo. Lo destruye y crea otros dos si es el caso
-	void popBalloon(std::shared_ptr<Balloon> balloon);
-
-	// Explosiona un globo. Lo destruye
-	void destroyBalloon(std::shared_ptr<Balloon> &balloon);
-
-	// Destruye todos los globos
-	void destroyAllBalloons();
-
 	// Destruye todos los items
 	void destroyAllItems();

-	// Detiene todos los globos
-	void stopAllBalloons();
-
-	// Pone en marcha todos los globos
-	void startAllBalloons();
-
-	// Cambia el color de todos los globos
-	void reverseColorsToAllBalloons();
-
-	// Cambia el color de todos los globos
-	void normalColorsToAllBalloons();
-
-	// Vacia el vector de globos
-	void freeBalloons();
-
 	// Comprueba la colisión entre el jugador y los globos activos
 	bool checkPlayerBalloonCollision(std::shared_ptr<Player> &player);

@@ -333,18 +265,9 @@ private:
 	// Acciones a realizar cuando el jugador muere
 	void killPlayer(std::shared_ptr<Player> &player);

-	// Calcula y establece el valor de amenaza en funcion de los globos activos
-	void evaluateAndSetMenace();
-
-	// Actualiza la variable EnemyDeployCounter
-	void updateBalloonDeployCounter();
-
 	// Actualiza y comprueba el valor de la variable
 	void updateTimeStopped();

-	// Gestiona el nivel de amenaza
-	void updateMenace();
-
 	// Actualiza el fondo
 	void updateBackground();

@@ -357,12 +280,6 @@ private:
 	// Deshabilita el efecto del item de detener el tiempo
 	void disableTimeStopItem();

-	// Indica si se puede crear una powerball
-	bool canPowerBallBeCreated();
-
-	// Calcula el poder actual de los globos en pantalla
-	int calculateScreenPower();
-
 	// Actualiza las variables de ayuda
 	void updateHelper();

@@ -450,9 +367,6 @@ private:
 	// Inicializa los jugadores
 	void initPlayers(int player_id);

-	// Crea dos globos gordos
-	void createTwoBigBalloons();
-
 	// Pausa la música
 	void pauseMusic();

@@ -471,9 +385,6 @@ private:
 	// Actualiza las variables durante el transcurso normal del juego
 	void updateGame();

-	// Actualiza las variables durante el transcurso del final del juego
-	void updateCompletedGame();
-
 	// Gestiona eventos para el estado del final del juego
 	void updateCompletedState();

@@ -483,6 +394,15 @@ private:
 	// Vacía los vectores de elementos deshabilitados
 	void cleanVectors();

+	// Gestiona el nivel de amenaza
+	void updateMenace();
+
+	// Calcula y establece el valor de amenaza en funcion de los globos activos
+	void evaluateAndSetMenace();
+
+	// Actualiza la velocidad de los globos en funcion del poder acumulado de la fase
+	void checkAndUpdateBalloonSpeed();
+
 public:
 	// Constructor
 	Game(int playerID, int current_stage, bool demo);
--- a/source/hiscore_table.cpp
+++ b/source/hiscore_table.cpp
@@ -27,7 +27,7 @@ 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_(std::make_unique<Text>(Resource::get()->getTexture("smb2.gif"), Resource::get()->getTextFile("smb2.txt"))),
+	  text_(Resource::get()->getText("smb2")),
 	  counter_(0),
 	  ticks_(0),
 	  view_area_({0, 0, param.game.width, param.game.height}),
--- a/source/hiscore_table.h
+++ b/source/hiscore_table.h
@@ -33,7 +33,7 @@ private:

 	std::unique_ptr<Fade> fade_;			 // Objeto para renderizar fades
 	std::unique_ptr<Background> background_; // Objeto para dibujar el fondo del juego
-	std::unique_ptr<Text> text_;			 // Objeto para escribir texto
+	std::shared_ptr<Text> text_;			 // Objeto para escribir texto

 	// Variables
 	Uint16 counter_;	 // Contador
--- a/source/instructions.cpp
+++ b/source/instructions.cpp
@@ -26,7 +26,7 @@ Instructions::Instructions()
 	: renderer_(Screen::get()->getRenderer()),
 	  texture_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height)),
 	  backbuffer_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height)),
-	  text_(std::make_unique<Text>(Resource::get()->getTexture("smb2.gif"), Resource::get()->getTextFile("smb2.txt"))),
+	  text_(Resource::get()->getText("smb2")),
 	  tiled_bg_(std::make_unique<TiledBG>((SDL_Rect){0, 0, param.game.width, param.game.height}, TiledBGMode::STATIC)),
 	  fade_(std::make_unique<Fade>())
 {
--- a/source/instructions.h
+++ b/source/instructions.h
@@ -35,7 +35,7 @@ private:

 	std::vector<std::shared_ptr<Texture>> item_textures_; // Vector con las texturas de los items
 	std::vector<std::unique_ptr<Sprite>> sprites_;		  // Vector con los sprites de los items
-	std::unique_ptr<Text> text_;						  // Objeto para escribir texto
+	std::shared_ptr<Text> text_;						  // Objeto para escribir texto
 	std::unique_ptr<TiledBG> tiled_bg_;					  // Objeto para dibujar el mosaico animado de fondo
 	std::unique_ptr<Fade> fade_;						  // Objeto para renderizar fades

--- a/source/intro.cpp
+++ b/source/intro.cpp
@@ -20,7 +20,7 @@
 // Constructor
 Intro::Intro()
 	: texture_(Resource::get()->getTexture("intro.png")),
-	  text_(std::make_shared<Text>(Resource::get()->getTexture("nokia.png"), Resource::get()->getTextFile("nokia.txt")))
+	  text_(Resource::get()->getText("nokia"))
 {

 	// Inicializa variables
--- a/source/item.cpp
+++ b/source/item.cpp
@@ -1,10 +1,10 @@
 #include "item.h"
+#include <algorithm>		 // para std::clamp
 #include <stdlib.h>			 // para rand
 #include "animated_sprite.h" // para SpriteAnimated
 #include "param.h"			 // para param
 class Texture;

-// Constructor
 Item::Item(ItemType type, float x, float y, SDL_Rect &play_area, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation)
 	: sprite_(std::make_unique<AnimatedSprite>(texture, animation)),
 	  type_(type),
@@ -38,34 +38,26 @@ Item::Item(ItemType type, float x, float y, SDL_Rect &play_area, std::shared_ptr
 	}
 	}

-	sprite_->setPosX(pos_x_);
-	sprite_->setPosY(pos_y_);
+	// Actualiza el sprite
+	shiftSprite();
 	shiftColliders();
 }

-// Centra el objeto en la posición X
 void Item::alignTo(int x)
 {
-	pos_x_ = static_cast<float>(x - (width_ / 2));
+	const float min_x = param.game.play_area.rect.x + 1;
+	const float max_x = play_area_.w - width_ - 1;

-	if (pos_x_ < param.game.play_area.rect.x)
-	{
-		pos_x_ = param.game.play_area.rect.x + 1;
-	}
-	else if (pos_x_ + width_ > play_area_.w)
-	{
-		pos_x_ = static_cast<float>(play_area_.w - width_ - 1);
-	}
+	pos_x_ = x - (width_ / 2);

-	// Posición X,Y del sprite
-	sprite_->setPosX(pos_x_);
-	sprite_->setPosY(pos_y_);
+	// Ajusta para que no quede fuera de la zona de juego
+	pos_x_ = std::clamp(pos_x_, min_x, max_x);

-	// Alinea el circulo de colisión con el objeto
+	// Actualiza el sprite
+	shiftSprite();
 	shiftColliders();
 }

-// Pinta el objeto en la pantalla
 void Item::render()
 {
 	if (enabled_)
@@ -81,7 +73,8 @@ void Item::render()
 	}
 }

-// Actualiza la posición y estados del objeto
+#include <algorithm> // Necesario para std::clamp
+
 void Item::move()
 {
 	floor_collision_ = false;
@@ -94,129 +87,90 @@ void Item::move()
 	vel_x_ += accel_x_;
 	vel_y_ += accel_y_;

-	// Si queda fuera de pantalla, corregimos su posición y cambiamos su sentido
-	if ((pos_x_ < param.game.play_area.rect.x) || (pos_x_ + width_ > play_area_.w))
-	{
-		// Corregir posición
-		pos_x_ -= vel_x_;
+	// Comprueba los laterales de la zona de juego
+	const float min_x = param.game.play_area.rect.x;
+	const float max_x = play_area_.w - width_;
+	pos_x_ = std::clamp(pos_x_, min_x, max_x);

-		// Invertir sentido
+	// Si toca el borde lateral, invierte la velocidad horizontal
+	if (pos_x_ == min_x || pos_x_ == max_x)
+	{
 		vel_x_ = -vel_x_;
 	}

-	// Si se sale por arriba rebota (excepto la maquina de café)
+	// Si colisiona por arriba, rebota (excepto la máquina de café)
 	if ((pos_y_ < param.game.play_area.rect.y) && !(type_ == ItemType::COFFEE_MACHINE))
 	{
 		// Corrige
 		pos_y_ = param.game.play_area.rect.y;

-		// Invierte el sentido
+		// Invierte la velocidad
 		vel_y_ = -vel_y_;
 	}

-	// Si el objeto se sale por la parte inferior
-	if (pos_y_ + height_ > play_area_.h)
+	// Si colisiona con la parte inferior
+	if (pos_y_ > play_area_.h - height_)
 	{
-		// Detiene el objeto
-		vel_y_ = 0;
-		vel_x_ = 0;
-		accel_x_ = 0;
-		accel_y_ = 0;
+		// Corrige la posición
 		pos_y_ = play_area_.h - height_;
+
 		if (type_ == ItemType::COFFEE_MACHINE)
 		{
+			// Si es una máquina de café, detiene el objeto
+			vel_y_ = vel_x_ = accel_x_ = accel_y_ = 0;
 			floor_collision_ = true;
 		}
+		else
+		{
+			// Si no es una máquina de café
+			if (vel_y_ < 1.0f)
+			{
+				// Si la velocidad vertical es baja, detiene el objeto
+				vel_y_ = vel_x_ = accel_x_ = accel_y_ = 0;
+			}
+			else
+			{
+				// Si la velocidad vertical es alta, el objeto rebota y pierde velocidad
+				vel_y_ *= -0.5f;
+				vel_x_ *= 0.75f;
+			}
+		}
 	}

 	// Actualiza la posición del sprite
-	sprite_->setPosX(int(pos_x_));
-	sprite_->setPosY(int(pos_y_));
+	shiftSprite();
 	shiftColliders();
 }

-// Pone a cero todos los valores del objeto
-void Item::disable()
-{
-	enabled_ = false;
-}
+void Item::disable() { enabled_ = false; }

-// Actualiza el objeto a su posicion, animación y controla los contadores
 void Item::update()
 {
 	move();
 	sprite_->update();
 	updateTimeToLive();
-	checkTimeToLive();
 }

-// Actualiza el contador
 void Item::updateTimeToLive()
 {
 	if (time_to_live_ > 0)
 	{
 		time_to_live_--;
 	}
-}
-
-// Comprueba si el objeto sigue vivo
-void Item::checkTimeToLive()
-{
-	if (time_to_live_ == 0)
+	else
+	{
 		disable();
+	}
 }

-// Obtiene del valor de la variable
-float Item::getPosX()
-{
-	return pos_x_;
-}
-
-// Obtiene del valor de la variable
-float Item::getPosY()
-{
-	return pos_y_;
-}
-
-// Obtiene del valor de la variable
-int Item::getWidth()
-{
-	return width_;
-}
-
-// Obtiene del valor de la variable
-int Item::getHeight()
-{
-	return height_;
-}
-
-// Obtiene del valor de la variable
-ItemType Item::getType()
-{
-	return type_;
-}
-
-// Obtiene el valor de la variable
-bool Item::isEnabled()
-{
-	return enabled_;
-}
-
-// Obtiene el circulo de colisión
-Circle &Item::getCollider()
-{
-	return collider_;
-}
-
-// Alinea el circulo de colisión con la posición del objeto
 void Item::shiftColliders()
 {
-	collider_.x = int(pos_x_ + (width_ / 2));
-	collider_.y = int(pos_y_ + (height_ / 2));
+	collider_.x = static_cast<int>(pos_x_ + (width_ / 2));
+	collider_.y = static_cast<int>(pos_y_ + (height_ / 2));
 }

-// Informa si el objeto ha colisionado con el suelo
-bool Item::isOnFloor()
+void Item::shiftSprite()
 {
-	return floor_collision_;
-}
+	sprite_->setPosX(pos_x_);
+	sprite_->setPosY(pos_y_);
+}
--- a/source/item.h
+++ b/source/item.h
@@ -9,93 +9,147 @@
 #include "utils.h"           // para Circle
 class Texture;

-// Tipos de objetos
+/**
+ * @brief Tipos de objetos disponibles en el juego.
+ *
+ * Esta enumeración define los diferentes tipos de objetos que pueden existir en el juego, 
+ * cada uno con un identificador único.
+ */
 enum class ItemType : int
 {
-    DISK = 1,
-    GAVINA = 2,
-    PACMAR = 3,
-    CLOCK = 4,
-    COFFEE = 5,
-    COFFEE_MACHINE = 6,
-    NONE = 7,
+    DISK = 1,          /**< Disco */
+    GAVINA = 2,        /**< Gavina */
+    PACMAR = 3,        /**< Pacman */
+    CLOCK = 4,         /**< Reloj */
+    COFFEE = 5,        /**< Café */
+    COFFEE_MACHINE = 6,/**< Máquina de café */
+    NONE = 7,          /**< Ninguno */
 };

-// Clase Item
+/**
+ * @brief Clase Item.
+ *
+ * Esta clase representa un objeto en el juego, con sus propiedades y métodos para gestionar su comportamiento.
+ */
 class Item
 {
 private:
    // Objetos y punteros
-    std::unique_ptr<AnimatedSprite> sprite_; // Sprite con los graficos del objeto
+    std::unique_ptr<AnimatedSprite> sprite_; /**< Sprite con los gráficos del objeto */

    // Variables
-    float pos_x_;                  // Posición X del objeto
-    float pos_y_;                  // Posición Y del objeto
-    int width_;                    // Ancho del objeto
-    int height_;                   // Alto del objeto
-    float vel_x_;                  // Velocidad en el eje X
-    float vel_y_;                  // Velocidad en el eje Y
-    float accel_x_ = 0.0f;         // Aceleración en el eje X
-    float accel_y_;                // Aceleración en el eje Y
-    bool floor_collision_ = false; // Indica si el objeto colisiona con el suelo
-    ItemType type_;                // Especifica el tipo de objeto que es
-    bool enabled_ = true;          // Especifica si el objeto está habilitado
-    Circle collider_;              // Circulo de colisión del objeto
-    SDL_Rect play_area_;           // Rectangulo con la zona de juego
-    Uint16 time_to_live_ = 600;    // Temporizador con el tiempo que el objeto está presente
+    float pos_x_;                  /**< Posición X del objeto */
+    float pos_y_;                  /**< Posición Y del objeto */
+    int width_;                    /**< Ancho del objeto */
+    int height_;                   /**< Alto del objeto */
+    float vel_x_;                  /**< Velocidad en el eje X */
+    float vel_y_;                  /**< Velocidad en el eje Y */
+    float accel_x_ = 0.0f;         /**< Aceleración en el eje X */
+    float accel_y_;                /**< Aceleración en el eje Y */
+    bool floor_collision_ = false; /**< Indica si el objeto colisiona con el suelo */
+    ItemType type_;                /**< Especifica el tipo de objeto que es */
+    bool enabled_ = true;          /**< Especifica si el objeto está habilitado */
+    Circle collider_;              /**< Círculo de colisión del objeto */
+    SDL_Rect play_area_;           /**< Rectángulo con la zona de juego */
+    Uint16 time_to_live_ = 600;    /**< Temporizador con el tiempo que el objeto está presente */

-    // Alinea el circulo de colisión con la posición del objeto
+    /**
+     * @brief Alinea el círculo de colisión con la posición del objeto.
+     *
+     * Esta función ajusta la posición del círculo de colisión para que coincida con la posición del objeto.
+     * Actualiza las coordenadas X e Y del colisionador basándose en las coordenadas del objeto.
+     */
    void shiftColliders();

-    // Actualiza la posición y estados del objeto
+    /**
+     * @brief Coloca el sprite en la posición del objeto.
+     *
+     * Esta función ajusta la posición del sprite para que coincida con la posición del objeto.
+     * Actualiza las coordenadas X e Y del sprite basándose en las coordenadas del objeto.
+     */
+    void shiftSprite();
+
+    /**
+     * @brief Actualiza la posición y estados del objeto.
+     *
+     * Esta función actualiza la posición del objeto basándose en su velocidad y aceleración.
+     * Controla las colisiones con los límites del área de juego, ajustando la posición y la velocidad en consecuencia.
+     * También actualiza la posición del sprite y el colisionador del objeto.
+     */
    void move();

-    // Actualiza el contador
+    /**
+     * @brief Actualiza el contador de tiempo de vida del objeto.
+     *
+     * Esta función decrementa el contador de tiempo de vida del objeto.
+     * Si el tiempo de vida es mayor a 0, se decrementa en 1.
+     * Si el tiempo de vida es 0 o menos, se desactiva el objeto llamando a la función `disable()`.
+     */
    void updateTimeToLive();

-    // Comprueba si el objeto sigue vivo
-    void checkTimeToLive();
-
 public:
-    // Constructor
+    /**
+     * @brief Constructor de la clase Item.
+     *
+     * Este constructor inicializa un objeto Item con el tipo especificado, posición inicial, área de juego, textura y animación.
+     *
+     * @param type El tipo de objeto (ItemType).
+     * @param x La posición X inicial del objeto.
+     * @param y La posición Y inicial del objeto.
+     * @param play_area El área de juego donde el objeto se moverá.
+     * @param texture La textura del objeto.
+     * @param animation La animación asociada al objeto.
+     */
    Item(ItemType type, float x, float y, SDL_Rect &play_area, std::shared_ptr<Texture> texture, const std::vector<std::string> &animation);

-    // Destructor
+    /**
+     * @brief Destructor de la clase Item.
+     *
+     * Este destructor libera los recursos asociados con el objeto Item.
+     */
    ~Item() = default;

-    // Centra el objeto en la posición X
+    /**
+     * @brief Centra el objeto en la posición X.
+     *
+     * Esta función ajusta la posición X del objeto para que esté centrado en la posición X especificada.
+     * Además, asegura que el objeto no se salga de los límites del área de juego.
+     *
+     * @param x La posición X en la que se desea centrar el objeto.
+     */
    void alignTo(int x);

-    // Pinta el objeto en la pantalla
+    /**
+     * @brief Pinta el objeto en la pantalla.
+     *
+     * Esta función renderiza el objeto en la pantalla si está habilitado.
+     * Si el tiempo de vida (`time_to_live_`) es mayor que 200, renderiza el sprite.
+     * Si el tiempo de vida es menor o igual a 200, renderiza el sprite de forma intermitente, basándose en un cálculo de módulo.
+     */
    void render();

-    // Pone a cero todos los valores del objeto
+    /**
+     * @brief Pone a cero todos los valores del objeto.
+     *
+     * Esta función desactiva el objeto estableciendo su estado `enabled_` a `false`.
+     */
    void disable();

-    // Actualiza al objeto a su posicion, animación y controla los contadores
+    /**
+     * @brief Actualiza el objeto a su posición, animación y controla los contadores.
+     *
+     * Esta función mueve el objeto, actualiza su animación y controla el contador de tiempo de vida.
+     * Llama a las funciones `move()`, `sprite_->update()` y `updateTimeToLive()`.
+     */
    void update();

-    // Obtiene del valor de la variable
-    float getPosX();
-
-    // Obtiene del valor de la variable
-    float getPosY();
-
-    // Obtiene del valor de la variable
-    int getWidth();
-
-    // Obtiene del valor de la variable
-    int getHeight();
-
-    // Obtiene del valor de la variable
-    ItemType getType();
-
-    // Obtiene el valor de la variable
-    bool isEnabled();
-
-    // Obtiene el circulo de colisión
-    Circle &getCollider();
-
-    // Informa si el objeto ha colisionado con el suelo
-    bool isOnFloor();
-};
+    // Getters
+    float getPosX() const { return pos_x_; }
+    float getPosY() const { return pos_y_; }
+    int getWidth() const { return width_; }
+    int getHeight() const { return height_; }
+    ItemType getType() const { return type_; }
+    bool isEnabled() const { return enabled_; }
+    bool isOnFloor() const { return floor_collision_; }
+    Circle &getCollider() { return collider_; }
+};
--- a/source/manage_hiscore_table.cpp
+++ b/source/manage_hiscore_table.cpp
@@ -12,16 +12,18 @@ void ManageHiScoreTable::clear()
    table_.clear();

    // Añade 10 entradas predefinidas
-    table_.push_back(HiScoreEntry("Bry", 1000000));
-    table_.push_back(HiScoreEntry("Usufondo", 500000));
-    table_.push_back(HiScoreEntry("G.Lucas", 100000));
-    table_.push_back(HiScoreEntry("P.Delgat", 50000));
-    table_.push_back(HiScoreEntry("P.Arrabalera", 10000));
-    table_.push_back(HiScoreEntry("Pelechano", 5000));
-    table_.push_back(HiScoreEntry("Sahuquillo", 1000));
-    table_.push_back(HiScoreEntry("Bacteriol", 500));
-    table_.push_back(HiScoreEntry("Pepe", 200));
-    table_.push_back(HiScoreEntry("Rosita", 100));
+    table_.push_back(HiScoreEntry("BRY", 1000000));
+    table_.push_back(HiScoreEntry("USUFON", 500000));
+    table_.push_back(HiScoreEntry("GLUCAS", 100000));
+    table_.push_back(HiScoreEntry("PDLGAT", 50000));
+    table_.push_back(HiScoreEntry("PARRAB", 10000));
+    table_.push_back(HiScoreEntry("PELECH", 5000));
+    table_.push_back(HiScoreEntry("SAHUQU", 1000));
+    table_.push_back(HiScoreEntry("BACTER", 500));
+    table_.push_back(HiScoreEntry("PEPE", 200));
+    table_.push_back(HiScoreEntry("ROSITA", 100));
+
+    sort();
 }

 // Añade un elemento a la tabla
--- a/source/moving_sprite.cpp
+++ b/source/moving_sprite.cpp
@@ -96,6 +96,12 @@ void MovingSprite::setAngle(double value)
 	rotate_.angle = value;
 }

+// Establece el valor de la variable
+void MovingSprite::setRotatingCenter(SDL_Point *point)
+{
+	rotate_.center = point;
+}
+
 // Incrementa el valor del ángulo
 void MovingSprite::updateAngle()
 {
@@ -122,17 +128,10 @@ void MovingSprite::rotate()
 	}
 }

-// Establece el valor de la variable
-void MovingSprite::enableRotate()
+// Activa o desactiva el efecto de rotación
+void MovingSprite::setRotate(bool enable)
 {
-	rotate_.enabled = true;
-	rotate_.counter = 0;
-}
-
-// Establece el valor de la variable
-void MovingSprite::disableRotate()
-{
-	rotate_.enabled = false;
+	rotate_.enabled = enable;
 	rotate_.counter = 0;
 }

@@ -172,41 +171,6 @@ SDL_RendererFlip MovingSprite::getFlip()
 	return flip_;
 }

-// Obtiene el valor de la variable
-float MovingSprite::getPosX() const
-{
-	return x_;
-}
-
-// Obtiene el valor de la variable
-float MovingSprite::getPosY() const
-{
-	return y_;
-}
-
-// Obtiene el valor de la variable
-float MovingSprite::getVelX() const
-{
-	return vx_;
-}
-
-// Obtiene el valor de la variable
-float MovingSprite::getVelY() const
-{
-	return vy_;
-}
-
-// Obtiene el valor de la variable
-float MovingSprite::getAccelX() const
-{
-	return ax_;
-}
-
-// Obtiene el valor de la variable
-float MovingSprite::getAccelY() const
-{
-	return ay_;
-}

 // Establece la posición y_ el tamaño del objeto
 void MovingSprite::setPos(SDL_Rect rect)
--- a/source/moving_sprite.h
+++ b/source/moving_sprite.h
@@ -19,7 +19,7 @@ public:
        float amount;      // Cantidad de grados a girar en cada iteración
        SDL_Point *center; // Centro de rotación

-        Rotate() : enabled(false), counter(0), speed(0), angle(0.0), amount(0.0f), center(nullptr) {}
+        Rotate() : enabled(false), counter(0), speed(1), angle(0.0), amount(0.0f), center(nullptr) {}
    };

 protected:
@@ -65,12 +65,12 @@ public:
    void render() override;

    // Obtiene la variable
-    float getPosX() const;
-    float getPosY() const;
-    float getVelX() const;
-    float getVelY() const;
-    float getAccelX() const;
-    float getAccelY() const;
+    float getPosX() const { return x_; }
+    float getPosY() const { return y_; }
+    float getVelX() const { return vx_; }
+    float getVelY() const { return vy_; }
+    float getAccelX() const { return ax_; }
+    float getAccelY() const { return ay_; }

    // Establece la variable
    void setVelX(float value);
@@ -87,10 +87,10 @@ public:

    // Establece el valor de la variable
    void setAngle(double vaue);
+    void setRotatingCenter(SDL_Point *point);

-    // Activa o desactiva el efecto derotación
-    void enableRotate();
-    void disableRotate();
+    // Activa o desactiva el efecto de rotación
+    void setRotate(bool enable);

    // Establece el valor de la variable
    void setRotateSpeed(int value);
--- a/source/on_screen_help.cpp
+++ b/source/on_screen_help.cpp
@@ -94,7 +94,7 @@ void OnScreenHelp::fillTexture()
    SDL_SetRenderTarget(Screen::get()->getRenderer(), texture);

    // Crea el objeto para el texto
-    auto text = std::make_unique<Text>(Resource::get()->getTexture("8bithud.png"), Resource::get()->getTextFile("8bithud.txt"));
+    auto text = Resource::get()->getText("8bithud");

    // Crea la textura con los gráficos
    auto controllersTexture = Resource::get()->getTexture("controllers.png");
@@ -169,7 +169,7 @@ void OnScreenHelp::toggleState()
 // Calcula la longitud en pixels del texto más largo
 auto OnScreenHelp::getLargestStringSize() -> int const
 {
-    auto text = std::make_unique<Text>(Resource::get()->getTexture("8bithud.png"), Resource::get()->getTextFile("8bithud.txt"));
+    auto text = Resource::get()->getText("8bithud");
    auto size = 0;

    for (int i = 107; i <= 113; ++i)
--- a/source/player.cpp
+++ b/source/player.cpp
@@ -29,7 +29,7 @@ Player::Player(int id, float x, int y, bool demo, SDL_Rect &play_area, std::vect
 	power_sprite_->setPosY(y - (power_sprite_->getHeight() - player_sprite_->getHeight()));

 	// Inicializa variables
-	setRecordName(enter_name_->getName());
+	pos_x_ = default_pos_x_;
 	init();
 }

@@ -37,7 +37,6 @@ Player::Player(int id, float x, int y, bool demo, SDL_Rect &play_area, std::vect
 void Player::init()
 {
 	// Inicializa variables de estado
-	pos_x_ = default_pos_x_;
 	pos_y_ = default_pos_y_;
 	walking_state_ = PlayerState::WALKING_STOP;
 	firing_state_ = PlayerState::FIRING_NONE;
@@ -58,6 +57,7 @@ void Player::init()
 	score_ = 0;
 	score_multiplier_ = 1.0f;
 	cooldown_ = 10;
+	enter_name_->init();

 	// Establece la posición del sprite
 	player_sprite_->clear();
@@ -147,12 +147,10 @@ void Player::setInputEnteringName(InputType input)
 		enter_name_->decIndex();
 		break;
 	case InputType::START:
-		setRecordName(enter_name_->getName());
 		break;
 	default:
 		break;
 	}
-	setRecordName(enter_name_->getName());
 }

 // Mueve el jugador a la posición y animación que le corresponde
@@ -177,14 +175,33 @@ void Player::move()
 	{
 		// Si el cadaver abandona el area de juego por los laterales lo hace rebotar
 		if ((player_sprite_->getPosX() < param.game.play_area.rect.x) || (player_sprite_->getPosX() + WIDTH_ > play_area_.w))
+		{
 			player_sprite_->setVelX(-player_sprite_->getVelX());
+		}

-		// Si el cadaver abandona el area de juego por abajo
-		if (player_sprite_->getPosY() > param.game.play_area.rect.h)
-			setPlayingState(PlayerState::DIED);
+		// Si el cadaver toca el suelo cambia el estado
+		if (player_sprite_->getPosY() > param.game.play_area.rect.h - HEIGHT_)
+		{
+			if (player_sprite_->getVelY() < 2.0f)
+			{
+				// Si la velocidad de rebote es baja, termina de rebotar y cambia de estado
+				setPlayingState(PlayerState::DIED);
+				pos_x_ = player_sprite_->getPosX();
+				pos_y_ = default_pos_y_;
+				player_sprite_->clear();
+				shiftSprite();
+			}
+			else
+			{
+				// Decrementa las velocidades de rebote
+				player_sprite_->setPosY(param.game.play_area.rect.h - HEIGHT_);
+				player_sprite_->setVelY(player_sprite_->getVelY() * -0.5f);
+				player_sprite_->setVelX(player_sprite_->getVelX() * 0.75f);
+			}
+		}
 		break;
 	}
-	case PlayerState::GAME_COMPLETED:
+	case PlayerState::LEAVING_SCREEN:
 	{
 		switch (id_)
 		{
@@ -216,28 +233,38 @@ void Player::move()
 void Player::render()
 {
 	if (power_up_ && isPlaying())
+	{
 		if (power_up_counter_ > (POWERUP_COUNTER_ / 4) || power_up_counter_ % 20 > 4)
+		{
 			power_sprite_->render();
+		}
+	}

 	if (isRenderable())
+	{
 		player_sprite_->render();
+	}
 }

 // Establece la animación correspondiente al estado
 void Player::setAnimation()
 {
-	// Crea cadenas de texto para componer el nombre de la animación
-	const std::string a_walking = walking_state_ == PlayerState::WALKING_STOP ? "stand" : "walk";
-	const std::string a_firing = firing_state_ == PlayerState::FIRING_UP ? "centershoot" : "sideshoot";
-	const std::string a_cooling = firing_state_ == PlayerState::COOLING_UP ? "centershoot" : "sideshoot";
-
-	const SDL_RendererFlip flip_walk = walking_state_ == PlayerState::WALKING_RIGHT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
-	const SDL_RendererFlip flip_fire = firing_state_ == PlayerState::FIRING_RIGHT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
-	const SDL_RendererFlip flip_cooling = firing_state_ == PlayerState::COOLING_RIGHT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
-
-	// Establece la animación a partir de las cadenas
-	if (isPlaying() || isEnteringNameGameCompleted() || isGameCompleted())
+	switch (playing_state_)
 	{
+	case PlayerState::PLAYING:
+	case PlayerState::ENTERING_NAME_GAME_COMPLETED:
+	case PlayerState::LEAVING_SCREEN:
+	{
+		// Crea cadenas de texto para componer el nombre de la animación
+		const std::string a_walking = walking_state_ == PlayerState::WALKING_STOP ? "stand" : "walk";
+		const std::string a_firing = firing_state_ == PlayerState::FIRING_UP ? "centershoot" : "sideshoot";
+		const std::string a_cooling = firing_state_ == PlayerState::COOLING_UP ? "centershoot" : "sideshoot";
+
+		const SDL_RendererFlip flip_walk = walking_state_ == PlayerState::WALKING_RIGHT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
+		const SDL_RendererFlip flip_fire = firing_state_ == PlayerState::FIRING_RIGHT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
+		const SDL_RendererFlip flip_cooling = firing_state_ == PlayerState::COOLING_RIGHT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
+
+		// Establece la animación a partir de las cadenas
 		if (firing_state_ == PlayerState::FIRING_NONE)
 		{ // No esta disparando
 			player_sprite_->setCurrentAnimation(a_walking);
@@ -255,14 +282,27 @@ void Player::setAnimation()
 			// Si dispara recto, invierte el sprite segun hacia donde camina
 			player_sprite_->setFlip(a_firing == "centershoot" ? flip_walk : flip_fire);
 		}
+		break;
 	}
-	else if (isDying() || hasDied())
+	case PlayerState::DYING:
 	{
-		player_sprite_->setCurrentAnimation("death");
+		player_sprite_->setCurrentAnimation("dying");
+		break;
 	}
-	else if (isCelebrating())
+	case PlayerState::DIED:
+	case PlayerState::ENTERING_NAME:
+	case PlayerState::CONTINUE:
+	{
+		player_sprite_->setCurrentAnimation("dead");
+		break;
+	}
+	case PlayerState::CELEBRATING:
 	{
 		player_sprite_->setCurrentAnimation("celebration");
+		break;
+	}
+	default:
+		break;
 	}

 	// Actualiza las animaciones de los sprites
@@ -344,7 +384,7 @@ void Player::updateScoreboard()
 	case PlayerState::ENTERING_NAME:
 	case PlayerState::ENTERING_NAME_GAME_COMPLETED:
 	{
-		Scoreboard::get()->setRecordName(getScoreBoardPanel(), getRecordName());
+		Scoreboard::get()->setRecordName(getScoreBoardPanel(), enter_name_->getName());
 		Scoreboard::get()->setSelectorPos(getScoreBoardPanel(), getRecordNamePos());
 		break;
 	}
@@ -381,7 +421,6 @@ void Player::setPlayingState(PlayerState state)
 		// Inicializa el contador de continuar
 		continue_ticks_ = SDL_GetTicks();
 		continue_counter_ = 9;
-		enter_name_->init();
 		setScoreboardMode(ScoreboardMode::CONTINUE);
 		break;
 	}
@@ -426,7 +465,7 @@ void Player::setPlayingState(PlayerState state)
 		setScoreboardMode(ScoreboardMode::ENTER_NAME);
 		break;
 	}
-	case PlayerState::GAME_COMPLETED:
+	case PlayerState::LEAVING_SCREEN:
 	{
 		setScoreboardMode(ScoreboardMode::GAME_COMPLETED);
 		break;
@@ -578,7 +617,7 @@ void Player::decEnterNameCounter()
 		if (playing_state_ == PlayerState::ENTERING_NAME)
 			setPlayingState(PlayerState::CONTINUE);
 		else
-			setPlayingState(PlayerState::GAME_COMPLETED);
+			setPlayingState(PlayerState::LEAVING_SCREEN);
 	}
 }

@@ -597,50 +636,4 @@ void Player::shiftSprite()
 	player_sprite_->setPosX(pos_x_);
 	player_sprite_->setPosY(pos_y_);
 	power_sprite_->setPosX(getPosX() - power_up_desp_x_);
-}
-
-int Player::getScore() const { return score_; }
-void Player::setScore(int score) { score_ = score; }
-PlayerState Player::getPlayingState() const { return playing_state_; }
-float Player::getScoreMultiplier() const { return score_multiplier_; }
-void Player::setScoreMultiplier(float value) { score_multiplier_ = value; }
-bool Player::isInvulnerable() const { return invulnerable_; }
-int Player::getInvulnerableCounter() const { return invulnerable_counter_; }
-void Player::setInvulnerableCounter(int value) { invulnerable_counter_ = value; }
-bool Player::isPowerUp() const { return power_up_; }
-int Player::getPowerUpCounter() const { return power_up_counter_; }
-void Player::setPowerUpCounter(int value) { power_up_counter_ = value; }
-bool Player::hasExtraHit() const { return extra_hit_; }
-void Player::setScoreBoardPanel(int panel) { scoreboard_panel_ = panel; }
-int Player::getScoreBoardPanel() const { return scoreboard_panel_; }
-int Player::getCoffees() const { return coffees_; }
-Circle &Player::getCollider() { return collider_; }
-int Player::getContinueCounter() const { return continue_counter_; }
-void Player::setName(const std::string &name) { name_ = name; }
-void Player::setRecordName(const std::string &record_name) { record_name_ = record_name.substr(0, 8); }
-std::string Player::getName() const { return name_; }
-std::string Player::getRecordName() const { return record_name_; }
-void Player::setController(int index) { controller_index_ = index; }
-int Player::getController() const { return controller_index_; }
-int Player::getId() const { return id_; }
-bool Player::isRenderable() const { return isPlaying() || isDying() || isCelebrating() || isEnteringNameGameCompleted() || isGameCompleted(); }
-bool Player::IsEligibleForHighScore() { return score_ > options.game.hi_score_table.back().score; }
-bool Player::isCooling() { return firing_state_ == PlayerState::COOLING_LEFT || firing_state_ == PlayerState::COOLING_UP || firing_state_ == PlayerState::COOLING_RIGHT; }
-int Player::getPosX() const { return static_cast<int>(pos_x_); }
-int Player::getPosY() const { return pos_y_; }
-int Player::getWidth() const { return WIDTH_; }
-int Player::getHeight() const { return HEIGHT_; }
-bool Player::canFire() const { return cooldown_ > 0 ? false : true; }
-void Player::setFireCooldown(int time) { cooldown_ = time; }
-void Player::setWalkingState(PlayerState state) { walking_state_ = state; }
-void Player::setFiringState(PlayerState state) { firing_state_ = state; }
-bool Player::isPlaying() const { return playing_state_ == PlayerState::PLAYING; }
-bool Player::isContinue() const { return playing_state_ == PlayerState::CONTINUE; }
-bool Player::isWaiting() const { return playing_state_ == PlayerState::WAITING; }
-bool Player::isEnteringName() const { return playing_state_ == PlayerState::ENTERING_NAME; }
-bool Player::isDying() const { return playing_state_ == PlayerState::DYING; }
-bool Player::hasDied() const { return playing_state_ == PlayerState::DIED; }
-bool Player::isGameOver() const { return playing_state_ == PlayerState::GAME_OVER; }
-bool Player::isEnteringNameGameCompleted() const { return playing_state_ == PlayerState::ENTERING_NAME_GAME_COMPLETED; }
-bool Player::isGameCompleted() const { return playing_state_ == PlayerState::GAME_COMPLETED; }
-bool Player::isCelebrating() const { return playing_state_ == PlayerState::CELEBRATING; }
+}
--- a/source/player.h
+++ b/source/player.h
@@ -8,6 +8,7 @@
 #include <memory>			 // Para unique_ptr, shared_ptr
 #include <string>			 // Para string
 #include <vector>			 // Para vector
+#include "options.h"

 class Texture;				// lines 12-12
 enum class InputType : int; // lines 13-13
@@ -38,7 +39,7 @@ enum class PlayerState
 	GAME_OVER,					  // No está jugando y no puede entrar a jugar
 	CELEBRATING,				  // Poniendo pose de victoria
 	ENTERING_NAME_GAME_COMPLETED, // Poniendo nombre en el tramo final del juego
-	GAME_COMPLETED,				  // Moviendose fuera de la pantalla
+	LEAVING_SCREEN,				  // Moviendose fuera de la pantalla
 };

 // Clase Player
@@ -85,7 +86,6 @@ private:
 	Uint32 continue_ticks_ = 0;								// Variable para poder cambiar el contador de continue en función del tiempo
 	int scoreboard_panel_ = 0;								// Panel del marcador asociado al jugador
 	std::string name_;										// Nombre del jugador
-	std::string record_name_;								// Nombre del jugador para la tabla de mejores puntuaciones
 	int controller_index_ = 0;								// Indice del array de mandos que utilizará para moverse
 	bool demo_;												// Para que el jugador sepa si está en el modo demostración
 	int enter_name_counter_;								// Contador para poner nombre
@@ -109,17 +109,13 @@ private:
 	// Decrementa el contador de entrar nombre
 	void decEnterNameCounter();

-	// Indica si el jugador se puede dibujar
-	bool isRenderable() const;
-
 	// Actualiza el panel del marcador
 	void updateScoreboard();

 	// Cambia el modo del marcador
 	void setScoreboardMode(ScoreboardMode mode);

-	// Se encuentra en alguno de los estados "COOLING"
-	bool isCooling();
+	bool isRenderable() const { return !isWaiting() && !isGameOver(); }

 public:
 	// Constructor
@@ -152,153 +148,91 @@ public:
 	// Mueve el jugador a la posición y animación que le corresponde
 	void move();

-	// Establece el estado del jugador
-	void setWalkingState(PlayerState state);
-
-	// Establece el estado del jugador
-	void setFiringState(PlayerState state);
-
 	// Establece la animación correspondiente al estado
 	void setAnimation();

-	// Obtiene el valor de la variable
-	int getPosX() const;
-
-	// Obtiene el valor de la variable
-	int getPosY() const;
-
-	// Obtiene el valor de la variable
-	int getWidth() const;
-
-	// Obtiene el valor de la variable
-	int getHeight() const;
-
-	// Indica si el jugador puede disparar
-	bool canFire() const;
-
-	// Establece el valor de la variable
-	void setFireCooldown(int time);
-
 	// Actualiza el valor de la variable
 	void updateCooldown();

-	// Obtiene la puntuación del jugador
-	int getScore() const;
-
-	// Asigna un valor a la puntuación del jugador
-	void setScore(int score);
-
 	// Incrementa la puntuación del jugador
 	void addScore(int score);

-	// Indica si el jugador se encuentra en ese estado
-	bool isPlaying() const;
-	bool isContinue() const;
-	bool isWaiting() const;
-	bool isEnteringName() const;
-	bool isDying() const;
-	bool hasDied() const;
-	bool isGameOver() const;
-	bool isEnteringNameGameCompleted() const;
-	bool isGameCompleted() const;
-	bool isCelebrating() const;
-
 	// Establece el estado del jugador en el juego
 	void setPlayingState(PlayerState state);

-	// Obtiene el estado del jugador en el juego
-	PlayerState getPlayingState() const;
-
-	// Obtiene el valor de la variable
-	float getScoreMultiplier() const;
-
-	// Establece el valor de la variable
-	void setScoreMultiplier(float value);
-
 	// Aumenta el valor de la variable hasta un máximo
 	void incScoreMultiplier();

 	// Decrementa el valor de la variable hasta un mínimo
 	void decScoreMultiplier();

-	// Obtiene el valor de la variable
-	bool isInvulnerable() const;
-
 	// Establece el valor del estado
 	void setInvulnerable(bool value);

-	// Obtiene el valor de la variable
-	int getInvulnerableCounter() const;
-
-	// Establece el valor de la variable
-	void setInvulnerableCounter(int value);
-
-	// Obtiene el valor de la variable
-	bool isPowerUp() const;
-
 	// Establece el valor de la variable a verdadero
 	void setPowerUp();

-	// Obtiene el valor de la variable
-	int getPowerUpCounter() const;
-
-	// Establece el valor de la variable
-	void setPowerUpCounter(int value);
-
 	// Actualiza el valor de la variable
 	void updatePowerUp();

-	// Obtiene el valor de la variable
-	bool hasExtraHit() const;
-
 	// Concede un toque extra al jugador
 	void giveExtraHit();

 	// Quita el toque extra al jugador
 	void removeExtraHit();

-	// Devuelve el número de cafes actuales
-	int getCoffees() const;
-
-	// Obtiene el circulo de colisión
-	Circle &getCollider();
-
-	// Obtiene el valor de la variable
-	int getContinueCounter() const;
-
-	// Le asigna un panel en el marcador al jugador
-	void setScoreBoardPanel(int panel);
-
-	// Obtiene el valor de la variable
-	int getScoreBoardPanel() const;
-
 	// Decrementa el contador de continuar
 	void decContinueCounter();

-	// Establece el nombre del jugador
-	void setName(const std::string &name);
-
-	// Establece el nombre del jugador para la tabla de mejores puntuaciones
-	void setRecordName(const std::string &record_name);
-
-	// Obtiene el nombre del jugador
-	std::string getName() const;
-
-	// Obtiene el nombre del jugador para la tabla de mejores puntuaciones
-	std::string getRecordName() const;
-
 	// Obtiene la posición que se está editando del nombre del jugador para la tabla de mejores puntuaciones
 	int getRecordNamePos() const;

-	// Establece el mando que usará para ser controlado
-	void setController(int index);
+	// Comprobación de playing_state
+	bool hasDied() const { return playing_state_ == PlayerState::DIED; }
+	bool isCelebrating() const { return playing_state_ == PlayerState::CELEBRATING; }
+	bool isContinue() const { return playing_state_ == PlayerState::CONTINUE; }
+	bool isDying() const { return playing_state_ == PlayerState::DYING; }
+	bool isEnteringName() const { return playing_state_ == PlayerState::ENTERING_NAME; }
+	bool isEnteringNameGameCompleted() const { return playing_state_ == PlayerState::ENTERING_NAME_GAME_COMPLETED; }
+	bool isLeavingScreen() const { return playing_state_ == PlayerState::LEAVING_SCREEN; }
+	bool isGameOver() const { return playing_state_ == PlayerState::GAME_OVER; }
+	bool isPlaying() const { return playing_state_ == PlayerState::PLAYING; }
+	bool isWaiting() const { return playing_state_ == PlayerState::WAITING; }

-	// Obtiene el mando que usa para ser controlado
-	int getController() const;
+	// Getters
+	bool canFire() const { return cooldown_ > 0 ? false : true; }
+	bool hasExtraHit() const { return extra_hit_; }
+	bool isCooling() { return firing_state_ == PlayerState::COOLING_LEFT || firing_state_ == PlayerState::COOLING_UP || firing_state_ == PlayerState::COOLING_RIGHT; }
+	bool IsEligibleForHighScore() { return score_ > options.game.hi_score_table.back().score; }
+	bool isInvulnerable() const { return invulnerable_; }
+	bool isPowerUp() const { return power_up_; }
+	Circle &getCollider() { return collider_; }
+	float getScoreMultiplier() const { return score_multiplier_; }
+	int getCoffees() const { return coffees_; }
+	int getContinueCounter() const { return continue_counter_; }
+	int getController() const { return controller_index_; }
+	int getHeight() const { return HEIGHT_; }
+	int getId() const { return id_; }
+	int getInvulnerableCounter() const { return invulnerable_counter_; }
+	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(); }
+	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_; }

-	// Obtiene el "id" del jugador
-	int getId() const;
-
-	// Comprueba si la puntuación entra en la tabla de mejores puntuaciones
-	bool IsEligibleForHighScore();
+	// Setters
+	void setController(int index) { controller_index_ = index; }
+	void setFireCooldown(int time) { cooldown_ = time; }
+	void setFiringState(PlayerState state) { firing_state_ = state; }
+	void setInvulnerableCounter(int value) { invulnerable_counter_ = value; }
+	void setName(const std::string &name) { name_ = name; }
+	void setPowerUpCounter(int value) { power_up_counter_ = value; }
+	void setScore(int score) { score_ = score; }
+	void setScoreBoardPanel(int panel) { scoreboard_panel_ = panel; }
+	void setScoreMultiplier(float value) { score_multiplier_ = value; }
+	void setWalkingState(PlayerState state) { walking_state_ = state; }
 };
--- a/source/resource.cpp
+++ b/source/resource.cpp
@@ -2,13 +2,14 @@
 #include <algorithm>    // Para find_if
 #include <iostream>     // Para basic_ostream, operator<<, endl, cout, cerr
 #include <stdexcept>    // Para runtime_error
+#include <utility>      // Para pair
 #include "asset.h"      // Para Asset, AssetType
-#include "lang.h"       // Para lang
 #include "jail_audio.h" // Para JA_LoadMusic, JA_LoadSound
+#include "lang.h"       // Para getText
 #include "screen.h"     // Para Screen
-#include "text.h"       // Para Text
-struct JA_Music_t;
-struct JA_Sound_t;
+#include "text.h"       // Para Text, loadTextFile
+struct JA_Music_t;      // lines 10-10
+struct JA_Sound_t;      // lines 11-11

 // [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
 Resource *Resource::resource_ = nullptr;
@@ -42,6 +43,7 @@ Resource::Resource()
    loadAnimations();
    loadDemoData();
    addPalettes();
+    createText();
    createTextures();
    std::cout << "\n** RESOURCES LOADED" << std::endl;
 }
@@ -106,6 +108,21 @@ std::shared_ptr<TextFile> Resource::getTextFile(const std::string &name)
    throw std::runtime_error("TextFile no encontrado: " + name);
 }

+// Obtiene el objeto de texto a partir de un nombre
+std::shared_ptr<Text> Resource::getText(const std::string &name)
+{
+    auto it = std::find_if(texts_.begin(), texts_.end(), [&name](const auto &t)
+                           { return t.name == name; });
+
+    if (it != texts_.end())
+    {
+        return it->text;
+    }
+
+    std::cerr << "Error: Text no encontrado " << name << std::endl;
+    throw std::runtime_error("Text no encontrado: " + name);
+}
+
 // Obtiene la animación a partir de un nombre
 AnimationsFileBuffer &Resource::getAnimation(const std::string &name)
 {
@@ -239,7 +256,6 @@ void Resource::createTextures()
    };

    std::cout << "\n>> CREATING TEXTURES" << std::endl;
-    auto text = std::make_unique<Text>(getTexture("04b_25.png"), getTextFile("04b_25.txt"));

    // Tamaño normal
    std::vector<NameAndText> strings = {
@@ -251,6 +267,7 @@ void Resource::createTextures()
        NameAndText("game_text_stop", lang::getText(119)),
        NameAndText("1000000_points", lang::getText(76))};

+    auto text = getText("04b_25");
    for (const auto &s : strings)
    {
        textures_.emplace_back(ResourceTexture(s.name, text->writeToTexture(s.text, 1, -2)));
@@ -264,9 +281,29 @@ void Resource::createTextures()
        NameAndText("congratulations", lang::getText(50)),
        NameAndText("game_over", "Game Over")};

+    auto text2 = getText("04b_25_2x");
    for (const auto &s : strings2X)
    {
-        textures_.emplace_back(ResourceTexture(s.name, text->writeToTexture(s.text, 2, -2)));
+        textures_.emplace_back(ResourceTexture(s.name, text2->writeToTexture(s.text, 1, -4)));
        printWithDots("Texture : ", s.name, "[  DONE  ]");
    }
 }
+
+// Crea los objetos de texto
+void Resource::createText()
+{
+    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"}};
+
+    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  ]");
+    }
+}
--- a/source/resource.h
+++ b/source/resource.h
@@ -54,6 +54,17 @@ struct ResourceTextFile
        : name(name), text_file(text_file) {}
 };

+// Estructura para almacenar objetos Text y su nombre
+struct ResourceText
+{
+    std::string name;           // Nombre del objeto
+    std::shared_ptr<Text> text; // Objeto
+
+    // Constructor
+    ResourceText(const std::string &name, std::shared_ptr<Text> text)
+        : name(name), text(text) {}
+};
+
 // Estructura para almacenar ficheros animaciones y su nombre
 struct ResourceAnimation
 {
@@ -75,6 +86,7 @@ private:
    std::vector<ResourceMusic> musics_;         // Vector con las musicas
    std::vector<ResourceTexture> textures_;     // Vector con las musicas
    std::vector<ResourceTextFile> text_files_;  // Vector con los ficheros de texto
+    std::vector<ResourceText> texts_;           // Vector con los objetos de texto
    std::vector<ResourceAnimation> animations_; // Vector con las animaciones
    std::vector<DemoData> demos_;               // Vector con los ficheros de datos para el modo demostración

@@ -102,6 +114,9 @@ private:
    // Crea texturas
    void createTextures();

+    // Crea los objetos de texto
+    void createText();
+
    // [SINGLETON] Ahora el constructor y el destructor son privados, para no poder crear objetos resource desde fuera

    // Constructor
@@ -132,6 +147,9 @@ public:
    // Obtiene el fichero de texto a partir de un nombre
    std::shared_ptr<TextFile> getTextFile(const std::string &name);

+    // Obtiene el objeto de texto a partir de un nombre
+    std::shared_ptr<Text> getText(const std::string &name);
+
    // Obtiene la animación a partir de un nombre
    AnimationsFileBuffer &getAnimation(const std::string &name);

--- a/source/scoreboard.cpp
+++ b/source/scoreboard.cpp
@@ -10,6 +10,7 @@
 #include "screen.h"				// Para Screen
 #include "sprite.h"				// Para Sprite
 #include "text.h"				// Para Text
+#include "enter_name.h"

 // [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
 Scoreboard *Scoreboard::scoreboard_ = nullptr;
@@ -37,7 +38,7 @@ Scoreboard::Scoreboard()
 	: renderer_(Screen::get()->getRenderer()),
 	  game_power_meter_texture_(Resource::get()->getTexture("game_power_meter.png")),
 	  power_meter_sprite_(std::make_unique<Sprite>(game_power_meter_texture_)),
-	  text_scoreboard_(std::make_unique<Text>(Resource::get()->getTexture("8bithud.png"), Resource::get()->getTextFile("8bithud.txt")))
+	  text_scoreboard_(Resource::get()->getText("8bithud"))
 {
 	// Inicializa variables
 	for (int i = 0; i < SCOREBOARD_MAX_PANELS; ++i)
@@ -118,17 +119,6 @@ void Scoreboard::render()
 	SDL_RenderCopy(renderer_, background_, nullptr, &rect_);
 }

-void Scoreboard::setName(int panel, const std::string &name) { name_[panel] = name; }
-void Scoreboard::setRecordName(int panel, const std::string &record_name) { record_name_[panel] = record_name; }
-void Scoreboard::setSelectorPos(int panel, int pos) { selector_pos_[panel] = pos; }
-void Scoreboard::setScore(int panel, int score) { score_[panel] = score; }
-void Scoreboard::setMult(int panel, float mult) { mult_[panel] = mult; }
-void Scoreboard::setContinue(int panel, int continue_counter) { continue_counter_[panel] = continue_counter; }
-void Scoreboard::setStage(int stage) { stage_ = stage; }
-void Scoreboard::setHiScore(int hi_score) { hi_score_ = hi_score; }
-void Scoreboard::setPower(float power) { power_ = power; }
-void Scoreboard::setHiScoreName(const std::string &name) { hi_score_name_ = name; }
-
 // Establece el valor de la variable
 void Scoreboard::setColor(Color color)
 {
@@ -180,7 +170,7 @@ void Scoreboard::fillPanelTextures()

 			// MULT
 			text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y, lang::getText(55));
-			text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y, std::to_string(mult_[i]).substr(0, 3));
+			text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y, "x" + std::to_string(mult_[i]).substr(0, 3));
 			break;
 		}

@@ -239,7 +229,8 @@ void Scoreboard::fillPanelTextures()

 			// HI-SCORE
 			text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y, lang::getText(56));
-			text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y, hi_score_name_ + " - " + updateScoreText(hi_score_));
+			const std::string name = hi_score_name_ == "" ? "" : hi_score_name_ + " - ";
+			text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y, name + updateScoreText(hi_score_));
 			break;
 		}

@@ -267,21 +258,6 @@ void Scoreboard::fillPanelTextures()
 			SDL_SetRenderDrawColor(renderer_, 0xFF, 0xFF, 0xEB, 255);
 			for (size_t j = 0; j < record_name_[i].size(); ++j)
 			{
-				/*
-				if (j == selector_pos_[i])
-				{ // La letra seleccionada se pinta de forma intermitente
-					if (counter_ % 3 > 0)
-					{
-						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));
-					}
-				}
-				else
-				{
-					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));
-				}
-				*/
 				if (j != selector_pos_[i] || counter_ % 3 == 0)
 				{
 					SDL_RenderDrawLine(renderer_, rect.x, rect.y + rect.h, rect.x + rect.w, rect.y + rect.h);
@@ -372,7 +348,7 @@ void Scoreboard::recalculateAnchors()
 	slot4_4_ = {col, row4};

 	// Primer cuadrado para poner el nombre de record
-	const int enterNameLenght = 8 * 7;
+	const int enterNameLenght = NAME_LENGHT * 7;
 	enter_name_pos_.x = (panelWidth - enterNameLenght) / 2;
 	enter_name_pos_.y = row4;

@@ -384,9 +360,6 @@ void Scoreboard::recalculateAnchors()
 	}
 }

-// Establece el modo del marcador
-void Scoreboard::setMode(int index, ScoreboardMode mode) { panel_[index].mode = mode; }
-
 // Crea la textura de fondo
 void Scoreboard::createBackgroundTexture()
 {
--- a/source/scoreboard.h
+++ b/source/scoreboard.h
@@ -52,7 +52,7 @@ private:

 	std::shared_ptr<Texture> game_power_meter_texture_; // Textura con el marcador de poder de la fase
 	std::unique_ptr<Sprite> power_meter_sprite_;		// Sprite para el medidor de poder de la fase
-	std::unique_ptr<Text> text_scoreboard_;				// Fuente para el marcador del juego
+	std::shared_ptr<Text> text_scoreboard_;				// Fuente para el marcador del juego

 	SDL_Texture *background_ = nullptr;		   // Textura para dibujar el marcador
 	std::vector<SDL_Texture *> panel_texture_; // Texturas para dibujar cada panel
@@ -126,42 +126,21 @@ public:
 	// Pinta el marcador
 	void render();

-	// Establece el valor de la variable
-	void setName(int panel, const std::string &name);
-
-	// Establece el valor de la variable
-	void setRecordName(int panel, const std::string &record_name);
-
-	// Establece el valor de la variable
-	void setSelectorPos(int panel, int pos);
-
-	// Establece el valor de la variable
-	void setScore(int panel, int score);
-
-	// Establece el valor de la variable
-	void setMult(int panel, float mult);
-
-	// Establece el valor de la variable
-	void setContinue(int panel, int score);
-
-	// Establece el valor de la variable
-	void setStage(int stage);
-
-	// Establece el valor de la variable
-	void setHiScore(int hi_score);
-
-	// Establece el valor de la variable
-	void setPower(float power);
-
-	// Establece el valor de la variable
-	void setHiScoreName(const std::string &name);
-
 	// Establece el valor de la variable
 	void setColor(Color color);

 	// Establece el valor de la variable
 	void setPos(SDL_Rect rect);

-	// Establece el modo del marcador
-	void setMode(int index, ScoreboardMode mode);
+	void setContinue(int panel, int continue_counter) { continue_counter_[panel] = continue_counter; }
+	void setHiScore(int hi_score) { hi_score_ = hi_score; }
+	void setHiScoreName(const std::string &name) { hi_score_name_ = name; }
+	void setMode(int index, ScoreboardMode mode) { panel_[index].mode = mode; }
+	void setMult(int panel, float mult) { mult_[panel] = mult; }
+	void setName(int panel, const std::string &name) { name_[panel] = name; }
+	void setPower(float power) { power_ = power; }
+	void setRecordName(int panel, const std::string &record_name) { record_name_[panel] = record_name; }
+	void setScore(int panel, int score) { score_[panel] = score; }
+	void setSelectorPos(int panel, int pos) { selector_pos_[panel] = pos; }
+	void setStage(int stage) { stage_ = stage; }
 };
--- a/source/stage.cpp
+++ b/source/stage.cpp
@@ -0,0 +1,40 @@
+#include "stage.h"
+#include <vector>
+
+namespace Stage
+{
+
+    std::vector<Stage> stages; // Variable con los datos de cada pantalla
+    int power = 0;             // Poder acumulado en la fase
+    int total_power = 0;       // Poder total necesario para completar el juego
+    int number = 0;            // Fase actual
+
+    // Devuelve una fase
+    Stage get(int index) { return stages.at(std::min(9, index)); }
+
+    // Inicializa las variables del namespace Stage
+    void init()
+    {
+        stages.emplace_back(Stage(200, 7 + (4 * 1), 7 + (4 * 3)));
+        stages.emplace_back(Stage(300, 7 + (4 * 2), 7 + (4 * 4)));
+        stages.emplace_back(Stage(600, 7 + (4 * 3), 7 + (4 * 5)));
+        stages.emplace_back(Stage(600, 7 + (4 * 3), 7 + (4 * 5)));
+        stages.emplace_back(Stage(600, 7 + (4 * 4), 7 + (4 * 6)));
+        stages.emplace_back(Stage(600, 7 + (4 * 4), 7 + (4 * 6)));
+        stages.emplace_back(Stage(650, 7 + (4 * 5), 7 + (4 * 7)));
+        stages.emplace_back(Stage(750, 7 + (4 * 5), 7 + (4 * 7)));
+        stages.emplace_back(Stage(850, 7 + (4 * 6), 7 + (4 * 8)));
+        stages.emplace_back(Stage(950, 7 + (4 * 7), 7 + (4 * 10)));
+
+        power = 0;
+        total_power = 0;
+        number = 0;
+    }
+
+    // Añade poder
+    void addPower(int amount)
+    {
+        power += amount;
+        total_power += amount;
+    }
+}
--- a/source/stage.h
+++ b/source/stage.h
@@ -0,0 +1,31 @@
+#pragma once
+
+#include <vector>
+
+namespace Stage
+{
+    struct Stage
+    {
+        int power_to_complete; // Cantidad de poder que se necesita para completar la fase
+        int min_menace;        // Umbral mínimo de amenaza de la fase
+        int max_menace;        // Umbral máximo de amenaza de la fase
+
+        // Constructor
+        Stage(int power_to_complete, int min_menace, int max_menace)
+            : power_to_complete(power_to_complete), min_menace(min_menace), max_menace(max_menace) {}
+    };
+
+    extern std::vector<Stage> stages; // Variable con los datos de cada pantalla
+    extern int power;                 // Poder acumulado en la fase
+    extern int total_power;           // Poder total necesario para completar el juego
+    extern int number;                // Fase actual
+
+    // Devuelve una fase
+    Stage get(int index);
+
+    // Inicializa las variables del namespace Stage
+    void init();
+
+    // Añade poder
+    void addPower(int amount);
+}
--- a/source/text.cpp
+++ b/source/text.cpp
@@ -164,6 +164,8 @@ std::shared_ptr<Texture> Text::writeToTexture(const std::string &text, int zoom,
 	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);
 	zoom == 1 ? write(0, 0, text, kerning) : write2X(0, 0, text, kerning);

 	return texture;
--- a/source/title.cpp
+++ b/source/title.cpp
@@ -5,7 +5,6 @@
 #include <SDL2/SDL_timer.h>	  // Para SDL_GetTicks
 #include <stddef.h>			  // Para size_t
 #include <string>			  // Para char_traits, operator+, basic_string
-#include <utility>			  // Para move
 #include <vector>			  // Para vector
 #include "define_buttons.h"	  // Para DefineButtons
 #include "fade.h"			  // Para Fade, FadeType
@@ -21,21 +20,20 @@
 #include "screen.h"			  // Para Screen
 #include "section.h"		  // Para Options, options, Name, name, AttractMode
 #include "sprite.h"			  // Para Sprite
-#include "text.h"			  // Para Text, TEXT_CENTER, TEXT_SHADOW
+#include "text.h"			  // Para TEXT_CENTER, TEXT_SHADOW, Text
 #include "texture.h"		  // Para Texture
 #include "tiled_bg.h"		  // Para TiledBG, TiledBGMode
 #include "utils.h"			  // Para Color, Zone, fade_color, no_color, BLOCK

 // Constructor
 Title::Title()
-	: text1_(std::make_unique<Text>(Resource::get()->getTexture("smb2.gif"), Resource::get()->getTextFile("smb2.txt"))),
-	  text2_(std::make_unique<Text>(Resource::get()->getTexture("8bithud.png"), Resource::get()->getTextFile("8bithud.txt"))),
+	: text_(Resource::get()->getText("smb2")),
 	  fade_(std::make_unique<Fade>()),
 	  tiled_bg_(std::make_unique<TiledBG>((SDL_Rect){0, 0, param.game.width, param.game.height}, TiledBGMode::RANDOM)),
 	  game_logo_(std::make_unique<GameLogo>(param.game.game_area.center_x, param.title.title_c_c_position)),
 	  mini_logo_texture_(Resource::get()->getTexture("logo_jailgames_mini.png")),
 	  mini_logo_sprite_(std::make_unique<Sprite>(mini_logo_texture_, param.game.game_area.center_x - mini_logo_texture_->getWidth() / 2, 0, mini_logo_texture_->getWidth(), mini_logo_texture_->getHeight())),
-	  define_buttons_(std::make_unique<DefineButtons>(std::move(text2_))),
+	  define_buttons_(std::make_unique<DefineButtons>()),
 	  num_controllers_(Input::get()->getNumControllers())
 {
 	// Configura objetos
@@ -146,7 +144,7 @@ void Title::render()
 		// 'PRESS TO PLAY'
 		if (counter_ % 50 > 14 && !define_buttons_->isEnabled())
 		{
-			text1_->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, param.title.press_start_position, lang::getText(23), 1, no_color, 1, shadow);
+			text_->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, param.title.press_start_position, lang::getText(23), 1, no_color, 1, shadow);
 		}

 		// Mini logo
@@ -156,7 +154,7 @@ void Title::render()
 		mini_logo_sprite_->render();

 		// Texto con el copyright
-		text1_->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, pos2, TEXT_COPYRIGHT, 1, no_color, 1, shadow);
+		text_->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, pos2, TEXT_COPYRIGHT, 1, no_color, 1, shadow);
 	}

 	// Define Buttons
--- a/source/title.h
+++ b/source/title.h
@@ -40,8 +40,7 @@ class Title
 {
 private:
 	// Objetos y punteros
-	std::unique_ptr<Text> text1_;					// Objeto de texto para poder escribir textos en pantalla
-	std::unique_ptr<Text> text2_;					// Objeto de texto para poder escribir textos en pantalla
+	std::shared_ptr<Text> text_;					// Objeto de texto para poder escribir textos en pantalla
 	std::unique_ptr<Fade> fade_;					// Objeto para realizar fundidos en pantalla
 	std::unique_ptr<TiledBG> tiled_bg_;				// Objeto para dibujar el mosaico animado de fondo
 	std::unique_ptr<GameLogo> game_logo_;			// Objeto para dibujar el logo con el título del juego
Author	SHA1	Message	Date
Sergio Valor	8941072357	Els items reboten al tocar el piso	2024-11-20 21:55:55 +01:00
Sergio Valor	77bf1d73b3	Afegits els grafics de caure derrotat per al segon jugador	2024-11-19 19:30:30 +01:00
Sergio Valor	700d3846fb	Afegits rebots en la animació de morir	2024-11-19 18:59:35 +01:00
Sergio Valor	185a1b47d1	Afegida llengua fora i ulls en X a la animació de derrotat	2024-11-19 18:59:22 +01:00
Sergio Valor	121774e460	Nova animació de jugador derrotat	2024-11-19 18:33:52 +01:00
Sergio Valor	47e468034f	Nova animació per a la mort del personatge Nova lògica al morir	2024-11-17 08:43:24 +01:00
Sergio Valor	da74b8dfce	La powerball ja no mata La powerball no pillava la rotació si es creava amb el rellotge actiu	2024-11-16 12:45:58 +01:00
Sergio Valor	065336c310	Els globos fills ja no ixen centrats al pare, si no al final havia varios apilats	2024-11-16 12:24:20 +01:00
Sergio Valor	79d25fb812	Nous grafics per a la powerball Nou comportament per a la powerball	2024-11-16 12:13:00 +01:00
Sergio Valor	6262b5814d	Arreglos varios relacionats amb el nom al obtenir la màxima puntuació: No canviava al marcador, ni el nom del que tenia la maxima puntuació en calent ni al posar nom retallat el nom de 8 a 6 caracters, i tots en majuscula pa que capia en el marcador ja actualitza be la cadena amb el nom al posar nom per segona vegada en la mateixa partida	2024-11-08 20:49:07 +01:00
Sergio Valor	f9520185a2	Acabat BalloonManager	2024-11-08 18:29:08 +01:00
Sergio Valor	2fb7e88e4b	Continue amb BalloonManager	2024-11-07 20:56:56 +01:00
Sergio Valor	0e527ff9d9	Au, a dormir que tinc son	2024-11-06 22:22:35 +01:00
Sergio Valor Martínez	d902bb9088	canvi de pc	2024-11-06 17:22:16 +01:00
Sergio Valor	caf04e3a7e	Treballant en BalloonManager	2024-11-05 22:06:15 +01:00
Sergio Valor Martínez	12213a3dab	Toooooornem a commitaaaar, aci vinga jugar al ping pong entre windows i macos i el puto copilot. Apanye aci i trenque allà	2024-11-05 17:54:23 +01:00
Sergio Valor	1f2a8ae38d	Canvis en CMakeLists.txt	2024-11-05 17:38:26 +01:00
Sergio Valor Martínez	aa8d3502e2	Actualitzat make i cmake	2024-11-05 16:51:41 +01:00
Sergio Valor	e445a0b218	CMakeLists.txt crea el executable en la arrel del projecte	2024-11-05 13:13:43 +01:00
Sergio Valor	3f9c4b887f	Apareixia brossa en la textura al crear un text i no netejarla primer (en el windows de la faena)	2024-11-05 13:06:32 +01:00
Sergio Valor	27ccae6132	Refet CMakeLists.txt	2024-11-05 13:05:52 +01:00
Sergio Valor Martínez	443f0f3254	Añadido CMakeLists.txt	2024-11-05 07:15:54 +01:00
Sergio Valor Martínez	2e62214a4b	Canviat un #include <bits/chrono.h> per #include <chrono>	2024-11-04 22:26:31 +01:00
Sergio Valor	7b1c2a6005	Nova font de text per al text gran amb el doble de definició	2024-11-04 20:28:19 +01:00
Sergio Valor	2256ee46eb	Modificada la paleta verda del primer jugador per a fer la mes pareguda a la del coffee crisis original	2024-11-04 19:39:27 +01:00
Sergio Valor	087fd3377c	fix: els globos verds, al popparlos, uno tirava cap avall el molt cabró	2024-11-04 19:16:44 +01:00
Sergio Valor	30735f00e8	Els objectes de Text es precarreguen al inici	2024-11-04 19:08:18 +01:00