migrant a SDL3

CMakeLists.txt

@@ -6,12 +6,6 @@ project(coffee_crisis_arcade_edition VERSION 2.00)
 # Establece las políticas
 cmake_policy(SET CMP0072 NEW)
 
-# Configuración de compilador para MinGW en Windows, si es necesario
-if(WIN32 AND NOT CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
-    set(CMAKE_CXX_COMPILER "g++")
-    set(CMAKE_C_COMPILER "gcc")
-endif()
-
 # Establecer estándar de C++
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED True)
@@ -31,49 +25,43 @@ if(NOT SOURCES)
     message(FATAL_ERROR "No se encontraron archivos fuente en ${DIR_SOURCES}. Verifica que el directorio existe y contiene archivos .cpp.")
 endif()
 
-# Configuración de SDL3
+# Configuración de SDL3 (usando el método recomendado)
-find_package(SDL3 REQUIRED)
+find_package(SDL3 REQUIRED CONFIG REQUIRED COMPONENTS SDL3)
-if(SDL3_FOUND)
+message(STATUS "SDL3 encontrado: ${SDL3_INCLUDE_DIRS}")
-    message(STATUS "SDL3 encontrado: ${SDL3_INCLUDE_DIRS}")
-    include_directories(${SDL3_INCLUDE_DIRS})
-    link_directories(${SDL3_LIBDIR})
-else()
-    message(FATAL_ERROR "SDL3 no encontrado")
-endif()
 
-# Incluye rutas de SDL3 obtenidas con pkg-config
+# Incluye los directorios si es necesario (SDL3::SDL3 ya incluye la información necesaria)
-include_directories(/usr/local/include /usr/local/include/SDL3)
+include_directories(${SDL3_INCLUDE_DIRS})
-link_directories(/usr/local/lib)
-
-# Definir las bibliotecas comunes
-set(LIBS SDL2)
-
-# Configuración común de salida de ejecutables en el directorio raíz
-set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR})
 
 # Añadir ejecutable principal
 add_executable(${PROJECT_NAME} ${SOURCES})
 
+# Enlazar la librería SDL3
+target_link_libraries(${PROJECT_NAME} PRIVATE SDL3::SDL3)
+
+# Configuración común de salida de ejecutables en el directorio raíz
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR})
+
 # Añadir definiciones de compilación dependiendo del tipo de build
 target_compile_definitions(${PROJECT_NAME} PRIVATE $<$<CONFIG:DEBUG>:DEBUG VERBOSE>)
 
-# Enlazar bibliotecas
-target_link_libraries(${PROJECT_NAME} ${LIBS})
-
 # Configuración específica para cada plataforma
 if(WIN32)
     target_compile_definitions(${PROJECT_NAME} PRIVATE WINDOWS_BUILD)
-    target_link_libraries(${PROJECT_NAME} mingw32 opengl32 gdi32 winmm imm32 ole32 version)
+    target_link_libraries(${PROJECT_NAME} PRIVATE mingw32 opengl32)
 elseif(APPLE)
-    set(LIBS ${LIBS} "-framework OpenGL")
     target_compile_definitions(${PROJECT_NAME} PRIVATE MACOS_BUILD)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated")
-    # Configurar compilación para Apple Silicon
     set(CMAKE_OSX_ARCHITECTURES "arm64")
 elseif(UNIX AND NOT APPLE)
-    set(LIBS ${LIBS} GL)
     target_compile_definitions(${PROJECT_NAME} PRIVATE LINUX_BUILD)
-    target_link_libraries(${PROJECT_NAME} ${LIBS})
+    # Por ejemplo, si necesitas enlazar OpenGL:
+    find_package(OpenGL REQUIRED)
+    if(OPENGL_FOUND)
+        message(STATUS "OpenGL encontrado: ${OPENGL_LIBRARIES}")
+        target_link_libraries(${PROJECT_NAME} PRIVATE ${OPENGL_LIBRARIES})
+    else()
+        message(FATAL_ERROR "OpenGL no encontrado")
+    endif()
 endif()
 
 # Añadir OpenGL a las bibliotecas enlazadas

source/animated_sprite.cpp

@@ -156,8 +156,8 @@ void AnimatedSprite::resetAnimation()
 // Carga la animación desde un vector de cadenas
 void AnimatedSprite::loadFromAnimationsFileBuffer(const AnimationsFileBuffer &source)
 {
-	int frame_width = 1;
+	float frame_width = 1;
-	int frame_height = 1;
+	float frame_height = 1;
 	int frames_per_row = 1;
 	int max_tiles = 1;
 

source/animated_sprite.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <SDL3/SDL.h>
 #include <SDL3/SDL_rect.h> // Para SDL_FRect
 #include <memory>          // Para shared_ptr
 #include <string>          // Para string

source/asset.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include <string> // Para string, basic_string
 #include <vector> // Para vector

source/background.cpp

@@ -57,11 +57,11 @@ Background::Background()
         const float TOP_CLOUDS_Y = base_ - 165;
         const float BOTTOM_CLOUDS_Y = base_ - 101;
 
-        top_clouds_sprite_a_ = std::make_unique<MovingSprite>(top_clouds_texture_, (SDL_FRect){0, TOP_CLOUDS_Y, rect_.w, top_clouds_texture_->getHeight()});
+        top_clouds_sprite_a_ = std::make_unique<MovingSprite>(top_clouds_texture_, (SDL_FRect){0, TOP_CLOUDS_Y, rect_.w, static_cast<float>(top_clouds_texture_->getHeight())});
-        top_clouds_sprite_b_ = std::make_unique<MovingSprite>(top_clouds_texture_, (SDL_FRect){rect_.w, TOP_CLOUDS_Y, rect_.w, top_clouds_texture_->getHeight()});
+        top_clouds_sprite_b_ = std::make_unique<MovingSprite>(top_clouds_texture_, (SDL_FRect){rect_.w, TOP_CLOUDS_Y, rect_.w, static_cast<float>(top_clouds_texture_->getHeight())});
 
-        bottom_clouds_sprite_a_ = std::make_unique<MovingSprite>(bottom_clouds_texture_, (SDL_FRect){0, BOTTOM_CLOUDS_Y, rect_.w, bottom_clouds_texture_->getHeight()});
+        bottom_clouds_sprite_a_ = std::make_unique<MovingSprite>(bottom_clouds_texture_, (SDL_FRect){0, BOTTOM_CLOUDS_Y, rect_.w, static_cast<float>(bottom_clouds_texture_->getHeight())});
-        bottom_clouds_sprite_b_ = std::make_unique<MovingSprite>(bottom_clouds_texture_, (SDL_FRect){rect_.w, BOTTOM_CLOUDS_Y, rect_.w, bottom_clouds_texture_->getHeight()});
+        bottom_clouds_sprite_b_ = std::make_unique<MovingSprite>(bottom_clouds_texture_, (SDL_FRect){rect_.w, BOTTOM_CLOUDS_Y, rect_.w, static_cast<float>(bottom_clouds_texture_->getHeight())});
 
         buildings_sprite_ = std::make_unique<Sprite>(buildings_texture_);
         gradient_sprite_ = std::make_unique<Sprite>(gradients_texture_, 0, 0, rect_.w, rect_.h);
@@ -337,21 +337,21 @@ void Background::updateClouds()
 // Precalcula el vector con el recorrido del sol
 void Background::createSunPath()
 {
-    constexpr int CENTER_X = 170;
+    constexpr float CENTER_X = 170;
-    const int center_y = base_ - 80;
+    const float center_y = base_ - 80;
-    constexpr int RADIUS = 120;
+    constexpr float RADIUS = 120;
 
     // Generar puntos de la curva desde 90 a 180 grados
     for (double theta = M_PI / 2; theta <= M_PI; theta += 0.01)
     {
-        int x = CENTER_X + static_cast<int>(RADIUS * cos(theta));
+        float x = CENTER_X + (RADIUS * cos(theta));
-        int y = center_y - static_cast<int>(RADIUS * sin(theta));
+        float y = center_y - (RADIUS * sin(theta));
         sun_path_.push_back({x, y});
     }
 
     // Agregar puntos en línea recta después de la curva
     constexpr int EXTRA_PIXELS = 40;
-    SDL_Point last_point = sun_path_.back();
+    SDL_FPoint last_point = sun_path_.back();
     for (int i = 1; i <= EXTRA_PIXELS; ++i)
     {
         sun_path_.push_back({last_point.x, last_point.y + i});
@@ -361,15 +361,15 @@ void Background::createSunPath()
 // Precalcula el vector con el recorrido de la luna
 void Background::createMoonPath()
 {
-    constexpr int CENTER_X = 100;
+    constexpr float CENTER_X = 100;
-    const int center_y = base_ - 50;
+    const float center_y = base_ - 50;
-    constexpr int RADIUS = 140;
+    constexpr float RADIUS = 140;
 
     // Generar puntos de la curva desde 0 a 90 grados
     for (double theta = 0; theta <= M_PI / 2; theta += 0.01)
     {
-        int x = CENTER_X + static_cast<int>(RADIUS * cos(theta));
+        float x = CENTER_X + (RADIUS * cos(theta));
-        int y = center_y - static_cast<int>(RADIUS * sin(theta));
+        float y = center_y - (RADIUS * sin(theta));
         moon_path_.push_back({x, y});
     }
 }

source/background.h

@@ -1,6 +1,7 @@
 #pragma once
+#include <SDL3/SDL.h>
 
-#include <SDL3/SDL_rect.h>   // Para SDL_FRect, SDL_Point
+#include <SDL3/SDL_rect.h>   // Para SDL_FRect, SDL_FPoint
 #include <SDL3/SDL_render.h> // Para SDL_Texture, SDL_Renderer
 #include <stddef.h>          // Para size_t
 #include <memory>            // Para unique_ptr, shared_ptr
@@ -71,25 +72,25 @@ private:
   SDL_Texture *color_texture_; // Textura para atenuar el fondo
 
   // Variables
-  SDL_FRect gradient_rect_[4];       // Vector con las coordenadas de los 4 degradados para el cielo
+  SDL_FRect gradient_rect_[4];        // Vector con las coordenadas de los 4 degradados para el cielo
-  SDL_FRect top_clouds_rect_[4];     // Vector con las coordenadas de los 4 nubes de arriba
+  SDL_FRect top_clouds_rect_[4];      // Vector con las coordenadas de los 4 nubes de arriba
-  SDL_FRect bottom_clouds_rect_[4];  // Vector con las coordenadas de los 4 nubes de abajo
+  SDL_FRect bottom_clouds_rect_[4];   // Vector con las coordenadas de los 4 nubes de abajo
-  int gradient_number_ = 0;          // Indica el número de degradado de fondo que se va a dibujar
+  int gradient_number_ = 0;           // Indica el número de degradado de fondo que se va a dibujar
-  int alpha_ = 0;                    // Transparencia entre los dos degradados
+  int alpha_ = 0;                     // Transparencia entre los dos degradados
-  float clouds_speed_ = 0;           // Velocidad a la que se desplazan las nubes
+  float clouds_speed_ = 0;            // Velocidad a la que se desplazan las nubes
-  float transition_ = 0;             // Nivel de transición del fondo 0..1
+  float transition_ = 0;              // Nivel de transición del fondo 0..1
-  int counter_ = 0;                  // Contador interno
+  int counter_ = 0;                   // Contador interno
-  SDL_FRect rect_;                   // Tamaño del objeto fondo
+  SDL_FRect rect_;                    // Tamaño del objeto fondo
-  SDL_FRect src_rect_;               // Parte del objeto fondo que se va a dibujará en pantalla
+  SDL_FRect src_rect_;                // Parte del objeto fondo que se va a dibujará en pantalla
-  SDL_FRect dst_rect_;               // Posición donde dibujar la parte del objeto fondo que se dibujará en pantalla
+  SDL_FRect dst_rect_;                // Posición donde dibujar la parte del objeto fondo que se dibujará en pantalla
-  int base_;                         // Linea de fondo coincidente con el area inferior de la zona de juego
+  int base_;                          // Linea de fondo coincidente con el area inferior de la zona de juego
-  Color attenuate_color_;            // Color para atenuar el fondo
+  Color attenuate_color_;             // Color para atenuar el fondo
-  int alpha_color_text_;             // Alpha para atenuar el fondo
+  int alpha_color_text_;              // Alpha para atenuar el fondo
-  int alpha_color_text_temp_;        // Valor temporal para hacer la transición de alpha
+  int alpha_color_text_temp_;         // Valor temporal para hacer la transición de alpha
-  std::vector<SDL_Point> sun_path_;  // Vector con el recorrido del sol
+  std::vector<SDL_FPoint> sun_path_;  // Vector con el recorrido del sol
-  std::vector<SDL_Point> moon_path_; // Vector con el recorrido de la luna
+  std::vector<SDL_FPoint> moon_path_; // Vector con el recorrido de la luna
-  size_t sun_index_ = 0;             // Posición del vector del recorrido del sol
+  size_t sun_index_ = 0;              // Posición del vector del recorrido del sol
-  size_t moon_index_ = 0;            // Posición del vector del recorrido de la luna
+  size_t moon_index_ = 0;             // Posición del vector del recorrido de la luna
 
   // Dibuja el gradiente de fondo
   void renderGradient();

source/balloon.cpp

@@ -117,7 +117,7 @@ void Balloon::render()
 		// Renderiza la estrella
 		if (!invulnerable_)
 		{
-			SDL_Point p = {24, 24};
+			SDL_FPoint p = {24.0f, 24.0f};
 			sprite_->setRotatingCenter(p);
 			sprite_->render();
 		}

source/balloon.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include <SDL3/SDL_rect.h>	 // Para SDL_FRect
 #include <SDL3/SDL_stdinc.h> // Para Uint8, Uint16, Uint32
@@ -90,8 +91,8 @@ private:
 	// Variables
 	float x_;						   // Posición en el eje X
 	float y_;						   // Posición en el eje Y
-	Uint8 w_;						   // Ancho
+	float w_;						   // Ancho
-	Uint8 h_;						   // Alto
+	float h_;						   // Alto
 	float vx_;						   // Velocidad en el eje X. Cantidad de pixeles a desplazarse
 	float vy_;						   // Velocidad en el eje Y. Cantidad de pixeles a desplazarse
 	float gravity_;					   // Aceleración en el eje Y. Modifica la velocidad

source/balloon_formations.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include "balloon.h" // Para BALLOON_VELX_NEGATIVE, BALLOON_VELX_POSITIVE
 #include <vector>

source/balloon_manager.cpp

@@ -216,19 +216,19 @@ void BalloonManager::createPowerBall()
 {
     if (can_deploy_balloons_)
     {
-        constexpr int values = 6;
+        constexpr int VALUES = 6;
-        constexpr int pos_y = -BALLOON_SIZE[4];
+        constexpr float POS_Y = -BALLOON_SIZE[4];
-        constexpr int creation_time = 0;
+        constexpr int CREATION_TIME = 0;
 
-        const auto left = param.game.play_area.rect.x;
+        const float LEFT = param.game.play_area.rect.x;
-        const auto center = param.game.play_area.center_x - (BALLOON_SIZE[4] / 2);
+        const float CENTER = param.game.play_area.center_x - (BALLOON_SIZE[4] / 2);
-        const auto right = param.game.play_area.rect.w - BALLOON_SIZE[4];
+        const float RIGHT = param.game.play_area.rect.w - BALLOON_SIZE[4];
 
-        const auto luck = rand() % values;
+        const int LUCK = rand() % VALUES;
-        const int x[values] = {left, left, center, center, right, right};
+        const float POS_X[VALUES] = {LEFT, LEFT, CENTER, CENTER, RIGHT, RIGHT};
-        const float vx[values] = {BALLOON_VELX_POSITIVE, BALLOON_VELX_POSITIVE, BALLOON_VELX_POSITIVE, BALLOON_VELX_NEGATIVE, BALLOON_VELX_NEGATIVE, BALLOON_VELX_NEGATIVE};
+        const float VEL_X[VALUES] = {BALLOON_VELX_POSITIVE, BALLOON_VELX_POSITIVE, BALLOON_VELX_POSITIVE, BALLOON_VELX_NEGATIVE, BALLOON_VELX_NEGATIVE, BALLOON_VELX_NEGATIVE};
 
-        balloons_.emplace_back(std::make_unique<Balloon>(x[luck], pos_y, BalloonType::POWERBALL, BalloonSize::SIZE4, vx[luck], balloon_speed_, creation_time, play_area_, balloon_textures_[4], balloon_animations_[4]));
+        balloons_.emplace_back(std::make_unique<Balloon>(POS_X[LUCK], POS_Y, BalloonType::POWERBALL, BalloonSize::SIZE4, VEL_X[LUCK], balloon_speed_, CREATION_TIME, play_area_, balloon_textures_[4], balloon_animations_[4]));
         balloons_.back()->setInvulnerable(true);
 
         power_ball_enabled_ = true;

source/balloon_manager.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include <SDL3/SDL_rect.h>      // Para SDL_FRect
 #include <memory>               // Para shared_ptr, unique_ptr

source/bullet.cpp

@@ -6,7 +6,7 @@
 class Texture;             // lines 5-5
 
 // Constructor
-Bullet::Bullet(int x, int y, BulletType bullet_type, bool powered_up, int owner, std::shared_ptr<Texture> texture)
+Bullet::Bullet(float x, float y, BulletType bullet_type, bool powered_up, int owner, std::shared_ptr<Texture> texture)
     : sprite_(std::make_unique<Sprite>(texture, SDL_FRect{x, y, BULLET_WIDTH_, BULLET_HEIGHT_})),
       pos_x_(x),
       pos_y_(y),

source/bullet.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include <SDL3/SDL_stdinc.h> // Para Uint8
 #include <memory>			 // Para shared_ptr, unique_ptr
@@ -27,17 +28,17 @@ class Bullet
 {
 private:
 	// Constantes
-	static constexpr int BULLET_WIDTH_ = 12;
+	static constexpr float BULLET_WIDTH_ = 12.0f;
-	static constexpr int BULLET_HEIGHT_ = 12;
+	static constexpr float BULLET_HEIGHT_ = 12.0f;
-	static constexpr int BULLET_VEL_Y_ = -3;
+	static constexpr float BULLET_VEL_Y_ = -3.0f;
-	static constexpr int BULLET_VEL_X_LEFT_ = -2;
+	static constexpr float BULLET_VEL_X_LEFT_ = -2.0f;
-	static constexpr int BULLET_VEL_X_RIGHT_ = 2;
+	static constexpr float BULLET_VEL_X_RIGHT_ = 2.0f;
 
 	std::unique_ptr<Sprite> sprite_; // Sprite con los gráficos y métodos de pintado
 
-	int pos_x_; // Posición en el eje X
+	float pos_x_; // Posición en el eje X
-	int pos_y_; // Posición en el eje Y
+	float pos_y_; // Posición en el eje Y
-	int vel_x_; // Velocidad en el eje X
+	float vel_x_; // Velocidad en el eje X
 
 	BulletType bullet_type_; // Tipo de objeto
 	int owner_;				 // Identificador del dueño del objeto
@@ -48,7 +49,7 @@ private:
 
 public:
 	// Constructor
-	Bullet(int x, int y, BulletType bullet_type, bool powered_up, int owner, std::shared_ptr<Texture> texture);
+	Bullet(float x, float y, BulletType bullet_type, bool powered_up, int owner, std::shared_ptr<Texture> texture);
 
 	// Destructor
 	~Bullet() = default;

source/credits.cpp

@@ -408,11 +408,11 @@ void Credits::updateBlackRects()
         if (counter_ % 4 == 0)
         {
             // Incrementa la altura del rectangulo superior
-            top_black_rect_.h = std::min(static_cast<int>(top_black_rect_.h) + 1, param.game.game_area.center_y - 1);
+            top_black_rect_.h = std::min(top_black_rect_.h + 1, param.game.game_area.center_y - 1);
 
             // Incrementa la altura y modifica la posición del rectangulo inferior
             ++bottom_black_rect_.h;
-            bottom_black_rect_.y = std::max(static_cast<int>(bottom_black_rect_.y) - 1, param.game.game_area.center_y + 1);
+            bottom_black_rect_.y = std::max(bottom_black_rect_.y - 1, param.game.game_area.center_y + 1);
 
             --current_step;
             setVolume(static_cast<int>(initial_volume_ * current_step / steps_));
@@ -426,11 +426,11 @@ void Credits::updateBlackRects()
             constexpr int SPEED = 2;
             // Si los rectangulos izquierdo y derecho no han llegado al centro
             // Incrementa la anchura del rectangulo situado a la izquierda
-            left_black_rect_.w = std::min(static_cast<int>(left_black_rect_.w) + SPEED, param.game.game_area.center_x);
+            left_black_rect_.w = std::min(left_black_rect_.w + SPEED, param.game.game_area.center_x);
 
             // Incrementa la anchura y modifica la posición del rectangulo situado a la derecha
             right_black_rect_.w += SPEED;
-            right_black_rect_.x = std::max(static_cast<int>(right_black_rect_.x) - SPEED, param.game.game_area.center_x);
+            right_black_rect_.x = std::max(right_black_rect_.x - SPEED, param.game.game_area.center_x);
 
             --current_step;
             setVolume(static_cast<int>(initial_volume_ * current_step / steps_));

source/credits.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include <SDL3/SDL_rect.h>   // Para SDL_FRect
 #include <SDL3/SDL_render.h> // Para SDL_Texture
@@ -28,17 +29,17 @@ private:
     std::vector<std::shared_ptr<Player>> players_;    // Vector con los jugadores
 
     // Variables
-    Uint32 ticks_ = 0;                                                           // Contador de ticks para ajustar la velocidad del programa
+    Uint64 ticks_ = 0;                                                             // Contador de ticks para ajustar la velocidad del programa
-    Uint32 counter_ = 0;                                                         // Contador para la lógica de la clase
+    Uint32 counter_ = 0;                                                           // Contador para la lógica de la clase
-    Uint32 counter_pre_fade_ = 0;                                                // Contador para activar el fundido final
+    Uint32 counter_pre_fade_ = 0;                                                  // Contador para activar el fundido final
-    Uint32 counter_prevent_endless_ = 0;                                         // Contador para evitar que el juego se quede para siempre en los creditos
+    Uint32 counter_prevent_endless_ = 0;                                           // Contador para evitar que el juego se quede para siempre en los creditos
-    int black_bars_size_ = (param.game.game_area.rect.h - PLAY_AREA_HEIGHT) / 2; // Tamaño de las barras negras
+    float black_bars_size_ = (param.game.game_area.rect.h - PLAY_AREA_HEIGHT) / 2; // Tamaño de las barras negras
-    int mini_logo_final_pos_ = 0;                                                // Ubicación donde se detiene el minilogo
+    int mini_logo_final_pos_ = 0;                                                  // Ubicación donde se detiene el minilogo
-    bool fading_ = false;                                                        // Indica si se está realizando el fade final
+    bool fading_ = false;                                                          // Indica si se está realizando el fade final
-    bool want_to_pass_ = false;                                                  // Indica si el jugador quiere saltarse los titulos de crédito
+    bool want_to_pass_ = false;                                                    // Indica si el jugador quiere saltarse los titulos de crédito
-    bool mini_logo_on_position_ = false;                                         // Indica si el minilogo ya se ha quedado en su posición
+    bool mini_logo_on_position_ = false;                                           // Indica si el minilogo ya se ha quedado en su posición
-    int initial_volume_ = options.audio.music.volume;                            // Volumen actual al crear el objeto
+    int initial_volume_ = options.audio.music.volume;                              // Volumen actual al crear el objeto
-    int steps_ = 0;                                                              // Cantidad de pasos a dar para ir reduciendo el audio
+    int steps_ = 0;                                                                // Cantidad de pasos a dar para ir reduciendo el audio
 
     // Rectangulos
     SDL_FRect credits_rect_src_ = param.game.game_area.rect;   // Rectangulo con el texto de los créditos (origen)

source/define_buttons.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include <SDL3/SDL_events.h>         // Para SDL_ControllerButtonEvent
 #include <SDL3/SDL.h> // Para SDL_GamepadButton

source/director.cpp

@@ -1,47 +1,47 @@
 // IWYU pragma: no_include <bits/chrono.h>
 #include "director.h"
-#include <SDL3/SDL.h>				 // Para SDL_Init, SDL_Quit, SDL_INIT_EV...
+#include <SDL3/SDL.h>			  // Para SDL_Init, SDL_Quit, SDL_INIT_EV...
-#include <SDL3/SDL_audio.h>			 // Para AUDIO_S16
+#include <SDL3/SDL_audio.h>		  // Para AUDIO_S16
-#include <SDL3/SDL_blendmode.h>		 // Para SDL_BLENDMODE_BLEND
+#include <SDL3/SDL_blendmode.h>	  // Para SDL_BLENDMODE_BLEND
-#include <SDL3/SDL_error.h>			 // Para SDL_GetError
+#include <SDL3/SDL_error.h>		  // Para SDL_GetError
-#include <SDL3/SDL_events.h>		 // Para SDL_DISABLE
+#include <SDL3/SDL_events.h>	  // Para SDL_DISABLE
-#include <SDL3/SDL.h> // Para SDL_GAMEPAD_BUTTON_B, SDL_CO...
+#include <SDL3/SDL.h>			  // Para SDL_GAMEPAD_BUTTON_B, SDL_CO...
-#include <SDL3/SDL_hints.h>			 // Para SDL_SetHint, SDL_HINT_RENDER_DR...
+#include <SDL3/SDL_hints.h>		  // Para SDL_SetHint, SDL_HINT_RENDER_DR...
-#include <SDL3/SDL_mouse.h>			 // Para SDL_ShowCursor
+#include <SDL3/SDL_mouse.h>		  // Para SDL_ShowCursor
-#include <SDL3/SDL_scancode.h>		 // Para SDL_SCANCODE_0, SDL_SCANCODE_DOWN
+#include <SDL3/SDL_scancode.h>	  // Para SDL_SCANCODE_0, SDL_SCANCODE_DOWN
-#include <SDL3/SDL_stdinc.h>		 // Para Uint32, SDL_bool
+#include <SDL3/SDL_stdinc.h>	  // Para Uint32, SDL_bool
-#include <errno.h>					 // Para errno, EEXIST, EACCES, ENAMETOO...
+#include <errno.h>				  // Para errno, EEXIST, EACCES, ENAMETOO...
-#include <stdio.h>					 // Para printf, perror
+#include <stdio.h>				  // Para printf, perror
-#include <sys/stat.h>				 // Para mkdir, stat, S_IRWXU
+#include <sys/stat.h>			  // Para mkdir, stat, S_IRWXU
-#include <unistd.h>					 // Para getuid
+#include <unistd.h>				  // Para getuid
-#include <algorithm>				 // Para min
+#include <algorithm>			  // Para min
-#include <chrono>					 // Para chrono
+#include <chrono>				  // Para chrono
-#include <cstdlib>					 // Para exit, EXIT_FAILURE, size_t, rand
+#include <cstdlib>				  // Para exit, EXIT_FAILURE, size_t, rand
-#include <iostream>					 // Para basic_ostream, operator<<, basi...
+#include <iostream>				  // Para basic_ostream, operator<<, basi...
-#include <memory>					 // Para make_unique, unique_ptr
+#include <memory>				  // Para make_unique, unique_ptr
-#include <stdexcept>				 // Para runtime_error
+#include <stdexcept>			  // Para runtime_error
-#include <string>					 // Para operator+, char_traits, allocator
+#include <string>				  // Para operator+, char_traits, allocator
-#include <vector>					 // Para vector
+#include <vector>				  // Para vector
-#include "asset.h"					 // Para Asset, AssetType
+#include "asset.h"				  // Para Asset, AssetType
-#include "credits.h"				 // Para Credits
+#include "credits.h"			  // Para Credits
-#include "game.h"					 // Para Game, GAME_MODE_DEMO_OFF, GAME_...
+#include "game.h"				  // Para Game, GAME_MODE_DEMO_OFF, GAME_...
-#include "hiscore_table.h"			 // Para HiScoreTable
+#include "hiscore_table.h"		  // Para HiScoreTable
-#include "input.h"					 // Para Input, InputAction
+#include "input.h"				  // Para Input, InputAction
-#include "instructions.h"			 // Para Instructions
+#include "instructions.h"		  // Para Instructions
-#include "intro.h"					 // Para Intro
+#include "intro.h"				  // Para Intro
-#include "jail_audio.h"				 // Para JA_SetMusicVolume, JA_SetSoundV...
+#include "jail_audio.h"			  // Para JA_SetMusicVolume, JA_SetSoundV...
-#include "lang.h"					 // Para Code, loadFromFile
+#include "lang.h"				  // Para Code, loadFromFile
-#include "logo.h"					 // Para Logo
+#include "logo.h"				  // Para Logo
-#include "manage_hiscore_table.h"	 // Para ManageHiScoreTable
+#include "manage_hiscore_table.h" // Para ManageHiScoreTable
-#include "notifier.h"				 // Para Notifier
+#include "notifier.h"			  // Para Notifier
-#include "on_screen_help.h"			 // Para OnScreenHelp
+#include "on_screen_help.h"		  // Para OnScreenHelp
-#include "options.h"				 // Para Options, options, OptionsContro...
+#include "options.h"			  // Para Options, options, OptionsContro...
-#include "param.h"					 // Para Param, ParamGame, param, loadPa...
+#include "param.h"				  // Para Param, ParamGame, param, loadPa...
-#include "resource.h"				 // Para Resource
+#include "resource.h"			  // Para Resource
-#include "screen.h"					 // Para Screen
+#include "screen.h"				  // Para Screen
-#include "section.h"				 // Para Name, Options, name, options
+#include "section.h"			  // Para Name, Options, name, options
-#include "title.h"					 // Para Title
+#include "title.h"				  // Para Title
-#include "utils.h"					 // Para Overrides, overrides
+#include "utils.h"				  // Para Overrides, overrides
 
 #ifndef _WIN32
 #include <pwd.h> // Para getpwuid, passwd
@@ -296,7 +296,7 @@ bool Director::initSDL()
 	else
 	{
 		// Obtiene información sobre la pantalla
-		auto DM=		SDL_GetCurrentDisplayMode(0);
+		auto DM = SDL_GetCurrentDisplayMode(0);
 
 		// Calcula el máximo factor de zoom que se puede aplicar a la pantalla
 		options.video.window.max_zoom = std::min(DM->w / param.game.width, DM->h / param.game.height);
@@ -327,14 +327,14 @@ bool Director::initSDL()
 		else
 		{
 			// Crea un renderizador para la ventana. El vsync se activa en funcion de las opciones
-			Uint32 flags = 0;
+			//Uint32 flags = 0;
 			if (options.video.v_sync)
 			{
-				//flags = SDL_RENDERER_PRESENTVSYNC;
+				// flags = SDL_RENDERER_PRESENTVSYNC;
 			}
 
 			// La aceleración se activa según el define
-			//flags = flags | SDL_RENDERER_ACCELERATED | SDL_RENDERER_TARGETTEXTURE;
+			// flags = flags | SDL_RENDERER_ACCELERATED | SDL_RENDERER_TARGETTEXTURE;
 
 			renderer_ = SDL_CreateRenderer(window_, nullptr);
 
@@ -347,7 +347,7 @@ bool Director::initSDL()
 			{
 				SDL_SetRenderDrawColor(renderer_, 0x00, 0x00, 0x00, 0xFF);
 				SDL_SetRenderLogicalPresentation(renderer_, param.game.width, param.game.height, SDL_LOGICAL_PRESENTATION_INTEGER_SCALE);
-				SDL_SetWindowFullscreen(window_, static_cast<Uint32>(options.video.mode));
+				SDL_SetWindowFullscreen(window_, static_cast<Uint32>(options.video.fullscreen));
 				SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_BLEND);
 			}
 		}
@@ -799,9 +799,9 @@ std::string Director::getLangFile(lang::Code code)
 
 #ifdef ARCADE
 // Apaga el sistema
-void Director::shutdownSystem(bool shouldShutdown)
+void Director::shutdownSystem(bool should_shutdown)
 {
-	if (shouldShutdown)
+	if (should_shutdown)
 	{
 #ifdef _WIN32
 		// Apaga el sistema en Windows

source/director.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include <SDL3/SDL_render.h> // Para SDL_Renderer
 #include <SDL3/SDL_video.h>	 // Para SDL_Window
@@ -74,7 +75,7 @@ private:
 	std::string getLangFile(lang::Code code);
 #ifdef ARCADE
 	// Apaga el sistema
-	void shutdownSystem(bool shouldShutdown);
+	void shutdownSystem(bool should_shutdown);
 #endif
 
 	// Inicializa todo

source/enter_name.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include <string>
 #include <array>

source/explosions.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include <memory>            // Para unique_ptr, shared_ptr
 #include <string>            // Para string

source/fade.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include <SDL3/SDL_rect.h>	 // Para SDL_FRect
 #include <SDL3/SDL_render.h> // Para SDL_Renderer, SDL_Texture

source/game.cpp

@@ -314,7 +314,7 @@ void Game::updateGameStateGameOver()
 		if (game_over_counter_ == GAME_OVER_COUNTER_)
 		{
 			createMessage({paths_.at(2), paths_.at(3)}, Resource::get()->getTexture("game_text_game_over"));
-			JA_FadeOutMusic(1000);
+			/*JA_FadeOutMusic(1000);*/
 			balloon_manager_->setSounds(true);
 		}
 

source/game.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include <SDL3/SDL_render.h>	  // Para SDL_Renderer, SDL_Texture
 #include <SDL3/SDL_stdinc.h>	  // Para Uint32, Uint8
@@ -159,7 +160,7 @@ private:
 	Demo demo_;											  // Variable con todas las variables relacionadas con el modo demo
 	GameDifficulty difficulty_ = options.game.difficulty; // Dificultad del juego
 	Helper helper_;										  // Variable para gestionar las ayudas
-	Uint32 ticks_ = 0;									  // Contador de ticks para ajustar la velocidad del programa
+	Uint64 ticks_ = 0;									  // Contador de ticks para ajustar la velocidad del programa
 	bool coffee_machine_enabled_ = false;				  // Indica si hay una máquina de café en el terreno de juego
 	bool hi_score_achieved_ = false;					  // Indica si se ha superado la puntuación máxima
 	bool paused_ = false;								  // Indica si el juego está pausado (no se deberia de poder utilizar en el modo arcade)

source/game_logo.cpp

@@ -247,8 +247,8 @@ bool GameLogo::hasFinished() const
 // Calcula el desplazamiento vertical inicial
 int GameLogo::getInitialVerticalDesp()
 {
-    auto desp_up = y_;
+    const float OFFSET_UP = y_;
-    auto desp_down = param.game.height - y_;
+    const float OFFSET_DOWN = param.game.height - y_;
 
-    return std::max(desp_up, desp_down);
+    return std::max(OFFSET_UP, OFFSET_DOWN);
 }

source/game_logo.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include <memory>            // Para unique_ptr, shared_ptr
 #include "animated_sprite.h" // Para AnimatedSprite
@@ -61,8 +62,8 @@ private:
     std::unique_ptr<Sprite> arcade_edition_sprite_; // Sprite con los graficos de "Arcade Edition"
 
     // Variables
-    int x_;                         // Posición donde dibujar el logo
+    float x_;                         // Posición donde dibujar el logo
-    int y_;                         // Posición donde dibujar el logo
+    float y_;                         // Posición donde dibujar el logo
     float zoom_ = 1.0f;             // Zoom aplicado al texto "ARCADE EDITION"
     int post_finished_counter_ = 1; // Contador final una vez terminada las animaciones de los logos
 

source/global_events.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include <SDL3/SDL_events.h>
 

source/global_inputs.cpp

@@ -10,7 +10,7 @@
 #include "notifier.h"        // Para Notifier
 #include "on_screen_help.h"  // Para OnScreenHelp
 #include "options.h"         // Para Options, options, OptionsGame, OptionsV...
-#include "screen.h"          // Para Screen, ScreenVideoMode
+#include "screen.h"          // Para Screen
 #include "section.h"         // Para Name, name, Options, options, AttractMode
 #include "utils.h"           // Para boolToOnOff
 
@@ -79,7 +79,7 @@ namespace globalInputs
     {
         options.video.integer_scale = !options.video.integer_scale;
         SDL_SetRenderLogicalPresentation(Screen::get()->getRenderer(), param.game.width, param.game.height, options.video.integer_scale ? SDL_LOGICAL_PRESENTATION_INTEGER_SCALE : SDL_LOGICAL_PRESENTATION_LETTERBOX);
-        Screen::get()->setVideoMode();
+        Screen::get()->setFullscreenMode();
         Notifier::get()->show({lang::getText(134) + " " + boolToOnOff(options.video.integer_scale)});
     }
 
@@ -180,9 +180,9 @@ namespace globalInputs
             // Comprueba el teclado para cambiar entre pantalla completa y ventana
             if (Input::get()->checkInput(InputAction::WINDOW_FULLSCREEN, INPUT_DO_NOT_ALLOW_REPEAT, InputDeviceToUse::KEYBOARD))
             {
-                Screen::get()->toggleVideoMode();
+                Screen::get()->toggleFullscreen();
-                const std::string mode = options.video.mode == ScreenVideoMode::WINDOW ? lang::getText(132) : lang::getText(133);
+                const std::string MODE = options.video.fullscreen ? lang::getText(133) : lang::getText(132);
-                Notifier::get()->show({mode});
+                Notifier::get()->show({MODE});
                 return;
             }
 

source/global_inputs.h

@@ -1,3 +1,6 @@
+#pragma once
+#include <SDL3/SDL.h>
+
 namespace globalInputs
 {
     extern int service_pressed_counter;

source/hiscore_table.cpp

@@ -123,7 +123,7 @@ void HiScoreTable::render()
 	background_->render();
 
 	// Establece la ventana del backbuffer
-	view_area_.y = std::max(0, param.game.height - counter_ + 100);
+	view_area_.y = std::max(0.0f, param.game.height - counter_ + 100);
 
 	// Copia el backbuffer al renderizador
 	SDL_RenderTexture(renderer_, backbuffer_, nullptr, &view_area_);

source/hiscore_table.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include <SDL3/SDL_rect.h>	 // Para SDL_FRect
 #include <SDL3/SDL_render.h> // Para SDL_Renderer, SDL_Texture
@@ -43,7 +44,7 @@ private:
 
 	// Variables
 	Uint16 counter_ = 0;			  // Contador
-	Uint32 ticks_;					  // Contador de ticks para ajustar la velocidad del programa
+	Uint64 ticks_;					  // Contador de ticks para ajustar la velocidad del programa
 	SDL_FRect view_area_;			  // Parte de la textura que se muestra en pantalla
 	FadeMode fade_mode_;			  // Modo de fade a utilizar
 	Color background_fade_color_;	  // Color de atenuación del fondo

source/input.cpp

@@ -296,7 +296,7 @@ std::string Input::getControllerName(int controller_index) const { return num_ga
 int Input::getNumControllers() const { return num_gamepads_; }
 
 // Obtiene el indice del controlador a partir de un event.id
-int Input::getJoyIndex(int id) const
+int Input::getJoyIndex(SDL_JoystickID id) const
 {
 	for (int i = 0; i < num_joysticks_; ++i)
 	{

source/input.h

@@ -148,7 +148,7 @@ public:
 	std::string getControllerName(int controller_index) const;
 
 	// Obtiene el indice del controlador a partir de un event.id
-	int getJoyIndex(int id) const;
+	int getJoyIndex(SDL_JoystickID id) const;
 
 	// Muestra por consola los controles asignados
 	void printBindings(InputDeviceToUse device = InputDeviceToUse::KEYBOARD, int controller_index = 0) const;

source/instructions.cpp

@@ -78,7 +78,7 @@ void Instructions::iniSprites()
 	for (int i = 0; i < (int)item_textures_.size(); ++i)
 	{
 		auto sprite = std::make_unique<Sprite>(item_textures_[i], 0, 0, param.game.item_size, param.game.item_size);
-		sprite->setPosition((SDL_Point){sprite_pos_.x, sprite_pos_.y + ((param.game.item_size + item_space_) * i)});
+		sprite->setPosition((SDL_FPoint){sprite_pos_.x, sprite_pos_.y + ((param.game.item_size + item_space_) * i)});
 		sprites_.push_back(std::move(sprite));
 	}
 }
@@ -302,44 +302,44 @@ std::vector<Line> Instructions::initializeLines(int height)
 // Método para mover las líneas con suavizado
 bool Instructions::moveLines(std::vector<Line> &lines, int width, float duration, Uint32 startDelay)
 {
-	Uint32 currentTime = SDL_GetTicks();
+	Uint32 current_time = SDL_GetTicks();
-	bool allLinesOffScreen = true;
+	bool all_lines_off_screen = true;
 
 	for (auto &line : lines)
 	{
 		// Establecer startTime en el primer cuadro de animación
 		if (line.startTime == 0)
 		{
-			line.startTime = currentTime + line.y * startDelay;
+			line.startTime = current_time + line.y * startDelay;
 		}
 
-		float elapsedTime = (currentTime - line.startTime) / 1000.0f; // Convertir a segundos
+		float elapsed_time = (current_time - line.startTime) / 1000.0f; // Convertir a segundos
-		if (elapsedTime < 0)
+		if (elapsed_time < 0)
 		{
-			allLinesOffScreen = false; // Si aún no se debe mover esta línea, no están todas fuera de pantalla
+			all_lines_off_screen = false; // Si aún no se debe mover esta línea, no están todas fuera de pantalla
 			continue;
 		}
-		if (elapsedTime >= duration)
+		if (elapsed_time >= duration)
 		{
 			continue; // Si la línea ha salido de los límites, no la muevas más
 		}
 
-		float t = elapsedTime / duration;
+		float t = elapsed_time / duration;
-		float smoothFactor = easeInOutQuint(t);
+		float smooth_factor = easeInOutQuint(t);
-		line.x = line.direction * smoothFactor * width;
+		line.x = line.direction * smooth_factor * width;
-		allLinesOffScreen = false; // Si alguna línea aún se está moviendo, no están todas fuera de pantalla
+		all_lines_off_screen = false; // Si alguna línea aún se está moviendo, no están todas fuera de pantalla
 	}
 
-	return allLinesOffScreen;
+	return all_lines_off_screen;
 }
 
 // Método para renderizar las líneas
 void Instructions::renderLines(SDL_Renderer *renderer, SDL_Texture *texture, const std::vector<Line> &lines)
 {
-	for (const auto &line : lines)
+	for (const auto &LINE : lines)
 	{
-		SDL_FRect srcRect = {0, line.y, 320, 1};
+		SDL_FRect srcRect = {0, static_cast<float>(LINE.y), 320, 1};
-		SDL_FRect dstRect = {static_cast<int>(line.x), line.y, 320, 1};
+		SDL_FRect dstRect = {static_cast<float>(LINE.x), static_cast<float>(LINE.y), 320, 1};
 		SDL_RenderTexture(renderer, texture, &srcRect, &dstRect);
 	}
 }
@@ -357,7 +357,7 @@ void Instructions::updateMusic()
 void Instructions::updateBackbuffer()
 {
 	// Establece la ventana del backbuffer
-	view_.y = std::max(0, param.game.height - counter_ + 100);
+	view_.y = std::max(0.0f, param.game.height - counter_ + 100);
 
 	// Verifica si view_.y == 0 y gestiona el temporizador
 	if (view_.y == 0)

source/instructions.h

@@ -1,6 +1,7 @@
 #pragma once
+#include <SDL3/SDL.h>
 
-#include <SDL3/SDL_rect.h>	 // Para SDL_Point, SDL_FRect
+#include <SDL3/SDL_rect.h>	 // Para SDL_FPoint, SDL_FRect
 #include <SDL3/SDL_render.h> // Para SDL_Texture, SDL_Renderer
 #include <SDL3/SDL_stdinc.h> // Para Uint32
 #include <memory>			 // Para unique_ptr, shared_ptr
@@ -54,10 +55,10 @@ private:
 
 	// Variables
 	int counter_ = 0;					 // Contador para manejar el progreso en la pantalla de instrucciones
-	Uint32 ticks_ = 0;					 // Contador de ticks para ajustar la velocidad del programa
+	Uint64 ticks_ = 0;					 // Contador de ticks para ajustar la velocidad del programa
 	SDL_FRect view_;					 // Vista del backbuffer que se va a mostrar por pantalla
-	SDL_Point sprite_pos_ = {0, 0};		 // Posición del primer sprite en la lista
+	SDL_FPoint sprite_pos_ = {0, 0};	 // Posición del primer sprite en la lista
-	int item_space_ = 2;				 // Espacio entre los items en pantalla
+	float item_space_ = 2.0;			 // Espacio entre los items en pantalla
 	std::vector<Line> lines_;			 // Vector que contiene las líneas animadas en la pantalla
 	bool all_lines_off_screen_ = false;	 // Indica si todas las líneas han salido de la pantalla
 	Uint32 start_delay_time_ = 0;		 // Tiempo de inicio del retraso para mover las líneas

source/intro.cpp

@@ -308,10 +308,10 @@ void Intro::initSprites()
 
 	// Constantes
 	auto texture = Resource::get()->getTexture(TEXTURE_LIST.front());
-	const int SPRITE_WIDTH = texture->getWidth();
+	const float SPRITE_WIDTH = texture->getWidth();
-	const int SPRITE_HEIGHT = texture->getHeight();
+	const float SPRITE_HEIGHT = texture->getHeight();
-	const int X_DEST = param.game.game_area.center_x - SPRITE_WIDTH / 2;
+	const float X_DEST = param.game.game_area.center_x - SPRITE_WIDTH / 2;
-	const int Y_DEST = param.game.game_area.first_quarter_y - (SPRITE_HEIGHT / 4);
+	const float Y_DEST = param.game.game_area.first_quarter_y - (SPRITE_HEIGHT / 4);
 
 	// Inicializa los sprites con las imagenes
 	constexpr int TOTAL_SPRITES = 6;
@@ -333,11 +333,11 @@ void Intro::initSprites()
 	sprites_.at(5)->addPath(X_DEST, -SPRITE_WIDTH, PathType::HORIZONTAL, Y_DEST, 80, easeInElastic, 0);
 
 	// Constantes
-	const int BORDER = 4;
+	const float BORDER = 4;
-	const int SHADOW_SPRITE_WIDTH = SPRITE_WIDTH + BORDER;
+	const float SHADOW_SPRITE_WIDTH = SPRITE_WIDTH + BORDER;
-	const int SHADOW_SPRITE_HEIGHT = SPRITE_HEIGHT + BORDER;
+	const float SHADOW_SPRITE_HEIGHT = SPRITE_HEIGHT + BORDER;
-	const int S_X_DEST = X_DEST - BORDER / 2;
+	const float S_X_DEST = X_DEST - BORDER / 2;
-	const int S_Y_DEST = Y_DEST - BORDER / 2;
+	const float S_Y_DEST = Y_DEST - BORDER / 2;
 
 	// Crea las texturas para las imágenes traseras
 	std::vector<std::shared_ptr<Texture>> shadow_textures;

source/intro.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include <SDL3/SDL_stdinc.h> // Para Uint32, Uint8
 #include <memory>			 // Para unique_ptr
@@ -35,7 +36,7 @@ private:
 	std::unique_ptr<TiledBG> tiled_bg_;
 
 	// Variables
-	Uint32 ticks_ = 0;									  // Contador de ticks para ajustar la velocidad del programa
+	Uint64 ticks_ = 0;									  // Contador de ticks para ajustar la velocidad del programa
 	int scene_ = 0;										  // Indica que escena está activa
 	IntroState state_ = IntroState::SCENES;				  // Estado
 	IntroPostState post_state_ = IntroPostState::STOP_BG; // Estado

source/item.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include <SDL3/SDL_rect.h>   // Para SDL_FRect
 #include <SDL3/SDL_stdinc.h> // Para Uint16

source/jail_audio.cpp

@@ -89,7 +89,7 @@ Uint32 JA_UpdateCallback(void *userdata, SDL_TimerID timerID, Uint32 interval)
     {
         if (current_music->times != 0)
         {
-            if (SDL_GetAudioStreamAvailable(current_music->stream) < (current_music->length / 2))
+            if (SDL_GetAudioStreamAvailable(current_music->stream) < static_cast<int>(current_music->length / 2))
                 SDL_PutAudioStreamData(current_music->stream, current_music->buffer, current_music->length);
             if (current_music->times > 0)
                 current_music->times--;
@@ -108,7 +108,7 @@ Uint32 JA_UpdateCallback(void *userdata, SDL_TimerID timerID, Uint32 interval)
             {
                 if (channels[i].times != 0)
                 {
-                    if (SDL_GetAudioStreamAvailable(channels[i].stream) < (channels[i].sound->length / 2))
+                    if (SDL_GetAudioStreamAvailable(channels[i].stream) < static_cast<int>(channels[i].sound->length / 2))
                         SDL_PutAudioStreamData(channels[i].stream, channels[i].sound->buffer, channels[i].sound->length);
                     if (channels[i].times > 0)
                         channels[i].times--;

source/jail_shader.cpp

@@ -1,5 +1,5 @@
 #include "jail_shader.h"
-#include <SDL3/SDL_rect.h>   // Para SDL_Point
+#include <SDL3/SDL_rect.h>   // Para SDL_FPoint
 #include <SDL3/SDL_stdinc.h> // Para SDL_bool
 #include <cstring>           // Para strncmp
 #include <iostream>          // Para basic_ostream, operator<<, endl, cout
@@ -25,7 +25,7 @@ namespace shader
     GLuint programId = 0;
     SDL_Texture *backBuffer = nullptr;
     SDL_Point win_size = {320 * 4, 256 * 4};
-    SDL_Point tex_size = {320, 256};
+    SDL_FPoint tex_size = {320, 256};
     bool usingOpenGL = false;
 
 #ifndef __APPLE__
@@ -157,12 +157,13 @@ namespace shader
         shader::backBuffer = texturaBackBuffer;
         SDL_GetWindowSize(ventana, &win_size.x, &win_size.y);
 
-        int acceso;
+        //int acceso;
-        SDL_QueryTexture(texturaBackBuffer, nullptr, &acceso, &tex_size.x, &tex_size.y);
+        SDL_GetTextureSize(texturaBackBuffer, &tex_size.x, &tex_size.y);
-        if (acceso != SDL_TEXTUREACCESS_TARGET)
+        // SDL_QueryTexture(texturaBackBuffer, nullptr, &acceso, &tex_size.x, &tex_size.y);
+        /*if (acceso != SDL_TEXTUREACCESS_TARGET)
         {
             throw std::runtime_error("ERROR FATAL: La textura debe tener definido SDL_TEXTUREACCESS_TARGET.");
-        }
+        }*/
 
         const auto RENDER_NAME = SDL_GetRendererName(renderer);
 

source/jail_shader.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include <SDL3/SDL_render.h> // Para SDL_Texture
 #include <SDL3/SDL_video.h>  // Para SDL_Window

source/lang.cpp

@@ -23,9 +23,9 @@ namespace lang
             while (std::getline(rfile, line))
             {
                 // Almacena solo las lineas que no empiezan por # o no esten vacias
-                const bool test1 = line.substr(0, 1) != "#";
+                const bool TEST1 = line.substr(0, 1) != "#";
-                const bool test2 = !line.empty();
+                const bool TEST2 = !line.empty();
-                if (test1 && test2)
+                if (TEST1 && TEST2)
                 {
                     texts.push_back(line);
                 }

source/lang.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include <string> // Para string
 

source/logo.cpp

@@ -24,7 +24,11 @@ Logo::Logo()
 	section::name = section::Name::LOGO;
 	dest_.x = param.game.game_area.center_x - jail_texture_->getWidth() / 2;
 	dest_.y = param.game.game_area.center_y - jail_texture_->getHeight() / 2;
-	since_sprite_->setPosition({(param.game.width - since_texture_->getWidth()) / 2, 83 + jail_texture_->getHeight() + 5, since_texture_->getWidth(), since_texture_->getHeight()});
+	since_sprite_->setPosition(SDL_FRect{
+		static_cast<float>((param.game.width - since_texture_->getWidth()) / 2),
+		static_cast<float>(83 + jail_texture_->getHeight() + 5),
+		static_cast<float>(since_texture_->getWidth()),
+		static_cast<float>(since_texture_->getHeight())});
 	since_sprite_->setY(dest_.y + jail_texture_->getHeight() + 5);
 	since_sprite_->setSpriteClip(0, 0, since_texture_->getWidth(), since_texture_->getHeight());
 	since_texture_->setColor(0x00, 0x00, 0x00);
@@ -181,7 +185,7 @@ void Logo::render()
 void Logo::run()
 {
 	// Detiene la música
-	JA_FadeOutMusic(300);
+	/*JA_FadeOutMusic(300);*/
 
 	while (section::name == section::Name::LOGO)
 	{

source/logo.h

@@ -1,6 +1,7 @@
 #pragma once
+#include <SDL3/SDL.h>
 
-#include <SDL3/SDL_rect.h>	 // Para SDL_Point
+#include <SDL3/SDL_rect.h>	 // Para SDL_FPoint
 #include <SDL3/SDL_stdinc.h> // Para Uint32
 #include <memory>			 // Para shared_ptr, unique_ptr
 #include <vector>			 // Para vector
@@ -36,8 +37,8 @@ private:
 	// Variables
 	std::vector<Color> color_; // Vector con los colores para el fade
 	int counter_ = 0;		   // Contador
-	Uint32 ticks_ = 0;		   // Contador de ticks para ajustar la velocidad del programa
+	Uint64 ticks_ = 0;		   // Contador de ticks para ajustar la velocidad del programa
-	SDL_Point dest_;		   // Posición X donde dibujar el logo
+	SDL_FPoint dest_;		   // Posición X donde dibujar el logo
 
 	// Actualiza las variables
 	void update();

source/manage_hiscore_table.cpp

@@ -1,6 +1,6 @@
 #include "manage_hiscore_table.h"
 #include <SDL3/SDL_error.h> // Para SDL_GetError
-#include <SDL3/SDL_rwops.h> // Para SDL_RWread, SDL_RWwrite, SDL_RWFromFile
+#include <SDL3/SDL.h> // Para SDL_RWread, SDL_WriteIO, SDL_RWFromFile
 #include <algorithm>        // Para find_if, sort
 #include <iostream>         // Para basic_ostream, operator<<, cout, endl
 #include <iterator>         // Para distance
@@ -70,9 +70,9 @@ void ManageHiScoreTable::sort()
     struct
     {
         bool operator()(const HiScoreEntry &a, const HiScoreEntry &b) const { return a.score > b.score; }
-    } scoreDescendingComparator;
+    } score_descending_comparator;
 
-    std::sort(table_.begin(), table_.end(), scoreDescendingComparator);
+    std::sort(table_.begin(), table_.end(), score_descending_comparator);
 }
 
 // Carga la tabla desde un fichero
@@ -80,44 +80,44 @@ bool ManageHiScoreTable::loadFromFile(const std::string &file_path)
 {
     clear();
     auto success = true;
-    auto file = SDL_RWFromFile(file_path.c_str(), "rb");
+    auto file = SDL_IOFromFile(file_path.c_str(), "rb");
 
     if (file)
     {
         table_.clear(); // Limpia la tabla actual
 
         // Lee el número de entradas en la tabla
-        int tableSize = 0;
+        int table_size = 0;
-        SDL_RWread(file, &tableSize, sizeof(int), 1);
+        SDL_ReadIO(file, &table_size, sizeof(int));
 
         // Lee los datos de cada entrada
-        for (int i = 0; i < tableSize; ++i)
+        for (int i = 0; i < table_size; ++i)
         {
             HiScoreEntry entry;
 
             // Lee la puntuación
-            SDL_RWread(file, &entry.score, sizeof(int), 1);
+            SDL_ReadIO(file, &entry.score, sizeof(int));
 
             // Lee el tamaño del nombre y luego el nombre
-            int nameSize = 0;
+            int name_size = 0;
-            SDL_RWread(file, &nameSize, sizeof(int), 1);
+            SDL_ReadIO(file, &name_size, sizeof(int));
 
-            std::vector<char> nameBuffer(nameSize + 1);
+            std::vector<char> name_buffer(name_size + 1);
-            SDL_RWread(file, nameBuffer.data(), nameSize, 1);
+            SDL_ReadIO(file, name_buffer.data(), name_size);
-            nameBuffer[nameSize] = '\0'; // Asegurar el fin de la cadena
+            name_buffer[name_size] = '\0'; // Asegurar el fin de la cadena
-            entry.name = std::string(nameBuffer.data());
+            entry.name = std::string(name_buffer.data());
 
             // Lee el valor de one_credit_complete
-            int occValue = 0;
+            int occ_value = 0;
-            SDL_RWread(file, &occValue, sizeof(int), 1);
+            SDL_ReadIO(file, &occ_value, sizeof(int));
-            entry.one_credit_complete = (occValue != 0);
+            entry.one_credit_complete = (occ_value != 0);
 
             // Añade la entrada a la tabla
             table_.push_back(entry);
         }
 
         std::cout << "Reading file: " << getFileName(file_path) << std::endl;
-        SDL_RWclose(file);
+        SDL_CloseIO(file);
     }
     else
     {
@@ -131,34 +131,34 @@ bool ManageHiScoreTable::loadFromFile(const std::string &file_path)
 bool ManageHiScoreTable::saveToFile(const std::string &file_path)
 {
     auto success = true;
-    auto file = SDL_RWFromFile(file_path.c_str(), "w+b");
+    auto file = SDL_IOFromFile(file_path.c_str(), "w+b");
 
     if (file)
     {
         // Guarda el número de entradas en la tabla
-        int tableSize = static_cast<int>(table_.size());
+        int table_size = static_cast<int>(table_.size());
-        SDL_RWwrite(file, &tableSize, sizeof(int), 1);
+        SDL_WriteIO(file, &table_size, sizeof(int));
 
         // Guarda los datos de cada entrada
-        for (int i = 0; i < tableSize; ++i)
+        for (int i = 0; i < table_size; ++i)
         {
             const HiScoreEntry &entry = table_.at(i);
 
             // Guarda la puntuación
-            SDL_RWwrite(file, &entry.score, sizeof(int), 1);
+            SDL_WriteIO(file, &entry.score, sizeof(int));
 
             // Guarda el tamaño del nombre y luego el nombre
-            int nameSize = static_cast<int>(entry.name.size());
+            int name_size = static_cast<int>(entry.name.size());
-            SDL_RWwrite(file, &nameSize, sizeof(int), 1);
+            SDL_WriteIO(file, &name_size, sizeof(int));
-            SDL_RWwrite(file, entry.name.c_str(), nameSize, 1);
+            SDL_WriteIO(file, entry.name.c_str(), name_size);
 
             // Guarda el valor de one_credit_complete como un entero (0 o 1)
-            int occValue = entry.one_credit_complete ? 1 : 0;
+            int occ_value = entry.one_credit_complete ? 1 : 0;
-            SDL_RWwrite(file, &occValue, sizeof(int), 1);
+            SDL_WriteIO(file, &occ_value, sizeof(int));
         }
 
         std::cout << "Writing file: " << getFileName(file_path) << std::endl;
-        SDL_RWclose(file);
+        SDL_CloseIO(file);
     }
     else
     {

source/manage_hiscore_table.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <SDL3/SDL.h>
 #include <string> // Para string
 #include <vector> // Para vector
 

source/mouse.cpp

@@ -10,14 +10,12 @@ namespace Mouse
 
     void handleEvent(const SDL_Event &event)
     {
-        if (event.type == SDL_MOUSEMOTION)
+        if (event.type == SDL_EVENT_MOUSE_MOTION)
         {
             last_mouse_move_time = SDL_GetTicks();
             if (!cursor_visible)
             {
-#ifndef ARCADE
+                SDL_ShowCursor();
-                SDL_ShowCursor(SDL_ENABLE);
-#endif
                 cursor_visible = true;
             }
         }
@@ -28,7 +26,7 @@ namespace Mouse
         Uint32 current_time = SDL_GetTicks();
         if (cursor_visible && (current_time - last_mouse_move_time > cursor_hide_time))
         {
-            SDL_ShowCursor(SDL_DISABLE);
+            SDL_HideCursor();
             cursor_visible = false;
         }
     }

source/mouse.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include <SDL3/SDL_events.h> // Para SDL_Event
 #include <SDL3/SDL_stdinc.h> // Para Uint32

source/moving_sprite.cpp

@@ -2,7 +2,7 @@
 #include "texture.h" // Para Texture
 
 // Constructor
-MovingSprite::MovingSprite(std::shared_ptr<Texture> texture, SDL_FRect pos, Rotate rotate, float zoom_w, float zoom_h, SDL_RendererFlip flip)
+MovingSprite::MovingSprite(std::shared_ptr<Texture> texture, SDL_FRect pos, Rotate rotate, float zoom_w, float zoom_h, SDL_FlipMode flip)
 	: Sprite(texture, pos),
 	  x_(pos.x),
 	  y_(pos.y),

source/moving_sprite.h

@@ -1,7 +1,8 @@
 #pragma once
+#include <SDL3/SDL.h>
 
-#include <SDL3/SDL_rect.h>   // Para SDL_FRect, SDL_Point
+#include <SDL3/SDL_rect.h>   // Para SDL_FRect, SDL_FPoint
-#include <SDL3/SDL_render.h> // Para SDL_RendererFlip
+#include <SDL3/SDL_render.h> // Para SDL_FlipMode
 #include <memory>            // Para shared_ptr
 #include <algorithm>
 #include "sprite.h" // Para Sprite
@@ -13,19 +14,19 @@ class MovingSprite : public Sprite
 public:
     struct Rotate
     {
-        bool enabled;     // Indica si ha de rotar
+        bool enabled;      // Indica si ha de rotar
-        int counter;      // Contador
+        int counter;       // Contador
-        int speed;        // Velocidad de giro
+        int speed;         // Velocidad de giro
-        double angle;     // Angulo para dibujarlo
+        double angle;      // Angulo para dibujarlo
-        float amount;     // Cantidad de grados a girar en cada iteración
+        float amount;      // Cantidad de grados a girar en cada iteración
-        SDL_Point center; // Centro de rotación
+        SDL_FPoint center; // Centro de rotación
 
-        Rotate() : enabled(false), counter(0), speed(1), angle(0.0), amount(0.0f), center({0, 0}) {}
+        Rotate() : enabled(false), counter(0), speed(1), angle(0.0), amount(0.0f), center({0.0f, 0.0f}) {}
     };
 
 protected:
-    float x_; // Posición en el eje X
+    float x_ = 0.0f; // Posición en el eje X
-    float y_; // Posición en el eje Y
+    float y_ = 0.0f; // Posición en el eje Y
 
     float vx_ = 0.0f; // Velocidad en el eje X. Cantidad de pixeles a desplazarse
     float vy_ = 0.0f; // Velocidad en el eje Y. Cantidad de pixeles a desplazarse
@@ -33,10 +34,10 @@ protected:
     float ax_ = 0.0f; // Aceleración en el eje X. Variación de la velocidad
     float ay_ = 0.0f; // Aceleración en el eje Y. Variación de la velocidad
 
-    Rotate rotate_;         // Variables usada para controlar la rotación del sprite
+    Rotate rotate_;     // Variables usada para controlar la rotación del sprite
-    float zoom_w_;          // Zoom aplicado a la anchura
+    float zoom_w_;      // Zoom aplicado a la anchura
-    float zoom_h_;          // Zoom aplicado a la altura
+    float zoom_h_;      // Zoom aplicado a la altura
-    SDL_RendererFlip flip_; // Indica como se voltea el sprite
+    SDL_FlipMode flip_; // Indica como se voltea el sprite
 
     // Incrementa el valor del ángulo
     void updateAngle() { rotate_.angle += rotate_.amount; }
@@ -49,7 +50,7 @@ protected:
 
 public:
     // Constructor
-    MovingSprite(std::shared_ptr<Texture> texture, SDL_FRect pos, MovingSprite::Rotate rotate, float zoom_w, float zoom_h, SDL_RendererFlip flip);
+    MovingSprite(std::shared_ptr<Texture> texture, SDL_FRect pos, MovingSprite::Rotate rotate, float zoom_w, float zoom_h, SDL_FlipMode flip);
     MovingSprite(std::shared_ptr<Texture> texture, SDL_FRect pos);
     explicit MovingSprite(std::shared_ptr<Texture> texture);
 
@@ -88,7 +89,7 @@ public:
 
     // Establece el valor de la variable
     void setAngle(double value) { rotate_.angle = value; }
-    void setRotatingCenter(SDL_Point point) { rotate_.center = point; }
+    void setRotatingCenter(SDL_FPoint point) { rotate_.center = point; }
 
     // Activa o desactiva el efecto de rotación
     void setRotate(bool enable);
@@ -101,13 +102,13 @@ public:
     void switchRotate() { rotate_.amount *= -1; }
 
     // Establece el valor de la variable
-    void setFlip(SDL_RendererFlip flip) { flip_ = flip; }
+    void setFlip(SDL_FlipMode flip) { flip_ = flip; }
 
     // Gira el sprite horizontalmente
     void flip() { flip_ = (flip_ == SDL_FLIP_HORIZONTAL) ? SDL_FLIP_NONE : SDL_FLIP_HORIZONTAL; }
 
     // Obtiene el valor de la variable
-    SDL_RendererFlip getFlip() { return flip_; }
+    SDL_FlipMode getFlip() { return flip_; }
 
     // Establece la posición y_ el tamaño del objeto
     void setPos(SDL_FRect rect);

source/notifier.cpp

@@ -181,60 +181,60 @@ void Notifier::show(std::vector<std::string> texts, int icon, const std::string
     }
 
     // Inicializa variables
-    constexpr int icon_size = 16;
+    constexpr int ICON_SIZE = 16;
-    constexpr int padding_out = 1;
+    constexpr int PADDING_OUT = 1;
-    const auto padding_in_h = text_->getCharacterSize();
+    const float PADDING_IN_H = text_->getCharacterSize();
-    const auto padding_in_v = text_->getCharacterSize() / 2;
+    const float PADDING_IN_V = text_->getCharacterSize() / 2;
-    const int icon_space = icon >= 0 ? icon_size + padding_in_h : 0;
+    const int ICON_SPACE = icon >= 0 ? ICON_SIZE + PADDING_IN_H : 0;
-    const int width = text_->lenght(longest) + (padding_in_h * 2) + icon_space;
+    const float WIDTH = text_->lenght(longest) + (PADDING_IN_H * 2) + ICON_SPACE;
-    const int height = (text_->getCharacterSize() * texts.size()) + (padding_in_v * 2);
+    const float HEIGHT = (text_->getCharacterSize() * texts.size()) + (PADDING_IN_V * 2);
-    const auto shape = NotificationShape::SQUARED;
+    const auto SHAPE = NotificationShape::SQUARED;
 
     // Posición horizontal
-    auto desp_h = 0;
+    float desp_h = 0;
-    if (param.notification.pos_h == NotifyPosition::LEFT)
+    switch (param.notification.pos_h)
     {
-        desp_h = padding_out;
+    case NotifyPosition::LEFT:
-    }
+        desp_h = PADDING_OUT;
-    else if (param.notification.pos_h == NotifyPosition::MIDDLE)
+        break;
-    {
+
-        desp_h = ((param.game.width / 2) - (width / 2));
+    case NotifyPosition::MIDDLE:
-    }
+        desp_h = ((param.game.width / 2) - (WIDTH / 2));
-    else
+        break;
-    {
+
-        desp_h = param.game.width - width - padding_out;
+    case NotifyPosition::RIGHT:
+        desp_h = param.game.width - WIDTH - PADDING_OUT;
+        break;
+
+    default:
+        desp_h = 0;
+        break;
     }
 
     // Posición vertical
-    const int desp_v = (param.notification.pos_v == NotifyPosition::TOP) ? padding_out : (param.game.height - height - padding_out);
+    const int DESP_V = (param.notification.pos_v == NotifyPosition::TOP) ? PADDING_OUT : (param.game.height - HEIGHT - PADDING_OUT);
 
     // Offset
-    const auto travel_dist = height + padding_out;
+    const auto TRAVEL_DIST = HEIGHT + PADDING_OUT;
-    auto offset = 0;
+    auto OFFSET = notifications_.empty()
-    if (param.notification.pos_v == NotifyPosition::TOP)
+                      ? DESP_V
-    {
+                      : notifications_.back().y + (param.notification.pos_v == NotifyPosition::TOP ? TRAVEL_DIST : -TRAVEL_DIST);
-        offset = !notifications_.empty() ? notifications_.back().y + travel_dist : desp_v;
-    }
-    else
-    {
-        offset = !notifications_.empty() ? notifications_.back().y - travel_dist : desp_v;
-    }
 
     // Crea la notificacion
     Notification n;
 
     // Inicializa variables
     n.code = code;
-    n.y = offset;
+    n.y = OFFSET;
-    n.travel_dist = travel_dist;
+    n.travel_dist = TRAVEL_DIST;
     n.texts = texts;
-    n.shape = shape;
+    n.shape = SHAPE;
-    auto y_pos = offset + (param.notification.pos_v == NotifyPosition::TOP ? -travel_dist : travel_dist);
+    const float POS_Y = OFFSET + (param.notification.pos_v == NotifyPosition::TOP ? -TRAVEL_DIST : TRAVEL_DIST);
-    n.rect = {desp_h, y_pos, width, height};
+    n.rect = {desp_h, POS_Y, WIDTH, HEIGHT};
 
     // Crea la textura
     n.texture = std::make_shared<Texture>(renderer_);
-    n.texture->createBlank(width, height, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET);
+    n.texture->createBlank(WIDTH, HEIGHT, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET);
     n.texture->setBlendMode(SDL_BLENDMODE_BLEND);
 
     // Prepara para dibujar en la textura
@@ -243,22 +243,22 @@ void Notifier::show(std::vector<std::string> texts, int icon, const std::string
     // Dibuja el fondo de la notificación
     SDL_SetRenderDrawColor(renderer_, bg_color_.r, bg_color_.g, bg_color_.b, 255);
     SDL_FRect rect;
-    if (shape == NotificationShape::ROUNDED)
+    if (SHAPE == NotificationShape::ROUNDED)
     {
-        rect = {4, 0, width - (4 * 2), height};
+        rect = {4, 0, WIDTH - (4 * 2), HEIGHT};
         SDL_RenderFillRect(renderer_, &rect);
 
-        rect = {4 / 2, 1, width - 4, height - 2};
+        rect = {4 / 2, 1, WIDTH - 4, HEIGHT - 2};
         SDL_RenderFillRect(renderer_, &rect);
 
-        rect = {1, 4 / 2, width - 2, height - 4};
+        rect = {1, 4 / 2, WIDTH - 2, HEIGHT - 4};
         SDL_RenderFillRect(renderer_, &rect);
 
-        rect = {0, 4, width, height - (4 * 2)};
+        rect = {0, 4, WIDTH, HEIGHT - (4 * 2)};
         SDL_RenderFillRect(renderer_, &rect);
     }
 
-    else if (shape == NotificationShape::SQUARED)
+    else if (SHAPE == NotificationShape::SQUARED)
     {
         SDL_RenderClear(renderer_);
     }
@@ -266,9 +266,13 @@ void Notifier::show(std::vector<std::string> texts, int icon, const std::string
     // Dibuja el icono de la notificación
     if (has_icons_ && icon >= 0 && texts.size() >= 2)
     {
-        auto sp = std::make_unique<Sprite>(icon_texture_, (SDL_FRect){0, 0, icon_size, icon_size});
+        auto sp = std::make_unique<Sprite>(icon_texture_, (SDL_FRect){0, 0, ICON_SIZE, ICON_SIZE});
-        sp->setPosition({padding_in_h, padding_in_v, icon_size, icon_size});
+        sp->setPosition({PADDING_IN_H, PADDING_IN_V, ICON_SIZE, ICON_SIZE});
-        sp->setSpriteClip({icon_size * (icon % 10), icon_size * (icon / 10), icon_size, icon_size});
+        sp->setSpriteClip(SDL_FRect{
+            static_cast<float>(ICON_SIZE * (icon % 10)),
+            static_cast<float>(ICON_SIZE * (icon / 10)),
+            ICON_SIZE,
+            ICON_SIZE});
         sp->render();
     }
 
@@ -277,7 +281,7 @@ void Notifier::show(std::vector<std::string> texts, int icon, const std::string
     int iterator = 0;
     for (const auto &text : texts)
     {
-        text_->writeColored(padding_in_h + icon_space, padding_in_v + iterator * (text_->getCharacterSize() + 1), text, color);
+        text_->writeColored(PADDING_IN_H + ICON_SPACE, PADDING_IN_V + iterator * (text_->getCharacterSize() + 1), text, color);
         ++iterator;
     }
 

source/notifier.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include <SDL3/SDL_rect.h>	 // Para SDL_FRect
 #include <SDL3/SDL_render.h> // Para SDL_Renderer

source/on_screen_help.cpp

@@ -15,8 +15,8 @@ OnScreenHelp *OnScreenHelp::onScreenHelp = nullptr;
 
 // Constantes evaluables en tiempo de compilación
 constexpr int ICONSIZE = 16;
-constexpr SDL_Point PADDING = {8, 8};
+constexpr SDL_FPoint PADDING = {8, 8};
-constexpr SDL_Point DESP = {ICONSIZE + 4, 5};
+constexpr SDL_FPoint DESP = {ICONSIZE + 4, 5};
 
 constexpr SDL_FRect CONTROLLER_UP = {16, 0, ICONSIZE, ICONSIZE};
 constexpr SDL_FRect CONTROLLER_DOWN = {48, 0, ICONSIZE, ICONSIZE};

source/on_screen_help.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include <SDL3/SDL_rect.h>   // Para SDL_FRect
 #include <SDL3/SDL_render.h> // Para SDL_Texture

source/options.cpp

@@ -1,14 +1,14 @@
 #include "options.h"
-#include <SDL3/SDL_gamecontroller.h> // Para SDL_GameControllerButton
+#include <SDL3/SDL.h> // Para SDL_GamepadButton
-#include <algorithm>				 // Para clamp
+#include <algorithm>  // Para clamp
-#include <fstream>					 // Para basic_ostream, operator<<, basi...
+#include <fstream>	  // Para basic_ostream, operator<<, basi...
-#include <iostream>					 // Para cout
+#include <iostream>	  // Para cout
-#include <utility>					 // Para swap
+#include <utility>	  // Para swap
-#include <vector>					 // Para vector
+#include <vector>	  // Para vector
-#include "input.h"					 // Para InputDeviceToUse
+#include "input.h"	  // Para InputDeviceToUse
-#include "lang.h"					 // Para Code
+#include "lang.h"	  // Para Code
-#include "screen.h"					 // Para ScreenVideoMode, ScreenFilter
+#include "screen.h"	  // Para ScreenFilter
-#include "utils.h"					 // Para boolToString, stringToBool, get...
+#include "utils.h"	  // Para boolToString, stringToBool, get...
 
 // Variables
 Options options;
@@ -21,10 +21,10 @@ void initOptions()
 {
 	// Opciones de video
 #ifdef ANBERNIC
-	options.video.mode = ScreenVideoMode::WINDOW;
+	options.video.mode = false;
 	options.video.window.size = 3;
 #else
-	options.video.mode = ScreenVideoMode::WINDOW;
+	options.video.fullscreen = false;
 	options.video.window.zoom = 2;
 #endif
 	options.video.filter = ScreenFilter::NEAREST;
@@ -98,13 +98,6 @@ bool loadOptionsFile(std::string file_path)
 	}
 
 	// Normaliza los valores
-	const bool a = options.video.mode == ScreenVideoMode::WINDOW;
-	const bool b = options.video.mode == ScreenVideoMode::FULLSCREEN;
-	if (!(a || b))
-	{
-		options.video.mode = ScreenVideoMode::WINDOW;
-	}
-
 	options.video.window.zoom = std::clamp(options.video.window.zoom, 1, 4);
 
 	if (options.game.language != lang::Code::en_UK &&
@@ -132,11 +125,10 @@ bool saveOptionsFile(std::string file_path)
 
 	// Opciones de video
 	file << "## VIDEO\n";
-	file << "## video.mode [" << static_cast<int>(ScreenVideoMode::WINDOW) << ": window, " << static_cast<int>(ScreenVideoMode::FULLSCREEN) << ": fullscreen]\n";
 	file << "## video.filter [" << static_cast<int>(ScreenFilter::NEAREST) << ": nearest, " << static_cast<int>(ScreenFilter::LINEAL) << ": lineal]\n";
 	file << "\n";
 
-	file << "video.mode=" << static_cast<int>(options.video.mode) << "\n";
+	file << "video.fullscreen=" << boolToString(options.video.fullscreen) << "\n";
 	file << "video.window.size=" << options.video.window.zoom << "\n";
 	file << "video.filter=" << static_cast<int>(options.video.filter) << "\n";
 	file << "video.v_sync=" << boolToString(options.video.v_sync) << "\n";
@@ -200,7 +192,7 @@ bool setOptions(const std::string &var, const std::string &value)
 	// Opciones de video
 	if (var == "video.mode")
 	{
-		options.video.mode = static_cast<ScreenVideoMode>(std::stoi(value));
+		options.video.fullscreen = stringToBool(value);
 	}
 	else if (var == "video.window.size")
 	{
@@ -282,23 +274,23 @@ bool setOptions(const std::string &var, const std::string &value)
 	}
 	else if (var == "controller.0.button.fire_left")
 	{
-		options.controllers.at(0).buttons.at(0) = static_cast<SDL_GameControllerButton>(std::stoi(value));
+		options.controllers.at(0).buttons.at(0) = static_cast<SDL_GamepadButton>(std::stoi(value));
 	}
 	else if (var == "controller.0.button.fire_center")
 	{
-		options.controllers.at(0).buttons.at(1) = static_cast<SDL_GameControllerButton>(std::stoi(value));
+		options.controllers.at(0).buttons.at(1) = static_cast<SDL_GamepadButton>(std::stoi(value));
 	}
 	else if (var == "controller.0.button.fire_right")
 	{
-		options.controllers.at(0).buttons.at(2) = static_cast<SDL_GameControllerButton>(std::stoi(value));
+		options.controllers.at(0).buttons.at(2) = static_cast<SDL_GamepadButton>(std::stoi(value));
 	}
 	else if (var == "controller.0.button.start")
 	{
-		options.controllers.at(0).buttons.at(3) = static_cast<SDL_GameControllerButton>(std::stoi(value));
+		options.controllers.at(0).buttons.at(3) = static_cast<SDL_GamepadButton>(std::stoi(value));
 	}
 	else if (var == "controller.0.button.service")
 	{
-		options.controllers.at(0).buttons.at(4) = static_cast<SDL_GameControllerButton>(std::stoi(value));
+		options.controllers.at(0).buttons.at(4) = static_cast<SDL_GamepadButton>(std::stoi(value));
 	}
 	else if (var == "controller.1.name")
 	{
@@ -314,23 +306,23 @@ bool setOptions(const std::string &var, const std::string &value)
 	}
 	else if (var == "controller.1.button.fire_left")
 	{
-		options.controllers.at(1).buttons.at(0) = static_cast<SDL_GameControllerButton>(std::stoi(value));
+		options.controllers.at(1).buttons.at(0) = static_cast<SDL_GamepadButton>(std::stoi(value));
 	}
 	else if (var == "controller.1.button.fire_center")
 	{
-		options.controllers.at(1).buttons.at(1) = static_cast<SDL_GameControllerButton>(std::stoi(value));
+		options.controllers.at(1).buttons.at(1) = static_cast<SDL_GamepadButton>(std::stoi(value));
 	}
 	else if (var == "controller.1.button.fire_right")
 	{
-		options.controllers.at(1).buttons.at(2) = static_cast<SDL_GameControllerButton>(std::stoi(value));
+		options.controllers.at(1).buttons.at(2) = static_cast<SDL_GamepadButton>(std::stoi(value));
 	}
 	else if (var == "controller.1.button.start")
 	{
-		options.controllers.at(1).buttons.at(3) = static_cast<SDL_GameControllerButton>(std::stoi(value));
+		options.controllers.at(1).buttons.at(3) = static_cast<SDL_GamepadButton>(std::stoi(value));
 	}
 	else if (var == "controller.1.button.service")
 	{
-		options.controllers.at(1).buttons.at(4) = static_cast<SDL_GameControllerButton>(std::stoi(value));
+		options.controllers.at(1).buttons.at(4) = static_cast<SDL_GamepadButton>(std::stoi(value));
 	}
 
 	// Lineas vacias o que empiezan por comentario

source/options.h

@@ -1,13 +1,12 @@
 #pragma once
 
-#include <SDL3/SDL.h> // Para SDL_CONTROLLER_BUTTON_B, SDL_CO...
+#include <SDL3/SDL.h>				 // Para SDL_CONTROLLER_BUTTON_B, SDL_CO...
 #include <SDL3/SDL_stdinc.h>		 // Para Uint32
 #include <string>					 // Para string
 #include <vector>					 // Para vector
 #include "input.h"					 // Para InputAction, InputDeviceToUse
 #include "manage_hiscore_table.h"	 // Para HiScoreEntry
 enum class ScreenFilter : int;		 // lines 8-8
-enum class ScreenVideoMode : Uint32; // lines 9-9
 namespace lang
 {
 	enum class Code : int;
@@ -22,48 +21,48 @@ enum class GameDifficulty
 };
 
 // Estructura para las opciones de la ventana
-struct OptionsWindow
+struct WindowOptions
 {
 	int zoom = 1;	  // Contiene el valor por el que se multiplica el tamaño de la ventana
 	int max_zoom = 1; // Tamaño máximo para que el tamaño de la ventana no sea mayor que el tamaño de la pantalla
 };
 
 // Estructura con opciones para el video
-struct OptionsVideo
+struct VideoOptions
 {
-	OptionsWindow window; // Opciones para la ventana del programa
+	WindowOptions window; // Opciones para la ventana del programa
-	ScreenVideoMode mode; // Contiene el valor del modo de pantalla completa
 	ScreenFilter filter;  // Filtro usado para el escalado de la imagen
+	bool fullscreen;	  // Contiene el valor del modo de pantalla completa
 	bool v_sync;		  // Indica si se quiere usar vsync o no
 	bool integer_scale;	  // Indica si se va a usar el escalado entero
 	bool shaders;		  // Indica si se van a usar shaders para los filtros de video
 };
 
 // Estructura para las opciones de musica
-struct OptionsMusic
+struct MusicOptions
 {
 	bool enabled; // Indica si la musica suena o no
 	int volume;	  // Volumen al que suena la música
 };
 
 // Estructura para las opciones de sonido
-struct OptionsSound
+struct SoundOptions
 {
 	bool enabled; // Indica si los sonidos suenan o no
 	int volume;	  // Volumen al que suenan los sonidos
 };
 
 // Estructura para las opciones de audio
-struct OptionsAudio
+struct AudioOptions
 {
-	OptionsMusic music; // Opciones para la música
+	MusicOptions music; // Opciones para la música
-	OptionsSound sound; // Opciones para los efectos de sonido
+	SoundOptions sound; // Opciones para los efectos de sonido
 	bool enabled;		// Indica si el audio está activo o no
 	int volume;			// Volumen al que suenan el audio
 };
 
 // Estructura para las opciones del juego
-struct OptionsGame
+struct GameOptions
 {
 	GameDifficulty difficulty;						 // Dificultad del juego
 	lang::Code language;							 // Idioma usado en el juego
@@ -80,35 +79,36 @@ struct OptionsGame
 };
 
 // Estructura para los controles del juego
-struct OptionsController
+struct GamepadOptions
 {
-	int index;									   // Indice en el vector de mandos
+	int index;								// Indice en el vector de mandos
-	int player_id;								   // Jugador asociado al mando
+	int player_id;							// Jugador asociado al mando
-	InputDeviceToUse type;						   // Indica si se utilizará teclado o mando o ambos
+	InputDeviceToUse type;					// Indica si se utilizará teclado o mando o ambos
-	std::string name;							   // Nombre del dispositivo
+	std::string name;						// Nombre del dispositivo
-	bool plugged;								   // Indica si el mando se encuentra conectado
+	bool plugged;							// Indica si el mando se encuentra conectado
-	std::vector<InputAction> inputs;			   // Listado de inputs
+	std::vector<InputAction> inputs;		// Listado de inputs
-	std::vector<SDL_GameControllerButton> buttons; // Listado de botones asignados a cada input
+	std::vector<SDL_GamepadButton> buttons; // Listado de botones asignados a cada input
 
 	// Constructor por defecto
-	OptionsController()
+	GamepadOptions()
 		: index(-1), player_id(-1), type(InputDeviceToUse::CONTROLLER), name(""), plugged(false),
 		  inputs{InputAction::FIRE_LEFT, InputAction::FIRE_CENTER, InputAction::FIRE_RIGHT, InputAction::START, InputAction::SERVICE},
-		  buttons{SDL_CONTROLLER_BUTTON_X, SDL_CONTROLLER_BUTTON_Y, SDL_CONTROLLER_BUTTON_B, SDL_CONTROLLER_BUTTON_START, SDL_CONTROLLER_BUTTON_BACK} {}
+		  buttons{SDL_GAMEPAD_BUTTON_WEST, SDL_GAMEPAD_BUTTON_NORTH, SDL_GAMEPAD_BUTTON_EAST, SDL_GAMEPAD_BUTTON_START, SDL_GAMEPAD_BUTTON_BACK} {}
 };
 
 // Estructura con todas las opciones de configuración del programa
 struct Options
 {
-	OptionsGame game;							// Opciones para el propio juego
+	GameOptions game;						 // Opciones para el propio juego
-	OptionsVideo video;							// Opciones relativas a la clase screen
+	VideoOptions video;						 // Opciones relativas a la clase screen
-	OptionsAudio audio;							// Opciones para el audio
+	AudioOptions audio;						 // Opciones para el audio
-	std::vector<OptionsController> controllers; // Opciones con las asignaciones del mando para cada jugador
+	std::vector<GamepadOptions> controllers; // Opciones con las asignaciones del mando para cada jugador
 };
 
 // Variables
 extern Options options;
 
+// Inicializa las opciones del programa
 void initOptions();
 
 // Carga el fichero de configuración

source/param.cpp

@@ -360,7 +360,7 @@ void precalculateZones()
 	param.game.play_area.third_quarter_y = param.game.play_area.rect.h / 4 * 3;
 
 	// gameArea
-	param.game.game_area.rect = {0, 0, param.game.width, param.game.height};
+	param.game.game_area.rect = {0, 0, static_cast<float>(param.game.width), static_cast<float>(param.game.height)};
 	param.game.game_area.center_x = param.game.game_area.rect.w / 2;
 	param.game.game_area.first_quarter_x = param.game.game_area.rect.w / 4;
 	param.game.game_area.third_quarter_x = param.game.game_area.rect.w / 4 * 3;

source/param.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include <SDL3/SDL_rect.h>   // Para SDL_FRect
 #include <SDL3/SDL_stdinc.h> // Para Uint32
@@ -9,11 +10,11 @@
 // param.game
 struct ParamGame
 {
-    int width;              // Ancho de la resolucion nativa del juego
+    float width;              // Ancho de la resolucion nativa del juego
-    int height;             // Alto de la resolucion nativa del juego
+    float height;             // Alto de la resolucion nativa del juego
-    int item_size;          // Tamaño de los items del juego
+    float item_size;          // Tamaño de los items del juego
-    int coffee_machine_w;   // Ancho de la máquina de café
+    float coffee_machine_w;   // Ancho de la máquina de café
-    int coffee_machine_h;   // Alto de la máquina de café
+    float coffee_machine_h;   // Alto de la máquina de café
     Zone play_area;         // Rectangulo con la posición de la zona de juego
     Zone game_area;         // Rectangulo con las dimensiones del juego
     int enter_name_seconds; // Duración en segundos para introducir el nombre al finalizar la partida
@@ -23,12 +24,12 @@ struct ParamGame
 // param.fade
 struct ParamFade
 {
-    int num_squares_width;    // Cantidad total de cuadraditos en horizontal para el FadeType::RANDOM_SQUARE
+    float num_squares_width;    // Cantidad total de cuadraditos en horizontal para el FadeType::RANDOM_SQUARE
-    int num_squares_height;   // Cantidad total de cuadraditos en vertical para el FadeType::RANDOM_SQUARE
+    float num_squares_height;   // Cantidad total de cuadraditos en vertical para el FadeType::RANDOM_SQUARE
     int random_squares_delay; // Duración entre cada pintado de cuadrados
     int random_squares_mult;  // Cantidad de cuadrados que se pintaran cada vez
     int post_duration;        // Duración final del fade
-    int venetian_size;        // Altura de los rectangulos para FadeType::VENETIAN
+    float venetian_size;        // Altura de los rectangulos para FadeType::VENETIAN
 };
 
 // param.title

source/path_sprite.cpp

@@ -5,9 +5,9 @@
 #include <utility>	  // Para move
 
 // Devuelve un vector con los puntos que conforman la ruta
-std::vector<SDL_Point> createPath(int start, int end, PathType type, int fixed_pos, int steps, const std::function<double(double)> &easingFunction)
+std::vector<SDL_FPoint> createPath(float start, float end, PathType type, float fixed_pos, int steps, const std::function<double(double)> &easingFunction)
 {
-	std::vector<SDL_Point> v;
+	std::vector<SDL_FPoint> v;
 	v.reserve(steps);
 
 	for (int i = 0; i < steps; ++i)
@@ -23,10 +23,10 @@ std::vector<SDL_Point> createPath(int start, int end, PathType type, int fixed_p
 		switch (type)
 		{
 		case PathType::HORIZONTAL:
-			v.emplace_back(SDL_Point{static_cast<int>(value), fixed_pos});
+			v.emplace_back(SDL_FPoint{static_cast<float>(value), fixed_pos});
 			break;
 		case PathType::VERTICAL:
-			v.emplace_back(SDL_Point{fixed_pos, static_cast<int>(value)});
+			v.emplace_back(SDL_FPoint{fixed_pos, static_cast<float>(value)});
 			break;
 		default:
 			break;
@@ -93,7 +93,7 @@ void PathSprite::addPath(int start, int end, PathType type, int fixed_pos, int s
 }
 
 // Añade un recorrido
-void PathSprite::addPath(std::vector<SDL_Point> spots, int waiting_counter)
+void PathSprite::addPath(std::vector<SDL_FPoint> spots, int waiting_counter)
 {
 	paths_.emplace_back(std::move(spots), waiting_counter);
 }

source/path_sprite.h

@@ -1,6 +1,7 @@
 #pragma once
+#include <SDL3/SDL.h>
 
-#include <SDL3/SDL_rect.h> // Para SDL_Point
+#include <SDL3/SDL_rect.h> // Para SDL_FPoint
 #include <functional>	   // Para function
 #include <memory>		   // Para shared_ptr
 #include <vector>		   // Para vector
@@ -23,19 +24,19 @@ enum class PathCentered
 // Estructuras
 struct Path
 {
-	std::vector<SDL_Point> spots; // Puntos por los que se desplazará el sprite
+	std::vector<SDL_FPoint> spots; // Puntos por los que se desplazará el sprite
-	int waiting_counter;		  // Tiempo de espera una vez en el destino
+	int waiting_counter;		   // Tiempo de espera una vez en el destino
-	bool on_destination = false;  // Indica si ha llegado al destino
+	bool on_destination = false;   // Indica si ha llegado al destino
-	bool finished = false;		  // Indica si ha terminado de esperarse
+	bool finished = false;		   // Indica si ha terminado de esperarse
-	int counter = 0;			  // Contador interno
+	int counter = 0;			   // Contador interno
 
 	// Constructor
-	Path(const std::vector<SDL_Point> &spots_init, int waiting_counter_init)
+	Path(const std::vector<SDL_FPoint> &spots_init, int waiting_counter_init)
 		: spots(spots_init), waiting_counter(waiting_counter_init) {}
 };
 
 // Devuelve un vector con los puntos que conforman la ruta
-std::vector<SDL_Point> createPath(int start, int end, PathType type, int fixed_pos, int steps, const std::function<double(double)> &easingFunction);
+std::vector<SDL_FPoint> createPath(float start, float end, PathType type, float fixed_pos, int steps, const std::function<double(double)> &easingFunction);
 
 // Clase PathSprite
 class PathSprite : public Sprite
@@ -69,7 +70,7 @@ public:
 
 	// Añade un recorrido
 	void addPath(Path path, bool centered = false);
-	void addPath(std::vector<SDL_Point> spots, int waiting_counter = 0);
+	void addPath(std::vector<SDL_FPoint> spots, int waiting_counter = 0);
 	void addPath(int start, int end, PathType type, int fixed_pos, int steps, const std::function<double(double)> &easingFunction, int waiting_counter = 0);
 
 	// Habilita el objeto

source/player.cpp

@@ -350,34 +350,34 @@ void Player::setAnimation()
 	case PlayerState::CREDITS:
 	{
 		// Crea cadenas de texto para componer el nombre de la animación
-		const std::string a_walking = walking_state_ == PlayerState::WALKING_STOP ? "stand" : "walk";
+		const std::string WALKING_ANIMATION = walking_state_ == PlayerState::WALKING_STOP ? "stand" : "walk";
-		const std::string a_firing = firing_state_ == PlayerState::FIRING_UP ? "centershoot" : "sideshoot";
+		const std::string FIRING_ANIMATION = firing_state_ == PlayerState::FIRING_UP ? "centershoot" : "sideshoot";
-		const std::string a_cooling = firing_state_ == PlayerState::COOLING_UP ? "centershoot" : "sideshoot";
+		const std::string COOLING_ANIMATION = firing_state_ == PlayerState::COOLING_UP ? "centershoot" : "sideshoot";
 
-		const SDL_RendererFlip flip_walk = walking_state_ == PlayerState::WALKING_RIGHT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
+		const SDL_FlipMode FLIP_WALK = walking_state_ == PlayerState::WALKING_RIGHT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
-		const SDL_RendererFlip flip_fire = firing_state_ == PlayerState::FIRING_RIGHT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
+		const SDL_FlipMode FLIP_FIRE = firing_state_ == PlayerState::FIRING_RIGHT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
-		const SDL_RendererFlip flip_cooling = firing_state_ == PlayerState::COOLING_RIGHT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
+		const SDL_FlipMode FLIP_COOLING = firing_state_ == PlayerState::COOLING_RIGHT ? SDL_FLIP_HORIZONTAL : SDL_FLIP_NONE;
 
 		// Establece la animación a partir de las cadenas
 		if (firing_state_ == PlayerState::FIRING_NONE)
 		{
 			// No esta disparando
-			player_sprite_->setCurrentAnimation(a_walking);
+			player_sprite_->setCurrentAnimation(WALKING_ANIMATION);
-			player_sprite_->setFlip(flip_walk);
+			player_sprite_->setFlip(FLIP_WALK);
 		}
 		else if (isCooling())
 		{
 			// Acaba de disparar
-			player_sprite_->setCurrentAnimation(a_walking + "-" + a_cooling + "-cooldown");
+			player_sprite_->setCurrentAnimation(WALKING_ANIMATION + "-" + COOLING_ANIMATION + "-cooldown");
-			player_sprite_->setFlip(flip_cooling);
+			player_sprite_->setFlip(FLIP_COOLING);
 		}
 		else
 		{
 			// Está disparando
-			player_sprite_->setCurrentAnimation(a_walking + "-" + a_firing);
+			player_sprite_->setCurrentAnimation(WALKING_ANIMATION + "-" + FIRING_ANIMATION);
 			// Si dispara de lado, invierte el sprite segun hacia donde dispara
 			// Si dispara recto, invierte el sprite segun hacia donde camina
-			player_sprite_->setFlip(a_firing == "centershoot" ? flip_walk : flip_fire);
+			player_sprite_->setFlip(FIRING_ANIMATION == "centershoot" ? FLIP_WALK : FLIP_FIRE);
 		}
 		break;
 	}

source/player.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include <SDL3/SDL_rect.h>		  // Para SDL_FRect
 #include <SDL3/SDL_stdinc.h>	  // Para Uint32

source/resource.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include <memory>            // Para shared_ptr
 #include <string>            // Para string

source/scoreboard.cpp

@@ -57,7 +57,11 @@ Scoreboard::Scoreboard()
 
 	// Recalcula las anclas de los elementos
 	recalculateAnchors();
-	power_meter_sprite_->setPosition({slot4_2_.x - 20, slot4_2_.y, 40, 7});
+	power_meter_sprite_->setPosition(SDL_FRect{
+		static_cast<float>(slot4_2_.x - 20),
+		static_cast<float>(slot4_2_.y),
+		40,
+		7});
 
 	// Crea la textura de fondo
 	background_ = nullptr;
@@ -259,7 +263,7 @@ void Scoreboard::fillPanelTextures()
 			// ENTER NAME
 			{
 				text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y, lang::getText(106));
-				SDL_FRect rect = {enter_name_pos_.x, enter_name_pos_.y, 5, 7};
+				SDL_FRect rect = {enter_name_pos_.x, enter_name_pos_.y, 5.0f, 7.0f};
 
 				// Recorre todos los slots de letras del nombre
 				for (size_t j = 0; j < MAX_NAME_LENGHT; ++j)
@@ -273,7 +277,7 @@ void Scoreboard::fillPanelTextures()
 						if (j >= selector_pos_[i])
 						{
 							SDL_SetRenderDrawColor(renderer_, color.r, color.g, color.b, 255);
-							SDL_RenderDrawLine(renderer_, rect.x, rect.y + rect.h, rect.x + rect.w, rect.y + rect.h);
+							SDL_RenderLine(renderer_, rect.x, rect.y + rect.h, rect.x + rect.w, rect.y + rect.h);
 						}
 
 						// Dibuja la letra
@@ -364,28 +368,28 @@ void Scoreboard::recalculateAnchors()
 	}
 
 	// Constantes para definir las zonas del panel_: 4 filas y 1 columna
-	const int row_size = rect_.h / 4;
+	const int ROW_SIZE = rect_.h / 4;
-	const int text_height = 7;
+	const int TEXT_HEIGHT = 7;
 
 	// Filas
-	const int row1 = (row_size * 0) + (text_height / 2);
+	const float ROW1 = (ROW_SIZE * 0) + (TEXT_HEIGHT / 2);
-	const int row2 = (row_size * 1) + (text_height / 2) - 1;
+	const float ROW2 = (ROW_SIZE * 1) + (TEXT_HEIGHT / 2) - 1;
-	const int row3 = (row_size * 2) + (text_height / 2) - 2;
+	const float ROW3 = (ROW_SIZE * 2) + (TEXT_HEIGHT / 2) - 2;
-	const int row4 = (row_size * 3) + (text_height / 2) - 3;
+	const float ROW4 = (ROW_SIZE * 3) + (TEXT_HEIGHT / 2) - 3;
 
 	// Columna
-	const int col = panel_width / 2;
+	const float COL = panel_width / 2;
 
 	// Slots de 4
-	slot4_1_ = {col, row1};
+	slot4_1_ = {COL, ROW1};
-	slot4_2_ = {col, row2};
+	slot4_2_ = {COL, ROW2};
-	slot4_3_ = {col, row3};
+	slot4_3_ = {COL, ROW3};
-	slot4_4_ = {col, row4};
+	slot4_4_ = {COL, ROW4};
 
 	// Primer cuadrado para poner el nombre de record
 	const int enter_name_lenght = text_scoreboard_->lenght(std::string(MAX_NAME_LENGHT, 'A'));
-	enter_name_pos_.x = col - (enter_name_lenght / 2);
+	enter_name_pos_.x = COL - (enter_name_lenght / 2);
-	enter_name_pos_.y = row4;
+	enter_name_pos_.y = ROW4;
 
 	// Recoloca los sprites
 	if (power_meter_sprite_)
@@ -436,7 +440,7 @@ void Scoreboard::renderSeparator()
 {
 	// Dibuja la linea que separa el marcador de la zona de juego
 	SDL_SetRenderDrawColor(renderer_, separator_color.r, separator_color.g, separator_color.b, 255);
-	SDL_RenderDrawLine(renderer_, 0, 0, rect_.w, 0);
+	SDL_RenderLine(renderer_, 0, 0, rect_.w, 0);
 }
 
 // Inicializa el vector de colores para el nombre

source/scoreboard.h

@@ -1,6 +1,7 @@
 #pragma once
+#include <SDL3/SDL.h>
 
-#include <SDL3/SDL_rect.h>	 // Para SDL_Point, SDL_FRect
+#include <SDL3/SDL_rect.h>	 // Para SDL_FPoint, SDL_FRect
 #include <SDL3/SDL_render.h> // Para SDL_Texture, SDL_Renderer
 #include <SDL3/SDL_stdinc.h> // Para Uint32
 #include <SDL3/SDL_timer.h>	 // Para SDL_GetTicks
@@ -72,14 +73,14 @@ private:
 	std::string hi_score_name_ = std::string();			  // Nombre del jugador con la máxima puntuación
 	Color color_ = Color();								  // Color del marcador
 	SDL_FRect rect_ = {0, 0, 320, 40};					  // Posición y dimensiones del marcador
-	Uint32 ticks_ = SDL_GetTicks();						  // Variable donde almacenar el valor de SDL_GetTiks()
+	Uint64 ticks_ = SDL_GetTicks();						  // Variable donde almacenar el valor de SDL_GetTiks()
 	int time_counter_ = 0;								  // Contador de segundos
 	int loop_counter_ = 0;								  // Contador de bucle
 	std::vector<Color> name_colors_;					  // Colores para destacar el nombre una vez introducido
 
 	// Puntos predefinidos para colocar elementos en los paneles
-	SDL_Point slot4_1_, slot4_2_, slot4_3_, slot4_4_;
+	SDL_FPoint slot4_1_, slot4_2_, slot4_3_, slot4_4_;
-	SDL_Point enter_name_pos_;
+	SDL_FPoint enter_name_pos_;
 
 	// Recalcula las anclas de los elementos
 	void recalculateAnchors();

source/screen.cpp

@@ -6,7 +6,6 @@
 #include <iterator>          // Para istreambuf_iterator, operator==
 #include <string>            // Para allocator, char_traits, operator+, to_s...
 #include "asset.h"           // Para Asset
-#include "dbgtxt.h"          // Para dbg_print
 #include "global_inputs.h"   // Para service_pressed_counter
 #include "jail_shader.h"     // Para init, render
 #include "mouse.h"           // Para updateCursorVisibility
@@ -90,26 +89,22 @@ void Screen::renderScreen()
 }
 
 // Establece el modo de video
-void Screen::setVideoMode(ScreenVideoMode mode)
+void Screen::setFullscreenMode(bool mode)
 {
     // Actualiza las opciones
-    options.video.mode = mode;
+    options.video.fullscreen = mode;
 
     // Configura el modo de pantalla
-    Uint32 flags = SDL_GetWindowFlags(window_);
+    SDL_SetWindowFullscreen(window_, options.video.fullscreen);
-    if (flags != static_cast<Uint32>(options.video.mode))
-    {
-        SDL_SetWindowFullscreen(window_, static_cast<bool>(options.video.mode));
-    }
 
     initShaders();
 }
 
 // Camibia entre pantalla completa y ventana
-void Screen::toggleVideoMode()
+void Screen::toggleFullscreen()
 {
-    options.video.mode = options.video.mode == ScreenVideoMode::WINDOW ? ScreenVideoMode::FULLSCREEN : ScreenVideoMode::WINDOW;
+    options.video.fullscreen = !options.video.fullscreen;
-    setVideoMode();
+    setFullscreenMode();
 }
 
 // Cambia el tamaño de la ventana
@@ -122,7 +117,7 @@ void Screen::setWindowZoom(int zoom)
 // Reduce el tamaño de la ventana
 bool Screen::decWindowZoom()
 {
-    if (options.video.mode == ScreenVideoMode::WINDOW)
+    if (!options.video.fullscreen)
     {
         const int PREVIOUS_ZOOM = options.video.window.zoom;
         --options.video.window.zoom;
@@ -141,7 +136,7 @@ bool Screen::decWindowZoom()
 // Aumenta el tamaño de la ventana
 bool Screen::incWindowZoom()
 {
-    if (options.video.mode == ScreenVideoMode::WINDOW)
+    if (!options.video.fullscreen)
     {
         const int PREVIOUS_ZOOM = options.video.window.zoom;
         ++options.video.window.zoom;
@@ -245,7 +240,7 @@ void Screen::adjustWindowSize()
     options.video.window.max_zoom = getMaxZoom();
 
     // Establece el nuevo tamaño
-    if (options.video.mode == ScreenVideoMode::WINDOW)
+    if (!options.video.fullscreen)
     {
         const int WIDTH = param.game.width * options.video.window.zoom;
         const int HEIGHT = param.game.height * options.video.window.zoom;
@@ -259,7 +254,7 @@ void Screen::adjustWindowSize()
         const int NEW_POS_X = old_pos_x + (old_width - WIDTH) / 2;
         const int NEW_POS_Y = old_pos_y + (old_height - HEIGHT) / 2;
 
-        SDL_FRect viewport = {0, 0, WIDTH, HEIGHT};
+        SDL_Rect viewport = {0, 0, WIDTH, HEIGHT};
         SDL_SetRenderViewport(renderer_, &viewport);
 
         SDL_SetWindowPosition(window_, std::max(NEW_POS_X, WINDOWS_DECORATIONS_), std::max(NEW_POS_Y, 0));

source/screen.h

@@ -1,7 +1,8 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include <SDL3/SDL_blendmode.h> // Para SDL_BlendMode
-#include <SDL3/SDL_rect.h>		// Para SDL_FRect, SDL_Point
+#include <SDL3/SDL_rect.h>		// Para SDL_FRect, SDL_FPoint
 #include <SDL3/SDL_render.h>	// Para SDL_Renderer, SDL_Texture
 #include <SDL3/SDL_stdinc.h>	// Para Uint32
 #include <SDL3/SDL_video.h>		// Para SDL_Window
@@ -16,12 +17,6 @@ enum class ScreenFilter : int
 	LINEAL = 1,
 };
 
-enum class ScreenVideoMode : bool
-{
-	WINDOW = false,
-	FULLSCREEN = true,
-};
-
 class Screen
 {
 private:
@@ -239,10 +234,10 @@ public:
 	void render();
 
 	// Establece el modo de video
-	void setVideoMode(ScreenVideoMode mode = options.video.mode);
+	void setFullscreenMode(bool mode = options.video.fullscreen);
 
 	// Cambia entre pantalla completa y ventana
-	void toggleVideoMode();
+	void toggleFullscreen();
 
 	// Cambia el tamaño de la ventana
 	void setWindowZoom(int size);

source/section.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 namespace section
 {

source/smart_sprite.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include <memory>			 // Para shared_ptr
 #include "animated_sprite.h" // Para SpriteAnimated

source/sprite.cpp

@@ -2,7 +2,7 @@
 #include "texture.h" // Para Texture
 
 // Constructor
-Sprite::Sprite(std::shared_ptr<Texture> texture, int x, int y, int w, int h)
+Sprite::Sprite(std::shared_ptr<Texture> texture, float x, float y, float w, float h)
 	: texture_(texture),
 	  pos_((SDL_FRect){x, y, w, h}),
 	  sprite_clip_((SDL_FRect){0, 0, pos_.w, pos_.h}) {}
@@ -14,7 +14,7 @@ Sprite::Sprite(std::shared_ptr<Texture> texture, SDL_FRect rect)
 
 Sprite::Sprite(std::shared_ptr<Texture> texture)
 	: texture_(texture),
-	  pos_({0, 0, texture_->getWidth(), texture_->getHeight()}),
+	  pos_(SDL_FRect{0, 0, static_cast<float>(texture_->getWidth()), static_cast<float>(texture_->getHeight())}),
 	  sprite_clip_(pos_) {}
 
 // Muestra el sprite por pantalla
@@ -24,14 +24,14 @@ void Sprite::render()
 }
 
 // Establece la posición del objeto
-void Sprite::setPosition(int x, int y)
+void Sprite::setPosition(float x, float y)
 {
 	pos_.x = x;
 	pos_.y = y;
 }
 
 // Establece la posición del objeto
-void Sprite::setPosition(SDL_Point p)
+void Sprite::setPosition(SDL_FPoint p)
 {
 	pos_.x = p.x;
 	pos_.y = p.y;

source/sprite.h

@@ -1,6 +1,7 @@
 #pragma once
+#include <SDL3/SDL.h>
 
-#include <SDL3/SDL_rect.h> // Para SDL_FRect, SDL_Point
+#include <SDL3/SDL_rect.h> // Para SDL_FRect, SDL_FPoint
 #include <memory>          // Para shared_ptr
 class Texture;
 
@@ -16,7 +17,7 @@ protected:
 
 public:
     // Constructor
-    Sprite(std::shared_ptr<Texture>, int x, int y, int w, int h);
+    Sprite(std::shared_ptr<Texture>, float x, float y, float w, float h);
     Sprite(std::shared_ptr<Texture>, SDL_FRect rect);
     explicit Sprite(std::shared_ptr<Texture>);
 
@@ -30,39 +31,39 @@ public:
     virtual void clear();
 
     // Obtiene la posición y el tamaño
-    int getX() const { return pos_.x; }
+    float getX() const { return pos_.x; }
-    int getY() const { return pos_.y; }
+    float getY() const { return pos_.y; }
-    int getWidth() const { return pos_.w; }
+    float getWidth() const { return pos_.w; }
-    int getHeight() const { return pos_.h; }
+    float getHeight() const { return pos_.h; }
 
     // Devuelve el rectangulo donde está el sprite
     SDL_FRect getPosition() const { return pos_; }
     SDL_FRect &getRect() { return pos_; }
 
     // Establece la posición y el tamaño
-    void setX(int x) { pos_.x = x; }
+    void setX(float x) { pos_.x = x; }
-    void setY(int y) { pos_.y = y; }
+    void setY(float y) { pos_.y = y; }
-    void setWidth(int w) { pos_.w = w; }
+    void setWidth(float w) { pos_.w = w; }
-    void setHeight(int h) { pos_.h = h; }
+    void setHeight(float h) { pos_.h = h; }
 
     // Establece la posición del objeto
-    void setPosition(int x, int y);
+    void setPosition(float x, float y);
-    void setPosition(SDL_Point p);
+    void setPosition(SDL_FPoint p);
     void setPosition(SDL_FRect r) { pos_ = r; }
 
     // Establece el nivel de zoom
     void setZoom(float zoom) { zoom_ = zoom; }
 
     // Aumenta o disminuye la posición
-    void incX(int value) { pos_.x += value; }
+    void incX(float value) { pos_.x += value; }
-    void incY(int value) { pos_.y += value; }
+    void incY(float value) { pos_.y += value; }
 
     // Obtiene el rectangulo que se dibuja de la textura
     SDL_FRect getSpriteClip() const { return sprite_clip_; }
 
     // Establece el rectangulo que se dibuja de la textura
     void setSpriteClip(SDL_FRect rect) { sprite_clip_ = rect; }
-    void setSpriteClip(int x, int y, int w, int h) { sprite_clip_ = (SDL_FRect){x, y, w, h}; }
+    void setSpriteClip(float x, float y, float w, float h) { sprite_clip_ = (SDL_FRect){x, y, w, h}; }
 
     // Obtiene un puntero a la textura
     std::shared_ptr<Texture> getTexture() const { return texture_; }

source/stage.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include <vector>
 

source/tabe.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include <SDL3/SDL_rect.h>   // Para SDL_FRect
 #include <SDL3/SDL_stdinc.h> // Para Uint32

source/text.cpp

@@ -96,7 +96,7 @@ Text::Text(std::shared_ptr<Texture> texture, const std::string &text_file)
 	}
 
 	// Crea los objetos
-	sprite_ = std::make_unique<Sprite>(texture, (SDL_FRect){0, 0, box_width_, box_height_});
+	sprite_ = std::make_unique<Sprite>(texture, (SDL_FRect){0, 0, static_cast<float>(box_width_), static_cast<float>(box_height_)});
 
 	// Inicializa variables
 	fixed_width_ = false;
@@ -116,7 +116,7 @@ Text::Text(std::shared_ptr<Texture> texture, std::shared_ptr<TextFile> text_file
 	}
 
 	// Crea los objetos
-	sprite_ = std::make_unique<Sprite>(texture, (SDL_FRect){0, 0, box_width_, box_height_});
+	sprite_ = std::make_unique<Sprite>(texture, (SDL_FRect){0, 0, static_cast<float>(box_width_), static_cast<float>(box_height_)});
 
 	// Inicializa variables
 	fixed_width_ = false;
@@ -148,7 +148,7 @@ void Text::write2X(int x, int y, const std::string &text, int kerning)
 	for (size_t i = 0; i < text.length(); ++i)
 	{
 		auto index = static_cast<size_t>(text[i]);
-		SDL_FRect rect = {offset_[index].x, offset_[index].y, box_width_, box_height_};
+		SDL_FRect rect = {static_cast<float>(offset_[index].x), static_cast<float>(offset_[index].y), static_cast<float>(box_width_), static_cast<float>(box_height_)};
 		sprite_->getTexture()->render(x + shift, y, &rect, 2.0f, 2.0f);
 		shift += (offset_[index].w + kerning) * 2;
 	}

source/text.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include <SDL3/SDL_stdinc.h> // Para Uint8
 #include <memory>			 // Para unique_ptr, shared_ptr

source/texture.cpp

@@ -75,11 +75,10 @@ bool Texture::loadFromFile(const std::string &file_path)
 		printWithDots("Image : ", getFileName(file_path), "[ LOADED ]");
 	}
 
-	int depth, pitch;
+	int pitch;
-	Uint32 pixel_format;
+	SDL_PixelFormat pixel_format;
 
 	// STBI_rgb_alpha (RGBA)
-	depth = 32;
 	pitch = 4 * width;
 	pixel_format = SDL_PIXELFORMAT_RGBA32;
 
@@ -87,41 +86,42 @@ bool Texture::loadFromFile(const std::string &file_path)
 	unloadTexture();
 
 	// La textura final
-	SDL_Texture *newTexture = nullptr;
+	SDL_Texture *new_texture = nullptr;
 
 	// Carga la imagen desde una ruta específica
-	auto loadedSurface = SDL_CreateRGBSurfaceWithFormatFrom(static_cast<void *>(data), width, height, depth, pitch, pixel_format);
+	/*auto loaded_surface = SDL_CreateRGBSurfaceWithFormatFrom(static_cast<void *>(data), width, height, depth, pitch, pixel_format);*/
-	if (loadedSurface == nullptr)
+	auto loaded_surface = SDL_CreateSurfaceFrom(width, height, pixel_format, static_cast<void *>(data), pitch);
+	if (loaded_surface == nullptr)
 	{
 		std::cout << "Unable to load image " << file_path << std::endl;
 	}
 	else
 	{
 		// Crea la textura desde los pixels de la surface
-		newTexture = SDL_CreateTextureFromSurface(renderer_, loadedSurface);
+		new_texture = SDL_CreateTextureFromSurface(renderer_, loaded_surface);
-		if (newTexture == nullptr)
+		if (new_texture == nullptr)
 		{
 			std::cout << "Unable to create texture from " << file_path << "! SDL Error: " << SDL_GetError() << std::endl;
 		}
 		else
 		{
 			// Obtiene las dimensiones de la imagen
-			width_ = loadedSurface->w;
+			width_ = loaded_surface->w;
-			height_ = loadedSurface->h;
+			height_ = loaded_surface->h;
 		}
 
 		// Elimina la textura cargada
-		SDL_FreeSurface(loadedSurface);
+		SDL_DestroySurface(loaded_surface);
 	}
 
 	// Return success
 	stbi_image_free(data);
-	texture_ = newTexture;
+	texture_ = new_texture;
 	return texture_ != nullptr;
 }
 
 // Crea una textura en blanco
-bool Texture::createBlank(int width, int height, SDL_PixelFormatEnum format, SDL_TextureAccess access)
+bool Texture::createBlank(int width, int height, SDL_PixelFormat format, SDL_TextureAccess access)
 {
 	// Crea una textura sin inicializar
 	texture_ = SDL_CreateTexture(renderer_, format, access, width, height);
@@ -174,10 +174,10 @@ void Texture::setAlpha(Uint8 alpha)
 }
 
 // Renderiza la textura en un punto específico
-void Texture::render(int x, int y, SDL_FRect *clip, float zoomW, float zoomH, double angle, SDL_Point *center, SDL_RendererFlip flip)
+void Texture::render(int x, int y, SDL_FRect *clip, float zoomW, float zoomH, double angle, SDL_FPoint *center, SDL_FlipMode flip)
 {
 	// Establece el destino de renderizado en la pantalla
-	SDL_FRect renderQuad = {x, y, width_, height_};
+	SDL_FRect renderQuad = {static_cast<float>(x), static_cast<float>(y), static_cast<float>(width_), static_cast<float>(height_)};
 
 	// Obtiene las dimesiones del clip de renderizado
 	if (clip != nullptr)
@@ -198,7 +198,7 @@ void Texture::render(int x, int y, SDL_FRect *clip, float zoomW, float zoomH, do
 	}
 
 	// Renderiza a pantalla
-	SDL_RenderCopyEx(renderer_, texture_, clip, &renderQuad, angle, center, flip);
+	SDL_RenderTextureRotated(renderer_, texture_, clip, &renderQuad, angle, center, flip);
 }
 
 // Establece la textura como objetivo de renderizado

source/texture.h

@@ -1,8 +1,9 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include <SDL3/SDL_blendmode.h> // Para SDL_BlendMode
 #include <SDL3/SDL_pixels.h>    // Para SDL_PIXELFORMAT_RGBA8888, SDL_PixelF...
-#include <SDL3/SDL_rect.h>      // Para SDL_Point, SDL_FRect
+#include <SDL3/SDL_rect.h>      // Para SDL_FPoint, SDL_FRect
 #include <SDL3/SDL_render.h>    // Para SDL_Renderer, SDL_FLIP_NONE, SDL_TEX...
 #include <SDL3/SDL_stdinc.h>    // Para Uint8, Uint16, Uint32
 #include <memory>               // Para shared_ptr
@@ -62,7 +63,7 @@ public:
     bool loadFromFile(const std::string &path);
 
     // Crea una textura en blanco
-    bool createBlank(int width, int height, SDL_PixelFormatEnum format = SDL_PIXELFORMAT_RGBA8888, SDL_TextureAccess = SDL_TEXTUREACCESS_STREAMING);
+    bool createBlank(int width, int height, SDL_PixelFormat format = SDL_PIXELFORMAT_RGBA8888, SDL_TextureAccess = SDL_TEXTUREACCESS_STREAMING);
 
     // Establece el color para la modulacion
     void setColor(Uint8 red, Uint8 green, Uint8 blue);
@@ -75,7 +76,7 @@ public:
     void setAlpha(Uint8 alpha);
 
     // Renderiza la textura en un punto específico
-    void render(int x, int y, SDL_FRect *clip = nullptr, float zoomW = 1, float zoomH = 1, double angle = 0.0, SDL_Point *center = nullptr, SDL_RendererFlip flip = SDL_FLIP_NONE);
+    void render(int x, int y, SDL_FRect *clip = nullptr, float zoomW = 1, float zoomH = 1, double angle = 0.0, SDL_FPoint *center = nullptr, SDL_FlipMode flip = SDL_FLIP_NONE);
 
     // Establece la textura como objetivo de renderizado
     void setAsRenderTarget(SDL_Renderer *renderer);

source/tiled_bg.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include <SDL3/SDL_rect.h>   // Para SDL_FRect
 #include <SDL3/SDL_render.h> // Para SDL_Renderer, SDL_Texture

source/title.cpp

@@ -143,11 +143,11 @@ void Title::checkEvents()
 	SDL_Event event;
 	while (SDL_PollEvent(&event))
 	{
-		if (event.type == SDL_KEYDOWN && event.key.repeat == 0)
+		if (event.type == SDL_EVENT_KEY_DOWN && event.key.repeat == 0)
 		{
 			bool should_reset = false;
 
-			switch (event.key.keysym.sym)
+			switch (event.key.key)
 			{
 			case SDLK_1: // Redefine los botones del mando #0
 				should_reset = define_buttons_->enable(0);
@@ -204,7 +204,7 @@ void Title::checkInput()
 				if ((state_ == TitleState::LOGO_FINISHED || ALLOW_TITLE_ANIMATION_SKIP) && !fade_->isEnabled())
 				{
 					JA_PlaySound(Resource::get()->getSound("game_start.wav"));
-					JA_FadeOutMusic(1500);
+					/*JA_FadeOutMusic(1500);*/
 					switch (controller.player_id)
 					{
 					case 1:

source/title.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include <SDL3/SDL_stdinc.h> // Para Uint32
 #include <memory>			 // Para unique_ptr, shared_ptr
@@ -54,7 +55,7 @@ private:
 
 	// Variable
 	int counter_ = 0;												// Temporizador para la pantalla de titulo
-	Uint32 ticks_ = 0;												// Contador de ticks para ajustar la velocidad del programa
+	Uint64 ticks_ = 0;												// Contador de ticks para ajustar la velocidad del programa
 	section::Name next_section_;									// Indica cual es la siguiente sección a cargar cuando termine el contador del titulo
 	section::Options selection_ = section::Options::TITLE_TIME_OUT; // Opción elegida en el titulo
 	int num_controllers_;											// Número de mandos conectados

source/utils.cpp

@@ -1,14 +1,15 @@
+#define _USE_MATH_DEFINES
 #include "utils.h"
-#include <SDL3/SDL_rwops.h> // Para SDL_RWFromFile, SDL_RWclose, SDL_RWread
+#include <SDL3/SDL.h> // Para SDL_IOFromFile, SDL_CloseIO, SDL_RIO
-#include <stddef.h>         // Para size_t
+#include <stddef.h>   // Para size_t
-#include <algorithm>        // Para min, clamp, find_if_not, find, transform
+#include <algorithm>  // Para min, clamp, find_if_not, find, transform
-#include <cctype>           // Para tolower, isspace
+#include <cctype>     // Para tolower, isspace
-#include <cmath>            // Para pow, sin, M_PI, cos
+#include <cmath>      // Para pow, sin, M_PI, cos
-#include <compare>          // Para operator<
+#include <compare>    // Para operator<
-#include <filesystem>       // Para path
+#include <filesystem> // Para path
-#include <iostream>         // Para basic_ostream, cout, basic_ios, endl, ios
+#include <iostream>   // Para basic_ostream, cout, basic_ios, endl, ios
-#include <stdexcept>        // Para runtime_error
+#include <stdexcept>  // Para runtime_error
-#include <string>           // Para basic_string, string, char_traits, opera...
+#include <string>     // Para basic_string, string, char_traits, opera...
 #include "lang.h"
 
 // Variables
@@ -72,11 +73,11 @@ bool checkCollision(const Circle &a, const Circle &b)
 bool checkCollision(const Circle &a, const SDL_FRect &b)
 {
     // Encuentra el punto más cercano en el rectángulo
-    int cX = std::clamp(a.x, b.x, b.x + b.w);
+    float cX = std::clamp(static_cast<float>(a.x), b.x, b.x + b.w);
-    int cY = std::clamp(a.y, b.y, b.y + b.h);
+    float cY = std::clamp(static_cast<float>(a.y), b.y, b.y + b.h);
 
     // Si el punto más cercano está dentro del círculo
-    return distanceSquared(a.x, a.y, cX, cY) < a.r * a.r;
+    return distanceSquared(static_cast<float>(a.x), static_cast<float>(a.y), cX, cY) < static_cast<float>(a.r) * a.r;
 }
 
 // Detector de colisiones entre dos rectangulos
@@ -98,7 +99,7 @@ bool checkCollision(const SDL_FRect &a, const SDL_FRect &b)
 }
 
 // Detector de colisiones entre un punto y un rectangulo
-bool checkCollision(const SDL_Point &p, const SDL_FRect &r)
+bool checkCollision(const SDL_FPoint &p, const SDL_FRect &r)
 {
     if (p.x < r.x || p.x > r.x + r.w)
         return false;
@@ -149,14 +150,14 @@ void DrawCircle(SDL_Renderer *renderer, int32_t centerX, int32_t centerY, int32_
     while (x >= y)
     {
         //  Each of the following renders an octant of the circle
-        SDL_RenderDrawPoint(renderer, centerX + x, centerY - y);
+        SDL_RenderPoint(renderer, centerX + x, centerY - y);
-        SDL_RenderDrawPoint(renderer, centerX + x, centerY + y);
+        SDL_RenderPoint(renderer, centerX + x, centerY + y);
-        SDL_RenderDrawPoint(renderer, centerX - x, centerY - y);
+        SDL_RenderPoint(renderer, centerX - x, centerY - y);
-        SDL_RenderDrawPoint(renderer, centerX - x, centerY + y);
+        SDL_RenderPoint(renderer, centerX - x, centerY + y);
-        SDL_RenderDrawPoint(renderer, centerX + y, centerY - x);
+        SDL_RenderPoint(renderer, centerX + y, centerY - x);
-        SDL_RenderDrawPoint(renderer, centerX + y, centerY + x);
+        SDL_RenderPoint(renderer, centerX + y, centerY + x);
-        SDL_RenderDrawPoint(renderer, centerX - y, centerY - x);
+        SDL_RenderPoint(renderer, centerX - y, centerY - x);
-        SDL_RenderDrawPoint(renderer, centerX - y, centerY + x);
+        SDL_RenderPoint(renderer, centerX - y, centerY + x);
 
         if (error <= 0)
         {
@@ -317,7 +318,7 @@ DemoData loadDemoDataFromFile(const std::string &file_path)
     DemoData dd;
 
     // Indicador de éxito en la carga
-    auto file = SDL_RWFromFile(file_path.c_str(), "r+b");
+    auto file = SDL_IOFromFile(file_path.c_str(), "r+b");
     if (!file)
     {
         std::cerr << "Error: Fichero no encontrado " << file_path << std::endl;
@@ -331,12 +332,12 @@ DemoData loadDemoDataFromFile(const std::string &file_path)
         for (int i = 0; i < TOTAL_DEMO_DATA; ++i)
         {
             DemoKeys dk = DemoKeys();
-            SDL_RWread(file, &dk, sizeof(DemoKeys), 1);
+            SDL_ReadIO(file, &dk, sizeof(DemoKeys));
             dd.push_back(dk);
         }
 
         // Cierra el fichero
-        SDL_RWclose(file);
+        SDL_CloseIO(file);
     }
 
     return dd;
@@ -347,7 +348,7 @@ DemoData loadDemoDataFromFile(const std::string &file_path)
 bool saveDemoFile(const std::string &file_path, const DemoData &dd)
 {
     auto success = true;
-    auto file = SDL_RWFromFile(file_path.c_str(), "w+b");
+    auto file = SDL_IOFromFile(file_path.c_str(), "w+b");
 
     if (file)
     {
@@ -366,7 +367,7 @@ bool saveDemoFile(const std::string &file_path, const DemoData &dd)
             std::cout << "Writing file " << getFileName(file_path).c_str() << std::endl;
         }
         // Cierra el fichero
-        SDL_RWclose(file);
+        SDL_CloseIO(file);
     }
     else
     {

source/utils.h

@@ -1,6 +1,7 @@
 #pragma once
+#include <SDL3/SDL.h>
 
-#include <SDL3/SDL_rect.h>	 // Para SDL_FRect, SDL_Point
+#include <SDL3/SDL_rect.h>	 // Para SDL_FRect, SDL_FPoint
 #include <SDL3/SDL_render.h> // Para SDL_Renderer
 #include <SDL3/SDL_stdinc.h> // Para Uint8
 #include <stdint.h>			 // Para int32_t
@@ -116,13 +117,13 @@ struct Demo
 // Posiciones dentro de un rectangulo
 struct Zone
 {
-	SDL_FRect rect;		 // Rectangulo que define la zona
+	SDL_FRect rect;		   // Rectangulo que define la zona
-	int center_x;		 // Anclaje al 50% del eje X
+	float center_x;		   // Anclaje al 50% del eje X
-	int first_quarter_x; // Anclaje al 25% del eje X
+	float first_quarter_x; // Anclaje al 25% del eje X
-	int third_quarter_x; // Anclaje al 75% del eje X
+	float third_quarter_x; // Anclaje al 75% del eje X
-	int center_y;		 // Anclaje al 50% del eje Y
+	float center_y;		   // Anclaje al 50% del eje Y
-	int first_quarter_y; // Anclaje al 25% del eje Y
+	float first_quarter_y; // Anclaje al 25% del eje Y
-	int third_quarter_y; // Anclaje al 75% del eje X
+	float third_quarter_y; // Anclaje al 75% del eje X
 };
 
 // Obtiene un color del vector de colores imitando al Coche Fantástico
@@ -141,7 +142,7 @@ bool checkCollision(const Circle &a, const SDL_FRect &b);
 bool checkCollision(const SDL_FRect &a, const SDL_FRect &b);
 
 // Detector de colisiones entre un punto y un rectangulo
-bool checkCollision(const SDL_Point &p, const SDL_FRect &r);
+bool checkCollision(const SDL_FPoint &p, const SDL_FRect &r);
 
 // Convierte una cadena en un valor booleano
 bool stringToBool(const std::string &str);

source/writer.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <SDL3/SDL.h>
 
 #include <memory> // Para shared_ptr
 #include <string> // Para string