From 7305d2f5dcfb8977b256f9c6d5472a24dd157d86 Mon Sep 17 00:00:00 2001 From: Sergio Valor Date: Sun, 24 May 2026 08:00:40 +0200 Subject: [PATCH] =?UTF-8?q?refactor(scenes):=20renombra=20identificadors?= =?UTF-8?q?=20valencians=20de=20logo/title=20a=20angl=C3=A8s?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- source/core/defaults/enemies.hpp | 8 +- source/game/entities/enemy.cpp | 12 +- source/game/scenes/logo_scene.cpp | 114 ++++++++--------- source/game/scenes/logo_scene.hpp | 38 +++--- source/game/scenes/title_scene.cpp | 188 ++++++++++++++--------------- source/game/scenes/title_scene.hpp | 38 +++--- 6 files changed, 199 insertions(+), 199 deletions(-) diff --git a/source/core/defaults/enemies.hpp b/source/core/defaults/enemies.hpp index f6f4d47..0834164 100644 --- a/source/core/defaults/enemies.hpp +++ b/source/core/defaults/enemies.hpp @@ -55,8 +55,8 @@ namespace Defaults::Enemies { namespace Animation { // Palpitation constexpr float PULSE_TRIGGER_PROB = 0.01F; // 1% chance per second - constexpr float PULSE_DURACIO_MIN = 1.0F; // Min duration (seconds) - constexpr float PULSE_DURACIO_MAX = 3.0F; // Max duration (seconds) + constexpr float PULSE_DURATION_MIN = 1.0F; // Min duration (seconds) + constexpr float PULSE_DURATION_MAX = 3.0F; // Max duration (seconds) constexpr float PULSE_AMPLITUD_MIN = 0.08F; // Min scale variation constexpr float PULSE_AMPLITUD_MAX = 0.20F; // Max scale variation constexpr float PULSE_FREQ_MIN = 1.5F; // Min frequency (Hz) @@ -64,8 +64,8 @@ namespace Defaults::Enemies { // Rotation acceleration constexpr float ROTATION_ACCEL_TRIGGER_PROB = 0.02F; // 2% chance per second [4x more frequent] - constexpr float ROTATION_ACCEL_DURACIO_MIN = 3.0F; // Min transition time - constexpr float ROTATION_ACCEL_DURACIO_MAX = 8.0F; // Max transition time + constexpr float ROTATION_ACCEL_DURATION_MIN = 3.0F; // Min transition time + constexpr float ROTATION_ACCEL_DURATION_MAX = 8.0F; // Max transition time constexpr float ROTATION_ACCEL_MULTIPLIER_MIN = 0.3F; // Min speed multiplier [more dramatic] constexpr float ROTATION_ACCEL_MULTIPLIER_MAX = 4.0F; // Max speed multiplier [more dramatic] } // namespace Animation diff --git a/source/game/entities/enemy.cpp b/source/game/entities/enemy.cpp index 74020fe..18917a7 100644 --- a/source/game/entities/enemy.cpp +++ b/source/game/entities/enemy.cpp @@ -394,9 +394,9 @@ void Enemy::updatePulse(float delta_time) { animation_.pulse_amplitude = Defaults::Enemies::Animation::PULSE_AMPLITUD_MIN + ((static_cast(std::rand()) / static_cast(RAND_MAX)) * AMP_RANGE); - const float DUR_RANGE = Defaults::Enemies::Animation::PULSE_DURACIO_MAX - - Defaults::Enemies::Animation::PULSE_DURACIO_MIN; - animation_.pulse_time_remaining = Defaults::Enemies::Animation::PULSE_DURACIO_MIN + + const float DUR_RANGE = Defaults::Enemies::Animation::PULSE_DURATION_MAX - + Defaults::Enemies::Animation::PULSE_DURATION_MIN; + animation_.pulse_time_remaining = Defaults::Enemies::Animation::PULSE_DURATION_MIN + ((static_cast(std::rand()) / static_cast(RAND_MAX)) * DUR_RANGE); } } @@ -428,9 +428,9 @@ void Enemy::updateRotationAcceleration(float delta_time) { ((static_cast(std::rand()) / static_cast(RAND_MAX)) * MULT_RANGE); animation_.rotation_delta_target = animation_.rotation_delta_base * MULTIPLIER; - const float DUR_RANGE = Defaults::Enemies::Animation::ROTATION_ACCEL_DURACIO_MAX - - Defaults::Enemies::Animation::ROTATION_ACCEL_DURACIO_MIN; - animation_.rotation_delta_duration = Defaults::Enemies::Animation::ROTATION_ACCEL_DURACIO_MIN + + const float DUR_RANGE = Defaults::Enemies::Animation::ROTATION_ACCEL_DURATION_MAX - + Defaults::Enemies::Animation::ROTATION_ACCEL_DURATION_MIN; + animation_.rotation_delta_duration = Defaults::Enemies::Animation::ROTATION_ACCEL_DURATION_MIN + ((static_cast(std::rand()) / static_cast(RAND_MAX)) * DUR_RANGE); } } diff --git a/source/game/scenes/logo_scene.cpp b/source/game/scenes/logo_scene.cpp index 84125a8..02c2b04 100644 --- a/source/game/scenes/logo_scene.cpp +++ b/source/game/scenes/logo_scene.cpp @@ -54,7 +54,7 @@ LogoScene::LogoScene(SDLManager& sdl, SceneContext& context) auto option = context_.consumeOption(); (void)option; // Suprimir warning - so_reproduit_.fill(false); // Inicialitzar seguiment de sons + sound_played_.fill(false); // Inicialitzar seguiment de sons initLetters(); } @@ -112,21 +112,21 @@ void LogoScene::initLetters() { float ancho_sin_escalar = max_x - min_x; - // IMPORTANT: Escalar ancho i offset con ESCALA_FINAL + // IMPORTANT: Escalar ancho i offset con FINAL_SCALE // per que las posicions finals coincideixin con la mida real de las lletres - float ancho = ancho_sin_escalar * ESCALA_FINAL; - float offset_centre = (shape->getCenter().x - min_x) * ESCALA_FINAL; + float ancho = ancho_sin_escalar * FINAL_SCALE; + float center_offset = (shape->getCenter().x - min_x) * FINAL_SCALE; - lletres_.push_back({shape, + letters_.push_back({shape, {.x = 0.0F, .y = 0.0F}, // Posición es calcularà después ancho, - offset_centre}); + center_offset}); ancho_total += ancho; } // Pas 2: Añadir espaiat entre lletres - ancho_total += ESPAI_ENTRE_LLETRES * (lletres_.size() - 1); + ancho_total += LETTER_SPACING * (letters_.size() - 1); // Pas 3: Calcular posición inicial (centrat horitzontal) constexpr auto PANTALLA_ANCHO = static_cast(Defaults::Game::WIDTH); @@ -138,38 +138,38 @@ void LogoScene::initLetters() { // Pas 4: Assignar posicions a cada lletra float x_actual = x_inicial; - for (auto& lletra : lletres_) { + for (auto& lletra : letters_) { // Posicionar el centro de la shape (shape_centre) en pantalla - // Usar offset_centre en lloc de ancho/2 perquè shape_centre + // Usar center_offset en lloc de ancho/2 perquè shape_centre // pot no estar exactament al mig del bounding box - lletra.position.x = x_actual + lletra.offset_centre; + lletra.position.x = x_actual + lletra.center_offset; lletra.position.y = y_centre; // Avançar para següent lletra - x_actual += lletra.ancho + ESPAI_ENTRE_LLETRES; + x_actual += lletra.ancho + LETTER_SPACING; } - std::cout << "[LogoScene] " << lletres_.size() + std::cout << "[LogoScene] " << letters_.size() << " lletres carregades, ancho total: " << ancho_total << " px\n"; } void LogoScene::changeState(AnimationState nou_estat) { - estat_actual_ = nou_estat; - temps_estat_actual_ = 0.0F; // Reset time + current_state_ = nou_estat; + temps_current_state_ = 0.0F; // Reset time // Inicialitzar state de explosión if (nou_estat == AnimationState::EXPLOSION) { - lletra_explosio_index_ = 0; - temps_des_ultima_explosio_ = 0.0F; + letter_explosion_index_ = 0; + time_since_last_explosion_ = 0.0F; // Generar ordre aleatori de explosions - ordre_explosio_.clear(); - for (size_t i = 0; i < lletres_.size(); i++) { - ordre_explosio_.push_back(i); + explosion_order_.clear(); + for (size_t i = 0; i < letters_.size(); i++) { + explosion_order_.push_back(i); } std::random_device rd; std::mt19937 g(rd()); - std::shuffle(ordre_explosio_.begin(), ordre_explosio_.end(), g); + std::shuffle(explosion_order_.begin(), explosion_order_.end(), g); } else if (nou_estat == AnimationState::POST_EXPLOSION) { Audio::get()->playMusic("title.ogg"); } @@ -180,34 +180,34 @@ void LogoScene::changeState(AnimationState nou_estat) { auto LogoScene::allLettersComplete() const -> bool { // Cuando global_progress = 1.0, todas las lletres tenen letra_progress = 1.0 - return temps_estat_actual_ >= DURACIO_ZOOM; + return temps_current_state_ >= DURATION_ZOOM; } void LogoScene::updateExplosions(float delta_time) { - temps_des_ultima_explosio_ += delta_time; + time_since_last_explosion_ += delta_time; // Comprovar si es el moment de explode la següent lletra - if (temps_des_ultima_explosio_ >= DELAY_ENTRE_EXPLOSIONS) { - if (lletra_explosio_index_ < lletres_.size()) { + if (time_since_last_explosion_ >= DELAY_ENTRE_EXPLOSIONS) { + if (letter_explosion_index_ < letters_.size()) { // Explotar lletra actual (en ordre aleatori) - size_t index_actual = ordre_explosio_[lletra_explosio_index_]; - const auto& lletra = lletres_[index_actual]; + size_t index_actual = explosion_order_[letter_explosion_index_]; + const auto& lletra = letters_[index_actual]; debris_manager_->explode( lletra.shape, // Forma a explode lletra.position, // Posición 0.0F, // Angle (sin rotación) - ESCALA_FINAL, // Escala (lletres a scale final) + FINAL_SCALE, // Escala (lletres a scale final) SPEED_EXPLOSIO, // Velocidad base 1.0F, // Brightness màxim (per defecte) {.x = 0.0F, .y = 0.0F} // Sin velocity (per defecte) ); - std::cout << "[LogoScene] Explota lletra " << lletra_explosio_index_ << "\n"; + std::cout << "[LogoScene] Explota lletra " << letter_explosion_index_ << "\n"; // Passar a la següent lletra - lletra_explosio_index_++; - temps_des_ultima_explosio_ = 0.0F; + letter_explosion_index_++; + time_since_last_explosion_ = 0.0F; } else { // Todas las lletres han explotat, transición a POST_EXPLOSION changeState(AnimationState::POST_EXPLOSION); @@ -216,31 +216,31 @@ void LogoScene::updateExplosions(float delta_time) { } void LogoScene::update(float delta_time) { - temps_estat_actual_ += delta_time; + temps_current_state_ += delta_time; - switch (estat_actual_) { + switch (current_state_) { case AnimationState::PRE_ANIMATION: - if (temps_estat_actual_ >= DURACIO_PRE) { + if (temps_current_state_ >= DURATION_PRE) { changeState(AnimationState::ANIMATION); } break; case AnimationState::ANIMATION: { // Reproduir so per cada lletra cuando comença a aparèixer - float global_progress = std::min(temps_estat_actual_ / DURACIO_ZOOM, 1.0F); + float global_progress = std::min(temps_current_state_ / DURATION_ZOOM, 1.0F); - for (size_t i = 0; i < lletres_.size() && i < so_reproduit_.size(); i++) { - if (!so_reproduit_[i]) { + for (size_t i = 0; i < letters_.size() && i < sound_played_.size(); i++) { + if (!sound_played_[i]) { float letra_progress = computeLetterProgress( i, - lletres_.size(), + letters_.size(), global_progress, - THRESHOLD_LETRA); + LETTER_THRESHOLD); // Reproduir so cuando la lletra comença a aparèixer (progress > 0) if (letra_progress > 0.0F) { Audio::get()->playSound(Defaults::Sound::LOGO, Audio::Group::GAME); - so_reproduit_[i] = true; + sound_played_[i] = true; } } } @@ -252,7 +252,7 @@ void LogoScene::update(float delta_time) { } case AnimationState::POST_ANIMATION: - if (temps_estat_actual_ >= DURACIO_POST_ANIMATION) { + if (temps_current_state_ >= DURATION_POST_ANIMATION) { changeState(AnimationState::EXPLOSION); } break; @@ -262,7 +262,7 @@ void LogoScene::update(float delta_time) { break; case AnimationState::POST_EXPLOSION: - if (temps_estat_actual_ >= DURACIO_POST_EXPLOSION) { + if (temps_current_state_ >= DURATION_POST_EXPLOSION) { // Transición a pantalla de título context_.setNextScene(SceneType::TITLE); } @@ -282,28 +282,28 @@ void LogoScene::draw() { // Director ha hecho el clear; aquí solo pintamos lo de la escena. // PRE_ANIMATION: Solo pantalla negra (no se pinta nada). - if (estat_actual_ == AnimationState::PRE_ANIMATION) { + if (current_state_ == AnimationState::PRE_ANIMATION) { return; } // ANIMATION o POST_ANIMATION: Dibuixar lletres con animación - if (estat_actual_ == AnimationState::ANIMATION || - estat_actual_ == AnimationState::POST_ANIMATION) { + if (current_state_ == AnimationState::ANIMATION || + current_state_ == AnimationState::POST_ANIMATION) { float global_progress = - (estat_actual_ == AnimationState::ANIMATION) - ? std::min(temps_estat_actual_ / DURACIO_ZOOM, 1.0F) + (current_state_ == AnimationState::ANIMATION) + ? std::min(temps_current_state_ / DURATION_ZOOM, 1.0F) : 1.0F; // POST: mantenir al 100% const Vec2 ORIGEN_ZOOM = {.x = ORIGEN_ZOOM_X, .y = ORIGEN_ZOOM_Y}; - for (size_t i = 0; i < lletres_.size(); i++) { - const auto& lletra = lletres_[i]; + for (size_t i = 0; i < letters_.size(); i++) { + const auto& lletra = letters_[i]; float letra_progress = computeLetterProgress( i, - lletres_.size(), + letters_.size(), global_progress, - THRESHOLD_LETRA); + LETTER_THRESHOLD); if (letra_progress <= 0.0F) { continue; @@ -318,7 +318,7 @@ void LogoScene::draw() { float t = letra_progress; float ease_factor = 1.0F - ((1.0F - t) * (1.0F - t)); float current_scale = - ESCALA_INICIAL + ((ESCALA_FINAL - ESCALA_INICIAL) * ease_factor); + INITIAL_SCALE + ((FINAL_SCALE - INITIAL_SCALE) * ease_factor); Rendering::renderShape( sdl_.getRenderer(), @@ -331,24 +331,24 @@ void LogoScene::draw() { } // EXPLOSION: Dibuixar solo lletres que aún no han explotat - if (estat_actual_ == AnimationState::EXPLOSION) { + if (current_state_ == AnimationState::EXPLOSION) { // Crear conjunt de lletres ya explotades std::set explotades; - for (size_t i = 0; i < lletra_explosio_index_; i++) { - explotades.insert(ordre_explosio_[i]); + for (size_t i = 0; i < letter_explosion_index_; i++) { + explotades.insert(explosion_order_[i]); } // Dibuixar solo lletres que NO han explotat - for (size_t i = 0; i < lletres_.size(); i++) { + for (size_t i = 0; i < letters_.size(); i++) { if (!explotades.contains(i)) { - const auto& lletra = lletres_[i]; + const auto& lletra = letters_[i]; Rendering::renderShape( sdl_.getRenderer(), lletra.shape, lletra.position, 0.0F, - ESCALA_FINAL, + FINAL_SCALE, 1.0F); } } diff --git a/source/game/scenes/logo_scene.hpp b/source/game/scenes/logo_scene.hpp index 0a347e7..a8b6bf4 100644 --- a/source/game/scenes/logo_scene.hpp +++ b/source/game/scenes/logo_scene.hpp @@ -42,44 +42,44 @@ class LogoScene final : public Scene { SDLManager& sdl_; SceneManager::SceneContext& context_; - AnimationState estat_actual_{AnimationState::PRE_ANIMATION}; // Estat actual de la màquina + AnimationState current_state_{AnimationState::PRE_ANIMATION}; // Estat actual de la màquina float - temps_estat_actual_{0.0F}; // Temps en l'state actual (reset en cada transición) + temps_current_state_{0.0F}; // Temps en l'state actual (reset en cada transición) // Gestor de fragments de explosions std::unique_ptr debris_manager_; // Seguiment de explosions seqüencials - size_t lletra_explosio_index_{0}; // Índex de la següent lletra a explode - float temps_des_ultima_explosio_{0.0F}; // Temps desde l'última explosión - std::vector ordre_explosio_; // Ordre aleatori de índexs de lletres + size_t letter_explosion_index_{0}; // Índex de la següent lletra a explode + float time_since_last_explosion_{0.0F}; // Temps desde l'última explosión + std::vector explosion_order_; // Ordre aleatori de índexs de lletres // Estructura para cada lletra del logo - struct LetraLogo { + struct LogoLetter { std::shared_ptr shape; Vec2 position; // Posición final en pantalla float ancho; // Ancho del bounding box - float offset_centre; // Distancia de min_x a shape_centre.x + float center_offset; // Distancia de min_x a shape_centre.x }; - std::vector lletres_; // 9 lletres: J-A-I-L-G-A-M-E-S + std::vector letters_; // 9 lletres: J-A-I-L-G-A-M-E-S // Seguiment de sons de lletres (evitar reproduccions repetides) - std::array so_reproduit_; // Track si cada lletra ya ha reproduit el so + std::array sound_played_; // Track si cada lletra ya ha reproduit el so // Constants de animación - static constexpr float DURACIO_PRE = 1.5F; // Duració PRE_ANIMATION (pantalla negra) - static constexpr float DURACIO_ZOOM = 4.0F; // Duració del zoom (segons) - static constexpr float DURACIO_POST_ANIMATION = 3.0F; // Duració POST_ANIMATION (logo complet) - static constexpr float DURACIO_POST_EXPLOSION = 3.0F; // Duració POST_EXPLOSION (espera final) - static constexpr float DELAY_ENTRE_EXPLOSIONS = 0.1F; // Temps entre explosions de lletres - static constexpr float SPEED_EXPLOSIO = 240.0F; // Velocidad base fragments (px/s) - static constexpr float ESCALA_INICIAL = 0.1F; // Escala inicial (10%) - static constexpr float ESCALA_FINAL = 0.8F; // Escala final (80%) - static constexpr float ESPAI_ENTRE_LLETRES = 10.0F; // Espaiat entre lletres + static constexpr float DURATION_PRE = 1.5F; // Duració PRE_ANIMATION (pantalla negra) + static constexpr float DURATION_ZOOM = 4.0F; // Duració del zoom (segons) + static constexpr float DURATION_POST_ANIMATION = 3.0F; // Duració POST_ANIMATION (logo complet) + static constexpr float DURATION_POST_EXPLOSION = 3.0F; // Duració POST_EXPLOSION (espera final) + static constexpr float DELAY_ENTRE_EXPLOSIONS = 0.1F; // Temps entre explosions de lletres + static constexpr float SPEED_EXPLOSIO = 240.0F; // Velocidad base fragments (px/s) + static constexpr float INITIAL_SCALE = 0.1F; // Escala inicial (10%) + static constexpr float FINAL_SCALE = 0.8F; // Escala final (80%) + static constexpr float LETTER_SPACING = 10.0F; // Espaiat entre lletres // Constants de animación seqüencial - static constexpr float THRESHOLD_LETRA = 0.6F; // Umbral per activar següent lletra (0.0-1.0) + static constexpr float LETTER_THRESHOLD = 0.6F; // Umbral per activar següent lletra (0.0-1.0) static constexpr float ORIGEN_ZOOM_X = Defaults::Game::WIDTH * 0.5F; // Vec2 inicial X del zoom static constexpr float ORIGEN_ZOOM_Y = Defaults::Game::HEIGHT * 0.4F; // Vec2 inicial Y del zoom diff --git a/source/game/scenes/title_scene.cpp b/source/game/scenes/title_scene.cpp index 7012384..423ccb0 100644 --- a/source/game/scenes/title_scene.cpp +++ b/source/game/scenes/title_scene.cpp @@ -43,8 +43,8 @@ TitleScene::TitleScene(SDLManager& sdl, SceneContext& context) auto option = context_.consumeOption(); if (option == Option::JUMP_TO_TITLE_MAIN) { std::cout << "SceneType Titol: Opció JUMP_TO_TITLE_MAIN activada\n"; - estat_actual_ = TitleState::MAIN; - temps_estat_main_ = 0.0F; + current_state_ = TitleState::MAIN; + state_time_main_ = 0.0F; } // Càmera 3D: posicionada a l'origen, mirant cap a +Z, amb Y cap amunt. @@ -61,7 +61,7 @@ TitleScene::TitleScene(SDLManager& sdl, SceneContext& context) camera_.get(), 200); starfield_->setColor(Defaults::Title::Colors::STARFIELD); - if (estat_actual_ == TitleState::MAIN) { + if (current_state_ == TitleState::MAIN) { starfield_->setBrightness(BRIGHTNESS_STARFIELD); } else { starfield_->setBrightness(0.0F); @@ -125,22 +125,22 @@ void TitleScene::initTitle() { const float ANCHO = (max_x - min_x) * Defaults::Title::Layout::LOGO_SCALE; const float ALTURA = (max_y - min_y) * Defaults::Title::Layout::LOGO_SCALE; const float OFFSET_CENTRE = (shape->getCenter().x - min_x) * Defaults::Title::Layout::LOGO_SCALE; - lletres_orni_.push_back({shape, {.x = 0.0F, .y = 0.0F}, ANCHO, ALTURA, OFFSET_CENTRE}); + letters_orni_.push_back({shape, {.x = 0.0F, .y = 0.0F}, ANCHO, ALTURA, OFFSET_CENTRE}); ancho_total_orni += ANCHO; } - ancho_total_orni += ESPAI_ENTRE_LLETRES * static_cast(lletres_orni_.size() - 1); + ancho_total_orni += LETTER_SPACING * static_cast(letters_orni_.size() - 1); float x_actual = (Defaults::Game::WIDTH - ancho_total_orni) / 2.0F; - for (auto& lletra : lletres_orni_) { - lletra.position.x = x_actual + lletra.offset_centre; + for (auto& lletra : letters_orni_) { + lletra.position.x = x_actual + lletra.center_offset; lletra.position.y = Defaults::Game::HEIGHT * Defaults::Title::Layout::LOGO_POS; - x_actual += lletra.ancho + ESPAI_ENTRE_LLETRES; + x_actual += lletra.ancho + LETTER_SPACING; } - const float ALTURA_ORNI = lletres_orni_.empty() ? 50.0F : lletres_orni_[0].altura; + const float ALTURA_ORNI = letters_orni_.empty() ? 50.0F : letters_orni_[0].altura; const float Y_ORNI = Defaults::Game::HEIGHT * Defaults::Title::Layout::LOGO_POS; const float SEPARACION = Defaults::Game::HEIGHT * Defaults::Title::Layout::LOGO_LINE_SPACING; - y_attack_dinamica_ = Y_ORNI + ALTURA_ORNI + SEPARACION; + dynamic_attack_y_ = Y_ORNI + ALTURA_ORNI + SEPARACION; const std::vector FITXERS_ATTACK = { "title/letra_a.shp", @@ -173,25 +173,25 @@ void TitleScene::initTitle() { const float ANCHO = (max_x - min_x) * Defaults::Title::Layout::LOGO_SCALE; const float ALTURA = (max_y - min_y) * Defaults::Title::Layout::LOGO_SCALE; const float OFFSET_CENTRE = (shape->getCenter().x - min_x) * Defaults::Title::Layout::LOGO_SCALE; - lletres_attack_.push_back({shape, {.x = 0.0F, .y = 0.0F}, ANCHO, ALTURA, OFFSET_CENTRE}); + letters_attack_.push_back({shape, {.x = 0.0F, .y = 0.0F}, ANCHO, ALTURA, OFFSET_CENTRE}); ancho_total_attack += ANCHO; } - ancho_total_attack += ESPAI_ENTRE_LLETRES * static_cast(lletres_attack_.size() - 1); + ancho_total_attack += LETTER_SPACING * static_cast(letters_attack_.size() - 1); x_actual = (Defaults::Game::WIDTH - ancho_total_attack) / 2.0F; - for (auto& lletra : lletres_attack_) { - lletra.position.x = x_actual + lletra.offset_centre; - lletra.position.y = y_attack_dinamica_; - x_actual += lletra.ancho + ESPAI_ENTRE_LLETRES; + for (auto& lletra : letters_attack_) { + lletra.position.x = x_actual + lletra.center_offset; + lletra.position.y = dynamic_attack_y_; + x_actual += lletra.ancho + LETTER_SPACING; } - posicions_originals_orni_.clear(); - for (const auto& lletra : lletres_orni_) { - posicions_originals_orni_.push_back(lletra.position); + original_positions_orni_.clear(); + for (const auto& lletra : letters_orni_) { + original_positions_orni_.push_back(lletra.position); } - posicions_originals_attack_.clear(); - for (const auto& lletra : lletres_attack_) { - posicions_originals_attack_.push_back(lletra.position); + original_positions_attack_.clear(); + for (const auto& lletra : letters_attack_) { + original_positions_attack_.push_back(lletra.position); } } @@ -234,13 +234,13 @@ void TitleScene::inicialitzarJailgames() { const float ANCHO = (max_x - min_x) * SCALE; const float ALTURA = (max_y - min_y) * SCALE; const float OFFSET_CENTRE = (shape->getCenter().x - min_x) * SCALE; - lletres_jailgames_.push_back({shape, {.x = 0.0F, .y = 0.0F}, ANCHO, ALTURA, OFFSET_CENTRE}); + letters_jailgames_.push_back({shape, {.x = 0.0F, .y = 0.0F}, ANCHO, ALTURA, OFFSET_CENTRE}); ancho_total += ANCHO; altura_max = std::max(altura_max, ALTURA); } - constexpr float ESPAI_JAILGAMES = ESPAI_ENTRE_LLETRES * SCALE; - if (!lletres_jailgames_.empty()) { - ancho_total += ESPAI_JAILGAMES * static_cast(lletres_jailgames_.size() - 1); + constexpr float ESPAI_JAILGAMES = LETTER_SPACING * SCALE; + if (!letters_jailgames_.empty()) { + ancho_total += ESPAI_JAILGAMES * static_cast(letters_jailgames_.size() - 1); } const float Y_COPY = Defaults::Game::HEIGHT * Defaults::Title::Layout::COPYRIGHT1_POS; @@ -249,8 +249,8 @@ void TitleScene::inicialitzarJailgames() { const float X_INICIAL = (Defaults::Game::WIDTH - ancho_total) / 2.0F; float x_actual = X_INICIAL; - for (auto& lletra : lletres_jailgames_) { - lletra.position.x = x_actual + lletra.offset_centre; + for (auto& lletra : letters_jailgames_) { + lletra.position.x = x_actual + lletra.center_offset; lletra.position.y = Y_CENTRE; x_actual += lletra.ancho + ESPAI_JAILGAMES; } @@ -268,7 +268,7 @@ void TitleScene::dibuixarPeuTitol(float spacing) const { const float COPYRIGHT_S = std::lerp(S::FOOTER_INTRO_SCALE_START, 1.0F, Easing::easeOutQuad(intro_copyright_progress_)); const float JAILGAMES_RENDER_SCALE = Defaults::Title::Layout::JAILGAMES_SCALE * JAILGAMES_S; - for (const auto& lletra : lletres_jailgames_) { + for (const auto& lletra : letters_jailgames_) { const Vec2 POS{ .x = SCREEN_CENTRE_X + (JAILGAMES_S * (lletra.position.x - SCREEN_CENTRE_X)), .y = SCREEN_CENTRE_Y + (JAILGAMES_S * (lletra.position.y - SCREEN_CENTRE_Y)), @@ -297,15 +297,15 @@ void TitleScene::update(float delta_time) { starfield_->update(delta_time); } if (ship_animator_ && - (estat_actual_ == TitleState::STARFIELD_FADE_IN || - estat_actual_ == TitleState::STARFIELD || - estat_actual_ == TitleState::MAIN || - estat_actual_ == TitleState::PLAYER_JOIN_PHASE)) { + (current_state_ == TitleState::STARFIELD_FADE_IN || + current_state_ == TitleState::STARFIELD || + current_state_ == TitleState::MAIN || + current_state_ == TitleState::PLAYER_JOIN_PHASE)) { ship_animator_->update(delta_time); } updateFlashes(delta_time); - switch (estat_actual_) { + switch (current_state_) { case TitleState::STARFIELD_FADE_IN: updateStarfieldFadeInState(delta_time); break; @@ -329,10 +329,10 @@ void TitleScene::update(float delta_time) { void TitleScene::updateStarfieldFadeInState(float delta_time) { temps_acumulat_ += delta_time; - const float PROGRESS = std::min(1.0F, temps_acumulat_ / DURACIO_FADE_IN); + const float PROGRESS = std::min(1.0F, temps_acumulat_ / DURATION_FADE_IN); starfield_->setBrightness(PROGRESS * BRIGHTNESS_STARFIELD); - if (temps_acumulat_ >= DURACIO_FADE_IN) { - estat_actual_ = TitleState::STARFIELD; + if (temps_acumulat_ >= DURATION_FADE_IN) { + current_state_ = TitleState::STARFIELD; temps_acumulat_ = 0.0F; starfield_->setBrightness(BRIGHTNESS_STARFIELD); } @@ -340,16 +340,16 @@ void TitleScene::updateStarfieldFadeInState(float delta_time) { void TitleScene::updateStarfieldState(float delta_time) { temps_acumulat_ += delta_time; - if (temps_acumulat_ >= DURACIO_INIT) { - estat_actual_ = TitleState::MAIN; - temps_estat_main_ = 0.0F; - animacio_activa_ = false; - factor_lerp_ = 0.0F; + if (temps_acumulat_ >= DURATION_INIT) { + current_state_ = TitleState::MAIN; + state_time_main_ = 0.0F; + animation_active_ = false; + lerp_factor_ = 0.0F; } } void TitleScene::updateMainState(float delta_time) { - temps_estat_main_ += delta_time; + state_time_main_ += delta_time; namespace S = Defaults::Title::Sequence; namespace Sh = Defaults::Title::Ships; @@ -364,38 +364,38 @@ void TitleScene::updateMainState(float delta_time) { constexpr float T_SHIPS_LANDED = T_SHIPS_START + Sh::ENTRY_DURATION + Sh::P2_ENTRY_DELAY; constexpr float T_PRESS_START_VISIBLE = T_SHIPS_LANDED + S::PRESS_START_DELAY_AFTER_SHIPS; - intro_logo_progress_ = std::clamp(temps_estat_main_ / S::LOGO_ENTRY_DURATION, 0.0F, 1.0F); + intro_logo_progress_ = std::clamp(state_time_main_ / S::LOGO_ENTRY_DURATION, 0.0F, 1.0F); intro_jailgames_progress_ = std::clamp( - (temps_estat_main_ - T_FOOTER_START) / S::JAILGAMES_ENTRY_DURATION, + (state_time_main_ - T_FOOTER_START) / S::JAILGAMES_ENTRY_DURATION, 0.0F, 1.0F); intro_copyright_progress_ = std::clamp( - (temps_estat_main_ - T_COPY_START) / S::COPYRIGHT_ENTRY_DURATION, + (state_time_main_ - T_COPY_START) / S::COPYRIGHT_ENTRY_DURATION, 0.0F, 1.0F); - if (!ships_intro_launched_ && temps_estat_main_ >= T_SHIPS_START && + if (!ships_intro_launched_ && state_time_main_ >= T_SHIPS_START && ship_animator_ != nullptr) { ship_animator_->setVisible(true); ship_animator_->startEntryAnimation(); ships_intro_launched_ = true; } - if (!press_start_visible_ && temps_estat_main_ >= T_PRESS_START_VISIBLE) { + if (!press_start_visible_ && state_time_main_ >= T_PRESS_START_VISIBLE) { press_start_visible_ = true; } // L'oscil·lació suau del logo arrenca quan el logo ha aterrat. Així // l'amplitud creix gradualment (lerp) durant la resta de la intro. - if (temps_estat_main_ < S::LOGO_ENTRY_DURATION) { - factor_lerp_ = 0.0F; - animacio_activa_ = false; - } else if (temps_estat_main_ < S::LOGO_ENTRY_DURATION + DURACIO_LERP) { - factor_lerp_ = (temps_estat_main_ - S::LOGO_ENTRY_DURATION) / DURACIO_LERP; - animacio_activa_ = true; + if (state_time_main_ < S::LOGO_ENTRY_DURATION) { + lerp_factor_ = 0.0F; + animation_active_ = false; + } else if (state_time_main_ < S::LOGO_ENTRY_DURATION + DURATION_LERP) { + lerp_factor_ = (state_time_main_ - S::LOGO_ENTRY_DURATION) / DURATION_LERP; + animation_active_ = true; } else { - factor_lerp_ = 1.0F; - animacio_activa_ = true; + lerp_factor_ = 1.0F; + animation_active_ = true; } updateLogoAnimation(delta_time); } @@ -414,27 +414,27 @@ void TitleScene::updatePlayerJoinPhaseState(float delta_time) { temps_acumulat_ = 0.0F; } - if (temps_acumulat_ >= DURACIO_TRANSITION) { - estat_actual_ = TitleState::BLACK_SCREEN; + if (temps_acumulat_ >= DURATION_TRANSITION) { + current_state_ = TitleState::BLACK_SCREEN; temps_acumulat_ = 0.0F; } } void TitleScene::updateBlackScreenState(float delta_time) { temps_acumulat_ += delta_time; - if (temps_acumulat_ >= DURACIO_BLACK_SCREEN) { + if (temps_acumulat_ >= DURATION_BLACK_SCREEN) { context_.setNextScene(SceneType::GAME); } } void TitleScene::handleSkipInput() { - if (estat_actual_ != TitleState::STARFIELD_FADE_IN && estat_actual_ != TitleState::STARFIELD) { + if (current_state_ != TitleState::STARFIELD_FADE_IN && current_state_ != TitleState::STARFIELD) { return; } if (!checkSkipButtonPressed()) { return; } - estat_actual_ = TitleState::MAIN; + current_state_ = TitleState::MAIN; starfield_->setBrightness(BRIGHTNESS_STARFIELD); // Saltar la intro coreografiada: deixar tots els elements ja in-place. @@ -445,7 +445,7 @@ void TitleScene::handleSkipInput() { S::LOGO_ENTRY_DURATION + S::COPYRIGHT_STAGGER + S::COPYRIGHT_ENTRY_DURATION); constexpr float T_PRESS_START_VISIBLE = T_FOOTER_END + S::SHIPS_DELAY_AFTER_FOOTER + Sh::ENTRY_DURATION + Sh::P2_ENTRY_DELAY + S::PRESS_START_DELAY_AFTER_SHIPS; - temps_estat_main_ = T_PRESS_START_VISIBLE; + state_time_main_ = T_PRESS_START_VISIBLE; intro_logo_progress_ = 1.0F; intro_jailgames_progress_ = 1.0F; intro_copyright_progress_ = 1.0F; @@ -458,7 +458,7 @@ void TitleScene::handleSkipInput() { } void TitleScene::handleStartInput() { - if (estat_actual_ != TitleState::MAIN) { + if (current_state_ != TitleState::MAIN) { return; } // No acceptar START fins que la intro coreografiada haja conclòs i el @@ -479,7 +479,7 @@ void TitleScene::handleStartInput() { } context_.setMatchConfig(match_config_); - estat_actual_ = TitleState::PLAYER_JOIN_PHASE; + current_state_ = TitleState::PLAYER_JOIN_PHASE; temps_acumulat_ = 0.0F; triggerExitForJoinedPlayers(P1_ABANS, P2_ABANS, ""); @@ -503,44 +503,44 @@ void TitleScene::triggerExitForJoinedPlayers(bool p1_was_active, bool p2_was_act } void TitleScene::updateLogoAnimation(float delta_time) { - if (!animacio_activa_) { + if (!animation_active_) { return; } - temps_animacio_ += delta_time * factor_lerp_; + animation_time_ += delta_time * lerp_factor_; const float TWO_PI = 2.0F * Defaults::Math::PI; - const float OFFSET_X = ORBIT_AMPLITUDE_X * std::sin(TWO_PI * ORBIT_FREQUENCY_X * temps_animacio_); - const float OFFSET_Y = ORBIT_AMPLITUDE_Y * std::sin((TWO_PI * ORBIT_FREQUENCY_Y * temps_animacio_) + ORBIT_PHASE_OFFSET); + const float OFFSET_X = ORBIT_AMPLITUDE_X * std::sin(TWO_PI * ORBIT_FREQUENCY_X * animation_time_); + const float OFFSET_Y = ORBIT_AMPLITUDE_Y * std::sin((TWO_PI * ORBIT_FREQUENCY_Y * animation_time_) + ORBIT_PHASE_OFFSET); - for (std::size_t i = 0; i < lletres_orni_.size(); ++i) { - lletres_orni_[i].position.x = posicions_originals_orni_[i].x + std::round(OFFSET_X); - lletres_orni_[i].position.y = posicions_originals_orni_[i].y + std::round(OFFSET_Y); + for (std::size_t i = 0; i < letters_orni_.size(); ++i) { + letters_orni_[i].position.x = original_positions_orni_[i].x + std::round(OFFSET_X); + letters_orni_[i].position.y = original_positions_orni_[i].y + std::round(OFFSET_Y); } - for (std::size_t i = 0; i < lletres_attack_.size(); ++i) { - lletres_attack_[i].position.x = posicions_originals_attack_[i].x + std::round(OFFSET_X); - lletres_attack_[i].position.y = posicions_originals_attack_[i].y + std::round(OFFSET_Y); + for (std::size_t i = 0; i < letters_attack_.size(); ++i) { + letters_attack_[i].position.x = original_positions_attack_[i].x + std::round(OFFSET_X); + letters_attack_[i].position.y = original_positions_attack_[i].y + std::round(OFFSET_Y); } } void TitleScene::draw() { - if (starfield_ && estat_actual_ != TitleState::BLACK_SCREEN) { + if (starfield_ && current_state_ != TitleState::BLACK_SCREEN) { starfield_->draw(); } if (ship_animator_ && - (estat_actual_ == TitleState::STARFIELD_FADE_IN || - estat_actual_ == TitleState::STARFIELD || - estat_actual_ == TitleState::MAIN || - estat_actual_ == TitleState::PLAYER_JOIN_PHASE)) { + (current_state_ == TitleState::STARFIELD_FADE_IN || + current_state_ == TitleState::STARFIELD || + current_state_ == TitleState::MAIN || + current_state_ == TitleState::PLAYER_JOIN_PHASE)) { ship_animator_->draw(); } drawFlashes(); - if (estat_actual_ == TitleState::STARFIELD_FADE_IN || estat_actual_ == TitleState::STARFIELD) { + if (current_state_ == TitleState::STARFIELD_FADE_IN || current_state_ == TitleState::STARFIELD) { return; } - if (estat_actual_ != TitleState::MAIN && estat_actual_ != TitleState::PLAYER_JOIN_PHASE) { + if (current_state_ != TitleState::MAIN && current_state_ != TitleState::PLAYER_JOIN_PHASE) { return; } @@ -552,40 +552,40 @@ void TitleScene::draw() { const float SCREEN_CENTRE_Y = Defaults::Game::HEIGHT / 2.0F; const float LOGO_RENDER_SCALE = Defaults::Title::Layout::LOGO_SCALE * LOGO_S; - if (animacio_activa_) { - float temps_shadow = std::max(0.0F, temps_animacio_ - SHADOW_DELAY); + if (animation_active_) { + float temps_shadow = std::max(0.0F, animation_time_ - SHADOW_DELAY); const float TWO_PI = 2.0F * Defaults::Math::PI; const float SHADOW_OX = (ORBIT_AMPLITUDE_X * std::sin(TWO_PI * ORBIT_FREQUENCY_X * temps_shadow)) + SHADOW_OFFSET_X; const float SHADOW_OY = (ORBIT_AMPLITUDE_Y * std::sin((TWO_PI * ORBIT_FREQUENCY_Y * temps_shadow) + ORBIT_PHASE_OFFSET)) + SHADOW_OFFSET_Y; - for (std::size_t i = 0; i < lletres_orni_.size(); ++i) { - const float BASE_X = posicions_originals_orni_[i].x + std::round(SHADOW_OX); - const float BASE_Y = posicions_originals_orni_[i].y + std::round(SHADOW_OY); + for (std::size_t i = 0; i < letters_orni_.size(); ++i) { + const float BASE_X = original_positions_orni_[i].x + std::round(SHADOW_OX); + const float BASE_Y = original_positions_orni_[i].y + std::round(SHADOW_OY); const Vec2 POS_SHADOW{ .x = SCREEN_CENTRE_X + (LOGO_S * (BASE_X - SCREEN_CENTRE_X)), .y = SCREEN_CENTRE_Y + (LOGO_S * (BASE_Y - SCREEN_CENTRE_Y)), }; - Rendering::renderShape(sdl_.getRenderer(), lletres_orni_[i].shape, POS_SHADOW, 0.0F, LOGO_RENDER_SCALE, 1.0F, SHADOW_BRIGHTNESS, Defaults::Title::Colors::LOGO_SHADOW); + Rendering::renderShape(sdl_.getRenderer(), letters_orni_[i].shape, POS_SHADOW, 0.0F, LOGO_RENDER_SCALE, 1.0F, SHADOW_BRIGHTNESS, Defaults::Title::Colors::LOGO_SHADOW); } - for (std::size_t i = 0; i < lletres_attack_.size(); ++i) { - const float BASE_X = posicions_originals_attack_[i].x + std::round(SHADOW_OX); - const float BASE_Y = posicions_originals_attack_[i].y + std::round(SHADOW_OY); + for (std::size_t i = 0; i < letters_attack_.size(); ++i) { + const float BASE_X = original_positions_attack_[i].x + std::round(SHADOW_OX); + const float BASE_Y = original_positions_attack_[i].y + std::round(SHADOW_OY); const Vec2 POS_SHADOW{ .x = SCREEN_CENTRE_X + (LOGO_S * (BASE_X - SCREEN_CENTRE_X)), .y = SCREEN_CENTRE_Y + (LOGO_S * (BASE_Y - SCREEN_CENTRE_Y)), }; - Rendering::renderShape(sdl_.getRenderer(), lletres_attack_[i].shape, POS_SHADOW, 0.0F, LOGO_RENDER_SCALE, 1.0F, SHADOW_BRIGHTNESS, Defaults::Title::Colors::LOGO_SHADOW); + Rendering::renderShape(sdl_.getRenderer(), letters_attack_[i].shape, POS_SHADOW, 0.0F, LOGO_RENDER_SCALE, 1.0F, SHADOW_BRIGHTNESS, Defaults::Title::Colors::LOGO_SHADOW); } } - for (const auto& lletra : lletres_orni_) { + for (const auto& lletra : letters_orni_) { const Vec2 POS{ .x = SCREEN_CENTRE_X + (LOGO_S * (lletra.position.x - SCREEN_CENTRE_X)), .y = SCREEN_CENTRE_Y + (LOGO_S * (lletra.position.y - SCREEN_CENTRE_Y)), }; Rendering::renderShape(sdl_.getRenderer(), lletra.shape, POS, 0.0F, LOGO_RENDER_SCALE, 1.0F, 1.0F, Defaults::Title::Colors::LOGO_MAIN); } - for (const auto& lletra : lletres_attack_) { + for (const auto& lletra : letters_attack_) { const Vec2 POS{ .x = SCREEN_CENTRE_X + (LOGO_S * (lletra.position.x - SCREEN_CENTRE_X)), .y = SCREEN_CENTRE_Y + (LOGO_S * (lletra.position.y - SCREEN_CENTRE_Y)), @@ -597,7 +597,7 @@ void TitleScene::draw() { if (press_start_visible_) { bool mostrar_text = true; - if (estat_actual_ == TitleState::PLAYER_JOIN_PHASE) { + if (current_state_ == TitleState::PLAYER_JOIN_PHASE) { const float FASE = temps_acumulat_ * BLINK_FREQUENCY * 2.0F * std::numbers::pi_v; mostrar_text = (std::sin(FASE) > 0.0F); } diff --git a/source/game/scenes/title_scene.hpp b/source/game/scenes/title_scene.hpp index 6f03692..e5396f0 100644 --- a/source/game/scenes/title_scene.hpp +++ b/source/game/scenes/title_scene.hpp @@ -48,12 +48,12 @@ class TitleScene final : public Scene { BLACK_SCREEN, }; - struct LetraLogo { + struct LogoLetter { std::shared_ptr shape; Vec2 position; float ancho; float altura; - float offset_centre; + float center_offset; }; SDLManager& sdl_; @@ -77,22 +77,22 @@ class TitleScene final : public Scene { void triggerFlash(Vec2 pos); void updateFlashes(float delta_time); void drawFlashes(); - TitleState estat_actual_{TitleState::STARFIELD_FADE_IN}; + TitleState current_state_{TitleState::STARFIELD_FADE_IN}; float temps_acumulat_{0.0F}; - std::vector lletres_orni_; - std::vector lletres_attack_; - float y_attack_dinamica_{0.0F}; + std::vector letters_orni_; + std::vector letters_attack_; + float dynamic_attack_y_{0.0F}; - std::vector lletres_jailgames_; + std::vector letters_jailgames_; - float temps_animacio_{0.0F}; - std::vector posicions_originals_orni_; - std::vector posicions_originals_attack_; + float animation_time_{0.0F}; + std::vector original_positions_orni_; + std::vector original_positions_attack_; - float temps_estat_main_{0.0F}; - bool animacio_activa_{false}; - float factor_lerp_{0.0F}; + float state_time_main_{0.0F}; + bool animation_active_{false}; + float lerp_factor_{0.0F}; // Progresos de la intro coreografiada al state MAIN. float intro_logo_progress_{0.0F}; @@ -102,12 +102,12 @@ class TitleScene final : public Scene { bool ships_intro_launched_{false}; static constexpr float BRIGHTNESS_STARFIELD = 1.2F; - static constexpr float DURACIO_FADE_IN = 3.0F; - static constexpr float DURACIO_INIT = 4.0F; - static constexpr float DURACIO_TRANSITION = 2.5F; - static constexpr float ESPAI_ENTRE_LLETRES = 10.0F; + static constexpr float DURATION_FADE_IN = 3.0F; + static constexpr float DURATION_INIT = 4.0F; + static constexpr float DURATION_TRANSITION = 2.5F; + static constexpr float LETTER_SPACING = 10.0F; static constexpr float BLINK_FREQUENCY = 3.0F; - static constexpr float DURACIO_BLACK_SCREEN = 2.0F; + static constexpr float DURATION_BLACK_SCREEN = 2.0F; static constexpr int MUSIC_FADE = 1500; static constexpr float ORBIT_AMPLITUDE_X = 4.0F; @@ -121,7 +121,7 @@ class TitleScene final : public Scene { static constexpr float SHADOW_OFFSET_X = 2.0F; static constexpr float SHADOW_OFFSET_Y = 2.0F; - static constexpr float DURACIO_LERP = 2.0F; + static constexpr float DURATION_LERP = 2.0F; // Càmera 3D: FOV vertical en radians. static constexpr float CAMERA_FOV_Y_RAD = 1.0472F; // 60°