jaildesigner-jailgames/coffee_crisis_arcade_edition
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 13 Wiki Activity

fade: readability-function-cognitive-complexity

Browse Source
This commit is contained in:
Sergio
2025-07-23 17:39:30 +02:00
parent ca328f5011
commit b0564ceccf
2 changed files with 193 additions and 144 deletions
Download Patch File Download Diff File Expand all files Collapse all files

308
source/fade.cpp
View File

@@ -1,12 +1,13 @@
#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
#include "color.h" // Para Color
#include "param.h" // Para Param, param, ParamGame, ParamFade
#include "screen.h" // Para Screen
#include <algorithm> // Para min, max
#include <cstdlib> // Para rand, size_t
#include "color.h" // Para Color
#include "param.h" // Para Param, param, ParamGame, ParamFade
#include "screen.h" // Para Screen
// Constructor
Fade::Fade()
@@ -58,150 +59,177 @@ void Fade::render() {
// Actualiza las variables internas
void Fade::update() {
if (state_ == FadeState::PRE) {
// Actualiza el contador
if (pre_counter_ == pre_duration_) {
state_ = FadeState::FADING;
} else {
pre_counter_++;
}
switch (state_) {
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 {
pre_counter_++;
}
}
void Fade::updateFadingState() {
switch (type_) {
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;
}
}
void Fade::updateCenterFade() {
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++) {
rect1_.h = rect2_.h = i * 4;
rect2_.y = param.game.height - (i * 4);
SDL_RenderFillRect(renderer_, &rect1_);
SDL_RenderFillRect(renderer_, &rect2_);
value_ = calculateValue(0, counter_, i);
}
if (state_ == FadeState::FADING) {
switch (type_) {
case FadeType::FULLSCREEN: {
// Modifica la transparencia
a_ = mode_ == FadeMode::OUT ? std::min(counter_ * 4, 255) : 255 - std::min(counter_ * 4, 255);
SDL_SetRenderTarget(renderer_, temp);
}
SDL_SetTextureAlphaMod(backbuffer_, a_);
// Comprueba si ha terminado
if (counter_ >= 255 / 4) {
state_ = FadeState::POST;
}
break;
}
case FadeType::CENTER: {
// Dibuja sobre el backbuffer_
auto *temp = SDL_GetRenderTarget(renderer_);
SDL_SetRenderTarget(renderer_, backbuffer_);
SDL_SetRenderDrawColor(renderer_, r_, g_, b_, a_);
for (int i = 0; i < counter_; i++) {
rect1_.h = rect2_.h = i * 4;
rect2_.y = param.game.height - (i * 4);
SDL_RenderFillRect(renderer_, &rect1_);
SDL_RenderFillRect(renderer_, &rect2_);
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: {
if (counter_ % fade_random_squares_delay_ == 0) {
// Cambia el renderizador al backbuffer_ y modifica sus opciones
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_) {
state_ = FadeState::POST;
}
break;
}
case FadeType::VENETIAN: {
// 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
for (const auto RECT : square_) {
SDL_RenderFillRect(renderer_, &RECT);
}
// 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);
}
int completed = 0;
for (const auto &square : square_) {
if (square.h >= param.fade.venetian_size) {
++completed;
}
}
value_ = calculateValue(0, square_.size() - 1, completed);
} else {
state_ = FadeState::POST;
}
break;
}
default:
break;
}
counter_++;
void Fade::updateRandomSquareFade() {
if (counter_ % fade_random_squares_delay_ == 0) {
drawRandomSquares();
}
if (state_ == FadeState::POST) {
// Actualiza el contador
if (post_counter_ == post_duration_) {
state_ = FadeState::FINISHED;
} else {
post_counter_++;
}
value_ = calculateValue(0, (num_squares_width_ * num_squares_height_), (counter_ * fade_random_squares_mult_ / fade_random_squares_delay_));
// Deja el backbuffer_ todo del mismo color
cleanBackbuffer(r_, g_, b_, a_);
// Comprueba si ha terminado
if (counter_ * fade_random_squares_mult_ / fade_random_squares_delay_ >=
num_squares_width_ * num_squares_height_) {
state_ = FadeState::POST;
}
}
void Fade::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_);
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,
static_cast<int>(square_.size()) - 1);
SDL_RenderFillRect(renderer_, &square_[INDEX2]);
}
SDL_SetRenderDrawBlendMode(renderer_, blend_mode);
SDL_SetRenderTarget(renderer_, temp);
}
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) {
++completed;
}
}
value_ = calculateValue(0, square_.size() - 1, completed);
}
// Activa el fade
void Fade::activate() {
// Si ya está habilitado, no hay que volverlo a activar