Lint: rename de locales (constants + const-ref vars)

Tanda de identifier-naming de variables y constantes locales a funciones
o archivos. Ninguno cross-file (los símbolos públicos quedan para una
pasada manual con VS Code).

- audio_adapter.cpp: path → PATH (const local en 3 funciones).
- vector_text.cpp: symbols → SYMBOLS, char_width_scaled → CHAR_WIDTH_SCALED,
  char_height_scaled → CHAR_HEIGHT_SCALED, spacing_scaled → SPACING_SCALED
  (const locales en render/renderCentered/get_text_width).
- physics_world.cpp: acceleration → ACCELERATION (const local en update).
- constants.hpp::dins_zona_joc: point → POINT.
- game_scene.cpp:
  - stepGameOver: game_over_text → GAME_OVER_TEXT.
  - dibuixar_marcador: scale/spacing → SCALE/SPACING (const), y la ref
    local 'scoreboard' (const SDL_FRect&) → 'scoreboard_zone' para no
    colisionar con Defaults::Zones::SCOREBOARD (las refs no son
    "constant" según el .clang-tidy y deben ser lower_case).
  - dibuixar_missatge_stage: max_width → MAX_WIDTH (const local).
  - dibuixar_continue: continue_text/counter_str/continues_text →
    UPPER_CASE.
- title_scene.cpp::draw (sección MAIN): spacing → SPACING, main_text →
  MAIN_TEXT, escala_main → MAIN_SCALE.
- shape_renderer.cpp: const Vec2& SHAPE_CENTRE → shape_centre (es ref,
  no constant).
- collision_system.cpp: const Vec2& POS_ENEMIC → enemy_pos (ref + traducción).
- init_hud_animator.cpp: refs ZONA → zone (en 2 funciones), SCOREBOARD →
  scoreboard_zone (sin colisionar con Defaults::Zones::SCOREBOARD).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

source/game/constants.hpp

@@ -27,8 +27,8 @@ constexpr float PI = Defaults::Math::PI;
 
 // Helpers per comprovar límits de zona
 inline auto dins_zona_joc(float x, float y) -> bool {
-    const SDL_FPoint point = {x, y};
-    return SDL_PointInRectFloat(&point, &Defaults::Zones::PLAYAREA);
+    const SDL_FPoint POINT = {x, y};
+    return SDL_PointInRectFloat(&POINT, &Defaults::Zones::PLAYAREA);
 }
 
 inline void obtenir_limits_zona(float& min_x, float& max_x, float& min_y, float& max_y) {

source/game/scenes/game_scene.cpp

@@ -527,7 +527,7 @@ void GameScene::draw() {
         floating_score_manager_.draw();
 
         // Draw centered "GAME OVER" text
-        const std::string game_over_text = "GAME OVER";
+        const std::string GAME_OVER_TEXT = "GAME OVER";
         constexpr float SCALE = Defaults::Game::GameOverScreen::TEXT_SCALE;
         constexpr float SPACING = Defaults::Game::GameOverScreen::TEXT_SPACING;
 
@@ -536,7 +536,7 @@ void GameScene::draw() {
         float centre_x = play_area.x + (play_area.w / 2.0F);
         float centre_y = play_area.y + (play_area.h / 2.0F);
 
-        text_.renderCentered(game_over_text, {.x = centre_x, .y = centre_y}, SCALE, SPACING);
+        text_.renderCentered(GAME_OVER_TEXT, {.x = centre_x, .y = centre_y}, SCALE, SPACING);
 
         dibuixar_marcador();
         return;
@@ -736,16 +736,16 @@ void GameScene::dibuixar_marcador() {
     std::string text = buildScoreboard();
 
     // Parámetros de renderització
-    const float scale = 0.85F;
-    const float spacing = 0.0F;
+    const float SCALE = 0.85F;
+    const float SPACING = 0.0F;
 
     // Calcular centro de la zona del marcador
-    const SDL_FRect& scoreboard = Defaults::Zones::SCOREBOARD;
-    float centre_x = scoreboard.w / 2.0F;
-    float centre_y = scoreboard.y + (scoreboard.h / 2.0F);
+    const SDL_FRect& scoreboard_zone = Defaults::Zones::SCOREBOARD;
+    float centre_x = scoreboard_zone.w / 2.0F;
+    float centre_y = scoreboard_zone.y + (scoreboard_zone.h / 2.0F);
 
     // Renderizar centrat
-    text_.renderCentered(text, {.x = centre_x, .y = centre_y}, scale, spacing);
+    text_.renderCentered(text, {.x = centre_x, .y = centre_y}, SCALE, SPACING);
 }
 
 auto GameScene::buildScoreboard() const -> std::string {
@@ -794,7 +794,7 @@ void GameScene::dibuixar_missatge_stage(const std::string& message) {
     constexpr float SPACING = 2.0F;
 
     const SDL_FRect& play_area = Defaults::Zones::PLAYAREA;
-    const float max_width = play_area.w * Defaults::Game::STAGE_MESSAGE_MAX_WIDTH_RATIO;
+    const float MAX_WIDTH = play_area.w * Defaults::Game::STAGE_MESSAGE_MAX_WIDTH_RATIO;
 
     // ========== TYPEWRITER EFFECT (PARAMETRIZED) ==========
     // Get state-specific timing configuration
@@ -837,9 +837,9 @@ void GameScene::dibuixar_missatge_stage(const std::string& message) {
     float text_width_at_base = text_.get_text_width(message, BASE_SCALE, SPACING);
 
     // Auto-scale if text exceeds max width
-    float scale = (text_width_at_base <= max_width)
+    float scale = (text_width_at_base <= MAX_WIDTH)
         ? BASE_SCALE
-        : max_width / text_width_at_base;
+        : MAX_WIDTH / text_width_at_base;
 
     // Recalculate dimensions with final scale (using FULL message for centering)
     float full_text_width = text_.get_text_width(message, scale, SPACING);
@@ -913,33 +913,33 @@ void GameScene::dibuixar_continue() {
     constexpr float SPACING = 4.0F;
 
     // "CONTINUE" text (using constants)
-    const std::string continue_text = "CONTINUE";
+    const std::string CONTINUE_TEXT = "CONTINUE";
     float escala_continue = Defaults::Game::ContinueScreen::CONTINUE_TEXT_SCALE;
     float y_ratio_continue = Defaults::Game::ContinueScreen::CONTINUE_TEXT_Y_RATIO;
 
     float centre_x = play_area.x + (play_area.w / 2.0F);
     float centre_y_continue = play_area.y + (play_area.h * y_ratio_continue);
 
-    text_.renderCentered(continue_text, {.x = centre_x, .y = centre_y_continue}, escala_continue, SPACING);
+    text_.renderCentered(CONTINUE_TEXT, {.x = centre_x, .y = centre_y_continue}, escala_continue, SPACING);
 
     // Countdown number (using constants)
-    const std::string counter_str = std::to_string(continue_counter_);
+    const std::string COUNTER_STR = std::to_string(continue_counter_);
     float escala_counter = Defaults::Game::ContinueScreen::COUNTER_TEXT_SCALE;
     float y_ratio_counter = Defaults::Game::ContinueScreen::COUNTER_TEXT_Y_RATIO;
 
     float centre_y_counter = play_area.y + (play_area.h * y_ratio_counter);
 
-    text_.renderCentered(counter_str, {.x = centre_x, .y = centre_y_counter}, escala_counter, SPACING);
+    text_.renderCentered(COUNTER_STR, {.x = centre_x, .y = centre_y_counter}, escala_counter, SPACING);
 
     // "CONTINUES LEFT" (conditional + using constants)
     if (!Defaults::Game::INFINITE_CONTINUES) {
-        const std::string continues_text = "CONTINUES LEFT: " + std::to_string(Defaults::Game::MAX_CONTINUES - continues_used_);
+        const std::string CONTINUES_TEXT = "CONTINUES LEFT: " + std::to_string(Defaults::Game::MAX_CONTINUES - continues_used_);
         float escala_info = Defaults::Game::ContinueScreen::INFO_TEXT_SCALE;
         float y_ratio_info = Defaults::Game::ContinueScreen::INFO_TEXT_Y_RATIO;
 
         float centre_y_info = play_area.y + (play_area.h * y_ratio_info);
 
-        text_.renderCentered(continues_text, {.x = centre_x, .y = centre_y_info}, escala_info, SPACING);
+        text_.renderCentered(CONTINUES_TEXT, {.x = centre_x, .y = centre_y_info}, escala_info, SPACING);
     }
 }
 

source/game/scenes/title_scene.cpp

@@ -676,7 +676,7 @@ void TitleScene::draw() {
         // En state MAIN: siempre visible
         // En state TRANSITION: parpellejant (blink con sinusoide)
 
-        const float spacing = Defaults::Title::Layout::TEXT_SPACING;
+        const float SPACING = Defaults::Title::Layout::TEXT_SPACING;
 
         bool mostrar_text = true;
         if (estat_actual_ == TitleState::PLAYER_JOIN_PHASE) {
@@ -686,16 +686,16 @@ void TitleScene::draw() {
         }
 
         if (mostrar_text) {
-            const std::string main_text = "PRESS START TO PLAY";
-            const float escala_main = Defaults::Title::Layout::PRESS_START_SCALE;
+            const std::string MAIN_TEXT = "PRESS START TO PLAY";
+            const float MAIN_SCALE = Defaults::Title::Layout::PRESS_START_SCALE;
 
             float centre_x = Defaults::Game::WIDTH / 2.0F;
             float centre_y = Defaults::Game::HEIGHT * Defaults::Title::Layout::PRESS_START_POS;
 
-            text_.renderCentered(main_text, {.x = centre_x, .y = centre_y}, escala_main, spacing);
+            text_.renderCentered(MAIN_TEXT, {.x = centre_x, .y = centre_y}, MAIN_SCALE, SPACING);
         }
 
-        dibuixarPeuTitol(spacing);
+        dibuixarPeuTitol(SPACING);
     }
 }
 

source/game/systems/collision_system.cpp

@@ -21,7 +21,7 @@ void detectBulletEnemy(Context& ctx) {
             }
 
             // *** COLISIÓN bullet → enemy ***
-            const Vec2& POS_ENEMIC = enemy.getCenter();
+            const Vec2& enemy_pos = enemy.getCenter();
 
             // 1. Puntos según tipo
             int points = 0;
@@ -39,7 +39,7 @@ void detectBulletEnemy(Context& ctx) {
 
             uint8_t owner_id = bullet.getOwnerId();
             ctx.score_per_player[owner_id] += points;
-            ctx.floating_score_manager.crear(points, POS_ENEMIC);
+            ctx.floating_score_manager.crear(points, enemy_pos);
 
             // 2. Destruir enemy + crear explosión (debris hereda color del enemy)
             SDL_Color enemy_color{};
@@ -52,7 +52,7 @@ void detectBulletEnemy(Context& ctx) {
             Vec2 vel_enemic = enemy.getVelocityVector();
             ctx.debris_manager.explode(
                 enemy.getShape(),
-                POS_ENEMIC,
+                enemy_pos,
                 0.0F,                  // angle (la rotación es interna del enemy)
                 1.0F,                  // escala
                 VELOCITAT_EXPLOSIO,

source/game/systems/init_hud_animator.cpp

@@ -31,21 +31,21 @@ auto computeRangeProgress(float global_progress,
 
 auto computeShipPosition(float progress, const Vec2& final_position) -> Vec2 {
     const float EASED = Easing::ease_out_quad(progress);
-    const SDL_FRect& ZONA = Defaults::Zones::PLAYAREA;
+    const SDL_FRect& zone = Defaults::Zones::PLAYAREA;
     // Y inicial: 50 px bajo la zona de juego.
-    const float Y_INI = ZONA.y + ZONA.h + 50.0F;
+    const float Y_INI = zone.y + zone.h + 50.0F;
     const float Y_ANIM = Y_INI + ((final_position.y - Y_INI) * EASED);
     return Vec2{.x = final_position.x, .y = Y_ANIM};
 }
 
 void drawBordersAnimated(Rendering::Renderer* renderer, float progress) {
-    const SDL_FRect& ZONA = Defaults::Zones::PLAYAREA;
+    const SDL_FRect& zone = Defaults::Zones::PLAYAREA;
     const float EASED = Easing::ease_out_quad(progress);
 
-    const int X1 = static_cast<int>(ZONA.x);
-    const int Y1 = static_cast<int>(ZONA.y);
-    const int X2 = static_cast<int>(ZONA.x + ZONA.w);
-    const int Y2 = static_cast<int>(ZONA.y + ZONA.h);
+    const int X1 = static_cast<int>(zone.x);
+    const int Y1 = static_cast<int>(zone.y);
+    const int X2 = static_cast<int>(zone.x + zone.w);
+    const int Y2 = static_cast<int>(zone.y + zone.h);
     const int CX = (X1 + X2) / 2;
 
     constexpr float PHASE_1_END = 0.33F;
@@ -85,9 +85,9 @@ void drawScoreboardAnimated(const Graphics::VectorText& text,
 
     constexpr float SCALE = 0.85F;
     constexpr float SPACING = 0.0F;
-    const SDL_FRect& SCOREBOARD = Defaults::Zones::SCOREBOARD;
-    const float CENTRE_X = SCOREBOARD.w / 2.0F;
-    const float Y_FINAL = SCOREBOARD.y + (SCOREBOARD.h / 2.0F);
+    const SDL_FRect& scoreboard_zone = Defaults::Zones::SCOREBOARD;
+    const float CENTRE_X = scoreboard_zone.w / 2.0F;
+    const float Y_FINAL = scoreboard_zone.y + (scoreboard_zone.h / 2.0F);
     // Posición inicial: fuera de la pantalla por debajo.
     const auto Y_INI = static_cast<float>(Defaults::Game::HEIGHT);
     const float Y_ANIM = Y_INI + ((Y_FINAL - Y_INI) * EASED);