refactor(scenes): renombra ancho/altura/centre_punt residuals a anglès

source/game/scenes/logo_scene.cpp

@@ -20,14 +20,14 @@ using SceneManager::SceneContext;
 using SceneType = SceneContext::SceneType;
 using Option = SceneContext::Option;
 
-// Helper: calcular el progrés individual de una lletra
+// Helper: calcular el progrés individual de una letter
 // en función del progrés global (efecte seqüencial)
 static auto computeLetterProgress(size_t letra_index, size_t num_letras, float global_progress, float threshold) -> float {
     if (num_letras == 0) {
         return 1.0F;
     }
 
-    // Calcular time per lletra
+    // Calcular time per letter
     float duration_per_letra = 1.0F / static_cast<float>(num_letras);
     float step = threshold * duration_per_letra;
     float start = static_cast<float>(letra_index) * step;
@@ -90,7 +90,7 @@ void LogoScene::initLetters() {
         "logo/letra_s.shp"};
 
     // Pas 1: Carregar todas las formes i calcular amplades
-    float ancho_total = 0.0F;
+    float total_width = 0.0F;
 
     for (const auto& file : archivos) {
         auto shape = ShapeLoader::load(file);
@@ -110,47 +110,47 @@ void LogoScene::initLetters() {
             }
         }
 
-        float ancho_sin_escalar = max_x - min_x;
+        float width_unscaled = max_x - min_x;
 
         // 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 * FINAL_SCALE;
+        float width = width_unscaled * FINAL_SCALE;
         float center_offset = (shape->getCenter().x - min_x) * FINAL_SCALE;
 
         letters_.push_back({shape,
             {.x = 0.0F, .y = 0.0F},  // Posición es calcularà después
-            ancho,
+            width,
             center_offset});
 
-        ancho_total += ancho;
+        total_width += width;
     }
 
     // Pas 2: Añadir espaiat entre lletres
-    ancho_total += LETTER_SPACING * (letters_.size() - 1);
+    total_width += LETTER_SPACING * (letters_.size() - 1);
 
     // Pas 3: Calcular posición inicial (centrat horitzontal)
-    constexpr auto PANTALLA_ANCHO = static_cast<float>(Defaults::Game::WIDTH);
+    constexpr auto SCREEN_WIDTH = static_cast<float>(Defaults::Game::WIDTH);
     constexpr auto PANTALLA_ALTO = static_cast<float>(Defaults::Game::HEIGHT);
 
-    float x_inicial = (PANTALLA_ANCHO - ancho_total) / 2.0F;
+    float x_inicial = (SCREEN_WIDTH - total_width) / 2.0F;
     float y_centre = PANTALLA_ALTO / 2.0F;
 
-    // Pas 4: Assignar posicions a cada lletra
+    // Pas 4: Assignar posicions a cada letter
     float x_actual = x_inicial;
 
-    for (auto& lletra : letters_) {
+    for (auto& letter : letters_) {
         // Posicionar el centro de la shape (shape_centre) en pantalla
         // 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.center_offset;
-        lletra.position.y = y_centre;
+        letter.position.x = x_actual + letter.center_offset;
+        letter.position.y = y_centre;
 
-        // Avançar para següent lletra
-        x_actual += lletra.ancho + LETTER_SPACING;
+        // Avançar para següent letter
+        x_actual += letter.width + LETTER_SPACING;
     }
 
     std::cout << "[LogoScene] " << letters_.size()
-              << " lletres carregades, ancho total: " << ancho_total << " px\n";
+              << " lletres carregades, ancho total: " << total_width << " px\n";
 }
 
 void LogoScene::changeState(AnimationState nou_estat) {
@@ -186,16 +186,16 @@ auto LogoScene::allLettersComplete() const -> bool {
 void LogoScene::updateExplosions(float delta_time) {
     time_since_last_explosion_ += delta_time;
 
-    // Comprovar si es el moment de explode la següent lletra
+    // Comprovar si es el moment de explode la següent letter
     if (time_since_last_explosion_ >= DELAY_ENTRE_EXPLOSIONS) {
         if (letter_explosion_index_ < letters_.size()) {
-            // Explotar lletra actual (en ordre aleatori)
+            // Explotar letter actual (en ordre aleatori)
             size_t index_actual = explosion_order_[letter_explosion_index_];
-            const auto& lletra = letters_[index_actual];
+            const auto& letter = letters_[index_actual];
 
             debris_manager_->explode(
-                lletra.shape,           // Forma a explode
-                lletra.position,        // Posición
+                letter.shape,           // Forma a explode
+                letter.position,        // Posición
                 0.0F,                   // Angle (sin rotación)
                 FINAL_SCALE,            // Escala (lletres a scale final)
                 SPEED_EXPLOSIO,         // Velocidad base
@@ -203,9 +203,9 @@ void LogoScene::updateExplosions(float delta_time) {
                 {.x = 0.0F, .y = 0.0F}  // Sin velocity (per defecte)
             );
 
-            std::cout << "[LogoScene] Explota lletra " << letter_explosion_index_ << "\n";
+            std::cout << "[LogoScene] Explota letter " << letter_explosion_index_ << "\n";
 
-            // Passar a la següent lletra
+            // Passar a la següent letter
             letter_explosion_index_++;
             time_since_last_explosion_ = 0.0F;
         } else {
@@ -226,7 +226,7 @@ void LogoScene::update(float delta_time) {
             break;
 
         case AnimationState::ANIMATION: {
-            // Reproduir so per cada lletra cuando comença a aparèixer
+            // Reproduir so per cada letter cuando comença a aparèixer
             float global_progress = std::min(temps_current_state_ / DURATION_ZOOM, 1.0F);
 
             for (size_t i = 0; i < letters_.size() && i < sound_played_.size(); i++) {
@@ -237,7 +237,7 @@ void LogoScene::update(float delta_time) {
                         global_progress,
                         LETTER_THRESHOLD);
 
-                    // Reproduir so cuando la lletra comença a aparèixer (progress > 0)
+                    // Reproduir so cuando la letter comença a aparèixer (progress > 0)
                     if (letra_progress > 0.0F) {
                         Audio::get()->playSound(Defaults::Sound::LOGO, Audio::Group::GAME);
                         sound_played_[i] = true;
@@ -297,7 +297,7 @@ void LogoScene::draw() {
         const Vec2 ORIGEN_ZOOM = {.x = ORIGEN_ZOOM_X, .y = ORIGEN_ZOOM_Y};
 
         for (size_t i = 0; i < letters_.size(); i++) {
-            const auto& lletra = letters_[i];
+            const auto& letter = letters_[i];
 
             float letra_progress = computeLetterProgress(
                 i,
@@ -311,9 +311,9 @@ void LogoScene::draw() {
 
             Vec2 pos_actual;
             pos_actual.x =
-                ORIGEN_ZOOM.x + ((lletra.position.x - ORIGEN_ZOOM.x) * letra_progress);
+                ORIGEN_ZOOM.x + ((letter.position.x - ORIGEN_ZOOM.x) * letra_progress);
             pos_actual.y =
-                ORIGEN_ZOOM.y + ((lletra.position.y - ORIGEN_ZOOM.y) * letra_progress);
+                ORIGEN_ZOOM.y + ((letter.position.y - ORIGEN_ZOOM.y) * letra_progress);
 
             float t = letra_progress;
             float ease_factor = 1.0F - ((1.0F - t) * (1.0F - t));
@@ -322,7 +322,7 @@ void LogoScene::draw() {
 
             Rendering::renderShape(
                 sdl_.getRenderer(),
-                lletra.shape,
+                letter.shape,
                 pos_actual,
                 0.0F,
                 current_scale,
@@ -341,12 +341,12 @@ void LogoScene::draw() {
         // Dibuixar solo lletres que NO han explotat
         for (size_t i = 0; i < letters_.size(); i++) {
             if (!explotades.contains(i)) {
-                const auto& lletra = letters_[i];
+                const auto& letter = letters_[i];
 
                 Rendering::renderShape(
                     sdl_.getRenderer(),
-                    lletra.shape,
-                    lletra.position,
+                    letter.shape,
+                    letter.position,
                     0.0F,
                     FINAL_SCALE,
                     1.0F);