fade: readability-function-cognitive-complexity

source/fade.cpp

@@ -1,6 +1,7 @@
 #include "fade.h"
 
 #include <SDL3/SDL.h>  // Para SDL_SetRenderTarget, SDL_FRect, SDL_GetRenderTarget, SDL_RenderFillRect, SDL_SetRenderDrawBlendMode, SDL_SetRenderDrawColor, Uint8, SDL_GetRenderDrawBlendMode, SDL_BLENDMODE_NONE, SDL_BlendMode, SDL_CreateTexture, SDL_DestroyTexture, SDL_RenderClear, SDL_RenderTexture, SDL_SetTextureAlphaMod, SDL_SetTextureBlendMode, SDL_BLENDMODE_BLEND, SDL_PixelFormat, SDL_TextureAccess
+
 #include <algorithm>  // Para min, max
 #include <cstdlib>    // Para rand, size_t
 
@@ -58,8 +59,22 @@ void Fade::render() {
 
 // Actualiza las variables internas
 void Fade::update() {
-    if (state_ == FadeState::PRE) {
+    switch (state_) {
-        // Actualiza el contador
+        case FadeState::PRE:
+            updatePreState();
+            break;
+        case FadeState::FADING:
+            updateFadingState();
+            break;
+        case FadeState::POST:
+            updatePostState();
+            break;
+        default:
+            break;
+    }
+}
+
+void Fade::updatePreState() {
     if (pre_counter_ == pre_duration_) {
         state_ = FadeState::FADING;
     } else {
@@ -67,27 +82,59 @@ void Fade::update() {
     }
 }
 
-    if (state_ == FadeState::FADING) {
+void Fade::updateFadingState() {
     switch (type_) {
-            case FadeType::FULLSCREEN: {
+        case FadeType::FULLSCREEN:
+            updateFullscreenFade();
+            break;
+        case FadeType::CENTER:
+            updateCenterFade();
+            break;
+        case FadeType::RANDOM_SQUARE:
+            updateRandomSquareFade();
+            break;
+        case FadeType::VENETIAN:
+            updateVenetianFade();
+            break;
+        default:
+            break;
+    }
+    counter_++;
+}
+
+void Fade::updatePostState() {
+    if (post_counter_ == post_duration_) {
+        state_ = FadeState::FINISHED;
+    } else {
+        post_counter_++;
+    }
+    cleanBackbuffer(r_, g_, b_, a_);
+}
+
+void Fade::updateFullscreenFade() {
     // Modifica la transparencia
     a_ = mode_ == FadeMode::OUT ? std::min(counter_ * 4, 255) : 255 - std::min(counter_ * 4, 255);
-
     SDL_SetTextureAlphaMod(backbuffer_, a_);
 
     // Comprueba si ha terminado
     if (counter_ >= 255 / 4) {
         state_ = FadeState::POST;
     }
-
-                break;
 }
 
-            case FadeType::CENTER: {
+void Fade::updateCenterFade() {
-                // Dibuja sobre el backbuffer_
+    drawCenterFadeRectangles();
+
+    // Comprueba si ha terminado
+    if ((counter_ * 4) > param.game.height) {
+        state_ = FadeState::POST;
+        a_ = 255;
+    }
+}
+
+void Fade::drawCenterFadeRectangles() {
     auto *temp = SDL_GetRenderTarget(renderer_);
     SDL_SetRenderTarget(renderer_, backbuffer_);
-
     SDL_SetRenderDrawColor(renderer_, r_, g_, b_, a_);
 
     for (int i = 0; i < counter_; i++) {
@@ -100,76 +147,80 @@ void Fade::update() {
         value_ = calculateValue(0, counter_, i);
     }
 
-                // Deja el renderizador como estaba
     SDL_SetRenderTarget(renderer_, temp);
-
-                // Comprueba si ha terminado
-                if ((counter_ * 4) > param.game.height) {
-                    state_ = FadeState::POST;
-                    a_ = 255;
-                }
-                break;
 }
 
-            case FadeType::RANDOM_SQUARE: {
+void Fade::updateRandomSquareFade() {
     if (counter_ % fade_random_squares_delay_ == 0) {
-                    // Cambia el renderizador al backbuffer_ y modifica sus opciones
+        drawRandomSquares();
-                    auto *temp = SDL_GetRenderTarget(renderer_);
-                    SDL_SetRenderTarget(renderer_, backbuffer_);
-                    SDL_BlendMode blend_mode;
-                    SDL_GetRenderDrawBlendMode(renderer_, &blend_mode);
-                    SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_NONE);
-                    SDL_SetRenderDrawColor(renderer_, r_, g_, b_, a_);
-
-                    // Dibuja el cuadrado correspondiente
-                    const int INDEX = std::min(counter_ / fade_random_squares_delay_, (num_squares_width_ * num_squares_height_) - 1);
-                    for (int i = 0; i < fade_random_squares_mult_; ++i) {
-                        const int INDEX2 = std::min(INDEX * fade_random_squares_mult_ + i, (int)square_.size() - 1);
-                        SDL_RenderFillRect(renderer_, &square_[INDEX2]);
-                    }
-
-                    // Deja el renderizador como estaba
-                    SDL_SetRenderDrawBlendMode(renderer_, blend_mode);
-                    SDL_SetRenderTarget(renderer_, temp);
     }
 
     value_ = calculateValue(0, (num_squares_width_ * num_squares_height_), (counter_ * fade_random_squares_mult_ / fade_random_squares_delay_));
 
     // Comprueba si ha terminado
-                if (counter_ * fade_random_squares_mult_ / fade_random_squares_delay_ >= num_squares_width_ * num_squares_height_) {
+    if (counter_ * fade_random_squares_mult_ / fade_random_squares_delay_ >=
+        num_squares_width_ * num_squares_height_) {
         state_ = FadeState::POST;
     }
-
-                break;
 }
 
-            case FadeType::VENETIAN: {
+void Fade::drawRandomSquares() {
-                // Counter debe ir de 0 a 150 <-- comprobar si esto es aún cierto
-                if (square_.back().h < param.fade.venetian_size) {
-                    // Dibuja sobre el backbuffer_
     auto *temp = SDL_GetRenderTarget(renderer_);
     SDL_SetRenderTarget(renderer_, backbuffer_);
+
     SDL_BlendMode blend_mode;
     SDL_GetRenderDrawBlendMode(renderer_, &blend_mode);
     SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_NONE);
     SDL_SetRenderDrawColor(renderer_, r_, g_, b_, a_);
 
-                    // Dibuja el cuadrado correspondiente
+    const int INDEX = std::min(counter_ / fade_random_squares_delay_,
-                    for (const auto RECT : square_) {
+        (num_squares_width_ * num_squares_height_) - 1);
-                        SDL_RenderFillRect(renderer_, &RECT);
+
+    for (int i = 0; i < fade_random_squares_mult_; ++i) {
+        const int INDEX2 = std::min(INDEX * fade_random_squares_mult_ + i,
+            static_cast<int>(square_.size()) - 1);
+        SDL_RenderFillRect(renderer_, &square_[INDEX2]);
     }
 
-                    // Deja el renderizador como estaba
     SDL_SetRenderDrawBlendMode(renderer_, blend_mode);
     SDL_SetRenderTarget(renderer_, temp);
-
-                    // Modifica el tamaño de los rectangulos
-                    const auto H = counter_ / 2;
-                    for (size_t i = 0; i < square_.size(); ++i) {
-                        // A partir del segundo rectangulo se pinta en función del anterior
-                        square_.at(i).h = i == 0 ? H : std::max(static_cast<int>(square_.at(i - 1).h) - 2, 0);
 }
 
+void Fade::updateVenetianFade() {
+    if (square_.back().h < param.fade.venetian_size) {
+        drawVenetianBlinds();
+        updateVenetianRectangles();
+        calculateVenetianProgress();
+    } else {
+        state_ = FadeState::POST;
+    }
+}
+
+void Fade::drawVenetianBlinds() {
+    auto *temp = SDL_GetRenderTarget(renderer_);
+    SDL_SetRenderTarget(renderer_, backbuffer_);
+
+    SDL_BlendMode blend_mode;
+    SDL_GetRenderDrawBlendMode(renderer_, &blend_mode);
+    SDL_SetRenderDrawBlendMode(renderer_, SDL_BLENDMODE_NONE);
+    SDL_SetRenderDrawColor(renderer_, r_, g_, b_, a_);
+
+    for (const auto &rect : square_) {
+        SDL_RenderFillRect(renderer_, &rect);
+    }
+
+    SDL_SetRenderDrawBlendMode(renderer_, blend_mode);
+    SDL_SetRenderTarget(renderer_, temp);
+}
+
+void Fade::updateVenetianRectangles() {
+    const auto H = counter_ / 2;
+    for (size_t i = 0; i < square_.size(); ++i) {
+        square_.at(i).h = i == 0 ? H : std::max(static_cast<int>(square_.at(i - 1).h) - 2, 0);
+    }
+}
+
+void Fade::calculateVenetianProgress() {
     int completed = 0;
     for (const auto &square : square_) {
         if (square.h >= param.fade.venetian_size) {
@@ -177,29 +228,6 @@ void Fade::update() {
         }
     }
     value_ = calculateValue(0, square_.size() - 1, completed);
-                } else {
-                    state_ = FadeState::POST;
-                }
-
-                break;
-            }
-            default:
-                break;
-        }
-        counter_++;
-    }
-
-    if (state_ == FadeState::POST) {
-        // Actualiza el contador
-        if (post_counter_ == post_duration_) {
-            state_ = FadeState::FINISHED;
-        } else {
-            post_counter_++;
-        }
-
-        // Deja el backbuffer_ todo del mismo color
-        cleanBackbuffer(r_, g_, b_, a_);
-    }
 }
 
 // Activa el fade

source/fade.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <SDL3/SDL.h>  // Para Uint8, SDL_FRect, SDL_Renderer, SDL_Texture, Uint16
+
 #include <vector>  // Para vector
 
 struct Color;
@@ -82,8 +83,28 @@ class Fade {
         // --- Valor de progreso ---
         int value_ = 0;  // Estado del fade (0-100)
 
-        // --- Métodos internos ---
+        // --- Inicialización y limpieza ---
         void init();                                               // Inicializa variables
-        void cleanBackbuffer(Uint8 r, Uint8 g, Uint8 b, Uint8 a);          // Limpia el backbuffer
+        void cleanBackbuffer(Uint8 r, Uint8 g, Uint8 b, Uint8 a);  // Limpia el backbuffer con un color RGBA
-        static auto calculateValue(int min, int max, int current) -> int;  // Calcula el valor del fade
+
+        // --- Utilidades generales ---
+        static auto calculateValue(int min, int max, int current) -> int;  // Calcula el valor del fade entre dos límites
+
+        // --- Lógica de estado ---
+        void updatePreState();     // Actualiza el estado previo al fade
+        void updateFadingState();  // Actualiza el estado durante el fade
+        void updatePostState();    // Actualiza el estado posterior al fade
+
+        // --- Efectos de fundido (fade) ---
+        void updateFullscreenFade();       // Actualiza el fundido de pantalla completa
+        void updateCenterFade();           // Actualiza el fundido desde el centro
+        void updateRandomSquareFade();     // Actualiza el fundido con cuadrados aleatorios
+        void updateVenetianFade();         // Actualiza el fundido tipo persiana veneciana
+        void updateVenetianRectangles();   // Actualiza los rectángulos del efecto veneciano
+        void calculateVenetianProgress();  // Calcula el progreso del efecto veneciano
+
+        // --- Dibujo de efectos visuales ---
+        void drawCenterFadeRectangles();  // Dibuja los rectángulos del fundido central
+        void drawRandomSquares();         // Dibuja los cuadrados aleatorios del fundido
+        void drawVenetianBlinds();        // Dibuja las persianas venecianas del fundido
 };