migrat Logo a time based

CMakeLists.txt

@@ -86,6 +86,7 @@ set(APP_SOURCES
     source/game/ui/notifier.cpp
 
     # Utils
+    source/utils/delta_timer.cpp
     source/utils/global_events.cpp
     source/utils/utils.cpp
 

source/core/rendering/surface_animated_sprite.cpp

@@ -31,8 +31,8 @@ Animations loadAnimationsFromFile(const std::string& file_path) {
 }
 
 // Constructor
-SAnimatedSprite::SAnimatedSprite(std::shared_ptr<Surface> surface, const std::string& file_path)
-    : SMovingSprite(surface) {
+SurfaceAnimatedSprite::SurfaceAnimatedSprite(std::shared_ptr<Surface> surface, const std::string& file_path)
+    : SurfaceMovingSprite(surface) {
     // Carga las animaciones
     if (!file_path.empty()) {
         Animations v = loadAnimationsFromFile(file_path);
@@ -41,15 +41,15 @@ SAnimatedSprite::SAnimatedSprite(std::shared_ptr<Surface> surface, const std::st
 }
 
 // Constructor
-SAnimatedSprite::SAnimatedSprite(std::shared_ptr<Surface> surface, const Animations& animations)
-    : SMovingSprite(surface) {
+SurfaceAnimatedSprite::SurfaceAnimatedSprite(std::shared_ptr<Surface> surface, const Animations& animations)
+    : SurfaceMovingSprite(surface) {
     if (!animations.empty()) {
         setAnimations(animations);
     }
 }
 
 // Obtiene el indice de la animación a partir del nombre
-int SAnimatedSprite::getIndex(const std::string& name) {
+int SurfaceAnimatedSprite::getIndex(const std::string& name) {
     auto index = -1;
 
     for (const auto& a : animations_) {
@@ -63,7 +63,7 @@ int SAnimatedSprite::getIndex(const std::string& name) {
 }
 
 // Calcula el frame correspondiente a la animación
-void SAnimatedSprite::animate() {
+void SurfaceAnimatedSprite::animate() {
     if (animations_[current_animation_].speed == 0) {
         return;
     }
@@ -93,12 +93,12 @@ void SAnimatedSprite::animate() {
 }
 
 // Comprueba si ha terminado la animación
-bool SAnimatedSprite::animationIsCompleted() {
+bool SurfaceAnimatedSprite::animationIsCompleted() {
     return animations_[current_animation_].completed;
 }
 
 // Establece la animacion actual
-void SAnimatedSprite::setCurrentAnimation(const std::string& name) {
+void SurfaceAnimatedSprite::setCurrentAnimation(const std::string& name) {
     const auto new_animation = getIndex(name);
     if (current_animation_ != new_animation) {
         current_animation_ = new_animation;
@@ -110,7 +110,7 @@ void SAnimatedSprite::setCurrentAnimation(const std::string& name) {
 }
 
 // Establece la animacion actual
-void SAnimatedSprite::setCurrentAnimation(int index) {
+void SurfaceAnimatedSprite::setCurrentAnimation(int index) {
     const auto new_animation = index;
     if (current_animation_ != new_animation) {
         current_animation_ = new_animation;
@@ -122,20 +122,20 @@ void SAnimatedSprite::setCurrentAnimation(int index) {
 }
 
 // Actualiza las variables del objeto
-void SAnimatedSprite::update() {
+void SurfaceAnimatedSprite::update() {
     animate();
-    SMovingSprite::update();
+    SurfaceMovingSprite::update();
 }
 
 // Reinicia la animación
-void SAnimatedSprite::resetAnimation() {
+void SurfaceAnimatedSprite::resetAnimation() {
     animations_[current_animation_].current_frame = 0;
     animations_[current_animation_].counter = 0;
     animations_[current_animation_].completed = false;
 }
 
 // Carga la animación desde un vector de cadenas
-void SAnimatedSprite::setAnimations(const Animations& animations) {
+void SurfaceAnimatedSprite::setAnimations(const Animations& animations) {
     float frame_width = 1.0F;
     float frame_height = 1.0F;
     int frames_per_row = 1;
@@ -221,7 +221,7 @@ void SAnimatedSprite::setAnimations(const Animations& animations) {
 }
 
 // Establece el frame actual de la animación
-void SAnimatedSprite::setCurrentAnimationFrame(int num) {
+void SurfaceAnimatedSprite::setCurrentAnimationFrame(int num) {
     // Descarta valores fuera de rango
     if (num < 0 || num >= static_cast<int>(animations_[current_animation_].frames.size())) {
         num = 0;

source/core/rendering/surface_animated_sprite.hpp

@@ -32,7 +32,7 @@ using Animations = std::vector<std::string>;
 // Carga las animaciones en un vector(Animations) desde un fichero
 Animations loadAnimationsFromFile(const std::string& file_path);
 
-class SAnimatedSprite : public SMovingSprite {
+class SurfaceAnimatedSprite : public SurfaceMovingSprite {
     protected:
         // Variables
         std::vector<AnimationData> animations_;  // Vector con las diferentes animaciones
@@ -46,13 +46,13 @@ class SAnimatedSprite : public SMovingSprite {
 
     public:
         // Constructor
-        SAnimatedSprite(std::shared_ptr<Surface> surface, const std::string& file_path);
-        SAnimatedSprite(std::shared_ptr<Surface> surface, const Animations& animations);
-        explicit SAnimatedSprite(std::shared_ptr<Surface> surface)
-            : SMovingSprite(surface) {}
+        SurfaceAnimatedSprite(std::shared_ptr<Surface> surface, const std::string& file_path);
+        SurfaceAnimatedSprite(std::shared_ptr<Surface> surface, const Animations& animations);
+        explicit SurfaceAnimatedSprite(std::shared_ptr<Surface> surface)
+            : SurfaceMovingSprite(surface) {}
 
         // Destructor
-        virtual ~SAnimatedSprite() override = default;
+        virtual ~SurfaceAnimatedSprite() override = default;
 
         // Actualiza las variables del objeto
         void update() override;

source/core/rendering/surface_moving_sprite.cpp

@@ -3,26 +3,26 @@
 #include "core/rendering/surface.hpp"  // Para Surface
 
 // Constructor
-SMovingSprite::SMovingSprite(std::shared_ptr<Surface> surface, SDL_FRect pos, SDL_FlipMode flip)
-    : SSprite(surface, pos),
+SurfaceMovingSprite::SurfaceMovingSprite(std::shared_ptr<Surface> surface, SDL_FRect pos, SDL_FlipMode flip)
+    : SurfaceSprite(surface, pos),
       x_(pos.x),
       y_(pos.y),
-      flip_(flip) { SSprite::pos_ = pos; }
+      flip_(flip) { SurfaceSprite::pos_ = pos; }
 
-SMovingSprite::SMovingSprite(std::shared_ptr<Surface> surface, SDL_FRect pos)
-    : SSprite(surface, pos),
+SurfaceMovingSprite::SurfaceMovingSprite(std::shared_ptr<Surface> surface, SDL_FRect pos)
+    : SurfaceSprite(surface, pos),
       x_(pos.x),
       y_(pos.y),
-      flip_(SDL_FLIP_NONE) { SSprite::pos_ = pos; }
+      flip_(SDL_FLIP_NONE) { SurfaceSprite::pos_ = pos; }
 
-SMovingSprite::SMovingSprite(std::shared_ptr<Surface> surface)
-    : SSprite(surface),
+SurfaceMovingSprite::SurfaceMovingSprite(std::shared_ptr<Surface> surface)
+    : SurfaceSprite(surface),
       x_(0.0f),
       y_(0.0f),
-      flip_(SDL_FLIP_NONE) { SSprite::clear(); }
+      flip_(SDL_FLIP_NONE) { SurfaceSprite::clear(); }
 
 // Reinicia todas las variables
-void SMovingSprite::clear() {
+void SurfaceMovingSprite::clear() {
     x_ = 0.0f;  // Posición en el eje X
     y_ = 0.0f;  // Posición en el eje Y
 
@@ -34,11 +34,11 @@ void SMovingSprite::clear() {
 
     flip_ = SDL_FLIP_NONE;  // Establece como se ha de voltear el sprite
 
-    SSprite::clear();
+    SurfaceSprite::clear();
 }
 
 // Mueve el sprite
-void SMovingSprite::move() {
+void SurfaceMovingSprite::move() {
     x_ += vx_;
     y_ += vy_;
 
@@ -50,22 +50,22 @@ void SMovingSprite::move() {
 }
 
 // Actualiza las variables internas del objeto
-void SMovingSprite::update() {
+void SurfaceMovingSprite::update() {
     move();
 }
 
 // Muestra el sprite por pantalla
-void SMovingSprite::render() {
+void SurfaceMovingSprite::render() {
     surface_->render(pos_.x, pos_.y, &clip_, flip_);
 }
 
 // Muestra el sprite por pantalla
-void SMovingSprite::render(Uint8 source_color, Uint8 target_color) {
+void SurfaceMovingSprite::render(Uint8 source_color, Uint8 target_color) {
     surface_->renderWithColorReplace(pos_.x, pos_.y, source_color, target_color, &clip_, flip_);
 }
 
 // Establece la posición y_ el tamaño del objeto
-void SMovingSprite::setPos(SDL_FRect rect) {
+void SurfaceMovingSprite::setPos(SDL_FRect rect) {
     x_ = static_cast<float>(rect.x);
     y_ = static_cast<float>(rect.y);
 
@@ -73,7 +73,7 @@ void SMovingSprite::setPos(SDL_FRect rect) {
 }
 
 // Establece el valor de las variables
-void SMovingSprite::setPos(float x, float y) {
+void SurfaceMovingSprite::setPos(float x, float y) {
     x_ = x;
     y_ = y;
 
@@ -82,13 +82,13 @@ void SMovingSprite::setPos(float x, float y) {
 }
 
 // Establece el valor de la variable
-void SMovingSprite::setPosX(float value) {
+void SurfaceMovingSprite::setPosX(float value) {
     x_ = value;
     pos_.x = static_cast<int>(x_);
 }
 
 // Establece el valor de la variable
-void SMovingSprite::setPosY(float value) {
+void SurfaceMovingSprite::setPosY(float value) {
     y_ = value;
     pos_.y = static_cast<int>(y_);
 }

source/core/rendering/surface_moving_sprite.hpp

@@ -8,7 +8,7 @@
 class Surface;                                // lines 8-8
 
 // Clase SMovingSprite. Añade movimiento y flip al sprite
-class SMovingSprite : public SSprite {
+class SurfaceMovingSprite : public SurfaceSprite {
     public:
     protected:
         float x_;  // Posición en el eje X
@@ -27,12 +27,12 @@ class SMovingSprite : public SSprite {
 
     public:
         // Constructor
-        SMovingSprite(std::shared_ptr<Surface> surface, SDL_FRect pos, SDL_FlipMode flip);
-        SMovingSprite(std::shared_ptr<Surface> surface, SDL_FRect pos);
-        explicit SMovingSprite(std::shared_ptr<Surface> surface);
+        SurfaceMovingSprite(std::shared_ptr<Surface> surface, SDL_FRect pos, SDL_FlipMode flip);
+        SurfaceMovingSprite(std::shared_ptr<Surface> surface, SDL_FRect pos);
+        explicit SurfaceMovingSprite(std::shared_ptr<Surface> surface);
 
         // Destructor
-        virtual ~SMovingSprite() override = default;
+        virtual ~SurfaceMovingSprite() override = default;
 
         // Actualiza las variables internas del objeto
         virtual void update();

source/core/rendering/surface_sprite.cpp

@@ -3,44 +3,44 @@
 #include "core/rendering/surface.hpp"  // Para Surface
 
 // Constructor
-SSprite::SSprite(std::shared_ptr<Surface> surface, float x, float y, float w, float h)
+SurfaceSprite::SurfaceSprite(std::shared_ptr<Surface> surface, float x, float y, float w, float h)
     : surface_(surface),
       pos_((SDL_FRect){x, y, w, h}),
       clip_((SDL_FRect){0.0F, 0.0F, pos_.w, pos_.h}) {}
 
-SSprite::SSprite(std::shared_ptr<Surface> surface, SDL_FRect rect)
+SurfaceSprite::SurfaceSprite(std::shared_ptr<Surface> surface, SDL_FRect rect)
     : surface_(surface),
       pos_(rect),
       clip_((SDL_FRect){0, 0, pos_.w, pos_.h}) {}
 
-SSprite::SSprite(std::shared_ptr<Surface> surface)
+SurfaceSprite::SurfaceSprite(std::shared_ptr<Surface> surface)
     : surface_(surface),
       pos_((SDL_FRect){0.0F, 0.0F, surface_->getWidth(), surface_->getHeight()}),
       clip_(pos_) {}
 
 // Muestra el sprite por pantalla
-void SSprite::render() {
+void SurfaceSprite::render() {
     surface_->render(pos_.x, pos_.y, &clip_);
 }
 
-void SSprite::render(Uint8 source_color, Uint8 target_color) {
+void SurfaceSprite::render(Uint8 source_color, Uint8 target_color) {
     surface_->renderWithColorReplace(pos_.x, pos_.y, source_color, target_color, &clip_);
 }
 
 // Establece la posición del objeto
-void SSprite::setPosition(float x, float y) {
+void SurfaceSprite::setPosition(float x, float y) {
     pos_.x = x;
     pos_.y = y;
 }
 
 // Establece la posición del objeto
-void SSprite::setPosition(SDL_FPoint p) {
+void SurfaceSprite::setPosition(SDL_FPoint p) {
     pos_.x = p.x;
     pos_.y = p.y;
 }
 
 // Reinicia las variables a cero
-void SSprite::clear() {
+void SurfaceSprite::clear() {
     pos_ = {0, 0, 0, 0};
     clip_ = {0, 0, 0, 0};
 }

source/core/rendering/surface_sprite.hpp

@@ -5,8 +5,8 @@
 #include <memory>  // Para shared_ptr
 class Surface;     // lines 5-5
 
-// Clase SSprite
-class SSprite {
+// Clase SurfaceSprite
+class SurfaceSprite {
     protected:
         // Variables
         std::shared_ptr<Surface> surface_;  // Surface donde estan todos los dibujos del sprite
@@ -15,12 +15,12 @@ class SSprite {
 
     public:
         // Constructor
-        SSprite(std::shared_ptr<Surface>, float x, float y, float w, float h);
-        SSprite(std::shared_ptr<Surface>, SDL_FRect rect);
-        explicit SSprite(std::shared_ptr<Surface>);
+        SurfaceSprite(std::shared_ptr<Surface>, float x, float y, float w, float h);
+        SurfaceSprite(std::shared_ptr<Surface>, SDL_FRect rect);
+        explicit SurfaceSprite(std::shared_ptr<Surface>);
 
         // Destructor
-        virtual ~SSprite() = default;
+        virtual ~SurfaceSprite() = default;
 
         // Muestra el sprite por pantalla
         virtual void render();

source/core/rendering/text.cpp

@@ -88,7 +88,7 @@ Text::Text(std::shared_ptr<Surface> surface, const std::string& text_file) {
     }
 
     // Crea los objetos
-    sprite_ = std::make_unique<SSprite>(surface, (SDL_FRect){0.0F, 0.0F, static_cast<float>(box_width_), static_cast<float>(box_height_)});
+    sprite_ = std::make_unique<SurfaceSprite>(surface, (SDL_FRect){0.0F, 0.0F, static_cast<float>(box_width_), static_cast<float>(box_height_)});
 
     // Inicializa variables
     fixed_width_ = false;
@@ -106,7 +106,7 @@ Text::Text(std::shared_ptr<Surface> surface, std::shared_ptr<TextFile> text_file
     }
 
     // Crea los objetos
-    sprite_ = std::make_unique<SSprite>(surface, (SDL_FRect){0.0F, 0.0F, static_cast<float>(box_width_), static_cast<float>(box_height_)});
+    sprite_ = std::make_unique<SurfaceSprite>(surface, (SDL_FRect){0.0F, 0.0F, static_cast<float>(box_width_), static_cast<float>(box_height_)});
 
     // Inicializa variables
     fixed_width_ = false;

source/core/rendering/text.hpp

@@ -30,7 +30,7 @@ std::shared_ptr<TextFile> loadTextFile(const std::string& file_path);
 class Text {
     private:
         // Objetos y punteros
-        std::unique_ptr<SSprite> sprite_ = nullptr;  // Objeto con los graficos para el texto
+        std::unique_ptr<SurfaceSprite> sprite_ = nullptr;  // Objeto con los graficos para el texto
 
         // Variables
         int box_width_ = 0;            // Anchura de la caja de cada caracter en el png

source/game/entities/enemy.cpp

@@ -9,7 +9,7 @@
 
 // Constructor
 Enemy::Enemy(const EnemyData& enemy)
-    : sprite_(std::make_shared<SAnimatedSprite>(Resource::get()->getSurface(enemy.surface_path), Resource::get()->getAnimations(enemy.animation_path))),
+    : sprite_(std::make_shared<SurfaceAnimatedSprite>(Resource::get()->getSurface(enemy.surface_path), Resource::get()->getAnimations(enemy.animation_path))),
       color_string_(enemy.color),
       x1_(enemy.x1),
       x2_(enemy.x2),

source/game/entities/enemy.hpp

@@ -2,9 +2,9 @@
 
 #include <SDL3/SDL.h>
 
-#include <memory>       // Para shared_ptr
-#include <string>       // Para string
-class SAnimatedSprite;  // lines 7-7
+#include <memory>             // Para shared_ptr
+#include <string>             // Para string
+class SurfaceAnimatedSprite;  // lines 7-7
 
 // Estructura para pasar los datos de un enemigo
 struct EnemyData {
@@ -29,7 +29,7 @@ struct EnemyData {
 class Enemy {
     private:
         // Objetos y punteros
-        std::shared_ptr<SAnimatedSprite> sprite_;  // Sprite del enemigo
+        std::shared_ptr<SurfaceAnimatedSprite> sprite_;  // Sprite del enemigo
 
         // Variables
         Uint8 color_;               // Color del enemigo

source/game/entities/item.cpp

@@ -5,7 +5,7 @@
 
 // Constructor
 Item::Item(ItemData item)
-    : sprite_(std::make_shared<SSprite>(Resource::get()->getSurface(item.tile_set_file), item.x, item.y, ITEM_SIZE_, ITEM_SIZE_)),
+    : sprite_(std::make_shared<SurfaceSprite>(Resource::get()->getSurface(item.tile_set_file), item.x, item.y, ITEM_SIZE_, ITEM_SIZE_)),
       change_color_speed(4) {
     // Inicia variables
     sprite_->setClip((item.tile % 10) * ITEM_SIZE_, (item.tile / 10) * ITEM_SIZE_, ITEM_SIZE_, ITEM_SIZE_);

source/game/entities/item.hpp

@@ -5,7 +5,7 @@
 #include <memory>  // Para shared_ptr
 #include <string>  // Para string
 #include <vector>  // Para vector
-class SSprite;
+class SurfaceSprite;
 
 struct ItemData {
         std::string tile_set_file;  // Ruta al fichero con los gráficos del item
@@ -32,7 +32,7 @@ class Item {
         static constexpr float ITEM_SIZE_ = 8;
 
         // Objetos y punteros
-        std::shared_ptr<SSprite> sprite_;  // SSprite del objeto
+        std::shared_ptr<SurfaceSprite> sprite_;  // SSprite del objeto
 
         // Variables
         std::vector<Uint8> color_;  // Vector con los colores del objeto

source/game/entities/player.cpp

@@ -9,8 +9,8 @@
 #include "core/resources/resource.hpp"                 // Para Resource
 #include "core/system/debug.hpp"                       // Para Debug
 #include "external/jail_audio.h"                       // Para JA_PlaySound
-#include "game/options.hpp"                   // Para Cheat, Options, options
 #include "game/gameplay/room.hpp"                      // Para Room, TileType
+#include "game/options.hpp"                            // Para Cheat, Options, options
 #include "utils/defines.hpp"                           // Para RoomBorder::BOTTOM, RoomBorder::LEFT, RoomBorder::RIGHT
 
 // Constructor
@@ -621,7 +621,7 @@ void Player::initSprite(const std::string& surface_path, const std::string& anim
     auto surface = Resource::get()->getSurface(surface_path);
     auto animations = Resource::get()->getAnimations(animations_path);
 
-    sprite_ = std::make_shared<SAnimatedSprite>(surface, animations);
+    sprite_ = std::make_shared<SurfaceAnimatedSprite>(surface, animations);
     sprite_->setWidth(WIDTH_);
     sprite_->setHeight(HEIGHT_);
     sprite_->setCurrentAnimation("walk");

source/game/entities/player.hpp

@@ -71,8 +71,8 @@ class Player {
         static constexpr float MAX_VY_ = 1.2f;                 // Velocidad máxima que puede alcanzar al desplazarse en vertical
 
         // Objetos y punteros
-        std::shared_ptr<Room> room_;               // Objeto encargado de gestionar cada habitación del juego
-        std::shared_ptr<SAnimatedSprite> sprite_;  // Sprite del jugador
+        std::shared_ptr<Room> room_;                     // Objeto encargado de gestionar cada habitación del juego
+        std::shared_ptr<SurfaceAnimatedSprite> sprite_;  // Sprite del jugador
 
         // Variables
         float x_;                                  // Posición del jugador en el eje X

source/game/gameplay/room.cpp

@@ -12,8 +12,8 @@
 #include "core/system/debug.hpp"              // Para Debug
 #include "external/jail_audio.h"              // Para JA_PlaySound
 #include "game/gameplay/item_tracker.hpp"     // Para ItemTracker
-#include "game/options.hpp"          // Para Options, OptionsStats, options
 #include "game/gameplay/scoreboard.hpp"       // Para ScoreboardData
+#include "game/options.hpp"                   // Para Options, OptionsStats, options
 #include "utils/defines.hpp"                  // Para BLOCK, PLAY_AREA_HEIGHT, PLAY_AREA_WIDTH
 #include "utils/utils.hpp"                    // Para LineHorizontal, LineDiagonal, LineVertical
 
@@ -931,7 +931,7 @@ void Room::setAnimatedTiles() {
             const int yc = (tile_map_[i] / tile_set_width_) * TILE_SIZE_;
 
             AnimatedTile at;
-            at.sprite = std::make_shared<SSprite>(surface_, x, y, 8, 8);
+            at.sprite = std::make_shared<SurfaceSprite>(surface_, x, y, 8, 8);
             at.sprite->setClip(xc, yc, 8, 8);
             at.x_orig = xc;
             animated_tiles_.push_back(at);

source/game/gameplay/room.hpp

@@ -9,7 +9,7 @@
 #include "game/entities/enemy.hpp"  // Para EnemyData
 #include "game/entities/item.hpp"   // Para ItemData
 #include "utils/utils.hpp"          // Para LineHorizontal, LineDiagonal, LineVertical
-class SSprite;                      // lines 12-12
+class SurfaceSprite;                // lines 12-12
 class Surface;                      // lines 13-13
 struct ScoreboardData;              // lines 15-15
 
@@ -31,8 +31,8 @@ enum class RoomBorder : int {
 };
 
 struct AnimatedTile {
-        std::shared_ptr<SSprite> sprite;  // SSprite para dibujar el tile
-        int x_orig;                       // Poicion X donde se encuentra el primer tile de la animacion en la tilesheet
+        std::shared_ptr<SurfaceSprite> sprite;  // SSprite para dibujar el tile
+        int x_orig;                             // Poicion X donde se encuentra el primer tile de la animacion en la tilesheet
 };
 
 struct RoomData {

source/game/gameplay/scoreboard.cpp

@@ -7,7 +7,7 @@
 #include "core/rendering/surface_animated_sprite.hpp"  // Para SAnimatedSprite
 #include "core/rendering/text.hpp"                     // Para Text
 #include "core/resources/resource.hpp"                 // Para Resource
-#include "game/options.hpp"                   // Para Options, options, Cheat, OptionsGame
+#include "game/options.hpp"                            // Para Options, options, Cheat, OptionsGame
 #include "utils/defines.hpp"                           // Para BLOCK
 #include "utils/utils.hpp"                             // Para stringToColor
 
@@ -22,7 +22,7 @@ Scoreboard::Scoreboard(std::shared_ptr<ScoreboardData> data)
     // Reserva memoria para los objetos
     auto player_texture = Resource::get()->getSurface(Options::cheats.alternate_skin == Options::Cheat::State::ENABLED ? "player2.gif" : "player.gif");
     auto player_animations = Resource::get()->getAnimations(Options::cheats.alternate_skin == Options::Cheat::State::ENABLED ? "player2.ani" : "player.ani");
-    player_sprite_ = std::make_shared<SAnimatedSprite>(player_texture, player_animations);
+    player_sprite_ = std::make_shared<SurfaceAnimatedSprite>(player_texture, player_animations);
     player_sprite_->setCurrentAnimation("walk_menu");
 
     surface_ = std::make_shared<Surface>(SURFACE_WIDTH_, SURFACE_HEIGHT_);

source/game/gameplay/scoreboard.hpp

@@ -2,11 +2,11 @@
 
 #include <SDL3/SDL.h>
 
-#include <memory>       // Para shared_ptr
-#include <string>       // Para string, basic_string
-#include <vector>       // Para vector
-class SAnimatedSprite;  // lines 10-10
-class Surface;          // lines 11-11
+#include <memory>             // Para shared_ptr
+#include <string>             // Para string, basic_string
+#include <vector>             // Para vector
+class SurfaceAnimatedSprite;  // lines 10-10
+class Surface;                // lines 11-11
 
 struct ScoreboardData {
         int items;          // Lleva la cuenta de los objetos recogidos
@@ -62,10 +62,10 @@ class Scoreboard {
         };
 
         // Objetos y punteros
-        std::shared_ptr<SAnimatedSprite> player_sprite_;  // Sprite para mostrar las vidas en el marcador
-        std::shared_ptr<Surface> item_surface_;           // Surface con los graficos para los elementos del marcador
-        std::shared_ptr<ScoreboardData> data_;            // Contiene las variables a mostrar en el marcador
-        std::shared_ptr<Surface> surface_;                // Surface donde dibujar el marcador;
+        std::shared_ptr<SurfaceAnimatedSprite> player_sprite_;  // Sprite para mostrar las vidas en el marcador
+        std::shared_ptr<Surface> item_surface_;                 // Surface con los graficos para los elementos del marcador
+        std::shared_ptr<ScoreboardData> data_;                  // Contiene las variables a mostrar en el marcador
+        std::shared_ptr<Surface> surface_;                      // Surface donde dibujar el marcador;
 
         // Variables
         std::vector<Uint8> color_;    // Vector con los colores del objeto

source/game/options.cpp

@@ -15,18 +15,7 @@
 #include "utils/utils.hpp"  // Para stringToBool, boolToString, safeStoi
 
 namespace Options {
-// --- Variables globales ---
-std::string version;         // Versión del fichero de configuración. Sirve para saber si las opciones son compatibles
-bool console;                // Indica si ha de mostrar información por la consola de texto
-Cheat cheats;                // Contiene trucos y ventajas para el juego
-Game game;                   // Opciones de juego
-Video video;                 // Opciones de video
-Stats stats;                 // Datos con las estadisticas de juego
-Notification notifications;  // Opciones relativas a las notificaciones;
-Window window;               // Opciones relativas a la ventana
-Audio audio;                 // Opciones relativas al audio
-ControlScheme keys;          // Teclas usadas para jugar
-
+// Declaración de función interna
 bool setOptions(const std::string& var, const std::string& value);
 
 // Crea e inicializa las opciones del programa

source/game/options.hpp

@@ -312,17 +312,17 @@ struct Game {
               height(game_height) {}
 };
 
-// --- Variables ---
-extern std::string version;         // Versión del fichero de configuración. Sirve para saber si las opciones son compatibles
-extern bool console;                // Indica si ha de mostrar información por la consola de texto
-extern Cheat cheats;                // Contiene trucos y ventajas para el juego
-extern Game game;                   // Opciones de juego
-extern Video video;                 // Opciones de video
-extern Stats stats;                 // Datos con las estadisticas de juego
-extern Notification notifications;  // Opciones relativas a las notificaciones;
-extern Window window;               // Opciones relativas a la ventana
-extern Audio audio;                 // Opciones relativas al audio
-extern ControlScheme keys;          // Teclas usadas para jugar
+// --- Variables globales (inline C++17+) ---
+inline std::string version{};         // Versión del fichero de configuración. Sirve para saber si las opciones son compatibles
+inline bool console{false};           // Indica si ha de mostrar información por la consola de texto
+inline Cheat cheats{};                // Contiene trucos y ventajas para el juego
+inline Game game{};                   // Opciones de juego
+inline Video video{};                 // Opciones de video
+inline Stats stats{};                 // Datos con las estadisticas de juego
+inline Notification notifications{};  // Opciones relativas a las notificaciones;
+inline Window window{};               // Opciones relativas a la ventana
+inline Audio audio{};                 // Opciones relativas al audio
+inline ControlScheme keys{GameDefaults::CONTROL_SCHEME};  // Teclas usadas para jugar
 
 // --- Funciones ---
 void init();                                      // Crea e inicializa las opciones del programa

source/game/scenes/credits.cpp

@@ -1,5 +1,3 @@
-#include "game/scene_manager.hpp"  // Para SceneManager
-
 #include "game/scenes/credits.hpp"
 
 #include <SDL3/SDL.h>
@@ -12,14 +10,15 @@
 #include "core/rendering/surface_animated_sprite.hpp"  // Para SAnimatedSprite
 #include "core/rendering/text.hpp"                     // Para Text, TEXT_CENTER, TEXT_COLOR
 #include "core/resources/resource.hpp"                 // Para Resource
-#include "game/options.hpp"                   // Para Options, options, OptionsGame, Sectio...
+#include "game/options.hpp"                            // Para Options, options, OptionsGame, Sectio...
+#include "game/scene_manager.hpp"                      // Para SceneManager
 #include "utils/defines.hpp"                           // Para GAME_SPEED, PLAY_AREA_CENTER_X, PLAY_...
 #include "utils/global_events.hpp"                     // Para check
 #include "utils/utils.hpp"                             // Para PaletteColor
 
 // Constructor
 Credits::Credits()
-    : shining_sprite_(std::make_shared<SAnimatedSprite>(Resource::get()->getSurface("shine.gif"), Resource::get()->getAnimations("shine.ani"))) {
+    : shining_sprite_(std::make_shared<SurfaceAnimatedSprite>(Resource::get()->getSurface("shine.gif"), Resource::get()->getAnimations("shine.ani"))) {
     // Inicializa variables
     SceneManager::current = SceneManager::Scene::CREDITS;
     SceneManager::options = SceneManager::Options::NONE;

source/game/scenes/credits.hpp

@@ -2,10 +2,10 @@
 
 #include <SDL3/SDL.h>
 
-#include <memory>       // Para shared_ptr
-#include <string>       // Para string
-#include <vector>       // Para vector
-class SAnimatedSprite;  // lines 11-11
+#include <memory>             // Para shared_ptr
+#include <string>             // Para string
+#include <vector>             // Para vector
+class SurfaceAnimatedSprite;  // lines 11-11
 class Surface;
 
 class Credits {
@@ -16,9 +16,9 @@ class Credits {
         };
 
         // Objetos y punteros
-        std::shared_ptr<Surface> text_surface_;            // Textura para dibujar el texto
-        std::shared_ptr<Surface> cover_surface_;           // Textura para cubrir el texto
-        std::shared_ptr<SAnimatedSprite> shining_sprite_;  // Sprite para el brillo del corazón
+        std::shared_ptr<Surface> text_surface_;                  // Textura para dibujar el texto
+        std::shared_ptr<Surface> cover_surface_;                 // Textura para cubrir el texto
+        std::shared_ptr<SurfaceAnimatedSprite> shining_sprite_;  // Sprite para el brillo del corazón
 
         // Variables
         int counter_ = 0;              // Contador

source/game/scenes/ending.cpp

@@ -1,5 +1,3 @@
-#include "game/scene_manager.hpp"  // Para SceneManager
-
 #include "game/scenes/ending.hpp"
 
 #include <SDL3/SDL.h>
@@ -13,7 +11,8 @@
 #include "core/rendering/text.hpp"            // Para Text, TEXT_STROKE
 #include "core/resources/resource.hpp"        // Para Resource
 #include "external/jail_audio.h"              // Para JA_SetVolume, JA_PlayMusic, JA_StopMusic
-#include "game/options.hpp"          // Para Options, options, OptionsGame, SectionS...
+#include "game/options.hpp"                   // Para Options, options, OptionsGame, SectionS...
+#include "game/scene_manager.hpp"             // Para SceneManager
 #include "utils/defines.hpp"                  // Para GAME_SPEED
 #include "utils/global_events.hpp"            // Para check
 #include "utils/utils.hpp"                    // Para PaletteColor
@@ -168,7 +167,7 @@ void Ending::iniTexts() {
         text->writeDX(TEXT_STROKE, 2, 2, txt.caption, 1, text_color, 2, shadow_color);
 
         // Crea el sprite
-        st.image_sprite = std::make_shared<SSprite>(st.image_surface, 0, 0, st.image_surface->getWidth(), st.image_surface->getHeight());
+        st.image_sprite = std::make_shared<SurfaceSprite>(st.image_surface, 0, 0, st.image_surface->getWidth(), st.image_surface->getHeight());
         st.image_sprite->setPosition((Options::game.width - st.image_surface->getWidth()) / 2, txt.pos);
 
         // Crea la cover_surface
@@ -196,7 +195,7 @@ void Ending::iniTexts() {
         surface->fillRect(&rect, color);
 
         // Crea el sprite
-        st.cover_sprite = std::make_shared<SSprite>(st.cover_surface, 0, 0, st.cover_surface->getWidth(), st.cover_surface->getHeight() - 8);
+        st.cover_sprite = std::make_shared<SurfaceSprite>(st.cover_surface, 0, 0, st.cover_surface->getWidth(), st.cover_surface->getHeight() - 8);
         st.cover_sprite->setPosition((Options::game.width - st.cover_surface->getWidth()) / 2, txt.pos);
         st.cover_sprite->setClip(0, 8, st.cover_surface->getWidth(), st.cover_surface->getHeight());
 
@@ -233,7 +232,7 @@ void Ending::iniPics() {
         const float HEIGHT = sp.image_surface->getHeight();
 
         // Crea el sprite
-        sp.image_sprite = std::make_shared<SSprite>(sp.image_surface, 0, 0, WIDTH, HEIGHT);
+        sp.image_sprite = std::make_shared<SurfaceSprite>(sp.image_surface, 0, 0, WIDTH, HEIGHT);
         sp.image_sprite->setPosition((Options::game.width - WIDTH) / 2, pic.pos);
 
         // Crea la cover_surface
@@ -262,7 +261,7 @@ void Ending::iniPics() {
         surface->fillRect(&rect, color);
 
         // Crea el sprite
-        sp.cover_sprite = std::make_shared<SSprite>(sp.cover_surface, 0, 0, sp.cover_surface->getWidth(), sp.cover_surface->getHeight() - 8);
+        sp.cover_sprite = std::make_shared<SurfaceSprite>(sp.cover_surface, 0, 0, sp.cover_surface->getWidth(), sp.cover_surface->getHeight() - 8);
         sp.cover_sprite->setPosition((Options::game.width - sp.cover_surface->getWidth()) / 2, pic.pos);
         sp.cover_sprite->setClip(0, 8, sp.cover_surface->getWidth(), sp.cover_surface->getHeight());
 

source/game/scenes/ending.hpp

@@ -2,23 +2,23 @@
 
 #include <SDL3/SDL.h>
 
-#include <memory>  // Para shared_ptr
-#include <string>  // Para string
-#include <vector>  // Para vector
-class SSprite;     // lines 8-8
-class Surface;     // lines 9-9
+#include <memory>     // Para shared_ptr
+#include <string>     // Para string
+#include <vector>     // Para vector
+class SurfaceSprite;  // lines 8-8
+class Surface;        // lines 9-9
 
 class Ending {
     private:
         // Estructuras
         struct EndingSurface  // Estructura con dos texturas y sprites, uno para mostrar y el otro hace de cortinilla
         {
-                std::shared_ptr<Surface> image_surface;  // Surface a mostrar
-                std::shared_ptr<SSprite> image_sprite;   // SSprite para mostrar la textura
-                std::shared_ptr<Surface> cover_surface;  // Surface que cubre a la otra textura
-                std::shared_ptr<SSprite> cover_sprite;   // SSprite para mostrar la textura que cubre a la otra textura
-                int cover_clip_desp;                     // Desplazamiento del spriteClip de la textura de cobertura
-                int cover_clip_height;                   // Altura del spriteClip de la textura de cobertura
+                std::shared_ptr<Surface> image_surface;       // Surface a mostrar
+                std::shared_ptr<SurfaceSprite> image_sprite;  // SSprite para mostrar la textura
+                std::shared_ptr<Surface> cover_surface;       // Surface que cubre a la otra textura
+                std::shared_ptr<SurfaceSprite> cover_sprite;  // SSprite para mostrar la textura que cubre a la otra textura
+                int cover_clip_desp;                          // Desplazamiento del spriteClip de la textura de cobertura
+                int cover_clip_height;                        // Altura del spriteClip de la textura de cobertura
         };
 
         struct TextAndPosition  // Estructura con un texto y su posición en el eje Y

source/game/scenes/ending2.cpp

@@ -12,7 +12,7 @@
 #include "core/rendering/text.hpp"                     // Para Text
 #include "core/resources/resource.hpp"                 // Para Resource
 #include "external/jail_audio.h"                       // Para JA_SetVolume, JA_PlayMusic, JA_StopMusic
-#include "game/options.hpp"                   // Para Options, options, OptionsGame, Sectio...
+#include "game/options.hpp"                            // Para Options, options, OptionsGame, Sectio...
 #include "game/scene_manager.hpp"                      // Para SceneManager
 #include "utils/defines.hpp"                           // Para GAMECANVAS_CENTER_X, GAMECANVAS_CENTER_Y
 #include "utils/global_events.hpp"                     // Para check
@@ -275,7 +275,7 @@ void Ending2::loadSprites() {
 
     // Carga los sprites
     for (const auto& file : sprite_list_) {
-        sprites_.emplace_back(std::make_shared<SAnimatedSprite>(Resource::get()->getSurface(file + ".gif"), Resource::get()->getAnimations(file + ".ani")));
+        sprites_.emplace_back(std::make_shared<SurfaceAnimatedSprite>(Resource::get()->getSurface(file + ".gif"), Resource::get()->getAnimations(file + ".ani")));
         sprite_max_width_ = std::max(sprites_.back()->getWidth(), sprite_max_width_);
         sprite_max_height_ = std::max(sprites_.back()->getHeight(), sprite_max_height_);
     }
@@ -395,7 +395,7 @@ void Ending2::createSpriteTexts() {
 
         // Crea el sprite
         SDL_FRect pos = {X, Y, W, H};
-        sprite_texts_.emplace_back(std::make_shared<SMovingSprite>(surface, pos));
+        sprite_texts_.emplace_back(std::make_shared<SurfaceMovingSprite>(surface, pos));
         sprite_texts_.back()->setVelY(SPRITE_DESP_SPEED_);
         Screen::get()->setRendererSurface(previuos_renderer);
     }
@@ -426,7 +426,7 @@ void Ending2::createTexts() {
 
         // Crea el sprite
         SDL_FRect pos = {X + DX, Y, W, H};
-        texts_.emplace_back(std::make_shared<SMovingSprite>(surface, pos));
+        texts_.emplace_back(std::make_shared<SurfaceMovingSprite>(surface, pos));
         texts_.back()->setVelY(SPRITE_DESP_SPEED_);
         Screen::get()->setRendererSurface(previuos_renderer);
     }
@@ -455,7 +455,7 @@ void Ending2::createTexts() {
 
         // Crea el sprite
         SDL_FRect pos = {X + DX, Y, W, H};
-        texts_.emplace_back(std::make_shared<SMovingSprite>(surface, pos));
+        texts_.emplace_back(std::make_shared<SurfaceMovingSprite>(surface, pos));
         texts_.back()->setVelY(SPRITE_DESP_SPEED_);
         Screen::get()->setRendererSurface(previuos_renderer);
     }

source/game/scenes/ending2.hpp

@@ -7,8 +7,8 @@
 #include <vector>  // Para vector
 
 #include "utils/defines.hpp"  // Para GAMECANVAS_WIDTH, GAMECANVAS_FIRST_QUAR...
-class SAnimatedSprite;        // lines 9-9
-class SMovingSprite;          // lines 10-10
+class SurfaceAnimatedSprite;  // lines 9-9
+class SurfaceMovingSprite;    // lines 10-10
 
 class Ending2 {
     private:
@@ -62,9 +62,9 @@ class Ending2 {
         static constexpr int STATE_FADE_DURATION_ = 5000;
 
         // Objetos y punteros
-        std::vector<std::shared_ptr<SAnimatedSprite>> sprites_;     // Vector con todos los sprites a dibujar
-        std::vector<std::shared_ptr<SMovingSprite>> sprite_texts_;  // Vector con los sprites de texto de los sprites
-        std::vector<std::shared_ptr<SMovingSprite>> texts_;         // Vector con los sprites de texto
+        std::vector<std::shared_ptr<SurfaceAnimatedSprite>> sprites_;     // Vector con todos los sprites a dibujar
+        std::vector<std::shared_ptr<SurfaceMovingSprite>> sprite_texts_;  // Vector con los sprites de texto de los sprites
+        std::vector<std::shared_ptr<SurfaceMovingSprite>> texts_;         // Vector con los sprites de texto
 
         // Variables
         Uint32 ticks_ = 0;                      // Contador de ticks para ajustar la velocidad del programa

source/game/scenes/game_over.cpp

@@ -1,5 +1,3 @@
-#include "game/scene_manager.hpp"  // Para SceneManager
-
 #include "game/scenes/game_over.hpp"
 
 #include <SDL3/SDL.h>
@@ -13,15 +11,16 @@
 #include "core/rendering/text.hpp"                     // Para TEXT_CENTER, TEXT_COLOR, Text
 #include "core/resources/resource.hpp"                 // Para Resource
 #include "external/jail_audio.h"                       // Para JA_PlayMusic
-#include "game/options.hpp"                   // Para Options, options, OptionsStats, Secti...
+#include "game/options.hpp"                            // Para Options, options, OptionsStats, Secti...
+#include "game/scene_manager.hpp"                      // Para SceneManager
 #include "utils/defines.hpp"                           // Para GAMECANVAS_CENTER_X, GAME_SPEED
 #include "utils/global_events.hpp"                     // Para check
 #include "utils/utils.hpp"                             // Para PaletteColor, stringToColor
 
 // Constructor
 GameOver::GameOver()
-    : player_sprite_(std::make_shared<SAnimatedSprite>(Resource::get()->getSurface("player_game_over.gif"), Resource::get()->getAnimations("player_game_over.ani"))),
-      tv_sprite_(std::make_shared<SAnimatedSprite>(Resource::get()->getSurface("tv.gif"), Resource::get()->getAnimations("tv.ani"))),
+    : player_sprite_(std::make_shared<SurfaceAnimatedSprite>(Resource::get()->getSurface("player_game_over.gif"), Resource::get()->getAnimations("player_game_over.ani"))),
+      tv_sprite_(std::make_shared<SurfaceAnimatedSprite>(Resource::get()->getSurface("tv.gif"), Resource::get()->getAnimations("tv.ani"))),
       pre_counter_(0),
       counter_(0),
       ticks_(0) {

source/game/scenes/game_over.hpp

@@ -2,9 +2,9 @@
 
 #include <SDL3/SDL.h>
 
-#include <memory>       // Para shared_ptr
-#include <vector>       // Para vector
-class SAnimatedSprite;  // lines 7-7
+#include <memory>             // Para shared_ptr
+#include <vector>             // Para vector
+class SurfaceAnimatedSprite;  // lines 7-7
 
 class GameOver {
     private:
@@ -14,8 +14,8 @@ class GameOver {
         static constexpr int COUNTER_FADE_LENGHT_ = 20;   // Contador: duración del fade
 
         // Objetos y punteros
-        std::shared_ptr<SAnimatedSprite> player_sprite_;  // Sprite con el jugador
-        std::shared_ptr<SAnimatedSprite> tv_sprite_;      // Sprite con el televisor
+        std::shared_ptr<SurfaceAnimatedSprite> player_sprite_;  // Sprite con el jugador
+        std::shared_ptr<SurfaceAnimatedSprite> tv_sprite_;      // Sprite con el televisor
 
         // Variables
         int pre_counter_ = 0;        // Contador previo

source/game/scenes/loading_screen.cpp

@@ -1,5 +1,3 @@
-#include "game/scene_manager.hpp"  // Para SceneManager
-
 #include "game/scenes/loading_screen.hpp"
 
 #include <SDL3/SDL.h>
@@ -11,7 +9,8 @@
 #include "core/rendering/surface_sprite.hpp"  // Para SSprite
 #include "core/resources/resource.hpp"        // Para Resource
 #include "external/jail_audio.h"              // Para JA_PlayMusic, JA_SetVolume, JA_StopMusic
-#include "game/options.hpp"          // Para Options, options, SectionState, Options...
+#include "game/options.hpp"                   // Para Options, options, SectionState, Options...
+#include "game/scene_manager.hpp"             // Para SceneManager
 #include "utils/defines.hpp"                  // Para GAME_SPEED
 #include "utils/global_events.hpp"            // Para check
 #include "utils/utils.hpp"                    // Para stringToColor, PaletteColor
@@ -20,8 +19,8 @@
 LoadingScreen::LoadingScreen()
     : mono_loading_screen_surface_(Resource::get()->getSurface("loading_screen_bn.gif")),
       color_loading_screen_surface_(Resource::get()->getSurface("loading_screen_color.gif")),
-      mono_loading_screen_sprite_(std::make_shared<SSprite>(mono_loading_screen_surface_, 0, 0, mono_loading_screen_surface_->getWidth(), mono_loading_screen_surface_->getHeight())),
-      color_loading_screen_sprite_(std::make_shared<SSprite>(color_loading_screen_surface_, 0, 0, color_loading_screen_surface_->getWidth(), color_loading_screen_surface_->getHeight())),
+      mono_loading_screen_sprite_(std::make_shared<SurfaceSprite>(mono_loading_screen_surface_, 0, 0, mono_loading_screen_surface_->getWidth(), mono_loading_screen_surface_->getHeight())),
+      color_loading_screen_sprite_(std::make_shared<SurfaceSprite>(color_loading_screen_surface_, 0, 0, color_loading_screen_surface_->getWidth(), color_loading_screen_surface_->getHeight())),
       screen_surface_(std::make_shared<Surface>(Options::game.width, Options::game.height)) {
     // Configura la superficie donde se van a pintar los sprites
     screen_surface_->clear(static_cast<Uint8>(PaletteColor::WHITE));

source/game/scenes/loading_screen.hpp

@@ -2,18 +2,18 @@
 
 #include <SDL3/SDL.h>
 
-#include <memory>  // Para shared_ptr
-class SSprite;     // lines 7-7
-class Surface;     // lines 8-8
+#include <memory>     // Para shared_ptr
+class SurfaceSprite;  // lines 7-7
+class Surface;        // lines 8-8
 
 class LoadingScreen {
     private:
         // Objetos y punteros
-        std::shared_ptr<Surface> mono_loading_screen_surface_;   // Surface con la pantalla de carga en blanco y negro
-        std::shared_ptr<Surface> color_loading_screen_surface_;  // Surface con la pantalla de carga en color
-        std::shared_ptr<SSprite> mono_loading_screen_sprite_;    // SSprite para manejar la textura loadingScreenTexture1
-        std::shared_ptr<SSprite> color_loading_screen_sprite_;   // SSprite para manejar la textura loadingScreenTexture2
-        std::shared_ptr<Surface> screen_surface_;                // Surface para dibujar la pantalla de carga
+        std::shared_ptr<Surface> mono_loading_screen_surface_;        // Surface con la pantalla de carga en blanco y negro
+        std::shared_ptr<Surface> color_loading_screen_surface_;       // Surface con la pantalla de carga en color
+        std::shared_ptr<SurfaceSprite> mono_loading_screen_sprite_;   // SSprite para manejar la textura loadingScreenTexture1
+        std::shared_ptr<SurfaceSprite> color_loading_screen_sprite_;  // SSprite para manejar la textura loadingScreenTexture2
+        std::shared_ptr<Surface> screen_surface_;                     // Surface para dibujar la pantalla de carga
 
         // Variables
         int pre_counter_ = 0;                  // Contador previo para realizar una pausa inicial

source/game/scenes/logo.cpp

@@ -1,15 +1,16 @@
 #include "game/scenes/logo.hpp"
 
 #include <SDL3/SDL.h>
+#include <algorithm>  // Para std::clamp
 
 #include "core/input/global_inputs.hpp"       // Para check
 #include "core/rendering/screen.hpp"          // Para Screen
 #include "core/rendering/surface.hpp"         // Para Surface
 #include "core/rendering/surface_sprite.hpp"  // Para SSprite
 #include "core/resources/resource.hpp"        // Para Resource
-#include "game/options.hpp"          // Para Options, SectionState, options, Section
+#include "game/options.hpp"                   // Para Options, SectionState, options, Section
 #include "game/scene_manager.hpp"             // Para SceneManager
-#include "utils/defines.hpp"                  // Para GAME_SPEED
+#include "utils/delta_timer.hpp"              // Para DeltaTimer
 #include "utils/global_events.hpp"            // Para check
 #include "utils/utils.hpp"                    // Para PaletteColor
 
@@ -17,35 +18,20 @@
 Logo::Logo()
     : jailgames_surface_(Resource::get()->getSurface("jailgames.gif")),
       since_1998_surface_(Resource::get()->getSurface("since_1998.gif")),
-      since_1998_sprite_(std::make_shared<SSprite>(since_1998_surface_, (256 - since_1998_surface_->getWidth()) / 2, 83 + jailgames_surface_->getHeight() + 5, since_1998_surface_->getWidth(), since_1998_surface_->getHeight())) {
+      since_1998_sprite_(std::make_shared<SurfaceSprite>(since_1998_surface_, (256 - since_1998_surface_->getWidth()) / 2, 83 + jailgames_surface_->getHeight() + 5, since_1998_surface_->getWidth(), since_1998_surface_->getHeight())),
+      delta_timer_(std::make_unique<DeltaTimer>()),
+      state_(LogoState::INITIAL),
+      state_time_(0.0f) {
+    // Configura variables
     since_1998_sprite_->setClip(0, 0, since_1998_surface_->getWidth(), since_1998_surface_->getHeight());
     since_1998_color_ = static_cast<Uint8>(PaletteColor::BLACK);
     jailgames_color_ = static_cast<Uint8>(PaletteColor::BRIGHT_WHITE);
 
-    // Crea los sprites de cada linea
-    for (int i = 0; i < jailgames_surface_->getHeight(); ++i) {
-        jailgames_sprite_.push_back(std::make_shared<SSprite>(jailgames_surface_, 0, i, jailgames_surface_->getWidth(), 1));
-        jailgames_sprite_.back()->setClip(0, i, jailgames_surface_->getWidth(), 1);
-        jailgames_sprite_.at(i)->setX((i % 2 == 0) ? (256 + (i * 3)) : (-181 - (i * 3)));
-        jailgames_sprite_.at(i)->setY(83 + i);
-    }
-
     // Inicializa variables
     SceneManager::current = SceneManager::Scene::LOGO;
 
-    // Inicializa el vector de colores
-    const std::vector<Uint8> COLORS = {
-        static_cast<Uint8>(PaletteColor::BLACK),
-        static_cast<Uint8>(PaletteColor::BLUE),
-        static_cast<Uint8>(PaletteColor::RED),
-        static_cast<Uint8>(PaletteColor::MAGENTA),
-        static_cast<Uint8>(PaletteColor::GREEN),
-        static_cast<Uint8>(PaletteColor::CYAN),
-        static_cast<Uint8>(PaletteColor::YELLOW),
-        static_cast<Uint8>(PaletteColor::BRIGHT_WHITE)};
-    for (const auto& color : COLORS) {
-        color_.push_back(color);
-    }
+    initSprites();  // Crea los sprites de cada linea
+    initColors();   // Inicializa el vector de colores
 
     // Cambia el color del borde
     Screen::get()->setBorderColor(static_cast<Uint8>(PaletteColor::BLACK));
@@ -64,119 +50,140 @@ void Logo::checkInput() {
     globalInputs::check();
 }
 
-// Gestiona el logo de JAILGAME
-void Logo::updateJAILGAMES() {
-    if (counter_ > 30) {
-        for (int i = 1; i < (int)jailgames_sprite_.size(); ++i) {
-            constexpr int SPEED = 8;
-            constexpr int DEST = 37;
-            if (jailgames_sprite_.at(i)->getX() != 37) {
-                if (i % 2 == 0) {
-                    jailgames_sprite_.at(i)->incX(-SPEED);
-                    if (jailgames_sprite_.at(i)->getX() < DEST) {
-                        jailgames_sprite_.at(i)->setX(DEST);
-                    }
-                } else {
-                    jailgames_sprite_.at(i)->incX(SPEED);
-                    if (jailgames_sprite_.at(i)->getX() > DEST) {
-                        jailgames_sprite_.at(i)->setX(DEST);
-                    }
-                }
+// Gestiona el logo de JAILGAME (time-based)
+void Logo::updateJAILGAMES(float delta_time) {
+    // Solo actualizar durante el estado JAILGAMES_SLIDE_IN
+    if (state_ != LogoState::JAILGAMES_SLIDE_IN) {
+        return;
+    }
+
+    // Calcular el desplazamiento basado en velocidad y delta time
+    const float displacement = JAILGAMES_SLIDE_SPEED * delta_time;
+
+    // Actualizar cada línea del sprite JAILGAMES
+    for (size_t i = 1; i < jailgames_sprite_.size(); ++i) {
+        const int current_x = jailgames_sprite_[i]->getX();
+
+        // Las líneas pares se mueven desde la derecha, las impares desde la izquierda
+        if (i % 2 == 0) {
+            // Mover hacia la izquierda
+            if (current_x > JAILGAMES_DEST_X) {
+                const int new_x = static_cast<int>(current_x - displacement);
+                jailgames_sprite_[i]->setX(new_x < JAILGAMES_DEST_X ? JAILGAMES_DEST_X : new_x);
+            }
+        } else {
+            // Mover hacia la derecha
+            if (current_x < JAILGAMES_DEST_X) {
+                const int new_x = static_cast<int>(current_x + displacement);
+                jailgames_sprite_[i]->setX(new_x > JAILGAMES_DEST_X ? JAILGAMES_DEST_X : new_x);
             }
         }
     }
 }
 
+// Calcula el índice de color según el progreso (0.0-1.0)
+int Logo::getColorIndex(float progress) const {
+    // Asegurar que progress esté en el rango [0.0, 1.0]
+    progress = std::clamp(progress, 0.0f, 1.0f);
+
+    // Mapear el progreso al índice de color (0-7)
+    const int max_index = static_cast<int>(color_.size()) - 1;
+    const int index = static_cast<int>(progress * max_index);
+
+    return index;
+}
+
 // Gestiona el color de las texturas
 void Logo::updateTextureColors() {
-    constexpr int INI = 70;
-    constexpr int INC = 4;
+    switch (state_) {
+        case LogoState::SINCE_1998_FADE_IN: {
+            // Fade-in de "Since 1998" de negro a blanco
+            const float progress = state_time_ / SINCE_1998_FADE_DURATION;
+            since_1998_color_ = color_[getColorIndex(progress)];
+            break;
+        }
 
-    if (counter_ == INI + INC * 0) {
-        since_1998_color_ = color_.at(0);
+        case LogoState::DISPLAY: {
+            // Asegurar que ambos logos estén en blanco durante el display
+            jailgames_color_ = color_.back();  // BRIGHT_WHITE
+            since_1998_color_ = color_.back(); // BRIGHT_WHITE
+            break;
+        }
+
+        case LogoState::FADE_OUT: {
+            // Fade-out de ambos logos de blanco a negro
+            const float progress = 1.0f - (state_time_ / FADE_OUT_DURATION);
+            const int color_index = getColorIndex(progress);
+            jailgames_color_ = color_[color_index];
+            since_1998_color_ = color_[color_index];
+            break;
+        }
+
+        default:
+            // En otros estados, mantener los colores actuales
+            break;
     }
+}
 
-    else if (counter_ == INI + INC * 1) {
-        since_1998_color_ = color_.at(1);
-    }
+// Transiciona a un nuevo estado
+void Logo::transitionToState(LogoState new_state) {
+    state_ = new_state;
+    state_time_ = 0.0f;
+}
 
-    else if (counter_ == INI + INC * 2) {
-        since_1998_color_ = color_.at(2);
-    }
+// Actualiza el estado actual
+void Logo::updateState(float delta_time) {
+    state_time_ += delta_time;
 
-    else if (counter_ == INI + INC * 3) {
-        since_1998_color_ = color_.at(3);
-    }
+    // Gestionar transiciones entre estados basándose en el tiempo
+    switch (state_) {
+        case LogoState::INITIAL:
+            if (state_time_ >= INITIAL_DELAY) {
+                transitionToState(LogoState::JAILGAMES_SLIDE_IN);
+            }
+            break;
 
-    else if (counter_ == INI + INC * 4) {
-        since_1998_color_ = color_.at(4);
-    }
+        case LogoState::JAILGAMES_SLIDE_IN:
+            if (state_time_ >= JAILGAMES_SLIDE_DURATION) {
+                transitionToState(LogoState::SINCE_1998_FADE_IN);
+            }
+            break;
 
-    else if (counter_ == INI + INC * 5) {
-        since_1998_color_ = color_.at(5);
-    }
+        case LogoState::SINCE_1998_FADE_IN:
+            if (state_time_ >= SINCE_1998_FADE_DURATION) {
+                transitionToState(LogoState::DISPLAY);
+            }
+            break;
 
-    else if (counter_ == INI + INC * 6) {
-        since_1998_color_ = color_.at(6);
-    }
+        case LogoState::DISPLAY:
+            if (state_time_ >= DISPLAY_DURATION) {
+                transitionToState(LogoState::FADE_OUT);
+            }
+            break;
 
-    else if (counter_ == INI + INC * 7) {
-        since_1998_color_ = color_.at(7);
-    }
+        case LogoState::FADE_OUT:
+            if (state_time_ >= FADE_OUT_DURATION) {
+                transitionToState(LogoState::END);
+                endSection();
+            }
+            break;
 
-    else if (counter_ == INIT_FADE_ + INC * 0) {
-        jailgames_color_ = color_.at(6);
-        since_1998_color_ = color_.at(6);
-    }
-
-    else if (counter_ == INIT_FADE_ + INC * 1) {
-        jailgames_color_ = color_.at(5);
-        since_1998_color_ = color_.at(5);
-    }
-
-    else if (counter_ == INIT_FADE_ + INC * 2) {
-        jailgames_color_ = color_.at(4);
-        since_1998_color_ = color_.at(4);
-    }
-
-    else if (counter_ == INIT_FADE_ + INC * 3) {
-        jailgames_color_ = color_.at(3);
-        since_1998_color_ = color_.at(3);
-    }
-
-    else if (counter_ == INIT_FADE_ + INC * 4) {
-        jailgames_color_ = color_.at(2);
-        since_1998_color_ = color_.at(2);
-    }
-
-    else if (counter_ == INIT_FADE_ + INC * 5) {
-        jailgames_color_ = color_.at(1);
-        since_1998_color_ = color_.at(1);
-    }
-
-    else if (counter_ == INIT_FADE_ + INC * 6) {
-        jailgames_color_ = color_.at(0);
-        since_1998_color_ = color_.at(0);
+        case LogoState::END:
+            // Estado final, no hacer nada
+            break;
     }
 }
 
 // Actualiza las variables
 void Logo::update() {
-    // Comprueba que la diferencia de ticks sea mayor a la velocidad del juego
-    if (SDL_GetTicks() - ticks_ > GAME_SPEED) {
-        ticks_ = SDL_GetTicks();  // Actualiza el contador de ticks
+    // Obtener delta time desde el último frame
+    const float delta_time = delta_timer_->tick();
 
-        checkInput();             // Comprueba las entradas
-        counter_++;               // Incrementa el contador
-        updateJAILGAMES();        // Gestiona el logo de JAILGAME
-        updateTextureColors();    // Gestiona el color de las texturas
-        Screen::get()->update();  // Actualiza el objeto Screen
-
-        // Comprueba si ha terminado el logo
-        if (counter_ == END_LOGO_ + POST_LOGO_) {
-            endSection();
-        }
-    }
+    checkInput();                 // Comprueba las entradas
+    updateState(delta_time);      // Actualiza el estado y gestiona transiciones
+    updateJAILGAMES(delta_time);  // Gestiona el logo de JAILGAME
+    updateTextureColors();        // Gestiona el color de las texturas
+    Screen::get()->update();      // Actualiza el objeto Screen
 }
 
 // Dibuja en pantalla
@@ -186,8 +193,8 @@ void Logo::render() {
     Screen::get()->clearSurface(static_cast<Uint8>(PaletteColor::BLACK));
 
     // Dibuja los objetos
-    for (const auto& s : jailgames_sprite_) {
-        s->render(1, jailgames_color_);
+    for (const auto& sprite : jailgames_sprite_) {
+        sprite->render(1, jailgames_color_);
     }
     since_1998_sprite_->render(1, since_1998_color_);
 
@@ -220,3 +227,31 @@ void Logo::endSection() {
             break;
     }
 }
+
+// Inicializa el vector de colores
+void Logo::initColors() {
+    // Inicializa el vector de colores
+    const std::vector<Uint8> COLORS = {
+        static_cast<Uint8>(PaletteColor::BLACK),
+        static_cast<Uint8>(PaletteColor::BLUE),
+        static_cast<Uint8>(PaletteColor::RED),
+        static_cast<Uint8>(PaletteColor::MAGENTA),
+        static_cast<Uint8>(PaletteColor::GREEN),
+        static_cast<Uint8>(PaletteColor::CYAN),
+        static_cast<Uint8>(PaletteColor::YELLOW),
+        static_cast<Uint8>(PaletteColor::BRIGHT_WHITE)};
+    for (const auto& color : COLORS) {
+        color_.push_back(color);
+    }
+}
+
+// Crea los sprites de cada linea
+void Logo::initSprites() {
+    const float WIDTH = jailgames_surface_->getWidth();
+    for (int i = 0; i < jailgames_surface_->getHeight(); ++i) {
+        jailgames_sprite_.push_back(std::make_shared<SurfaceSprite>(jailgames_surface_, 0, i, jailgames_surface_->getWidth(), 1));
+        jailgames_sprite_.back()->setClip(0, i, jailgames_surface_->getWidth(), 1);
+        jailgames_sprite_.at(i)->setX((i % 2 == 0) ? (256 + (i * 3)) : (-WIDTH - (i * 3)));
+        jailgames_sprite_.at(i)->setY(83 + i);
+    }
+}

source/game/scenes/logo.hpp

@@ -2,59 +2,65 @@
 
 #include <SDL3/SDL.h>
 
-#include <memory>  // Para shared_ptr
-#include <vector>  // Para vector
-class SSprite;     // lines 7-7
-class Surface;     // lines 8-8
+#include <memory>     // Para shared_ptr
+#include <vector>     // Para vector
+#include "utils/delta_timer.hpp"  // Para DeltaTimer
+class SurfaceSprite;  // Forward declaration
+class Surface;        // Forward declaration
+
+// Estados de la secuencia del logo
+enum class LogoState {
+    INITIAL,              // Espera inicial
+    JAILGAMES_SLIDE_IN,   // Las líneas de JAILGAMES se deslizan hacia el centro
+    SINCE_1998_FADE_IN,   // Aparición gradual del texto "Since 1998"
+    DISPLAY,              // Logo completo visible
+    FADE_OUT,             // Desaparición gradual
+    END                   // Fin de la secuencia
+};
 
 class Logo {
-    private:
-        // Constantes
-        static constexpr int INIT_FADE_ = 300;  // Tiempo del contador cuando inicia el fade a negro
-        static constexpr int END_LOGO_ = 400;   // Tiempo del contador para terminar el logo
-        static constexpr int POST_LOGO_ = 20;   // Tiempo que dura el logo con el fade al maximo
-
-        // Objetos y punteros
-        std::shared_ptr<Surface> jailgames_surface_;              // Textura con los graficos "JAILGAMES"
-        std::shared_ptr<Surface> since_1998_surface_;             // Textura con los graficos "Since 1998"
-        std::vector<std::shared_ptr<SSprite>> jailgames_sprite_;  // Vector con los sprites de cada linea que forman el bitmap JAILGAMES
-        std::shared_ptr<SSprite> since_1998_sprite_;              // SSprite para manejar la textura2
-        Uint8 jailgames_color_ = 0;                               // Color para el sprite de "JAILGAMES"
-        Uint8 since_1998_color_ = 0;                              // Color para el sprite de "Since 1998"
-
-        // Variables
-        std::vector<Uint8> color_;  // Vector con los colores para el fade
-        int counter_ = 0;           // Contador
-        Uint32 ticks_ = 0;          // Contador de ticks para ajustar la velocidad del programa
-
-        // Actualiza las variables
-        void update();
-
-        // Dibuja en pantalla
-        void render();
-
-        // Comprueba el manejador de eventos
-        void checkEvents();
-
-        // Comprueba las entradas
-        void checkInput();
-
-        // Gestiona el logo de JAILGAME
-        void updateJAILGAMES();
-
-        // Gestiona el color de las texturas
-        void updateTextureColors();
-
-        // Termina la sección
-        void endSection();
-
     public:
-        // Constructor
-        Logo();
+        Logo();             // Constructor
+        ~Logo() = default;  // Destructor
+        void run();         // Bucle principal
 
-        // Destructor
-        ~Logo() = default;
+    private:
+        // --- Constantes de tiempo (en segundos) ---
+        static constexpr float INITIAL_DELAY = 0.5f;           // Tiempo antes de que empiece la animación
+        static constexpr float JAILGAMES_SLIDE_DURATION = 1.2f; // Duración del slide-in de JAILGAMES
+        static constexpr float SINCE_1998_FADE_DURATION = 0.5f; // Duración del fade-in de "Since 1998"
+        static constexpr float DISPLAY_DURATION = 3.5f;         // Tiempo que el logo permanece visible
+        static constexpr float FADE_OUT_DURATION = 0.5f;        // Duración del fade-out final
 
-        // Bucle principal
-        void run();
+        // --- Constantes de animación ---
+        static constexpr float JAILGAMES_SLIDE_SPEED = 800.0f;  // Velocidad de slide-in (pixels/segundo)
+        static constexpr int JAILGAMES_DEST_X = 37;             // Posición X de destino para JAILGAMES
+
+        // --- Objetos y punteros ---
+        std::shared_ptr<Surface> jailgames_surface_;                    // Textura con los graficos "JAILGAMES"
+        std::shared_ptr<Surface> since_1998_surface_;                   // Textura con los graficos "Since 1998"
+        std::vector<std::shared_ptr<SurfaceSprite>> jailgames_sprite_;  // Vector con los sprites de cada linea que forman el bitmap JAILGAMES
+        std::shared_ptr<SurfaceSprite> since_1998_sprite_;              // SSprite para manejar la textura2
+        Uint8 jailgames_color_ = 0;                                     // Color para el sprite de "JAILGAMES"
+        Uint8 since_1998_color_ = 0;                                    // Color para el sprite de "Since 1998"
+
+        // --- Variables de estado ---
+        std::vector<Uint8> color_;       // Vector con los colores para el fade
+        std::unique_ptr<DeltaTimer> delta_timer_;  // Timer para delta time
+        LogoState state_;                // Estado actual de la secuencia
+        float state_time_;               // Tiempo acumulado en el estado actual
+
+        // --- Funciones ---
+        void update();                              // Actualiza las variables
+        void render();                              // Dibuja en pantalla
+        void checkEvents();                         // Comprueba el manejador de eventos
+        void checkInput();                          // Comprueba las entradas
+        void updateJAILGAMES(float delta_time);     // Gestiona el logo de JAILGAME (time-based)
+        void updateTextureColors();                 // Gestiona el color de las texturas
+        void updateState(float delta_time);         // Actualiza el estado actual
+        void transitionToState(LogoState new_state); // Transiciona a un nuevo estado
+        int getColorIndex(float progress) const;    // Calcula el índice de color según el progreso (0.0-1.0)
+        void endSection();                          // Termina la sección
+        void initColors();                          // Inicializa el vector de colores
+        void initSprites();                         // Crea los sprites de cada linea
 };

source/game/scenes/title.cpp

@@ -1,5 +1,3 @@
-#include "game/scene_manager.hpp"  // Para SceneManager
-
 #include "game/scenes/title.hpp"
 
 #include <SDL3/SDL.h>
@@ -14,7 +12,8 @@
 #include "core/rendering/text.hpp"            // Para Text, TEXT_CENTER, TEXT_COLOR
 #include "core/resources/resource.hpp"        // Para Resource
 #include "game/gameplay/cheevos.hpp"          // Para Cheevos, Achievement
-#include "game/options.hpp"          // Para Options, options, SectionState, Section
+#include "game/options.hpp"                   // Para Options, options, SectionState, Section
+#include "game/scene_manager.hpp"             // Para SceneManager
 #include "utils/defines.hpp"                  // Para PLAY_AREA_CENTER_X, GAMECANVAS_WIDTH
 #include "utils/global_events.hpp"            // Para check
 #include "utils/utils.hpp"                    // Para stringToColor, PaletteColor, playMusic
@@ -22,9 +21,9 @@
 // Constructor
 Title::Title()
     : title_logo_surface_(Resource::get()->getSurface("title_logo.gif")),
-      title_logo_sprite_(std::make_shared<SSprite>(title_logo_surface_, 29, 9, title_logo_surface_->getWidth(), title_logo_surface_->getHeight())),
+      title_logo_sprite_(std::make_shared<SurfaceSprite>(title_logo_surface_, 29, 9, title_logo_surface_->getWidth(), title_logo_surface_->getHeight())),
       loading_screen_surface_(Resource::get()->getSurface("loading_screen_color.gif")),
-      loading_screen_sprite_(std::make_shared<SSprite>(loading_screen_surface_, 0, 0, loading_screen_surface_->getWidth(), loading_screen_surface_->getHeight())),
+      loading_screen_sprite_(std::make_shared<SurfaceSprite>(loading_screen_surface_, 0, 0, loading_screen_surface_->getWidth(), loading_screen_surface_->getHeight())),
       bg_surface_(std::make_shared<Surface>(Options::game.width, Options::game.height)) {
     // Inicializa variables
     state_ = SceneManager::options == SceneManager::Options::TITLE_WITH_LOADING_SCREEN ? TitleState::SHOW_LOADING_SCREEN : TitleState::SHOW_MENU;
@@ -321,7 +320,7 @@ void Title::createCheevosTexture() {
     Screen::get()->setRendererSurface(previuos_renderer);
 
     // Crea el sprite para el listado de logros
-    cheevos_sprite_ = std::make_shared<SSprite>(cheevos_surface_, (GAMECANVAS_WIDTH - cheevos_surface_->getWidth()) / 2, CHEEVOS_TEXTURE_POS_Y, cheevos_surface_->getWidth(), cheevos_surface_->getHeight());
+    cheevos_sprite_ = std::make_shared<SurfaceSprite>(cheevos_surface_, (GAMECANVAS_WIDTH - cheevos_surface_->getWidth()) / 2, CHEEVOS_TEXTURE_POS_Y, cheevos_surface_->getWidth(), cheevos_surface_->getHeight());
     cheevos_surface_view_ = {0, 0, cheevos_surface_->getWidth(), CHEEVOS_TEXTURE_VIEW_HEIGHT};
     cheevos_sprite_->setClip(cheevos_surface_view_);
 }

source/game/scenes/title.hpp

@@ -2,11 +2,11 @@
 
 #include <SDL3/SDL.h>
 
-#include <memory>  // Para shared_ptr
-#include <string>  // Para string
-#include <vector>  // Para vector
-class SSprite;     // lines 9-9
-class Surface;     // lines 10-10
+#include <memory>     // Para shared_ptr
+#include <string>     // Para string
+#include <vector>     // Para vector
+class SurfaceSprite;  // lines 9-9
+class Surface;        // lines 10-10
 
 class Title {
     private:
@@ -23,13 +23,13 @@ class Title {
         };
 
         // Objetos y punteros
-        std::shared_ptr<Surface> title_logo_surface_;      // Textura con los graficos
-        std::shared_ptr<SSprite> title_logo_sprite_;       // SSprite para manejar la surface
-        std::shared_ptr<Surface> loading_screen_surface_;  // Surface con los gráficos de la pantalla de carga
-        std::shared_ptr<SSprite> loading_screen_sprite_;   // SSprite con los gráficos de la pantalla de carga
-        std::shared_ptr<Surface> bg_surface_;              // Textura para dibujar el fondo de la pantalla
-        std::shared_ptr<Surface> cheevos_surface_;         // Textura con la lista de logros
-        std::shared_ptr<SSprite> cheevos_sprite_;          // SSprite para manejar la surface con la lista de logros
+        std::shared_ptr<Surface> title_logo_surface_;           // Textura con los graficos
+        std::shared_ptr<SurfaceSprite> title_logo_sprite_;      // SSprite para manejar la surface
+        std::shared_ptr<Surface> loading_screen_surface_;       // Surface con los gráficos de la pantalla de carga
+        std::shared_ptr<SurfaceSprite> loading_screen_sprite_;  // SSprite con los gráficos de la pantalla de carga
+        std::shared_ptr<Surface> bg_surface_;                   // Textura para dibujar el fondo de la pantalla
+        std::shared_ptr<Surface> cheevos_surface_;              // Textura con la lista de logros
+        std::shared_ptr<SurfaceSprite> cheevos_sprite_;         // SSprite para manejar la surface con la lista de logros
 
         // Variables
         int counter_ = 0;                   // Contador

source/game/ui/notifier.cpp

@@ -13,7 +13,7 @@
 #include "core/rendering/text.hpp"            // Para Text, TEXT_CENTER, TEXT_COLOR
 #include "core/resources/resource.hpp"        // Para Resource
 #include "external/jail_audio.h"              // Para JA_PlaySound
-#include "game/options.hpp"          // Para Options, options, NotificationPosition
+#include "game/options.hpp"                   // Para Options, options, NotificationPosition
 #include "utils/utils.hpp"                    // Para PaletteColor
 
 // [SINGLETON]
@@ -217,7 +217,7 @@ void Notifier::show(std::vector<std::string> texts, NotificationText text_is, Ui
 
     // Dibuja el icono de la notificación
     if (has_icons_ && icon >= 0 && texts.size() >= 2) {
-        auto sp = std::make_unique<SSprite>(icon_surface_, (SDL_FRect){0, 0, ICON_SIZE_, ICON_SIZE_});
+        auto sp = std::make_unique<SurfaceSprite>(icon_surface_, (SDL_FRect){0, 0, ICON_SIZE_, ICON_SIZE_});
         sp->setPosition({PADDING_IN_H, PADDING_IN_V, ICON_SIZE_, ICON_SIZE_});
         sp->setClip((SDL_FRect){ICON_SIZE_ * (icon % 10), ICON_SIZE_ * (icon / 10), ICON_SIZE_, ICON_SIZE_});
         sp->render();
@@ -245,7 +245,7 @@ void Notifier::show(std::vector<std::string> texts, NotificationText text_is, Ui
     Screen::get()->setRendererSurface(previuos_renderer);
 
     // Crea el sprite de la notificación
-    n.sprite = std::make_shared<SSprite>(n.surface, n.rect);
+    n.sprite = std::make_shared<SurfaceSprite>(n.surface, n.rect);
 
     // Añade la notificación a la lista
     notifications_.emplace_back(n);

source/game/ui/notifier.hpp

@@ -2,12 +2,12 @@
 
 #include <SDL3/SDL.h>
 
-#include <memory>  // Para shared_ptr
-#include <string>  // Para string, basic_string
-#include <vector>  // Para vector
-class SSprite;     // lines 8-8
-class Surface;     // lines 10-10
-class Text;        // lines 9-9
+#include <memory>     // Para shared_ptr
+#include <string>     // Para string, basic_string
+#include <vector>     // Para vector
+class SurfaceSprite;  // lines 8-8
+class Surface;        // lines 10-10
+class Text;           // lines 9-9
 
 // Constantes
 constexpr Uint32 DEFAULT_NOTIFICATION_DURATION = 2000;
@@ -41,20 +41,20 @@ class Notifier {
         };
 
         struct Notification {
-                std::shared_ptr<Surface> surface;  // Superficie asociada a la notificación
-                std::shared_ptr<SSprite> sprite;   // Sprite asociado para gráficos o animaciones
-                std::vector<std::string> texts;    // Lista de textos incluidos en la notificación
-                NotificationStatus state;          // Estado actual de la notificación (RISING, SHOWING, etc.)
-                NotificationShape shape;           // Forma de la notificación (ej. SQUARED o ROUNDED)
-                SDL_FRect rect;                    // Dimensiones y posición de la notificación en pantalla
-                int y;                             // Posición actual en el eje Y
-                int travel_dist;                   // Distancia a recorrer (por ejemplo, en animaciones)
-                std::string code;                  // Código identificador único para esta notificación
-                bool can_be_removed;               // Indica si la notificación puede ser eliminada
-                int height;                        // Altura de la notificación
-                Uint32 start_time;                 // Momento en que se creó la notificación
-                Uint32 elapsed_time;               // Tiempo transcurrido desde la creación
-                Uint32 display_duration;           // Duración total para mostrar la notificación
+                std::shared_ptr<Surface> surface;       // Superficie asociada a la notificación
+                std::shared_ptr<SurfaceSprite> sprite;  // Sprite asociado para gráficos o animaciones
+                std::vector<std::string> texts;         // Lista de textos incluidos en la notificación
+                NotificationStatus state;               // Estado actual de la notificación (RISING, SHOWING, etc.)
+                NotificationShape shape;                // Forma de la notificación (ej. SQUARED o ROUNDED)
+                SDL_FRect rect;                         // Dimensiones y posición de la notificación en pantalla
+                int y;                                  // Posición actual en el eje Y
+                int travel_dist;                        // Distancia a recorrer (por ejemplo, en animaciones)
+                std::string code;                       // Código identificador único para esta notificación
+                bool can_be_removed;                    // Indica si la notificación puede ser eliminada
+                int height;                             // Altura de la notificación
+                Uint32 start_time;                      // Momento en que se creó la notificación
+                Uint32 elapsed_time;                    // Tiempo transcurrido desde la creación
+                Uint32 display_duration;                // Duración total para mostrar la notificación
 
                 // Constructor
                 explicit Notification()

source/utils/delta_timer.cpp

@@ -0,0 +1,39 @@
+#include "utils/delta_timer.hpp"
+
+DeltaTimer::DeltaTimer() noexcept
+    : last_counter_(SDL_GetPerformanceCounter()),
+      perf_freq_(static_cast<double>(SDL_GetPerformanceFrequency())),
+      time_scale_(1.0f) {
+}
+
+float DeltaTimer::tick() noexcept {
+    const Uint64 now = SDL_GetPerformanceCounter();
+    const Uint64 diff = (now > last_counter_) ? (now - last_counter_) : 0;
+    last_counter_ = now;
+    const double seconds = static_cast<double>(diff) / perf_freq_;
+    return static_cast<float>(seconds * static_cast<double>(time_scale_));
+}
+
+float DeltaTimer::peek() const noexcept {
+    const Uint64 now = SDL_GetPerformanceCounter();
+    const Uint64 diff = (now > last_counter_) ? (now - last_counter_) : 0;
+    const double seconds = static_cast<double>(diff) / perf_freq_;
+    return static_cast<float>(seconds * static_cast<double>(time_scale_));
+}
+
+void DeltaTimer::reset(Uint64 counter) noexcept {
+    if (counter == 0) {
+        last_counter_ = SDL_GetPerformanceCounter();
+    } else {
+        last_counter_ = counter;
+    }
+}
+
+void DeltaTimer::setTimeScale(float scale) noexcept {
+    time_scale_ = std::max(scale, 0.0f);
+}
+
+float DeltaTimer::getTimeScale() const noexcept {
+    return time_scale_;
+}
+

source/utils/delta_timer.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <SDL3/SDL.h>
+#include <algorithm>
+
+class DeltaTimer {
+public:
+    DeltaTimer() noexcept;
+
+    // Calcula delta en segundos y actualiza el contador interno
+    float tick() noexcept;
+
+    // Devuelve el delta estimado desde el último tick sin actualizar el contador
+    float peek() const noexcept;
+
+    // Reinicia el contador al valor actual o al valor pasado (en performance counter ticks)
+    void reset(Uint64 counter = 0) noexcept;
+
+    // Escala el tiempo retornado por tick/peek, por defecto 1.0f
+    void setTimeScale(float scale) noexcept;
+    float getTimeScale() const noexcept;
+
+private:
+    Uint64 last_counter_;
+    double perf_freq_;
+    float time_scale_;
+};