treballant en el LOGO

source/game/escenes/escena_joc.cpp

@@ -4,6 +4,7 @@
 
 #include "escena_joc.hpp"
 #include "../../core/system/gestor_escenes.hpp"
+#include "../../core/system/global_events.hpp"
 #include <cmath>
 #include <cstdlib>
 #include <ctime>
@@ -49,29 +50,13 @@ void EscenaJoc::executar() {
         continue;
       }
 
-      // Tecles globals de finestra (F1/F2/F3)
-      if (event.type == SDL_EVENT_KEY_DOWN) {
-        switch (event.key.key) {
-        case SDLK_F1:
-          sdl_.decreaseWindowSize();
-          continue;
-        case SDLK_F2:
-          sdl_.increaseWindowSize();
-          continue;
-        case SDLK_F3:
-          sdl_.toggleFullscreen();
-          continue;
-        }
+      // Events globals (F1/F2/F3/ESC/QUIT)
+      if (GlobalEvents::handle(event, sdl_)) {
+        continue;
       }
 
-      // Processament normal del joc
+      // Processament específic del joc (SPACE per disparar)
       processar_input(event);
-
-      // Detectar tancament de finestra o ESC
-      if (event.type == SDL_EVENT_QUIT ||
-          (event.type == SDL_EVENT_KEY_DOWN && event.key.key == SDLK_ESCAPE)) {
-        GestorEscenes::actual = GestorEscenes::Escena::EIXIR;
-      }
     }
 
     // Actualitzar física del joc amb delta_time real

source/game/escenes/escena_logo.cpp

@@ -3,11 +3,17 @@
 
 #include "escena_logo.hpp"
 #include "../../core/system/gestor_escenes.hpp"
+#include "../../core/system/global_events.hpp"
+#include "../../core/graphics/shape_loader.hpp"
+#include "../../core/rendering/shape_renderer.hpp"
 #include <iostream>
+#include <cfloat>
+#include <algorithm>
 
 EscenaLogo::EscenaLogo(SDLManager& sdl)
   : sdl_(sdl), temps_acumulat_(0.0f) {
   std::cout << "Escena Logo: Inicialitzant...\n";
+  inicialitzar_lletres();
 }
 
 void EscenaLogo::executar() {
@@ -32,34 +38,21 @@ void EscenaLogo::executar() {
         continue;
       }
 
-      // Tecles globals de finestra (F1/F2/F3)
-      if (event.type == SDL_EVENT_KEY_DOWN) {
-        switch (event.key.key) {
-        case SDLK_F1:
-          sdl_.decreaseWindowSize();
-          continue;
-        case SDLK_F2:
-          sdl_.increaseWindowSize();
-          continue;
-        case SDLK_F3:
-          sdl_.toggleFullscreen();
-          continue;
-        }
+      // Events globals (F1/F2/F3/ESC/QUIT)
+      if (GlobalEvents::handle(event, sdl_)) {
+        continue;
       }
 
-      // Processar events de l'escena
+      // Processar events de l'escena (qualsevol tecla/clic salta al joc)
       processar_events(event);
-
-      // ESC o tancar finestra = eixir
-      if (event.type == SDL_EVENT_QUIT ||
-          (event.type == SDL_EVENT_KEY_DOWN && event.key.key == SDLK_ESCAPE)) {
-        GestorEscenes::actual = GestorEscenes::Escena::EIXIR;
-      }
     }
 
     // Actualitzar lògica
     actualitzar(delta_time);
 
+    // Actualitzar colors oscil·lats (efecte verd global)
+    sdl_.updateColors(delta_time);
+
     // Dibuixar
     dibuixar();
   }
@@ -67,18 +60,117 @@ void EscenaLogo::executar() {
   std::cout << "Escena Logo: Finalitzant...\n";
 }
 
+void EscenaLogo::inicialitzar_lletres() {
+  using namespace Graphics;
+
+  // Llista de fitxers .shp (A repetida per a les dues A's)
+  std::vector<std::string> fitxers = {
+    "letra_j.shp", "letra_a.shp", "letra_i.shp", "letra_l.shp",
+    "letra_g.shp", "letra_a.shp", "letra_m.shp", "letra_e.shp", "letra_s.shp"
+  };
+
+  // Pas 1: Carregar totes les formes i calcular amplades
+  float ancho_total = 0.0f;
+
+  for (const auto& fitxer : fitxers) {
+    auto forma = ShapeLoader::load(fitxer);
+    if (!forma || !forma->es_valida()) {
+      std::cerr << "[EscenaLogo] Error carregant " << fitxer << std::endl;
+      continue;
+    }
+
+    // Calcular bounding box de la forma (trobar ancho)
+    float min_x = FLT_MAX;
+    float max_x = -FLT_MAX;
+
+    for (const auto& prim : forma->get_primitives()) {
+      for (const auto& punt : prim.points) {
+        min_x = std::min(min_x, punt.x);
+        max_x = std::max(max_x, punt.x);
+      }
+    }
+
+    float ancho = max_x - min_x;
+
+    lletres_.push_back({
+      forma,
+      {0.0f, 0.0f},  // Posició es calcularà després
+      ancho
+    });
+
+    ancho_total += ancho;
+  }
+
+  // Pas 2: Afegir espaiat entre lletres
+  ancho_total += ESPAI_ENTRE_LLETRES * (lletres_.size() - 1);
+
+  // Pas 3: Calcular posició inicial (centrat horitzontal)
+  constexpr float PANTALLA_ANCHO = 640.0f;
+  constexpr float PANTALLA_ALTO = 480.0f;
+
+  float x_inicial = (PANTALLA_ANCHO - ancho_total) / 2.0f;
+  float y_centre = PANTALLA_ALTO / 2.0f;
+
+  // Pas 4: Assignar posicions a cada lletra
+  float x_actual = x_inicial;
+
+  for (auto& lletra : lletres_) {
+    // Centre de la lletra en pantalla
+    lletra.posicio.x = x_actual + lletra.ancho / 2.0f;
+    lletra.posicio.y = y_centre;
+
+    // Avançar per a següent lletra
+    x_actual += lletra.ancho + ESPAI_ENTRE_LLETRES;
+  }
+
+  std::cout << "[EscenaLogo] " << lletres_.size()
+            << " lletres carregades, ancho total: " << ancho_total << " px\n";
+}
+
+float EscenaLogo::calcular_escala_zoom(float temps) const {
+  if (temps >= DURACIO_ZOOM) {
+    return ESCALA_FINAL;  // Animació acabada
+  }
+
+  // Progrés normalitzat (0.0 a 1.0)
+  float t = temps / DURACIO_ZOOM;
+
+  // Ease-out quadràtic: y = 1 - (1-t)^2
+  // Comença ràpid, acaba suau
+  float factor = 1.0f - (1.0f - t) * (1.0f - t);
+
+  // Interpolar entre escala inicial i final
+  return ESCALA_INICIAL + (ESCALA_FINAL - ESCALA_INICIAL) * factor;
+}
+
 void EscenaLogo::actualitzar(float delta_time) {
   temps_acumulat_ += delta_time;
 
-  // Després de 2 segons, saltar al joc
-  if (temps_acumulat_ >= 2.0f) {
+  // Després de DURACIO_TOTAL segons, saltar al joc
+  if (temps_acumulat_ >= DURACIO_TOTAL) {
     GestorEscenes::actual = GestorEscenes::Escena::JOC;
   }
 }
 
 void EscenaLogo::dibuixar() {
-  // Pantalla negra
+  // Fons negre
   sdl_.neteja(0, 0, 0);
+
+  // Calcular escala actual del zoom
+  float escala = calcular_escala_zoom(temps_acumulat_);
+
+  // Dibuixar cada lletra amb l'escala animada
+  for (const auto& lletra : lletres_) {
+    Rendering::render_shape(
+      sdl_.obte_renderer(),
+      lletra.forma,
+      lletra.posicio,      // Posició en pantalla
+      0.0f,                // Sense rotació
+      escala,              // Escala animada
+      true                 // Dibuixar
+    );
+  }
+
   sdl_.presenta();
 }
 

source/game/escenes/escena_logo.hpp

@@ -1,11 +1,15 @@
 // escena_logo.hpp - Pantalla d'inici del joc
-// Mostra pantalla negra durant 2 segons i salta al joc
+// Mostra logo JAILGAMES animat amb zoom i salta al joc
 // © 2025 Port a C++20
 
 #pragma once
 
 #include "../../core/rendering/sdl_manager.hpp"
+#include "../../core/graphics/shape.hpp"
+#include "../../core/types.hpp"
 #include <SDL3/SDL.h>
+#include <vector>
+#include <memory>
 
 class EscenaLogo {
 public:
@@ -16,6 +20,25 @@ private:
   SDLManager& sdl_;
   float temps_acumulat_;
 
+  // Estructura per a cada lletra del logo
+  struct LetraLogo {
+    std::shared_ptr<Graphics::Shape> forma;
+    Punt posicio;  // Posició final en pantalla
+    float ancho;   // Ancho per a càlcul de centrat
+  };
+
+  std::vector<LetraLogo> lletres_;  // 9 lletres: J-A-I-L-G-A-M-E-S
+
+  // Constants d'animació
+  static constexpr float DURACIO_ZOOM = 1.5f;      // Duració del zoom (segons)
+  static constexpr float DURACIO_TOTAL = 3.0f;     // Duració total abans d'anar al joc
+  static constexpr float ESCALA_INICIAL = 0.1f;    // Escala inicial (10%)
+  static constexpr float ESCALA_FINAL = 1.0f;      // Escala final (100%)
+  static constexpr float ESPAI_ENTRE_LLETRES = 10.0f;  // Espaiat entre lletres
+
+  // Mètodes privats
+  void inicialitzar_lletres();
+  float calcular_escala_zoom(float temps) const;
   void actualitzar(float delta_time);
   void dibuixar();
   void processar_events(const SDL_Event& event);