reestructuració

source/core/rendering/animatedsprite.cpp

@@ -0,0 +1,438 @@
+#include "core/rendering/animatedsprite.h"
+
+#include <fstream>   // for basic_ostream, operator<<, basic_istream, basic...
+#include <iostream>  // for cout
+#include <sstream>   // for basic_stringstream
+
+#include "core/rendering/texture.h"  // for Texture
+
+// Parser compartido: lee un istream con el formato .ani
+static animatedSprite_t parseAnimationStream(std::istream &file, Texture *texture, const std::string &filename, bool verbose) {
+    animatedSprite_t as;
+    as.texture = texture;
+    int framesPerRow = 0;
+    int frameWidth = 0;
+    int frameHeight = 0;
+    int maxTiles = 0;
+    std::string line;
+
+    if (verbose) {
+        std::cout << "Animation loaded: " << filename << std::endl;
+    }
+    while (std::getline(file, line)) {
+        if (line == "[animation]") {
+            animation_t buffer;
+            buffer.counter = 0;
+            buffer.currentFrame = 0;
+            buffer.completed = false;
+
+            do {
+                std::getline(file, line);
+                int pos = line.find("=");
+                if (pos != (int)line.npos) {
+                    if (line.substr(0, pos) == "name") {
+                        buffer.name = line.substr(pos + 1, line.length());
+                    } else if (line.substr(0, pos) == "speed") {
+                        buffer.speed = std::stoi(line.substr(pos + 1, line.length()));
+                    } else if (line.substr(0, pos) == "loop") {
+                        buffer.loop = std::stoi(line.substr(pos + 1, line.length()));
+                    } else if (line.substr(0, pos) == "frames") {
+                        std::stringstream ss(line.substr(pos + 1, line.length()));
+                        std::string tmp;
+                        SDL_Rect rect = {0, 0, frameWidth, frameHeight};
+                        while (getline(ss, tmp, ',')) {
+                            const int numTile = std::stoi(tmp) > maxTiles ? 0 : std::stoi(tmp);
+                            rect.x = (numTile % framesPerRow) * frameWidth;
+                            rect.y = (numTile / framesPerRow) * frameHeight;
+                            buffer.frames.push_back(rect);
+                        }
+                    } else {
+                        std::cout << "Warning: file " << filename.c_str() << "\n, unknown parameter \"" << line.substr(0, pos).c_str() << "\"" << std::endl;
+                    }
+                }
+            } while (line != "[/animation]");
+
+            as.animations.push_back(buffer);
+        } else {
+            int pos = line.find("=");
+            if (pos != (int)line.npos) {
+                if (line.substr(0, pos) == "framesPerRow") {
+                    framesPerRow = std::stoi(line.substr(pos + 1, line.length()));
+                } else if (line.substr(0, pos) == "frameWidth") {
+                    frameWidth = std::stoi(line.substr(pos + 1, line.length()));
+                } else if (line.substr(0, pos) == "frameHeight") {
+                    frameHeight = std::stoi(line.substr(pos + 1, line.length()));
+                } else {
+                    std::cout << "Warning: file " << filename.c_str() << "\n, unknown parameter \"" << line.substr(0, pos).c_str() << "\"" << std::endl;
+                }
+
+                if (framesPerRow == 0 && frameWidth > 0) {
+                    framesPerRow = texture->getWidth() / frameWidth;
+                }
+                if (maxTiles == 0 && frameWidth > 0 && frameHeight > 0) {
+                    const int w = texture->getWidth() / frameWidth;
+                    const int h = texture->getHeight() / frameHeight;
+                    maxTiles = w * h;
+                }
+            }
+        }
+    }
+
+    return as;
+}
+
+// Carga la animación desde un fichero
+animatedSprite_t loadAnimationFromFile(Texture *texture, std::string filePath, bool verbose) {
+    const std::string filename = filePath.substr(filePath.find_last_of("\\/") + 1);
+    std::ifstream file(filePath);
+    if (!file.good()) {
+        if (verbose) {
+            std::cout << "Warning: Unable to open " << filename.c_str() << " file" << std::endl;
+        }
+        animatedSprite_t as;
+        as.texture = texture;
+        return as;
+    }
+    return parseAnimationStream(file, texture, filename, verbose);
+}
+
+// Carga la animación desde bytes en memoria
+animatedSprite_t loadAnimationFromMemory(Texture *texture, const std::vector<uint8_t> &bytes, const std::string &nameForLogs, bool verbose) {
+    if (bytes.empty()) {
+        animatedSprite_t as;
+        as.texture = texture;
+        return as;
+    }
+    std::string content(reinterpret_cast<const char *>(bytes.data()), bytes.size());
+    std::stringstream ss(content);
+    return parseAnimationStream(ss, texture, nameForLogs, verbose);
+}
+
+// Constructor
+AnimatedSprite::AnimatedSprite(Texture *texture, SDL_Renderer *renderer, std::string file, std::vector<std::string> *buffer) {
+    // Copia los punteros
+    setTexture(texture);
+    setRenderer(renderer);
+
+    // Carga las animaciones
+    if (file != "") {
+        animatedSprite_t as = loadAnimationFromFile(texture, file);
+
+        // Copia los datos de las animaciones
+        for (auto animation : as.animations) {
+            this->animation.push_back(animation);
+        }
+    }
+
+    else if (buffer) {
+        loadFromVector(buffer);
+    }
+
+    // Inicializa variables
+    currentAnimation = 0;
+}
+
+// Constructor
+AnimatedSprite::AnimatedSprite(SDL_Renderer *renderer, animatedSprite_t *animation) {
+    // Copia los punteros
+    setTexture(animation->texture);
+    setRenderer(renderer);
+
+    // Inicializa variables
+    currentAnimation = 0;
+
+    // Copia los datos de las animaciones
+    for (auto a : animation->animations) {
+        this->animation.push_back(a);
+    }
+}
+
+// Destructor
+AnimatedSprite::~AnimatedSprite() {
+    for (auto &a : animation) {
+        a.frames.clear();
+    }
+    animation.clear();
+}
+
+// Obtiene el indice de la animación a partir del nombre
+int AnimatedSprite::getIndex(std::string name) {
+    int index = -1;
+
+    for (auto a : animation) {
+        index++;
+        if (a.name == name) {
+            return index;
+        }
+    }
+
+    std::cout << "** Warning: could not find \"" << name.c_str() << "\" animation" << std::endl;
+
+    return -1;
+}
+
+// Calcula el frame correspondiente a la animación
+void AnimatedSprite::animate() {
+    if (!enabled || animation[currentAnimation].speed == 0) {
+        return;
+    }
+
+    // Calcula el frame actual a partir del contador
+    animation[currentAnimation].currentFrame = animation[currentAnimation].counter / animation[currentAnimation].speed;
+
+    // Si alcanza el final de la animación, reinicia el contador de la animación
+    // en función de la variable loop y coloca el nuevo frame
+    if (animation[currentAnimation].currentFrame >= (int)animation[currentAnimation].frames.size()) {
+        if (animation[currentAnimation].loop == -1) {  // Si no hay loop, deja el último frame
+            animation[currentAnimation].currentFrame = animation[currentAnimation].frames.size();
+            animation[currentAnimation].completed = true;
+        } else {  // Si hay loop, vuelve al frame indicado
+            animation[currentAnimation].counter = 0;
+            animation[currentAnimation].currentFrame = animation[currentAnimation].loop;
+        }
+    }
+    // En caso contrario
+    else {
+        // Escoge el frame correspondiente de la animación
+        setSpriteClip(animation[currentAnimation].frames[animation[currentAnimation].currentFrame]);
+
+        // Incrementa el contador de la animacion
+        animation[currentAnimation].counter++;
+    }
+}
+
+// Obtiene el numero de frames de la animación actual
+int AnimatedSprite::getNumFrames() {
+    return (int)animation[currentAnimation].frames.size();
+}
+
+// Establece el frame actual de la animación
+void AnimatedSprite::setCurrentFrame(int num) {
+    // Descarta valores fuera de rango
+    if (num >= (int)animation[currentAnimation].frames.size()) {
+        num = 0;
+    }
+
+    // Cambia el valor de la variable
+    animation[currentAnimation].currentFrame = num;
+    animation[currentAnimation].counter = 0;
+
+    // Escoge el frame correspondiente de la animación
+    setSpriteClip(animation[currentAnimation].frames[animation[currentAnimation].currentFrame]);
+}
+
+// Establece el valor del contador
+void AnimatedSprite::setAnimationCounter(std::string name, int num) {
+    animation[getIndex(name)].counter = num;
+}
+
+// Establece la velocidad de una animación
+void AnimatedSprite::setAnimationSpeed(std::string name, int speed) {
+    animation[getIndex(name)].counter = speed;
+}
+
+// Establece la velocidad de una animación
+void AnimatedSprite::setAnimationSpeed(int index, int speed) {
+    animation[index].counter = speed;
+}
+
+// Establece si la animación se reproduce en bucle
+void AnimatedSprite::setAnimationLoop(std::string name, int loop) {
+    animation[getIndex(name)].loop = loop;
+}
+
+// Establece si la animación se reproduce en bucle
+void AnimatedSprite::setAnimationLoop(int index, int loop) {
+    animation[index].loop = loop;
+}
+
+// Establece el valor de la variable
+void AnimatedSprite::setAnimationCompleted(std::string name, bool value) {
+    animation[getIndex(name)].completed = value;
+}
+
+// OLD - Establece el valor de la variable
+void AnimatedSprite::setAnimationCompleted(int index, bool value) {
+    animation[index].completed = value;
+}
+
+// Comprueba si ha terminado la animación
+bool AnimatedSprite::animationIsCompleted() {
+    return animation[currentAnimation].completed;
+}
+
+// Devuelve el rectangulo de una animación y frame concreto
+SDL_Rect AnimatedSprite::getAnimationClip(std::string name, Uint8 index) {
+    return animation[getIndex(name)].frames[index];
+}
+
+// Devuelve el rectangulo de una animación y frame concreto
+SDL_Rect AnimatedSprite::getAnimationClip(int indexA, Uint8 indexF) {
+    return animation[indexA].frames[indexF];
+}
+
+// Carga la animación desde un vector
+bool AnimatedSprite::loadFromVector(std::vector<std::string> *source) {
+    // Inicializa variables
+    int framesPerRow = 0;
+    int frameWidth = 0;
+    int frameHeight = 0;
+    int maxTiles = 0;
+
+    // Indicador de éxito en el proceso
+    bool success = true;
+    std::string line;
+
+    // Recorre todo el vector
+    int index = 0;
+    while (index < (int)source->size()) {
+        // Lee desde el vector
+        line = source->at(index);
+
+        // Si la linea contiene el texto [animation] se realiza el proceso de carga de una animación
+        if (line == "[animation]") {
+            animation_t buffer;
+            buffer.counter = 0;
+            buffer.currentFrame = 0;
+            buffer.completed = false;
+
+            do {
+                // Aumenta el indice para leer la siguiente linea
+                index++;
+                line = source->at(index);
+
+                // Encuentra la posición del caracter '='
+                int pos = line.find("=");
+
+                // Procesa las dos subcadenas
+                if (pos != (int)line.npos) {
+                    if (line.substr(0, pos) == "name") {
+                        buffer.name = line.substr(pos + 1, line.length());
+                    }
+
+                    else if (line.substr(0, pos) == "speed") {
+                        buffer.speed = std::stoi(line.substr(pos + 1, line.length()));
+                    }
+
+                    else if (line.substr(0, pos) == "loop") {
+                        buffer.loop = std::stoi(line.substr(pos + 1, line.length()));
+                    }
+
+                    else if (line.substr(0, pos) == "frames") {
+                        // Se introducen los valores separados por comas en un vector
+                        std::stringstream ss(line.substr(pos + 1, line.length()));
+                        std::string tmp;
+                        SDL_Rect rect = {0, 0, frameWidth, frameHeight};
+                        while (getline(ss, tmp, ',')) {
+                            // Comprueba que el tile no sea mayor que el maximo indice permitido
+                            const int numTile = std::stoi(tmp) > maxTiles ? 0 : std::stoi(tmp);
+                            rect.x = (numTile % framesPerRow) * frameWidth;
+                            rect.y = (numTile / framesPerRow) * frameHeight;
+                            buffer.frames.push_back(rect);
+                        }
+                    }
+
+                    else {
+                        std::cout << "Warning: unknown parameter " << line.substr(0, pos).c_str() << std::endl;
+                        success = false;
+                    }
+                }
+            } while (line != "[/animation]");
+
+            // Añade la animación al vector de animaciones
+            animation.push_back(buffer);
+        }
+
+        // En caso contrario se parsea el fichero para buscar las variables y los valores
+        else {
+            // Encuentra la posición del caracter '='
+            int pos = line.find("=");
+
+            // Procesa las dos subcadenas
+            if (pos != (int)line.npos) {
+                if (line.substr(0, pos) == "framesPerRow") {
+                    framesPerRow = std::stoi(line.substr(pos + 1, line.length()));
+                }
+
+                else if (line.substr(0, pos) == "frameWidth") {
+                    frameWidth = std::stoi(line.substr(pos + 1, line.length()));
+                }
+
+                else if (line.substr(0, pos) == "frameHeight") {
+                    frameHeight = std::stoi(line.substr(pos + 1, line.length()));
+                }
+
+                else {
+                    std::cout << "Warning: unknown parameter " << line.substr(0, pos).c_str() << std::endl;
+                    success = false;
+                }
+
+                // Normaliza valores
+                if (framesPerRow == 0 && frameWidth > 0) {
+                    framesPerRow = texture->getWidth() / frameWidth;
+                }
+
+                if (maxTiles == 0 && frameWidth > 0 && frameHeight > 0) {
+                    const int w = texture->getWidth() / frameWidth;
+                    const int h = texture->getHeight() / frameHeight;
+                    maxTiles = w * h;
+                }
+            }
+        }
+
+        // Una vez procesada la linea, aumenta el indice para pasar a la siguiente
+        index++;
+    }
+
+    // Pone un valor por defecto
+    setRect({0, 0, frameWidth, frameHeight});
+
+    return success;
+}
+
+// Establece la animacion actual
+void AnimatedSprite::setCurrentAnimation(std::string name) {
+    const int newAnimation = getIndex(name);
+    if (currentAnimation != newAnimation) {
+        currentAnimation = newAnimation;
+        animation[currentAnimation].currentFrame = 0;
+        animation[currentAnimation].counter = 0;
+        animation[currentAnimation].completed = false;
+    }
+}
+
+// Establece la animacion actual
+void AnimatedSprite::setCurrentAnimation(int index) {
+    const int newAnimation = index;
+    if (currentAnimation != newAnimation) {
+        currentAnimation = newAnimation;
+        animation[currentAnimation].currentFrame = 0;
+        animation[currentAnimation].counter = 0;
+        animation[currentAnimation].completed = false;
+    }
+}
+
+// Actualiza las variables del objeto
+void AnimatedSprite::update() {
+    animate();
+    MovingSprite::update();
+}
+
+// Establece el rectangulo para un frame de una animación
+void AnimatedSprite::setAnimationFrames(Uint8 index_animation, Uint8 index_frame, int x, int y, int w, int h) {
+    animation[index_animation].frames.push_back({x, y, w, h});
+}
+
+// OLD - Establece el contador para todas las animaciones
+void AnimatedSprite::setAnimationCounter(int value) {
+    for (auto &a : animation) {
+        a.counter = value;
+    }
+}
+
+// Reinicia la animación
+void AnimatedSprite::resetAnimation() {
+    animation[currentAnimation].currentFrame = 0;
+    animation[currentAnimation].counter = 0;
+    animation[currentAnimation].completed = false;
+}

source/core/rendering/animatedsprite.h

@@ -0,0 +1,99 @@
+#pragma once
+
+#include <SDL3/SDL.h>
+
+#include <cstdint>
+#include <string>  // for string, basic_string
+#include <vector>  // for vector
+
+#include "core/rendering/movingsprite.h"  // for MovingSprite
+class Texture;
+
+struct animation_t {
+    std::string name;              // Nombre de la animacion
+    std::vector<SDL_Rect> frames;  // Cada uno de los frames que componen la animación
+    int speed;                     // Velocidad de la animación
+    int loop;                      // Indica a que frame vuelve la animación al terminar. -1 para que no vuelva
+    bool completed;                // Indica si ha finalizado la animación
+    int currentFrame;              // Frame actual
+    int counter;                   // Contador para las animaciones
+};
+
+struct animatedSprite_t {
+    std::vector<animation_t> animations;  // Vector con las diferentes animaciones
+    Texture *texture;                     // Textura con los graficos para el sprite
+};
+
+// Carga la animación desde un fichero
+animatedSprite_t loadAnimationFromFile(Texture *texture, std::string filePath, bool verbose = false);
+
+// Carga la animación desde bytes en memoria
+animatedSprite_t loadAnimationFromMemory(Texture *texture, const std::vector<uint8_t> &bytes, const std::string &nameForLogs = "", bool verbose = false);
+
+class AnimatedSprite : public MovingSprite {
+   private:
+    // Variables
+    std::vector<animation_t> animation;  // Vector con las diferentes animaciones
+    int currentAnimation;                // Animacion activa
+
+   public:
+    // Constructor
+    AnimatedSprite(Texture *texture = nullptr, SDL_Renderer *renderer = nullptr, std::string file = "", std::vector<std::string> *buffer = nullptr);
+    AnimatedSprite(SDL_Renderer *renderer, animatedSprite_t *animation);
+
+    // Destructor
+    ~AnimatedSprite();
+
+    // Calcula el frame correspondiente a la animación actual
+    void animate();
+
+    // Obtiene el numero de frames de la animación actual
+    int getNumFrames();
+
+    // Establece el frame actual de la animación
+    void setCurrentFrame(int num);
+
+    // Establece el valor del contador
+    void setAnimationCounter(std::string name, int num);
+
+    // Establece la velocidad de una animación
+    void setAnimationSpeed(std::string name, int speed);
+    void setAnimationSpeed(int index, int speed);
+
+    // Establece el frame al que vuelve la animación al finalizar
+    void setAnimationLoop(std::string name, int loop);
+    void setAnimationLoop(int index, int loop);
+
+    // Establece el valor de la variable
+    void setAnimationCompleted(std::string name, bool value);
+    void setAnimationCompleted(int index, bool value);
+
+    // Comprueba si ha terminado la animación
+    bool animationIsCompleted();
+
+    // Devuelve el rectangulo de una animación y frame concreto
+    SDL_Rect getAnimationClip(std::string name = "default", Uint8 index = 0);
+    SDL_Rect getAnimationClip(int indexA = 0, Uint8 indexF = 0);
+
+    // Obtiene el indice de la animación a partir del nombre
+    int getIndex(std::string name);
+
+    // Carga la animación desde un vector
+    bool loadFromVector(std::vector<std::string> *source);
+
+    // Establece la animacion actual
+    void setCurrentAnimation(std::string name = "default");
+    void setCurrentAnimation(int index = 0);
+
+    // Actualiza las variables del objeto
+    void update();
+
+    // OLD - Establece el rectangulo para un frame de una animación
+    void setAnimationFrames(Uint8 index_animation, Uint8 index_frame, int x, int y, int w, int h);
+
+    // OLD - Establece el contador para todas las animaciones
+    void setAnimationCounter(int value);
+
+    // Reinicia la animación
+    void resetAnimation();
+};

source/core/rendering/fade.cpp

@@ -0,0 +1,180 @@
+#include "core/rendering/fade.h"
+
+#include <SDL3/SDL.h>
+#include <stdlib.h>  // for rand
+
+#include <iostream>  // for char_traits, basic_ostream, operator<<
+
+#include "game/defaults.hpp"  // for GAMECANVAS_HEIGHT, GAMECANVAS_WIDTH
+
+// Constructor
+Fade::Fade(SDL_Renderer *renderer) {
+    mRenderer = renderer;
+
+    mBackbuffer = SDL_CreateTexture(mRenderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, GAMECANVAS_WIDTH, GAMECANVAS_HEIGHT);
+    if (mBackbuffer != nullptr) {
+        SDL_SetTextureScaleMode(mBackbuffer, SDL_SCALEMODE_NEAREST);
+    }
+    if (mBackbuffer == nullptr) {
+        std::cout << "Error: textTexture could not be created!\nSDL Error: " << SDL_GetError() << std::endl;
+    }
+}
+
+// Destructor
+Fade::~Fade() {
+    SDL_DestroyTexture(mBackbuffer);
+    mBackbuffer = nullptr;
+}
+
+// Inicializa las variables
+void Fade::init(Uint8 r, Uint8 g, Uint8 b) {
+    mFadeType = FADE_CENTER;
+    mEnabled = false;
+    mFinished = false;
+    mCounter = 0;
+    mR = r;
+    mG = g;
+    mB = b;
+    mROriginal = r;
+    mGOriginal = g;
+    mBOriginal = b;
+    mLastSquareTicks = 0;
+    mSquaresDrawn = 0;
+    mFullscreenDone = false;
+}
+
+// Pinta una transición en pantalla
+void Fade::render() {
+    if (mEnabled && !mFinished) {
+        switch (mFadeType) {
+            case FADE_FULLSCREEN: {
+                if (!mFullscreenDone) {
+                    SDL_FRect fRect1 = {0, 0, (float)GAMECANVAS_WIDTH, (float)GAMECANVAS_HEIGHT};
+
+                    int alpha = mCounter * 4;
+                    if (alpha >= 255) {
+                        alpha = 255;
+                        mFullscreenDone = true;
+
+                        // Deja todos los buffers del mismo color
+                        SDL_SetRenderTarget(mRenderer, mBackbuffer);
+                        SDL_SetRenderDrawColor(mRenderer, mR, mG, mB, 255);
+                        SDL_RenderClear(mRenderer);
+
+                        SDL_SetRenderTarget(mRenderer, nullptr);
+                        SDL_SetRenderDrawColor(mRenderer, mR, mG, mB, 255);
+                        SDL_RenderClear(mRenderer);
+
+                        mFinished = true;
+                    } else {
+                        // Dibujamos sobre el renderizador
+                        SDL_SetRenderTarget(mRenderer, nullptr);
+
+                        // Copia el backbuffer con la imagen que había al renderizador
+                        SDL_RenderTexture(mRenderer, mBackbuffer, nullptr, nullptr);
+
+                        SDL_SetRenderDrawColor(mRenderer, mR, mG, mB, alpha);
+                        SDL_RenderFillRect(mRenderer, &fRect1);
+                    }
+                }
+                break;
+            }
+
+            case FADE_CENTER: {
+                SDL_FRect fR1 = {0, 0, (float)GAMECANVAS_WIDTH, 0};
+                SDL_FRect fR2 = {0, 0, (float)GAMECANVAS_WIDTH, 0};
+
+                SDL_SetRenderDrawColor(mRenderer, mR, mG, mB, 64);
+
+                for (int i = 0; i < mCounter; i++) {
+                    fR1.h = fR2.h = (float)(i * 4);
+                    fR2.y = (float)(GAMECANVAS_HEIGHT - (i * 4));
+
+                    SDL_RenderFillRect(mRenderer, &fR1);
+                    SDL_RenderFillRect(mRenderer, &fR2);
+                }
+
+                if ((mCounter * 4) > GAMECANVAS_HEIGHT)
+                    mFinished = true;
+                break;
+            }
+
+            case FADE_RANDOM_SQUARE: {
+                Uint32 now = SDL_GetTicks();
+                if (mSquaresDrawn < 50 && now - mLastSquareTicks >= 100) {
+                    mLastSquareTicks = now;
+
+                    SDL_FRect fRs = {0, 0, 32, 32};
+
+                    // Crea un color al azar
+                    Uint8 r = 255 * (rand() % 2);
+                    Uint8 g = 255 * (rand() % 2);
+                    Uint8 b = 255 * (rand() % 2);
+                    SDL_SetRenderDrawColor(mRenderer, r, g, b, 64);
+
+                    // Dibujamos sobre el backbuffer
+                    SDL_SetRenderTarget(mRenderer, mBackbuffer);
+
+                    fRs.x = (float)(rand() % (GAMECANVAS_WIDTH - 32));
+                    fRs.y = (float)(rand() % (GAMECANVAS_HEIGHT - 32));
+                    SDL_RenderFillRect(mRenderer, &fRs);
+
+                    // Volvemos a usar el renderizador de forma normal
+                    SDL_SetRenderTarget(mRenderer, nullptr);
+
+                    mSquaresDrawn++;
+                }
+
+                // Copiamos el backbuffer al renderizador
+                SDL_RenderTexture(mRenderer, mBackbuffer, nullptr, nullptr);
+
+                if (mSquaresDrawn >= 50) {
+                    mFinished = true;
+                }
+                break;
+            }
+
+            default:
+                break;
+        }
+    }
+
+    if (mFinished) {
+        SDL_SetRenderDrawColor(mRenderer, mR, mG, mB, 255);
+        SDL_RenderClear(mRenderer);
+    }
+}
+
+// Actualiza las variables internas
+void Fade::update() {
+    if (mEnabled)
+        mCounter++;
+}
+
+// Activa el fade
+void Fade::activateFade() {
+    mEnabled = true;
+    mFinished = false;
+    mCounter = 0;
+    mSquaresDrawn = 0;
+    mLastSquareTicks = 0;
+    mFullscreenDone = false;
+    mR = mROriginal;
+    mG = mGOriginal;
+    mB = mBOriginal;
+}
+
+// Comprueba si está activo
+bool Fade::isEnabled() {
+    return mEnabled;
+}
+
+// Comprueba si ha terminado la transicion
+bool Fade::hasEnded() {
+    return mFinished;
+}
+
+// Establece el tipo de fade
+void Fade::setFadeType(Uint8 fadeType) {
+    mFadeType = fadeType;
+}

source/core/rendering/fade.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <SDL3/SDL.h>
+
+// Tipos de fundido
+constexpr int FADE_FULLSCREEN = 0;
+constexpr int FADE_CENTER = 1;
+constexpr int FADE_RANDOM_SQUARE = 2;
+
+// Clase Fade
+class Fade {
+   private:
+    SDL_Renderer *mRenderer;                   // El renderizador de la ventana
+    SDL_Texture *mBackbuffer;                  // Textura para usar como backbuffer
+    Uint8 mFadeType;                           // Tipo de fade a realizar
+    Uint16 mCounter;                           // Contador interno
+    bool mEnabled;                             // Indica si el fade está activo
+    bool mFinished;                            // Indica si ha terminado la transición
+    Uint8 mR, mG, mB;                          // Colores para el fade
+    Uint8 mROriginal, mGOriginal, mBOriginal;  // Colores originales para FADE_RANDOM_SQUARE
+    Uint32 mLastSquareTicks;                   // Ticks del último cuadrado dibujado (FADE_RANDOM_SQUARE)
+    Uint16 mSquaresDrawn;                      // Número de cuadrados dibujados (FADE_RANDOM_SQUARE)
+    bool mFullscreenDone;                      // Indica si el fade fullscreen ha terminado la fase de fundido
+    SDL_Rect mRect1;                           // Rectangulo usado para crear los efectos de transición
+    SDL_Rect mRect2;                           // Rectangulo usado para crear los efectos de transición
+
+   public:
+    // Constructor
+    Fade(SDL_Renderer *renderer);
+
+    // Destructor
+    ~Fade();
+
+    // Inicializa las variables
+    void init(Uint8 r, Uint8 g, Uint8 b);
+
+    // Pinta una transición en pantalla
+    void render();
+
+    // Actualiza las variables internas
+    void update();
+
+    // Activa el fade
+    void activateFade();
+
+    // Comprueba si ha terminado la transicion
+    bool hasEnded();
+
+    // Comprueba si está activo
+    bool isEnabled();
+
+    // Establece el tipo de fade
+    void setFadeType(Uint8 fadeType);
+};

source/core/rendering/movingsprite.cpp

@@ -0,0 +1,312 @@
+#include "core/rendering/movingsprite.h"
+
+#include "core/rendering/texture.h"  // for Texture
+
+// Constructor
+MovingSprite::MovingSprite(float x, float y, int w, int h, float velx, float vely, float accelx, float accely, Texture *texture, SDL_Renderer *renderer) {
+    // Copia los punteros
+    this->texture = texture;
+    this->renderer = renderer;
+
+    // Establece el alto y el ancho del sprite
+    this->w = w;
+    this->h = h;
+
+    // Establece la posición X,Y del sprite
+    this->x = x;
+    this->y = y;
+    xPrev = x;
+    yPrev = y;
+
+    // Establece la velocidad X,Y del sprite
+    vx = velx;
+    vy = vely;
+
+    // Establece la aceleración X,Y del sprite
+    ax = accelx;
+    ay = accely;
+
+    // Establece el zoom W,H del sprite
+    zoomW = 1;
+    zoomH = 1;
+
+    // Establece el angulo con el que se dibujará
+    angle = (double)0;
+
+    // Establece los valores de rotacion
+    rotateEnabled = false;
+    rotateSpeed = 0;
+    rotateAmount = (double)0;
+
+    // Contador interno
+    counter = 0;
+
+    // Establece el rectangulo de donde coger la imagen
+    spriteClip = {0, 0, w, h};
+
+    // Establece el centro de rotación
+    center = nullptr;
+
+    // Establece el tipo de volteado
+    currentFlip = SDL_FLIP_NONE;
+};
+
+// Reinicia todas las variables
+void MovingSprite::clear() {
+    x = 0.0f;  // Posición en el eje X
+    y = 0.0f;  // Posición en el eje Y
+
+    vx = 0.0f;  // Velocidad en el eje X. Cantidad de pixeles a desplazarse
+    vy = 0.0f;  // Velocidad en el eje Y. Cantidad de pixeles a desplazarse
+
+    ax = 0.0f;  // Aceleración en el eje X. Variación de la velocidad
+    ay = 0.0f;  // Aceleración en el eje Y. Variación de la velocidad
+
+    zoomW = 1.0f;  // Zoom aplicado a la anchura
+    zoomH = 1.0f;  // Zoom aplicado a la altura
+
+    angle = 0.0;            // Angulo para dibujarlo
+    rotateEnabled = false;  // Indica si ha de rotar
+    center = nullptr;       // Centro de rotación
+    rotateSpeed = 0;        // Velocidad de giro
+    rotateAmount = 0.0;     // Cantidad de grados a girar en cada iteración
+    counter = 0;            // Contador interno
+
+    currentFlip = SDL_FLIP_NONE;  // Establece como se ha de voltear el sprite
+}
+
+// Mueve el sprite
+void MovingSprite::move() {
+    if (enabled) {
+        xPrev = x;
+        yPrev = y;
+
+        x += vx;
+        y += vy;
+
+        vx += ax;
+        vy += ay;
+    }
+}
+
+// Muestra el sprite por pantalla
+void MovingSprite::render() {
+    if (enabled) {
+        texture->render(renderer, (int)x, (int)y, &spriteClip, zoomW, zoomH, angle, center, currentFlip);
+    }
+}
+
+// Obtiene el valor de la variable
+float MovingSprite::getPosX() {
+    return x;
+}
+
+// Obtiene el valor de la variable
+float MovingSprite::getPosY() {
+    return y;
+}
+
+// Obtiene el valor de la variable
+float MovingSprite::getVelX() {
+    return vx;
+}
+
+// Obtiene el valor de la variable
+float MovingSprite::getVelY() {
+    return vy;
+}
+
+// Obtiene el valor de la variable
+float MovingSprite::getAccelX() {
+    return ax;
+}
+
+// Obtiene el valor de la variable
+float MovingSprite::getAccelY() {
+    return ay;
+}
+
+// Obtiene el valor de la variable
+float MovingSprite::getZoomW() {
+    return zoomW;
+}
+
+// Obtiene el valor de la variable
+float MovingSprite::getZoomH() {
+    return zoomH;
+}
+
+// Obtiene el valor de la variable
+double MovingSprite::getAngle() {
+    return angle;
+}
+
+// Establece la posición y el tamaño del objeto
+void MovingSprite::setRect(SDL_Rect rect) {
+    x = (float)rect.x;
+    y = (float)rect.y;
+    w = rect.w;
+    h = rect.h;
+}
+
+// Establece el valor de la variable
+void MovingSprite::setPosX(float value) {
+    x = value;
+}
+
+// Establece el valor de la variable
+void MovingSprite::setPosY(float value) {
+    y = value;
+}
+
+// Establece el valor de la variable
+void MovingSprite::setVelX(float value) {
+    vx = value;
+}
+
+// Establece el valor de la variable
+void MovingSprite::setVelY(float value) {
+    vy = value;
+}
+
+// Establece el valor de la variable
+void MovingSprite::setAccelX(float value) {
+    ax = value;
+}
+
+// Establece el valor de la variable
+void MovingSprite::setAccelY(float value) {
+    ay = value;
+}
+
+// Establece el valor de la variable
+void MovingSprite::setZoomW(float value) {
+    zoomW = value;
+}
+
+// Establece el valor de la variable
+void MovingSprite::setZoomH(float value) {
+    zoomH = value;
+}
+
+// Establece el valor de la variable
+void MovingSprite::setAngle(double value) {
+    angle = value;
+}
+
+// Incrementa el valor de la variable
+void MovingSprite::incAngle(double value) {
+    angle += value;
+}
+
+// Decrementa el valor de la variable
+void MovingSprite::decAngle(double value) {
+    angle -= value;
+}
+
+// Obtiene el valor de la variable
+bool MovingSprite::getRotate() {
+    return rotateEnabled;
+}
+
+// Obtiene el valor de la variable
+Uint16 MovingSprite::getRotateSpeed() {
+    return rotateSpeed;
+}
+
+// Establece la rotacion
+void MovingSprite::rotate() {
+    if (enabled)
+        if (rotateEnabled) {
+            if (counter % rotateSpeed == 0) {
+                incAngle(rotateAmount);
+            }
+        }
+}
+
+// Establece el valor de la variable
+void MovingSprite::setRotate(bool value) {
+    rotateEnabled = value;
+}
+
+// Establece el valor de la variable
+void MovingSprite::setRotateSpeed(int value) {
+    if (value < 1) {
+        rotateSpeed = 1;
+    } else {
+        rotateSpeed = value;
+    }
+}
+
+// Establece el valor de la variable
+void MovingSprite::setRotateAmount(double value) {
+    rotateAmount = value;
+}
+
+// Establece el valor de la variable
+void MovingSprite::disableRotate() {
+    rotateEnabled = false;
+    angle = (double)0;
+}
+
+// Actualiza las variables internas del objeto
+void MovingSprite::update() {
+    move();
+    rotate();
+
+    if (enabled) {
+        ++counter %= 60000;
+    }
+}
+
+// Cambia el sentido de la rotación
+void MovingSprite::switchRotate() {
+    rotateAmount *= -1;
+}
+
+// Establece el valor de la variable
+void MovingSprite::setFlip(SDL_FlipMode flip) {
+    currentFlip = flip;
+}
+
+// Gira el sprite horizontalmente
+void MovingSprite::flip() {
+    currentFlip = (currentFlip == SDL_FLIP_HORIZONTAL) ? SDL_FLIP_NONE : SDL_FLIP_HORIZONTAL;
+}
+
+// Obtiene el valor de la variable
+SDL_FlipMode MovingSprite::getFlip() {
+    return currentFlip;
+}
+
+// Devuelve el rectangulo donde está el sprite
+SDL_Rect MovingSprite::getRect() {
+    const SDL_Rect rect = {(int)x, (int)y, w, h};
+    return rect;
+}
+
+// Deshace el último movimiento
+void MovingSprite::undoMove() {
+    x = xPrev;
+    y = yPrev;
+}
+
+// Deshace el último movimiento en el eje X
+void MovingSprite::undoMoveX() {
+    x = xPrev;
+}
+
+// Deshace el último movimiento en el eje Y
+void MovingSprite::undoMoveY() {
+    y = yPrev;
+}
+
+// Pone a cero las velocidades de desplacamiento
+void MovingSprite::clearVel() {
+    vx = vy = 0.0f;
+}
+
+// Devuelve el incremento en el eje X en pixels
+int MovingSprite::getIncX() {
+    return (int)x - (int)xPrev;
+}

source/core/rendering/movingsprite.h

@@ -0,0 +1,163 @@
+#pragma once
+
+#include <SDL3/SDL.h>
+
+#include "core/rendering/sprite.h"  // for Sprite
+class Texture;
+
+// Clase MovingSprite. Añade posicion y velocidad en punto flotante
+class MovingSprite : public Sprite {
+   protected:
+    float x;  // Posición en el eje X
+    float y;  // Posición en el eje Y
+
+    float xPrev;  // Posición anterior en el eje X
+    float yPrev;  // Posición anterior en el eje Y
+
+    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 ax;  // Aceleración en el eje X. Variación de la velocidad
+    float ay;  // Aceleración en el eje Y. Variación de la velocidad
+
+    float zoomW;  // Zoom aplicado a la anchura
+    float zoomH;  // Zoom aplicado a la altura
+
+    double angle;              // Angulo para dibujarlo
+    bool rotateEnabled;        // Indica si ha de rotar
+    int rotateSpeed;           // Velocidad de giro
+    double rotateAmount;       // Cantidad de grados a girar en cada iteración
+    int counter;               // Contador interno
+    SDL_Point *center;         // Centro de rotación
+    SDL_FlipMode currentFlip;  // Indica como se voltea el sprite
+
+   public:
+    // Constructor
+    MovingSprite(float x = 0, float y = 0, int w = 0, int h = 0, float velx = 0, float vely = 0, float accelx = 0, float accely = 0, Texture *texture = nullptr, SDL_Renderer *renderer = nullptr);
+
+    // Mueve el sprite
+    void move();
+
+    // Rota el sprite
+    void rotate();
+
+    // Actualiza las variables internas del objeto
+    void update();
+
+    // Reinicia todas las variables
+    void clear();
+
+    // Muestra el sprite por pantalla
+    void render();
+
+    // Obten el valor de la variable
+    float getPosX();
+
+    // Obten el valor de la variable
+    float getPosY();
+
+    // Obten el valor de la variable
+    float getVelX();
+
+    // Obten el valor de la variable
+    float getVelY();
+
+    // Obten el valor de la variable
+    float getAccelX();
+
+    // Obten el valor de la variable
+    float getAccelY();
+
+    // Obten el valor de la variable
+    float getZoomW();
+
+    // Obten el valor de la variable
+    float getZoomH();
+
+    // Obten el valor de la variable
+    double getAngle();
+
+    // Obtiene el valor de la variable
+    bool getRotate();
+
+    // Obtiene el valor de la variable
+    Uint16 getRotateSpeed();
+
+    // Establece la posición y el tamaño del objeto
+    void setRect(SDL_Rect rect);
+
+    // Establece el valor de la variable
+    void setPosX(float value);
+
+    // Establece el valor de la variable
+    void setPosY(float value);
+
+    // Establece el valor de la variable
+    void setVelX(float value);
+
+    // Establece el valor de la variable
+    void setVelY(float value);
+
+    // Establece el valor de la variable
+    void setAccelX(float value);
+
+    // Establece el valor de la variable
+    void setAccelY(float value);
+
+    // Establece el valor de la variable
+    void setZoomW(float value);
+
+    // Establece el valor de la variable
+    void setZoomH(float value);
+
+    // Establece el valor de la variable
+    void setAngle(double vaue);
+
+    // Incrementa el valor de la variable
+    void incAngle(double value);
+
+    // Decrementa el valor de la variable
+    void decAngle(double value);
+
+    // Establece el valor de la variable
+    void setRotate(bool value);
+
+    // Establece el valor de la variable
+    void setRotateSpeed(int value);
+
+    // Establece el valor de la variable
+    void setRotateAmount(double value);
+
+    // Quita el efecto de rotación y deja el sprite en su angulo inicial.
+    void disableRotate();
+
+    // Cambia el sentido de la rotación
+    void switchRotate();
+
+    // Establece el valor de la variable
+    void setFlip(SDL_FlipMode flip);
+
+    // Gira el sprite horizontalmente
+    void flip();
+
+    // Obtiene el valor de la variable
+    SDL_FlipMode getFlip();
+
+    // Devuelve el rectangulo donde está el sprite
+    SDL_Rect getRect();
+
+    // Deshace el último movimiento
+    void undoMove();
+
+    // Deshace el último movimiento en el eje X
+    void undoMoveX();
+
+    // Deshace el último movimiento en el eje Y
+    void undoMoveY();
+
+    // Pone a cero las velocidades de desplacamiento
+    void clearVel();
+
+    // Devuelve el incremento en el eje X en pixels
+    int getIncX();
+};

source/core/rendering/screen.cpp

@@ -0,0 +1,369 @@
+#include "core/rendering/screen.h"
+
+#include <SDL3/SDL.h>
+
+#include <algorithm>  // for max, min
+#include <iostream>   // for basic_ostream, operator<<, cout, endl
+#include <string>     // for basic_string, char_traits, string
+
+#include "core/input/mouse.hpp"    // for Mouse::cursorVisible, Mouse::lastMouseMoveTime
+#include "core/rendering/text.h"   // for Text, TXT_CENTER, TXT_COLOR, TXT_STROKE
+#include "core/resources/asset.h"  // for Asset
+#include "core/resources/resource.h"
+
+#ifdef __EMSCRIPTEN__
+#include <emscripten.h>
+#include <emscripten/html5.h>
+
+// --- Fix per a fullscreen/resize en Emscripten ---
+//
+// SDL3 + Emscripten no emet de forma fiable SDL_EVENT_WINDOW_LEAVE_FULLSCREEN
+// (libsdl-org/SDL#13300) ni SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED /
+// SDL_EVENT_DISPLAY_ORIENTATION (libsdl-org/SDL#11389). Quan l'usuari ix de
+// fullscreen amb Esc o rota el mòbil, el canvas HTML torna al tamany correcte
+// però l'estat intern de SDL creu que segueix en fullscreen amb la resolució
+// anterior i el viewport queda desencuadrat.
+//
+// Solució: registrar callbacks natius d'Emscripten, diferir la feina un tick
+// del event loop (el canvas encara no està estable en el moment del callback)
+// i cridar setVideoMode() amb el flag de fullscreen actualitzat. La crida
+// interna a SDL_SetWindowFullscreen(false) és la peça que realment fa eixir
+// SDL del seu estat intern de fullscreen — sense això res més funciona.
+namespace {
+    Screen *g_screen_instance = nullptr;
+
+    void deferredCanvasResize(void * /*userData*/) {
+        if (g_screen_instance) {
+            g_screen_instance->handleCanvasResized();
+        }
+    }
+
+    EM_BOOL onEmFullscreenChange(int /*eventType*/, const EmscriptenFullscreenChangeEvent *event, void * /*userData*/) {
+        if (g_screen_instance && event) {
+            g_screen_instance->syncFullscreenFlagFromBrowser(event->isFullscreen != 0);
+        }
+        emscripten_async_call(deferredCanvasResize, nullptr, 0);
+        return EM_FALSE;
+    }
+
+    EM_BOOL onEmOrientationChange(int /*eventType*/, const EmscriptenOrientationChangeEvent * /*event*/, void * /*userData*/) {
+        emscripten_async_call(deferredCanvasResize, nullptr, 0);
+        return EM_FALSE;
+    }
+}  // namespace
+#endif  // __EMSCRIPTEN__
+
+// Constructor
+Screen::Screen(SDL_Window *window, SDL_Renderer *renderer, Asset *asset, options_t *options) {
+    // Inicializa variables
+    this->window = window;
+    this->renderer = renderer;
+    this->options = options;
+    this->asset = asset;
+
+    gameCanvasWidth = options->gameWidth;
+    gameCanvasHeight = options->gameHeight;
+    borderWidth = options->borderWidth * 2;
+    borderHeight = options->borderHeight * 2;
+
+    // Define el color del borde para el modo de pantalla completa
+    borderColor = {0x00, 0x00, 0x00};
+
+    // Crea la textura donde se dibujan los graficos del juego
+    gameCanvas = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, gameCanvasWidth, gameCanvasHeight);
+    if (gameCanvas != nullptr) {
+        SDL_SetTextureScaleMode(gameCanvas, options->filter == FILTER_NEAREST ? SDL_SCALEMODE_NEAREST : SDL_SCALEMODE_LINEAR);
+    }
+    if (gameCanvas == nullptr) {
+        if (options->console) {
+            std::cout << "gameCanvas could not be created!\nSDL Error: " << SDL_GetError() << std::endl;
+        }
+    }
+
+    // Establece el modo de video
+    setVideoMode(options->videoMode != 0);
+
+    // Inicializa el sistema de notificaciones (Text compartido de Resource)
+    notificationText = Resource::get()->getText("8bithud");
+    notificationMessage = "";
+    notificationTextColor = {0xFF, 0xFF, 0xFF};
+    notificationOutlineColor = {0x00, 0x00, 0x00};
+    notificationEndTime = 0;
+    notificationY = 2;
+
+    // Registra callbacks natius d'Emscripten per a fullscreen/orientation
+    registerEmscriptenEventCallbacks();
+}
+
+// Destructor
+Screen::~Screen() {
+    // notificationText es propiedad de Resource — no liberar.
+    SDL_DestroyTexture(gameCanvas);
+}
+
+// Limpia la pantalla
+void Screen::clean(color_t color) {
+    SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, 0xFF);
+    SDL_RenderClear(renderer);
+}
+
+// Prepara para empezar a dibujar en la textura de juego
+void Screen::start() {
+    SDL_SetRenderTarget(renderer, gameCanvas);
+}
+
+// Vuelca el contenido del renderizador en pantalla
+void Screen::blit() {
+    // Dibuja la notificación activa sobre el gameCanvas antes de presentar
+    SDL_SetRenderTarget(renderer, gameCanvas);
+    renderNotification();
+
+    // Vuelve a dejar el renderizador en modo normal
+    SDL_SetRenderTarget(renderer, nullptr);
+
+    // Borra el contenido previo
+    SDL_SetRenderDrawColor(renderer, borderColor.r, borderColor.g, borderColor.b, 0xFF);
+    SDL_RenderClear(renderer);
+
+    // Copia la textura de juego en el renderizador en la posición adecuada
+    SDL_FRect fdest = {(float)dest.x, (float)dest.y, (float)dest.w, (float)dest.h};
+    SDL_RenderTexture(renderer, gameCanvas, nullptr, &fdest);
+
+    // Muestra por pantalla el renderizador
+    SDL_RenderPresent(renderer);
+}
+
+// ============================================================================
+// Video y ventana
+// ============================================================================
+
+// Establece el modo de video
+void Screen::setVideoMode(bool fullscreen) {
+    applyFullscreen(fullscreen);
+    if (fullscreen) {
+        applyFullscreenLayout();
+    } else {
+        applyWindowedLayout();
+    }
+    applyLogicalPresentation(fullscreen);
+}
+
+// Cambia entre pantalla completa y ventana
+void Screen::toggleVideoMode() {
+    setVideoMode(options->videoMode == 0);
+}
+
+// Reduce el zoom de la ventana
+auto Screen::decWindowZoom() -> bool {
+    if (options->videoMode != 0) { return false; }
+    const int PREV = options->windowSize;
+    options->windowSize = std::max(options->windowSize - 1, WINDOW_ZOOM_MIN);
+    if (options->windowSize == PREV) { return false; }
+    setVideoMode(false);
+    return true;
+}
+
+// Aumenta el zoom de la ventana
+auto Screen::incWindowZoom() -> bool {
+    if (options->videoMode != 0) { return false; }
+    const int PREV = options->windowSize;
+    options->windowSize = std::min(options->windowSize + 1, WINDOW_ZOOM_MAX);
+    if (options->windowSize == PREV) { return false; }
+    setVideoMode(false);
+    return true;
+}
+
+// Establece el zoom de la ventana directamente
+auto Screen::setWindowZoom(int zoom) -> bool {
+    if (options->videoMode != 0) { return false; }
+    if (zoom < WINDOW_ZOOM_MIN || zoom > WINDOW_ZOOM_MAX) { return false; }
+    if (zoom == options->windowSize) { return false; }
+    options->windowSize = zoom;
+    setVideoMode(false);
+    return true;
+}
+
+// Establece el escalado entero
+void Screen::setIntegerScale(bool enabled) {
+    if (options->integerScale == enabled) { return; }
+    options->integerScale = enabled;
+    setVideoMode(options->videoMode != 0);
+}
+
+// Alterna el escalado entero
+void Screen::toggleIntegerScale() {
+    setIntegerScale(!options->integerScale);
+}
+
+// Establece el V-Sync
+void Screen::setVSync(bool enabled) {
+    options->vSync = enabled;
+    SDL_SetRenderVSync(renderer, enabled ? 1 : SDL_RENDERER_VSYNC_DISABLED);
+}
+
+// Alterna el V-Sync
+void Screen::toggleVSync() {
+    setVSync(!options->vSync);
+}
+
+// Cambia el color del borde
+void Screen::setBorderColor(color_t color) {
+    borderColor = color;
+}
+
+// ============================================================================
+// Helpers privados de setVideoMode
+// ============================================================================
+
+// SDL_SetWindowFullscreen + visibilidad del cursor
+void Screen::applyFullscreen(bool fullscreen) {
+    SDL_SetWindowFullscreen(window, fullscreen);
+    if (fullscreen) {
+        SDL_HideCursor();
+        Mouse::cursorVisible = false;
+    } else {
+        SDL_ShowCursor();
+        Mouse::cursorVisible = true;
+        Mouse::lastMouseMoveTime = SDL_GetTicks();
+    }
+}
+
+// Calcula windowWidth/Height/dest para el modo ventana y aplica SDL_SetWindowSize
+void Screen::applyWindowedLayout() {
+    if (options->borderEnabled) {
+        windowWidth = gameCanvasWidth + borderWidth;
+        windowHeight = gameCanvasHeight + borderHeight;
+        dest = {0 + (borderWidth / 2), 0 + (borderHeight / 2), gameCanvasWidth, gameCanvasHeight};
+    } else {
+        windowWidth = gameCanvasWidth;
+        windowHeight = gameCanvasHeight;
+        dest = {0, 0, gameCanvasWidth, gameCanvasHeight};
+    }
+
+#ifdef __EMSCRIPTEN__
+    windowWidth *= WASM_RENDER_SCALE;
+    windowHeight *= WASM_RENDER_SCALE;
+    dest.w *= WASM_RENDER_SCALE;
+    dest.h *= WASM_RENDER_SCALE;
+#endif
+
+    // Modifica el tamaño de la ventana
+    SDL_SetWindowSize(window, windowWidth * options->windowSize, windowHeight * options->windowSize);
+    SDL_SetWindowPosition(window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
+}
+
+// Obtiene el tamaño de la ventana en fullscreen y calcula el rect del juego
+void Screen::applyFullscreenLayout() {
+    SDL_GetWindowSize(window, &windowWidth, &windowHeight);
+    computeFullscreenGameRect();
+}
+
+// Calcula el rectángulo dest para fullscreen: integerScale / keepAspect / stretched
+void Screen::computeFullscreenGameRect() {
+    if (options->integerScale) {
+        // Calcula el tamaño de la escala máxima
+        int scale = 0;
+        while (((gameCanvasWidth * (scale + 1)) <= windowWidth) && ((gameCanvasHeight * (scale + 1)) <= windowHeight)) {
+            scale++;
+        }
+
+        dest.w = gameCanvasWidth * scale;
+        dest.h = gameCanvasHeight * scale;
+        dest.x = (windowWidth - dest.w) / 2;
+        dest.y = (windowHeight - dest.h) / 2;
+    } else if (options->keepAspect) {
+        float ratio = (float)gameCanvasWidth / (float)gameCanvasHeight;
+        if ((windowWidth - gameCanvasWidth) >= (windowHeight - gameCanvasHeight)) {
+            dest.h = windowHeight;
+            dest.w = (int)((windowHeight * ratio) + 0.5f);
+            dest.x = (windowWidth - dest.w) / 2;
+            dest.y = (windowHeight - dest.h) / 2;
+        } else {
+            dest.w = windowWidth;
+            dest.h = (int)((windowWidth / ratio) + 0.5f);
+            dest.x = (windowWidth - dest.w) / 2;
+            dest.y = (windowHeight - dest.h) / 2;
+        }
+    } else {
+        dest.w = windowWidth;
+        dest.h = windowHeight;
+        dest.x = dest.y = 0;
+    }
+}
+
+// Aplica la logical presentation y persiste el estado en options
+void Screen::applyLogicalPresentation(bool fullscreen) {
+    SDL_SetRenderLogicalPresentation(renderer, windowWidth, windowHeight, SDL_LOGICAL_PRESENTATION_LETTERBOX);
+
+    // Actualiza las opciones
+    options->videoMode = fullscreen ? SDL_WINDOW_FULLSCREEN : 0;
+    options->screen.windowWidth = windowWidth;
+    options->screen.windowHeight = windowHeight;
+}
+
+// ============================================================================
+// Notificaciones
+// ============================================================================
+
+// Muestra una notificación en la línea superior durante durationMs
+void Screen::notify(const std::string &text, color_t textColor, color_t outlineColor, Uint32 durationMs) {
+    notificationMessage = text;
+    notificationTextColor = textColor;
+    notificationOutlineColor = outlineColor;
+    notificationEndTime = SDL_GetTicks() + durationMs;
+}
+
+// Limpia la notificación actual
+void Screen::clearNotification() {
+    notificationEndTime = 0;
+    notificationMessage.clear();
+}
+
+// Dibuja la notificación activa (si la hay) sobre el gameCanvas
+void Screen::renderNotification() {
+    if (SDL_GetTicks() >= notificationEndTime) {
+        return;
+    }
+    notificationText->writeDX(TXT_CENTER | TXT_COLOR | TXT_STROKE,
+        gameCanvasWidth / 2,
+        notificationY,
+        notificationMessage,
+        1,
+        notificationTextColor,
+        1,
+        notificationOutlineColor);
+}
+
+// ============================================================================
+// Emscripten — fix per a fullscreen/resize (veure el bloc de comentaris al
+// principi del fitxer i l'anonymous namespace amb els callbacks natius).
+// ============================================================================
+
+void Screen::handleCanvasResized() {
+#ifdef __EMSCRIPTEN__
+    // La crida a SDL_SetWindowFullscreen + SDL_SetRenderLogicalPresentation
+    // que fa setVideoMode és l'única manera de resincronitzar l'estat intern
+    // de SDL amb el canvas HTML real.
+    setVideoMode(options->videoMode != 0);
+#endif
+}
+
+void Screen::syncFullscreenFlagFromBrowser(bool isFullscreen) {
+#ifdef __EMSCRIPTEN__
+    options->videoMode = isFullscreen ? SDL_WINDOW_FULLSCREEN : 0;
+#else
+    (void)isFullscreen;
+#endif
+}
+
+void Screen::registerEmscriptenEventCallbacks() {
+#ifdef __EMSCRIPTEN__
+    // IMPORTANT: NO registrem resize callback. En mòbil, fer scroll fa que el
+    // navegador oculti/mostri la barra d'URL, disparant un resize del DOM per
+    // cada scroll. Això portava a cridar setVideoMode per cada scroll, que
+    // re-aplicava la logical presentation i corrompia el viewport intern de SDL.
+    g_screen_instance = this;
+    emscripten_set_fullscreenchange_callback(EMSCRIPTEN_EVENT_TARGET_DOCUMENT, nullptr, EM_TRUE, onEmFullscreenChange);
+    emscripten_set_orientationchange_callback(nullptr, EM_TRUE, onEmOrientationChange);
+#endif
+}

source/core/rendering/screen.h

@@ -0,0 +1,94 @@
+#pragma once
+
+#include <SDL3/SDL.h>
+
+#include <string>  // for string
+
+#include "utils/utils.h"  // for color_t
+class Asset;
+class Text;
+
+// Tipos de filtro
+constexpr int FILTER_NEAREST = 0;
+constexpr int FILTER_LINEAL = 1;
+
+class Screen {
+   public:
+    // Constantes
+    static constexpr int WINDOW_ZOOM_MIN = 1;
+    static constexpr int WINDOW_ZOOM_MAX = 4;
+#ifdef __EMSCRIPTEN__
+    // En WASM el tamaño de ventana está fijado a 1x, así que escalamos el
+    // renderizado por 3 aprovechando el modo NEAREST de la textura del juego
+    // para que los píxeles salgan nítidos.
+    static constexpr int WASM_RENDER_SCALE = 3;
+#endif
+
+    // Constructor y destructor
+    Screen(SDL_Window *window, SDL_Renderer *renderer, Asset *asset, options_t *options);
+    ~Screen();
+
+    // Render loop
+    void clean(color_t color = {0x00, 0x00, 0x00});  // Limpia la pantalla
+    void start();                                    // Prepara para empezar a dibujar en la textura de juego
+    void blit();                                     // Vuelca el contenido del renderizador en pantalla
+
+    // Video y ventana
+    void setVideoMode(bool fullscreen);                     // Establece el modo de video
+    void toggleVideoMode();                                 // Cambia entre pantalla completa y ventana
+    void handleCanvasResized();                             // En Emscripten, reaplica setVideoMode tras un cambio del navegador (salida de fullscreen con Esc, rotación). No-op fuera de Emscripten
+    void syncFullscreenFlagFromBrowser(bool isFullscreen);  // Sincroniza el flag interno de fullscreen con el estado real del navegador. Debe llamarse antes de diferir handleCanvasResized. No-op fuera de Emscripten
+    void toggleIntegerScale();                              // Alterna el escalado entero
+    void setIntegerScale(bool enabled);                     // Establece el escalado entero
+    void toggleVSync();                                     // Alterna el V-Sync
+    void setVSync(bool enabled);                            // Establece el V-Sync
+    auto decWindowZoom() -> bool;                           // Reduce el zoom de la ventana (devuelve true si cambió)
+    auto incWindowZoom() -> bool;                           // Aumenta el zoom de la ventana (devuelve true si cambió)
+    auto setWindowZoom(int zoom) -> bool;                   // Establece el zoom de la ventana (devuelve true si cambió)
+
+    // Borde
+    void setBorderColor(color_t color);  // Cambia el color del borde
+
+    // Notificaciones
+    void notify(const std::string &text, color_t textColor, color_t outlineColor, Uint32 durationMs);  // Muestra una notificación en la línea superior del canvas durante durationMs. Sobrescribe cualquier notificación activa (sin apilación).
+    void clearNotification();                                                                          // Limpia la notificación actual
+
+   private:
+    // Helpers internos de setVideoMode
+    void applyFullscreen(bool fullscreen);           // SDL_SetWindowFullscreen + visibilidad del cursor
+    void applyWindowedLayout();                      // Calcula windowWidth/Height/dest + SDL_SetWindowSize + SDL_SetWindowPosition
+    void applyFullscreenLayout();                    // SDL_GetWindowSize + delegación a computeFullscreenGameRect
+    void computeFullscreenGameRect();                // Calcula dest en fullscreen (integerScale / keepAspect / stretched)
+    void applyLogicalPresentation(bool fullscreen);  // SDL_SetRenderLogicalPresentation + persistencia a options
+
+    // Emscripten
+    void registerEmscriptenEventCallbacks();  // Registra los callbacks nativos de Emscripten para fullscreenchange y orientationchange. No-op fuera de Emscripten
+
+    // Notificaciones
+    void renderNotification();  // Dibuja la notificación activa (si la hay) sobre el gameCanvas
+
+    // Objetos y punteros
+    SDL_Window *window;       // Ventana de la aplicación
+    SDL_Renderer *renderer;   // El renderizador de la ventana
+    Asset *asset;             // Objeto con el listado de recursos
+    SDL_Texture *gameCanvas;  // Textura para completar la ventana de juego hasta la pantalla completa
+    options_t *options;       // Variable con todas las opciones del programa
+
+    // Variables
+    int windowWidth;       // Ancho de la pantalla o ventana
+    int windowHeight;      // Alto de la pantalla o ventana
+    int gameCanvasWidth;   // Resolución interna del juego. Es el ancho de la textura donde se dibuja el juego
+    int gameCanvasHeight;  // Resolución interna del juego. Es el alto de la textura donde se dibuja el juego
+    int borderWidth;       // Anchura del borde
+    int borderHeight;      // Altura del borde
+    SDL_Rect dest;         // Coordenadas donde se va a dibujar la textura del juego sobre la pantalla o ventana
+    color_t borderColor;   // Color del borde añadido a la textura de juego para rellenar la pantalla
+
+    // Notificaciones - una sola activa, sin apilación ni animaciones
+    Text *notificationText;            // Fuente 8bithud dedicada a las notificaciones
+    std::string notificationMessage;   // Texto a mostrar
+    color_t notificationTextColor;     // Color del texto
+    color_t notificationOutlineColor;  // Color del outline
+    Uint32 notificationEndTime;        // SDL_GetTicks() hasta el cual se muestra
+    int notificationY;                 // Fila vertical en el canvas virtual
+};

source/core/rendering/smartsprite.cpp

@@ -0,0 +1,164 @@
+#include "core/rendering/smartsprite.h"
+
+#include "core/rendering/movingsprite.h"  // for MovingSprite
+class Texture;
+
+// Constructor
+SmartSprite::SmartSprite(Texture *texture, SDL_Renderer *renderer) {
+    // Copia punteros
+    setTexture(texture);
+    setRenderer(renderer);
+
+    // Inicializa el objeto
+    init();
+}
+
+// Inicializa el objeto
+void SmartSprite::init() {
+    enabled = false;
+    enabledCounter = 0;
+    onDestination = false;
+    destX = 0;
+    destY = 0;
+    counter = 0;
+    finished = false;
+}
+
+// Actualiza la posición y comprueba si ha llegado a su destino
+void SmartSprite::update() {
+    if (enabled) {
+        // Actualiza las variables internas del objeto
+        MovingSprite::update();
+
+        // Comprueba el movimiento
+        checkMove();
+
+        // Comprueba si ha terminado
+        checkFinished();
+    }
+}
+
+// Pinta el objeto en pantalla
+void SmartSprite::render() {
+    if (enabled) {
+        // Muestra el sprite por pantalla
+        MovingSprite::render();
+    }
+}
+
+// Obtiene el valor de la variable
+bool SmartSprite::isEnabled() {
+    return enabled;
+}
+
+// Establece el valor de la variable
+void SmartSprite::setEnabled(bool enabled) {
+    this->enabled = enabled;
+}
+
+// Obtiene el valor de la variable
+int SmartSprite::getEnabledCounter() {
+    return enabledCounter;
+}
+
+// Establece el valor de la variable
+void SmartSprite::setEnabledCounter(int value) {
+    enabledCounter = value;
+}
+
+// Establece el valor de la variable
+void SmartSprite::setDestX(int x) {
+    destX = x;
+}
+
+// Establece el valor de la variable
+void SmartSprite::setDestY(int y) {
+    destY = y;
+}
+
+// Obtiene el valor de la variable
+int SmartSprite::getDestX() {
+    return destX;
+}
+
+// Obtiene el valor de la variable
+int SmartSprite::getDestY() {
+    return destY;
+}
+
+// Comprueba el movimiento
+void SmartSprite::checkMove() {
+    // Comprueba si se desplaza en el eje X hacia la derecha
+    if (getAccelX() > 0 || getVelX() > 0) {
+        // Comprueba si ha llegado al destino
+        if (getPosX() > destX) {
+            // Lo coloca en posición
+            setPosX(destX);
+
+            // Lo detiene
+            setVelX(0.0f);
+            setAccelX(0.0f);
+        }
+    }
+    // Comprueba si se desplaza en el eje X hacia la izquierda
+    else if (getAccelX() < 0 || getVelX() < 0) {
+        // Comprueba si ha llegado al destino
+        if (getPosX() < destX) {
+            // Lo coloca en posición
+            setPosX(destX);
+
+            // Lo detiene
+            setVelX(0.0f);
+            setAccelX(0.0f);
+        }
+    }
+
+    // Comprueba si se desplaza en el eje Y hacia abajo
+    if (getAccelY() > 0 || getVelY() > 0) {
+        // Comprueba si ha llegado al destino
+        if (getPosY() > destY) {
+            // Lo coloca en posición
+            setPosY(destY);
+
+            // Lo detiene
+            setVelY(0.0f);
+            setAccelY(0.0f);
+        }
+    }
+    // Comprueba si se desplaza en el eje Y hacia arriba
+    else if (getAccelY() < 0 || getVelY() < 0) {
+        // Comprueba si ha llegado al destino
+        if (getPosY() < destY) {
+            // Lo coloca en posición
+            setPosY(destY);
+
+            // Lo detiene
+            setVelY(0.0f);
+            setAccelY(0.0f);
+        }
+    }
+}
+
+// Comprueba si ha terminado
+void SmartSprite::checkFinished() {
+    // Comprueba si ha llegado a su destino
+    onDestination = (getPosX() == destX && getPosY() == destY) ? true : false;
+
+    if (onDestination) {            // Si esta en el destino comprueba su contador
+        if (enabledCounter == 0) {  // Si ha llegado a cero, deshabilita el objeto y lo marca como finalizado
+            finished = true;
+        } else {  // Si no ha llegado a cero, decrementa el contador
+            enabledCounter--;
+        }
+    }
+}
+
+// Obtiene el valor de la variable
+bool SmartSprite::isOnDestination() {
+    return onDestination;
+}
+
+// Obtiene el valor de la variable
+bool SmartSprite::hasFinished() {
+    return finished;
+}

source/core/rendering/smartsprite.h

@@ -0,0 +1,67 @@
+#pragma once
+
+#include <SDL3/SDL.h>
+
+#include "core/rendering/animatedsprite.h"  // for AnimatedSprite
+class Texture;
+
+// Clase SmartSprite
+class SmartSprite : public AnimatedSprite {
+   private:
+    // Variables
+    bool enabled;        // Indica si esta habilitado
+    bool onDestination;  // Indica si está en el destino
+    int destX;           // Posicion de destino en el eje X
+    int destY;           // Posicion de destino en el eje Y
+    int enabledCounter;  // Contador para deshabilitarlo
+    bool finished;       // Indica si ya ha terminado
+
+    // Comprueba el movimiento
+    void checkMove();
+
+    // Comprueba si ha terminado
+    void checkFinished();
+
+   public:
+    // Constructor
+    SmartSprite(Texture *texture, SDL_Renderer *renderer);
+
+    // Inicializa el objeto
+    void init();
+
+    // Actualiza la posición y comprueba si ha llegado a su destino
+    void update();
+
+    // Pinta el objeto en pantalla
+    void render();
+
+    // Obtiene el valor de la variable
+    bool isEnabled();
+
+    // Establece el valor de la variable
+    void setEnabled(bool enabled);
+
+    // Obtiene el valor de la variable
+    int getEnabledCounter();
+
+    // Establece el valor de la variable
+    void setEnabledCounter(int value);
+
+    // Establece el valor de la variable
+    void setDestX(int x);
+
+    // Establece el valor de la variable
+    void setDestY(int y);
+
+    // Obtiene el valor de la variable
+    int getDestX();
+
+    // Obtiene el valor de la variable
+    int getDestY();
+
+    // Obtiene el valor de la variable
+    bool isOnDestination();
+
+    // Obtiene el valor de la variable
+    bool hasFinished();
+};

source/core/rendering/sprite.cpp

@@ -0,0 +1,166 @@
+#include "core/rendering/sprite.h"
+
+#include "core/rendering/texture.h"  // for Texture
+
+// Constructor
+Sprite::Sprite(int x, int y, int w, int h, Texture *texture, SDL_Renderer *renderer) {
+    // Establece la posición X,Y del sprite
+    this->x = x;
+    this->y = y;
+
+    // Establece el alto y el ancho del sprite
+    this->w = w;
+    this->h = h;
+
+    // Establece el puntero al renderizador de la ventana
+    this->renderer = renderer;
+
+    // Establece la textura donde están los gráficos para el sprite
+    this->texture = texture;
+
+    // Establece el rectangulo de donde coger la imagen
+    spriteClip = {0, 0, w, h};
+
+    // Inicializa variables
+    enabled = true;
+}
+
+Sprite::Sprite(SDL_Rect rect, Texture *texture, SDL_Renderer *renderer) {
+    // Establece la posición X,Y del sprite
+    x = rect.x;
+    y = rect.y;
+
+    // Establece el alto y el ancho del sprite
+    w = rect.w;
+    h = rect.h;
+
+    // Establece el puntero al renderizador de la ventana
+    this->renderer = renderer;
+
+    // Establece la textura donde están los gráficos para el sprite
+    this->texture = texture;
+
+    // Establece el rectangulo de donde coger la imagen
+    spriteClip = {0, 0, w, h};
+
+    // Inicializa variables
+    enabled = true;
+}
+
+// Destructor
+Sprite::~Sprite() {
+    texture = nullptr;
+    renderer = nullptr;
+}
+
+// Muestra el sprite por pantalla
+void Sprite::render() {
+    if (enabled) {
+        texture->render(renderer, x, y, &spriteClip);
+    }
+}
+
+// Obten el valor de la variable
+int Sprite::getPosX() {
+    return x;
+}
+
+// Obten el valor de la variable
+int Sprite::getPosY() {
+    return y;
+}
+
+// Obten el valor de la variable
+int Sprite::getWidth() {
+    return w;
+}
+
+// Obten el valor de la variable
+int Sprite::getHeight() {
+    return h;
+}
+
+// Establece la posición del objeto
+void Sprite::setPos(SDL_Rect rect) {
+    this->x = rect.x;
+    this->y = rect.y;
+}
+
+// Establece el valor de la variable
+void Sprite::setPosX(int x) {
+    this->x = x;
+}
+
+// Establece el valor de la variable
+void Sprite::setPosY(int y) {
+    this->y = y;
+}
+
+// Establece el valor de la variable
+void Sprite::setWidth(int w) {
+    this->w = w;
+}
+
+// Establece el valor de la variable
+void Sprite::setHeight(int h) {
+    this->h = h;
+}
+
+// Obten el valor de la variable
+SDL_Rect Sprite::getSpriteClip() {
+    return spriteClip;
+}
+
+// Establece el valor de la variable
+void Sprite::setSpriteClip(SDL_Rect rect) {
+    spriteClip = rect;
+}
+
+// Establece el valor de la variable
+void Sprite::setSpriteClip(int x, int y, int w, int h) {
+    spriteClip = {x, y, w, h};
+}
+
+// Obten el valor de la variable
+Texture *Sprite::getTexture() {
+    return texture;
+}
+
+// Establece el valor de la variable
+void Sprite::setTexture(Texture *texture) {
+    this->texture = texture;
+}
+
+// Obten el valor de la variable
+SDL_Renderer *Sprite::getRenderer() {
+    return renderer;
+}
+
+// Establece el valor de la variable
+void Sprite::setRenderer(SDL_Renderer *renderer) {
+    this->renderer = renderer;
+}
+
+// Establece el valor de la variable
+void Sprite::setEnabled(bool value) {
+    enabled = value;
+}
+
+// Comprueba si el objeto está habilitado
+bool Sprite::isEnabled() {
+    return enabled;
+}
+
+// Devuelve el rectangulo donde está el sprite
+SDL_Rect Sprite::getRect() {
+    SDL_Rect rect = {x, y, w, h};
+    return rect;
+}
+
+// Establece los valores de posición y tamaño del sprite
+void Sprite::setRect(SDL_Rect rect) {
+    x = rect.x;
+    y = rect.y;
+    w = rect.w;
+    h = rect.h;
+}

source/core/rendering/sprite.h

@@ -0,0 +1,90 @@
+#pragma once
+
+#include <SDL3/SDL.h>
+class Texture;
+
+// Clase sprite
+class Sprite {
+   protected:
+    int x;  // Posición en el eje X donde dibujar el sprite
+    int y;  // Posición en el eje Y donde dibujar el sprite
+    int w;  // Ancho del sprite
+    int h;  // Alto del sprite
+
+    SDL_Renderer *renderer;  // Puntero al renderizador de la ventana
+    Texture *texture;        // Textura donde estan todos los dibujos del sprite
+    SDL_Rect spriteClip;     // Rectangulo de origen de la textura que se dibujará en pantalla
+
+    bool enabled;  // Indica si el sprite esta habilitado
+
+   public:
+    // Constructor
+    Sprite(int x = 0, int y = 0, int w = 0, int h = 0, Texture *texture = nullptr, SDL_Renderer *renderer = nullptr);
+    Sprite(SDL_Rect rect, Texture *texture, SDL_Renderer *renderer);
+
+    // Destructor
+    ~Sprite();
+
+    // Muestra el sprite por pantalla
+    void render();
+
+    // Obten el valor de la variable
+    int getPosX();
+
+    // Obten el valor de la variable
+    int getPosY();
+
+    // Obten el valor de la variable
+    int getWidth();
+
+    // Obten el valor de la variable
+    int getHeight();
+
+    // Establece la posición del objeto
+    void setPos(SDL_Rect rect);
+
+    // Establece el valor de la variable
+    void setPosX(int x);
+
+    // Establece el valor de la variable
+    void setPosY(int y);
+
+    // Establece el valor de la variable
+    void setWidth(int w);
+
+    // Establece el valor de la variable
+    void setHeight(int h);
+
+    // Obten el valor de la variable
+    SDL_Rect getSpriteClip();
+
+    // Establece el valor de la variable
+    void setSpriteClip(SDL_Rect rect);
+
+    // Establece el valor de la variable
+    void setSpriteClip(int x, int y, int w, int h);
+
+    // Obten el valor de la variable
+    Texture *getTexture();
+
+    // Establece el valor de la variable
+    void setTexture(Texture *texture);
+
+    // Obten el valor de la variable
+    SDL_Renderer *getRenderer();
+
+    // Establece el valor de la variable
+    void setRenderer(SDL_Renderer *renderer);
+
+    // Establece el valor de la variable
+    void setEnabled(bool value);
+
+    // Comprueba si el objeto está habilitado
+    bool isEnabled();
+
+    // Devuelve el rectangulo donde está el sprite
+    SDL_Rect getRect();
+
+    // Establece los valores de posición y tamaño del sprite
+    void setRect(SDL_Rect rect);
+};

source/core/rendering/text.cpp

@@ -0,0 +1,271 @@
+
+#include "core/rendering/text.h"
+
+#include <fstream>   // for char_traits, basic_ostream, basic_ifstream, ope...
+#include <iostream>  // for cout
+#include <sstream>
+
+#include "core/rendering/sprite.h"   // for Sprite
+#include "core/rendering/texture.h"  // for Texture
+#include "utils/utils.h"             // for color_t
+
+// Parser compartido: rellena un textFile_t desde cualquier istream
+static void parseTextFileStream(std::istream &rfile, textFile_t &tf) {
+    std::string buffer;
+    std::getline(rfile, buffer);
+    std::getline(rfile, buffer);
+    tf.boxWidth = std::stoi(buffer);
+
+    std::getline(rfile, buffer);
+    std::getline(rfile, buffer);
+    tf.boxHeight = std::stoi(buffer);
+
+    int index = 32;
+    int line_read = 0;
+    while (std::getline(rfile, buffer)) {
+        if (line_read % 2 == 1) {
+            tf.offset[index++].w = std::stoi(buffer);
+        }
+        buffer.clear();
+        line_read++;
+    }
+}
+
+static void computeTextFileOffsets(textFile_t &tf) {
+    for (int i = 32; i < 128; ++i) {
+        tf.offset[i].x = ((i - 32) % 15) * tf.boxWidth;
+        tf.offset[i].y = ((i - 32) / 15) * tf.boxHeight;
+    }
+}
+
+// Llena una estructuta textFile_t desde un fichero
+textFile_t LoadTextFile(std::string file, bool verbose) {
+    textFile_t tf;
+    for (int i = 0; i < 128; ++i) {
+        tf.offset[i].x = 0;
+        tf.offset[i].y = 0;
+        tf.offset[i].w = 0;
+    }
+
+    const std::string filename = file.substr(file.find_last_of("\\/") + 1).c_str();
+    std::ifstream rfile(file);
+    if (rfile.is_open() && rfile.good()) {
+        parseTextFileStream(rfile, tf);
+        if (verbose) {
+            std::cout << "Text loaded: " << filename.c_str() << std::endl;
+        }
+    } else if (verbose) {
+        std::cout << "Warning: Unable to open " << filename.c_str() << " file" << std::endl;
+    }
+
+    computeTextFileOffsets(tf);
+    return tf;
+}
+
+// Llena una estructura textFile_t desde bytes en memoria
+textFile_t LoadTextFileFromMemory(const std::vector<uint8_t> &bytes, bool verbose) {
+    textFile_t tf;
+    for (int i = 0; i < 128; ++i) {
+        tf.offset[i].x = 0;
+        tf.offset[i].y = 0;
+        tf.offset[i].w = 0;
+    }
+    if (!bytes.empty()) {
+        std::string content(reinterpret_cast<const char *>(bytes.data()), bytes.size());
+        std::stringstream ss(content);
+        parseTextFileStream(ss, tf);
+        if (verbose) {
+            std::cout << "Text loaded from memory" << std::endl;
+        }
+    }
+    computeTextFileOffsets(tf);
+    return tf;
+}
+
+// Constructor
+Text::Text(std::string bitmapFile, std::string textFile, SDL_Renderer *renderer) {
+    // Carga los offsets desde el fichero
+    textFile_t tf = LoadTextFile(textFile);
+
+    // Inicializa variables desde la estructura
+    boxHeight = tf.boxHeight;
+    boxWidth = tf.boxWidth;
+    for (int i = 0; i < 128; ++i) {
+        offset[i].x = tf.offset[i].x;
+        offset[i].y = tf.offset[i].y;
+        offset[i].w = tf.offset[i].w;
+    }
+
+    // Crea los objetos
+    texture = new Texture(renderer, bitmapFile);
+    sprite = new Sprite({0, 0, boxWidth, boxHeight}, texture, renderer);
+
+    // Inicializa variables
+    fixedWidth = false;
+}
+
+// Constructor
+Text::Text(std::string textFile, Texture *texture, SDL_Renderer *renderer) {
+    // Carga los offsets desde el fichero
+    textFile_t tf = LoadTextFile(textFile);
+
+    // Inicializa variables desde la estructura
+    boxHeight = tf.boxHeight;
+    boxWidth = tf.boxWidth;
+    for (int i = 0; i < 128; ++i) {
+        offset[i].x = tf.offset[i].x;
+        offset[i].y = tf.offset[i].y;
+        offset[i].w = tf.offset[i].w;
+    }
+
+    // Crea los objetos
+    this->texture = nullptr;
+    sprite = new Sprite({0, 0, boxWidth, boxHeight}, texture, renderer);
+
+    // Inicializa variables
+    fixedWidth = false;
+}
+
+// Constructor
+Text::Text(textFile_t *textFile, Texture *texture, SDL_Renderer *renderer) {
+    // Inicializa variables desde la estructura
+    boxHeight = textFile->boxHeight;
+    boxWidth = textFile->boxWidth;
+    for (int i = 0; i < 128; ++i) {
+        offset[i].x = textFile->offset[i].x;
+        offset[i].y = textFile->offset[i].y;
+        offset[i].w = textFile->offset[i].w;
+    }
+
+    // Crea los objetos
+    this->texture = nullptr;
+    sprite = new Sprite({0, 0, boxWidth, boxHeight}, texture, renderer);
+
+    // Inicializa variables
+    fixedWidth = false;
+}
+
+// Constructor desde bytes
+Text::Text(const std::vector<uint8_t> &pngBytes, const std::vector<uint8_t> &txtBytes, SDL_Renderer *renderer) {
+    textFile_t tf = LoadTextFileFromMemory(txtBytes);
+    boxHeight = tf.boxHeight;
+    boxWidth = tf.boxWidth;
+    for (int i = 0; i < 128; ++i) {
+        offset[i].x = tf.offset[i].x;
+        offset[i].y = tf.offset[i].y;
+        offset[i].w = tf.offset[i].w;
+    }
+
+    // Crea la textura desde bytes (Text es dueño en este overload)
+    texture = new Texture(renderer, pngBytes);
+    sprite = new Sprite({0, 0, boxWidth, boxHeight}, texture, renderer);
+
+    fixedWidth = false;
+}
+
+// Destructor
+Text::~Text() {
+    delete sprite;
+    if (texture != nullptr) {
+        delete texture;
+    }
+}
+
+// Escribe texto en pantalla
+void Text::write(int x, int y, std::string text, int kerning, int lenght) {
+    int shift = 0;
+
+    if (lenght == -1) {
+        lenght = text.length();
+    }
+
+    sprite->setPosY(y);
+    const int width = sprite->getWidth();
+    const int height = sprite->getHeight();
+    for (int i = 0; i < lenght; ++i) {
+        const int index = text[i];
+        sprite->setSpriteClip(offset[index].x, offset[index].y, width, height);
+        sprite->setPosX(x + shift);
+        sprite->render();
+        shift += fixedWidth ? boxWidth : (offset[int(text[i])].w + kerning);
+    }
+}
+
+// Escribe el texto con colores
+void Text::writeColored(int x, int y, std::string text, color_t color, int kerning, int lenght) {
+    sprite->getTexture()->setColor(color.r, color.g, color.b);
+    write(x, y, text, kerning, lenght);
+    sprite->getTexture()->setColor(255, 255, 255);
+}
+
+// Escribe el texto con sombra
+void Text::writeShadowed(int x, int y, std::string text, color_t color, Uint8 shadowDistance, int kerning, int lenght) {
+    sprite->getTexture()->setColor(color.r, color.g, color.b);
+    write(x + shadowDistance, y + shadowDistance, text, kerning, lenght);
+    sprite->getTexture()->setColor(255, 255, 255);
+    write(x, y, text, kerning, lenght);
+}
+
+// Escribe el texto centrado en un punto x
+void Text::writeCentered(int x, int y, std::string text, int kerning, int lenght) {
+    x -= (Text::lenght(text, kerning) / 2);
+    write(x, y, text, kerning, lenght);
+}
+
+// Escribe texto con extras
+void Text::writeDX(Uint8 flags, int x, int y, std::string text, int kerning, color_t textColor, Uint8 shadowDistance, color_t shadowColor, int lenght) {
+    const bool centered = ((flags & TXT_CENTER) == TXT_CENTER);
+    const bool shadowed = ((flags & TXT_SHADOW) == TXT_SHADOW);
+    const bool colored = ((flags & TXT_COLOR) == TXT_COLOR);
+    const bool stroked = ((flags & TXT_STROKE) == TXT_STROKE);
+
+    if (centered) {
+        x -= (Text::lenght(text, kerning) / 2);
+    }
+
+    if (shadowed) {
+        writeColored(x + shadowDistance, y + shadowDistance, text, shadowColor, kerning, lenght);
+    }
+
+    if (stroked) {
+        for (int dist = 1; dist <= shadowDistance; ++dist) {
+            for (int dy = -dist; dy <= dist; ++dy) {
+                for (int dx = -dist; dx <= dist; ++dx) {
+                    writeColored(x + dx, y + dy, text, shadowColor, kerning, lenght);
+                }
+            }
+        }
+    }
+
+    if (colored) {
+        writeColored(x, y, text, textColor, kerning, lenght);
+    } else {
+        write(x, y, text, kerning, lenght);
+    }
+}
+
+// Obtiene la longitud en pixels de una cadena
+int Text::lenght(std::string text, int kerning) {
+    int shift = 0;
+
+    for (int i = 0; i < (int)text.length(); ++i)
+        shift += (offset[int(text[i])].w + kerning);
+
+    // Descuenta el kerning del último caracter
+    return shift - kerning;
+}
+
+// Devuelve el valor de la variable
+int Text::getCharacterSize() {
+    return boxWidth;
+}
+
+// Recarga la textura
+void Text::reLoadTexture() {
+    sprite->getTexture()->reLoad();
+}
+
+// Establece si se usa un tamaño fijo de letra
+void Text::setFixedWidth(bool value) {
+    fixedWidth = value;
+}

source/core/rendering/text.h

@@ -0,0 +1,87 @@
+#pragma once
+
+#include <SDL3/SDL.h>
+
+#include <cstdint>
+#include <string>  // for string
+#include <vector>
+class Sprite;
+class Texture;
+#include "utils/utils.h"
+
+// Opciones de texto
+constexpr int TXT_COLOR = 1;
+constexpr int TXT_SHADOW = 2;
+constexpr int TXT_CENTER = 4;
+constexpr int TXT_STROKE = 8;
+
+struct offset_t {
+    int x;
+    int y;
+    int w;
+};
+
+struct textFile_t {
+    int boxWidth;          // Anchura de la caja de cada caracter en el png
+    int boxHeight;         // Altura de la caja de cada caracter en el png
+    offset_t offset[128];  // Vector con las posiciones y ancho de cada letra
+};
+
+// Llena una estructuta textFile_t desde un fichero
+textFile_t LoadTextFile(std::string file, bool verbose = false);
+
+// Llena una estructura textFile_t desde bytes en memoria
+textFile_t LoadTextFileFromMemory(const std::vector<uint8_t> &bytes, bool verbose = false);
+
+// Clase texto. Pinta texto en pantalla a partir de un bitmap
+class Text {
+   private:
+    // Objetos y punteros
+    Sprite *sprite;    // Objeto con los graficos para el texto
+    Texture *texture;  // Textura con los bitmaps del texto
+
+    // Variables
+    int boxWidth;          // Anchura de la caja de cada caracter en el png
+    int boxHeight;         // Altura de la caja de cada caracter en el png
+    bool fixedWidth;       // Indica si el texto se ha de escribir con longitud fija en todas las letras
+    offset_t offset[128];  // Vector con las posiciones y ancho de cada letra
+
+   public:
+    // Constructor
+    Text(std::string bitmapFile, std::string textFile, SDL_Renderer *renderer);
+    Text(std::string textFile, Texture *texture, SDL_Renderer *renderer);
+    Text(textFile_t *textFile, Texture *texture, SDL_Renderer *renderer);
+
+    // Constructor desde bytes en memoria: comparte ownership del texture (no lo libera)
+    Text(const std::vector<uint8_t> &pngBytes, const std::vector<uint8_t> &txtBytes, SDL_Renderer *renderer);
+
+    // Destructor
+    ~Text();
+
+    // Escribe el texto en pantalla
+    void write(int x, int y, std::string text, int kerning = 1, int lenght = -1);
+
+    // Escribe el texto con colores
+    void writeColored(int x, int y, std::string text, color_t color, int kerning = 1, int lenght = -1);
+
+    // Escribe el texto con sombra
+    void writeShadowed(int x, int y, std::string text, color_t color, Uint8 shadowDistance = 1, int kerning = 1, int lenght = -1);
+
+    // Escribe el texto centrado en un punto x
+    void writeCentered(int x, int y, std::string text, int kerning = 1, int lenght = -1);
+
+    // Escribe texto con extras
+    void writeDX(Uint8 flags, int x, int y, std::string text, int kerning = 1, color_t textColor = color_t(255, 255, 255), Uint8 shadowDistance = 1, color_t shadowColor = color_t(0, 0, 0), int lenght = -1);
+
+    // Obtiene la longitud en pixels de una cadena
+    int lenght(std::string text, int kerning = 1);
+
+    // Devuelve el valor de la variable
+    int getCharacterSize();
+
+    // Recarga la textura
+    void reLoadTexture();
+
+    // Establece si se usa un tamaño fijo de letra
+    void setFixedWidth(bool value);
+};

source/core/rendering/texture.cpp

@@ -0,0 +1,212 @@
+
+#include "core/rendering/texture.h"
+
+#include <SDL3/SDL.h>
+#include <stdlib.h>  // for exit
+
+#include <iostream>  // for basic_ostream, operator<<, cout, endl
+#define STB_IMAGE_IMPLEMENTATION
+#include "external/stb_image.h"  // for stbi_failure_reason, stbi_image_free
+
+SDL_ScaleMode Texture::currentScaleMode = SDL_SCALEMODE_NEAREST;
+
+void Texture::setGlobalScaleMode(SDL_ScaleMode mode) {
+    currentScaleMode = mode;
+}
+
+// Constructor
+Texture::Texture(SDL_Renderer *renderer, std::string path, bool verbose) {
+    // Copia punteros
+    this->renderer = renderer;
+    this->path = path;
+
+    // Inicializa
+    texture = nullptr;
+    width = 0;
+    height = 0;
+
+    // Carga el fichero en la textura
+    if (path != "") {
+        loadFromFile(path, renderer, verbose);
+    }
+}
+
+// Constructor desde bytes
+Texture::Texture(SDL_Renderer *renderer, const std::vector<uint8_t> &bytes, bool verbose) {
+    this->renderer = renderer;
+    this->path = "";
+    texture = nullptr;
+    width = 0;
+    height = 0;
+
+    if (!bytes.empty()) {
+        loadFromMemory(bytes.data(), bytes.size(), renderer, verbose);
+    }
+}
+
+// Destructor
+Texture::~Texture() {
+    // Libera memoria
+    unload();
+}
+
+// Helper: convierte píxeles RGBA decodificados por stbi en SDL_Texture
+static SDL_Texture *createTextureFromPixels(SDL_Renderer *renderer, unsigned char *data, int w, int h, int *out_w, int *out_h) {
+    const int pitch = 4 * w;
+    SDL_Surface *loadedSurface = SDL_CreateSurfaceFrom(w, h, SDL_PIXELFORMAT_RGBA32, (void *)data, pitch);
+    if (loadedSurface == nullptr) {
+        return nullptr;
+    }
+    SDL_Texture *newTexture = SDL_CreateTextureFromSurface(renderer, loadedSurface);
+    if (newTexture != nullptr) {
+        *out_w = loadedSurface->w;
+        *out_h = loadedSurface->h;
+        SDL_SetTextureScaleMode(newTexture, Texture::currentScaleMode);
+    }
+    SDL_DestroySurface(loadedSurface);
+    return newTexture;
+}
+
+// Carga una imagen desde un fichero
+bool Texture::loadFromFile(std::string path, SDL_Renderer *renderer, bool verbose) {
+    const std::string filename = path.substr(path.find_last_of("\\/") + 1);
+    int req_format = STBI_rgb_alpha;
+    int w, h, orig_format;
+    unsigned char *data = stbi_load(path.c_str(), &w, &h, &orig_format, req_format);
+    if (data == nullptr) {
+        SDL_Log("Loading image failed: %s", stbi_failure_reason());
+        exit(1);
+    } else if (verbose) {
+        std::cout << "Image loaded: " << filename.c_str() << std::endl;
+    }
+
+    unload();
+    SDL_Texture *newTexture = createTextureFromPixels(renderer, data, w, h, &this->width, &this->height);
+    if (newTexture == nullptr && verbose) {
+        std::cout << "Unable to load image " << path.c_str() << std::endl;
+    }
+
+    stbi_image_free(data);
+    texture = newTexture;
+    return texture != nullptr;
+}
+
+// Carga una imagen desde bytes en memoria
+bool Texture::loadFromMemory(const uint8_t *data, size_t size, SDL_Renderer *renderer, bool verbose) {
+    int w, h, orig_format;
+    unsigned char *pixels = stbi_load_from_memory(data, (int)size, &w, &h, &orig_format, STBI_rgb_alpha);
+    if (pixels == nullptr) {
+        SDL_Log("Loading image from memory failed: %s", stbi_failure_reason());
+        return false;
+    }
+
+    unload();
+    SDL_Texture *newTexture = createTextureFromPixels(renderer, pixels, w, h, &this->width, &this->height);
+    if (newTexture == nullptr && verbose) {
+        std::cout << "Unable to create texture from memory" << std::endl;
+    }
+
+    stbi_image_free(pixels);
+    texture = newTexture;
+    return texture != nullptr;
+}
+
+// Crea una textura en blanco
+bool Texture::createBlank(SDL_Renderer *renderer, int width, int height, SDL_TextureAccess access) {
+    // Crea una textura sin inicializar
+    texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, access, width, height);
+    if (texture == nullptr) {
+        std::cout << "Unable to create blank texture! SDL Error: " << SDL_GetError() << std::endl;
+    } else {
+        this->width = width;
+        this->height = height;
+        SDL_SetTextureScaleMode(texture, currentScaleMode);
+    }
+
+    return texture != nullptr;
+}
+
+// Libera la memoria de la textura
+void Texture::unload() {
+    // Libera la textura si existe
+    if (texture != nullptr) {
+        SDL_DestroyTexture(texture);
+        texture = nullptr;
+        width = 0;
+        height = 0;
+    }
+}
+
+// Establece el color para la modulacion
+void Texture::setColor(Uint8 red, Uint8 green, Uint8 blue) {
+    SDL_SetTextureColorMod(texture, red, green, blue);
+}
+
+// Establece el blending
+void Texture::setBlendMode(SDL_BlendMode blending) {
+    SDL_SetTextureBlendMode(texture, blending);
+}
+
+// Establece el alpha para la modulación
+void Texture::setAlpha(Uint8 alpha) {
+    SDL_SetTextureAlphaMod(texture, alpha);
+}
+
+// Renderiza la textura en un punto específico
+void Texture::render(SDL_Renderer *renderer, int x, int y, SDL_Rect *clip, float zoomW, float zoomH, double angle, SDL_Point *center, SDL_FlipMode flip) {
+    // Establece el destino de renderizado en la pantalla
+    SDL_FRect renderQuad = {(float)x, (float)y, (float)width, (float)height};
+
+    // Obtiene las dimesiones del clip de renderizado
+    if (clip != nullptr) {
+        renderQuad.w = (float)clip->w;
+        renderQuad.h = (float)clip->h;
+    }
+
+    renderQuad.w = renderQuad.w * zoomW;
+    renderQuad.h = renderQuad.h * zoomH;
+
+    // Convierte el clip a SDL_FRect
+    SDL_FRect srcRect;
+    SDL_FRect *srcRectPtr = nullptr;
+    if (clip != nullptr) {
+        srcRect = {(float)clip->x, (float)clip->y, (float)clip->w, (float)clip->h};
+        srcRectPtr = &srcRect;
+    }
+
+    // Convierte el centro a SDL_FPoint
+    SDL_FPoint fCenter;
+    SDL_FPoint *fCenterPtr = nullptr;
+    if (center != nullptr) {
+        fCenter = {(float)center->x, (float)center->y};
+        fCenterPtr = &fCenter;
+    }
+
+    // Renderiza a pantalla
+    SDL_RenderTextureRotated(renderer, texture, srcRectPtr, &renderQuad, angle, fCenterPtr, flip);
+}
+
+// Establece la textura como objetivo de renderizado
+void Texture::setAsRenderTarget(SDL_Renderer *renderer) {
+    SDL_SetRenderTarget(renderer, texture);
+}
+
+// Obtiene el ancho de la imagen
+int Texture::getWidth() {
+    return width;
+}
+
+// Obtiene el alto de la imagen
+int Texture::getHeight() {
+    return height;
+}
+
+// Recarga la textura
+bool Texture::reLoad() {
+    return loadFromFile(path, renderer);
+}
+
+// Obtiene la textura
+SDL_Texture *Texture::getSDLTexture() {
+    return texture;
+}

source/core/rendering/texture.h

@@ -0,0 +1,73 @@
+#pragma once
+
+#include <SDL3/SDL.h>
+
+#include <cstdint>
+#include <string>  // for basic_string, string
+#include <vector>
+
+class Texture {
+   private:
+    // Objetos y punteros
+    SDL_Texture *texture;    // La textura
+    SDL_Renderer *renderer;  // Renderizador donde dibujar la textura
+
+    // Variables
+    int width;         // Ancho de la imagen
+    int height;        // Alto de la imagen
+    std::string path;  // Ruta de la imagen de la textura
+
+   public:
+    static SDL_ScaleMode currentScaleMode;  // Modo de escalado global para nuevas texturas
+
+    // Establece el modo de escalado global para nuevas texturas
+    static void setGlobalScaleMode(SDL_ScaleMode mode);
+
+    // Constructor
+    Texture(SDL_Renderer *renderer, std::string path = "", bool verbose = false);
+
+    // Constructor desde bytes (PNG en memoria)
+    Texture(SDL_Renderer *renderer, const std::vector<uint8_t> &bytes, bool verbose = false);
+
+    // Destructor
+    ~Texture();
+
+    // Carga una imagen desde un fichero
+    bool loadFromFile(std::string path, SDL_Renderer *renderer, bool verbose = false);
+
+    // Carga una imagen desde bytes en memoria
+    bool loadFromMemory(const uint8_t *data, size_t size, SDL_Renderer *renderer, bool verbose = false);
+
+    // Crea una textura en blanco
+    bool createBlank(SDL_Renderer *renderer, int width, int height, SDL_TextureAccess = SDL_TEXTUREACCESS_STREAMING);
+
+    // Libera la memoria de la textura
+    void unload();
+
+    // Establece el color para la modulacion
+    void setColor(Uint8 red, Uint8 green, Uint8 blue);
+
+    // Establece el blending
+    void setBlendMode(SDL_BlendMode blending);
+
+    // Establece el alpha para la modulación
+    void setAlpha(Uint8 alpha);
+
+    // Renderiza la textura en un punto específico
+    void render(SDL_Renderer *renderer, int x, int y, SDL_Rect *clip = nullptr, float zoomW = 1, float zoomH = 1, double angle = 0.0, SDL_Point *center = nullptr, SDL_FlipMode flip = SDL_FLIP_NONE);
+
+    // Establece la textura como objetivo de renderizado
+    void setAsRenderTarget(SDL_Renderer *renderer);
+
+    // Obtiene el ancho de la imagen
+    int getWidth();
+
+    // Obtiene el alto de la imagen
+    int getHeight();
+
+    // Recarga la textura
+    bool reLoad();
+
+    // Obtiene la textura
+    SDL_Texture *getSDLTexture();
+};

source/core/rendering/writer.cpp

@@ -0,0 +1,115 @@
+#include "core/rendering/writer.h"
+
+#include "core/rendering/text.h"  // for Text
+
+// Constructor
+Writer::Writer(Text *text) {
+    // Copia los punteros
+    this->text = text;
+
+    // Inicializa variables
+    posX = 0;
+    posY = 0;
+    kerning = 0;
+    caption = "";
+    speed = 0;
+    writingCounter = 0;
+    index = 0;
+    lenght = 0;
+    completed = false;
+    enabled = false;
+    enabledCounter = 0;
+    finished = false;
+}
+
+// Actualiza el objeto
+void Writer::update() {
+    if (enabled) {
+        if (!completed) {  // No completado
+            if (writingCounter > 0) {
+                writingCounter--;
+            }
+
+            else if (writingCounter == 0) {
+                index++;
+                writingCounter = speed;
+            }
+
+            if (index == lenght) {
+                completed = true;
+            }
+        }
+
+        if (completed) {  // Completado
+            if (enabledCounter > 0) {
+                enabledCounter--;
+            } else if (enabledCounter == 0) {
+                finished = true;
+            }
+        }
+    }
+}
+
+// Dibuja el objeto en pantalla
+void Writer::render() {
+    if (enabled) {
+        text->write(posX, posY, caption, kerning, index);
+    }
+}
+
+// Establece el valor de la variable
+void Writer::setPosX(int value) {
+    posX = value;
+}
+
+// Establece el valor de la variable
+void Writer::setPosY(int value) {
+    posY = value;
+}
+
+// Establece el valor de la variable
+void Writer::setKerning(int value) {
+    kerning = value;
+}
+
+// Establece el valor de la variable
+void Writer::setCaption(std::string text) {
+    caption = text;
+    lenght = text.length();
+}
+
+// Establece el valor de la variable
+void Writer::setSpeed(int value) {
+    speed = value;
+    writingCounter = value;
+}
+
+// Establece el valor de la variable
+void Writer::setEnabled(bool value) {
+    enabled = value;
+}
+
+// Obtiene el valor de la variable
+bool Writer::IsEnabled() {
+    return enabled;
+}
+
+// Establece el valor de la variable
+void Writer::setEnabledCounter(int time) {
+    enabledCounter = time;
+}
+
+// Obtiene el valor de la variable
+int Writer::getEnabledCounter() {
+    return enabledCounter;
+}
+
+// Centra la cadena de texto a un punto X
+void Writer::center(int x) {
+    setPosX(x - (text->lenght(caption, kerning) / 2));
+}
+
+// Obtiene el valor de la variable
+bool Writer::hasFinished() {
+    return finished;
+}

source/core/rendering/writer.h

@@ -0,0 +1,68 @@
+#pragma once
+
+#include <string>  // for string, basic_string
+class Text;
+
+// Clase Writer. Pinta texto en pantalla letra a letra a partir de una cadena y un bitmap
+class Writer {
+   private:
+    // Objetos y punteros
+    Text *text;  // Objeto encargado de escribir el texto
+
+    // Variables
+    int posX;             // Posicion en el eje X donde empezar a escribir el texto
+    int posY;             // Posicion en el eje Y donde empezar a escribir el texto
+    int kerning;          // Kerning del texto, es decir, espaciado entre caracteres
+    std::string caption;  // El texto para escribir
+    int speed;            // Velocidad de escritura
+    int writingCounter;   // Temporizador de escritura para cada caracter
+    int index;            // Posición del texto que se está escribiendo
+    int lenght;           // Longitud de la cadena a escribir
+    bool completed;       // Indica si se ha escrito todo el texto
+    bool enabled;         // Indica si el objeto está habilitado
+    int enabledCounter;   // Temporizador para deshabilitar el objeto
+    bool finished;        // Indica si ya ha terminado
+
+   public:
+    // Constructor
+    Writer(Text *text);
+
+    // Actualiza el objeto
+    void update();
+
+    // Dibuja el objeto en pantalla
+    void render();
+
+    // Establece el valor de la variable
+    void setPosX(int value);
+
+    // Establece el valor de la variable
+    void setPosY(int value);
+
+    // Establece el valor de la variable
+    void setKerning(int value);
+
+    // Establece el valor de la variable
+    void setCaption(std::string text);
+
+    // Establece el valor de la variable
+    void setSpeed(int value);
+
+    // Establece el valor de la variable
+    void setEnabled(bool value);
+
+    // Obtiene el valor de la variable
+    bool IsEnabled();
+
+    // Establece el valor de la variable
+    void setEnabledCounter(int time);
+
+    // Obtiene el valor de la variable
+    int getEnabledCounter();
+
+    // Centra la cadena de texto a un punto X
+    void center(int x);
+
+    // Obtiene el valor de la variable
+    bool hasFinished();
+};