precarrega les textures del jugador amb variants de paleta

source/animated_sprite.cpp

@@ -197,9 +197,9 @@ void AnimatedSprite::processConfigLine(const std::string& line, AnimationConfig&
 
 // Actualiza los cálculos basados en las dimensiones del frame
 void AnimatedSprite::updateFrameCalculations(AnimationConfig& config) {
-    config.frames_per_row = texture_->getWidth() / config.frame_width;
+    config.frames_per_row = getTexture()->getWidth() / config.frame_width;
-    const int WIDTH = texture_->getWidth() / config.frame_width;
+    const int WIDTH = getTexture()->getWidth() / config.frame_width;
-    const int HEIGHT = texture_->getHeight() / config.frame_height;
+    const int HEIGHT = getTexture()->getHeight() / config.frame_height;
     config.max_tiles = WIDTH * HEIGHT;
 }
 

source/director.cpp

@@ -46,7 +46,7 @@ Director::Director(int argc, std::span<char *> argv) {
     Section::name = Section::Name::GAME;
     Section::options = Section::Options::GAME_PLAY_1P;
 #elif _DEBUG
-    Section::name = Section::Name::TITLE;
+    Section::name = Section::Name::GAME;
     Section::options = Section::Options::GAME_PLAY_1P;
 #else  // NORMAL GAME
     Section::name = Section::Name::LOGO;
@@ -99,7 +99,7 @@ void Director::init() {
     Screen::init();                                 // Inicializa la pantalla y el sistema de renderizado
     Audio::init();                                  // Activa el sistema de audio
 #ifdef _DEBUG
-    Resource::init(Resource::LoadingMode::LAZY_LOAD);  // Inicializa el sistema de gestión de recursos
+    Resource::init(Resource::LoadingMode::PRELOAD);  // Inicializa el sistema de gestión de recursos
 #else
     Resource::init(Resource::LoadingMode::PRELOAD);  // Inicializa el sistema de gestión de recursos
 #endif

source/moving_sprite.cpp

@@ -72,7 +72,7 @@ void MovingSprite::update() {
 }
 
 // Muestra el sprite por pantalla
-void MovingSprite::render() { texture_->render(pos_.x, pos_.y, &sprite_clip_, horizontal_zoom_, vertical_zoom_, rotate_.angle, &rotate_.center, flip_); }
+void MovingSprite::render() { getTexture()->render(pos_.x, pos_.y, &sprite_clip_, horizontal_zoom_, vertical_zoom_, rotate_.angle, &rotate_.center, flip_); }
 
 // Establece la rotacion
 void MovingSprite::rotate() {

source/player.cpp

@@ -22,7 +22,7 @@
 // Constructor
 Player::Player(const Config &config)
     : player_sprite_(std::make_unique<AnimatedSprite>(config.texture.at(0), config.animations.at(0))),
-      power_sprite_(std::make_unique<AnimatedSprite>(config.texture.at(1), config.animations.at(1))),
+      power_sprite_(std::make_unique<AnimatedSprite>(config.texture.at(4), config.animations.at(1))),
       enter_name_(std::make_unique<EnterName>()),
       hi_score_table_(*config.hi_score_table),
       glowing_entry_(*config.glowing_entry),
@@ -32,7 +32,10 @@ Player::Player(const Config &config)
       default_pos_y_(config.y),
       demo_(config.demo) {
     // Configura objetos
-    player_sprite_->getTexture()->setPalette(coffees_);
+    player_sprite_->addTexture(config.texture.at(1));
+    player_sprite_->addTexture(config.texture.at(2));
+    player_sprite_->addTexture(config.texture.at(3));
+    player_sprite_->setActiveTexture(coffees_);
     power_sprite_->getTexture()->setAlpha(224);
     power_up_x_offset_ = (power_sprite_->getWidth() - player_sprite_->getWidth()) / 2;
     power_sprite_->setPosY(default_pos_y_ - (power_sprite_->getHeight() - player_sprite_->getHeight()));
@@ -777,10 +780,10 @@ void Player::updateInvulnerable() {
         if (invulnerable_) {
             if (invulnerable_counter_ > 0) {
                 --invulnerable_counter_;
-                invulnerable_counter_ % 8 > 3 ? player_sprite_->getTexture()->setPalette(coffees_) : player_sprite_->getTexture()->setPalette(3);
+                invulnerable_counter_ % 8 > 3 ? player_sprite_->setActiveTexture(coffees_) : player_sprite_->setActiveTexture(3);
             } else {
                 setInvulnerable(false);
-                player_sprite_->getTexture()->setPalette(coffees_);
+                player_sprite_->setActiveTexture(coffees_);
             }
         }
     }
@@ -807,7 +810,7 @@ void Player::giveExtraHit() {
     extra_hit_ = true;
     if (coffees_ < 2) {
         coffees_++;
-        player_sprite_->getTexture()->setPalette(coffees_);
+        player_sprite_->setActiveTexture(coffees_);
     }
 }
 
@@ -816,7 +819,7 @@ void Player::removeExtraHit() {
     if (coffees_ > 0) {
         coffees_--;
         setInvulnerable(true);
-        player_sprite_->getTexture()->setPalette(coffees_);
+        player_sprite_->setActiveTexture(coffees_);
     }
 
     extra_hit_ = coffees_ != 0;

source/resource.cpp

@@ -69,7 +69,8 @@ void Resource::loadEssentialResources() {
     loadTextFilesQuiet();     // <- VERSIÓN SILENCIOSA
     loadEssentialTextures();  // Ya es silenciosa
     createText();             // Crear objetos de texto
-    createTextures();         // Crear texturas generadas (game_text_xxx)
+    createTextTextures();     // Crear texturas generadas (game_text_xxx)
+    createPlayerTextures();   // Crea las texturas de jugadores con todas sus variantes de paleta
 
     SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "Essential resources loaded");
 }
@@ -421,9 +422,9 @@ void Resource::load() {
     loadTextFiles();         // Carga ficheros de texto
     loadAnimations();        // Carga animaciones
     loadDemoData();          // Carga datos de demo
-    addPalettes();     // Añade paletas a las texturas
     createText();            // Crea objetos de texto
-    createTextures();  // Crea texturas a partir de texto
+    createTextTextures();    // Crea texturas a partir de texto
+    createPlayerTextures();  // Crea las texturas de jugadores con todas sus variantes de paleta
     SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "\n** RESOURCES LOADED");
 
     // Restablece el sincronismo vertical a su valor original
@@ -440,20 +441,6 @@ void Resource::reload() {
     }
 }
 
-// Recarga solo las texturas y paletas
-void Resource::reloadTextures() {
-    if (loading_mode_ == LoadingMode::PRELOAD) {
-        loadTextures();
-        addPalettes();
-        createTextures();
-    } else {
-        // En modo lazy, limpiamos las texturas cargadas para forzar recarga
-        for (auto &texture : textures_) {
-            texture.texture = nullptr;
-        }
-    }
-}
-
 // Carga los sonidos del juego
 void Resource::loadSounds() {
     SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "\n>> SOUND FILES");
@@ -541,23 +528,61 @@ void Resource::loadDemoData() {
     }
 }
 
-// Añade paletas de colores a las texturas principales
+// Crea las texturas de jugadores con todas sus variantes de paleta
-void Resource::addPalettes() {
+void Resource::createPlayerTextures() {
-    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "\n>> PALETTES");
+    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "\n>> CREATING PLAYER TEXTURES");
 
-    // Paletas para el jugador 1
+    // Configuración de jugadores y sus paletas
-    getTexture("player1.gif")->addPaletteFromPalFile(Asset::get()->get("player1_coffee1.pal"));
+    struct PlayerConfig {
-    getTexture("player1.gif")->addPaletteFromPalFile(Asset::get()->get("player1_coffee2.pal"));
+            std::string base_texture;
-    getTexture("player1.gif")->addPaletteFromPalFile(Asset::get()->get("player1_invencible.pal"));
+            std::vector<std::string> palette_files;
+            std::string name_prefix;
+    };
 
-    // Paletas para el jugador 2
+    std::vector<PlayerConfig> players = {
-    getTexture("player2.gif")->addPaletteFromPalFile(Asset::get()->get("player2_coffee1.pal"));
+        {"player1.gif", {"player1_coffee1.pal", "player1_coffee2.pal", "player1_invencible.pal"}, "player1"},
-    getTexture("player2.gif")->addPaletteFromPalFile(Asset::get()->get("player2_coffee2.pal"));
+        {"player2.gif", {"player2_coffee1.pal", "player2_coffee2.pal", "player2_invencible.pal"}, "player2"}};
-    getTexture("player2.gif")->addPaletteFromPalFile(Asset::get()->get("player2_invencible.pal"));
+
+    for (const auto &player : players) {
+        // Encontrar el archivo original de la textura
+        std::string texture_file_path;
+        auto texture_list = Asset::get()->getListByType(Asset::Type::BITMAP);
+        for (const auto &file : texture_list) {
+            if (getFileName(file) == player.base_texture) {
+                texture_file_path = file;
+                break;
+            }
+        }
+
+        // Crear variante con paleta original (pal0) - usar la textura ya cargada
+        auto base_texture = getTexture(player.base_texture);
+        std::string pal0_name = player.name_prefix + "_pal0";
+        textures_.emplace_back(pal0_name, base_texture);
+        printWithDots("Player Texture : ", pal0_name, "[  DONE  ]");
+
+        // Crear variantes con paletas adicionales - CADA UNA DESDE EL ARCHIVO
+        for (size_t i = 0; i < player.palette_files.size(); ++i) {
+            // Crear textura completamente nueva desde el archivo
+            auto texture_copy = std::make_shared<Texture>(Screen::get()->getRenderer(), texture_file_path);
+
+            // Añadir todas las paletas
+            texture_copy->addPaletteFromPalFile(Asset::get()->get(player.palette_files[0]));
+            texture_copy->addPaletteFromPalFile(Asset::get()->get(player.palette_files[1]));
+            texture_copy->addPaletteFromPalFile(Asset::get()->get(player.palette_files[2]));
+
+            // Cambiar a la paleta específica (índice i+1 porque 0 es la original)
+            texture_copy->setPalette(i + 1);
+
+            // Guardar con nombre específico
+            std::string variant_name = player.name_prefix + "_pal" + std::to_string(i + 1);
+            textures_.emplace_back(variant_name, texture_copy);
+            printWithDots("Player Texture : ", variant_name, "[  DONE  ]");
+        }
+    }
 }
 
 // Crea texturas a partir de textos para mostrar puntuaciones y mensajes
-void Resource::createTextures() {
+void Resource::createTextTextures() {
     struct NameAndText {
             std::string name;
             std::string text;

source/resource.h

@@ -41,7 +41,6 @@ class Resource {
 
         // --- Métodos de recarga de recursos ---
         void reload();          // Recarga todos los recursos
-        void reloadTextures();  // Recarga solo las texturas
 
         // --- Método para obtener el modo de carga actual ---
         auto getLoadingMode() const -> LoadingMode { return loading_mode_; }
@@ -141,8 +140,9 @@ class Resource {
         void loadEssentialResources();  // Carga recursos esenciales en modo lazy
         void loadEssentialTextures();   // Carga solo las texturas esenciales (fuentes)
         void loadTextFilesQuiet();      // Carga ficheros de texto sin mostrar progreso (para modo lazy)
-        void addPalettes();             // Añade paletas a las texturas
+        // void addPalettes();             // Añade paletas a las texturas
-        void createTextures();          // Crea las texturas a partir de los datos cargados
+        void createPlayerTextures();    // Crea las texturas de jugadores con todas sus variantes de paleta
+        void createTextTextures();      // Crea las texturas a partir de los datos cargados
         void createText();              // Crea los objetos de texto
         void clear();                   // Vacía todos los vectores de recursos
         void load();                    // Carga todos los recursos

source/sections/credits.cpp

@@ -331,13 +331,19 @@ void Credits::initPlayers() {
 
     // Texturas - Player1
     std::vector<std::shared_ptr<Texture>> player1_textures;
-    player1_textures.emplace_back(Resource::get()->getTexture("player1.gif"));
+    player1_textures.emplace_back(Resource::get()->getTexture("player1_pal0"));
+    player1_textures.emplace_back(Resource::get()->getTexture("player1_pal1"));
+    player1_textures.emplace_back(Resource::get()->getTexture("player1_pal2"));
+    player1_textures.emplace_back(Resource::get()->getTexture("player1_pal3"));
     player1_textures.emplace_back(Resource::get()->getTexture("player1_power.png"));
     player_textures.push_back(player1_textures);
 
     // Texturas - Player2
     std::vector<std::shared_ptr<Texture>> player2_textures;
-    player2_textures.emplace_back(Resource::get()->getTexture("player2.gif"));
+    player2_textures.emplace_back(Resource::get()->getTexture("player2_pal0"));
+    player2_textures.emplace_back(Resource::get()->getTexture("player2_pal1"));
+    player2_textures.emplace_back(Resource::get()->getTexture("player2_pal2"));
+    player2_textures.emplace_back(Resource::get()->getTexture("player2_pal3"));
     player2_textures.emplace_back(Resource::get()->getTexture("player2_power.png"));
     player_textures.push_back(player2_textures);
 

source/sections/game.cpp

@@ -163,13 +163,19 @@ void Game::setResources() {
     player_textures_.clear();
     // Texturas - Player1
     std::vector<std::shared_ptr<Texture>> player1_textures;
-    player1_textures.emplace_back(Resource::get()->getTexture("player1.gif"));
+    player1_textures.emplace_back(Resource::get()->getTexture("player1_pal0"));
+    player1_textures.emplace_back(Resource::get()->getTexture("player1_pal1"));
+    player1_textures.emplace_back(Resource::get()->getTexture("player1_pal2"));
+    player1_textures.emplace_back(Resource::get()->getTexture("player1_pal3"));
     player1_textures.emplace_back(Resource::get()->getTexture("player1_power.png"));
     player_textures_.push_back(player1_textures);
 
     // Texturas - Player2
     std::vector<std::shared_ptr<Texture>> player2_textures;
-    player2_textures.emplace_back(Resource::get()->getTexture("player2.gif"));
+    player2_textures.emplace_back(Resource::get()->getTexture("player2_pal0"));
+    player2_textures.emplace_back(Resource::get()->getTexture("player2_pal1"));
+    player2_textures.emplace_back(Resource::get()->getTexture("player2_pal2"));
+    player2_textures.emplace_back(Resource::get()->getTexture("player2_pal3"));
     player2_textures.emplace_back(Resource::get()->getTexture("player2_power.png"));
     player_textures_.push_back(player2_textures);
 

source/sections/title.cpp

@@ -488,13 +488,19 @@ void Title::initPlayers() {
 
     // Texturas - Player1
     std::vector<std::shared_ptr<Texture>> player1_textures;
-    player1_textures.emplace_back(Resource::get()->getTexture("player1.gif"));
+    player1_textures.emplace_back(Resource::get()->getTexture("player1_pal0"));
+    player1_textures.emplace_back(Resource::get()->getTexture("player1_pal1"));
+    player1_textures.emplace_back(Resource::get()->getTexture("player1_pal2"));
+    player1_textures.emplace_back(Resource::get()->getTexture("player1_pal3"));
     player1_textures.emplace_back(Resource::get()->getTexture("player1_power.png"));
     player_textures.push_back(player1_textures);
 
     // Texturas - Player2
     std::vector<std::shared_ptr<Texture>> player2_textures;
-    player2_textures.emplace_back(Resource::get()->getTexture("player2.gif"));
+    player2_textures.emplace_back(Resource::get()->getTexture("player2_pal0"));
+    player2_textures.emplace_back(Resource::get()->getTexture("player2_pal1"));
+    player2_textures.emplace_back(Resource::get()->getTexture("player2_pal2"));
+    player2_textures.emplace_back(Resource::get()->getTexture("player2_pal3"));
     player2_textures.emplace_back(Resource::get()->getTexture("player2_power.png"));
     player_textures.push_back(player2_textures);
 

source/sprite.cpp

@@ -1,28 +1,29 @@
 #include "sprite.h"
 
 #include <utility>  // Para move
+#include <vector>   // Para vector
 
 #include "texture.h"  // Para Texture
 
 // Constructor
 Sprite::Sprite(std::shared_ptr<Texture> texture, float pos_x, float pos_y, float width, float height)
-    : texture_(std::move(texture)),
+    : textures_{texture},
       pos_((SDL_FRect){pos_x, pos_y, width, height}),
       sprite_clip_((SDL_FRect){0, 0, pos_.w, pos_.h}) {}
 
 Sprite::Sprite(std::shared_ptr<Texture> texture, SDL_FRect rect)
-    : texture_(std::move(texture)),
+    : textures_{texture},
       pos_(rect),
       sprite_clip_((SDL_FRect){0, 0, pos_.w, pos_.h}) {}
 
 Sprite::Sprite(std::shared_ptr<Texture> texture)
-    : texture_(std::move(texture)),
+    : textures_{texture},
-      pos_(SDL_FRect{0, 0, static_cast<float>(texture_->getWidth()), static_cast<float>(texture_->getHeight())}),
+      pos_(SDL_FRect{0, 0, static_cast<float>(textures_.at(texture_index_)->getWidth()), static_cast<float>(textures_.at(texture_index_)->getHeight())}),
       sprite_clip_(pos_) {}
 
 // Muestra el sprite por pantalla
 void Sprite::render() {
-    texture_->render(pos_.x, pos_.y, &sprite_clip_, zoom_, zoom_);
+    textures_.at(texture_index_)->render(pos_.x, pos_.y, &sprite_clip_, zoom_, zoom_);
 }
 
 // Establece la posición del objeto
@@ -42,3 +43,12 @@ void Sprite::clear() {
     pos_ = {0, 0, 0, 0};
     sprite_clip_ = {0, 0, 0, 0};
 }
+
+// Cambia la textura activa por índice
+bool Sprite::setActiveTexture(size_t index) {
+    if (index < textures_.size()) {
+        texture_index_ = index;
+        return true;
+    }
+    return false;  // Índice fuera de rango
+}

source/sprite.h

@@ -3,6 +3,7 @@
 #include <SDL3/SDL.h>  // Para SDL_FRect, SDL_FPoint
 
 #include <memory>  // Para shared_ptr
+#include <vector>  // Para vector
 
 class Texture;
 
@@ -49,12 +50,21 @@ class Sprite {
         void setSpriteClip(float pos_x, float pos_y, float width, float height) { sprite_clip_ = SDL_FRect{pos_x, pos_y, width, height}; }
 
         // --- Textura ---
-        [[nodiscard]] auto getTexture() const -> std::shared_ptr<Texture> { return texture_; }
+        [[nodiscard]] auto getTexture() const -> std::shared_ptr<Texture> { return textures_.at(texture_index_); }
-        void setTexture(std::shared_ptr<Texture> texture) { texture_ = texture; }
+        void setTexture(std::shared_ptr<Texture> texture) { textures_.at(texture_index_) = texture; }
+        void addTexture(std::shared_ptr<Texture> texture) { textures_.push_back(texture); }
+        bool setActiveTexture(size_t index);                             // Cambia la textura activa por índice
+        size_t getActiveTextureIndex() const { return texture_index_; }  // Obtiene el índice de la textura activa
+        size_t getTextureCount() const { return textures_.size(); }      // Obtiene el número total de texturas
 
     protected:
+        std::shared_ptr<Texture>& getTextureRef() {
+            return textures_.at(texture_index_);
+        }
+
         // --- Variables internas ---
-        std::shared_ptr<Texture> texture_;  // Textura donde están todos los dibujos del sprite
+        size_t texture_index_ = 0;
+        std::vector<std::shared_ptr<Texture>> textures_;  // Lista de texturas
         SDL_FRect pos_;                                   // Posición y tamaño donde dibujar el sprite
         SDL_FRect sprite_clip_;                           // Rectángulo de origen de la textura que se dibujará en pantalla
         double zoom_ = 1.0F;                              // Zoom aplicado a la textura