afegit surface_dissolve_sprite

ending2 amb els fades correctes

source/core/rendering/surface_animated_sprite.cpp

@@ -214,6 +214,15 @@ SurfaceAnimatedSprite::SurfaceAnimatedSprite(const AnimationResource& cached_dat
     }
 }
 
+// Constructor per a subclasses amb surface directa (sense YAML)
+SurfaceAnimatedSprite::SurfaceAnimatedSprite(std::shared_ptr<Surface> surface, SDL_FRect pos)
+    : SurfaceMovingSprite(std::move(surface), pos) {
+    // animations_ queda buit (protegit per el guard de animate())
+    if (surface_) {
+        clip_ = {0, 0, static_cast<float>(surface_->getWidth()), static_cast<float>(surface_->getHeight())};
+    }
+}
+
 // Obtiene el indice de la animación a partir del nombre
 auto SurfaceAnimatedSprite::getIndex(const std::string& name) -> int {
     auto index = -1;
@@ -230,6 +239,7 @@ auto SurfaceAnimatedSprite::getIndex(const std::string& name) -> int {
 
 // Calcula el frame correspondiente a la animación (time-based)
 void SurfaceAnimatedSprite::animate(float delta_time) {
+    if (animations_.empty()) return;
     if (animations_[current_animation_].speed <= 0.0F) {
         return;
     }

source/core/rendering/surface_animated_sprite.hpp

@@ -49,6 +49,9 @@ class SurfaceAnimatedSprite : public SurfaceMovingSprite {
         void setCurrentAnimationFrame(int num);                         // Establece el frame actual de la animación
 
     protected:
+        // Constructor per a ús de subclasses que gestionen la surface directament (sense YAML)
+        SurfaceAnimatedSprite(std::shared_ptr<Surface> surface, SDL_FRect pos);
+
         // Métodos protegidos
         void animate(float delta_time);  // Calcula el frame correspondiente a la animación actual (time-based)
 

source/core/rendering/surface_dissolve_sprite.cpp

@@ -32,6 +32,18 @@ auto SurfaceDissolveSprite::computePixelRank(int col, int row, int frame_h,
     return y_factor * 0.7F + RANDOM * 0.3F;
 }
 
+// Constructor per a surface directa (sense AnimationResource)
+SurfaceDissolveSprite::SurfaceDissolveSprite(std::shared_ptr<Surface> surface, SDL_FRect pos)
+    : SurfaceAnimatedSprite(std::move(surface), pos) {
+    if (surface_) {
+        const int W = static_cast<int>(surface_->getWidth());
+        const int H = static_cast<int>(surface_->getHeight());
+        surface_display_ = std::make_shared<Surface>(W, H);
+        surface_display_->setTransparentColor(surface_->getTransparentColor());
+        surface_display_->clear(surface_->getTransparentColor());
+    }
+}
+
 // Constructor
 SurfaceDissolveSprite::SurfaceDissolveSprite(const AnimationResource& data)
     : SurfaceAnimatedSprite(data) {
@@ -87,7 +99,8 @@ void SurfaceDissolveSprite::rebuildDisplaySurface() {
             }
             const float RANK = computePixelRank(col, row, SH, direction_);
             if (RANK >= progress_) {
-                dst_data->data[(SY + row) * DST_W + (SX + col)] = COLOR;
+                const Uint8 OUT = (COLOR == source_color_) ? target_color_ : COLOR;
+                dst_data->data[(SY + row) * DST_W + (SX + col)] = OUT;
             }
         }
     }
@@ -123,9 +136,9 @@ void SurfaceDissolveSprite::update(float delta_time) {
     }
 }
 
-// Renderitza: usa surface_display_ si hi ha dissolució activa
+// Renderitza: usa surface_display_ (amb color replace) si disponible
 void SurfaceDissolveSprite::render() {
-    if (progress_ <= 0.0F || !surface_display_) {
+    if (!surface_display_) {
         SurfaceAnimatedSprite::render();
         return;
     }
@@ -167,3 +180,10 @@ void SurfaceDissolveSprite::stopTransition() {
 auto SurfaceDissolveSprite::isTransitionDone() const -> bool {
     return transition_mode_ == TransitionMode::NONE;
 }
+
+// Configura substitució de color per a la reconstrucció
+void SurfaceDissolveSprite::setColorReplace(Uint8 source, Uint8 target) {
+    source_color_ = source;
+    target_color_ = target;
+    needs_rebuild_ = true;
+}

source/core/rendering/surface_dissolve_sprite.hpp

@@ -16,6 +16,7 @@ enum class DissolveDirection { NONE, DOWN, UP };
 class SurfaceDissolveSprite : public SurfaceAnimatedSprite {
     public:
         explicit SurfaceDissolveSprite(const AnimationResource& data);
+        SurfaceDissolveSprite(std::shared_ptr<Surface> surface, SDL_FRect pos);
         ~SurfaceDissolveSprite() override = default;
 
         void update(float delta_time) override;
@@ -34,6 +35,9 @@ class SurfaceDissolveSprite : public SurfaceAnimatedSprite {
         void stopTransition();
         [[nodiscard]] auto isTransitionDone() const -> bool;
 
+        // Substitució de color: en reconstruir, substitueix source per target
+        void setColorReplace(Uint8 source, Uint8 target);
+
     private:
         enum class TransitionMode { NONE, DISSOLVING, GENERATING };
 
@@ -46,6 +50,8 @@ class SurfaceDissolveSprite : public SurfaceAnimatedSprite {
         float transition_elapsed_{0.0F};
         SDL_FRect prev_clip_{0, 0, 0, 0};
         bool needs_rebuild_{false};
+        Uint8 source_color_{255};  // 255 = transparent = sense replace per defecte
+        Uint8 target_color_{0};
 
         void rebuildDisplaySurface();
         [[nodiscard]] static auto computePixelRank(int col, int row, int frame_h,