el fitxer de parametres es guarda en options/config.txt

creat param_red.txt
afegides guardes en setParams
2025-08-17 21:42:26 +02:00 · 2025-08-17 21:29:49 +02:00 · 2025-08-17 20:42:55 +02:00 · 2025-08-17 20:22:53 +02:00 · 2025-08-17 20:17:55 +02:00 · 2025-08-17 19:34:48 +02:00
34 changed files with 1285 additions and 429 deletions
--- a/.clang-format
+++ b/.clang-format
@@ -6,7 +6,14 @@ BreakBeforeBraces: Attach  # Llaves en la misma línea
 AllowShortIfStatementsOnASingleLine: true
 AllowShortBlocksOnASingleLine: true
 AllowShortFunctionsOnASingleLine: All
-AlignOperands: false
+AlignOperands: DontAlign
 AlignAfterOpenBracket: DontAlign
 BinPackArguments: false
 BinPackParameters: false
+ContinuationIndentWidth: 4
+ConstructorInitializerIndentWidth: 4
+IndentWrappedFunctionNames: false
+Cpp11BracedListStyle: true
+BreakConstructorInitializers: BeforeComma
+AllowAllArgumentsOnNextLine: false
+AllowAllParametersOfDeclarationOnNextLine: false
--- a/data/config/assets.txt
+++ b/data/config/assets.txt
@@ -13,6 +13,7 @@ DATA|${PREFIX}/data/config/formations.txt
 DATA|${PREFIX}/data/config/gamecontrollerdb.txt
 DATA|${PREFIX}/data/config/param_320x240.txt
 DATA|${PREFIX}/data/config/param_320x256.txt
+DATA|${PREFIX}/data/config/param_red.txt
 DATA|${PREFIX}/data/config/pools.txt
 DATA|${PREFIX}/data/config/stages.txt
 DEMODATA|${PREFIX}/data/config/demo1.bin
@@ -56,12 +57,12 @@ SOUND|${PREFIX}/data/sound/tabe_hit.wav
 SOUND|${PREFIX}/data/sound/tabe.wav
 SOUND|${PREFIX}/data/sound/title.wav
 SOUND|${PREFIX}/data/sound/voice_aw_aw_aw.wav
-SOUND|${PREFIX}/data/sound/voice_brbrbr.wav
 SOUND|${PREFIX}/data/sound/voice_coffee.wav
 SOUND|${PREFIX}/data/sound/voice_credit_thankyou.wav
 SOUND|${PREFIX}/data/sound/voice_get_ready.wav
 SOUND|${PREFIX}/data/sound/voice_no.wav
 SOUND|${PREFIX}/data/sound/voice_power_up.wav
+SOUND|${PREFIX}/data/sound/voice_recover.wav
 SOUND|${PREFIX}/data/sound/voice_thankyou.wav
 SOUND|${PREFIX}/data/sound/walk.wav

@@ -177,6 +178,7 @@ BITMAP|${PREFIX}/data/font/04b_25_grey.png
 BITMAP|${PREFIX}/data/font/04b_25_metal.png
 BITMAP|${PREFIX}/data/font/04b_25_reversed_2x.png
 BITMAP|${PREFIX}/data/font/04b_25_reversed.png
+BITMAP|${PREFIX}/data/font/04b_25_white.png
 BITMAP|${PREFIX}/data/font/04b_25.png
 BITMAP|${PREFIX}/data/font/8bithud.png
 BITMAP|${PREFIX}/data/font/aseprite.png
--- a/data/config/param_320x240.txt
+++ b/data/config/param_320x240.txt
@@ -2,26 +2,26 @@
 # Formato: PARAMETRO VALOR

 # --- GAME ---
-game.item_size                 20   # Tamaño de los items del juego (en píxeles)
-game.width                    320   # Ancho de la resolución nativa del juego (en píxeles)
-game.height                   240   # Alto de la resolución nativa del juego (en píxeles)
-game.play_area.rect.x           0   # Posición X de la zona jugable
-game.play_area.rect.y           0   # Posición Y de la zona jugable
-game.play_area.rect.w         320   # Ancho de la zona jugable
-game.play_area.rect.h         200   # Alto de la zona jugable
-game.name_entry_idle_time      10   # Segundos para introducir el nombre al finalizar la partida si no se pulsa nada
-game.name_entry_total_time     60   # Segundos totales para introducir el nombre al finalizar la partida
-game.hit_stop               false   # Indica si debe haber un paro cuando el jugador es golpeado por un globo
-game.hit_stop_ms              500   # Cantidad de milisegundos que dura el hit_stop
+game.item_size                      20   # Tamaño de los items del juego (en píxeles)
+game.item_text_outline_color  E0E0E0F0   # Color del outline del texto de los items (RGBA hex)
+game.width                         320   # Ancho de la resolución nativa del juego (en píxeles)
+game.height                        240   # Alto de la resolución nativa del juego (en píxeles)
+game.play_area.rect.x                0   # Posición X de la zona jugable
+game.play_area.rect.y                0   # Posición Y de la zona jugable
+game.play_area.rect.w              320   # Ancho de la zona jugable
+game.play_area.rect.h              200   # Alto de la zona jugable
+game.name_entry_idle_time           10   # Segundos para introducir el nombre al finalizar la partida si no se pulsa nada
+game.name_entry_total_time          60   # Segundos totales para introducir el nombre al finalizar la partida
+game.hit_stop                    false   # Indica si debe haber un paro cuando el jugador es golpeado por un globo
+game.hit_stop_ms                   500   # Cantidad de milisegundos que dura el hit_stop

 # --- FADE ---
-fade.color                 1F2B30   # Color hexadecimal para el efecto de fundido
-fade.num_squares_width        160   # Número de cuadrados en el eje X para el fundido
-fade.num_squares_height       120   # Número de cuadrados en el eje Y para el fundido
-fade.random_squares_delay       1   # Delay entre aparición de cuadrados aleatorios (frames)
-fade.random_squares_mult      500   # Multiplicador para la velocidad de aparición aleatoria
-fade.post_duration             80   # Duración tras el fundido (frames)
-fade.venetian_size             12   # Tamaño de las bandas para el efecto veneciano (en píxeles)
+fade.color                     1F2B30   # Color hexadecimal para el efecto de fundido
+fade.num_squares_width             64   # Número de cuadrados en el eje X para el fundido
+fade.num_squares_height            48   # Número de cuadrados en el eje Y para el fundido
+fade.random_squares_duration_ms  1200   # Duración del fade en milisegundos
+fade.post_duration_ms             500   # Duración tras el fundido en milisegundos
+fade.venetian_size                 12   # Tamaño de las bandas para el efecto veneciano (en píxeles)

 # --- SCOREBOARD ---
 scoreboard.rect.x                     0   # Posición X del marcador
@@ -84,8 +84,8 @@ service_menu.window_message.title_color              6496C8FF   # Color del tít
 service_menu.window_message.text_color               DCDCDCFF   # Color del texto en ventanas de mensaje (RGBA hexadecimal)
 service_menu.window_message.padding                     15.0f   # Espaciado interno de ventanas de mensaje (píxeles)
 service_menu.window_message.line_spacing                 5.0f   # Espaciado entre líneas de texto (píxeles)
-service_menu.window_message.title_separator_spacing     10.0f   # Espaciado entre título y contenido (píxeles)
-service_menu.window_message.min_width                  250.0f   # Ancho mínimo de ventanas de mensaje (píxeles)
+service_menu.window_message.title_separator_spacing     20.0f   # Espaciado entre título y contenido (píxeles)
+service_menu.window_message.min_width                  200.0f   # Ancho mínimo de ventanas de mensaje (píxeles)
 service_menu.window_message.min_height                  32.0f   # Alto mínimo de ventanas de mensaje (píxeles)
 service_menu.window_message.max_width_ratio              0.8f   # Ratio máximo de ancho respecto a pantalla (0.0-1.0)
 service_menu.window_message.max_height_ratio             0.8f   # Ratio máximo de alto respecto a pantalla (0.0-1.0)
@@ -110,6 +110,18 @@ tabe.min_spawn_time  2.0f # Tiempo mínimo en minutos para que aparezca el Tabe
 tabe.max_spawn_time  3.0f # Tiempo máximo en minutos para que aparezca el Tabe

 # --- PLAYER ---
+# Jugador 1 - Camiseta por defecto
+player.default_shirt[0].darkest      028ECFFF   # Tono más oscuro - bordes y contornos (Jugador 1, por defecto)
+player.default_shirt[0].dark         0297DBFF   # Tono oscuro - sombras (Jugador 1, por defecto)
+player.default_shirt[0].base         029FE8FF   # Tono principal - color base (Jugador 1, por defecto)
+player.default_shirt[0].light        03A9F4FF   # Tono claro - zonas iluminadas (Jugador 1, por defecto)
+
+# Jugador 2 - Camiseta por defecto
+player.default_shirt[1].darkest      8E8E8EFF   # Tono más oscuro - bordes y contornos (Jugador 2, por defecto)
+player.default_shirt[1].dark         AEADADFF   # Tono oscuro - sombras (Jugador 2, por defecto)
+player.default_shirt[1].base         E4E4E4FF   # Tono principal - color base (Jugador 2, por defecto)
+player.default_shirt[1].light        F7F1F1FF   # Tono claro - zonas iluminadas (Jugador 2, por defecto)
+
 # Jugador 1 - Camiseta con 1 café
 player.one_coffee_shirt[0].darkest   3D9C70FF   # Tono más oscuro - bordes y contornos (Jugador 1, 1 café)
 player.one_coffee_shirt[0].dark      4FA370FF   # Tono oscuro - sombras (Jugador 1, 1 café)
@@ -132,4 +144,8 @@ player.one_coffee_shirt[1].light     55EF8DFF   # Tono claro - zonas iluminadas
 player.two_coffee_shirt[1].darkest   E08500FF   # Tono más oscuro - bordes y contornos (Jugador 2, 2 cafés)
 player.two_coffee_shirt[1].dark      FA7D00FF   # Tono oscuro - sombras (Jugador 2, 2 cafés)
 player.two_coffee_shirt[1].base      FAA200FF   # Tono principal - color base (Jugador 2, 2 cafés)
-player.two_coffee_shirt[1].light     FA8500FF   # Tono claro - zonas iluminadas (Jugador 2, 2 cafés)
+player.two_coffee_shirt[1].light     FA8500FF   # Tono claro - zonas iluminadas (Jugador 2, 2 cafés)
+
+# Colores de contorno de los jugadores
+player.outline_color[0]              66323FFF   # Color del contorno del sprite del Jugador 1
+player.outline_color[1]              422028FF   # Color del contorno del sprite del Jugador 2
--- a/data/config/param_320x256.txt
+++ b/data/config/param_320x256.txt
@@ -2,26 +2,26 @@
 # Formato: PARAMETRO VALOR

 # --- GAME ---
-game.item_size                 20   # Tamaño de los items del juego (en píxeles)
-game.width                    320   # Ancho de la resolución nativa del juego (en píxeles)
-game.height                   256   # Alto de la resolución nativa del juego (en píxeles)
-game.play_area.rect.x           0   # Posición X de la zona jugable
-game.play_area.rect.y           0   # Posición Y de la zona jugable
-game.play_area.rect.w         320   # Ancho de la zona jugable
-game.play_area.rect.h         216   # Alto de la zona jugable
-game.name_entry_idle_time      10   # Segundos para introducir el nombre al finalizar la partida si no se pulsa nada
-game.name_entry_total_time     60   # Segundos totales para introducir el nombre al finalizar la partida
-game.hit_stop               false   # Indica si debe haber un paro cuando el jugador es golpeado por un globo
-game.hit_stop_ms              500   # Cantidad de milisegundos que dura el hit_stop
+game.item_size                      20   # Tamaño de los items del juego (en píxeles)
+game.item_text_outline_color  E0E0E0F0   # Color del outline del texto de los items (RGBA hex)
+game.width                         320   # Ancho de la resolución nativa del juego (en píxeles)
+game.height                        256   # Alto de la resolución nativa del juego (en píxeles)
+game.play_area.rect.x                0   # Posición X de la zona jugable
+game.play_area.rect.y                0   # Posición Y de la zona jugable
+game.play_area.rect.w              320   # Ancho de la zona jugable
+game.play_area.rect.h              216   # Alto de la zona jugable
+game.name_entry_idle_time           10   # Segundos para introducir el nombre al finalizar la partida si no se pulsa nada
+game.name_entry_total_time          60   # Segundos totales para introducir el nombre al finalizar la partida
+game.hit_stop                    false   # Indica si debe haber un paro cuando el jugador es golpeado por un globo
+game.hit_stop_ms                   500   # Cantidad de milisegundos que dura el hit_stop

 # --- FADE ---
-fade.color                 1F2B30   # Color hexadecimal para el efecto de fundido
-fade.num_squares_width        160   # Número de cuadrados en el eje X para el fundido
-fade.num_squares_height       128   # Número de cuadrados en el eje Y para el fundido
-fade.random_squares_delay       1   # Delay entre aparición de cuadrados aleatorios (frames)
-fade.random_squares_mult      500   # Multiplicador para la velocidad de aparición aleatoria
-fade.post_duration             80   # Duración tras el fundido (frames)
-fade.venetian_size             12   # Tamaño de las bandas para el efecto veneciano (en píxeles)
+fade.color                     1F2B30   # Color hexadecimal para el efecto de fundido
+fade.num_squares_width             64   # Número de cuadrados en el eje X para el fundido
+fade.num_squares_height            48   # Número de cuadrados en el eje Y para el fundido
+fade.random_squares_duration_ms  1200   # Duración del fade en milisegundos
+fade.post_duration_ms             500   # Duración tras el fundido en milisegundos
+fade.venetian_size                 12   # Tamaño de las bandas para el efecto veneciano (en píxeles)

 # --- SCOREBOARD ---
 scoreboard.rect.x                     0   # Posición X del marcador
@@ -109,6 +109,18 @@ tabe.min_spawn_time  2.0f   # Tiempo mínimo en segundos para que aparezca el Ta
 tabe.max_spawn_time  3.0f   # Tiempo máximo en segundos para que aparezca el Tabe

 # --- PLAYER ---
+# Jugador 1 - Camiseta por defecto
+player.default_shirt[0].darkest      028ECFFF   # Tono más oscuro - bordes y contornos (Jugador 1, por defecto)
+player.default_shirt[0].dark         0297DBFF   # Tono oscuro - sombras (Jugador 1, por defecto)
+player.default_shirt[0].base         029FE8FF   # Tono principal - color base (Jugador 1, por defecto)
+player.default_shirt[0].light        03A9F4FF   # Tono claro - zonas iluminadas (Jugador 1, por defecto)
+
+# Jugador 2 - Camiseta por defecto
+player.default_shirt[1].darkest      8E8E8EFF   # Tono más oscuro - bordes y contornos (Jugador 2, por defecto)
+player.default_shirt[1].dark         AEADADFF   # Tono oscuro - sombras (Jugador 2, por defecto)
+player.default_shirt[1].base         E4E4E4FF   # Tono principal - color base (Jugador 2, por defecto)
+player.default_shirt[1].light        F7F1F1FF   # Tono claro - zonas iluminadas (Jugador 2, por defecto)
+
 # Jugador 1 - Camiseta con 1 café
 player.one_coffee_shirt[0].darkest   3D9C70FF   # Tono más oscuro - bordes y contornos (Jugador 1, 1 café)
 player.one_coffee_shirt[0].dark      4FA370FF   # Tono oscuro - sombras (Jugador 1, 1 café)
@@ -131,4 +143,8 @@ player.one_coffee_shirt[1].light     55EF8DFF   # Tono claro - zonas iluminadas
 player.two_coffee_shirt[1].darkest   E08500FF   # Tono más oscuro - bordes y contornos (Jugador 2, 2 cafés)
 player.two_coffee_shirt[1].dark      FA7D00FF   # Tono oscuro - sombras (Jugador 2, 2 cafés)
 player.two_coffee_shirt[1].base      FAA200FF   # Tono principal - color base (Jugador 2, 2 cafés)
-player.two_coffee_shirt[1].light     FA8500FF   # Tono claro - zonas iluminadas (Jugador 2, 2 cafés)
+player.two_coffee_shirt[1].light     FA8500FF   # Tono claro - zonas iluminadas (Jugador 2, 2 cafés)
+
+# Colores de contorno de los jugadores
+player.outline_color[0]              66323FFF   # Color del contorno del sprite del Jugador 1
+player.outline_color[1]              422028FF   # Color del contorno del sprite del Jugador 2
--- a/data/config/param_red.txt
+++ b/data/config/param_red.txt
@@ -0,0 +1,150 @@
+# Coffee Crisis Arcade Edition - Fichero de parametros - RED THEME
+# Formato: PARAMETRO VALOR
+
+# --- GAME ---
+game.item_size                      20   # Tamaño de los items del juego (en píxeles)
+game.item_text_outline_color  FFB8B8F0   # Color del outline del texto de los items (RGBA hex) - Rojo claro
+game.width                         320   # Ancho de la resolución nativa del juego (en píxeles)
+game.height                        256   # Alto de la resolución nativa del juego (en píxeles)
+game.play_area.rect.x                0   # Posición X de la zona jugable
+game.play_area.rect.y                0   # Posición Y de la zona jugable
+game.play_area.rect.w              320   # Ancho de la zona jugable
+game.play_area.rect.h              216   # Alto de la zona jugable
+game.name_entry_idle_time           10   # Segundos para introducir el nombre al finalizar la partida si no se pulsa nada
+game.name_entry_total_time          60   # Segundos totales para introducir el nombre al finalizar la partida
+game.hit_stop                    false   # Indica si debe haber un paro cuando el jugador es golpeado por un globo
+game.hit_stop_ms                   500   # Cantidad de milisegundos que dura el hit_stop
+
+# --- FADE ---
+fade.color                     5C1F1F   # Color hexadecimal para el efecto de fundido - Rojo oscuro
+fade.num_squares_width             64   # Número de cuadrados en el eje X para el fundido
+fade.num_squares_height            48   # Número de cuadrados en el eje Y para el fundido
+fade.random_squares_duration_ms  1200   # Duración del fade en milisegundos
+fade.post_duration_ms             500   # Duración tras el fundido en milisegundos
+fade.venetian_size                 12   # Tamaño de las bandas para el efecto veneciano (en píxeles)
+
+# --- SCOREBOARD ---
+scoreboard.rect.x                     0   # Posición X del marcador
+scoreboard.rect.y                   216   # Posición Y del marcador
+scoreboard.rect.w                   320   # Ancho del marcador
+scoreboard.rect.h                    40   # Alto del marcador
+scoreboard.separator_autocolor     true   # ¿El separador usa color automático?
+scoreboard.separator_color       2B0D0D   # Color del separador - Rojo muy oscuro
+scoreboard.easy_color            8B4A2F   # Color para la dificultad fácil - Marrón rojizo
+scoreboard.normal_color          6B2F2F   # Color para la dificultad normal - Rojo medio
+scoreboard.hard_color            A73030   # Color para la dificultad difícil - Rojo fuerte
+scoreboard.text_autocolor          true   # ¿El texto usa color automático?
+scoreboard.text_color1           FFE6E6   # Color principal del texto del marcador - Blanco rosado
+scoreboard.text_color2           FFE6E6   # Color secundario del texto del marcador - Blanco rosado
+scoreboard.skip_countdown_value       8   # Valor para saltar la cuenta atrás (segundos)
+
+# --- TITLE ---
+title.press_start_position     180   # Posición Y del texto "Press Start"
+title.title_duration           800   # Duración de la pantalla de título (frames)
+title.arcade_edition_position  123   # Posición Y del subtítulo "Arcade Edition"
+title.title_c_c_position        80   # Posición Y del título principal
+title.bg_color              8B4A3A   # Color de fondo en la sección titulo - Marrón rojizo
+
+# --- BACKGROUND ---
+background.attenuate_color  FF4A3A40   # Color de atenuación del fondo (RGBA hexadecimal) - Blanco rosado
+
+# --- BALLOONS ---
+balloon.settings[0].vel   2.75f   # Velocidad inicial del globo 1
+balloon.settings[0].grav  0.09f   # Gravedad aplicada al globo 1
+balloon.settings[1].vel   3.70f   # Velocidad inicial del globo 2
+balloon.settings[1].grav  0.10f   # Gravedad aplicada al globo 2
+balloon.settings[2].vel   4.70f   # Velocidad inicial del globo 3
+balloon.settings[2].grav  0.10f   # Gravedad aplicada al globo 3
+balloon.settings[3].vel   5.45f   # Velocidad inicial del globo 4
+balloon.settings[3].grav  0.10f   # Gravedad aplicada al globo 4
+
+balloon.color[0]  orange    # Color de creación del globo normal
+balloon.color[1]  red       # Color del globo normal
+balloon.color[2]  blue      # Color de creación del globo que rebota
+balloon.color[3]  green     # Color del globo que rebota
+
+balloon.bouncing_sound  false  # Indica si los globos hacer sonido al rebotar
+
+# --- NOTIFICATION ---
+notification.pos_v     TOP   # Posición vertical de la notificación (TOP/BOTTOM)
+notification.pos_h    LEFT   # Posición horizontal de la notificación (LEFT/RIGHT)
+notification.sound   false   # ¿La notificación reproduce sonido?
+notification.color  4D1A1A   # Color de fondo de la notificación - Rojo oscuro
+
+# --- SERVICE MENU ---
+service_menu.title_color       FF9966   # Color del título del menú de servicio - Naranja claro
+service_menu.text_color        FFE6E6   # Color del texto del menú de servicio - Blanco rosado
+service_menu.selected_color    FFB366   # Color de la opción seleccionada - Naranja dorado
+service_menu.bg_color        331A0AF5   # Color de fondo del menú de servicio - Marrón rojizo oscuro con alpha
+service_menu.drop_shadow        false   # ¿El menú de servicio tiene sombra?
+
+service_menu.window_message.bg_color                 4D1A1AF0   # Color de fondo de ventanas - Rojo oscuro con alpha
+service_menu.window_message.border_color             CC6633FF   # Color del borde de ventanas - Naranja rojizo
+service_menu.window_message.title_color              CC6633FF   # Color del título en ventanas - Naranja rojizo
+service_menu.window_message.text_color               FFE6E6FF   # Color del texto en ventanas - Blanco rosado
+service_menu.window_message.padding                     15.0f   # Espaciado interno de ventanas de mensaje (píxeles)
+service_menu.window_message.line_spacing                 5.0f   # Espaciado entre líneas de texto (píxeles)
+service_menu.window_message.title_separator_spacing     20.0f   # Espaciado entre título y contenido (píxeles)
+service_menu.window_message.min_width                  200.0f   # Ancho mínimo de ventanas de mensaje (píxeles)
+service_menu.window_message.min_height                  32.0f   # Alto mínimo de ventanas de mensaje (píxeles)
+service_menu.window_message.max_width_ratio              0.8f   # Ratio máximo de ancho respecto a pantalla (0.0-1.0)
+service_menu.window_message.max_height_ratio             0.8f   # Ratio máximo de alto respecto a pantalla (0.0-1.0)
+service_menu.window_message.text_safety_margin          15.0f   # Margen de seguridad para el texto (píxeles)
+service_menu.window_message.animation_duration           0.3f   # Duración de animaciones de ventanas (segundos)
+
+# --- INTRO ---
+intro.bg_color                     B8664D   # Color de fondo de la intro - Naranja tierra
+intro.card_color                   FFE6CC   # Color de las tarjetas en la intro - Crema rojizo
+intro.shadow_color               66000080   # Color de la sombra de las tarjetas - Rojo muy oscuro con alpha
+intro.text_distance_from_bottom        48   # Posición del texto desde la parte inferior
+
+# --- DEBUG ---
+debug.color  FF6666   # Color para elementos de depuración - Rojo claro
+
+# --- RESOURCE ---
+resource.color  FFE6E6   # Color de recursos - Blanco rosado
+
+# --- TABE ---
+tabe.min_spawn_time  2.0f   # Tiempo mínimo en segundos para que aparezca el Tabe
+tabe.max_spawn_time  3.0f   # Tiempo máximo en segundos para que aparezca el Tabe
+
+# --- PLAYER ---
+# Jugador 1 - Camiseta por defecto (tonos rojos)
+player.default_shirt[0].darkest      B33030FF   # Tono más oscuro - Rojo fuerte
+player.default_shirt[0].dark         CC4040FF   # Tono oscuro - Rojo medio
+player.default_shirt[0].base         E65050FF   # Tono principal - Rojo claro
+player.default_shirt[0].light        FF6666FF   # Tono claro - Rojo muy claro
+
+# Jugador 2 - Camiseta por defecto (tonos naranjas)
+player.default_shirt[1].darkest      B36030FF   # Tono más oscuro - Naranja oscuro
+player.default_shirt[1].dark         CC7540FF   # Tono oscuro - Naranja medio
+player.default_shirt[1].base         E68A50FF   # Tono principal - Naranja claro
+player.default_shirt[1].light        FF9966FF   # Tono claro - Naranja muy claro
+
+# Jugador 1 - Camiseta con 1 café (tonos rojizos más intensos)
+player.one_coffee_shirt[0].darkest   8B2635FF   # Tono más oscuro - Rojo granate
+player.one_coffee_shirt[0].dark      A53040FF   # Tono oscuro - Rojo granate claro
+player.one_coffee_shirt[0].base      BF3A50FF   # Tono principal - Rojo vibrante
+player.one_coffee_shirt[0].light     D94460FF   # Tono claro - Rojo vibrante claro
+
+# Jugador 1 - Camiseta con 2 cafés (tonos naranja dorado)
+player.two_coffee_shirt[0].darkest   CC6600FF   # Tono más oscuro - Naranja dorado oscuro
+player.two_coffee_shirt[0].dark      E6750AFF   # Tono oscuro - Naranja dorado
+player.two_coffee_shirt[0].base      FF8514FF   # Tono principal - Naranja dorado claro
+player.two_coffee_shirt[0].light     FF991EFF   # Tono claro - Naranja dorado muy claro
+
+# Jugador 2 - Camiseta con 1 café (tonos terracotas)
+player.one_coffee_shirt[1].darkest   A0472DFF   # Tono más oscuro - Terracota oscuro
+player.one_coffee_shirt[1].dark      B8553AFF   # Tono oscuro - Terracota medio
+player.one_coffee_shirt[1].base      D06347FF   # Tono principal - Terracota claro
+player.one_coffee_shirt[1].light     E87154FF   # Tono claro - Terracota muy claro
+
+# Jugador 2 - Camiseta con 2 cafés (tonos naranjas cálidos)
+player.two_coffee_shirt[1].darkest   CC5500FF   # Tono más oscuro - Naranja intenso
+player.two_coffee_shirt[1].dark      E66600FF   # Tono oscuro - Naranja fuerte
+player.two_coffee_shirt[1].base      FF7700FF   # Tono principal - Naranja brillante
+player.two_coffee_shirt[1].light     FF8800FF   # Tono claro - Naranja muy brillante
+
+# Colores de contorno de los jugadores
+player.outline_color[0]              994D33FF   # Color del contorno del Jugador 1 - Marrón rojizo
+player.outline_color[1]              664433FF   # Color del contorno del Jugador 2 - Marrón tierra
--- a/data/font/04b_25_white.png
+++ b/data/font/04b_25_white.png
--- a/data/sound/voice_brbrbr.wav
+++ b/data/sound/voice_brbrbr.wav
--- a/data/sound/voice_recover.wav
+++ b/data/sound/voice_recover.wav
--- a/source/balloon_manager.cpp
+++ b/source/balloon_manager.cpp
@@ -17,9 +17,7 @@

 // Constructor
 BalloonManager::BalloonManager(IStageInfo *stage_info)
-    : explosions_(std::make_unique<Explosions>()),
-      balloon_formations_(std::make_unique<BalloonFormations>()),
-      stage_info_(stage_info) { init(); }
+    : explosions_(std::make_unique<Explosions>()), balloon_formations_(std::make_unique<BalloonFormations>()), stage_info_(stage_info) { init(); }

 // Inicializa
 void BalloonManager::init() {
@@ -291,7 +289,7 @@ auto BalloonManager::destroyAllBalloons() -> int {
    }

    balloon_deploy_counter_ = 300;
-    Screen::get()->flash(FLASH_COLOR, 3);
+    Screen::get()->flash(Colors::FLASH, 3);
    Screen::get()->shake();

    return score;
--- a/source/color.cpp
+++ b/source/color.cpp
@@ -42,22 +42,8 @@ auto Color::fromHex(const std::string &hex_str) -> Color {
    return Color(r, g, b, a);
 }

-// Obtiene un color del vector de colores imitando al Coche Fantástico
-auto getColorLikeKnightRider(const std::vector<Color> &colors, int counter) -> Color {
-    int cycle_length = (colors.size() * 2) - 2;
-    size_t n = counter % cycle_length;
-
-    size_t index;
-    if (n < colors.size()) {
-        index = n;  // Avanza: 0,1,2,3
-    } else {
-        index = 2 * (colors.size() - 1) - n;  // Retrocede: 2,1
-    }
-
-    return colors[index];
-}
-
-constexpr auto rgbToHsv(Color color) -> HSV {
+// Implementaciones de métodos estáticos de Color
+constexpr auto Color::rgbToHsv(Color color) -> HSV {
    float r = color.r / 255.0F;
    float g = color.g / 255.0F;
    float b = color.b / 255.0F;
@@ -87,7 +73,7 @@ constexpr auto rgbToHsv(Color color) -> HSV {
    return {.h = h, .s = s, .v = v};
 }

-constexpr auto hsvToRgb(HSV hsv) -> Color {
+constexpr auto Color::hsvToRgb(HSV hsv) -> Color {
    float c = hsv.v * hsv.s;
    float x = c * (1 - std::abs(std::fmod(hsv.h / 60.0F, 2) - 1));
    float m = hsv.v - c;
@@ -128,55 +114,73 @@ constexpr auto hsvToRgb(HSV hsv) -> Color {
        static_cast<uint8_t>(roundf((b + m) * 255)));
 }

-auto generateMirroredCycle(Color base, ColorCycleStyle style) -> ColorCycle {
-    ColorCycle result{};
-    HSV base_hsv = rgbToHsv(base);
+// Implementaciones del namespace Colors
+namespace Colors {
+    // Obtiene un color del vector de colores imitando al Coche Fantástico
+    auto getColorLikeKnightRider(const std::vector<Color> &colors, int counter) -> Color {
+        int cycle_length = (colors.size() * 2) - 2;
+        size_t n = counter % cycle_length;

-    for (size_t i = 0; i < COLOR_CYCLE_SIZE; ++i) {
-        float t = static_cast<float>(i) / (COLOR_CYCLE_SIZE - 1);  // 0 → 1
-        float hue_shift = 0.0F;
-        float sat_shift = 0.0F;
-        float val_shift = 0.0F;
-
-        switch (style) {
-            case ColorCycleStyle::SUBTLE_PULSE:
-                // Solo brillo suave
-                val_shift = 0.07F * sinf(t * M_PI);
-                break;
-
-            case ColorCycleStyle::HUE_WAVE:
-                // Oscilación leve de tono
-                hue_shift = 15.0F * (t - 0.5F) * 2.0F;
-                val_shift = 0.05F * sinf(t * M_PI);
-                break;
-
-            case ColorCycleStyle::VIBRANT:
-                // Cambios fuertes en tono y brillo
-                hue_shift = 35.0F * sinf(t * M_PI);
-                val_shift = 0.2F * sinf(t * M_PI);
-                sat_shift = -0.2F * sinf(t * M_PI);
-                break;
-
-            case ColorCycleStyle::DARKEN_GLOW:
-                // Se oscurece al centro
-                val_shift = -0.15F * sinf(t * M_PI);
-                break;
-
-            case ColorCycleStyle::LIGHT_FLASH:
-                // Se ilumina al centro
-                val_shift = 0.25F * sinf(t * M_PI);
-                break;
+        size_t index;
+        if (n < colors.size()) {
+            index = n;  // Avanza: 0,1,2,3
+        } else {
+            index = 2 * (colors.size() - 1) - n;  // Retrocede: 2,1
        }

-        HSV adjusted = {
-            .h = fmodf(base_hsv.h + hue_shift + 360.0F, 360.0F),
-            .s = fminf(1.0F, fmaxf(0.0F, base_hsv.s + sat_shift)),
-            .v = fminf(1.0F, fmaxf(0.0F, base_hsv.v + val_shift))};
-
-        Color c = hsvToRgb(adjusted);
-        result[i] = c;
-        result[(2 * COLOR_CYCLE_SIZE) - 1 - i] = c;  // espejo
+        return colors[index];
    }

-    return result;
+    auto generateMirroredCycle(Color base, ColorCycleStyle style) -> Cycle {
+        Cycle result{};
+        HSV base_hsv = Color::rgbToHsv(base);
+
+        for (size_t i = 0; i < CYCLE_SIZE; ++i) {
+            float t = static_cast<float>(i) / (CYCLE_SIZE - 1);  // 0 → 1
+            float hue_shift = 0.0F;
+            float sat_shift = 0.0F;
+            float val_shift = 0.0F;
+
+            switch (style) {
+                case ColorCycleStyle::SUBTLE_PULSE:
+                    // Solo brillo suave
+                    val_shift = 0.07F * sinf(t * M_PI);
+                    break;
+
+                case ColorCycleStyle::HUE_WAVE:
+                    // Oscilación leve de tono
+                    hue_shift = 15.0F * (t - 0.5F) * 2.0F;
+                    val_shift = 0.05F * sinf(t * M_PI);
+                    break;
+
+                case ColorCycleStyle::VIBRANT:
+                    // Cambios fuertes en tono y brillo
+                    hue_shift = 35.0F * sinf(t * M_PI);
+                    val_shift = 0.2F * sinf(t * M_PI);
+                    sat_shift = -0.2F * sinf(t * M_PI);
+                    break;
+
+                case ColorCycleStyle::DARKEN_GLOW:
+                    // Se oscurece al centro
+                    val_shift = -0.15F * sinf(t * M_PI);
+                    break;
+
+                case ColorCycleStyle::LIGHT_FLASH:
+                    // Se ilumina al centro
+                    val_shift = 0.25F * sinf(t * M_PI);
+                    break;
+            }
+
+            HSV adjusted = {
+                .h = fmodf(base_hsv.h + hue_shift + 360.0F, 360.0F),
+                .s = fminf(1.0F, fmaxf(0.0F, base_hsv.s + sat_shift)),
+                .v = fminf(1.0F, fmaxf(0.0F, base_hsv.v + val_shift))};
+
+            Color c = Color::hsvToRgb(adjusted);
+            result[i] = c;
+            result[(2 * CYCLE_SIZE) - 1 - i] = c;  // espejo
+        }
+
+        return result;
+    }
 }
--- a/source/color.h
+++ b/source/color.h
@@ -9,8 +9,12 @@
 #include <string>     // Para string
 #include <vector>     // Para vector

-// --- Constantes ---
-constexpr size_t COLOR_CYCLE_SIZE = 6;  // Mitad del ciclo espejado
+// --- Estructura HSV: define un color en formato HSV ---
+struct HSV {
+        float h;  // Matiz (Hue)
+        float s;  // Saturación (Saturation)
+        float v;  // Valor (Value)
+};

 // --- Estructura Color: define un color RGBA ---
 struct Color {
@@ -60,6 +64,10 @@ struct Color {
        // Método estático para crear Color desde string hexadecimal
        static auto fromHex(const std::string &hex_str) -> Color;

+        // Conversiones de formato de color
+        [[nodiscard]] constexpr static auto rgbToHsv(Color color) -> HSV;
+        [[nodiscard]] constexpr static auto hsvToRgb(HSV hsv) -> Color;
+
        [[nodiscard]] constexpr auto IS_EQUAL_TO(const Color &other) const -> bool {
            return r == other.r && g == other.g && b == other.b && a == other.a;
        }
@@ -89,13 +97,6 @@ struct Color {
        }
 };

-// --- Estructura HSV: define un color en formato HSV ---
-struct HSV {
-        float h;  // Matiz (Hue)
-        float s;  // Saturación (Saturation)
-        float v;  // Valor (Value)
-};
-
 // --- Enum ColorCycleStyle: define estilos de ciclo de color ---
 enum class ColorCycleStyle {
    SUBTLE_PULSE,  // Variación leve en brillo (por defecto)
@@ -105,23 +106,27 @@ enum class ColorCycleStyle {
    LIGHT_FLASH    // Ilumina hacia el centro y regresa
 };

-// --- Alias ---
-using ColorCycle = std::array<Color, 2 * COLOR_CYCLE_SIZE>;
+// --- Namespace Colors: constantes y utilidades de color ---
+namespace Colors {
+    // --- Constantes ---
+    constexpr size_t CYCLE_SIZE = 6;  // Mitad del ciclo espejado

-// --- Colores predefinidos ---
-constexpr Color NO_TEXT_COLOR = Color(0XFF, 0XFF, 0XFF);
-constexpr Color SHADOW_TEXT_COLOR = Color(0X43, 0X43, 0X4F);
-constexpr Color TITLE_SHADOW_TEXT_COLOR = Color(0x14, 0x87, 0xc4);
-constexpr Color ORANGE_TEXT_COLOR = Color(0XFF, 0X7A, 0X00);
+    // --- Alias ---
+    using Cycle = std::array<Color, 2 * CYCLE_SIZE>;

-constexpr Color FLASH_COLOR = Color(0XFF, 0XFF, 0XFF);
+    // --- Colores predefinidos ---
+    constexpr Color NO_COLOR_MOD = Color(0XFF, 0XFF, 0XFF);
+    constexpr Color SHADOW_TEXT = Color(0X43, 0X43, 0X4F);
+    constexpr Color TITLE_SHADOW_TEXT = Color(0x14, 0x87, 0xc4);
+    constexpr Color ORANGE_TEXT = Color(0XFF, 0X7A, 0X00);

-constexpr Color BLUE_SKY_COLOR = Color(0X02, 0X88, 0XD1);
-constexpr Color PINK_SKY_COLOR = Color(0XFF, 0X6B, 0X97);
-constexpr Color GREEN_SKY_COLOR = Color(0X00, 0X79, 0X6B);
+    constexpr Color FLASH = Color(0XFF, 0XFF, 0XFF);

-// --- Funciones ---
-auto getColorLikeKnightRider(const std::vector<Color> &colors, int counter) -> Color;
-constexpr auto rgbToHsv(Color color) -> HSV;
-constexpr auto hsvToRgb(HSV hsv) -> Color;
-auto generateMirroredCycle(Color base, ColorCycleStyle style = ColorCycleStyle::SUBTLE_PULSE) -> ColorCycle;
+    constexpr Color BLUE_SKY = Color(0X02, 0X88, 0XD1);
+    constexpr Color PINK_SKY = Color(0XFF, 0X6B, 0X97);
+    constexpr Color GREEN_SKY = Color(0X00, 0X79, 0X6B);
+
+    // --- Funciones ---
+    auto getColorLikeKnightRider(const std::vector<Color> &colors, int counter) -> Color;
+    auto generateMirroredCycle(Color base, ColorCycleStyle style = ColorCycleStyle::SUBTLE_PULSE) -> Cycle;
+}
--- a/source/defaults.h
+++ b/source/defaults.h
@@ -1,5 +1,7 @@
 #pragma once

+#include <SDL3/SDL.h>  // Para SDL_ScaleMode
+
 #include <array>

 #include "color.h"
@@ -17,6 +19,7 @@ constexpr int NAME_ENTRY_IDLE_TIME = 10;
 constexpr int NAME_ENTRY_TOTAL_TIME = 60;
 constexpr bool HIT_STOP = false;
 constexpr int HIT_STOP_MS = 500;
+constexpr const char* ITEM_TEXT_OUTLINE_COLOR = "FFFFFF00";  // 255, 255, 255, 0

 // Play area por defecto
 constexpr float PLAY_AREA_X = 0.0F;
@@ -30,9 +33,8 @@ namespace Fade {
 constexpr const char* COLOR = "1F2B30";
 constexpr float NUM_SQUARES_WIDTH = 160.0F;
 constexpr float NUM_SQUARES_HEIGHT = 128.0F;
-constexpr int RANDOM_SQUARES_DELAY = 1;
-constexpr int RANDOM_SQUARES_MULT = 500;
-constexpr int POST_DURATION = 80;
+constexpr int RANDOM_SQUARES_DURATION_MS = 1;
+constexpr int POST_DURATION_MS = 80;
 constexpr float VENETIAN_SIZE = 12.0F;
 }  // namespace Fade

@@ -73,7 +75,8 @@ namespace Balloon {
 struct BalloonSettings {
        float vel;
        float grav;
-        constexpr BalloonSettings(float v, float g) : vel(v), grav(g) {}
+        constexpr BalloonSettings(float v, float g)
+            : vel(v), grav(g) {}
 };

 constexpr std::array<BalloonSettings, 4> SETTINGS = {{
@@ -84,7 +87,10 @@ constexpr std::array<BalloonSettings, 4> SETTINGS = {{
 }};

 constexpr std::array<const char*, 4> COLORS = {
-    "blue", "orange", "red", "green"};
+    "blue",
+    "orange",
+    "red",
+    "green"};

 constexpr bool BOUNCING_SOUND = false;
 }  // namespace Balloon
@@ -149,6 +155,20 @@ constexpr float MAX_SPAWN_TIME = 3.0F;

 // --- PLAYER ---
 namespace Player {
+namespace DefaultShirt {
+// Player 0 (Jugador 1)
+constexpr const char* PLAYER0_DARKEST = "028ECFFF";  // 2, 142, 207, 255
+constexpr const char* PLAYER0_DARK = "0297DBFF";     // 2, 151, 219, 255
+constexpr const char* PLAYER0_BASE = "029FE8FF";     // 2, 159, 232, 255
+constexpr const char* PLAYER0_LIGHT = "03A9F4FF";    // 3, 169, 244, 255
+
+// Player 1 (Jugador 2)
+constexpr const char* PLAYER1_DARKEST = "8E8E8EFF";  // 142, 142, 142, 255
+constexpr const char* PLAYER1_DARK = "AEADADFF";     // 174, 173, 173, 255
+constexpr const char* PLAYER1_BASE = "E4E4E4FF";     // 228, 228, 228, 255
+constexpr const char* PLAYER1_LIGHT = "F7F1F1FF";    // 247, 241, 241, 255
+}  // namespace DefaultShirt
+
 namespace OneCoffeeShirt {
 // Player 0 (Jugador 1)
 constexpr const char* PLAYER0_DARKEST = "3D9C70FF";  // 61, 156, 112, 255
@@ -176,5 +196,45 @@ constexpr const char* PLAYER1_DARK = "FA7D00FF";     // 250, 125, 0, 255
 constexpr const char* PLAYER1_BASE = "FAA200FF";     // 250, 162, 0, 255
 constexpr const char* PLAYER1_LIGHT = "FA8500FF";    // 250, 133, 0, 255
 }  // namespace TwoCoffeeShirt
+
+namespace OutlineColor {
+// Player 0 (Jugador 1)
+constexpr const char* PLAYER0 = "66323FFF";
+
+// Player 1 (Jugador 2)
+constexpr const char* PLAYER1 = "422028FF";
+}  // namespace OutlineColor
 }  // namespace Player
+
+// --- OPTIONS ---
+namespace Options {
+// Window
+constexpr const char* WINDOW_CAPTION = "Coffee Crisis Arcade Edition";
+constexpr int WINDOW_ZOOM = 2;
+constexpr int WINDOW_MAX_ZOOM = 2;
+
+// Video
+constexpr SDL_ScaleMode VIDEO_SCALE_MODE = SDL_ScaleMode::SDL_SCALEMODE_NEAREST;
+constexpr bool VIDEO_FULLSCREEN = false;
+constexpr bool VIDEO_VSYNC = true;
+constexpr bool VIDEO_INTEGER_SCALE = true;
+constexpr bool VIDEO_SHADERS = false;
+
+// Music
+constexpr bool MUSIC_ENABLED = true;
+constexpr int MUSIC_VOLUME = 100;
+
+// Sound
+constexpr bool SOUND_ENABLED = true;
+constexpr int SOUND_VOLUME = 100;
+
+// Audio
+constexpr bool AUDIO_ENABLED = true;
+constexpr int AUDIO_VOLUME = 100;
+
+// Settings
+constexpr bool SETTINGS_AUTOFIRE = true;
+constexpr bool SETTINGS_SHUTDOWN_ENABLED = false;
+constexpr const char* PARAMS_FILE = "param_320x256.txt";
+}  // namespace Options
 }  // namespace GameDefaults
--- a/source/director.cpp
+++ b/source/director.cpp
@@ -124,9 +124,9 @@ void Director::close() {
 void Director::loadParams() {
    // Carga los parametros para configurar el juego
 #ifdef ANBERNIC
-    const std::string paramFilePath = asset->get("param_320x240.txt");
+    const std::string PARAM_FILE_PATH = Asset::get()->get("param_320x240.txt");
 #else
-    const std::string PARAM_FILE_PATH = overrides.param_file == "--320x240" ? Asset::get()->get("param_320x240.txt") : Asset::get()->get("param_320x256.txt");
+    const std::string PARAM_FILE_PATH = Asset::get()->get(Options::settings.params_file);
 #endif
    loadParamsFromFile(PARAM_FILE_PATH);
 }
--- a/source/fade.cpp
+++ b/source/fade.cpp
@@ -35,24 +35,32 @@ void Fade::init() {
    b_ = 0;
    a_ = 0;
    post_duration_ = 0;
-    post_counter_ = 0;
+    post_start_time_ = 0;
    pre_duration_ = 0;
-    pre_counter_ = 0;
+    pre_start_time_ = 0;
    num_squares_width_ = param.fade.num_squares_width;
    num_squares_height_ = param.fade.num_squares_height;
-    fade_random_squares_delay_ = param.fade.random_squares_delay;
-    fade_random_squares_mult_ = param.fade.random_squares_mult;
+    random_squares_duration_ = param.fade.random_squares_duration_ms;  // Usar como duración en ms
+    square_transition_duration_ = random_squares_duration_ / 4;  // 25% del tiempo total para la transición individual
+    random_squares_start_time_ = 0;
 }

 // Resetea algunas variables para volver a hacer el fade sin perder ciertos parametros
 void Fade::reset() {
    state_ = State::NOT_ENABLED;
    counter_ = 0;
+    post_start_time_ = 0;
+    pre_start_time_ = 0;
 }

 // Pinta una transición en pantalla
 void Fade::render() {
    if (state_ != State::NOT_ENABLED) {
+        // Para fade IN terminado, no renderizar (auto-desactivación visual)
+        if (state_ == State::FINISHED && mode_ == Mode::IN) {
+            return;
+        }
+        
        SDL_RenderTexture(renderer_, backbuffer_, nullptr, nullptr);
    }
 }
@@ -75,10 +83,15 @@ void Fade::update() {
 }

 void Fade::updatePreState() {
-    if (pre_counter_ == pre_duration_) {
+    // Sistema basado en tiempo únicamente
+    Uint32 elapsed_time = SDL_GetTicks() - pre_start_time_;
+    
+    if (elapsed_time >= static_cast<Uint32>(pre_duration_)) {
        state_ = State::FADING;
-    } else {
-        pre_counter_++;
+        // CRÍTICO: Reinicializar tiempo de inicio para tipos que usan random_squares_start_time_
+        if (type_ == Type::RANDOM_SQUARE2 || type_ == Type::DIAGONAL) {
+            random_squares_start_time_ = SDL_GetTicks();
+        }
    }
 }

@@ -93,6 +106,12 @@ void Fade::updateFadingState() {
        case Type::RANDOM_SQUARE:
            updateRandomSquareFade();
            break;
+        case Type::RANDOM_SQUARE2:
+            updateRandomSquare2Fade();
+            break;
+        case Type::DIAGONAL:
+            updateDiagonalFade();
+            break;
        case Type::VENETIAN:
            updateVenetianFade();
            break;
@@ -102,13 +121,26 @@ void Fade::updateFadingState() {
    counter_++;
 }

+void Fade::changeToPostState() {
+    state_ = State::POST;
+    post_start_time_ = SDL_GetTicks();
+}
+
 void Fade::updatePostState() {
-    if (post_counter_ == post_duration_) {
+    // Sistema basado en tiempo únicamente
+    Uint32 elapsed_time = SDL_GetTicks() - post_start_time_;
+    
+    if (elapsed_time >= static_cast<Uint32>(post_duration_)) {
        state_ = State::FINISHED;
-    } else {
-        post_counter_++;
    }
-    cleanBackbuffer(r_, g_, b_, a_);
+    
+    // Mantener el alpha final correcto para cada tipo de fade
+    Uint8 post_alpha = a_;
+    if (type_ == Type::RANDOM_SQUARE2 || type_ == Type::DIAGONAL) {
+        post_alpha = (mode_ == Mode::OUT) ? 255 : 0;
+    }
+    
+    cleanBackbuffer(r_, g_, b_, post_alpha);
 }

 void Fade::updateFullscreenFade() {
@@ -118,7 +150,7 @@ void Fade::updateFullscreenFade() {

    // Comprueba si ha terminado
    if (counter_ >= 255 / 4) {
-        state_ = State::POST;
+        changeToPostState();
    }
 }

@@ -127,8 +159,8 @@ void Fade::updateCenterFade() {

    // Comprueba si ha terminado
    if ((counter_ * 4) > param.game.height) {
-        state_ = State::POST;
        a_ = 255;
+        changeToPostState();
    }
 }

@@ -151,20 +183,243 @@ void Fade::drawCenterFadeRectangles() {
 }

 void Fade::updateRandomSquareFade() {
-    if (counter_ % fade_random_squares_delay_ == 0) {
-        drawRandomSquares();
-    }
+    Uint32 elapsed_time = SDL_GetTicks() - random_squares_start_time_;
+    float progress = static_cast<float>(elapsed_time) / random_squares_duration_;

-    value_ = calculateValue(0, (num_squares_width_ * num_squares_height_), (counter_ * fade_random_squares_mult_ / fade_random_squares_delay_));
+    // Calcula cuántos cuadrados deberían estar activos
+    int total_squares = num_squares_width_ * num_squares_height_;
+    int active_squares = static_cast<int>(progress * total_squares);
+    active_squares = std::min(active_squares, total_squares);
+
+    // Dibuja los cuadrados activos
+    drawRandomSquares(active_squares);
+
+    value_ = calculateValue(0, total_squares, active_squares);

    // Comprueba si ha terminado
-    if (counter_ * fade_random_squares_mult_ / fade_random_squares_delay_ >=
-        num_squares_width_ * num_squares_height_) {
-        state_ = State::POST;
+    if (elapsed_time >= static_cast<Uint32>(random_squares_duration_)) {
+        changeToPostState();
    }
 }

-void Fade::drawRandomSquares() {
+void Fade::updateRandomSquare2Fade() {
+    Uint32 elapsed_time = SDL_GetTicks() - random_squares_start_time_;
+    
+    int total_squares = num_squares_width_ * num_squares_height_;
+    
+    // Calcula el tiempo de activación: total - tiempo que necesitan los últimos cuadrados
+    int activation_time = random_squares_duration_ - square_transition_duration_;
+    activation_time = std::max(activation_time, square_transition_duration_);  // Mínimo igual a la duración de transición
+    
+    // Lógica diferente según el modo
+    int squares_to_activate = 0;
+    
+    if (mode_ == Mode::OUT) {
+        // OUT: Activa cuadrados gradualmente
+        if (elapsed_time < static_cast<Uint32>(activation_time)) {
+            float activation_progress = static_cast<float>(elapsed_time) / activation_time;
+            squares_to_activate = static_cast<int>(activation_progress * total_squares);
+        } else {
+            squares_to_activate = total_squares;  // Activar todos
+        }
+        
+        // Activa nuevos cuadrados y guarda su tiempo de activación
+        for (int i = 0; i < squares_to_activate && i < total_squares; ++i) {
+            if (square_age_[i] == -1) {
+                square_age_[i] = elapsed_time;  // Guarda el tiempo de activación
+            }
+        }
+    } else {
+        // IN: Todos los cuadrados empiezan activos desde el inicio
+        squares_to_activate = total_squares;
+        
+        // Activa cuadrados gradualmente con tiempo de inicio escalonado
+        float activation_progress = static_cast<float>(elapsed_time) / activation_time;
+        int squares_starting_transition = static_cast<int>(activation_progress * total_squares);
+        
+        // Asegurar que al menos 1 cuadrado se active desde el primer frame
+        squares_starting_transition = std::max(squares_starting_transition, 1);
+        squares_starting_transition = std::min(squares_starting_transition, total_squares);
+        
+        for (int i = 0; i < squares_starting_transition; ++i) {
+            if (square_age_[i] == -1) {
+                square_age_[i] = elapsed_time;  // Empieza la transición a transparente
+            }
+        }
+    }
+    
+    drawRandomSquares2();
+
+    value_ = calculateValue(0, total_squares, squares_to_activate);
+
+    // Comprueba si ha terminado - todos los cuadrados han completado su transición
+    bool all_completed = (squares_to_activate >= total_squares);
+    if (all_completed) {
+        // Verificar que todos han completado su transición individual
+        for (int i = 0; i < total_squares; ++i) {
+            if (square_age_[i] >= 0) {  // Cuadrado activado
+                Uint32 square_elapsed = elapsed_time - square_age_[i];
+                if (square_elapsed < static_cast<Uint32>(square_transition_duration_)) {
+                    all_completed = false;
+                    break;
+                }
+            }
+        }
+        
+        if (all_completed) {
+            // Pintar textura final: OUT opaca, IN transparente
+            Uint8 final_alpha = (mode_ == Mode::OUT) ? 255 : 0;
+            cleanBackbuffer(r_, g_, b_, final_alpha);
+            changeToPostState();
+        }
+    }
+}
+
+void Fade::updateDiagonalFade() {
+    Uint32 elapsed_time = SDL_GetTicks() - random_squares_start_time_;
+    
+    int total_squares = num_squares_width_ * num_squares_height_;
+    
+    // Calcula el tiempo de activación: total - tiempo que necesitan los últimos cuadrados
+    int activation_time = random_squares_duration_ - square_transition_duration_;
+    activation_time = std::max(activation_time, square_transition_duration_);
+    
+    // Calcula cuántas diagonales deberían estar activas
+    int max_diagonal = num_squares_width_ + num_squares_height_ - 1;  // Número total de diagonales
+    int active_diagonals = 0;
+    
+    if (mode_ == Mode::OUT) {
+        // OUT: Activa diagonales gradualmente desde esquina superior izquierda
+        if (elapsed_time < static_cast<Uint32>(activation_time)) {
+            float activation_progress = static_cast<float>(elapsed_time) / activation_time;
+            active_diagonals = static_cast<int>(activation_progress * max_diagonal);
+        } else {
+            active_diagonals = max_diagonal;  // Activar todas
+        }
+        
+        // Activa cuadrados por diagonales
+        for (int diagonal = 0; diagonal < active_diagonals; ++diagonal) {
+            activateDiagonal(diagonal, elapsed_time);
+        }
+    } else {
+        // IN: Todas las diagonales empiezan activas, van desapareciendo
+        active_diagonals = max_diagonal;
+        
+        // Activa diagonales gradualmente para transición
+        if (elapsed_time < static_cast<Uint32>(activation_time)) {
+            float activation_progress = static_cast<float>(elapsed_time) / activation_time;
+            int diagonals_starting_transition = static_cast<int>(activation_progress * max_diagonal);
+            
+            for (int diagonal = 0; diagonal < diagonals_starting_transition; ++diagonal) {
+                activateDiagonal(diagonal, elapsed_time);
+            }
+        } else {
+            // Activar transición en todas las diagonales restantes
+            for (int diagonal = 0; diagonal < max_diagonal; ++diagonal) {
+                activateDiagonal(diagonal, elapsed_time);
+            }
+        }
+    }
+    
+    drawDiagonal();
+
+    value_ = calculateValue(0, total_squares, active_diagonals * (total_squares / max_diagonal));
+
+    // Comprueba si ha terminado - todas las diagonales activadas y último cuadrado completó transición
+    bool all_completed = (active_diagonals >= max_diagonal);
+    if (all_completed) {
+        // Verificar que todos han completado su transición individual
+        for (int i = 0; i < total_squares; ++i) {
+            if (square_age_[i] >= 0) {  // Cuadrado activado
+                Uint32 square_elapsed = elapsed_time - square_age_[i];
+                if (square_elapsed < static_cast<Uint32>(square_transition_duration_)) {
+                    all_completed = false;
+                    break;
+                }
+            }
+        }
+        
+        if (all_completed) {
+            // Pintar textura final: OUT opaca, IN transparente
+            Uint8 final_alpha = (mode_ == Mode::OUT) ? 255 : 0;
+            cleanBackbuffer(r_, g_, b_, final_alpha);
+            changeToPostState();
+        }
+    }
+}
+
+void Fade::activateDiagonal(int diagonal_index, Uint32 current_time) {
+    // Para cada diagonal, activamos los cuadrados que pertenecen a esa diagonal
+    // Diagonal 0: (0,0)
+    // Diagonal 1: (1,0), (0,1)
+    // Diagonal 2: (2,0), (1,1), (0,2)
+    // etc.
+    
+    for (int x = 0; x < num_squares_width_; ++x) {
+        int y = diagonal_index - x;
+        
+        // Verificar que y está dentro de los límites
+        if (y >= 0 && y < num_squares_height_) {
+            // Convertir coordenadas (x,y) a índice en el vector
+            int index = y * num_squares_width_ + x;
+            
+            if (index >= 0 && index < static_cast<int>(square_age_.size())) {
+                if (square_age_[index] == -1) {
+                    square_age_[index] = current_time;  // Guarda el tiempo de activación
+                }
+            }
+        }
+    }
+}
+
+void Fade::drawDiagonal() {
+    auto *temp = SDL_GetRenderTarget(renderer_);
+    SDL_SetRenderTarget(renderer_, backbuffer_);
+
+    // CRÍTICO: Limpiar la textura antes de dibujar
+    SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 0);
+    SDL_RenderClear(renderer_);
+
+    SDL_BlendMode blend_mode;
+    SDL_GetRenderDrawBlendMode(renderer_, &blend_mode);
+    SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_BLEND);  // Usar BLEND para alpha
+
+    Uint32 current_time = SDL_GetTicks() - random_squares_start_time_;
+    
+    // Lógica unificada: sobre textura transparente, pintar cuadrados según su estado
+    for (size_t i = 0; i < square_.size(); ++i) {
+        Uint8 current_alpha = 0;
+        
+        if (square_age_[i] == -1) {
+            // Cuadrado no activado
+            if (mode_ == Mode::OUT) {
+                current_alpha = 0;  // OUT: transparente si no activado
+            } else {
+                current_alpha = a_;  // IN: opaco si no activado  
+            }
+        } else {
+            // Cuadrado activado - calculamos progreso
+            Uint32 square_elapsed = current_time - square_age_[i];
+            float progress = std::min(static_cast<float>(square_elapsed) / square_transition_duration_, 1.0f);
+            
+            if (mode_ == Mode::OUT) {
+                current_alpha = static_cast<Uint8>(progress * a_);  // 0 → 255
+            } else {
+                current_alpha = static_cast<Uint8>((1.0f - progress) * a_);  // 255 → 0
+            }
+        }
+        
+        if (current_alpha > 0) {
+            SDL_SetRenderDrawColor(renderer_, r_, g_, b_, current_alpha);
+            SDL_RenderFillRect(renderer_, &square_[i]);
+        }
+    }
+
+    SDL_SetRenderDrawBlendMode(renderer_, blend_mode);
+    SDL_SetRenderTarget(renderer_, temp);
+}
+
+void Fade::drawRandomSquares(int active_count) {
    auto *temp = SDL_GetRenderTarget(renderer_);
    SDL_SetRenderTarget(renderer_, backbuffer_);

@@ -173,13 +428,56 @@ void Fade::drawRandomSquares() {
    SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_NONE);
    SDL_SetRenderDrawColor(renderer_, r_, g_, b_, a_);

-    const int INDEX = std::min(counter_ / fade_random_squares_delay_,
-        (num_squares_width_ * num_squares_height_) - 1);
+    // Dibuja solo los cuadrados activos
+    for (int i = 0; i < active_count && i < static_cast<int>(square_.size()); ++i) {
+        SDL_RenderFillRect(renderer_, &square_[i]);
+    }

-    for (int i = 0; i < fade_random_squares_mult_; ++i) {
-        const int INDEX2 = std::min((INDEX * fade_random_squares_mult_) + i,
-            static_cast<int>(square_.size()) - 1);
-        SDL_RenderFillRect(renderer_, &square_[INDEX2]);
+    SDL_SetRenderDrawBlendMode(renderer_, blend_mode);
+    SDL_SetRenderTarget(renderer_, temp);
+}
+
+void Fade::drawRandomSquares2() {
+    auto *temp = SDL_GetRenderTarget(renderer_);
+    SDL_SetRenderTarget(renderer_, backbuffer_);
+
+    // CRÍTICO: Limpiar la textura antes de dibujar
+    SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 0);
+    SDL_RenderClear(renderer_);
+
+    SDL_BlendMode blend_mode;
+    SDL_GetRenderDrawBlendMode(renderer_, &blend_mode);
+    SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_BLEND);  // Usar BLEND para alpha
+
+    Uint32 current_time = SDL_GetTicks() - random_squares_start_time_;
+    
+    // Lógica unificada: sobre textura transparente, pintar cuadrados según su estado
+    for (size_t i = 0; i < square_.size(); ++i) {
+        Uint8 current_alpha = 0;
+        
+        if (square_age_[i] == -1) {
+            // Cuadrado no activado
+            if (mode_ == Mode::OUT) {
+                current_alpha = 0;  // OUT: transparente si no activado
+            } else {
+                current_alpha = a_;  // IN: opaco si no activado  
+            }
+        } else {
+            // Cuadrado activado - calculamos progreso
+            Uint32 square_elapsed = current_time - square_age_[i];
+            float progress = std::min(static_cast<float>(square_elapsed) / square_transition_duration_, 1.0f);
+            
+            if (mode_ == Mode::OUT) {
+                current_alpha = static_cast<Uint8>(progress * a_);  // 0 → 255
+            } else {
+                current_alpha = static_cast<Uint8>((1.0f - progress) * a_);  // 255 → 0
+            }
+        }
+        
+        if (current_alpha > 0) {
+            SDL_SetRenderDrawColor(renderer_, r_, g_, b_, current_alpha);
+            SDL_RenderFillRect(renderer_, &square_[i]);
+        }
    }

    SDL_SetRenderDrawBlendMode(renderer_, blend_mode);
@@ -192,7 +490,7 @@ void Fade::updateVenetianFade() {
        updateVenetianRectangles();
        calculateVenetianProgress();
    } else {
-        state_ = State::POST;
+        changeToPostState();
    }
 }

@@ -239,8 +537,7 @@ void Fade::activate() {

    state_ = State::PRE;
    counter_ = 0;
-    post_counter_ = 0;
-    pre_counter_ = 0;
+    pre_start_time_ = SDL_GetTicks();

    switch (type_) {
        case Type::FULLSCREEN: {
@@ -284,6 +581,76 @@ void Fade::activate() {
            // Deja el color listo para usar
            a_ = mode_ == Mode::OUT ? 255 : 0;

+            // Inicializa el tiempo de inicio
+            random_squares_start_time_ = SDL_GetTicks();
+
+            break;
+        }
+
+        case Type::RANDOM_SQUARE2: {
+            rect1_ = {.x = 0, .y = 0, .w = static_cast<float>(param.game.width / num_squares_width_), .h = static_cast<float>(param.game.height / num_squares_height_)};
+            square_.clear();
+            square_age_.clear();
+
+            // Añade los cuadrados al vector
+            for (int i = 0; i < num_squares_width_ * num_squares_height_; ++i) {
+                rect1_.x = (i % num_squares_width_) * rect1_.w;
+                rect1_.y = (i / num_squares_width_) * rect1_.h;
+                square_.push_back(rect1_);
+                square_age_.push_back(-1);  // -1 indica cuadrado no activado aún
+            }
+
+            // Desordena el vector de cuadrados y edades
+            auto num = num_squares_width_ * num_squares_height_;
+            while (num > 1) {
+                auto num_arreu = rand() % num;
+                SDL_FRect temp_rect = square_[num_arreu];
+                int temp_age = square_age_[num_arreu];
+                square_[num_arreu] = square_[num - 1];
+                square_age_[num_arreu] = square_age_[num - 1];
+                square_[num - 1] = temp_rect;
+                square_age_[num - 1] = temp_age;
+                num--;
+            }
+
+            // Textura inicial: OUT transparente, IN opaca
+            Uint8 initial_alpha = (mode_ == Mode::OUT) ? 0 : 255;
+            cleanBackbuffer(r_, g_, b_, initial_alpha);
+
+            // Deja el color listo para usar (alpha target para los cuadrados)
+            a_ = 255;  // Siempre usar 255 como alpha target
+
+            // Inicializa el tiempo de inicio y recalcula la duración de transición
+            random_squares_start_time_ = SDL_GetTicks();
+            square_transition_duration_ = std::max(random_squares_duration_ / 4, 100);  // Mínimo 100ms
+
+            break;
+        }
+
+        case Type::DIAGONAL: {
+            rect1_ = {.x = 0, .y = 0, .w = static_cast<float>(param.game.width / num_squares_width_), .h = static_cast<float>(param.game.height / num_squares_height_)};
+            square_.clear();
+            square_age_.clear();
+
+            // Añade los cuadrados al vector en orden (sin desordenar)
+            for (int i = 0; i < num_squares_width_ * num_squares_height_; ++i) {
+                rect1_.x = (i % num_squares_width_) * rect1_.w;
+                rect1_.y = (i / num_squares_width_) * rect1_.h;
+                square_.push_back(rect1_);
+                square_age_.push_back(-1);  // -1 indica cuadrado no activado aún
+            }
+
+            // Textura inicial: OUT transparente, IN opaca
+            Uint8 initial_alpha = (mode_ == Mode::OUT) ? 0 : 255;
+            cleanBackbuffer(r_, g_, b_, initial_alpha);
+
+            // Deja el color listo para usar (alpha target para los cuadrados)
+            a_ = 255;  // Siempre usar 255 como alpha target
+
+            // Inicializa el tiempo de inicio y recalcula la duración de transición
+            random_squares_start_time_ = SDL_GetTicks();
+            square_transition_duration_ = std::max(random_squares_duration_ / 4, 100);  // Mínimo 100ms
+
            break;
        }

--- a/source/fade.h
+++ b/source/fade.h
@@ -14,7 +14,9 @@ class Fade {
            FULLSCREEN = 0,     // Fundido de pantalla completa
            CENTER = 1,         // Fundido desde el centro
            RANDOM_SQUARE = 2,  // Fundido con cuadrados aleatorios
-            VENETIAN = 3,       // Fundido tipo persiana veneciana
+            RANDOM_SQUARE2 = 3, // Fundido con cuadrados aleatorios (variante 2)
+            DIAGONAL = 4,       // Fundido diagonal desde esquina superior izquierda
+            VENETIAN = 5,       // Fundido tipo persiana veneciana
        };

        enum class Mode : Uint8 {
@@ -45,8 +47,8 @@ class Fade {
        void setColor(Color color);                                  // Establece el color del fade
        void setType(Type type) { type_ = type; }                    // Establece el tipo de fade
        void setMode(Mode mode) { mode_ = mode; }                    // Establece el modo de fade
-        void setPostDuration(int value) { post_duration_ = value; }  // Duración posterior al fade
-        void setPreDuration(int value) { pre_duration_ = value; }    // Duración previa al fade
+        void setPostDuration(int value) { post_duration_ = value; }  // Duración posterior al fade en milisegundos
+        void setPreDuration(int value) { pre_duration_ = value; }    // Duración previa al fade en milisegundos

        // --- Getters ---
        [[nodiscard]] auto getValue() const -> int { return value_; }
@@ -60,6 +62,7 @@ class Fade {

        // --- Variables de estado ---
        std::vector<SDL_FRect> square_;     // Vector de cuadrados
+        std::vector<int> square_age_;       // Edad de cada cuadrado (para RANDOM_SQUARE2)
        SDL_FRect rect1_, rect2_;           // Rectángulos para efectos
        Type type_;                         // Tipo de fade
        Mode mode_;                         // Modo de fade
@@ -68,12 +71,13 @@ class Fade {
        Uint8 r_, g_, b_, a_;               // Color del fade (RGBA)
        int num_squares_width_;             // Cuadrados en horizontal
        int num_squares_height_;            // Cuadrados en vertical
-        int fade_random_squares_delay_;     // Delay entre cuadrados
-        int fade_random_squares_mult_;      // Cuadrados por paso
-        int post_duration_ = 0;             // Duración posterior
-        int post_counter_ = 0;              // Contador posterior
-        int pre_duration_ = 0;              // Duración previa
-        int pre_counter_ = 0;               // Contador previo
+        Uint32 random_squares_start_time_;  // Tiempo de inicio del fade de cuadrados
+        int random_squares_duration_;       // Duración total en milisegundos
+        int square_transition_duration_;    // Duración de transición de cada cuadrado en ms
+        int post_duration_ = 0;             // Duración posterior en milisegundos
+        Uint32 post_start_time_ = 0;        // Tiempo de inicio del estado POST
+        int pre_duration_ = 0;              // Duración previa en milisegundos
+        Uint32 pre_start_time_ = 0;         // Tiempo de inicio del estado PRE
        int value_ = 0;                     // Estado del fade (0-100)

        // --- Inicialización y limpieza ---
@@ -87,17 +91,23 @@ class Fade {
        void updatePreState();     // Actualiza el estado previo al fade
        void updateFadingState();  // Actualiza el estado durante el fade
        void updatePostState();    // Actualiza el estado posterior al fade
+        void changeToPostState();  // Cambia al estado POST e inicializa el tiempo

        // --- Efectos de fundido (fade) ---
        void updateFullscreenFade();       // Actualiza el fundido de pantalla completa
        void updateCenterFade();           // Actualiza el fundido desde el centro
        void updateRandomSquareFade();     // Actualiza el fundido con cuadrados aleatorios
+        void updateRandomSquare2Fade();    // Actualiza el fundido con cuadrados aleatorios (variante 2)
+        void updateDiagonalFade();         // Actualiza el fundido diagonal
        void updateVenetianFade();         // Actualiza el fundido tipo persiana veneciana
        void updateVenetianRectangles();   // Actualiza los rectángulos del efecto veneciano
        void calculateVenetianProgress();  // Calcula el progreso del efecto veneciano

        // --- Dibujo de efectos visuales ---
        void drawCenterFadeRectangles();  // Dibuja los rectángulos del fundido central
-        void drawRandomSquares();         // Dibuja los cuadrados aleatorios del fundido
+        void drawRandomSquares(int active_count = -1);  // Dibuja los cuadrados aleatorios del fundido
+        void drawRandomSquares2();        // Dibuja los cuadrados con transición de color (RANDOM_SQUARE2)
+        void drawDiagonal();              // Dibuja los cuadrados con patrón diagonal
+        void activateDiagonal(int diagonal_index, Uint32 current_time);  // Activa una diagonal específica
        void drawVenetianBlinds();        // Dibuja las persianas venecianas del fundido
 };
--- a/source/item.cpp
+++ b/source/item.cpp
@@ -9,9 +9,7 @@
 class Texture;  // lines 6-6

 Item::Item(ItemType type, float x, float y, SDL_FRect &play_area, const std::shared_ptr<Texture> &texture, const std::vector<std::string> &animation)
-    : sprite_(std::make_unique<AnimatedSprite>(texture, animation)),
-      play_area_(play_area),
-      type_(type) {
+    : sprite_(std::make_unique<AnimatedSprite>(texture, animation)), play_area_(play_area), type_(type) {
    switch (type) {
        case ItemType::COFFEE_MACHINE: {
            width_ = COFFEE_MACHINE_WIDTH;
@@ -29,7 +27,15 @@ Item::Item(ItemType type, float x, float y, SDL_FRect &play_area, const std::sha
            height_ = param.game.item_size;
            pos_x_ = x;
            pos_y_ = y;
-            vel_x_ = -1.0F + ((rand() % 5) * 0.5F);
+            // 6 velocidades: 3 negativas (-1.0, -0.66, -0.33) y 3 positivas (0.33, 0.66, 1.0)
+            const int direction = rand() % 6;
+            if (direction < 3) {
+                // Velocidades negativas: -1.0, -0.66, -0.33
+                vel_x_ = -1.0F + (direction * 0.33F);
+            } else {
+                // Velocidades positivas: 0.33, 0.66, 1.0
+                vel_x_ = 0.33F + ((direction - 3) * 0.33F);
+            }
            vel_y_ = -4.0F;
            accel_y_ = 0.2F;
            collider_.r = width_ / 2;
@@ -82,9 +88,9 @@ void Item::move() {
    const float MAX_X = play_area_.w - width_;
    pos_x_ = std::clamp(pos_x_, MIN_X, MAX_X);

-    // Si toca el borde lateral, invierte la velocidad horizontal
+    // Si toca el borde lateral
    if (pos_x_ == MIN_X || pos_x_ == MAX_X) {
-        vel_x_ = -vel_x_;
+        vel_x_ = -vel_x_;                                 // Invierte la velocidad horizontal
    }

    // Si colisiona por arriba, rebota (excepto la máquina de café)
@@ -92,8 +98,8 @@ void Item::move() {
        // Corrige
        pos_y_ = param.game.play_area.rect.y;

-        // Invierte la velocidad
-        vel_y_ = -vel_y_;
+        // Fuerza la velocidad hacia abajo para evitar oscilaciones
+        vel_y_ = std::abs(vel_y_);
    }

    // Si colisiona con la parte inferior
--- a/source/options.cpp
+++ b/source/options.cpp
@@ -134,6 +134,7 @@ auto saveToFile() -> bool {
    file << "game.difficulty=" << static_cast<int>(settings.difficulty) << "\n";
    file << "game.autofire=" << boolToString(settings.autofire) << "\n";
    file << "game.shutdown_enabled=" << boolToString(settings.shutdown_enabled) << "\n";
+    file << "game.params_file=" << settings.params_file << "\n";

    // Opciones de mandos
    file << "\n## CONTROLLERS\n";
@@ -208,6 +209,7 @@ auto set(const std::string& var, const std::string& value) -> bool {
         }},
        {"game.autofire", [](const auto& val) { settings.autofire = stringToBool(val); }},
        {"game.shutdown_enabled", [](const auto& val) { settings.shutdown_enabled = stringToBool(val); }},
+        {"game.params_file", [](const auto& val) { settings.params_file = val; }},
        // Teclado
        {"keyboard.player", [](const auto& val) { keyboard.player_id = static_cast<Player::Id>(stoi(val)); }}};

--- a/source/options.h
+++ b/source/options.h
@@ -11,9 +11,10 @@
 #include <stdexcept>    // Para out_of_range, invalid_argument
 #include <string>       // Para char_traits, string, allocator, operator==, swap, operator<<, basic_string, stoi
 #include <string_view>  // Para string_view
-#include <utility>
-#include <vector>  // Para vector
+#include <utility>      // Para swap
+#include <vector>       // Para vector

+#include "defaults.h"              // Para GameDefaults
 #include "difficulty.h"            // Para Code
 #include "input.h"                 // Para Input
 #include "lang.h"                  // Para Code
@@ -25,66 +26,47 @@ namespace Options {

 // --- Estructuras ---
 struct Window {
-        std::string caption;  // Texto que aparece en la barra de título de la ventana
-        int zoom{2};          // Valor por el que se multiplica el tamaño de la ventana
-        int max_zoom{2};      // Tamaño máximo para que la ventana no sea mayor que la pantalla
-
-        // Constructor por defecto con valores iniciales
-        Window()
-            : caption("Coffee Crisis Arcade Edition") {}
+        std::string caption = GameDefaults::Options::WINDOW_CAPTION;  // Texto que aparece en la barra de título de la ventana
+        int zoom = GameDefaults::Options::WINDOW_ZOOM;                // Valor por el que se multiplica el tamaño de la ventana
+        int max_zoom = GameDefaults::Options::WINDOW_MAX_ZOOM;        // Tamaño máximo para que la ventana no sea mayor que la pantalla
 };

 struct Video {
-        SDL_ScaleMode scale_mode{SDL_ScaleMode::SDL_SCALEMODE_NEAREST};  // Filtro usado para el escalado de la imagen
-        bool fullscreen{false};                                          // Indica si se usa pantalla completa
-        bool vsync{true};                                                // Indica si se usa vsync
-        bool integer_scale{true};                                        // Indica si se usa escalado entero
-        bool shaders{false};                                             // Indica si se usan shaders para los filtros de vídeo
-        std::string info;                                                // Información sobre el modo de vídeo
-
-        // Constructor por defecto con valores iniciales
-        Video() = default;
+        SDL_ScaleMode scale_mode = GameDefaults::Options::VIDEO_SCALE_MODE;  // Filtro usado para el escalado de la imagen
+        bool fullscreen = GameDefaults::Options::VIDEO_FULLSCREEN;           // Indica si se usa pantalla completa
+        bool vsync = GameDefaults::Options::VIDEO_VSYNC;                     // Indica si se usa vsync
+        bool integer_scale = GameDefaults::Options::VIDEO_INTEGER_SCALE;     // Indica si se usa escalado entero
+        bool shaders = GameDefaults::Options::VIDEO_SHADERS;                 // Indica si se usan shaders para los filtros de vídeo
+        std::string info;                                                    // Información sobre el modo de vídeo
 };

 struct Music {
-        bool enabled{true};  // Indica si la música suena o no
-        int volume{100};     // Volumen de la música
-
-        // Constructor por defecto
-        Music() = default;
+        bool enabled = GameDefaults::Options::MUSIC_ENABLED;  // Indica si la música suena o no
+        int volume = GameDefaults::Options::MUSIC_VOLUME;     // Volumen de la música
 };

 struct Sound {
-        bool enabled{true};  // Indica si los sonidos suenan o no
-        int volume{100};     // Volumen de los sonidos
-
-        // Constructor por defecto
-        Sound() = default;
+        bool enabled = GameDefaults::Options::SOUND_ENABLED;  // Indica si los sonidos suenan o no
+        int volume = GameDefaults::Options::SOUND_VOLUME;     // Volumen de los sonidos
 };

 struct Audio {
-        Music music;         // Opciones para la música
-        Sound sound;         // Opciones para los efectos de sonido
-        bool enabled{true};  // Indica si el audio está activo o no
-        int volume{100};     // Volumen general del audio
-
-        // Constructor por defecto
-        Audio() = default;
+        Music music;                                          // Opciones para la música
+        Sound sound;                                          // Opciones para los efectos de sonido
+        bool enabled = GameDefaults::Options::AUDIO_ENABLED;  // Indica si el audio está activo o no
+        int volume = GameDefaults::Options::AUDIO_VOLUME;     // Volumen general del audio
 };

 struct Settings {
-        Difficulty::Code difficulty{Difficulty::Code::NORMAL};  // Dificultad del juego
-        Lang::Code language{Lang::Code::VALENCIAN};             // Idioma usado en el juego
-        bool autofire{true};                                    // Indicador de autofire
-        bool shutdown_enabled{false};                           // Especifica si se puede apagar el sistema
-        Table hi_score_table;                                   // Tabla de mejores puntuaciones
-        std::vector<int> glowing_entries;                       // Últimas posiciones de entrada en la tabla
-        std::string config_file;                                // Ruta al fichero donde guardar la configuración y las opciones del juego
-        std::string controllers_file;                           // Ruta al fichero con las configuraciones de los mandos
-
-        // Constructor por defecto con valores iniciales
-        Settings()
-            : glowing_entries({ManageHiScoreTable::NO_ENTRY, ManageHiScoreTable::NO_ENTRY}) {}
+        Difficulty::Code difficulty = Difficulty::Code::NORMAL;                                           // Dificultad del juego
+        Lang::Code language = Lang::Code::VALENCIAN;                                                      // Idioma usado en el juego
+        bool autofire = GameDefaults::Options::SETTINGS_AUTOFIRE;                                         // Indicador de autofire
+        bool shutdown_enabled = GameDefaults::Options::SETTINGS_SHUTDOWN_ENABLED;                         // Especifica si se puede apagar el sistema
+        Table hi_score_table;                                                                             // Tabla de mejores puntuaciones
+        std::vector<int> glowing_entries = {ManageHiScoreTable::NO_ENTRY, ManageHiScoreTable::NO_ENTRY};  // Últimas posiciones de entrada en la tabla
+        std::string config_file;                                                                          // Ruta al fichero donde guardar la configuración y las opciones del juego
+        std::string controllers_file;                                                                     // Ruta al fichero con las configuraciones de los mandos
+        std::string params_file = GameDefaults::Options::PARAMS_FILE;                                     // Ruta al fichero de parámetros del juego

        // Reinicia las últimas entradas de puntuación
        void clearLastHiScoreEntries() {
@@ -288,12 +270,9 @@ struct Keyboard {
 };

 struct PendingChanges {
-        Lang::Code new_language{Lang::Code::VALENCIAN};             // Idioma en espera de aplicar
-        Difficulty::Code new_difficulty{Difficulty::Code::NORMAL};  // Dificultad en espera de aplicar
-        bool has_pending_changes{false};                            // Indica si hay cambios pendientes
-
-        // Constructor por defecto con valores iniciales
-        PendingChanges() = default;
+        Lang::Code new_language = Lang::Code::VALENCIAN;             // Idioma en espera de aplicar
+        Difficulty::Code new_difficulty = Difficulty::Code::NORMAL;  // Dificultad en espera de aplicar
+        bool has_pending_changes = false;                            // Indica si hay cambios pendientes
 };

 // --- Variables ---
--- a/source/param.cpp
+++ b/source/param.cpp
@@ -97,9 +97,8 @@ auto setParams(const std::string& var, const std::string& value) -> bool {
        {"game.hit_stop_ms", [](const std::string& v) { param.game.hit_stop_ms = std::stoi(v); }},
        {"fade.num_squares_width", [](const std::string& v) { param.fade.num_squares_width = std::stoi(v); }},
        {"fade.num_squares_height", [](const std::string& v) { param.fade.num_squares_height = std::stoi(v); }},
-        {"fade.random_squares_delay", [](const std::string& v) { param.fade.random_squares_delay = std::stoi(v); }},
-        {"fade.random_squares_mult", [](const std::string& v) { param.fade.random_squares_mult = std::stoi(v); }},
-        {"fade.post_duration", [](const std::string& v) { param.fade.post_duration = std::stoi(v); }},
+        {"fade.random_squares_duration_ms", [](const std::string& v) { param.fade.random_squares_duration_ms = std::stoi(v); }},
+        {"fade.post_duration_ms", [](const std::string& v) { param.fade.post_duration_ms = std::stoi(v); }},
        {"fade.venetian_size", [](const std::string& v) { param.fade.venetian_size = std::stoi(v); }},
        {"scoreboard.rect.x", [](const std::string& v) { param.scoreboard.rect.x = std::stoi(v); }},
        {"scoreboard.rect.y", [](const std::string& v) { param.scoreboard.rect.y = std::stoi(v); }},
@@ -136,6 +135,15 @@ auto setParams(const std::string& var, const std::string& value) -> bool {
        {"intro.shadow_color", [](const std::string& v) { param.intro.shadow_color = Color::fromHex(v); }},
        {"debug.color", [](const std::string& v) { param.debug.color = Color::fromHex(v); }},
        {"resource.color", [](const std::string& v) { param.resource.color = Color::fromHex(v); }},
+        {"game.item_text_outline_color", [](const std::string& v) { param.game.item_text_outline_color = Color::fromHex(v); }},
+        {"player.default_shirt[0].darkest", [](const std::string& v) { param.player.default_shirt[0].darkest = Color::fromHex(v); }},
+        {"player.default_shirt[0].dark", [](const std::string& v) { param.player.default_shirt[0].dark = Color::fromHex(v); }},
+        {"player.default_shirt[0].base", [](const std::string& v) { param.player.default_shirt[0].base = Color::fromHex(v); }},
+        {"player.default_shirt[0].light", [](const std::string& v) { param.player.default_shirt[0].light = Color::fromHex(v); }},
+        {"player.default_shirt[1].darkest", [](const std::string& v) { param.player.default_shirt[1].darkest = Color::fromHex(v); }},
+        {"player.default_shirt[1].dark", [](const std::string& v) { param.player.default_shirt[1].dark = Color::fromHex(v); }},
+        {"player.default_shirt[1].base", [](const std::string& v) { param.player.default_shirt[1].base = Color::fromHex(v); }},
+        {"player.default_shirt[1].light", [](const std::string& v) { param.player.default_shirt[1].light = Color::fromHex(v); }},
        {"player.one_coffee_shirt[0].darkest", [](const std::string& v) { param.player.one_coffee_shirt[0].darkest = Color::fromHex(v); }},
        {"player.one_coffee_shirt[0].dark", [](const std::string& v) { param.player.one_coffee_shirt[0].dark = Color::fromHex(v); }},
        {"player.one_coffee_shirt[0].base", [](const std::string& v) { param.player.one_coffee_shirt[0].base = Color::fromHex(v); }},
@@ -151,7 +159,9 @@ auto setParams(const std::string& var, const std::string& value) -> bool {
        {"player.two_coffee_shirt[1].darkest", [](const std::string& v) { param.player.two_coffee_shirt[1].darkest = Color::fromHex(v); }},
        {"player.two_coffee_shirt[1].dark", [](const std::string& v) { param.player.two_coffee_shirt[1].dark = Color::fromHex(v); }},
        {"player.two_coffee_shirt[1].base", [](const std::string& v) { param.player.two_coffee_shirt[1].base = Color::fromHex(v); }},
-        {"player.two_coffee_shirt[1].light", [](const std::string& v) { param.player.two_coffee_shirt[1].light = Color::fromHex(v); }}};
+        {"player.two_coffee_shirt[1].light", [](const std::string& v) { param.player.two_coffee_shirt[1].light = Color::fromHex(v); }},
+        {"player.outline_color[0]", [](const std::string& v) { param.player.outline_color[0] = Color::fromHex(v); }},
+        {"player.outline_color[1]", [](const std::string& v) { param.player.outline_color[1] = Color::fromHex(v); }}};

    static const std::unordered_map<std::string, std::function<void(const std::string&)>> BOOL_PARAMS = {
        {"game.hit_stop", [](const std::string& v) { param.game.hit_stop = stringToBool(v); }},
@@ -184,11 +194,48 @@ auto setParams(const std::string& var, const std::string& value) -> bool {

    static const std::unordered_map<std::string, std::function<void(const std::string&)>> INT_PARAMS_EXTRA = {};

+    // Colores válidos para globos
+    static const std::unordered_map<std::string, bool> VALID_BALLOON_COLORS = {
+        {"blue", true}, {"orange", true}, {"red", true}, {"green", true}
+    };
+    
+    auto validateBalloonColor = [](const std::string& color) -> bool {
+        return VALID_BALLOON_COLORS.find(color) != VALID_BALLOON_COLORS.end();
+    };
+
    static const std::unordered_map<std::string, std::function<void(const std::string&)>> STRING_PARAMS = {
-        {"balloon.color[0]", [](const std::string& v) { param.balloon.color.at(0) = v; }},
-        {"balloon.color[1]", [](const std::string& v) { param.balloon.color.at(1) = v; }},
-        {"balloon.color[2]", [](const std::string& v) { param.balloon.color.at(2) = v; }},
-        {"balloon.color[3]", [](const std::string& v) { param.balloon.color.at(3) = v; }}};
+        {"balloon.color[0]", [validateBalloonColor](const std::string& v) { 
+            if (!validateBalloonColor(v)) {
+                SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Color de globo inválido '%s'. Usando 'blue' por defecto.", v.c_str());
+                param.balloon.color.at(0) = "blue";
+            } else {
+                param.balloon.color.at(0) = v; 
+            }
+        }},
+        {"balloon.color[1]", [validateBalloonColor](const std::string& v) { 
+            if (!validateBalloonColor(v)) {
+                SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Color de globo inválido '%s'. Usando 'orange' por defecto.", v.c_str());
+                param.balloon.color.at(1) = "orange";
+            } else {
+                param.balloon.color.at(1) = v; 
+            }
+        }},
+        {"balloon.color[2]", [validateBalloonColor](const std::string& v) { 
+            if (!validateBalloonColor(v)) {
+                SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Color de globo inválido '%s'. Usando 'red' por defecto.", v.c_str());
+                param.balloon.color.at(2) = "red";
+            } else {
+                param.balloon.color.at(2) = v; 
+            }
+        }},
+        {"balloon.color[3]", [validateBalloonColor](const std::string& v) { 
+            if (!validateBalloonColor(v)) {
+                SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Color de globo inválido '%s'. Usando 'green' por defecto.", v.c_str());
+                param.balloon.color.at(3) = "green";
+            } else {
+                param.balloon.color.at(3) = v; 
+            }
+        }}};

    // Lambda para intentar cada mapa de parámetros
    auto try_map = [&](const auto& param_map) -> bool {
--- a/source/param.h
+++ b/source/param.h
@@ -22,6 +22,7 @@ struct ParamGame {
        Uint32 speed = 15;  // Este valor no estaba en el archivo de configuración
        bool hit_stop = GameDefaults::Game::HIT_STOP;
        Uint32 hit_stop_ms = GameDefaults::Game::HIT_STOP_MS;
+        Color item_text_outline_color;
 };

 // --- Parámetros del fade ---
@@ -29,9 +30,8 @@ struct ParamFade {
        Color color = Color::fromHex(GameDefaults::Fade::COLOR);
        float num_squares_width = GameDefaults::Fade::NUM_SQUARES_WIDTH;
        float num_squares_height = GameDefaults::Fade::NUM_SQUARES_HEIGHT;
-        int random_squares_delay = GameDefaults::Fade::RANDOM_SQUARES_DELAY;
-        int random_squares_mult = GameDefaults::Fade::RANDOM_SQUARES_MULT;
-        int post_duration = GameDefaults::Fade::POST_DURATION;
+        int random_squares_duration_ms = GameDefaults::Fade::RANDOM_SQUARES_DURATION_MS;
+        int post_duration_ms = GameDefaults::Fade::POST_DURATION_MS;
        float venetian_size = GameDefaults::Fade::VENETIAN_SIZE;
 };

@@ -168,23 +168,51 @@ struct ParamPlayer {
        };

        // Inicialización con valores por defecto
-        std::array<Shirt, 2> one_coffee_shirt = {{Shirt(Color::fromHex(GameDefaults::Player::OneCoffeeShirt::PLAYER0_DARKEST),
-                                                      Color::fromHex(GameDefaults::Player::OneCoffeeShirt::PLAYER0_DARK),
-                                                      Color::fromHex(GameDefaults::Player::OneCoffeeShirt::PLAYER0_BASE),
-                                                      Color::fromHex(GameDefaults::Player::OneCoffeeShirt::PLAYER0_LIGHT)),
-            Shirt(Color::fromHex(GameDefaults::Player::OneCoffeeShirt::PLAYER1_DARKEST),
-                Color::fromHex(GameDefaults::Player::OneCoffeeShirt::PLAYER1_DARK),
-                Color::fromHex(GameDefaults::Player::OneCoffeeShirt::PLAYER1_BASE),
-                Color::fromHex(GameDefaults::Player::OneCoffeeShirt::PLAYER1_LIGHT))}};
+        const Shirt default_player0_shirt = Shirt(
+            Color::fromHex(GameDefaults::Player::DefaultShirt::PLAYER0_DARKEST),
+            Color::fromHex(GameDefaults::Player::DefaultShirt::PLAYER0_DARK),
+            Color::fromHex(GameDefaults::Player::DefaultShirt::PLAYER0_BASE),
+            Color::fromHex(GameDefaults::Player::DefaultShirt::PLAYER0_LIGHT));

-        std::array<Shirt, 2> two_coffee_shirt = {{Shirt(Color::fromHex(GameDefaults::Player::TwoCoffeeShirt::PLAYER0_DARKEST),
-                                                      Color::fromHex(GameDefaults::Player::TwoCoffeeShirt::PLAYER0_DARK),
-                                                      Color::fromHex(GameDefaults::Player::TwoCoffeeShirt::PLAYER0_BASE),
-                                                      Color::fromHex(GameDefaults::Player::TwoCoffeeShirt::PLAYER0_LIGHT)),
-            Shirt(Color::fromHex(GameDefaults::Player::TwoCoffeeShirt::PLAYER1_DARKEST),
-                Color::fromHex(GameDefaults::Player::TwoCoffeeShirt::PLAYER1_DARK),
-                Color::fromHex(GameDefaults::Player::TwoCoffeeShirt::PLAYER1_BASE),
-                Color::fromHex(GameDefaults::Player::TwoCoffeeShirt::PLAYER1_LIGHT))}};
+        const Shirt default_player1_shirt = Shirt(
+            Color::fromHex(GameDefaults::Player::DefaultShirt::PLAYER1_DARKEST),
+            Color::fromHex(GameDefaults::Player::DefaultShirt::PLAYER1_DARK),
+            Color::fromHex(GameDefaults::Player::DefaultShirt::PLAYER1_BASE),
+            Color::fromHex(GameDefaults::Player::DefaultShirt::PLAYER1_LIGHT));
+
+        std::array<Shirt, 2> default_shirt = {default_player0_shirt, default_player1_shirt};
+
+        const Shirt one_coffee_player0_shirt = Shirt(
+            Color::fromHex(GameDefaults::Player::OneCoffeeShirt::PLAYER0_DARKEST),
+            Color::fromHex(GameDefaults::Player::OneCoffeeShirt::PLAYER0_DARK),
+            Color::fromHex(GameDefaults::Player::OneCoffeeShirt::PLAYER0_BASE),
+            Color::fromHex(GameDefaults::Player::OneCoffeeShirt::PLAYER0_LIGHT));
+
+        const Shirt one_coffee_player1_shirt = Shirt(
+            Color::fromHex(GameDefaults::Player::OneCoffeeShirt::PLAYER1_DARKEST),
+            Color::fromHex(GameDefaults::Player::OneCoffeeShirt::PLAYER1_DARK),
+            Color::fromHex(GameDefaults::Player::OneCoffeeShirt::PLAYER1_BASE),
+            Color::fromHex(GameDefaults::Player::OneCoffeeShirt::PLAYER1_LIGHT));
+
+        std::array<Shirt, 2> one_coffee_shirt = {one_coffee_player0_shirt, one_coffee_player1_shirt};
+
+        const Shirt two_coffee_player0_shirt = Shirt(
+            Color::fromHex(GameDefaults::Player::TwoCoffeeShirt::PLAYER0_DARKEST),
+            Color::fromHex(GameDefaults::Player::TwoCoffeeShirt::PLAYER0_DARK),
+            Color::fromHex(GameDefaults::Player::TwoCoffeeShirt::PLAYER0_BASE),
+            Color::fromHex(GameDefaults::Player::TwoCoffeeShirt::PLAYER0_LIGHT));
+
+        const Shirt two_coffee_player1_shirt = Shirt(
+            Color::fromHex(GameDefaults::Player::TwoCoffeeShirt::PLAYER1_DARKEST),
+            Color::fromHex(GameDefaults::Player::TwoCoffeeShirt::PLAYER1_DARK),
+            Color::fromHex(GameDefaults::Player::TwoCoffeeShirt::PLAYER1_BASE),
+            Color::fromHex(GameDefaults::Player::TwoCoffeeShirt::PLAYER1_LIGHT));
+
+        std::array<Shirt, 2> two_coffee_shirt = {two_coffee_player0_shirt, two_coffee_player1_shirt};
+
+        const Color outline_player0_color = Color::fromHex(GameDefaults::Player::OutlineColor::PLAYER0);
+        const Color outline_player1_color = Color::fromHex(GameDefaults::Player::OutlineColor::PLAYER1);
+        std::array<Color, 2> outline_color = {outline_player0_color, outline_player1_color};
 };

 // --- Estructura Param: almacena todos los parámetros del juego ---
--- a/source/player.cpp
+++ b/source/player.cpp
@@ -22,17 +22,7 @@

 // Constructor
 Player::Player(const Config &config)
-    : player_sprite_(std::make_unique<AnimatedSprite>(config.texture.at(0), config.animations.at(0))),
-      power_sprite_(std::make_unique<AnimatedSprite>(config.texture.at(4), config.animations.at(1))),
-      enter_name_(std::make_unique<EnterName>()),
-      hi_score_table_(config.hi_score_table),
-      glowing_entry_(config.glowing_entry),
-      stage_info_(config.stage_info),
-      play_area_(*config.play_area),
-      id_(config.id),
-      default_pos_x_(config.x),
-      default_pos_y_(config.y),
-      demo_(config.demo) {
+    : player_sprite_(std::make_unique<AnimatedSprite>(config.texture.at(0), config.animations.at(0))), power_sprite_(std::make_unique<AnimatedSprite>(config.texture.at(4), config.animations.at(1))), enter_name_(std::make_unique<EnterName>()), hi_score_table_(config.hi_score_table), glowing_entry_(config.glowing_entry), stage_info_(config.stage_info), play_area_(*config.play_area), id_(config.id), default_pos_x_(config.x), default_pos_y_(config.y), demo_(config.demo) {
    // Configura objetos
    player_sprite_->addTexture(config.texture.at(1));
    player_sprite_->addTexture(config.texture.at(2));
@@ -199,7 +189,7 @@ void Player::handlePlayingMovement() {
 }

 void Player::handleRecoverMovement() {
-    if (player_sprite_->getCurrentAnimationFrame() == 10) { playSound("voice_brbrbr.wav"); }
+    if (player_sprite_->getCurrentAnimationFrame() == 10) { playSound("voice_recover.wav"); }
    if (player_sprite_->animationIsCompleted()) { setPlayingState(State::RESPAWNING); }
 }

@@ -788,15 +778,30 @@ void Player::setInvulnerable(bool value) {

 // Monitoriza el estado
 void Player::updateInvulnerable() {
-    if (playing_state_ == State::PLAYING) {
-        if (invulnerable_) {
-            if (invulnerable_counter_ > 0) {
-                --invulnerable_counter_;
-                invulnerable_counter_ % 8 > 3 ? player_sprite_->setActiveTexture(coffees_) : player_sprite_->setActiveTexture(3);
-            } else {
-                setInvulnerable(false);
-                player_sprite_->setActiveTexture(coffees_);
+    if (playing_state_ == State::PLAYING && invulnerable_) {
+        if (invulnerable_counter_ > 0) {
+            --invulnerable_counter_;
+            
+            // Frecuencia fija de parpadeo (como el original)
+            constexpr int blink_speed = 8;
+            
+            // Calcula proporción decreciente: menos textura blanca hacia el final
+            // Al inicio: 50-50, hacia el final: 70-30 (menos blanco)
+            float progress = 1.0f - (static_cast<float>(invulnerable_counter_) / INVULNERABLE_COUNTER);
+            int white_frames = static_cast<int>((0.5f - progress * 0.2f) * blink_speed);  
+            
+            // Alterna entre texturas con proporción variable
+            bool should_show_invulnerable = (invulnerable_counter_ % blink_speed) < white_frames;
+            size_t target_texture = should_show_invulnerable ? INVULNERABLE_TEXTURE : coffees_;
+            
+            // Solo cambia textura si es diferente (optimización)
+            if (player_sprite_->getActiveTexture() != target_texture) {
+                player_sprite_->setActiveTexture(target_texture);
            }
+        } else {
+            // Fin de invulnerabilidad
+            setInvulnerable(false);
+            player_sprite_->setActiveTexture(coffees_);
        }
    }
 }
--- a/source/player.h
+++ b/source/player.h
@@ -193,12 +193,13 @@ class Player {

    private:
        // --- Constantes ---
-        static constexpr int POWERUP_COUNTER = 1500;      // Duración del estado PowerUp
-        static constexpr int INVULNERABLE_COUNTER = 200;  // Duración del estado invulnerable
-        static constexpr float BASE_SPEED = 1.5F;         // Velocidad base del jugador
-        static constexpr int COOLING_DURATION = 50;
-        static constexpr int COOLING_COMPLETE = 0;
-        static constexpr int WAITING_COUNTER = 1000;
+        static constexpr int POWERUP_COUNTER = 1500;       // Duración del estado PowerUp
+        static constexpr int INVULNERABLE_COUNTER = 200;   // Duración del estado invulnerable
+        static constexpr size_t INVULNERABLE_TEXTURE = 3;  // Textura usada durante invulnerabilidad
+        static constexpr float BASE_SPEED = 1.5F;          // Velocidad base del jugador
+        static constexpr int COOLING_DURATION = 50;        // Duración del enfriamiento tras disparar
+        static constexpr int COOLING_COMPLETE = 0;         // Valor que indica enfriamiento completado
+        static constexpr int WAITING_COUNTER = 1000;       // Tiempo de espera en estado de espera

        // --- Objetos y punteros ---
        std::unique_ptr<AnimatedSprite> player_sprite_;      // Sprite para dibujar el jugador
--- a/source/resource.cpp
+++ b/source/resource.cpp
@@ -540,7 +540,7 @@ void Resource::createPlayerTextures() {
        {.base_texture = "player1.gif", .palette_files = {"player1_coffee1.pal", "player1_coffee2.pal", "player1_invencible.pal"}, .name_prefix = "player1"},
        {.base_texture = "player2.gif", .palette_files = {"player2_coffee1.pal", "player2_coffee2.pal", "player2_invencible.pal"}, .name_prefix = "player2"}};

-    // Bucle principal modificado para usar un índice (player_idx)
+    // Bucle principal
    for (size_t player_idx = 0; player_idx < players.size(); ++player_idx) {
        const auto &player = players[player_idx];  // Obtenemos el jugador actual

@@ -554,40 +554,52 @@ void Resource::createPlayerTextures() {
            }
        }

-        // Crear variante con paleta original (pal0) - usar la textura ya cargada
-        auto base_texture = getTexture(player.base_texture);
-        std::string pal0_name = player.name_prefix + "_pal0";
-        textures_.emplace_back(pal0_name, base_texture);
-        printWithDots("Player Texture : ", pal0_name, "[  DONE  ]");
+        // Crear las 4 texturas con sus respectivas paletas
+        for (int palette_idx = 0; palette_idx < 4; ++palette_idx) {
+            std::shared_ptr<Texture> texture;

-        // Crear variantes con paletas adicionales - CADA UNA DESDE EL ARCHIVO
-        for (size_t i = 0; i < player.palette_files.size(); ++i) {
-            // Crear textura completamente nueva desde el archivo
-            auto texture_copy = std::make_shared<Texture>(Screen::get()->getRenderer(), texture_file_path);
+            if (palette_idx == 0) {
+                // Textura 0 - usar la ya cargada y modificar solo paleta 0 (default_shirt)
+                texture = getTexture(player.base_texture);
+                texture->setPaletteColor(0, 16, param.player.default_shirt[player_idx].darkest.TO_UINT32());
+                texture->setPaletteColor(0, 17, param.player.default_shirt[player_idx].dark.TO_UINT32());
+                texture->setPaletteColor(0, 18, param.player.default_shirt[player_idx].base.TO_UINT32());
+                texture->setPaletteColor(0, 19, param.player.default_shirt[player_idx].light.TO_UINT32());
+                texture->setPaletteColor(0, 56, param.player.outline_color[player_idx].TO_UINT32());
+            } else {
+                // Crear textura nueva desde archivo
+                texture = std::make_shared<Texture>(Screen::get()->getRenderer(), texture_file_path);

-            // Añadir todas las paletas
-            texture_copy->addPaletteFromPalFile(Asset::get()->get(player.palette_files[0]));
-            texture_copy->addPaletteFromPalFile(Asset::get()->get(player.palette_files[1]));
-            texture_copy->addPaletteFromPalFile(Asset::get()->get(player.palette_files[2]));
+                // Añadir todas las paletas
+                texture->addPaletteFromPalFile(Asset::get()->get(player.palette_files[0]));
+                texture->addPaletteFromPalFile(Asset::get()->get(player.palette_files[1]));
+                texture->addPaletteFromPalFile(Asset::get()->get(player.palette_files[2]));

-            // Añade los colores establecidos en param.player usando el índice del jugador (player_idx)
-            texture_copy->setPaletteColor(1, 16, param.player.one_coffee_shirt[player_idx].darkest.TO_UINT32());
-            texture_copy->setPaletteColor(1, 17, param.player.one_coffee_shirt[player_idx].dark.TO_UINT32());
-            texture_copy->setPaletteColor(1, 18, param.player.one_coffee_shirt[player_idx].base.TO_UINT32());
-            texture_copy->setPaletteColor(1, 19, param.player.one_coffee_shirt[player_idx].light.TO_UINT32());
+                if (palette_idx == 1) {
+                    // Textura 1 - modificar solo paleta 1 (one_coffee_shirt)
+                    texture->setPaletteColor(1, 16, param.player.one_coffee_shirt[player_idx].darkest.TO_UINT32());
+                    texture->setPaletteColor(1, 17, param.player.one_coffee_shirt[player_idx].dark.TO_UINT32());
+                    texture->setPaletteColor(1, 18, param.player.one_coffee_shirt[player_idx].base.TO_UINT32());
+                    texture->setPaletteColor(1, 19, param.player.one_coffee_shirt[player_idx].light.TO_UINT32());
+                    texture->setPaletteColor(1, 56, param.player.outline_color[player_idx].TO_UINT32());
+                } else if (palette_idx == 2) {
+                    // Textura 2 - modificar solo paleta 2 (two_coffee_shirt)
+                    texture->setPaletteColor(2, 16, param.player.two_coffee_shirt[player_idx].darkest.TO_UINT32());
+                    texture->setPaletteColor(2, 17, param.player.two_coffee_shirt[player_idx].dark.TO_UINT32());
+                    texture->setPaletteColor(2, 18, param.player.two_coffee_shirt[player_idx].base.TO_UINT32());
+                    texture->setPaletteColor(2, 19, param.player.two_coffee_shirt[player_idx].light.TO_UINT32());
+                    texture->setPaletteColor(2, 56, param.player.outline_color[player_idx].TO_UINT32());
+                }
+                // Textura 3 (palette_idx == 3) - no modificar nada, usar colores originales
+            }

-            texture_copy->setPaletteColor(2, 16, param.player.two_coffee_shirt[player_idx].darkest.TO_UINT32());
-            texture_copy->setPaletteColor(2, 17, param.player.two_coffee_shirt[player_idx].dark.TO_UINT32());
-            texture_copy->setPaletteColor(2, 18, param.player.two_coffee_shirt[player_idx].base.TO_UINT32());
-            texture_copy->setPaletteColor(2, 19, param.player.two_coffee_shirt[player_idx].light.TO_UINT32());
-
-            // Cambiar a la paleta específica (índice i+1 porque 0 es la original)
-            texture_copy->setPalette(i + 1);
+            // Asignar la paleta correspondiente
+            texture->setPalette(palette_idx);

            // Guardar con nombre específico
-            std::string variant_name = player.name_prefix + "_pal" + std::to_string(i + 1);
-            textures_.emplace_back(variant_name, texture_copy);
-            printWithDots("Player Texture : ", variant_name, "[  DONE  ]");
+            std::string texture_name = player.name_prefix + "_pal" + std::to_string(palette_idx);
+            textures_.emplace_back(texture_name, texture);
+            printWithDots("Player Texture : ", texture_name, "[  DONE  ]");
        }
    }
 }
@@ -604,33 +616,42 @@ void Resource::createTextTextures() {

    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "\n>> CREATING TEXTURES");

-    // Texturas de tamaño normal
-    std::vector<NameAndText> strings = {
+    // Texturas de tamaño normal con outline
+    std::vector<NameAndText> strings1 = {
        {"game_text_1000_points", "1.000"},
        {"game_text_2500_points", "2.500"},
        {"game_text_5000_points", "5.000"},
        {"game_text_powerup", Lang::getText("[GAME_TEXT] 4")},
        {"game_text_one_hit", Lang::getText("[GAME_TEXT] 5")},
-        {"game_text_stop", Lang::getText("[GAME_TEXT] 6")},
+        {"game_text_stop", Lang::getText("[GAME_TEXT] 6")}};
+
+    auto text1 = getText("04b_25_enhanced");
+    for (const auto &s : strings1) {
+        textures_.emplace_back(s.name, text1->writeDXToTexture(Text::STROKE, s.text, -2, Colors::NO_COLOR_MOD, 1, param.game.item_text_outline_color));
+        printWithDots("Texture : ", s.name, "[  DONE  ]");
+    }
+
+    // Texturas de tamaño normal
+    std::vector<NameAndText> strings2 = {
        {"game_text_1000000_points", Lang::getText("[GAME_TEXT] 8")}};

-    auto text = getText("04b_25");
-    for (const auto &s : strings) {
-        textures_.emplace_back(s.name, text->writeToTexture(s.text, 1, -2));
+    auto text2 = getText("04b_25");
+    for (const auto &s : strings2) {
+        textures_.emplace_back(s.name, text2->writeDXToTexture(Text::STROKE, s.text, -2, Colors::NO_COLOR_MOD, 1, param.game.item_text_outline_color));
        printWithDots("Texture : ", s.name, "[  DONE  ]");
    }

    // Texturas de tamaño doble
-    std::vector<NameAndText> strings2_x = {
+    std::vector<NameAndText> strings3 = {
        {"game_text_100000_points", "100.000"},
        {"game_text_get_ready", Lang::getText("[GAME_TEXT] 7")},
        {"game_text_last_stage", Lang::getText("[GAME_TEXT] 3")},
        {"game_text_congratulations", Lang::getText("[GAME_TEXT] 1")},
        {"game_text_game_over", "Game Over"}};

-    auto text2 = getText("04b_25_2x");
-    for (const auto &s : strings2_x) {
-        textures_.emplace_back(s.name, text2->writeToTexture(s.text, 1, -4));
+    auto text3 = getText("04b_25_2x");
+    for (const auto &s : strings3) {
+        textures_.emplace_back(s.name, text3->writeToTexture(s.text, 1, -4));
        printWithDots("Texture : ", s.name, "[  DONE  ]");
    }
 }
@@ -641,15 +662,18 @@ void Resource::createText() {
            std::string key;
            std::string texture_file;
            std::string text_file;
+            std::string white_texture_file;  // Textura blanca opcional

-            ResourceInfo(std::string k, std::string t_file, std::string txt_file)
-                : key(std::move(k)), texture_file(std::move(t_file)), text_file(std::move(txt_file)) {}
+            ResourceInfo(std::string k, std::string t_file, std::string txt_file, std::string w_file = "")
+                : key(std::move(k)), texture_file(std::move(t_file)), text_file(std::move(txt_file)), white_texture_file(std::move(w_file)) {}
    };

    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "\n>> CREATING TEXT OBJECTS");

    std::vector<ResourceInfo> resources = {
        {"04b_25", "04b_25.png", "04b_25.txt"},
+        {"04b_25_enhanced", "04b_25.png", "04b_25.txt", "04b_25_white.png"},  // Nueva fuente con textura blanca
+        {"04b_25_white", "04b_25_white.png", "04b_25.txt"},
        {"04b_25_2x", "04b_25_2x.png", "04b_25_2x.txt"},
        {"04b_25_metal", "04b_25_metal.png", "04b_25.txt"},
        {"04b_25_grey", "04b_25_grey.png", "04b_25.txt"},
@@ -663,7 +687,13 @@ void Resource::createText() {
        {"smb2_grad", "smb2_grad.png", "smb2.txt"}};

    for (const auto &resource : resources) {
-        texts_.emplace_back(resource.key, std::make_shared<Text>(getTexture(resource.texture_file), getTextFile(resource.text_file)));
+        if (!resource.white_texture_file.empty()) {
+            // Crear texto con textura blanca
+            texts_.emplace_back(resource.key, std::make_shared<Text>(getTexture(resource.texture_file), getTexture(resource.white_texture_file), getTextFile(resource.text_file)));
+        } else {
+            // Crear texto normal
+            texts_.emplace_back(resource.key, std::make_shared<Text>(getTexture(resource.texture_file), getTextFile(resource.text_file)));
+        }
        printWithDots("Text : ", resource.key, "[  DONE  ]");
    }
 }
--- a/source/scoreboard.cpp
+++ b/source/scoreboard.cpp
@@ -309,7 +309,7 @@ void Scoreboard::renderShowNameMode(size_t panel_index) {
    text_scoreboard_->writeDX(Text::CENTER | Text::COLOR, slot4_3_.x, slot4_3_.y, Lang::getText("[SCOREBOARD] 11"), 1, text_color1_);

    /* TEXTO CENTRADO */
-    text_scoreboard_->writeDX(Text::CENTER | Text::COLOR, slot4_4_.x, slot4_4_.y, record_name_.at(panel_index), 1, getColorLikeKnightRider(name_colors_, loop_counter_ / 5));
+    text_scoreboard_->writeDX(Text::CENTER | Text::COLOR, slot4_4_.x, slot4_4_.y, record_name_.at(panel_index), 1, Colors::getColorLikeKnightRider(name_colors_, loop_counter_ / 5));
 }

 void Scoreboard::renderGameCompletedMode(size_t panel_index) {
--- a/source/sections/credits.cpp
+++ b/source/sections/credits.cpp
@@ -12,7 +12,7 @@

 #include "audio.h"            // Para Audio
 #include "balloon_manager.h"  // Para BalloonManager
-#include "color.h"            // Para Zone, SHADOW_TEXT_COLOR, NO_TEXT_COLOR, Color
+#include "color.h"            // Para Zone, Colors::SHADOW_TEXT, Colors::NO_COLOR_MOD, Color
 #include "fade.h"             // Para Fade, FadeType, FadeMode
 #include "global_events.h"    // Para check
 #include "global_inputs.h"    // Para check
@@ -35,12 +35,7 @@ constexpr std::string_view TEXT_COPYRIGHT = "@2020,2025 JailDesigner";

 // Constructor
 Credits::Credits()
-    : balloon_manager_(std::make_unique<BalloonManager>(nullptr)),
-      tiled_bg_(std::make_unique<TiledBG>(param.game.game_area.rect, TiledBGMode::DIAGONAL)),
-      fade_in_(std::make_unique<Fade>()),
-      fade_out_(std::make_unique<Fade>()),
-      text_texture_(SDL_CreateTexture(Screen::get()->getRenderer(), SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, static_cast<int>(param.game.width), static_cast<int>(param.game.height))),
-      canvas_(SDL_CreateTexture(Screen::get()->getRenderer(), SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, static_cast<int>(param.game.width), static_cast<int>(param.game.height))) {
+    : balloon_manager_(std::make_unique<BalloonManager>(nullptr)), tiled_bg_(std::make_unique<TiledBG>(param.game.game_area.rect, TiledBGMode::DIAGONAL)), fade_in_(std::make_unique<Fade>()), fade_out_(std::make_unique<Fade>()), text_texture_(SDL_CreateTexture(Screen::get()->getRenderer(), SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, static_cast<int>(param.game.width), static_cast<int>(param.game.height))), canvas_(SDL_CreateTexture(Screen::get()->getRenderer(), SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, static_cast<int>(param.game.width), static_cast<int>(param.game.height))) {
    if (text_texture_ == nullptr) {
        throw std::runtime_error("Failed to create SDL texture for text.");
    }
@@ -173,7 +168,7 @@ void Credits::fillTextTexture() {
    const int TEXTS_HEIGHT = (1 * text->getCharacterSize()) + (8 * SPACE_POST_TITLE) + (3 * SPACE_PRE_TITLE);
    const int POS_X = static_cast<int>(param.game.game_area.center_x);
    credits_rect_dst_.h = credits_rect_src_.h = static_cast<float>(TEXTS_HEIGHT);
-    auto text_style = Text::Style(Text::CENTER | Text::SHADOW, NO_TEXT_COLOR, SHADOW_TEXT_COLOR);
+    auto text_style = Text::Style(Text::CENTER | Text::SHADOW, Colors::NO_COLOR_MOD, Colors::SHADOW_TEXT);

    // PROGRAMMED_AND_DESIGNED_BY
    int y = 0;
@@ -214,7 +209,7 @@ void Credits::fillTextTexture() {
    mini_logo_rect_src_.y = static_cast<float>(y);
    auto mini_logo_sprite = std::make_unique<Sprite>(Resource::get()->getTexture("logo_jailgames_mini.png"));
    mini_logo_sprite->setPosition(1 + POS_X - (mini_logo_sprite->getWidth() / 2), 1 + y);
-    Resource::get()->getTexture("logo_jailgames_mini.png")->setColor(SHADOW_TEXT_COLOR.r, SHADOW_TEXT_COLOR.g, SHADOW_TEXT_COLOR.b);
+    Resource::get()->getTexture("logo_jailgames_mini.png")->setColor(Colors::SHADOW_TEXT.r, Colors::SHADOW_TEXT.g, Colors::SHADOW_TEXT.b);
    mini_logo_sprite->render();

    mini_logo_sprite->setPosition(POS_X - (mini_logo_sprite->getWidth() / 2), y);
@@ -223,7 +218,7 @@ void Credits::fillTextTexture() {

    // Texto con el copyright
    y += mini_logo_sprite->getHeight() + 3;
-    text->writeDX(Text::CENTER | Text::SHADOW, POS_X, y, std::string(TEXT_COPYRIGHT), 1, NO_TEXT_COLOR, 1, SHADOW_TEXT_COLOR);
+    text->writeDX(Text::CENTER | Text::SHADOW, POS_X, y, std::string(TEXT_COPYRIGHT), 1, Colors::NO_COLOR_MOD, 1, Colors::SHADOW_TEXT);

    // Resetea el renderizador
    SDL_SetRenderTarget(Screen::get()->getRenderer(), nullptr);
--- a/source/sections/game.cpp
+++ b/source/sections/game.cpp
@@ -16,7 +16,7 @@
 #include "balloon.h"               // Para Balloon
 #include "balloon_manager.h"       // Para BalloonManager
 #include "bullet.h"                // Para Bullet, BulletType, BulletMoveStatus
-#include "color.h"                 // Para Color, FLASH_COLOR
+#include "color.h"                 // Para Color, Colors::FLASH
 #include "difficulty.h"            // Para Code
 #include "fade.h"                  // Para Fade, FadeType, FadeMode
 #include "global_events.h"         // Para check
@@ -49,18 +49,7 @@

 // Constructor
 Game::Game(Player::Id player_id, int current_stage, bool demo)
-    : renderer_(Screen::get()->getRenderer()),
-      screen_(Screen::get()),
-      input_(Input::get()),
-      canvas_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.play_area.rect.w, param.game.play_area.rect.h)),
-      pause_manager_(std::make_unique<PauseManager>([this](bool is_paused) { onPauseStateChanged(is_paused); })),
-      stage_manager_(std::make_unique<StageManager>()),
-      balloon_manager_(std::make_unique<BalloonManager>(stage_manager_.get())),
-      background_(std::make_unique<Background>(stage_manager_->getPowerNeededToReachStage(stage_manager_->getTotalStages() - 1))),
-      fade_in_(std::make_unique<Fade>()),
-      fade_out_(std::make_unique<Fade>()),
-      tabe_(std::make_unique<Tabe>()),
-      hit_(Hit(Resource::get()->getTexture("hit.png"))) {
+    : renderer_(Screen::get()->getRenderer()), screen_(Screen::get()), input_(Input::get()), canvas_(SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.play_area.rect.w, param.game.play_area.rect.h)), pause_manager_(std::make_unique<PauseManager>([this](bool is_paused) { onPauseStateChanged(is_paused); })), stage_manager_(std::make_unique<StageManager>()), balloon_manager_(std::make_unique<BalloonManager>(stage_manager_.get())), background_(std::make_unique<Background>(stage_manager_->getPowerNeededToReachStage(stage_manager_->getTotalStages() - 1))), fade_in_(std::make_unique<Fade>()), fade_out_(std::make_unique<Fade>()), tabe_(std::make_unique<Tabe>()), hit_(Hit(Resource::get()->getTexture("hit.png"))) {
    // Pasa variables
    demo_.enabled = demo;

@@ -79,14 +68,14 @@ Game::Game(Player::Id player_id, int current_stage, bool demo)
    scoreboard_ = Scoreboard::get();

    fade_in_->setColor(param.fade.color);
-    fade_in_->setPreDuration(demo_.enabled ? 80 : 0);
+    fade_in_->setPreDuration(demo_.enabled ? 500 : 0);
    fade_in_->setPostDuration(0);
-    fade_in_->setType(Fade::Type::RANDOM_SQUARE);
+    fade_in_->setType(Fade::Type::RANDOM_SQUARE2);
    fade_in_->setMode(Fade::Mode::IN);
    fade_in_->activate();

    fade_out_->setColor(param.fade.color);
-    fade_out_->setPostDuration(param.fade.post_duration);
+    fade_out_->setPostDuration(param.fade.post_duration_ms);
    fade_out_->setType(Fade::Type::VENETIAN);

    background_->setPos(param.game.play_area.rect);
@@ -230,7 +219,8 @@ void Game::updatePlayers() {
                    handlePlayerCollision(player, balloon);

                    if (demo_.enabled && allPlayersAreNotPlaying()) {
-                        fade_out_->setType(Fade::Type::RANDOM_SQUARE);
+                        fade_out_->setType(Fade::Type::RANDOM_SQUARE2);
+                        fade_out_->setPostDuration(500);
                        fade_out_->activate();
                    }
                }
@@ -281,7 +271,7 @@ void Game::updateStage() {
    // Efectos de cambio de fase
    playSound("stage_change.wav");
    balloon_manager_->resetBalloonSpeed();
-    screen_->flash(FLASH_COLOR, 3);
+    screen_->flash(Colors::FLASH, 3);
    screen_->shake();

    // Obtener datos de la nueva fase
@@ -1491,8 +1481,10 @@ void Game::initDemo(Player::Id player_id) {

        // Asigna cafes a los jugadores
        for (auto &player : players_) {
-            for (int i = 0; i < rand() % 3; ++i) {
-                player->giveExtraHit();
+            if (player->isPlaying()) {
+                for (int i = 0; i < rand() % 3; ++i) {
+                    player->giveExtraHit();
+                }
            }

            player->setInvulnerable(true);
@@ -1662,7 +1654,8 @@ void Game::updateDemo() {

        // Activa el fundido antes de acabar con los datos de la demo
        if (demo_.counter == TOTAL_DEMO_DATA - 200) {
-            fade_out_->setType(Fade::Type::RANDOM_SQUARE);
+            fade_out_->setType(Fade::Type::RANDOM_SQUARE2);
+            fade_out_->setPostDuration(param.fade.post_duration_ms);
            fade_out_->activate();
        }

--- a/source/sections/game.h
+++ b/source/sections/game.h
@@ -259,7 +259,6 @@ class Game {

        // --- Gestión de fases y progresión ---
        void updateStage();         // Verifica y actualiza cambio de fase
-        void setTotalPower();       // Calcula poder total necesario para completar el juego
        void initDifficultyVars();  // Inicializa variables de dificultad

        // --- Sistema de amenaza ---
--- a/source/sections/hiscore_table.cpp
+++ b/source/sections/hiscore_table.cpp
@@ -9,7 +9,7 @@

 #include "audio.h"                 // Para Audio
 #include "background.h"            // Para Background
-#include "color.h"                 // Para Color, easeOutQuint, NO_TEXT_COLOR
+#include "color.h"                 // Para Color, easeOutQuint, Colors::NO_COLOR_MOD
 #include "fade.h"                  // Para Fade, FadeMode, FadeType
 #include "global_events.h"         // Para check
 #include "global_inputs.h"         // Para check
@@ -29,14 +29,7 @@

 // Constructor
 HiScoreTable::HiScoreTable()
-    : renderer_(Screen::get()->getRenderer()),
-      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>()),
-      ticks_(0),
-      view_area_(SDL_FRect{0, 0, param.game.width, param.game.height}),
-      fade_mode_(Fade::Mode::IN),
-      background_fade_color_(Color(0, 0, 0)) {
+    : renderer_(Screen::get()->getRenderer()), 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>()), ticks_(0), view_area_(SDL_FRect{0, 0, param.game.width, param.game.height}), fade_mode_(Fade::Mode::IN), background_fade_color_(Color(0, 0, 0)) {
    // Inicializa el resto
    Section::name = Section::Name::HI_SCORE_TABLE;
    SDL_SetTextureBlendMode(backbuffer_, SDL_BLENDMODE_BLEND);
@@ -191,7 +184,7 @@ void HiScoreTable::createSprites() {
    // Crea los sprites para las entradas en la tabla de puntuaciones
    const int ANIMATION = rand() % 4;
    const std::string SAMPLE_LINE(ENTRY_LENGTH + 3, ' ');
-    auto sample_entry = std::make_unique<Sprite>(entry_text->writeDXToTexture(Text::SHADOW, SAMPLE_LINE, 1, NO_TEXT_COLOR, 1, SHADOW_TEXT_COLOR));
+    auto sample_entry = std::make_unique<Sprite>(entry_text->writeDXToTexture(Text::SHADOW, SAMPLE_LINE, 1, Colors::NO_COLOR_MOD, 1, Colors::SHADOW_TEXT));
    const auto ENTRY_WIDTH = sample_entry->getWidth();
    for (int i = 0; i < MAX_NAMES; ++i) {
        const auto TABLE_POSITION = format(i + 1) + ". ";
@@ -204,7 +197,7 @@ void HiScoreTable::createSprites() {
        }
        const auto LINE = TABLE_POSITION + Options::settings.hi_score_table.at(i).name + dots + SCORE + ONE_CC;

-        entry_names_.emplace_back(std::make_shared<PathSprite>(entry_text->writeDXToTexture(Text::SHADOW, LINE, 1, NO_TEXT_COLOR, 1, SHADOW_TEXT_COLOR)));
+        entry_names_.emplace_back(std::make_shared<PathSprite>(entry_text->writeDXToTexture(Text::SHADOW, LINE, 1, Colors::NO_COLOR_MOD, 1, Colors::SHADOW_TEXT)));
        const int DEFAULT_POS_X = (backbuffer_width - ENTRY_WIDTH) / 2;
        const int POS_X = (i < 9) ? DEFAULT_POS_X : DEFAULT_POS_X - entry_text->getCharacterSize();
        const int POS_Y = (i * SPACE_BETWEEN_LINES) + FIRST_LINE + SPACE_BETWEEN_HEADER;
@@ -271,8 +264,8 @@ void HiScoreTable::updateSprites() {
 // Inicializa el fade
 void HiScoreTable::initFade() {
    fade_->setColor(param.fade.color);
-    fade_->setType(Fade::Type::RANDOM_SQUARE);
-    fade_->setPostDuration(param.fade.post_duration);
+    fade_->setType(Fade::Type::RANDOM_SQUARE2);
+    fade_->setPostDuration(param.fade.post_duration_ms);
    fade_->setMode(fade_mode_);
    fade_->activate();
 }
@@ -291,7 +284,7 @@ void HiScoreTable::initBackground() {
            background_->setTransition(0.0F);
            background_->setSunProgression(1.0F);
            background_->setMoonProgression(0.0F);
-            background_fade_color_ = GREEN_SKY_COLOR;
+            background_fade_color_ = Colors::GREEN_SKY;
            break;
        }

@@ -301,7 +294,7 @@ void HiScoreTable::initBackground() {
            background_->setTransition(0.0F);
            background_->setSunProgression(0.65F);
            background_->setMoonProgression(0.0F);
-            background_fade_color_ = PINK_SKY_COLOR;
+            background_fade_color_ = Colors::PINK_SKY;
            break;
        }

@@ -311,7 +304,7 @@ void HiScoreTable::initBackground() {
            background_->setTransition(0.0F);
            background_->setSunProgression(0.0F);
            background_->setMoonProgression(0.0F);
-            background_fade_color_ = BLUE_SKY_COLOR;
+            background_fade_color_ = Colors::BLUE_SKY;
            break;
        }

--- a/source/sections/instructions.cpp
+++ b/source/sections/instructions.cpp
@@ -9,7 +9,7 @@
 #include <vector>     // Para vector

 #include "audio.h"          // Para Audio
-#include "color.h"          // Para Color, SHADOW_TEXT_COLOR, Zone, NO_TEXT_C...
+#include "color.h"          // Para Color, Colors::SHADOW_TEXT, Zone, NO_TEXT_C...
 #include "fade.h"           // Para Fade, FadeMode, FadeType
 #include "global_events.h"  // Para check
 #include "global_inputs.h"  // Para check
@@ -26,12 +26,7 @@

 // Constructor
 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_(Resource::get()->getText("smb2")),
-      tiled_bg_(std::make_unique<TiledBG>(param.game.game_area.rect, TiledBGMode::STATIC)),
-      fade_(std::make_unique<Fade>()) {
+    : 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_(Resource::get()->getText("smb2")), tiled_bg_(std::make_unique<TiledBG>(param.game.game_area.rect, TiledBGMode::STATIC)), fade_(std::make_unique<Fade>()) {
    // Configura las texturas
    SDL_SetTextureBlendMode(backbuffer_, SDL_BLENDMODE_BLEND);
    SDL_SetTextureBlendMode(texture_, SDL_BLENDMODE_BLEND);
@@ -44,7 +39,7 @@ Instructions::Instructions()
    tiled_bg_->setColor(param.title.bg_color);
    fade_->setColor(param.fade.color);
    fade_->setType(Fade::Type::FULLSCREEN);
-    fade_->setPostDuration(param.fade.post_duration);
+    fade_->setPostDuration(param.fade.post_duration_ms);
    fade_->setMode(Fade::Mode::IN);
    fade_->activate();

@@ -150,8 +145,8 @@ void Instructions::fillTexture() {
    }
    const int ANCHOR_ITEM = (param.game.width - (length + X_OFFSET)) / 2;

-    auto caption_style = Text::Style(Text::CENTER | Text::COLOR | Text::SHADOW, ORANGE_TEXT_COLOR, SHADOW_TEXT_COLOR);
-    auto text_style = Text::Style(Text::CENTER | Text::COLOR | Text::SHADOW, NO_TEXT_COLOR, SHADOW_TEXT_COLOR);
+    auto caption_style = Text::Style(Text::CENTER | Text::COLOR | Text::SHADOW, Colors::ORANGE_TEXT, Colors::SHADOW_TEXT);
+    auto text_style = Text::Style(Text::CENTER | Text::COLOR | Text::SHADOW, Colors::NO_COLOR_MOD, Colors::SHADOW_TEXT);

    // Escribe el texto de las instrucciones
    text_->writeStyle(param.game.game_area.center_x, FIRST_LINE, Lang::getText("[INSTRUCTIONS] 01"), caption_style);
@@ -167,11 +162,11 @@ void Instructions::fillTexture() {
    text_->writeStyle(param.game.game_area.center_x, ANCHOR2, Lang::getText("[INSTRUCTIONS] 06"), caption_style);

    const int ANCHOR3 = ANCHOR2 + SPACE_POST_HEADER;
-    text_->writeShadowed(ANCHOR_ITEM + X_OFFSET, ANCHOR3 + (SPACE_BETWEEN_ITEM_LINES * 0), Lang::getText("[INSTRUCTIONS] 07"), SHADOW_TEXT_COLOR);
-    text_->writeShadowed(ANCHOR_ITEM + X_OFFSET, ANCHOR3 + (SPACE_BETWEEN_ITEM_LINES * 1), Lang::getText("[INSTRUCTIONS] 08"), SHADOW_TEXT_COLOR);
-    text_->writeShadowed(ANCHOR_ITEM + X_OFFSET, ANCHOR3 + (SPACE_BETWEEN_ITEM_LINES * 2), Lang::getText("[INSTRUCTIONS] 09"), SHADOW_TEXT_COLOR);
-    text_->writeShadowed(ANCHOR_ITEM + X_OFFSET, ANCHOR3 + (SPACE_BETWEEN_ITEM_LINES * 3), Lang::getText("[INSTRUCTIONS] 10"), SHADOW_TEXT_COLOR);
-    text_->writeShadowed(ANCHOR_ITEM + X_OFFSET, ANCHOR3 + (SPACE_BETWEEN_ITEM_LINES * 4), Lang::getText("[INSTRUCTIONS] 11"), SHADOW_TEXT_COLOR);
+    text_->writeShadowed(ANCHOR_ITEM + X_OFFSET, ANCHOR3 + (SPACE_BETWEEN_ITEM_LINES * 0), Lang::getText("[INSTRUCTIONS] 07"), Colors::SHADOW_TEXT);
+    text_->writeShadowed(ANCHOR_ITEM + X_OFFSET, ANCHOR3 + (SPACE_BETWEEN_ITEM_LINES * 1), Lang::getText("[INSTRUCTIONS] 08"), Colors::SHADOW_TEXT);
+    text_->writeShadowed(ANCHOR_ITEM + X_OFFSET, ANCHOR3 + (SPACE_BETWEEN_ITEM_LINES * 2), Lang::getText("[INSTRUCTIONS] 09"), Colors::SHADOW_TEXT);
+    text_->writeShadowed(ANCHOR_ITEM + X_OFFSET, ANCHOR3 + (SPACE_BETWEEN_ITEM_LINES * 3), Lang::getText("[INSTRUCTIONS] 10"), Colors::SHADOW_TEXT);
+    text_->writeShadowed(ANCHOR_ITEM + X_OFFSET, ANCHOR3 + (SPACE_BETWEEN_ITEM_LINES * 4), Lang::getText("[INSTRUCTIONS] 11"), Colors::SHADOW_TEXT);

    // Deja el renderizador como estaba
    SDL_SetRenderTarget(renderer_, temp);
--- a/source/sections/title.cpp
+++ b/source/sections/title.cpp
@@ -7,7 +7,7 @@
 #include <vector>     // Para vector

 #include "audio.h"            // Para Audio
-#include "color.h"            // Para NO_TEXT_COLOR, TITLE_SHADOW_TEXT_COLOR
+#include "color.h"            // Para Colors::NO_COLOR_MOD, Colors::TITLE_SHADOW_TEXT
 #include "fade.h"             // Para Fade, FadeType
 #include "game_logo.h"        // Para GameLogo
 #include "global_events.h"    // Para check
@@ -37,20 +37,14 @@ class Texture;

 // Constructor
 Title::Title()
-    : text_(Resource::get()->getText("smb2_grad")),
-      fade_(std::make_unique<Fade>()),
-      tiled_bg_(std::make_unique<TiledBG>(param.game.game_area.rect, TiledBGMode::RANDOM)),
-      game_logo_(std::make_unique<GameLogo>(param.game.game_area.center_x, param.title.title_c_c_position)),
-      mini_logo_sprite_(std::make_unique<Sprite>(Resource::get()->getTexture("logo_jailgames_mini.png"))),
-      state_(TitleState::LOGO_ANIMATING),
-      num_controllers_(Input::get()->getNumGamepads()) {
+    : text_(Resource::get()->getText("smb2_grad")), fade_(std::make_unique<Fade>()), tiled_bg_(std::make_unique<TiledBG>(param.game.game_area.rect, TiledBGMode::RANDOM)), game_logo_(std::make_unique<GameLogo>(param.game.game_area.center_x, param.title.title_c_c_position)), mini_logo_sprite_(std::make_unique<Sprite>(Resource::get()->getTexture("logo_jailgames_mini.png"))), state_(TitleState::LOGO_ANIMATING), num_controllers_(Input::get()->getNumGamepads()) {
    // Configura objetos
    tiled_bg_->setColor(param.title.bg_color);
    game_logo_->enable();
    mini_logo_sprite_->setX(param.game.game_area.center_x - (mini_logo_sprite_->getWidth() / 2));
    fade_->setColor(param.fade.color);
-    fade_->setType(Fade::Type::RANDOM_SQUARE);
-    fade_->setPostDuration(param.fade.post_duration);
+    fade_->setType(Fade::Type::RANDOM_SQUARE2);
+    fade_->setPostDuration(param.fade.post_duration_ms);
    initPlayers();

    // Asigna valores a otras variables
@@ -438,9 +432,9 @@ void Title::renderStartPrompt() {
            param.title.press_start_position,
            Lang::getText("[TITLE] PRESS_BUTTON_TO_PLAY"),
            1,
-            NO_TEXT_COLOR,
+            Colors::NO_COLOR_MOD,
            1,
-            TITLE_SHADOW_TEXT_COLOR);
+            Colors::TITLE_SHADOW_TEXT);
    }
 }

@@ -455,9 +449,9 @@ void Title::renderCopyright() {
            anchor_.copyright_text,
            std::string(TEXT_COPYRIGHT),
            1,
-            NO_TEXT_COLOR,
+            Colors::NO_COLOR_MOD,
            1,
-            TITLE_SHADOW_TEXT_COLOR);
+            Colors::TITLE_SHADOW_TEXT);
    }
 }

--- a/source/sprite.h
+++ b/source/sprite.h
@@ -56,7 +56,7 @@ class Sprite {
        void setTexture(std::shared_ptr<Texture> texture) { textures_.at(texture_index_) = std::move(texture); }
        void addTexture(const std::shared_ptr<Texture>& texture) { textures_.push_back(texture); }
        auto setActiveTexture(size_t index) -> bool;                                           // Cambia la textura activa por índice
-        [[nodiscard]] auto getActiveTextureIndex() const -> size_t { return texture_index_; }  // Obtiene el índice de la textura activa
+        [[nodiscard]] auto getActiveTexture() const -> size_t { return texture_index_; }       // Alias para getActiveTextureIndex
        [[nodiscard]] auto getTextureCount() const -> size_t { return textures_.size(); }      // Obtiene el número total de texturas

    protected:
--- a/source/text.cpp
+++ b/source/text.cpp
@@ -52,6 +52,47 @@ Text::Text(const std::shared_ptr<Texture> &texture, const std::shared_ptr<Text::
    fixed_width_ = false;
 }

+// Constructor con textura blanca opcional
+Text::Text(const std::shared_ptr<Texture> &texture, const std::shared_ptr<Texture> &white_texture, const std::string &text_file) {
+    // Carga los offsets desde el fichero
+    auto tf = loadFile(text_file);
+
+    // Inicializa variables desde la estructura
+    box_height_ = tf->box_height;
+    box_width_ = tf->box_width;
+    for (int i = 0; i < 128; ++i) {
+        offset_[i].x = tf->offset[i].x;
+        offset_[i].y = tf->offset[i].y;
+        offset_[i].w = tf->offset[i].w;
+    }
+
+    // Crea los objetos
+    sprite_ = std::make_unique<Sprite>(texture, (SDL_FRect){0, 0, static_cast<float>(box_width_), static_cast<float>(box_height_)});
+    white_sprite_ = std::make_unique<Sprite>(white_texture, (SDL_FRect){0, 0, static_cast<float>(box_width_), static_cast<float>(box_height_)});
+
+    // Inicializa variables
+    fixed_width_ = false;
+}
+
+// Constructor con textura blanca opcional
+Text::Text(const std::shared_ptr<Texture> &texture, const std::shared_ptr<Texture> &white_texture, const std::shared_ptr<Text::File> &text_file) {
+    // Inicializa variables desde la estructura
+    box_height_ = text_file->box_height;
+    box_width_ = text_file->box_width;
+    for (int i = 0; i < 128; ++i) {
+        offset_[i].x = text_file->offset[i].x;
+        offset_[i].y = text_file->offset[i].y;
+        offset_[i].w = text_file->offset[i].w;
+    }
+
+    // Crea los objetos
+    sprite_ = std::make_unique<Sprite>(texture, (SDL_FRect){0, 0, static_cast<float>(box_width_), static_cast<float>(box_height_)});
+    white_sprite_ = std::make_unique<Sprite>(white_texture, (SDL_FRect){0, 0, static_cast<float>(box_width_), static_cast<float>(box_height_)});
+
+    // Inicializa variables
+    fixed_width_ = false;
+}
+
 // Escribe texto en pantalla
 void Text::write(int x, int y, const std::string &text, int kerning, int length) {
    int shift = 0;
@@ -114,8 +155,30 @@ auto Text::writeToTexture(const std::string &text, int zoom, int kerning, int le
 auto Text::writeDXToTexture(Uint8 flags, const std::string &text, int kerning, Color text_color, Uint8 shadow_distance, Color shadow_color, int length) -> std::shared_ptr<Texture> {
    auto *renderer = Screen::get()->getRenderer();
    auto texture = std::make_shared<Texture>(renderer);
-    auto width = Text::length(text, kerning) + shadow_distance;
-    auto height = box_height_ + shadow_distance;
+    
+    // Calcula las dimensiones considerando los efectos
+    auto base_width = Text::length(text, kerning);
+    auto base_height = box_height_;
+    auto width = base_width;
+    auto height = base_height;
+    auto offset_x = 0;
+    auto offset_y = 0;
+    
+    const auto STROKED = ((flags & Text::STROKE) == Text::STROKE);
+    const auto SHADOWED = ((flags & Text::SHADOW) == Text::SHADOW);
+    
+    if (STROKED) {
+        // Para stroke, el texto se expande en todas las direcciones por shadow_distance
+        width = base_width + (shadow_distance * 2);
+        height = base_height + (shadow_distance * 2);
+        offset_x = shadow_distance;
+        offset_y = shadow_distance;
+    } else if (SHADOWED) {
+        // Para shadow, solo se añade espacio a la derecha y abajo
+        width = base_width + shadow_distance;
+        height = base_height + shadow_distance;
+    }
+    
    auto *temp = SDL_GetRenderTarget(renderer);

    texture->createBlank(width, height, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET);
@@ -123,7 +186,7 @@ auto Text::writeDXToTexture(Uint8 flags, const std::string &text, int kerning, C
    texture->setAsRenderTarget(renderer);
    SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
    SDL_RenderClear(renderer);
-    writeDX(flags, 0, 0, text, kerning, text_color, shadow_distance, shadow_color, length);
+    writeDX(flags, offset_x, offset_y, text, kerning, text_color, shadow_distance, shadow_color, length);
    SDL_SetRenderTarget(renderer, temp);

    return texture;
@@ -131,9 +194,79 @@ auto Text::writeDXToTexture(Uint8 flags, const std::string &text, int kerning, C

 // Escribe el texto con colores
 void Text::writeColored(int x, int y, const std::string &text, Color color, int kerning, int length) {
-    sprite_->getTexture()->setColor(color.r, color.g, color.b);
-    write(x, y, text, kerning, length);
-    sprite_->getTexture()->setColor(255, 255, 255);
+    writeColoredWithSprite(sprite_.get(), x, y, text, color, kerning, length);
+}
+
+// Escribe el texto con colores usando un sprite específico
+void Text::writeColoredWithSprite(Sprite* sprite, int x, int y, const std::string &text, Color color, int kerning, int length) {
+    int shift = 0;
+    const std::string_view VISIBLE_TEXT = (length == -1) ? std::string_view(text) : std::string_view(text).substr(0, length);
+
+    auto *texture = sprite->getTexture().get();
+    
+    // Guarda el alpha original y aplica el nuevo
+    Uint8 original_alpha;
+    SDL_GetTextureAlphaMod(texture->getSDLTexture(), &original_alpha);
+    texture->setAlpha(color.a);
+    texture->setColor(color.r, color.g, color.b);
+    
+    sprite->setY(y);
+    for (const auto CH : VISIBLE_TEXT) {
+        const auto INDEX = static_cast<unsigned char>(CH);
+
+        if (INDEX < offset_.size()) {
+            sprite->setSpriteClip(offset_[INDEX].x, offset_[INDEX].y, box_width_, box_height_);
+            sprite->setX(x + shift);
+            sprite->render();
+            shift += offset_[INDEX].w + kerning;
+        }
+    }
+    
+    // Restaura los valores originales
+    texture->setColor(255, 255, 255);
+    texture->setAlpha(255);
+}
+
+// Escribe stroke con alpha correcto usando textura temporal
+void Text::writeStrokeWithAlpha(int x, int y, const std::string &text, int kerning, Color stroke_color, Uint8 shadow_distance, int length) {
+    auto *renderer = Screen::get()->getRenderer();
+    auto *original_target = SDL_GetRenderTarget(renderer);
+    
+    // Calcula dimensiones de la textura temporal
+    auto text_width = Text::length(text, kerning);
+    auto text_height = box_height_;
+    auto temp_width = text_width + (shadow_distance * 2);
+    auto temp_height = text_height + (shadow_distance * 2);
+    
+    // Crea textura temporal
+    auto temp_texture = std::make_shared<Texture>(renderer);
+    temp_texture->createBlank(temp_width, temp_height, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET);
+    temp_texture->setBlendMode(SDL_BLENDMODE_BLEND);
+    
+    // Renderiza el stroke en la textura temporal
+    temp_texture->setAsRenderTarget(renderer);
+    SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
+    SDL_RenderClear(renderer);
+    
+    // Selecciona el sprite apropiado para el stroke
+    auto *stroke_sprite = white_sprite_ ? white_sprite_.get() : sprite_.get();
+    
+    // Renderiza stroke sin alpha (sólido) en textura temporal
+    Color solid_color = Color(stroke_color.r, stroke_color.g, stroke_color.b, 255);
+    for (int dist = 1; dist <= shadow_distance; ++dist) {
+        for (int dy = -dist; dy <= dist; ++dy) {
+            for (int dx = -dist; dx <= dist; ++dx) {
+                writeColoredWithSprite(stroke_sprite, shadow_distance + dx, shadow_distance + dy, text, solid_color, kerning, length);
+            }
+        }
+    }
+    
+    // Restaura render target original
+    SDL_SetRenderTarget(renderer, original_target);
+    
+    // Renderiza la textura temporal con el alpha deseado
+    temp_texture->setAlpha(stroke_color.a);
+    temp_texture->render(x - shadow_distance, y - shadow_distance);
 }

 // Escribe el texto con sombra
@@ -160,14 +293,28 @@ void Text::writeDX(Uint8 flags, int x, int y, const std::string &text, int kerni
    }

    if (SHADOWED) {
-        writeColored(x + shadow_distance, y + shadow_distance, text, shadow_color, kerning, length);
+        if (white_sprite_) {
+            writeColoredWithSprite(white_sprite_.get(), x + shadow_distance, y + shadow_distance, text, shadow_color, kerning, length);
+        } else {
+            writeColored(x + shadow_distance, y + shadow_distance, text, shadow_color, kerning, length);
+        }
    }

    if (STROKED) {
-        for (int dist = 1; dist <= shadow_distance; ++dist) {
-            for (int dy = -dist; dy <= dist; ++dy) {
-                for (int dx = -dist; dx <= dist; ++dx) {
-                    writeColored(x + dx, y + dy, text, shadow_color, kerning, length);
+        if (shadow_color.a < 255) {
+            // Usa textura temporal para alpha correcto
+            writeStrokeWithAlpha(x, y, text, kerning, shadow_color, shadow_distance, length);
+        } else {
+            // Método tradicional para stroke sólido
+            for (int dist = 1; dist <= shadow_distance; ++dist) {
+                for (int dy = -dist; dy <= dist; ++dy) {
+                    for (int dx = -dist; dx <= dist; ++dx) {
+                        if (white_sprite_) {
+                            writeColoredWithSprite(white_sprite_.get(), x + dx, y + dy, text, shadow_color, kerning, length);
+                        } else {
+                            writeColored(x + dx, y + dy, text, shadow_color, kerning, length);
+                        }
+                    }
                }
            }
        }
--- a/source/text.h
+++ b/source/text.h
@@ -54,6 +54,8 @@ class Text {
        // --- Constructores y destructor ---
        Text(const std::shared_ptr<Texture> &texture, const std::string &text_file);
        Text(const std::shared_ptr<Texture> &texture, const std::shared_ptr<Text::File> &text_file);
+        Text(const std::shared_ptr<Texture> &texture, const std::shared_ptr<Texture> &white_texture, const std::string &text_file);
+        Text(const std::shared_ptr<Texture> &texture, const std::shared_ptr<Texture> &white_texture, const std::shared_ptr<Text::File> &text_file);
        ~Text() = default;

        // --- Métodos de escritura en pantalla ---
@@ -81,9 +83,14 @@ class Text {
        // --- Métodos estáticos ---
        static auto loadFile(const std::string &file_path) -> std::shared_ptr<Text::File>;  // Llena una estructura Text::File desde un fichero

+        // --- Métodos privados ---
+        void writeColoredWithSprite(Sprite* sprite, int x, int y, const std::string &text, Color color, int kerning = 1, int length = -1);  // Escribe con un sprite específico
+        void writeStrokeWithAlpha(int x, int y, const std::string &text, int kerning, Color stroke_color, Uint8 shadow_distance, int length = -1);  // Escribe stroke con alpha correcto
+
    private:
        // --- Objetos y punteros ---
-        std::unique_ptr<Sprite> sprite_ = nullptr;  // Objeto con los gráficos para el texto
+        std::unique_ptr<Sprite> sprite_ = nullptr;        // Objeto con los gráficos para el texto
+        std::unique_ptr<Sprite> white_sprite_ = nullptr;  // Objeto con los gráficos en blanco para efectos

        // --- Variables de estado ---
        std::array<Offset, 128> offset_ = {};  // Vector con las posiciones y ancho de cada letra
--- a/source/ui/menu_renderer.cpp
+++ b/source/ui/menu_renderer.cpp
@@ -345,7 +345,7 @@ void MenuRenderer::updateColorCounter() {
    }
 }
 auto MenuRenderer::getAnimatedSelectedColor() const -> Color {
-    static auto color_cycle_ = generateMirroredCycle(param.service_menu.selected_color, ColorCycleStyle::HUE_WAVE);
+    static auto color_cycle_ = Colors::generateMirroredCycle(param.service_menu.selected_color, ColorCycleStyle::HUE_WAVE);
    return color_cycle_.at(color_counter_ % color_cycle_.size());
 }
 auto MenuRenderer::setRect(SDL_FRect rect) -> SDL_FRect {
Author	SHA1	Message	Date
Sergio Valor	2819b3628e	el fitxer de parametres es guarda en options/config.txt	2025-08-17 21:42:26 +02:00
Sergio Valor	1e9e664012	creat param_red.txt afegides guardes en setParams	2025-08-17 21:29:49 +02:00
Sergio Valor	0c8b39cee7	els items ja no tenen vel_x = 0	2025-08-17 20:42:55 +02:00
Sergio Valor	d7b3af5ab8	en el modo demo asignava cafes al jugador que no jugava i eixia saludant amb la camisa que no toca	2025-08-17 20:22:53 +02:00
Sergio Valor	5e5227305f	arreglat bug en el estat pre del fade	2025-08-17 20:17:55 +02:00
Sergio Valor	3fc15a9512	afegit el fade RANDOM_SQAURE2 canviat els timings del fade a milisegons	2025-08-17 19:34:48 +02:00
Sergio Valor	e774e0e8ad	modificat el efecte de invulnerabilitat per a que vaja menguant	2025-08-17 17:21:03 +02:00
Sergio Valor	a95776e6c7	retocat el audio de recover	2025-08-17 17:01:49 +02:00
Sergio Valor	0428ff26d5	options.h ara gasta defaults.h	2025-08-17 16:28:30 +02:00
Sergio Valor	fc3e2deb1f	Item fix: alguns items es quedaven engantxats en la part de dalt	2025-08-17 16:18:48 +02:00
Sergio Valor	65ca17f938	afegit i parametritzat outline per als textos dels items	2025-08-17 16:07:16 +02:00
Sergio Valor	ff2a51a507	noves coses chules en la clase text	2025-08-17 14:25:17 +02:00
Sergio Valor	fe0083abd4	afagit a param el color de la camiseta per defecte	2025-08-17 13:25:10 +02:00
Sergio Valor	1c058694fd	afegit a param el color de outline dels jugadors	2025-08-17 12:58:20 +02:00