colisions bala-enemic

.clang-format

@@ -0,0 +1,21 @@
+BasedOnStyle: Google
+IndentWidth: 4
+IndentAccessModifiers: true
+ColumnLimit: 0  # Sin límite de longitud de línea
+BreakBeforeBraces: Attach  # Llaves en la misma línea
+AllowShortIfStatementsOnASingleLine: true
+AllowShortBlocksOnASingleLine: true
+AllowShortFunctionsOnASingleLine: All
+AlignOperands: DontAlign
+AlignAfterOpenBracket: DontAlign
+BinPackArguments: false
+BinPackParameters: false
+ContinuationIndentWidth: 4
+ConstructorInitializerIndentWidth: 4
+IndentWrappedFunctionNames: false
+Cpp11BracedListStyle: true
+BreakConstructorInitializers: BeforeColon
+AllowAllConstructorInitializersOnNextLine: false
+PackConstructorInitializers: Never
+AllowAllArgumentsOnNextLine: false
+AllowAllParametersOfDeclarationOnNextLine: false

CMakeLists.txt

@@ -1,7 +1,7 @@
 # CMakeLists.txt
 
 cmake_minimum_required(VERSION 3.10)
-project(orni VERSION 0.1.0)
+project(orni VERSION 0.2.0)
 
 # Info del proyecto
 set(PROJECT_LONG_NAME "Orni Attack")
@@ -51,6 +51,7 @@ set(APP_SOURCES
     source/game/entities/nau.cpp
     source/game/entities/bala.cpp
     source/game/entities/enemic.cpp
+    source/game/effects/debris_manager.cpp
 )
 
 # Configuración de SDL3

Makefile

@@ -50,7 +50,8 @@ APP_SOURCES := \
     source/game/escenes/escena_joc.cpp \
     source/game/entities/nau.cpp \
     source/game/entities/bala.cpp \
-    source/game/entities/enemic.cpp
+    source/game/entities/enemic.cpp \
+    source/game/effects/debris_manager.cpp
 
 # ==============================================================================
 # INCLUDES

source/core/rendering/sdl_manager.cpp

@@ -2,302 +2,364 @@
 // © 2025 Port a C++20 amb SDL3
 
 #include "sdl_manager.hpp"
-#include "core/defaults.hpp"
+
-#include "core/rendering/line_renderer.hpp"
-#include "game/options.hpp"
-#include "project.h"
 #include <algorithm>
 #include <format>
 #include <iostream>
 
+#include "core/defaults.hpp"
+#include "core/rendering/line_renderer.hpp"
+#include "game/options.hpp"
+#include "project.h"
+
 SDLManager::SDLManager()
-    : finestra_(nullptr), renderer_(nullptr),
+    : finestra_(nullptr),
+      renderer_(nullptr),
+      fps_accumulator_(0.0f),
+      fps_frame_count_(0),
+      fps_display_(0),
       current_width_(Defaults::Window::WIDTH),
-      current_height_(Defaults::Window::HEIGHT), is_fullscreen_(false),
+      current_height_(Defaults::Window::HEIGHT),
-      max_width_(1920), max_height_(1080) {
+      is_fullscreen_(false),
-  // Inicialitzar SDL3
+      max_width_(1920),
-  if (!SDL_Init(SDL_INIT_VIDEO)) {
+      max_height_(1080) {
-    std::cerr << "Error inicialitzant SDL3: " << SDL_GetError() << std::endl;
+    // Inicialitzar SDL3
-    return;
+    if (!SDL_Init(SDL_INIT_VIDEO)) {
-  }
+        std::cerr << "Error inicialitzant SDL3: " << SDL_GetError() << std::endl;
+        return;
+    }
 
-  // Calcular mida màxima des del display
+    // Calcular mida màxima des del display
-  calculateMaxWindowSize();
+    calculateMaxWindowSize();
 
-  // Construir títol dinàmic igual que en pollo
+    // Construir títol dinàmic
-  std::string window_title = std::format("{} v{} ({})", Project::LONG_NAME,
+    std::string window_title = std::format("{} v{} ({})", Project::LONG_NAME, Project::VERSION, Project::COPYRIGHT);
-                                         Project::VERSION, Project::COPYRIGHT);
 
-  // Crear finestra CENTRADA (SDL ho fa automàticament amb CENTERED)
+    // Crear finestra CENTRADA (SDL ho fa automàticament amb CENTERED)
-  finestra_ =
+    finestra_ =
-      SDL_CreateWindow(window_title.c_str(), current_width_, current_height_,
+        SDL_CreateWindow(window_title.c_str(), current_width_, current_height_,
-                       SDL_WINDOW_RESIZABLE // Permetre resize manual també
+            SDL_WINDOW_RESIZABLE  // Permetre resize manual també
-      );
+        );
 
-  if (!finestra_) {
+    if (!finestra_) {
-    std::cerr << "Error creant finestra: " << SDL_GetError() << std::endl;
+        std::cerr << "Error creant finestra: " << SDL_GetError() << std::endl;
-    SDL_Quit();
+        SDL_Quit();
-    return;
+        return;
-  }
+    }
 
-  // IMPORTANT: Centrar explícitament la finestra
+    // IMPORTANT: Centrar explícitament la finestra
-  SDL_SetWindowPosition(finestra_, SDL_WINDOWPOS_CENTERED,
+    SDL_SetWindowPosition(finestra_, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
-                        SDL_WINDOWPOS_CENTERED);
 
-  // Crear renderer amb acceleració
+    // Crear renderer amb acceleració
-  renderer_ = SDL_CreateRenderer(finestra_, nullptr);
+    renderer_ = SDL_CreateRenderer(finestra_, nullptr);
 
-  if (!renderer_) {
+    if (!renderer_) {
-    std::cerr << "Error creant renderer: " << SDL_GetError() << std::endl;
+        std::cerr << "Error creant renderer: " << SDL_GetError() << std::endl;
-    SDL_DestroyWindow(finestra_);
+        SDL_DestroyWindow(finestra_);
-    SDL_Quit();
+        SDL_Quit();
-    return;
+        return;
-  }
+    }
 
-  // CRÍTIC: Configurar viewport scaling
+    // Aplicar configuració de V-Sync
-  updateLogicalPresentation();
+    SDL_SetRenderVSync(renderer_, Options::rendering.vsync);
 
-  std::cout << "SDL3 inicialitzat: " << current_width_ << "x" << current_height_
+    // CRÍTIC: Configurar viewport scaling
-            << " (logic: " << Defaults::Game::WIDTH << "x"
+    updateLogicalPresentation();
-            << Defaults::Game::HEIGHT << ")" << std::endl;
+
+    std::cout << "SDL3 inicialitzat: " << current_width_ << "x" << current_height_
+              << " (logic: " << Defaults::Game::WIDTH << "x"
+              << Defaults::Game::HEIGHT << ")" << std::endl;
 }
 
 // Constructor amb configuració
 SDLManager::SDLManager(int width, int height, bool fullscreen)
-    : finestra_(nullptr), renderer_(nullptr), current_width_(width),
+    : finestra_(nullptr),
-      current_height_(height), is_fullscreen_(fullscreen), max_width_(1920),
+      renderer_(nullptr),
+      fps_accumulator_(0.0f),
+      fps_frame_count_(0),
+      fps_display_(0),
+      current_width_(width),
+      current_height_(height),
+      is_fullscreen_(fullscreen),
+      max_width_(1920),
       max_height_(1080) {
-  // Inicialitzar SDL3
+    // Inicialitzar SDL3
-  if (!SDL_Init(SDL_INIT_VIDEO)) {
+    if (!SDL_Init(SDL_INIT_VIDEO)) {
-    std::cerr << "Error inicialitzant SDL3: " << SDL_GetError() << std::endl;
+        std::cerr << "Error inicialitzant SDL3: " << SDL_GetError() << std::endl;
-    return;
+        return;
-  }
+    }
 
-  // Calcular mida màxima des del display
+    // Calcular mida màxima des del display
-  calculateMaxWindowSize();
+    calculateMaxWindowSize();
 
-  // Construir títol dinàmic
+    // Construir títol dinàmic
-  std::string window_title = std::format("{} v{} ({})", Project::LONG_NAME,
+    std::string window_title = std::format("{} v{} ({})", Project::LONG_NAME, Project::VERSION, Project::COPYRIGHT);
-                                         Project::VERSION, Project::COPYRIGHT);
 
-  // Configurar flags de la finestra
+    // Configurar flags de la finestra
-  SDL_WindowFlags flags = SDL_WINDOW_RESIZABLE;
+    SDL_WindowFlags flags = SDL_WINDOW_RESIZABLE;
-  if (is_fullscreen_) {
+    if (is_fullscreen_) {
-    flags = static_cast<SDL_WindowFlags>(flags | SDL_WINDOW_FULLSCREEN);
+        flags = static_cast<SDL_WindowFlags>(flags | SDL_WINDOW_FULLSCREEN);
-  }
+    }
 
-  // Crear finestra
+    // Crear finestra
-  finestra_ = SDL_CreateWindow(window_title.c_str(), current_width_,
+    finestra_ = SDL_CreateWindow(window_title.c_str(), current_width_, current_height_, flags);
-                               current_height_, flags);
 
-  if (!finestra_) {
+    if (!finestra_) {
-    std::cerr << "Error creant finestra: " << SDL_GetError() << std::endl;
+        std::cerr << "Error creant finestra: " << SDL_GetError() << std::endl;
-    SDL_Quit();
+        SDL_Quit();
-    return;
+        return;
-  }
+    }
 
-  // Centrar explícitament la finestra (si no és fullscreen)
+    // Centrar explícitament la finestra (si no és fullscreen)
-  if (!is_fullscreen_) {
+    if (!is_fullscreen_) {
-    SDL_SetWindowPosition(finestra_, SDL_WINDOWPOS_CENTERED,
+        SDL_SetWindowPosition(finestra_, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
-                          SDL_WINDOWPOS_CENTERED);
+    }
-  }
 
-  // Crear renderer amb acceleració
+    // Crear renderer amb acceleració
-  renderer_ = SDL_CreateRenderer(finestra_, nullptr);
+    renderer_ = SDL_CreateRenderer(finestra_, nullptr);
 
-  if (!renderer_) {
+    if (!renderer_) {
-    std::cerr << "Error creant renderer: " << SDL_GetError() << std::endl;
+        std::cerr << "Error creant renderer: " << SDL_GetError() << std::endl;
-    SDL_DestroyWindow(finestra_);
+        SDL_DestroyWindow(finestra_);
-    SDL_Quit();
+        SDL_Quit();
-    return;
+        return;
-  }
+    }
 
-  // Configurar viewport scaling
+    // Aplicar configuració de V-Sync
-  updateLogicalPresentation();
+    SDL_SetRenderVSync(renderer_, Options::rendering.vsync);
 
-  std::cout << "SDL3 inicialitzat: " << current_width_ << "x" << current_height_
+    // Configurar viewport scaling
-            << " (logic: " << Defaults::Game::WIDTH << "x"
+    updateLogicalPresentation();
-            << Defaults::Game::HEIGHT << ")";
+
-  if (is_fullscreen_) {
+    std::cout << "SDL3 inicialitzat: " << current_width_ << "x" << current_height_
-    std::cout << " [FULLSCREEN]";
+              << " (logic: " << Defaults::Game::WIDTH << "x"
-  }
+              << Defaults::Game::HEIGHT << ")";
-  std::cout << std::endl;
+    if (is_fullscreen_) {
+        std::cout << " [FULLSCREEN]";
+    }
+    std::cout << std::endl;
 }
 
 SDLManager::~SDLManager() {
-  if (renderer_) {
+    if (renderer_) {
-    SDL_DestroyRenderer(renderer_);
+        SDL_DestroyRenderer(renderer_);
-    renderer_ = nullptr;
+        renderer_ = nullptr;
-  }
+    }
 
-  if (finestra_) {
+    if (finestra_) {
-    SDL_DestroyWindow(finestra_);
+        SDL_DestroyWindow(finestra_);
-    finestra_ = nullptr;
+        finestra_ = nullptr;
-  }
+    }
 
-  SDL_Quit();
+    SDL_Quit();
-  std::cout << "SDL3 netejat correctament" << std::endl;
+    std::cout << "SDL3 netejat correctament" << std::endl;
 }
 
 void SDLManager::calculateMaxWindowSize() {
-  SDL_DisplayID display = SDL_GetPrimaryDisplay();
+    SDL_DisplayID display = SDL_GetPrimaryDisplay();
-  const SDL_DisplayMode *mode = SDL_GetCurrentDisplayMode(display);
+    const SDL_DisplayMode* mode = SDL_GetCurrentDisplayMode(display);
 
-  if (mode) {
+    if (mode) {
-    // Deixar marge de 100px per a decoracions de l'OS
+        // Deixar marge de 100px per a decoracions de l'OS
-    max_width_ = mode->w - 100;
+        max_width_ = mode->w - 100;
-    max_height_ = mode->h - 100;
+        max_height_ = mode->h - 100;
-    std::cout << "Display detectat: " << mode->w << "x" << mode->h
+        std::cout << "Display detectat: " << mode->w << "x" << mode->h
-              << " (max finestra: " << max_width_ << "x" << max_height_ << ")"
+                  << " (max finestra: " << max_width_ << "x" << max_height_ << ")"
-              << std::endl;
+                  << std::endl;
-  } else {
+    } else {
-    // Fallback conservador
+        // Fallback conservador
-    max_width_ = 1920;
+        max_width_ = 1920;
-    max_height_ = 1080;
+        max_height_ = 1080;
-    std::cerr << "No s'ha pogut detectar el display, usant fallback: "
+        std::cerr << "No s'ha pogut detectar el display, usant fallback: "
-              << max_width_ << "x" << max_height_ << std::endl;
+                  << max_width_ << "x" << max_height_ << std::endl;
-  }
+    }
 }
 
 void SDLManager::updateLogicalPresentation() {
-  // AIXÒ ÉS LA MÀGIA: El joc SEMPRE dibuixa en 640x480,
+    // AIXÒ ÉS LA MÀGIA: El joc SEMPRE dibuixa en 640x480,
-  // SDL escala automàticament a la mida física de la finestra
+    // SDL escala automàticament a la mida física de la finestra
-  SDL_SetRenderLogicalPresentation(
+    SDL_SetRenderLogicalPresentation(
-      renderer_,
+        renderer_,
-      Defaults::Game::WIDTH,             // 640 (lògic)
+        Defaults::Game::WIDTH,              // 640 (lògic)
-      Defaults::Game::HEIGHT,            // 480 (lògic)
+        Defaults::Game::HEIGHT,             // 480 (lògic)
-      SDL_LOGICAL_PRESENTATION_LETTERBOX // Mantenir aspect ratio 4:3
+        SDL_LOGICAL_PRESENTATION_LETTERBOX  // Mantenir aspect ratio 4:3
-  );
+    );
 }
 
 void SDLManager::increaseWindowSize() {
-  if (is_fullscreen_)
+    if (is_fullscreen_)
-    return; // No operar en fullscreen
+        return;  // No operar en fullscreen
 
-  int new_width = current_width_ + Defaults::Window::SIZE_INCREMENT;
+    int new_width = current_width_ + Defaults::Window::SIZE_INCREMENT;
-  int new_height = current_height_ + Defaults::Window::SIZE_INCREMENT;
+    int new_height = current_height_ + Defaults::Window::SIZE_INCREMENT;
 
-  // Clamp a màxim
+    // Clamp a màxim
-  new_width = std::min(new_width, max_width_);
+    new_width = std::min(new_width, max_width_);
-  new_height = std::min(new_height, max_height_);
+    new_height = std::min(new_height, max_height_);
 
-  if (new_width != current_width_ || new_height != current_height_) {
+    if (new_width != current_width_ || new_height != current_height_) {
-    applyWindowSize(new_width, new_height);
+        applyWindowSize(new_width, new_height);
 
-    // Persistir canvis a Options (es guardarà a config.yaml al tancar)
+        // Persistir canvis a Options (es guardarà a config.yaml al tancar)
-    Options::window.width = current_width_;
+        Options::window.width = current_width_;
-    Options::window.height = current_height_;
+        Options::window.height = current_height_;
 
-    std::cout << "F2: Finestra augmentada a " << new_width << "x" << new_height
+        std::cout << "F2: Finestra augmentada a " << new_width << "x" << new_height
-              << std::endl;
+                  << std::endl;
-  }
+    }
 }
 
 void SDLManager::decreaseWindowSize() {
-  if (is_fullscreen_)
+    if (is_fullscreen_)
-    return;
+        return;
 
-  int new_width = current_width_ - Defaults::Window::SIZE_INCREMENT;
+    int new_width = current_width_ - Defaults::Window::SIZE_INCREMENT;
-  int new_height = current_height_ - Defaults::Window::SIZE_INCREMENT;
+    int new_height = current_height_ - Defaults::Window::SIZE_INCREMENT;
 
-  // Clamp a mínim
+    // Clamp a mínim
-  new_width = std::max(new_width, Defaults::Window::MIN_WIDTH);
+    new_width = std::max(new_width, Defaults::Window::MIN_WIDTH);
-  new_height = std::max(new_height, Defaults::Window::MIN_HEIGHT);
+    new_height = std::max(new_height, Defaults::Window::MIN_HEIGHT);
 
-  if (new_width != current_width_ || new_height != current_height_) {
+    if (new_width != current_width_ || new_height != current_height_) {
-    applyWindowSize(new_width, new_height);
+        applyWindowSize(new_width, new_height);
 
-    // Persistir canvis a Options (es guardarà a config.yaml al tancar)
+        // Persistir canvis a Options (es guardarà a config.yaml al tancar)
-    Options::window.width = current_width_;
+        Options::window.width = current_width_;
-    Options::window.height = current_height_;
+        Options::window.height = current_height_;
 
-    std::cout << "F1: Finestra reduïda a " << new_width << "x" << new_height
+        std::cout << "F1: Finestra reduïda a " << new_width << "x" << new_height
-              << std::endl;
+                  << std::endl;
-  }
+    }
 }
 
 void SDLManager::applyWindowSize(int new_width, int new_height) {
-  // Obtenir posició actual ABANS del resize
+    // Obtenir posició actual ABANS del resize
-  int old_x, old_y;
+    int old_x, old_y;
-  SDL_GetWindowPosition(finestra_, &old_x, &old_y);
+    SDL_GetWindowPosition(finestra_, &old_x, &old_y);
 
-  int old_width = current_width_;
+    int old_width = current_width_;
-  int old_height = current_height_;
+    int old_height = current_height_;
 
-  // Actualitzar mida
+    // Actualitzar mida
-  SDL_SetWindowSize(finestra_, new_width, new_height);
+    SDL_SetWindowSize(finestra_, new_width, new_height);
-  current_width_ = new_width;
+    current_width_ = new_width;
-  current_height_ = new_height;
+    current_height_ = new_height;
 
-  // CENTRADO INTEL·LIGENT (algoritme de pollo)
+    // CENTRADO INTEL·LIGENT (algoritme de pollo)
-  // Calcular nova posició per mantenir la finestra centrada sobre si mateixa
+    // Calcular nova posició per mantenir la finestra centrada sobre si mateixa
-  int delta_width = old_width - new_width;
+    int delta_width = old_width - new_width;
-  int delta_height = old_height - new_height;
+    int delta_height = old_height - new_height;
 
-  int new_x = old_x + (delta_width / 2);
+    int new_x = old_x + (delta_width / 2);
-  int new_y = old_y + (delta_height / 2);
+    int new_y = old_y + (delta_height / 2);
 
-  // Evitar que la finestra surti de la pantalla
+    // Evitar que la finestra surti de la pantalla
-  constexpr int TITLEBAR_HEIGHT = 35; // Alçada aproximada de la barra de títol
+    constexpr int TITLEBAR_HEIGHT = 35;  // Alçada aproximada de la barra de títol
-  new_x = std::max(new_x, 0);
+    new_x = std::max(new_x, 0);
-  new_y = std::max(new_y, TITLEBAR_HEIGHT);
+    new_y = std::max(new_y, TITLEBAR_HEIGHT);
 
-  SDL_SetWindowPosition(finestra_, new_x, new_y);
+    SDL_SetWindowPosition(finestra_, new_x, new_y);
 
-  // NO cal actualitzar el logical presentation aquí,
+    // NO cal actualitzar el logical presentation aquí,
-  // SDL ho maneja automàticament
+    // SDL ho maneja automàticament
 }
 
 void SDLManager::toggleFullscreen() {
-  is_fullscreen_ = !is_fullscreen_;
+    is_fullscreen_ = !is_fullscreen_;
-  SDL_SetWindowFullscreen(finestra_, is_fullscreen_);
+    SDL_SetWindowFullscreen(finestra_, is_fullscreen_);
 
-  // Persistir canvis a Options (es guardarà a config.yaml al tancar)
+    // Persistir canvis a Options (es guardarà a config.yaml al tancar)
-  Options::window.fullscreen = is_fullscreen_;
+    Options::window.fullscreen = is_fullscreen_;
 
-  std::cout << "F3: Fullscreen " << (is_fullscreen_ ? "activat" : "desactivat")
+    std::cout << "F3: Fullscreen " << (is_fullscreen_ ? "activat" : "desactivat")
-            << std::endl;
+              << std::endl;
 
-  // En fullscreen, SDL gestiona tot automàticament
+    // En fullscreen, SDL gestiona tot automàticament
-  // En sortir, restaura la mida anterior
+    // En sortir, restaura la mida anterior
 }
 
-bool SDLManager::handleWindowEvent(const SDL_Event &event) {
+bool SDLManager::handleWindowEvent(const SDL_Event& event) {
-  if (event.type == SDL_EVENT_WINDOW_RESIZED) {
+    if (event.type == SDL_EVENT_WINDOW_RESIZED) {
-    // Usuari ha redimensionat manualment (arrossegar vora)
+        // Usuari ha redimensionat manualment (arrossegar vora)
-    // Actualitzar el nostre tracking
+        // Actualitzar el nostre tracking
-    SDL_GetWindowSize(finestra_, &current_width_, &current_height_);
+        SDL_GetWindowSize(finestra_, &current_width_, &current_height_);
-    std::cout << "Finestra redimensionada manualment a " << current_width_
+        std::cout << "Finestra redimensionada manualment a " << current_width_
-              << "x" << current_height_ << std::endl;
+                  << "x" << current_height_ << std::endl;
-    return true;
+        return true;
-  }
+    }
-  return false;
+    return false;
 }
 
 void SDLManager::neteja(uint8_t r, uint8_t g, uint8_t b) {
-  if (!renderer_)
+    if (!renderer_)
-    return;
+        return;
 
-  // [MODIFICAT] Usar color oscil·lat del fons en lloc dels paràmetres
+    // [MODIFICAT] Usar color oscil·lat del fons en lloc dels paràmetres
-  (void)r;
+    (void)r;
-  (void)g;
+    (void)g;
-  (void)b; // Suprimir warnings
+    (void)b;  // Suprimir warnings
-  SDL_Color bg = color_oscillator_.getCurrentBackgroundColor();
+    SDL_Color bg = color_oscillator_.getCurrentBackgroundColor();
-  SDL_SetRenderDrawColor(renderer_, bg.r, bg.g, bg.b, 255);
+    SDL_SetRenderDrawColor(renderer_, bg.r, bg.g, bg.b, 255);
-  SDL_RenderClear(renderer_);
+    SDL_RenderClear(renderer_);
 }
 
 void SDLManager::presenta() {
-  if (!renderer_)
+    if (!renderer_)
-    return;
+        return;
 
-  SDL_RenderPresent(renderer_);
+    SDL_RenderPresent(renderer_);
 }
 
 // [NUEVO] Actualitzar colors amb oscil·lació
 void SDLManager::updateColors(float delta_time) {
-  color_oscillator_.update(delta_time);
+    color_oscillator_.update(delta_time);
 
-  // Actualitzar color global de línies
+    // Actualitzar color global de línies
-  Rendering::setLineColor(color_oscillator_.getCurrentLineColor());
+    Rendering::setLineColor(color_oscillator_.getCurrentLineColor());
+}
+
+// [NUEVO] Actualitzar comptador de FPS
+void SDLManager::updateFPS(float delta_time) {
+    // Acumular temps i frames
+    fps_accumulator_ += delta_time;
+    fps_frame_count_++;
+
+    // Actualitzar display cada 0.5 segons
+    if (fps_accumulator_ >= 0.5f) {
+        fps_display_ = static_cast<int>(fps_frame_count_ / fps_accumulator_);
+        fps_frame_count_ = 0;
+        fps_accumulator_ = 0.0f;
+
+        // Actualitzar títol de la finestra
+        std::string title = std::format("{} v{} ({}) - {} FPS",
+            Project::LONG_NAME,
+            Project::VERSION,
+            Project::COPYRIGHT,
+            fps_display_);
+
+        if (finestra_) {
+            SDL_SetWindowTitle(finestra_, title.c_str());
+        }
+    }
+}
+
+// [NUEVO] Actualitzar títol de la finestra
+void SDLManager::setWindowTitle(const std::string& title) {
+    if (finestra_) {
+        SDL_SetWindowTitle(finestra_, title.c_str());
+    }
+}
+
+// [NUEVO] Toggle V-Sync (F4)
+void SDLManager::toggleVSync() {
+    // Toggle: 1 → 0 → 1
+    Options::rendering.vsync = (Options::rendering.vsync == 1) ? 0 : 1;
+
+    // Aplicar a SDL
+    if (renderer_) {
+        SDL_SetRenderVSync(renderer_, Options::rendering.vsync);
+    }
+
+    // Guardar configuració
+    Options::saveToFile();
 }

source/core/rendering/sdl_manager.hpp

@@ -5,55 +5,70 @@
 #define SDL_MANAGER_HPP
 
 #include <SDL3/SDL.h>
+
 #include <cstdint>
+#include <string>
+
 #include "core/rendering/color_oscillator.hpp"
 
 class SDLManager {
-public:
+    public:
-  SDLManager(); // Constructor per defecte (usa Defaults::)
+        SDLManager();  // Constructor per defecte (usa Defaults::)
-  SDLManager(int width, int height,
+        SDLManager(int width, int height,
-             bool fullscreen); // Constructor amb configuració
+            bool fullscreen);  // Constructor amb configuració
-  ~SDLManager();
+        ~SDLManager();
 
-  // No permetre còpia ni assignació
+        // No permetre còpia ni assignació
-  SDLManager(const SDLManager &) = delete;
+        SDLManager(const SDLManager&) = delete;
-  SDLManager &operator=(const SDLManager &) = delete;
+        SDLManager& operator=(const SDLManager&) = delete;
 
-  // [NUEVO] Gestió de finestra dinàmica
+        // [NUEVO] Gestió de finestra dinàmica
-  void increaseWindowSize(); // F2: +100px
+        void increaseWindowSize();  // F2: +100px
-  void decreaseWindowSize(); // F1: -100px
+        void decreaseWindowSize();  // F1: -100px
-  void toggleFullscreen();   // F3
+        void toggleFullscreen();    // F3
-  bool
+        void toggleVSync();         // F4
-  handleWindowEvent(const SDL_Event &event); // Per a SDL_EVENT_WINDOW_RESIZED
+        bool
+        handleWindowEvent(const SDL_Event& event);  // Per a SDL_EVENT_WINDOW_RESIZED
 
-  // Funcions principals (renderitzat)
+        // Funcions principals (renderitzat)
-  void neteja(uint8_t r = 0, uint8_t g = 0, uint8_t b = 0);
+        void neteja(uint8_t r = 0, uint8_t g = 0, uint8_t b = 0);
-  void presenta();
+        void presenta();
 
-  // [NUEVO] Actualització de colors (oscil·lació)
+        // [NUEVO] Actualització de colors (oscil·lació)
-  void updateColors(float delta_time);
+        void updateColors(float delta_time);
 
-  // Getters
+        // [NUEVO] Actualitzar comptador de FPS
-  SDL_Renderer *obte_renderer() { return renderer_; }
+        void updateFPS(float delta_time);
 
-private:
+        // Getters
-  SDL_Window *finestra_;
+        SDL_Renderer* obte_renderer() { return renderer_; }
-  SDL_Renderer *renderer_;
 
-  // [NUEVO] Estat de la finestra
+        // [NUEVO] Actualitzar títol de la finestra
-  int current_width_; // Mida física actual
+        void setWindowTitle(const std::string& title);
-  int current_height_;
-  bool is_fullscreen_;
-  int max_width_; // Calculat des del display
-  int max_height_;
 
-  // [NUEVO] Funcions internes
+    private:
-  void calculateMaxWindowSize();               // Llegir resolució del display
+        SDL_Window* finestra_;
-  void applyWindowSize(int width, int height); // Canviar mida + centrar
+        SDL_Renderer* renderer_;
-  void updateLogicalPresentation();            // Actualitzar viewport
 
-  // [NUEVO] Oscil·lador de colors
+        // [NUEVO] Variables FPS
-  Rendering::ColorOscillator color_oscillator_;
+        float fps_accumulator_;
+        int fps_frame_count_;
+        int fps_display_;
+
+        // [NUEVO] Estat de la finestra
+        int current_width_;  // Mida física actual
+        int current_height_;
+        bool is_fullscreen_;
+        int max_width_;  // Calculat des del display
+        int max_height_;
+
+        // [NUEVO] Funcions internes
+        void calculateMaxWindowSize();                // Llegir resolució del display
+        void applyWindowSize(int width, int height);  // Canviar mida + centrar
+        void updateLogicalPresentation();             // Actualitzar viewport
+
+        // [NUEVO] Oscil·lador de colors
+        Rendering::ColorOscillator color_oscillator_;
 };
 
-#endif // SDL_MANAGER_HPP
+#endif  // SDL_MANAGER_HPP

source/external/.clang-format

@@ -0,0 +1,2 @@
+DisableFormat: true
+SortIncludes: Never

source/game/constants.hpp

@@ -7,10 +7,12 @@
 
 namespace Constants {
 // Marges de l'àrea de joc (derivats de Defaults::Zones::GAME)
-constexpr int MARGE_ESQ = static_cast<int>(Defaults::Zones::GAME.x);
+constexpr int MARGE_ESQ = static_cast<int>(Defaults::Zones::PLAYAREA.x);
-constexpr int MARGE_DRET = static_cast<int>(Defaults::Zones::GAME.x + Defaults::Zones::GAME.w);
+constexpr int MARGE_DRET =
-constexpr int MARGE_DALT = static_cast<int>(Defaults::Zones::GAME.y);
+    static_cast<int>(Defaults::Zones::PLAYAREA.x + Defaults::Zones::PLAYAREA.w);
-constexpr int MARGE_BAIX = static_cast<int>(Defaults::Zones::GAME.y + Defaults::Zones::GAME.h);
+constexpr int MARGE_DALT = static_cast<int>(Defaults::Zones::PLAYAREA.y);
+constexpr int MARGE_BAIX =
+    static_cast<int>(Defaults::Zones::PLAYAREA.y + Defaults::Zones::PLAYAREA.h);
 
 // Límits de polígons i objectes
 constexpr int MAX_IPUNTS = Defaults::Entities::MAX_IPUNTS;
@@ -26,15 +28,34 @@ constexpr float PI = Defaults::Math::PI;
 
 // Helpers per comprovar límits de zona
 inline bool dins_zona_joc(float x, float y) {
-  const SDL_FPoint punt = {x, y};
+    const SDL_FPoint punt = {x, y};
-  return SDL_PointInRectFloat(&punt, &Defaults::Zones::GAME);
+    return SDL_PointInRectFloat(&punt, &Defaults::Zones::PLAYAREA);
 }
 
 inline void obtenir_limits_zona(float& min_x, float& max_x, float& min_y, float& max_y) {
-  const auto& zona = Defaults::Zones::GAME;
+    const auto& zona = Defaults::Zones::PLAYAREA;
-  min_x = zona.x;
+    min_x = zona.x;
-  max_x = zona.x + zona.w;
+    max_x = zona.x + zona.w;
-  min_y = zona.y;
+    min_y = zona.y;
-  max_y = zona.y + zona.h;
+    max_y = zona.y + zona.h;
 }
-} // namespace Constants
+
+// Obtenir límits segurs (compensant radi de l'entitat)
+inline void obtenir_limits_zona_segurs(float radi, float& min_x, float& max_x,
+                                       float& min_y, float& max_y) {
+    const auto& zona = Defaults::Zones::PLAYAREA;
+    constexpr float MARGE_SEGURETAT = 10.0f;  // Safety margin
+
+    min_x = zona.x + radi + MARGE_SEGURETAT;
+    max_x = zona.x + zona.w - radi - MARGE_SEGURETAT;
+    min_y = zona.y + radi + MARGE_SEGURETAT;
+    max_y = zona.y + zona.h - radi - MARGE_SEGURETAT;
+}
+
+// Obtenir centre de l'àrea de joc
+inline void obtenir_centre_zona(float& centre_x, float& centre_y) {
+    const auto& zona = Defaults::Zones::PLAYAREA;
+    centre_x = zona.x + zona.w / 2.0f;
+    centre_y = zona.y + zona.h / 2.0f;
+}
+}  // namespace Constants

source/game/effects/debris.hpp

@@ -0,0 +1,33 @@
+// debris.hpp - Fragment de línia volant (explosió de formes)
+// © 2025 Port a C++20 amb SDL3
+
+#pragma once
+#include "core/types.hpp"
+
+namespace Effects {
+
+// Debris: un segment de línia que vola perpendicular a sí mateix
+// Representa un fragment d'una forma destruïda (nau, enemic, bala)
+struct Debris {
+        // Geometria del segment (2 punts en coordenades mundials)
+        Punt p1;  // Punt inicial del segment
+        Punt p2;  // Punt final del segment
+
+        // Física
+        Punt velocitat;     // Velocitat en px/s (components x, y)
+        float acceleracio;  // Acceleració negativa (fricció) en px/s²
+
+        // Rotació
+        float angle_rotacio;  // Angle de rotació acumulat (radians)
+        float velocitat_rot;  // Velocitat de rotació en rad/s
+
+        // Estat de vida
+        float temps_vida;  // Temps transcorregut (segons)
+        float temps_max;   // Temps de vida màxim (segons)
+        bool actiu;        // Està actiu?
+
+        // Shrinking (reducció de distància entre punts)
+        float factor_shrink;  // Factor de reducció per segon (0.0-1.0)
+};
+
+}  // namespace Effects

source/game/effects/debris_manager.cpp

@@ -0,0 +1,276 @@
+// debris_manager.cpp - Implementació del gestor de fragments
+// © 2025 Port a C++20 amb SDL3
+
+#include "debris_manager.hpp"
+
+#include <cmath>
+#include <cstdlib>
+#include <iostream>
+
+#include "core/defaults.hpp"
+#include "core/rendering/line_renderer.hpp"
+
+namespace Effects {
+
+// Helper: transformar punt amb rotació, escala i trasllació
+// (Copiat de shape_renderer.cpp:12-34)
+static Punt transform_point(const Punt& point, const Punt& shape_centre, const Punt& posicio, float angle, float escala) {
+    // 1. Centrar el punt respecte al centre de la forma
+    float centered_x = point.x - shape_centre.x;
+    float centered_y = point.y - shape_centre.y;
+
+    // 2. Aplicar escala al punt centrat
+    float scaled_x = centered_x * escala;
+    float scaled_y = centered_y * escala;
+
+    // 3. Aplicar rotació
+    float cos_a = std::cos(angle);
+    float sin_a = std::sin(angle);
+
+    float rotated_x = scaled_x * cos_a - scaled_y * sin_a;
+    float rotated_y = scaled_x * sin_a + scaled_y * cos_a;
+
+    // 4. Aplicar trasllació a posició mundial
+    return {rotated_x + posicio.x, rotated_y + posicio.y};
+}
+
+DebrisManager::DebrisManager(SDL_Renderer* renderer)
+    : renderer_(renderer) {
+    // Inicialitzar tots els debris com inactius
+    for (auto& debris : debris_pool_) {
+        debris.actiu = false;
+    }
+}
+
+void DebrisManager::explotar(const std::shared_ptr<Graphics::Shape>& shape,
+    const Punt& centre,
+    float angle,
+    float escala,
+    float velocitat_base) {
+    if (!shape || !shape->es_valida()) {
+        return;
+    }
+
+    // Obtenir centre de la forma per a transformacions
+    const Punt& shape_centre = shape->get_centre();
+
+    // Iterar sobre totes les primitives de la forma
+    for (const auto& primitive : shape->get_primitives()) {
+        // Processar cada segment de línia
+        std::vector<std::pair<Punt, Punt>> segments;
+
+        if (primitive.type == Graphics::PrimitiveType::POLYLINE) {
+            // Polyline: extreure segments consecutius
+            for (size_t i = 0; i < primitive.points.size() - 1; i++) {
+                segments.push_back({primitive.points[i], primitive.points[i + 1]});
+            }
+        } else {  // PrimitiveType::LINE
+            // Line: un únic segment
+            if (primitive.points.size() >= 2) {
+                segments.push_back({primitive.points[0], primitive.points[1]});
+            }
+        }
+
+        // Crear debris per a cada segment
+        for (const auto& [local_p1, local_p2] : segments) {
+            // 1. Transformar punts locals → coordenades mundials
+            Punt world_p1 =
+                transform_point(local_p1, shape_centre, centre, angle, escala);
+            Punt world_p2 =
+                transform_point(local_p2, shape_centre, centre, angle, escala);
+
+            // 2. Trobar slot lliure
+            Debris* debris = trobar_slot_lliure();
+            if (!debris) {
+                std::cerr << "[DebrisManager] Warning: no debris slots disponibles\n";
+                return;  // Pool ple
+            }
+
+            // 3. Inicialitzar geometria
+            debris->p1 = world_p1;
+            debris->p2 = world_p2;
+
+            // 4. Calcular direcció perpendicular
+            Punt direccio = calcular_direccio_perpendicular(world_p1, world_p2);
+
+            // 5. Velocitat inicial (base ± variació aleatòria)
+            float speed =
+                velocitat_base +
+                ((std::rand() / static_cast<float>(RAND_MAX)) * 2.0f - 1.0f) *
+                    Defaults::Physics::Debris::VARIACIO_VELOCITAT;
+
+            debris->velocitat.x = direccio.x * speed;
+            debris->velocitat.y = direccio.y * speed;
+            debris->acceleracio = Defaults::Physics::Debris::ACCELERACIO;
+
+            // 6. Rotació lenta aleatòria
+            debris->velocitat_rot =
+                Defaults::Physics::Debris::ROTACIO_MIN +
+                (std::rand() / static_cast<float>(RAND_MAX)) *
+                    (Defaults::Physics::Debris::ROTACIO_MAX -
+                        Defaults::Physics::Debris::ROTACIO_MIN);
+
+            // 50% probabilitat de rotació en sentit contrari
+            if (std::rand() % 2 == 0) {
+                debris->velocitat_rot = -debris->velocitat_rot;
+            }
+
+            debris->angle_rotacio = 0.0f;
+
+            // 7. Configurar vida i shrinking
+            debris->temps_vida = 0.0f;
+            debris->temps_max = Defaults::Physics::Debris::TEMPS_VIDA;
+            debris->factor_shrink = Defaults::Physics::Debris::SHRINK_RATE;
+
+            // 8. Activar
+            debris->actiu = true;
+        }
+    }
+}
+
+void DebrisManager::actualitzar(float delta_time) {
+    for (auto& debris : debris_pool_) {
+        if (!debris.actiu)
+            continue;
+
+        // 1. Actualitzar temps de vida
+        debris.temps_vida += delta_time;
+
+        // Desactivar si ha superat temps màxim
+        if (debris.temps_vida >= debris.temps_max) {
+            debris.actiu = false;
+            continue;
+        }
+
+        // 2. Actualitzar velocitat (desacceleració)
+        // Aplicar fricció en la direcció del moviment
+        float speed = std::sqrt(debris.velocitat.x * debris.velocitat.x +
+            debris.velocitat.y * debris.velocitat.y);
+
+        if (speed > 1.0f) {
+            // Calcular direcció normalitzada
+            float dir_x = debris.velocitat.x / speed;
+            float dir_y = debris.velocitat.y / speed;
+
+            // Aplicar acceleració negativa (fricció)
+            float nova_speed = speed + debris.acceleracio * delta_time;
+            if (nova_speed < 0.0f)
+                nova_speed = 0.0f;
+
+            debris.velocitat.x = dir_x * nova_speed;
+            debris.velocitat.y = dir_y * nova_speed;
+        } else {
+            // Velocitat molt baixa, aturar
+            debris.velocitat.x = 0.0f;
+            debris.velocitat.y = 0.0f;
+        }
+
+        // 3. Calcular centre del segment
+        Punt centre = {(debris.p1.x + debris.p2.x) / 2.0f,
+            (debris.p1.y + debris.p2.y) / 2.0f};
+
+        // 4. Actualitzar posició del centre
+        centre.x += debris.velocitat.x * delta_time;
+        centre.y += debris.velocitat.y * delta_time;
+
+        // 5. Actualitzar rotació
+        debris.angle_rotacio += debris.velocitat_rot * delta_time;
+
+        // 6. Aplicar shrinking (reducció de distància entre punts)
+        float shrink_factor =
+            1.0f - (debris.factor_shrink * debris.temps_vida / debris.temps_max);
+        shrink_factor = std::max(0.0f, shrink_factor);  // No negatiu
+
+        // Calcular distància original entre punts
+        float dx = debris.p2.x - debris.p1.x;
+        float dy = debris.p2.y - debris.p1.y;
+
+        // 7. Reconstruir segment amb nova mida i rotació
+        float half_length = std::sqrt(dx * dx + dy * dy) * shrink_factor / 2.0f;
+        float original_angle = std::atan2(dy, dx);
+        float new_angle = original_angle + debris.angle_rotacio;
+
+        debris.p1.x = centre.x - half_length * std::cos(new_angle);
+        debris.p1.y = centre.y - half_length * std::sin(new_angle);
+        debris.p2.x = centre.x + half_length * std::cos(new_angle);
+        debris.p2.y = centre.y + half_length * std::sin(new_angle);
+    }
+}
+
+void DebrisManager::dibuixar() const {
+    for (const auto& debris : debris_pool_) {
+        if (!debris.actiu)
+            continue;
+
+        // Dibuixar segment de línia
+        Rendering::linea(renderer_, static_cast<int>(debris.p1.x), static_cast<int>(debris.p1.y), static_cast<int>(debris.p2.x), static_cast<int>(debris.p2.y), true);
+    }
+}
+
+Debris* DebrisManager::trobar_slot_lliure() {
+    for (auto& debris : debris_pool_) {
+        if (!debris.actiu) {
+            return &debris;
+        }
+    }
+    return nullptr;  // Pool ple
+}
+
+Punt DebrisManager::calcular_direccio_perpendicular(const Punt& p1,
+    const Punt& p2) const {
+    // 1. Calcular vector de la línia (p1 → p2)
+    float dx = p2.x - p1.x;
+    float dy = p2.y - p1.y;
+
+    // 2. Normalitzar (obtenir vector unitari)
+    float length = std::sqrt(dx * dx + dy * dy);
+    if (length < 0.001f) {
+        // Línia degenerada, retornar direcció aleatòria
+        float angle_rand =
+            (std::rand() / static_cast<float>(RAND_MAX)) * 2.0f * Defaults::Math::PI;
+        return {std::cos(angle_rand), std::sin(angle_rand)};
+    }
+
+    dx /= length;
+    dy /= length;
+
+    // 3. Rotar 90° (perpendicular)
+    // Rotació 90° sentit antihorari: (x,y) → (-y, x)
+    float perp_x = -dy;
+    float perp_y = dx;
+
+    // 4. Afegir variació aleatòria petita (±15°)
+    float angle_variacio =
+        ((std::rand() % 30) - 15) * Defaults::Math::PI / 180.0f;
+
+    float cos_v = std::cos(angle_variacio);
+    float sin_v = std::sin(angle_variacio);
+
+    float final_x = perp_x * cos_v - perp_y * sin_v;
+    float final_y = perp_x * sin_v + perp_y * cos_v;
+
+    // 5. Afegir ± direcció aleatòria (50% probabilitat d'invertir)
+    if (std::rand() % 2 == 0) {
+        final_x = -final_x;
+        final_y = -final_y;
+    }
+
+    return {final_x, final_y};
+}
+
+void DebrisManager::reiniciar() {
+    for (auto& debris : debris_pool_) {
+        debris.actiu = false;
+    }
+}
+
+int DebrisManager::get_num_actius() const {
+    int count = 0;
+    for (const auto& debris : debris_pool_) {
+        if (debris.actiu)
+            count++;
+    }
+    return count;
+}
+
+}  // namespace Effects

source/game/effects/debris_manager.hpp

@@ -0,0 +1,63 @@
+// debris_manager.hpp - Gestor de fragments d'explosions
+// © 2025 Port a C++20 amb SDL3
+
+#pragma once
+#include <SDL3/SDL.h>
+
+#include <array>
+#include <memory>
+
+#include "core/graphics/shape.hpp"
+#include "core/types.hpp"
+#include "debris.hpp"
+
+namespace Effects {
+
+// Gestor de fragments d'explosions
+// Manté un pool d'objectes Debris i gestiona el seu cicle de vida
+class DebrisManager {
+    public:
+        explicit DebrisManager(SDL_Renderer* renderer);
+
+        // Crear explosió a partir d'una forma
+        // - shape: forma vectorial a explotar
+        // - centre: posició del centre de l'objecte
+        // - angle: orientació de l'objecte (radians)
+        // - escala: escala de l'objecte (1.0 = normal)
+        // - velocitat_base: velocitat inicial dels fragments (px/s)
+        void explotar(const std::shared_ptr<Graphics::Shape>& shape,
+            const Punt& centre,
+            float angle,
+            float escala,
+            float velocitat_base);
+
+        // Actualitzar tots els fragments actius
+        void actualitzar(float delta_time);
+
+        // Dibuixar tots els fragments actius
+        void dibuixar() const;
+
+        // Reiniciar tots els fragments (neteja)
+        void reiniciar();
+
+        // Obtenir número de fragments actius
+        int get_num_actius() const;
+
+    private:
+        SDL_Renderer* renderer_;
+
+        // Pool de fragments (màxim concurrent)
+        // Un pentàgon té 5 línies, 15 enemics = 75 línies
+        // + nau (3 línies) + bales (5 línies * 3) = 93 línies màxim
+        // Arrodonit a 100 per seguretat
+        static constexpr int MAX_DEBRIS = 100;
+        std::array<Debris, MAX_DEBRIS> debris_pool_;
+
+        // Trobar primer slot inactiu
+        Debris* trobar_slot_lliure();
+
+        // Calcular direcció perpendicular a un segment
+        Punt calcular_direccio_perpendicular(const Punt& p1, const Punt& p2) const;
+};
+
+}  // namespace Effects

source/game/entities/bala.cpp

@@ -3,84 +3,94 @@
 // © 2025 Port a C++20 amb SDL3
 
 #include "game/entities/bala.hpp"
-#include "core/graphics/shape_loader.hpp"
+
-#include "core/rendering/shape_renderer.hpp"
-#include "game/constants.hpp"
 #include <cmath>
 #include <iostream>
 
-Bala::Bala(SDL_Renderer *renderer)
+#include "core/graphics/shape_loader.hpp"
-    : renderer_(renderer), centre_({0.0f, 0.0f}), angle_(0.0f),
+#include "core/rendering/shape_renderer.hpp"
-      velocitat_(0.0f), esta_(false) {
+#include "game/constants.hpp"
 
-  // [NUEVO] Carregar forma compartida des de fitxer
+Bala::Bala(SDL_Renderer* renderer)
-  forma_ = Graphics::ShapeLoader::load("bullet.shp");
+    : renderer_(renderer),
+      centre_({0.0f, 0.0f}),
+      angle_(0.0f),
+      velocitat_(0.0f),
+      esta_(false) {
+    // [NUEVO] Carregar forma compartida des de fitxer
+    forma_ = Graphics::ShapeLoader::load("bullet.shp");
 
-  if (!forma_ || !forma_->es_valida()) {
+    if (!forma_ || !forma_->es_valida()) {
-    std::cerr << "[Bala] Error: no s'ha pogut carregar bullet.shp" << std::endl;
+        std::cerr << "[Bala] Error: no s'ha pogut carregar bullet.shp" << std::endl;
-  }
+    }
 }
 
 void Bala::inicialitzar() {
-  // Inicialment inactiva
+    // Inicialment inactiva
-  esta_ = false;
+    esta_ = false;
-  centre_ = {0.0f, 0.0f};
+    centre_ = {0.0f, 0.0f};
-  angle_ = 0.0f;
+    angle_ = 0.0f;
-  velocitat_ = 0.0f;
+    velocitat_ = 0.0f;
 }
 
-void Bala::disparar(const Punt &posicio, float angle) {
+void Bala::disparar(const Punt& posicio, float angle) {
-  // Activar bala i posicionar-la a la nau
+    // Activar bala i posicionar-la a la nau
-  // Basat en joc_asteroides.cpp línies 188-200
+    // Basat en joc_asteroides.cpp línies 188-200
 
-  // Activar bala
+    // Activar bala
-  esta_ = true;
+    esta_ = true;
 
-  // Posició inicial = centre de la nau
+    // Posició inicial = centre de la nau
-  centre_.x = posicio.x;
+    centre_.x = posicio.x;
-  centre_.y = posicio.y;
+    centre_.y = posicio.y;
 
-  // Angle = angle de la nau (dispara en la direcció que apunta)
+    // Angle = angle de la nau (dispara en la direcció que apunta)
-  angle_ = angle;
+    angle_ = angle;
 
-  // Velocitat alta (el joc Pascal original usava 7 px/frame)
+    // Velocitat alta (el joc Pascal original usava 7 px/frame)
-  // 7 px/frame × 20 FPS = 140 px/s
+    // 7 px/frame × 20 FPS = 140 px/s
-  velocitat_ = 140.0f;
+    velocitat_ = 140.0f;
 }
 
 void Bala::actualitzar(float delta_time) {
-  if (esta_) {
+    if (esta_) {
-    mou(delta_time);
+        mou(delta_time);
-  }
+    }
 }
 
 void Bala::dibuixar() const {
-  if (esta_ && forma_) {
+    if (esta_ && forma_) {
-    // [NUEVO] Usar render_shape en lloc de rota_pol
+        // [NUEVO] Usar render_shape en lloc de rota_pol
-    // Les bales no roten visualment (angle sempre 0.0f)
+        // Les bales no roten visualment (angle sempre 0.0f)
-    Rendering::render_shape(renderer_, forma_, centre_, 0.0f, 1.0f, true);
+        Rendering::render_shape(renderer_, forma_, centre_, 0.0f, 1.0f, true);
-  }
+    }
 }
 
 void Bala::mou(float delta_time) {
-  // Moviment rectilini de la bala
+    // Moviment rectilini de la bala
-  // Basat en el codi Pascal original: procedure mou_bales
+    // Basat en el codi Pascal original: procedure mou_bales
-  // Copiat EXACTAMENT de joc_asteroides.cpp línies 396-419
+    // Copiat EXACTAMENT de joc_asteroides.cpp línies 396-419
 
-  // Calcular nova posició (moviment polar time-based)
+    // Calcular nova posició (moviment polar time-based)
-  // velocitat ja està en px/s (140 px/s), només cal multiplicar per delta_time
+    // velocitat ja està en px/s (140 px/s), només cal multiplicar per delta_time
-  float velocitat_efectiva = velocitat_ * delta_time;
+    float velocitat_efectiva = velocitat_ * delta_time;
 
-  // Calcular desplaçament (angle-PI/2 perquè angle=0 apunta amunt)
+    // Calcular desplaçament (angle-PI/2 perquè angle=0 apunta amunt)
-  float dy = velocitat_efectiva * std::sin(angle_ - Constants::PI / 2.0f);
+    float dy = velocitat_efectiva * std::sin(angle_ - Constants::PI / 2.0f);
-  float dx = velocitat_efectiva * std::cos(angle_ - Constants::PI / 2.0f);
+    float dx = velocitat_efectiva * std::cos(angle_ - Constants::PI / 2.0f);
 
-  // Acumulació directa amb precisió subpíxel
+    // Acumulació directa amb precisió subpíxel
-  centre_.y += dy;
+    centre_.y += dy;
-  centre_.x += dx;
+    centre_.x += dx;
 
-  // Desactivar si surt de la zona de joc (no rebota com els ORNIs)
+    // Desactivar si surt de la zona de joc (no rebota com els ORNIs)
-  if (!Constants::dins_zona_joc(centre_.x, centre_.y)) {
+    // CORRECCIÓ: Usar límits segurs amb radi de la bala
-    esta_ = false;
+    float min_x, max_x, min_y, max_y;
-  }
+    Constants::obtenir_limits_zona_segurs(Defaults::Entities::BULLET_RADIUS,
+                                         min_x, max_x, min_y, max_y);
+
+    if (centre_.x < min_x || centre_.x > max_x ||
+        centre_.y < min_y || centre_.y > max_y) {
+        esta_ = false;
+    }
 }

source/game/entities/bala.hpp

@@ -3,37 +3,40 @@
 // © 2025 Port a C++20 amb SDL3
 
 #pragma once
-#include "core/graphics/shape.hpp"
-#include "core/types.hpp"
 #include <SDL3/SDL.h>
+
 #include <memory>
 
+#include "core/graphics/shape.hpp"
+#include "core/types.hpp"
+
 class Bala {
-public:
+    public:
-  Bala() : renderer_(nullptr) {}
+        Bala()
-  Bala(SDL_Renderer *renderer);
+            : renderer_(nullptr) {}
+        Bala(SDL_Renderer* renderer);
 
-  void inicialitzar();
+        void inicialitzar();
-  void disparar(const Punt &posicio, float angle);
+        void disparar(const Punt& posicio, float angle);
-  void actualitzar(float delta_time);
+        void actualitzar(float delta_time);
-  void dibuixar() const;
+        void dibuixar() const;
 
-  // Getters (API pública sense canvis)
+        // Getters (API pública sense canvis)
-  bool esta_activa() const { return esta_; }
+        bool esta_activa() const { return esta_; }
-  const Punt &get_centre() const { return centre_; }
+        const Punt& get_centre() const { return centre_; }
-  void desactivar() { esta_ = false; }
+        void desactivar() { esta_ = false; }
 
-private:
+    private:
-  SDL_Renderer *renderer_;
+        SDL_Renderer* renderer_;
 
-  // [NUEVO] Forma vectorial (compartida entre totes les bales)
+        // [NUEVO] Forma vectorial (compartida entre totes les bales)
-  std::shared_ptr<Graphics::Shape> forma_;
+        std::shared_ptr<Graphics::Shape> forma_;
 
-  // [NUEVO] Estat de la instància (separat de la geometria)
+        // [NUEVO] Estat de la instància (separat de la geometria)
-  Punt centre_;
+        Punt centre_;
-  float angle_;
+        float angle_;
-  float velocitat_;
+        float velocitat_;
-  bool esta_;
+        bool esta_;
 
-  void mou(float delta_time);
+        void mou(float delta_time);
 };

source/game/entities/enemic.cpp

@@ -3,117 +3,134 @@
 // © 2025 Port a C++20 amb SDL3
 
 #include "game/entities/enemic.hpp"
-#include "core/graphics/shape_loader.hpp"
+
-#include "core/rendering/shape_renderer.hpp"
-#include "game/constants.hpp"
 #include <cmath>
 #include <cstdlib>
 #include <iostream>
 
-Enemic::Enemic(SDL_Renderer *renderer)
+#include "core/graphics/shape_loader.hpp"
-    : renderer_(renderer), centre_({0.0f, 0.0f}), angle_(0.0f),
+#include "core/rendering/shape_renderer.hpp"
-      velocitat_(0.0f), drotacio_(0.0f), rotacio_(0.0f), esta_(false) {
+#include "game/constants.hpp"
 
-  // [NUEVO] Carregar forma compartida des de fitxer
+Enemic::Enemic(SDL_Renderer* renderer)
-  forma_ = Graphics::ShapeLoader::load("enemy_pentagon.shp");
+    : renderer_(renderer),
+      centre_({0.0f, 0.0f}),
+      angle_(0.0f),
+      velocitat_(0.0f),
+      drotacio_(0.0f),
+      rotacio_(0.0f),
+      esta_(false) {
+    // [NUEVO] Carregar forma compartida des de fitxer
+    forma_ = Graphics::ShapeLoader::load("enemy_pentagon.shp");
 
-  if (!forma_ || !forma_->es_valida()) {
+    if (!forma_ || !forma_->es_valida()) {
-    std::cerr << "[Enemic] Error: no s'ha pogut carregar enemy_pentagon.shp"
+        std::cerr << "[Enemic] Error: no s'ha pogut carregar enemy_pentagon.shp"
-              << std::endl;
+                  << std::endl;
-  }
+    }
 }
 
 void Enemic::inicialitzar() {
-  // Inicialitzar enemic (pentàgon)
+    // Inicialitzar enemic (pentàgon)
-  // Copiat de joc_asteroides.cpp línies 41-54
+    // Copiat de joc_asteroides.cpp línies 41-54
 
-  // [NUEVO] Ja no cal crear_poligon_regular - la geometria es carrega del fitxer
+    // [NUEVO] Ja no cal crear_poligon_regular - la geometria es carrega del
-  // Només inicialitzem l'estat de la instància
+    // fitxer Només inicialitzem l'estat de la instància
 
-  // Posició aleatòria dins de l'àrea de joc
+    // Posició aleatòria dins de l'àrea de joc
-  centre_.x = static_cast<float>((std::rand() % 580) + 30); // 30-610
+    // Calcular rangs segurs amb radi de l'enemic
-  centre_.y = static_cast<float>((std::rand() % 420) + 30); // 30-450
+    float min_x, max_x, min_y, max_y;
+    Constants::obtenir_limits_zona_segurs(Defaults::Entities::ENEMY_RADIUS,
+                                         min_x, max_x, min_y, max_y);
 
-  // Angle aleatori de moviment
+    // Spawn aleatori dins dels límits segurs
-  angle_ = (std::rand() % 360) * Constants::PI / 180.0f;
+    int range_x = static_cast<int>(max_x - min_x);
+    int range_y = static_cast<int>(max_y - min_y);
+    centre_.x = static_cast<float>((std::rand() % range_x) + static_cast<int>(min_x));
+    centre_.y = static_cast<float>((std::rand() % range_y) + static_cast<int>(min_y));
 
-  // Velocitat (2 px/frame original * 20 FPS = 40 px/s)
+    // Angle aleatori de moviment
-  velocitat_ = 40.0f;
+    angle_ = (std::rand() % 360) * Constants::PI / 180.0f;
 
-  // Rotació visual aleatòria (rad/s)
+    // Velocitat (2 px/frame original * 20 FPS = 40 px/s)
-  // Original Pascal: random * 0.1 rad/frame * 20 FPS ≈ 2 rad/s
+    velocitat_ = 40.0f;
-  drotacio_ = (static_cast<float>(std::rand()) / RAND_MAX) * 2.0f;
-  rotacio_ = 0.0f;
 
-  // Activar
+    // Rotació visual aleatòria (rad/s)
-  esta_ = true;
+    // Original Pascal: random * 0.1 rad/frame * 20 FPS ≈ 2 rad/s
+    drotacio_ = (static_cast<float>(std::rand()) / RAND_MAX) * 2.0f;
+    rotacio_ = 0.0f;
+
+    // Activar
+    esta_ = true;
 }
 
 void Enemic::actualitzar(float delta_time) {
-  if (esta_) {
+    if (esta_) {
-    // Moviment autònom
+        // Moviment autònom
-    mou(delta_time);
+        mou(delta_time);
 
-    // Rotació visual (time-based: drotacio_ està en rad/s)
+        // Rotació visual (time-based: drotacio_ està en rad/s)
-    rotacio_ += drotacio_ * delta_time;
+        rotacio_ += drotacio_ * delta_time;
-  }
+    }
 }
 
 void Enemic::dibuixar() const {
-  if (esta_ && forma_) {
+    if (esta_ && forma_) {
-    // [NUEVO] Usar render_shape en lloc de rota_pol
+        // [NUEVO] Usar render_shape en lloc de rota_pol
-    Rendering::render_shape(renderer_, forma_, centre_, rotacio_, 1.0f, true);
+        Rendering::render_shape(renderer_, forma_, centre_, rotacio_, 1.0f, true);
-  }
+    }
 }
 
 void Enemic::mou(float delta_time) {
-  // Moviment autònom d'ORNI (enemic pentàgon)
+    // Moviment autònom d'ORNI (enemic pentàgon)
-  // Basat EXACTAMENT en el codi Pascal original: ASTEROID.PAS lines 279-293
+    // Basat EXACTAMENT en el codi Pascal original: ASTEROID.PAS lines 279-293
-  // Copiat EXACTAMENT de joc_asteroides.cpp línies 348-394
+    // Copiat EXACTAMENT de joc_asteroides.cpp línies 348-394
-  //
+    //
-  // IMPORTANT: El Pascal original NO té canvi aleatori continu!
+    // IMPORTANT: El Pascal original NO té canvi aleatori continu!
-  // Només ajusta l'angle quan toca una paret.
+    // Només ajusta l'angle quan toca una paret.
 
-  // Calcular nova posició PROPUESTA (time-based, però lògica Pascal)
+    // Calcular nova posició PROPUESTA (time-based, però lògica Pascal)
-  // velocitat_ ja està en px/s (40 px/s), multiplicar per delta_time
+    // velocitat_ ja està en px/s (40 px/s), multiplicar per delta_time
-  float velocitat_efectiva = velocitat_ * delta_time;
+    float velocitat_efectiva = velocitat_ * delta_time;
 
-  // Calcular desplaçament (angle-PI/2 perquè angle=0 apunta amunt)
+    // Calcular desplaçament (angle-PI/2 perquè angle=0 apunta amunt)
-  float dy = velocitat_efectiva * std::sin(angle_ - Constants::PI / 2.0f);
+    float dy = velocitat_efectiva * std::sin(angle_ - Constants::PI / 2.0f);
-  float dx = velocitat_efectiva * std::cos(angle_ - Constants::PI / 2.0f);
+    float dx = velocitat_efectiva * std::cos(angle_ - Constants::PI / 2.0f);
 
-  float new_y = centre_.y + dy;
+    float new_y = centre_.y + dy;
-  float new_x = centre_.x + dx;
+    float new_x = centre_.x + dx;
 
-  // Obtenir límits de la zona de joc
+    // Obtenir límits segurs compensant el radi de l'enemic
-  float min_x, max_x, min_y, max_y;
+    float min_x, max_x, min_y, max_y;
-  Constants::obtenir_limits_zona(min_x, max_x, min_y, max_y);
+    Constants::obtenir_limits_zona_segurs(Defaults::Entities::ENEMY_RADIUS,
+                                         min_x, max_x, min_y, max_y);
 
-  // Lògica Pascal: Actualitza Y si dins, sinó ajusta angle aleatòriament
+    // Lògica Pascal: Actualitza Y si dins, sinó ajusta angle aleatòriament
-  // if (dy>marge_dalt) and (dy<marge_baix) then orni.centre.y:=round(Dy)
+    // if (dy>marge_dalt) and (dy<marge_baix) then orni.centre.y:=round(Dy)
-  // else orni.angle:=orni.angle+(random(256)/512)*(random(3)-1);
+    // else orni.angle:=orni.angle+(random(256)/512)*(random(3)-1);
-  if (new_y > min_y && new_y < max_y) {
+    // CORRECCIÓ: Usar inequalitats inclusives (>= i <=) per evitar fugides
-    centre_.y = new_y;
+    if (new_y >= min_y && new_y <= max_y) {
-  } else {
+        centre_.y = new_y;
-    // Pequeño ajuste aleatorio: (random(256)/512)*(random(3)-1)
+    } else {
-    // random(256) = 0..255, /512 = 0..0.498
+        // Pequeño ajuste aleatorio: (random(256)/512)*(random(3)-1)
-    // random(3) = 0,1,2, -1 = -1,0,1
+        // random(256) = 0..255, /512 = 0..0.498
-    // Resultado: ±0.5 rad aprox
+        // random(3) = 0,1,2, -1 = -1,0,1
-    float rand1 = (static_cast<float>(std::rand() % 256) / 512.0f);
+        // Resultado: ±0.5 rad aprox
-    int rand2 = (std::rand() % 3) - 1; // -1, 0, o 1
+        float rand1 = (static_cast<float>(std::rand() % 256) / 512.0f);
-    angle_ += rand1 * static_cast<float>(rand2);
+        int rand2 = (std::rand() % 3) - 1;  // -1, 0, o 1
-  }
+        angle_ += rand1 * static_cast<float>(rand2);
+    }
 
-  // Lògica Pascal: Actualitza X si dins, sinó ajusta angle aleatòriament
+    // Lògica Pascal: Actualitza X si dins, sinó ajusta angle aleatòriament
-  // if (dx>marge_esq) and (dx<marge_dret) then orni.centre.x:=round(Dx)
+    // if (dx>marge_esq) and (dx<marge_dret) then orni.centre.x:=round(Dx)
-  // else orni.angle:=orni.angle+(random(256)/512)*(random(3)-1);
+    // else orni.angle:=orni.angle+(random(256)/512)*(random(3)-1);
-  if (new_x > min_x && new_x < max_x) {
+    // CORRECCIÓ: Usar inequalitats inclusives (>= i <=) per evitar fugides
-    centre_.x = new_x;
+    if (new_x >= min_x && new_x <= max_x) {
-  } else {
+        centre_.x = new_x;
-    float rand1 = (static_cast<float>(std::rand() % 256) / 512.0f);
+    } else {
-    int rand2 = (std::rand() % 3) - 1;
+        float rand1 = (static_cast<float>(std::rand() % 256) / 512.0f);
-    angle_ += rand1 * static_cast<float>(rand2);
+        int rand2 = (std::rand() % 3) - 1;
-  }
+        angle_ += rand1 * static_cast<float>(rand2);
+    }
 
-  // Nota: La rotació visual (rotacio_ += drotacio_) ja es fa a actualitzar()
+    // Nota: La rotació visual (rotacio_ += drotacio_) ja es fa a actualitzar()
 }

source/game/entities/enemic.hpp

@@ -3,38 +3,42 @@
 // © 2025 Port a C++20 amb SDL3
 
 #pragma once
-#include "core/graphics/shape.hpp"
-#include "core/types.hpp"
 #include <SDL3/SDL.h>
+
 #include <memory>
 
+#include "core/graphics/shape.hpp"
+#include "core/types.hpp"
+
 class Enemic {
-public:
+    public:
-  Enemic() : renderer_(nullptr) {}
+        Enemic()
-  Enemic(SDL_Renderer *renderer);
+            : renderer_(nullptr) {}
+        Enemic(SDL_Renderer* renderer);
 
-  void inicialitzar();
+        void inicialitzar();
-  void actualitzar(float delta_time);
+        void actualitzar(float delta_time);
-  void dibuixar() const;
+        void dibuixar() const;
 
-  // Getters (API pública sense canvis)
+        // Getters (API pública sense canvis)
-  bool esta_actiu() const { return esta_; }
+        bool esta_actiu() const { return esta_; }
-  const Punt &get_centre() const { return centre_; }
+        const Punt& get_centre() const { return centre_; }
-  void destruir() { esta_ = false; }
+        const std::shared_ptr<Graphics::Shape>& get_forma() const { return forma_; }
+        void destruir() { esta_ = false; }
 
-private:
+    private:
-  SDL_Renderer *renderer_;
+        SDL_Renderer* renderer_;
 
-  // [NUEVO] Forma vectorial (compartida entre tots els enemics)
+        // [NUEVO] Forma vectorial (compartida entre tots els enemics)
-  std::shared_ptr<Graphics::Shape> forma_;
+        std::shared_ptr<Graphics::Shape> forma_;
 
-  // [NUEVO] Estat de la instància (separat de la geometria)
+        // [NUEVO] Estat de la instància (separat de la geometria)
-  Punt centre_;
+        Punt centre_;
-  float angle_;      // Angle de moviment
+        float angle_;  // Angle de moviment
-  float velocitat_;
+        float velocitat_;
-  float drotacio_;   // Delta rotació visual (rad/s)
+        float drotacio_;  // Delta rotació visual (rad/s)
-  float rotacio_;    // Rotació visual acumulada
+        float rotacio_;   // Rotació visual acumulada
-  bool esta_;
+        bool esta_;
 
-  void mou(float delta_time);
+        void mou(float delta_time);
 };

source/game/entities/nau.cpp

@@ -3,137 +3,146 @@
 // © 2025 Port a C++20 amb SDL3
 
 #include "game/entities/nau.hpp"
+
+#include <SDL3/SDL.h>
+
+#include <cmath>
+#include <iostream>
+
 #include "core/defaults.hpp"
 #include "core/graphics/shape_loader.hpp"
 #include "core/rendering/shape_renderer.hpp"
 #include "game/constants.hpp"
-#include <SDL3/SDL.h>
-#include <cmath>
-#include <iostream>
 
-Nau::Nau(SDL_Renderer *renderer)
+Nau::Nau(SDL_Renderer* renderer)
-    : renderer_(renderer), centre_({0.0f, 0.0f}), angle_(0.0f),
+    : renderer_(renderer),
-      velocitat_(0.0f), esta_tocada_(false) {
+      centre_({0.0f, 0.0f}),
+      angle_(0.0f),
+      velocitat_(0.0f),
+      esta_tocada_(false) {
+    // [NUEVO] Carregar forma compartida des de fitxer
+    forma_ = Graphics::ShapeLoader::load("ship.shp");
 
-  // [NUEVO] Carregar forma compartida des de fitxer
+    if (!forma_ || !forma_->es_valida()) {
-  forma_ = Graphics::ShapeLoader::load("ship.shp");
+        std::cerr << "[Nau] Error: no s'ha pogut carregar ship.shp" << std::endl;
-
+    }
-  if (!forma_ || !forma_->es_valida()) {
-    std::cerr << "[Nau] Error: no s'ha pogut carregar ship.shp" << std::endl;
-  }
 }
 
 void Nau::inicialitzar() {
-  // Inicialització de la nau (triangle)
+    // Inicialització de la nau (triangle)
-  // Basat en el codi Pascal original: lines 380-384
+    // Basat en el codi Pascal original: lines 380-384
-  // Copiat de joc_asteroides.cpp línies 30-44
+    // Copiat de joc_asteroides.cpp línies 30-44
 
-  // [NUEVO] Ja no cal configurar punts polars - la geometria es carrega del fitxer
+    // [NUEVO] Ja no cal configurar punts polars - la geometria es carrega del
-  // Només inicialitzem l'estat de la instància
+    // fitxer Només inicialitzem l'estat de la instància
 
-  // Posició inicial al centre de la pantalla
+    // Posició inicial al centre de l'àrea de joc
-  centre_.x = 320.0f;
+    float centre_x, centre_y;
-  centre_.y = 240.0f;
+    Constants::obtenir_centre_zona(centre_x, centre_y);
+    centre_.x = centre_x;  // 320
+    centre_.y = centre_y;  // 213 (not 240!)
 
-  // Estat inicial
+    // Estat inicial
-  angle_ = 0.0f;
+    angle_ = 0.0f;
-  velocitat_ = 0.0f;
+    velocitat_ = 0.0f;
-  esta_tocada_ = false;
+    esta_tocada_ = false;
 }
 
 void Nau::processar_input(float delta_time) {
-  // Processar input continu (com teclapuls() del Pascal original)
+    // Processar input continu (com teclapuls() del Pascal original)
-  // Basat en joc_asteroides.cpp línies 66-85
+    // Basat en joc_asteroides.cpp línies 66-85
-  // Només processa input si la nau està viva
+    // Només processa input si la nau està viva
-  if (esta_tocada_)
+    if (esta_tocada_)
-    return;
+        return;
 
-  // Obtenir estat actual del teclat (no events, sinó estat continu)
+    // Obtenir estat actual del teclat (no events, sinó estat continu)
-  const bool *keyboard_state = SDL_GetKeyboardState(nullptr);
+    const bool* keyboard_state = SDL_GetKeyboardState(nullptr);
 
-  // Rotació
+    // Rotació
-  if (keyboard_state[SDL_SCANCODE_RIGHT]) {
+    if (keyboard_state[SDL_SCANCODE_RIGHT]) {
-    angle_ += Defaults::Physics::ROTATION_SPEED * delta_time;
+        angle_ += Defaults::Physics::ROTATION_SPEED * delta_time;
-  }
+    }
-
+
-  if (keyboard_state[SDL_SCANCODE_LEFT]) {
+    if (keyboard_state[SDL_SCANCODE_LEFT]) {
-    angle_ -= Defaults::Physics::ROTATION_SPEED * delta_time;
+        angle_ -= Defaults::Physics::ROTATION_SPEED * delta_time;
-  }
+    }
-
+
-  // Acceleració
+    // Acceleració
-  if (keyboard_state[SDL_SCANCODE_UP]) {
+    if (keyboard_state[SDL_SCANCODE_UP]) {
-    if (velocitat_ < Defaults::Physics::MAX_VELOCITY) {
+        if (velocitat_ < Defaults::Physics::MAX_VELOCITY) {
-      velocitat_ += Defaults::Physics::ACCELERATION * delta_time;
+            velocitat_ += Defaults::Physics::ACCELERATION * delta_time;
-      if (velocitat_ > Defaults::Physics::MAX_VELOCITY) {
+            if (velocitat_ > Defaults::Physics::MAX_VELOCITY) {
-        velocitat_ = Defaults::Physics::MAX_VELOCITY;
+                velocitat_ = Defaults::Physics::MAX_VELOCITY;
-      }
+            }
+        }
     }
-  }
 }
 
 void Nau::actualitzar(float delta_time) {
-  // Només actualitzar si la nau està viva
+    // Només actualitzar si la nau està viva
-  if (esta_tocada_)
+    if (esta_tocada_)
-    return;
+        return;
 
-  // Aplicar física (moviment + fricció)
+    // Aplicar física (moviment + fricció)
-  aplicar_fisica(delta_time);
+    aplicar_fisica(delta_time);
 }
 
 void Nau::dibuixar() const {
-  // Només dibuixar si la nau està viva
+    // Només dibuixar si la nau està viva
-  if (esta_tocada_)
+    if (esta_tocada_)
-    return;
+        return;
 
-  if (!forma_)
+    if (!forma_)
-    return;
+        return;
 
-  // Escalar velocitat per l'efecte visual (200 px/s → ~6 px d'efecte)
+    // Escalar velocitat per l'efecte visual (200 px/s → ~6 px d'efecte)
-  // El codi Pascal original sumava velocitat (0-6) al radi per donar
+    // El codi Pascal original sumava velocitat (0-6) al radi per donar
-  // sensació de "empenta". Ara velocitat està en px/s (0-200).
+    // sensació de "empenta". Ara velocitat està en px/s (0-200).
-  // Basat en joc_asteroides.cpp línies 127-134
+    // Basat en joc_asteroides.cpp línies 127-134
-  //
+    //
-  // [NUEVO] Convertir suma de velocitat_visual a escala multiplicativa
+    // [NUEVO] Convertir suma de velocitat_visual a escala multiplicativa
-  // Radio base del ship = 12 px
+    // Radio base del ship = 12 px
-  // velocitat_visual = 0-6 → r = 12-18 → escala = 1.0-1.5
+    // velocitat_visual = 0-6 → r = 12-18 → escala = 1.0-1.5
-  float velocitat_visual = velocitat_ / 33.33f;
+    float velocitat_visual = velocitat_ / 33.33f;
-  float escala = 1.0f + (velocitat_visual / 12.0f);
+    float escala = 1.0f + (velocitat_visual / 12.0f);
 
-  Rendering::render_shape(renderer_, forma_, centre_, angle_, escala, true);
+    Rendering::render_shape(renderer_, forma_, centre_, angle_, escala, true);
 }
 
 void Nau::aplicar_fisica(float delta_time) {
-  // Aplicar física de moviment
+    // Aplicar física de moviment
-  // Basat en joc_asteroides.cpp línies 87-113
+    // Basat en joc_asteroides.cpp línies 87-113
 
-  // Calcular nova posició basada en velocitat i angle
+    // Calcular nova posició basada en velocitat i angle
-  // S'usa (angle - PI/2) perquè angle=0 apunta cap amunt, no cap a la dreta
+    // S'usa (angle - PI/2) perquè angle=0 apunta cap amunt, no cap a la dreta
-  // velocitat_ està en px/s, així que multipliquem per delta_time
+    // velocitat_ està en px/s, així que multipliquem per delta_time
-  float dy =
+    float dy =
-      (velocitat_ * delta_time) * std::sin(angle_ - Constants::PI / 2.0f) +
+        (velocitat_ * delta_time) * std::sin(angle_ - Constants::PI / 2.0f) +
-      centre_.y;
+        centre_.y;
-  float dx =
+    float dx =
-      (velocitat_ * delta_time) * std::cos(angle_ - Constants::PI / 2.0f) +
+        (velocitat_ * delta_time) * std::cos(angle_ - Constants::PI / 2.0f) +
-      centre_.x;
+        centre_.x;
 
-  // Boundary checking - només actualitzar si dins de la zona de joc
+    // Boundary checking amb radi de la nau
-  // Acumulació directa amb precisió subpíxel
+    // CORRECCIÓ: Usar límits segurs i inequalitats inclusives
-  float min_x, max_x, min_y, max_y;
+    float min_x, max_x, min_y, max_y;
-  Constants::obtenir_limits_zona(min_x, max_x, min_y, max_y);
+    Constants::obtenir_limits_zona_segurs(Defaults::Entities::SHIP_RADIUS,
+                                         min_x, max_x, min_y, max_y);
 
-  if (dy > min_y && dy < max_y) {
+    // Inequalitats inclusives (>= i <=)
-    centre_.y = dy;
+    if (dy >= min_y && dy <= max_y) {
-  }
+        centre_.y = dy;
-
+    }
-  if (dx > min_x && dx < max_x) {
+
-    centre_.x = dx;
+    if (dx >= min_x && dx <= max_x) {
-  }
+        centre_.x = dx;
-
+    }
-  // Fricció - desacceleració gradual (time-based)
+
-  if (velocitat_ > 0.1f) {
+    // Fricció - desacceleració gradual (time-based)
-    velocitat_ -= Defaults::Physics::FRICTION * delta_time;
+    if (velocitat_ > 0.1f) {
-    if (velocitat_ < 0.0f) {
+        velocitat_ -= Defaults::Physics::FRICTION * delta_time;
-      velocitat_ = 0.0f;
+        if (velocitat_ < 0.0f) {
+            velocitat_ = 0.0f;
+        }
     }
-  }
 }

source/game/entities/nau.hpp

@@ -3,40 +3,44 @@
 // © 2025 Port a C++20 amb SDL3
 
 #pragma once
-#include "core/graphics/shape.hpp"
-#include "core/types.hpp"
 #include <SDL3/SDL.h>
+
 #include <memory>
 
+#include "core/graphics/shape.hpp"
+#include "core/types.hpp"
+
 class Nau {
-public:
+    public:
-  Nau() : renderer_(nullptr) {}
+        Nau()
-  Nau(SDL_Renderer *renderer);
+            : renderer_(nullptr) {}
+        Nau(SDL_Renderer* renderer);
 
-  void inicialitzar();
+        void inicialitzar();
-  void processar_input(float delta_time);
+        void processar_input(float delta_time);
-  void actualitzar(float delta_time);
+        void actualitzar(float delta_time);
-  void dibuixar() const;
+        void dibuixar() const;
 
-  // Getters (API pública sense canvis)
+        // Getters (API pública sense canvis)
-  const Punt &get_centre() const { return centre_; }
+        const Punt& get_centre() const { return centre_; }
-  float get_angle() const { return angle_; }
+        float get_angle() const { return angle_; }
-  bool esta_viva() const { return !esta_tocada_; }
+        bool esta_viva() const { return !esta_tocada_; }
 
-  // Col·lisions (Fase 10)
+        // Col·lisions (Fase 10)
-  void marcar_tocada() { esta_tocada_ = true; }
+        void marcar_tocada() { esta_tocada_ = true; }
 
-private:
+    private:
-  SDL_Renderer *renderer_;
+        SDL_Renderer* renderer_;
 
-  // [NUEVO] Forma vectorial (compartida, només 1 instància de Nau però preparat per reutilització)
+        // [NUEVO] Forma vectorial (compartida, només 1 instància de Nau però preparat
-  std::shared_ptr<Graphics::Shape> forma_;
+        // per reutilització)
+        std::shared_ptr<Graphics::Shape> forma_;
 
-  // [NUEVO] Estat de la instància (separat de la geometria)
+        // [NUEVO] Estat de la instància (separat de la geometria)
-  Punt centre_;
+        Punt centre_;
-  float angle_;      // Angle d'orientació
+        float angle_;      // Angle d'orientació
-  float velocitat_;  // Velocitat (px/s)
+        float velocitat_;  // Velocitat (px/s)
-  bool esta_tocada_;
+        bool esta_tocada_;
 
-  void aplicar_fisica(float delta_time);
+        void aplicar_fisica(float delta_time);
 };

source/game/escenes/escena_joc.cpp

@@ -3,211 +3,305 @@
 // © 2025 Port a C++20 amb SDL3
 
 #include "escena_joc.hpp"
-#include "../../core/rendering/line_renderer.hpp"
+
-#include "../../core/system/gestor_escenes.hpp"
-#include "../../core/system/global_events.hpp"
 #include <cmath>
 #include <cstdlib>
 #include <ctime>
 #include <iostream>
+#include <vector>
+
+#include "../../core/rendering/line_renderer.hpp"
+#include "../../core/system/gestor_escenes.hpp"
+#include "../../core/system/global_events.hpp"
 
 EscenaJoc::EscenaJoc(SDLManager& sdl)
-    : sdl_(sdl), nau_(sdl.obte_renderer()), itocado_(0), text_(sdl.obte_renderer()) {
+    : sdl_(sdl),
-  // Inicialitzar bales amb renderer
+      debris_manager_(sdl.obte_renderer()),
-  for (auto &bala : bales_) {
+      nau_(sdl.obte_renderer()),
-    bala = Bala(sdl.obte_renderer());
+      itocado_(0),
-  }
+      text_(sdl.obte_renderer()) {
+    // Inicialitzar bales amb renderer
+    for (auto& bala : bales_) {
+        bala = Bala(sdl.obte_renderer());
+    }
 
-  // Inicialitzar enemics amb renderer
+    // Inicialitzar enemics amb renderer
-  for (auto &enemy : orni_) {
+    for (auto& enemy : orni_) {
-    enemy = Enemic(sdl.obte_renderer());
+        enemy = Enemic(sdl.obte_renderer());
-  }
+    }
 }
 
 void EscenaJoc::executar() {
-  std::cout << "Escena Joc: Inicialitzant...\n";
+    std::cout << "Escena Joc: Inicialitzant...\n";
 
-  // Inicialitzar estat del joc
+    // Inicialitzar estat del joc
-  inicialitzar();
+    inicialitzar();
 
-  SDL_Event event;
+    SDL_Event event;
-  Uint64 last_time = SDL_GetTicks();
+    Uint64 last_time = SDL_GetTicks();
 
-  while (GestorEscenes::actual == GestorEscenes::Escena::JOC) {
+    while (GestorEscenes::actual == GestorEscenes::Escena::JOC) {
-    // Calcular delta_time real
+        // Calcular delta_time real
-    Uint64 current_time = SDL_GetTicks();
+        Uint64 current_time = SDL_GetTicks();
-    float delta_time = (current_time - last_time) / 1000.0f;
+        float delta_time = (current_time - last_time) / 1000.0f;
-    last_time = current_time;
+        last_time = current_time;
 
-    // Limitar delta_time per evitar grans salts
+        // Limitar delta_time per evitar grans salts
-    if (delta_time > 0.05f) {
+        if (delta_time > 0.05f) {
-      delta_time = 0.05f;
+            delta_time = 0.05f;
+        }
+
+        // Actualitzar comptador de FPS
+        sdl_.updateFPS(delta_time);
+
+        // Processar events SDL
+        while (SDL_PollEvent(&event)) {
+            // Manejo de finestra
+            if (sdl_.handleWindowEvent(event)) {
+                continue;
+            }
+
+            // Events globals (F1/F2/F3/ESC/QUIT)
+            if (GlobalEvents::handle(event, sdl_)) {
+                continue;
+            }
+
+            // Processament específic del joc (SPACE per disparar)
+            processar_input(event);
+        }
+
+        // Actualitzar física del joc amb delta_time real
+        actualitzar(delta_time);
+
+        // Actualitzar colors oscil·lats
+        sdl_.updateColors(delta_time);
+
+        // Netejar pantalla (usa color oscil·lat)
+        sdl_.neteja(0, 0, 0);
+
+        // Dibuixar joc
+        dibuixar();
+
+        // Presentar renderer (swap buffers)
+        sdl_.presenta();
     }
 
-    // Processar events SDL
+    std::cout << "Escena Joc: Finalitzant...\n";
-    while (SDL_PollEvent(&event)) {
-      // Manejo de finestra
-      if (sdl_.handleWindowEvent(event)) {
-        continue;
-      }
-
-      // Events globals (F1/F2/F3/ESC/QUIT)
-      if (GlobalEvents::handle(event, sdl_)) {
-        continue;
-      }
-
-      // Processament específic del joc (SPACE per disparar)
-      processar_input(event);
-    }
-
-    // Actualitzar física del joc amb delta_time real
-    actualitzar(delta_time);
-
-    // Actualitzar colors oscil·lats
-    sdl_.updateColors(delta_time);
-
-    // Netejar pantalla (usa color oscil·lat)
-    sdl_.neteja(0, 0, 0);
-
-    // Dibuixar joc
-    dibuixar();
-
-    // Presentar renderer (swap buffers)
-    sdl_.presenta();
-  }
-
-  std::cout << "Escena Joc: Finalitzant...\n";
 }
 
 void EscenaJoc::inicialitzar() {
-  // Inicialitzar generador de números aleatoris
+    // Inicialitzar generador de números aleatoris
-  // Basat en el codi Pascal original: line 376
+    // Basat en el codi Pascal original: line 376
-  std::srand(static_cast<unsigned>(std::time(nullptr)));
+    std::srand(static_cast<unsigned>(std::time(nullptr)));
 
-  // Inicialitzar estat de col·lisió
+    // Inicialitzar estat de col·lisió
-  itocado_ = 0;
+    itocado_ = 0;
 
-  // Inicialitzar nau
+    // Inicialitzar nau
-  nau_.inicialitzar();
+    nau_.inicialitzar();
 
-  // Inicialitzar enemics (ORNIs)
+    // Inicialitzar enemics (ORNIs)
-  for (auto &enemy : orni_) {
+    for (auto& enemy : orni_) {
-    enemy.inicialitzar();
+        enemy.inicialitzar();
-  }
+    }
 
-  // Inicialitzar bales
+    // Inicialitzar bales
-  for (auto &bala : bales_) {
+    for (auto& bala : bales_) {
-    bala.inicialitzar();
+        bala.inicialitzar();
-  }
+    }
 }
 
 void EscenaJoc::actualitzar(float delta_time) {
-  // Actualitzar nau (input + física)
+    // Actualitzar nau (input + física)
-  nau_.processar_input(delta_time);
+    nau_.processar_input(delta_time);
-  nau_.actualitzar(delta_time);
+    nau_.actualitzar(delta_time);
 
-  // Actualitzar moviment i rotació dels enemics (ORNIs)
+    // Actualitzar moviment i rotació dels enemics (ORNIs)
-  for (auto &enemy : orni_) {
+    for (auto& enemy : orni_) {
-    enemy.actualitzar(delta_time);
+        enemy.actualitzar(delta_time);
-  }
+    }
 
-  // Actualitzar moviment de bales (Fase 9)
+    // Actualitzar moviment de bales (Fase 9)
-  for (auto &bala : bales_) {
+    for (auto& bala : bales_) {
-    bala.actualitzar(delta_time);
+        bala.actualitzar(delta_time);
-  }
+    }
+
+    // Detectar col·lisions bala-enemic (Fase 10)
+    detectar_col·lisions_bales_enemics();
+
+    // Actualitzar fragments d'explosions
+    debris_manager_.actualitzar(delta_time);
 }
 
 void EscenaJoc::dibuixar() {
-  // Dibuixar marges de la zona de joc
+    // Dibuixar marges de la zona de joc
-  dibuixar_marges();
+    dibuixar_marges();
 
-  // Dibuixar nau
+    // Dibuixar nau
-  nau_.dibuixar();
+    nau_.dibuixar();
 
-  // Dibuixar ORNIs (enemics)
+    // Dibuixar ORNIs (enemics)
-  for (const auto &enemy : orni_) {
+    for (const auto& enemy : orni_) {
-    enemy.dibuixar();
+        enemy.dibuixar();
-  }
+    }
 
-  // Dibuixar bales (Fase 9)
+    // Dibuixar bales (Fase 9)
-  for (const auto &bala : bales_) {
+    for (const auto& bala : bales_) {
-    bala.dibuixar();
+        bala.dibuixar();
-  }
+    }
 
-  // Dibuixar marcador
+    // Dibuixar fragments d'explosions (després d'altres objectes)
-  dibuixar_marcador();
+    debris_manager_.dibuixar();
+
+    // Dibuixar marcador
+    dibuixar_marcador();
 }
 
-void EscenaJoc::processar_input(const SDL_Event &event) {
+void EscenaJoc::processar_input(const SDL_Event& event) {
-  // Processament d'input per events puntuals (no continus)
+    // Processament d'input per events puntuals (no continus)
-  // L'input continu (fletxes) es processa en actualitzar() amb
+    // L'input continu (fletxes) es processa en actualitzar() amb
-  // SDL_GetKeyboardState()
+    // SDL_GetKeyboardState()
 
-  if (event.type == SDL_EVENT_KEY_DOWN) {
+    if (event.type == SDL_EVENT_KEY_DOWN) {
-    switch (event.key.key) {
+        switch (event.key.key) {
-    case SDLK_SPACE:
+            case SDLK_SPACE: {
-      // Disparar (Fase 9)
+                // No disparar si la nau està morta
-      // Basat en el codi Pascal original: crear bala en posició de la nau
+                if (!nau_.esta_viva()) {
-      // El joc original només permetia 1 bala activa alhora
+                    break;
+                }
 
-      // Buscar primera bala inactiva
+                // Disparar bala des del front de la nau
-      for (auto &bala : bales_) {
+                // El ship.shp té el front a (0, -12) en coordenades locals
-        if (!bala.esta_activa()) {
+
-          bala.disparar(nau_.get_centre(), nau_.get_angle());
+                // 1. Calcular posició del front de la nau
-          break;
+                constexpr float LOCAL_TIP_X = 0.0f;
+                constexpr float LOCAL_TIP_Y = -12.0f;
+
+                const Punt& ship_centre = nau_.get_centre();
+                float ship_angle = nau_.get_angle();
+
+                // Aplicar transformació: rotació + trasllació
+                float cos_a = std::cos(ship_angle);
+                float sin_a = std::sin(ship_angle);
+
+                float tip_x = LOCAL_TIP_X * cos_a - LOCAL_TIP_Y * sin_a + ship_centre.x;
+                float tip_y = LOCAL_TIP_X * sin_a + LOCAL_TIP_Y * cos_a + ship_centre.y;
+
+                Punt posicio_dispar = {tip_x, tip_y};
+
+                // 2. Buscar primera bala inactiva i disparar
+                for (auto& bala : bales_) {
+                    if (!bala.esta_activa()) {
+                        bala.disparar(posicio_dispar, ship_angle);
+                        break;  // Només una bala per polsació
+                    }
+                }
+                break;
+            }
+
+            default:
+                break;
         }
-      }
-      break;
-
-    default:
-      break;
     }
-  }
 }
 
 void EscenaJoc::tocado() {
-  // TODO: Implementar seqüència de mort
+    // TODO: Implementar seqüència de mort
 }
 
 void EscenaJoc::dibuixar_marges() const {
-  // Dibuixar rectangle de la zona de joc
+    // Dibuixar rectangle de la zona de joc
-  const SDL_FRect& zona = Defaults::Zones::GAME;
+    const SDL_FRect& zona = Defaults::Zones::PLAYAREA;
 
-  // Coordenades dels cantons
+    // Coordenades dels cantons
-  int x1 = static_cast<int>(zona.x);
+    int x1 = static_cast<int>(zona.x);
-  int y1 = static_cast<int>(zona.y);
+    int y1 = static_cast<int>(zona.y);
-  int x2 = static_cast<int>(zona.x + zona.w);
+    int x2 = static_cast<int>(zona.x + zona.w);
-  int y2 = static_cast<int>(zona.y + zona.h);
+    int y2 = static_cast<int>(zona.y + zona.h);
 
-  // 4 línies per formar el rectangle
+    // 4 línies per formar el rectangle
-  Rendering::linea(sdl_.obte_renderer(), x1, y1, x2, y1, true); // Top
+    Rendering::linea(sdl_.obte_renderer(), x1, y1, x2, y1, true);  // Top
-  Rendering::linea(sdl_.obte_renderer(), x1, y2, x2, y2, true); // Bottom
+    Rendering::linea(sdl_.obte_renderer(), x1, y2, x2, y2, true);  // Bottom
-  Rendering::linea(sdl_.obte_renderer(), x1, y1, x1, y2, true); // Left
+    Rendering::linea(sdl_.obte_renderer(), x1, y1, x1, y2, true);  // Left
-  Rendering::linea(sdl_.obte_renderer(), x2, y1, x2, y2, true); // Right
+    Rendering::linea(sdl_.obte_renderer(), x2, y1, x2, y2, true);  // Right
 }
 
 void EscenaJoc::dibuixar_marcador() {
-  // Text estàtic (hardcoded)
+    // Text estàtic (hardcoded)
-  const std::string text = "SCORE: 00000  LIFE: 3  LEVEL: 01";
+    const std::string text = "SCORE: 01000  LIFE: 3  LEVEL: 01";
 
-  // Escala ajustada per cabre en 640px d'amplada
+    // Paràmetres de renderització
-  // Zona marcador: width = 640 px, height = 64 px
+    const float escala = 0.85f;
-  // Text: 34 caràcters → necessitem ~487 px amb escala 1.2
+    const float spacing = 0.0f;
-  // Altura caràcter: 20 * 1.2 = 24 px (37.5% de 64px)
-  const float escala = 1.2f;
-  const float spacing = 2.0f;
 
-  // Calcular amplada total del text
+    // Calcular dimensions del text
-  float text_width = text_.get_text_width(text, escala, spacing);
+    float text_width = text_.get_text_width(text, escala, spacing);
+    float text_height = text_.get_text_height(escala);
 
-  // Centrat horitzontal
+    // Centrat horitzontal dins de la zona del marcador
-  float x = (Defaults::Zones::SCOREBOARD.w - text_width) / 2.0f;
+    float x = (Defaults::Zones::SCOREBOARD.w - text_width) / 2.0f;
 
-  // Centrat vertical
+    // Centrat vertical dins de la zona del marcador
-  // Altura del caràcter escalat: 20 * 1.2 = 24 px
+    float y = Defaults::Zones::SCOREBOARD.y +
-  // Marge superior: (64 - 24) / 2 = 20 px
+        (Defaults::Zones::SCOREBOARD.h - text_height) / 2.0f;
-  float y = Defaults::Zones::SCOREBOARD.y + 20.0f;
 
-  // Renderitzar
+    // Renderitzar
-  text_.render(text, {x, y}, escala, spacing);
+    text_.render(text, {x, y}, escala, spacing);
+}
+
+void EscenaJoc::detectar_col·lisions_bales_enemics() {
+    // Constants amplificades per hitbox més generós (115%)
+    constexpr float RADI_BALA = Defaults::Entities::BULLET_RADIUS;
+    constexpr float RADI_ENEMIC = Defaults::Entities::ENEMY_RADIUS;
+    constexpr float SUMA_RADIS = (RADI_BALA + RADI_ENEMIC) * 1.15f;  // 28.75 px
+    constexpr float SUMA_RADIS_QUADRAT = SUMA_RADIS * SUMA_RADIS;    // 826.56
+
+    // Velocitat d'explosió reduïda per efecte suau
+    constexpr float VELOCITAT_EXPLOSIO = 50.0f;  // px/s (en lloc de 80.0f per defecte)
+
+    // Iterar per totes les bales actives
+    for (auto& bala : bales_) {
+        if (!bala.esta_activa()) {
+            continue;
+        }
+
+        const Punt& pos_bala = bala.get_centre();
+
+        // Comprovar col·lisió amb tots els enemics actius
+        for (auto& enemic : orni_) {
+            if (!enemic.esta_actiu()) {
+                continue;
+            }
+
+            const Punt& pos_enemic = enemic.get_centre();
+
+            // Calcular distància quadrada (evita sqrt)
+            float dx = pos_bala.x - pos_enemic.x;
+            float dy = pos_bala.y - pos_enemic.y;
+            float distancia_quadrada = dx * dx + dy * dy;
+
+            // Comprovar col·lisió
+            if (distancia_quadrada <= SUMA_RADIS_QUADRAT) {
+                // *** COL·LISIÓ DETECTADA ***
+
+                // 1. Destruir enemic (marca com inactiu)
+                enemic.destruir();
+
+                // 2. Crear explosió de fragments
+                debris_manager_.explotar(
+                    enemic.get_forma(),      // Forma vectorial del pentàgon
+                    pos_enemic,              // Posició central
+                    0.0f,                    // Angle (enemic té rotació interna)
+                    1.0f,                    // Escala normal
+                    VELOCITAT_EXPLOSIO       // 50 px/s (explosió suau)
+                );
+
+                // 3. Desactivar bala
+                bala.desactivar();
+
+                // 4. Eixir del bucle intern (bala només destrueix 1 enemic)
+                break;
+            }
+        }
+    }
 }

source/game/escenes/escena_joc.hpp

@@ -5,46 +5,53 @@
 #ifndef ESCENA_JOC_HPP
 #define ESCENA_JOC_HPP
 
+#include <SDL3/SDL.h>
+
+#include <array>
+#include <cstdint>
+
 #include "../../core/graphics/vector_text.hpp"
 #include "../../core/rendering/sdl_manager.hpp"
 #include "../../core/types.hpp"
 #include "../constants.hpp"
+#include "../effects/debris_manager.hpp"
 #include "../entities/bala.hpp"
 #include "../entities/enemic.hpp"
 #include "../entities/nau.hpp"
-#include <SDL3/SDL.h>
-#include <array>
-#include <cstdint>
 
 // Classe principal del joc (escena)
 class EscenaJoc {
-public:
+    public:
-  explicit EscenaJoc(SDLManager& sdl);
+        explicit EscenaJoc(SDLManager& sdl);
-  ~EscenaJoc() = default;
+        ~EscenaJoc() = default;
 
-  void executar();  // Bucle principal de l'escena
+        void executar();  // Bucle principal de l'escena
-  void inicialitzar();
+        void inicialitzar();
-  void actualitzar(float delta_time);
+        void actualitzar(float delta_time);
-  void dibuixar();
+        void dibuixar();
-  void processar_input(const SDL_Event &event);
+        void processar_input(const SDL_Event& event);
 
-private:
+    private:
-  SDLManager& sdl_;
+        SDLManager& sdl_;
 
-  // Estat del joc
+        // Efectes visuals
-  Nau nau_;
+        Effects::DebrisManager debris_manager_;
-  std::array<Enemic, Constants::MAX_ORNIS> orni_;
-  std::array<Bala, Constants::MAX_BALES> bales_;
-  Poligon chatarra_cosmica_;
-  uint16_t itocado_;
 
-  // Text vectorial
+        // Estat del joc
-  Graphics::VectorText text_;
+        Nau nau_;
+        std::array<Enemic, Constants::MAX_ORNIS> orni_;
+        std::array<Bala, Constants::MAX_BALES> bales_;
+        Poligon chatarra_cosmica_;
+        uint16_t itocado_;
 
-  // Funcions privades
+        // Text vectorial
-  void tocado();
+        Graphics::VectorText text_;
-  void dibuixar_marges() const; // Dibuixar vores de la zona de joc
+
-  void dibuixar_marcador();     // Dibuixar marcador de puntuació
+        // Funcions privades
+        void tocado();
+        void detectar_col·lisions_bales_enemics();  // Col·lisions bala-enemic
+        void dibuixar_marges() const;  // Dibuixar vores de la zona de joc
+        void dibuixar_marcador();      // Dibuixar marcador de puntuació
 };
 
-#endif // ESCENA_JOC_HPP
+#endif  // ESCENA_JOC_HPP

source/game/escenes/escena_logo.cpp

@@ -2,262 +2,343 @@
 // © 2025 Port a C++20
 
 #include "escena_logo.hpp"
-#include "../../core/system/gestor_escenes.hpp"
+
-#include "../../core/system/global_events.hpp"
+#include <algorithm>
+#include <cfloat>
+#include <iostream>
+
 #include "../../core/graphics/shape_loader.hpp"
 #include "../../core/rendering/shape_renderer.hpp"
-#include <iostream>
+#include "../../core/system/gestor_escenes.hpp"
-#include <cfloat>
+#include "../../core/system/global_events.hpp"
-#include <algorithm>
 
 // Helper: calcular el progrés individual d'una lletra
 // en funció del progrés global (efecte seqüencial)
-static float calcular_progress_letra(size_t letra_index,
+static float calcular_progress_letra(size_t letra_index, size_t num_letras, float global_progress, float threshold) {
-                                     size_t num_letras,
+    if (num_letras == 0)
-                                     float global_progress,
+        return 1.0f;
-                                     float threshold) {
-  if (num_letras == 0)
-    return 1.0f;
 
-  // Calcular temps per lletra
+    // Calcular temps per lletra
-  float duration_per_letra = 1.0f / static_cast<float>(num_letras);
+    float duration_per_letra = 1.0f / static_cast<float>(num_letras);
-  float step = threshold * duration_per_letra;
+    float step = threshold * duration_per_letra;
-  float start = static_cast<float>(letra_index) * step;
+    float start = static_cast<float>(letra_index) * step;
-  float end = start + duration_per_letra;
+    float end = start + duration_per_letra;
 
-  // Interpolar progrés
+    // Interpolar progrés
-  if (global_progress < start) {
+    if (global_progress < start) {
-    return 0.0f;  // Encara no ha començat
+        return 0.0f;  // Encara no ha començat
-  } else if (global_progress >= end) {
+    } else if (global_progress >= end) {
-    return 1.0f;  // Completament apareguda
+        return 1.0f;  // Completament apareguda
-  } else {
+    } else {
-    return (global_progress - start) / (end - start);
+        return (global_progress - start) / (end - start);
-  }
+    }
 }
 
 EscenaLogo::EscenaLogo(SDLManager& sdl)
-  : sdl_(sdl),
+    : sdl_(sdl),
-    estat_actual_(EstatAnimacio::PRE_ANIMATION),
+      estat_actual_(EstatAnimacio::PRE_ANIMATION),
-    temps_estat_actual_(0.0f) {
+      temps_estat_actual_(0.0f),
-  std::cout << "Escena Logo: Inicialitzant...\n";
+      debris_manager_(std::make_unique<Effects::DebrisManager>(sdl.obte_renderer())),
-  inicialitzar_lletres();
+      lletra_explosio_index_(0),
+      temps_des_ultima_explosio_(0.0f) {
+    std::cout << "Escena Logo: Inicialitzant...\n";
+    inicialitzar_lletres();
 }
 
 void EscenaLogo::executar() {
-  SDL_Event event;
+    SDL_Event event;
-  Uint64 last_time = SDL_GetTicks();
+    Uint64 last_time = SDL_GetTicks();
 
-  while (GestorEscenes::actual == GestorEscenes::Escena::LOGO) {
+    while (GestorEscenes::actual == GestorEscenes::Escena::LOGO) {
-    // Calcular delta_time real
+        // Calcular delta_time real
-    Uint64 current_time = SDL_GetTicks();
+        Uint64 current_time = SDL_GetTicks();
-    float delta_time = (current_time - last_time) / 1000.0f;
+        float delta_time = (current_time - last_time) / 1000.0f;
-    last_time = current_time;
+        last_time = current_time;
 
-    // Limitar delta_time per evitar grans salts
+        // Limitar delta_time per evitar grans salts
-    if (delta_time > 0.05f) {
+        if (delta_time > 0.05f) {
-      delta_time = 0.05f;
+            delta_time = 0.05f;
+        }
+
+        // Actualitzar comptador de FPS
+        sdl_.updateFPS(delta_time);
+
+        // Processar events SDL
+        while (SDL_PollEvent(&event)) {
+            // Manejo de finestra
+            if (sdl_.handleWindowEvent(event)) {
+                continue;
+            }
+
+            // Events globals (F1/F2/F3/ESC/QUIT)
+            if (GlobalEvents::handle(event, sdl_)) {
+                continue;
+            }
+
+            // Processar events de l'escena (qualsevol tecla/clic salta al joc)
+            processar_events(event);
+        }
+
+        // Actualitzar lògica
+        actualitzar(delta_time);
+
+        // Actualitzar colors oscil·lats (efecte verd global)
+        sdl_.updateColors(delta_time);
+
+        // Dibuixar
+        dibuixar();
     }
 
-    // Processar events SDL
+    std::cout << "Escena Logo: Finalitzant...\n";
-    while (SDL_PollEvent(&event)) {
-      // Manejo de finestra
-      if (sdl_.handleWindowEvent(event)) {
-        continue;
-      }
-
-      // Events globals (F1/F2/F3/ESC/QUIT)
-      if (GlobalEvents::handle(event, sdl_)) {
-        continue;
-      }
-
-      // Processar events de l'escena (qualsevol tecla/clic salta al joc)
-      processar_events(event);
-    }
-
-    // Actualitzar lògica
-    actualitzar(delta_time);
-
-    // Actualitzar colors oscil·lats (efecte verd global)
-    sdl_.updateColors(delta_time);
-
-    // Dibuixar
-    dibuixar();
-  }
-
-  std::cout << "Escena Logo: Finalitzant...\n";
 }
 
 void EscenaLogo::inicialitzar_lletres() {
-  using namespace Graphics;
+    using namespace Graphics;
 
-  // Llista de fitxers .shp (A repetida per a les dues A's)
+    // Llista de fitxers .shp (A repetida per a les dues A's)
-  std::vector<std::string> fitxers = {
+    std::vector<std::string> fitxers = {
-    "logo/letra_j.shp", "logo/letra_a.shp", "logo/letra_i.shp", "logo/letra_l.shp",
+        "logo/letra_j.shp",
-    "logo/letra_g.shp", "logo/letra_a.shp", "logo/letra_m.shp", "logo/letra_e.shp", "logo/letra_s.shp"
+        "logo/letra_a.shp",
-  };
+        "logo/letra_i.shp",
+        "logo/letra_l.shp",
+        "logo/letra_g.shp",
+        "logo/letra_a.shp",
+        "logo/letra_m.shp",
+        "logo/letra_e.shp",
+        "logo/letra_s.shp"};
 
-  // Pas 1: Carregar totes les formes i calcular amplades
+    // Pas 1: Carregar totes les formes i calcular amplades
-  float ancho_total = 0.0f;
+    float ancho_total = 0.0f;
 
-  for (const auto& fitxer : fitxers) {
+    for (const auto& fitxer : fitxers) {
-    auto forma = ShapeLoader::load(fitxer);
+        auto forma = ShapeLoader::load(fitxer);
-    if (!forma || !forma->es_valida()) {
+        if (!forma || !forma->es_valida()) {
-      std::cerr << "[EscenaLogo] Error carregant " << fitxer << std::endl;
+            std::cerr << "[EscenaLogo] Error carregant " << fitxer << std::endl;
-      continue;
+            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_sin_escalar = max_x - min_x;
+
+        // IMPORTANT: Escalar ancho i offset amb ESCALA_FINAL
+        // per que les posicions finals coincideixin amb la mida real de les lletres
+        float ancho = ancho_sin_escalar * ESCALA_FINAL;
+        float offset_centre = (forma->get_centre().x - min_x) * ESCALA_FINAL;
+
+        lletres_.push_back({forma,
+            {0.0f, 0.0f},  // Posició es calcularà després
+            ancho,
+            offset_centre});
+
+        ancho_total += ancho;
     }
 
-    // Calcular bounding box de la forma (trobar ancho)
+    // Pas 2: Afegir espaiat entre lletres
-    float min_x = FLT_MAX;
+    ancho_total += ESPAI_ENTRE_LLETRES * (lletres_.size() - 1);
-    float max_x = -FLT_MAX;
 
-    for (const auto& prim : forma->get_primitives()) {
+    // Pas 3: Calcular posició inicial (centrat horitzontal)
-      for (const auto& punt : prim.points) {
+    constexpr float PANTALLA_ANCHO = 640.0f;
-        min_x = std::min(min_x, punt.x);
+    constexpr float PANTALLA_ALTO = 480.0f;
-        max_x = std::max(max_x, punt.x);
+
-      }
+    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_) {
+        // Posicionar el centre de la forma (shape_centre) en pantalla
+        // Usar offset_centre en lloc de ancho/2 perquè shape_centre
+        // pot no estar exactament al mig del bounding box
+        lletra.posicio.x = x_actual + lletra.offset_centre;
+        lletra.posicio.y = y_centre;
+
+        // Avançar per a següent lletra
+        x_actual += lletra.ancho + ESPAI_ENTRE_LLETRES;
     }
 
-    float ancho_sin_escalar = max_x - min_x;
+    std::cout << "[EscenaLogo] " << lletres_.size()
-
+              << " lletres carregades, ancho total: " << ancho_total << " px\n";
-    // IMPORTANT: Escalar ancho i offset amb ESCALA_FINAL
-    // per que les posicions finals coincideixin amb la mida real de les lletres
-    float ancho = ancho_sin_escalar * ESCALA_FINAL;
-    float offset_centre = (forma->get_centre().x - min_x) * ESCALA_FINAL;
-
-    lletres_.push_back({
-      forma,
-      {0.0f, 0.0f},  // Posició es calcularà després
-      ancho,
-      offset_centre
-    });
-
-    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_) {
-    // Posicionar el centre de la forma (shape_centre) en pantalla
-    // Usar offset_centre en lloc de ancho/2 perquè shape_centre
-    // pot no estar exactament al mig del bounding box
-    lletra.posicio.x = x_actual + lletra.offset_centre;
-    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";
 }
 
 void EscenaLogo::canviar_estat(EstatAnimacio nou_estat) {
-  estat_actual_ = nou_estat;
+    estat_actual_ = nou_estat;
-  temps_estat_actual_ = 0.0f;  // Reset temps
+    temps_estat_actual_ = 0.0f;  // Reset temps
-  std::cout << "[EscenaLogo] Canvi a estat: " << static_cast<int>(nou_estat) << "\n";
+
+    // Inicialitzar estat d'explosió
+    if (nou_estat == EstatAnimacio::EXPLOSION) {
+        lletra_explosio_index_ = 0;
+        temps_des_ultima_explosio_ = 0.0f;
+    }
+
+    std::cout << "[EscenaLogo] Canvi a estat: " << static_cast<int>(nou_estat)
+              << "\n";
 }
 
 bool EscenaLogo::totes_lletres_completes() const {
-  // Quan global_progress = 1.0, totes les lletres tenen letra_progress = 1.0
+    // Quan global_progress = 1.0, totes les lletres tenen letra_progress = 1.0
-  return temps_estat_actual_ >= DURACIO_ZOOM;
+    return temps_estat_actual_ >= DURACIO_ZOOM;
+}
+
+void EscenaLogo::actualitzar_explosions(float delta_time) {
+    temps_des_ultima_explosio_ += delta_time;
+
+    // Comprovar si és el moment d'explotar la següent lletra
+    if (temps_des_ultima_explosio_ >= DELAY_ENTRE_EXPLOSIONS) {
+        if (lletra_explosio_index_ < lletres_.size()) {
+            // Explotar lletra actual
+            const auto& lletra = lletres_[lletra_explosio_index_];
+
+            debris_manager_->explotar(
+                lletra.forma,       // Forma a explotar
+                lletra.posicio,     // Posició
+                0.0f,               // Angle (sense rotació)
+                ESCALA_FINAL,       // Escala (lletres a escala final)
+                VELOCITAT_EXPLOSIO  // Velocitat base
+            );
+
+            std::cout << "[EscenaLogo] Explota lletra " << lletra_explosio_index_ << "\n";
+
+            // Passar a la següent lletra
+            lletra_explosio_index_++;
+            temps_des_ultima_explosio_ = 0.0f;
+        } else {
+            // Totes les lletres han explotat, transició a POST_EXPLOSION
+            canviar_estat(EstatAnimacio::POST_EXPLOSION);
+        }
+    }
 }
 
 void EscenaLogo::actualitzar(float delta_time) {
-  temps_estat_actual_ += delta_time;
+    temps_estat_actual_ += delta_time;
 
-  switch (estat_actual_) {
+    switch (estat_actual_) {
-    case EstatAnimacio::PRE_ANIMATION:
+        case EstatAnimacio::PRE_ANIMATION:
-      if (temps_estat_actual_ >= DURACIO_PRE) {
+            if (temps_estat_actual_ >= DURACIO_PRE) {
-        canviar_estat(EstatAnimacio::ANIMATION);
+                canviar_estat(EstatAnimacio::ANIMATION);
-      }
+            }
-      break;
+            break;
 
-    case EstatAnimacio::ANIMATION:
+        case EstatAnimacio::ANIMATION:
-      if (totes_lletres_completes()) {
+            if (totes_lletres_completes()) {
-        canviar_estat(EstatAnimacio::POST_ANIMATION);
+                canviar_estat(EstatAnimacio::POST_ANIMATION);
-      }
+            }
-      break;
+            break;
 
-    case EstatAnimacio::POST_ANIMATION:
+        case EstatAnimacio::POST_ANIMATION:
-      if (temps_estat_actual_ >= DURACIO_POST) {
+            if (temps_estat_actual_ >= DURACIO_POST_ANIMATION) {
-        GestorEscenes::actual = GestorEscenes::Escena::JOC;
+                canviar_estat(EstatAnimacio::EXPLOSION);
-      }
+            }
-      break;
+            break;
-  }
+
+        case EstatAnimacio::EXPLOSION:
+            actualitzar_explosions(delta_time);
+            break;
+
+        case EstatAnimacio::POST_EXPLOSION:
+            if (temps_estat_actual_ >= DURACIO_POST_EXPLOSION) {
+                GestorEscenes::actual = GestorEscenes::Escena::JOC;
+            }
+            break;
+    }
+
+    // Actualitzar animacions de debris
+    debris_manager_->actualitzar(delta_time);
 }
 
 void EscenaLogo::dibuixar() {
-  // Fons negre
+    // Fons negre
-  sdl_.neteja(0, 0, 0);
+    sdl_.neteja(0, 0, 0);
 
-  // PRE_ANIMATION: Només pantalla negra
+    // PRE_ANIMATION: Només pantalla negra
-  if (estat_actual_ == EstatAnimacio::PRE_ANIMATION) {
+    if (estat_actual_ == EstatAnimacio::PRE_ANIMATION) {
-    sdl_.presenta();
+        sdl_.presenta();
-    return;  // No renderitzar lletres
+        return;  // No renderitzar lletres
-  }
-
-  // ANIMATION o POST_ANIMATION: Calcular progrés
-  float global_progress = (estat_actual_ == EstatAnimacio::ANIMATION)
-    ? std::min(temps_estat_actual_ / DURACIO_ZOOM, 1.0f)
-    : 1.0f;  // POST: mantenir al 100%
-
-  // Punt inicial del zoom (configurable amb ORIGEN_ZOOM_X/Y)
-  const Punt ORIGEN_ZOOM = {ORIGEN_ZOOM_X, ORIGEN_ZOOM_Y};
-
-  // Dibuixar cada lletra amb animació seqüencial
-  for (size_t i = 0; i < lletres_.size(); i++) {
-    const auto& lletra = lletres_[i];
-
-    // Calcular progrés individual d'aquesta lletra (0.0 → 1.0)
-    float letra_progress = calcular_progress_letra(i, lletres_.size(), global_progress, THRESHOLD_LETRA);
-
-    // Si la lletra encara no ha començat, saltar-la
-    if (letra_progress <= 0.0f) {
-      continue;
     }
 
-    // Interpolar posició: des del origen zoom cap a posició final
+    // ANIMATION o POST_ANIMATION: Dibuixar lletres amb animació
-    Punt pos_actual;
+    if (estat_actual_ == EstatAnimacio::ANIMATION ||
-    pos_actual.x = ORIGEN_ZOOM.x + (lletra.posicio.x - ORIGEN_ZOOM.x) * letra_progress;
+        estat_actual_ == EstatAnimacio::POST_ANIMATION) {
-    pos_actual.y = ORIGEN_ZOOM.y + (lletra.posicio.y - ORIGEN_ZOOM.y) * letra_progress;
+        float global_progress =
+            (estat_actual_ == EstatAnimacio::ANIMATION)
+            ? std::min(temps_estat_actual_ / DURACIO_ZOOM, 1.0f)
+            : 1.0f;  // POST: mantenir al 100%
 
-    // Aplicar ease-out quadràtic per suavitat
+        const Punt ORIGEN_ZOOM = {ORIGEN_ZOOM_X, ORIGEN_ZOOM_Y};
-    float t = letra_progress;
-    float ease_factor = 1.0f - (1.0f - t) * (1.0f - t);
 
-    // Interpolar escala amb ease-out: des de ESCALA_INICIAL cap a ESCALA_FINAL
+        for (size_t i = 0; i < lletres_.size(); i++) {
-    float escala_actual = ESCALA_INICIAL + (ESCALA_FINAL - ESCALA_INICIAL) * ease_factor;
+            const auto& lletra = lletres_[i];
 
-    // Renderitzar la lletra
+            float letra_progress = calcular_progress_letra(
-    Rendering::render_shape(
+                i,
-      sdl_.obte_renderer(),
+                lletres_.size(),
-      lletra.forma,
+                global_progress,
-      pos_actual,        // Posició interpolada
+                THRESHOLD_LETRA);
-      0.0f,              // Sense rotació
-      escala_actual,     // Escala interpolada amb ease-out
-      true,              // Dibuixar
-      1.0f               // Progress = 1.0 (lletra completa, sense animació de primitives)
-    );
-  }
 
-  sdl_.presenta();
+            if (letra_progress <= 0.0f) {
+                continue;
+            }
+
+            Punt pos_actual;
+            pos_actual.x =
+                ORIGEN_ZOOM.x + (lletra.posicio.x - ORIGEN_ZOOM.x) * letra_progress;
+            pos_actual.y =
+                ORIGEN_ZOOM.y + (lletra.posicio.y - ORIGEN_ZOOM.y) * letra_progress;
+
+            float t = letra_progress;
+            float ease_factor = 1.0f - (1.0f - t) * (1.0f - t);
+            float escala_actual =
+                ESCALA_INICIAL + (ESCALA_FINAL - ESCALA_INICIAL) * ease_factor;
+
+            Rendering::render_shape(
+                sdl_.obte_renderer(),
+                lletra.forma,
+                pos_actual,
+                0.0f,
+                escala_actual,
+                true,
+                1.0f);
+        }
+    }
+
+    // EXPLOSION: Dibuixar només lletres que encara no han explotat
+    if (estat_actual_ == EstatAnimacio::EXPLOSION) {
+        for (size_t i = lletra_explosio_index_; i < lletres_.size(); i++) {
+            const auto& lletra = lletres_[i];
+
+            Rendering::render_shape(
+                sdl_.obte_renderer(),
+                lletra.forma,
+                lletra.posicio,
+                0.0f,
+                ESCALA_FINAL,
+                true,
+                1.0f);
+        }
+    }
+
+    // POST_EXPLOSION: No dibuixar lletres, només debris (a baix)
+
+    // Sempre dibuixar debris (si n'hi ha d'actius)
+    debris_manager_->dibuixar();
+
+    sdl_.presenta();
 }
 
 void EscenaLogo::processar_events(const SDL_Event& event) {
-  // Qualsevol tecla o clic de ratolí salta al joc
+    // Qualsevol tecla o clic de ratolí salta al joc
-  if (event.type == SDL_EVENT_KEY_DOWN ||
+    if (event.type == SDL_EVENT_KEY_DOWN ||
-      event.type == SDL_EVENT_MOUSE_BUTTON_DOWN) {
+        event.type == SDL_EVENT_MOUSE_BUTTON_DOWN) {
-    GestorEscenes::actual = GestorEscenes::Escena::JOC;
+        GestorEscenes::actual = GestorEscenes::Escena::JOC;
-  }
+    }
 }

source/game/escenes/escena_logo.hpp

@@ -4,60 +4,78 @@
 
 #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>
+#include <vector>
+
+#include "../../core/graphics/shape.hpp"
+#include "../../core/rendering/sdl_manager.hpp"
+#include "../../core/types.hpp"
+#include "../effects/debris_manager.hpp"
+#include "core/defaults.hpp"
 
 class EscenaLogo {
-public:
+    public:
-  explicit EscenaLogo(SDLManager& sdl);
+        explicit EscenaLogo(SDLManager& sdl);
-  void executar();  // Bucle principal de l'escena
+        void executar();  // Bucle principal de l'escena
 
-private:
+    private:
-  // Màquina d'estats per l'animació
+        // Màquina d'estats per l'animació
-  enum class EstatAnimacio {
+        enum class EstatAnimacio {
-    PRE_ANIMATION,   // Pantalla negra inicial
+            PRE_ANIMATION,   // Pantalla negra inicial
-    ANIMATION,       // Animació de zoom de lletres
+            ANIMATION,       // Animació de zoom de lletres
-    POST_ANIMATION   // Logo complet visible
+            POST_ANIMATION,  // Logo complet visible
-  };
+            EXPLOSION,       // Explosió seqüencial de lletres
+            POST_EXPLOSION   // Espera després de l'última explosió
+        };
 
-  SDLManager& sdl_;
+        SDLManager& sdl_;
-  EstatAnimacio estat_actual_;      // Estat actual de la màquina
+        EstatAnimacio estat_actual_;  // Estat actual de la màquina
-  float temps_estat_actual_;        // Temps en l'estat actual (reset en cada transició)
+        float
+            temps_estat_actual_;  // Temps en l'estat actual (reset en cada transició)
 
-  // Estructura per a cada lletra del logo
+        // Gestor de fragments d'explosions
-  struct LetraLogo {
+        std::unique_ptr<Effects::DebrisManager> debris_manager_;
-    std::shared_ptr<Graphics::Shape> forma;
-    Punt posicio;        // Posició final en pantalla
-    float ancho;         // Ancho del bounding box
-    float offset_centre; // Distància de min_x a shape_centre.x
-  };
 
-  std::vector<LetraLogo> lletres_;  // 9 lletres: J-A-I-L-G-A-M-E-S
+        // Seguiment d'explosions seqüencials
+        size_t lletra_explosio_index_;     // Índex de la següent lletra a explotar
+        float temps_des_ultima_explosio_;  // Temps des de l'última explosió
 
-  // Constants d'animació
+        // Estructura per a cada lletra del logo
-  static constexpr float DURACIO_PRE = 1.5f;               // Duració PRE_ANIMATION (pantalla negra)
+        struct LetraLogo {
-  static constexpr float DURACIO_ZOOM = 4.0f;              // Duració del zoom (segons)
+                std::shared_ptr<Graphics::Shape> forma;
-  static constexpr float DURACIO_POST = 4.0f;              // Duració POST_ANIMATION (logo complet)
+                Punt posicio;         // Posició final en pantalla
-  static constexpr float ESCALA_INICIAL = 0.1f;            // Escala inicial (10%)
+                float ancho;          // Ancho del bounding box
-  static constexpr float ESCALA_FINAL = 0.8f;              // Escala final (80%)
+                float offset_centre;  // Distància de min_x a shape_centre.x
-  static constexpr float ESPAI_ENTRE_LLETRES = 10.0f;      // Espaiat entre lletres
+        };
 
-  // Constants d'animació seqüencial
+        std::vector<LetraLogo> lletres_;  // 9 lletres: J-A-I-L-G-A-M-E-S
-  static constexpr float THRESHOLD_LETRA = 0.6f;           // Umbral per activar següent lletra (0.0-1.0)
-  static constexpr float ORIGEN_ZOOM_X = 640.0f / 2.0f;   // Punt inicial X del zoom (320)
-  static constexpr float ORIGEN_ZOOM_Y = 480.0f * 0.4f;   // Punt inicial Y del zoom (240)
 
-  // Mètodes privats
+        // Constants d'animació
-  void inicialitzar_lletres();
+        static constexpr float DURACIO_PRE = 1.5f;             // Duració PRE_ANIMATION (pantalla negra)
-  void actualitzar(float delta_time);
+        static constexpr float DURACIO_ZOOM = 4.0f;            // Duració del zoom (segons)
-  void dibuixar();
+        static constexpr float DURACIO_POST_ANIMATION = 3.0f;  // Duració POST_ANIMATION (logo complet)
-  void processar_events(const SDL_Event& event);
+        static constexpr float DURACIO_POST_EXPLOSION = 3.0f;  // Duració POST_EXPLOSION (espera final)
+        static constexpr float DELAY_ENTRE_EXPLOSIONS = 0.15f;  // Temps entre explosions de lletres
+        static constexpr float VELOCITAT_EXPLOSIO = 80.0f;     // Velocitat 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
 
-  // Mètodes de gestió d'estats
+        // Constants d'animació seqüencial
-  void canviar_estat(EstatAnimacio nou_estat);
+        static constexpr float THRESHOLD_LETRA = 0.6f;         // Umbral per activar següent lletra (0.0-1.0)
-  bool totes_lletres_completes() const;
+        static constexpr float ORIGEN_ZOOM_X = Defaults::Game::WIDTH * 0.5f;  // Punt inicial X del zoom
+        static constexpr float ORIGEN_ZOOM_Y = Defaults::Game::HEIGHT * 0.4f;  // Punt inicial Y del zoom
+
+        // Mètodes privats
+        void inicialitzar_lletres();
+        void actualitzar(float delta_time);
+        void actualitzar_explosions(float delta_time);
+        void dibuixar();
+        void processar_events(const SDL_Event& event);
+
+        // Mètodes de gestió d'estats
+        void canviar_estat(EstatAnimacio nou_estat);
+        bool totes_lletres_completes() const;
 };

source/game/options.cpp

@@ -1,298 +1,323 @@
 #include "options.hpp"
-#include "../core/defaults.hpp"
-#include "../external/fkyaml_node.hpp"
-#include "project.h"
 
 #include <fstream>
 #include <iostream>
 #include <string>
 
+#include "../core/defaults.hpp"
+#include "../external/fkyaml_node.hpp"
+#include "project.h"
+
 namespace Options {
 
 // Inicialitzar opcions amb valors per defecte de Defaults::
 void init() {
 #ifdef _DEBUG
-  console = true;
+    console = true;
 #else
-  console = false;
+    console = false;
 #endif
 
-  // Window
+    // Window
-  window.width = Defaults::Window::WIDTH;
+    window.width = Defaults::Window::WIDTH;
-  window.height = Defaults::Window::HEIGHT;
+    window.height = Defaults::Window::HEIGHT;
-  window.fullscreen = false;
+    window.fullscreen = false;
-  window.size_increment = Defaults::Window::SIZE_INCREMENT;
+    window.size_increment = Defaults::Window::SIZE_INCREMENT;
 
-  // Physics
+    // Physics
-  physics.rotation_speed = Defaults::Physics::ROTATION_SPEED;
+    physics.rotation_speed = Defaults::Physics::ROTATION_SPEED;
-  physics.acceleration = Defaults::Physics::ACCELERATION;
+    physics.acceleration = Defaults::Physics::ACCELERATION;
-  physics.max_velocity = Defaults::Physics::MAX_VELOCITY;
+    physics.max_velocity = Defaults::Physics::MAX_VELOCITY;
-  physics.friction = Defaults::Physics::FRICTION;
+    physics.friction = Defaults::Physics::FRICTION;
-  physics.enemy_speed = Defaults::Physics::ENEMY_SPEED;
+    physics.enemy_speed = Defaults::Physics::ENEMY_SPEED;
-  physics.bullet_speed = Defaults::Physics::BULLET_SPEED;
+    physics.bullet_speed = Defaults::Physics::BULLET_SPEED;
 
-  // Gameplay
+    // Gameplay
-  gameplay.max_enemies = Defaults::Entities::MAX_ORNIS;
+    gameplay.max_enemies = Defaults::Entities::MAX_ORNIS;
-  gameplay.max_bullets = Defaults::Entities::MAX_BALES;
+    gameplay.max_bullets = Defaults::Entities::MAX_BALES;
 
-  // Version
+    // Rendering
-  version = std::string(Project::VERSION);
+    rendering.vsync = Defaults::Rendering::VSYNC_DEFAULT;
+
+    // Version
+    version = std::string(Project::VERSION);
 }
 
 // Establir la ruta del fitxer de configuració
-void setConfigFile(const std::string &path) { config_file_path = path; }
+void setConfigFile(const std::string& path) { config_file_path = path; }
 
 // Funcions auxiliars per carregar seccions del YAML
 
-static void loadWindowConfigFromYaml(const fkyaml::node &yaml) {
+static void loadWindowConfigFromYaml(const fkyaml::node& yaml) {
-  if (yaml.contains("window")) {
+    if (yaml.contains("window")) {
-    const auto &win = yaml["window"];
+        const auto& win = yaml["window"];
 
-    if (win.contains("width")) {
+        if (win.contains("width")) {
-      try {
+            try {
-        auto val = win["width"].get_value<int>();
+                auto val = win["width"].get_value<int>();
-        window.width = (val >= Defaults::Window::MIN_WIDTH)
+                window.width = (val >= Defaults::Window::MIN_WIDTH)
-                           ? val
+                    ? val
-                           : Defaults::Window::WIDTH;
+                    : Defaults::Window::WIDTH;
-      } catch (...) {
+            } catch (...) {
-        window.width = Defaults::Window::WIDTH;
+                window.width = Defaults::Window::WIDTH;
-      }
+            }
-    }
+        }
 
-    if (win.contains("height")) {
+        if (win.contains("height")) {
-      try {
+            try {
-        auto val = win["height"].get_value<int>();
+                auto val = win["height"].get_value<int>();
-        window.height = (val >= Defaults::Window::MIN_HEIGHT)
+                window.height = (val >= Defaults::Window::MIN_HEIGHT)
-                            ? val
+                    ? val
-                            : Defaults::Window::HEIGHT;
+                    : Defaults::Window::HEIGHT;
-      } catch (...) {
+            } catch (...) {
-        window.height = Defaults::Window::HEIGHT;
+                window.height = Defaults::Window::HEIGHT;
-      }
+            }
-    }
+        }
 
-    if (win.contains("fullscreen")) {
+        if (win.contains("fullscreen")) {
-      try {
+            try {
-        window.fullscreen = win["fullscreen"].get_value<bool>();
+                window.fullscreen = win["fullscreen"].get_value<bool>();
-      } catch (...) {
+            } catch (...) {
-        window.fullscreen = false;
+                window.fullscreen = false;
-      }
+            }
-    }
+        }
 
-    if (win.contains("size_increment")) {
+        if (win.contains("size_increment")) {
-      try {
+            try {
-        auto val = win["size_increment"].get_value<int>();
+                auto val = win["size_increment"].get_value<int>();
-        window.size_increment =
+                window.size_increment =
-            (val > 0) ? val : Defaults::Window::SIZE_INCREMENT;
+                    (val > 0) ? val : Defaults::Window::SIZE_INCREMENT;
-      } catch (...) {
+            } catch (...) {
-        window.size_increment = Defaults::Window::SIZE_INCREMENT;
+                window.size_increment = Defaults::Window::SIZE_INCREMENT;
-      }
+            }
+        }
     }
-  }
 }
 
-static void loadPhysicsConfigFromYaml(const fkyaml::node &yaml) {
+static void loadPhysicsConfigFromYaml(const fkyaml::node& yaml) {
-  if (yaml.contains("physics")) {
+    if (yaml.contains("physics")) {
-    const auto &phys = yaml["physics"];
+        const auto& phys = yaml["physics"];
 
-    if (phys.contains("rotation_speed")) {
+        if (phys.contains("rotation_speed")) {
-      try {
+            try {
-        auto val = phys["rotation_speed"].get_value<float>();
+                auto val = phys["rotation_speed"].get_value<float>();
-        physics.rotation_speed =
+                physics.rotation_speed =
-            (val > 0) ? val : Defaults::Physics::ROTATION_SPEED;
+                    (val > 0) ? val : Defaults::Physics::ROTATION_SPEED;
-      } catch (...) {
+            } catch (...) {
-        physics.rotation_speed = Defaults::Physics::ROTATION_SPEED;
+                physics.rotation_speed = Defaults::Physics::ROTATION_SPEED;
-      }
+            }
-    }
+        }
 
-    if (phys.contains("acceleration")) {
+        if (phys.contains("acceleration")) {
-      try {
+            try {
-        auto val = phys["acceleration"].get_value<float>();
+                auto val = phys["acceleration"].get_value<float>();
-        physics.acceleration =
+                physics.acceleration =
-            (val > 0) ? val : Defaults::Physics::ACCELERATION;
+                    (val > 0) ? val : Defaults::Physics::ACCELERATION;
-      } catch (...) {
+            } catch (...) {
-        physics.acceleration = Defaults::Physics::ACCELERATION;
+                physics.acceleration = Defaults::Physics::ACCELERATION;
-      }
+            }
-    }
+        }
 
-    if (phys.contains("max_velocity")) {
+        if (phys.contains("max_velocity")) {
-      try {
+            try {
-        auto val = phys["max_velocity"].get_value<float>();
+                auto val = phys["max_velocity"].get_value<float>();
-        physics.max_velocity =
+                physics.max_velocity =
-            (val > 0) ? val : Defaults::Physics::MAX_VELOCITY;
+                    (val > 0) ? val : Defaults::Physics::MAX_VELOCITY;
-      } catch (...) {
+            } catch (...) {
-        physics.max_velocity = Defaults::Physics::MAX_VELOCITY;
+                physics.max_velocity = Defaults::Physics::MAX_VELOCITY;
-      }
+            }
-    }
+        }
 
-    if (phys.contains("friction")) {
+        if (phys.contains("friction")) {
-      try {
+            try {
-        auto val = phys["friction"].get_value<float>();
+                auto val = phys["friction"].get_value<float>();
-        physics.friction = (val > 0) ? val : Defaults::Physics::FRICTION;
+                physics.friction = (val > 0) ? val : Defaults::Physics::FRICTION;
-      } catch (...) {
+            } catch (...) {
-        physics.friction = Defaults::Physics::FRICTION;
+                physics.friction = Defaults::Physics::FRICTION;
-      }
+            }
-    }
+        }
 
-    if (phys.contains("enemy_speed")) {
+        if (phys.contains("enemy_speed")) {
-      try {
+            try {
-        auto val = phys["enemy_speed"].get_value<float>();
+                auto val = phys["enemy_speed"].get_value<float>();
-        physics.enemy_speed = (val > 0) ? val : Defaults::Physics::ENEMY_SPEED;
+                physics.enemy_speed = (val > 0) ? val : Defaults::Physics::ENEMY_SPEED;
-      } catch (...) {
+            } catch (...) {
-        physics.enemy_speed = Defaults::Physics::ENEMY_SPEED;
+                physics.enemy_speed = Defaults::Physics::ENEMY_SPEED;
-      }
+            }
-    }
+        }
 
-    if (phys.contains("bullet_speed")) {
+        if (phys.contains("bullet_speed")) {
-      try {
+            try {
-        auto val = phys["bullet_speed"].get_value<float>();
+                auto val = phys["bullet_speed"].get_value<float>();
-        physics.bullet_speed =
+                physics.bullet_speed =
-            (val > 0) ? val : Defaults::Physics::BULLET_SPEED;
+                    (val > 0) ? val : Defaults::Physics::BULLET_SPEED;
-      } catch (...) {
+            } catch (...) {
-        physics.bullet_speed = Defaults::Physics::BULLET_SPEED;
+                physics.bullet_speed = Defaults::Physics::BULLET_SPEED;
-      }
+            }
+        }
     }
-  }
 }
 
-static void loadGameplayConfigFromYaml(const fkyaml::node &yaml) {
+static void loadGameplayConfigFromYaml(const fkyaml::node& yaml) {
-  if (yaml.contains("gameplay")) {
+    if (yaml.contains("gameplay")) {
-    const auto &game = yaml["gameplay"];
+        const auto& game = yaml["gameplay"];
 
-    if (game.contains("max_enemies")) {
+        if (game.contains("max_enemies")) {
-      try {
+            try {
-        auto val = game["max_enemies"].get_value<int>();
+                auto val = game["max_enemies"].get_value<int>();
-        gameplay.max_enemies =
+                gameplay.max_enemies =
-            (val > 0 && val <= 50) ? val : Defaults::Entities::MAX_ORNIS;
+                    (val > 0 && val <= 50) ? val : Defaults::Entities::MAX_ORNIS;
-      } catch (...) {
+            } catch (...) {
-        gameplay.max_enemies = Defaults::Entities::MAX_ORNIS;
+                gameplay.max_enemies = Defaults::Entities::MAX_ORNIS;
-      }
+            }
-    }
+        }
 
-    if (game.contains("max_bullets")) {
+        if (game.contains("max_bullets")) {
-      try {
+            try {
-        auto val = game["max_bullets"].get_value<int>();
+                auto val = game["max_bullets"].get_value<int>();
-        gameplay.max_bullets =
+                gameplay.max_bullets =
-            (val > 0 && val <= 10) ? val : Defaults::Entities::MAX_BALES;
+                    (val > 0 && val <= 10) ? val : Defaults::Entities::MAX_BALES;
-      } catch (...) {
+            } catch (...) {
-        gameplay.max_bullets = Defaults::Entities::MAX_BALES;
+                gameplay.max_bullets = Defaults::Entities::MAX_BALES;
-      }
+            }
+        }
+    }
+}
+
+static void loadRenderingConfigFromYaml(const fkyaml::node& yaml) {
+    if (yaml.contains("rendering")) {
+        const auto& rend = yaml["rendering"];
+
+        if (rend.contains("vsync")) {
+            try {
+                int val = rend["vsync"].get_value<int>();
+                // Validar: només 0 o 1
+                rendering.vsync = (val == 0 || val == 1) ? val : Defaults::Rendering::VSYNC_DEFAULT;
+            } catch (...) {
+                rendering.vsync = Defaults::Rendering::VSYNC_DEFAULT;
+            }
+        }
     }
-  }
 }
 
 // Carregar configuració des del fitxer YAML
 auto loadFromFile() -> bool {
-  const std::string CONFIG_VERSION = std::string(Project::VERSION);
+    const std::string CONFIG_VERSION = std::string(Project::VERSION);
 
-  std::ifstream file(config_file_path);
+    std::ifstream file(config_file_path);
-  if (!file.good()) {
+    if (!file.good()) {
-    // El fitxer no existeix → crear-ne un de nou amb valors per defecte
+        // El fitxer no existeix → crear-ne un de nou amb valors per defecte
-    if (console) {
+        if (console) {
-      std::cout << "Fitxer de config no trobat, creant-ne un de nou: "
+            std::cout << "Fitxer de config no trobat, creant-ne un de nou: "
-                << config_file_path << '\n';
+                      << config_file_path << '\n';
-    }
+        }
-    saveToFile();
+        saveToFile();
-    return true;
+        return true;
-  }
-
-  // Llegir tot el contingut del fitxer
-  std::string content((std::istreambuf_iterator<char>(file)),
-                      std::istreambuf_iterator<char>());
-  file.close();
-
-  try {
-    // Parsejar YAML
-    auto yaml = fkyaml::node::deserialize(content);
-
-    // Validar versió
-    if (yaml.contains("version")) {
-      version = yaml["version"].get_value<std::string>();
     }
 
-    if (CONFIG_VERSION != version) {
+    // Llegir tot el contingut del fitxer
-      // Versió incompatible → regenerar config
+    std::string content((std::istreambuf_iterator<char>(file)),
-      if (console) {
+        std::istreambuf_iterator<char>());
-        std::cout << "Versió de config incompatible (esperada: "
+    file.close();
-                  << CONFIG_VERSION << ", trobada: " << version
+
-                  << "), regenerant config\n";
+    try {
-      }
+        // Parsejar YAML
-      init();
+        auto yaml = fkyaml::node::deserialize(content);
-      saveToFile();
+
-      return true;
+        // Validar versió
+        if (yaml.contains("version")) {
+            version = yaml["version"].get_value<std::string>();
+        }
+
+        if (CONFIG_VERSION != version) {
+            // Versió incompatible → regenerar config
+            if (console) {
+                std::cout << "Versió de config incompatible (esperada: "
+                          << CONFIG_VERSION << ", trobada: " << version
+                          << "), regenerant config\n";
+            }
+            init();
+            saveToFile();
+            return true;
+        }
+
+        // Carregar seccions
+        loadWindowConfigFromYaml(yaml);
+        loadPhysicsConfigFromYaml(yaml);
+        loadGameplayConfigFromYaml(yaml);
+        loadRenderingConfigFromYaml(yaml);
+
+        if (console) {
+            std::cout << "Config carregada correctament des de: " << config_file_path
+                      << '\n';
+        }
+
+        return true;
+
+    } catch (const fkyaml::exception& e) {
+        // Error de parsejat YAML → regenerar config
+        if (console) {
+            std::cerr << "Error parsejant YAML: " << e.what() << '\n';
+            std::cerr << "Creant config nou amb valors per defecte\n";
+        }
+        init();
+        saveToFile();
+        return true;
     }
-
-    // Carregar seccions
-    loadWindowConfigFromYaml(yaml);
-    loadPhysicsConfigFromYaml(yaml);
-    loadGameplayConfigFromYaml(yaml);
-
-    if (console) {
-      std::cout << "Config carregada correctament des de: " << config_file_path
-                << '\n';
-    }
-
-    return true;
-
-  } catch (const fkyaml::exception &e) {
-    // Error de parsejat YAML → regenerar config
-    if (console) {
-      std::cerr << "Error parsejant YAML: " << e.what() << '\n';
-      std::cerr << "Creant config nou amb valors per defecte\n";
-    }
-    init();
-    saveToFile();
-    return true;
-  }
 }
 
 // Guardar configuració al fitxer YAML
 auto saveToFile() -> bool {
-  std::ofstream file(config_file_path);
+    std::ofstream file(config_file_path);
-  if (!file.is_open()) {
+    if (!file.is_open()) {
-    if (console) {
+        if (console) {
-      std::cerr << "No s'ha pogut obrir el fitxer de config per escriure: "
+            std::cerr << "No s'ha pogut obrir el fitxer de config per escriure: "
-                << config_file_path << '\n';
+                      << config_file_path << '\n';
+        }
+        return false;
     }
-    return false;
-  }
 
-  // Escriure manualment per controlar format i comentaris
+    // Escriure manualment per controlar format i comentaris
-  file << "# Orni Attack - Fitxer de Configuració\n";
+    file << "# Orni Attack - Fitxer de Configuració\n";
-  file << "# Auto-generat. Les edicions manuals es preserven si són "
+    file << "# Auto-generat. Les edicions manuals es preserven si són "
-          "vàlides.\n\n";
+            "vàlides.\n\n";
 
-  file << "version: \"" << Project::VERSION << "\"\n\n";
+    file << "version: \"" << Project::VERSION << "\"\n\n";
 
-  file << "# FINESTRA\n";
+    file << "# FINESTRA\n";
-  file << "window:\n";
+    file << "window:\n";
-  file << "  width: " << window.width << "\n";
+    file << "  width: " << window.width << "\n";
-  file << "  height: " << window.height << "\n";
+    file << "  height: " << window.height << "\n";
-  file << "  fullscreen: " << (window.fullscreen ? "true" : "false") << "\n";
+    file << "  fullscreen: " << (window.fullscreen ? "true" : "false") << "\n";
-  file << "  size_increment: " << window.size_increment << "\n\n";
+    file << "  size_increment: " << window.size_increment << "\n\n";
 
-  file << "# FÍSICA (tots els valors en px/s, rad/s, etc.)\n";
+    file << "# FÍSICA (tots els valors en px/s, rad/s, etc.)\n";
-  file << "physics:\n";
+    file << "physics:\n";
-  file << "  rotation_speed: " << physics.rotation_speed << "   # rad/s\n";
+    file << "  rotation_speed: " << physics.rotation_speed << "   # rad/s\n";
-  file << "  acceleration: " << physics.acceleration << "     # px/s²\n";
+    file << "  acceleration: " << physics.acceleration << "     # px/s²\n";
-  file << "  max_velocity: " << physics.max_velocity << "     # px/s\n";
+    file << "  max_velocity: " << physics.max_velocity << "     # px/s\n";
-  file << "  friction: " << physics.friction << "            # px/s²\n";
+    file << "  friction: " << physics.friction << "            # px/s²\n";
-  file << "  enemy_speed: " << physics.enemy_speed
+    file << "  enemy_speed: " << physics.enemy_speed
-       << "       # unitats/frame\n";
+         << "       # unitats/frame\n";
-  file << "  bullet_speed: " << physics.bullet_speed
+    file << "  bullet_speed: " << physics.bullet_speed
-       << "     # unitats/frame\n\n";
+         << "     # unitats/frame\n\n";
 
-  file << "# GAMEPLAY\n";
+    file << "# GAMEPLAY\n";
-  file << "gameplay:\n";
+    file << "gameplay:\n";
-  file << "  max_enemies: " << gameplay.max_enemies << "\n";
+    file << "  max_enemies: " << gameplay.max_enemies << "\n";
-  file << "  max_bullets: " << gameplay.max_bullets << "\n";
+    file << "  max_bullets: " << gameplay.max_bullets << "\n\n";
 
-  file.close();
+    file << "# RENDERITZACIÓ\n";
+    file << "rendering:\n";
+    file << "  vsync: " << rendering.vsync << "   # 0=disabled, 1=enabled\n";
 
-  if (console) {
+    file.close();
-    std::cout << "Config guardada a: " << config_file_path << '\n';
-  }
 
-  return true;
+    if (console) {
+        std::cout << "Config guardada a: " << config_file_path << '\n';
+    }
+
+    return true;
 }
 
-} // namespace Options
+}  // namespace Options

source/game/options.hpp

@@ -7,42 +7,47 @@ namespace Options {
 // Estructures de configuració
 
 struct Window {
-  int width{640};
+        int width{640};
-  int height{480};
+        int height{480};
-  bool fullscreen{false};
+        bool fullscreen{false};
-  int size_increment{100}; // Increment per F1/F2
+        int size_increment{100};  // Increment per F1/F2
 };
 
 struct Physics {
-  float rotation_speed{3.14f}; // rad/s
+        float rotation_speed{3.14f};  // rad/s
-  float acceleration{400.0f};  // px/s²
+        float acceleration{400.0f};   // px/s²
-  float max_velocity{120.0f};  // px/s
+        float max_velocity{120.0f};   // px/s
-  float friction{20.0f};       // px/s²
+        float friction{20.0f};        // px/s²
-  float enemy_speed{2.0f};     // unitats/frame
+        float enemy_speed{2.0f};      // unitats/frame
-  float bullet_speed{6.0f};    // unitats/frame
+        float bullet_speed{6.0f};     // unitats/frame
 };
 
 struct Gameplay {
-  int max_enemies{15};
+        int max_enemies{15};
-  int max_bullets{3};
+        int max_bullets{3};
+};
+
+struct Rendering {
+        int vsync{1};  // 0=disabled, 1=enabled
 };
 
 // Variables globals (inline per evitar ODR violations)
 
-inline std::string version{}; // Versió del config per validació
+inline std::string version{};  // Versió del config per validació
-inline bool console{false};   // Eixida de debug
+inline bool console{false};    // Eixida de debug
 inline Window window{};
 inline Physics physics{};
 inline Gameplay gameplay{};
+inline Rendering rendering{};
 
-inline std::string config_file_path{}; // Establert per setConfigFile()
+inline std::string config_file_path{};  // Establert per setConfigFile()
 
 // Funcions públiques
 
-void init(); // Inicialitzar amb valors per defecte
+void init();  // Inicialitzar amb valors per defecte
 void setConfigFile(
-    const std::string &path); // Establir ruta del fitxer de config
+    const std::string& path);  // Establir ruta del fitxer de config
-auto loadFromFile() -> bool;  // Carregar config YAML
+auto loadFromFile() -> bool;   // Carregar config YAML
-auto saveToFile() -> bool;    // Guardar config YAML
+auto saveToFile() -> bool;     // Guardar config YAML
 
-} // namespace Options
+}  // namespace Options

source/legacy/asteroids.cpp

@@ -1,4 +1,5 @@
 #include <SDL2/SDL.h>
+
 #include <string>
 #include <vector>
 
@@ -13,34 +14,34 @@
 #define MAX_BALES 3
 
 struct ipunt {
-  float r;
+        float r;
-  float angle;
+        float angle;
 };
 
 struct punt {
-  int x;
+        int x;
-  int y;
+        int y;
 };
 
 struct triangle {
-  ipunt p1, p2, p3;
+        ipunt p1, p2, p3;
-  punt centre;
+        punt centre;
-  float angle;
+        float angle;
-  float velocitat;
+        float velocitat;
 };
 
 typedef std::vector<ipunt> ivector();
 
 struct poligon {
-  ivector *ipunts;
+        ivector* ipunts;
-  ivector ipuntx;
+        ivector ipuntx;
-  punt centre;
+        punt centre;
-  float angl;
+        float angl;
-  float velocitat;
+        float velocitat;
-  Uint8 n;
+        Uint8 n;
-  float drotacio;
+        float drotacio;
-  float rotacio;
+        float rotacio;
-  bool esta;
+        bool esta;
 };
 
 std::vector<Uint8> pvirt(38400);
@@ -385,7 +386,7 @@ begin
      instalarkb;
      repeat
 {
-    rota_tri(nau, nau.angle, nau.velocitat, 0);}
+        rota_tri(nau, nau.angle, nau.velocitat, 0);}
             clsvirt;
 
            if teclapuls(KEYarrowright) then nau.angle:=nau.angle+0.157079632;
@@ -413,19 +414,19 @@ begin
                  nau.centre.x:=Dx;
            if (nau.velocitat>0.1) then nau.velocitat:=nau.velocitat-0.1;
 {
-  dist:
+    dist:
-    = distancia(nau.centre, pol.centre);
+        = distancia(nau.centre, pol.centre);
-    diferencia(pol.centre, nau.centre, puntaux);
+        diferencia(pol.centre, nau.centre, puntaux);
-    if dist
+        if dist
-      < (pol.ipuntx[1].r + 30) then begin nau.centre.x
+            < (pol.ipuntx[1].r + 30) then begin nau.centre.x
-          : = nau.centre.x + round(dist * cos(angle(puntaux) + 0.031415));
+                : = nau.centre.x + round(dist * cos(angle(puntaux) + 0.031415));
-    nau.centre.y
+        nau.centre.y
-        : = nau.centre.y + round(dist * sin(angle(puntaux) + 0.031415));
+            : = nau.centre.y + round(dist * sin(angle(puntaux) + 0.031415));
-    end;}
+        end;}
 {           for
-    i:
+        i:
-      = 1 to 5 do begin rota_pol(orni[i], ang, 0);
+            = 1 to 5 do begin rota_pol(orni[i], ang, 0);
-    end;}
+        end;}
            for i:=1 to MAX_ORNIS do begin
                mou_orni(orni[i]);
                rota_pol(orni[i],orni[i].rotacio,1);
@@ -440,26 +441,26 @@ begin
            waitretrace;
            volca;
 {
-    if aux
+        if aux
-      = 1 then begin {
+            = 1 then begin {
-        gotoxy(0, 0);
+                gotoxy(0, 0);
-        write('tocado') tocado;
+                write('tocado') tocado;
-        delay(200);
+                delay(200);
-        end;
+                end;
-      }
+            }
-    gotoxy(50, 24);
+        gotoxy(50, 24);
-    write('<EFBFBD> Visente i Sergi');
+        write('<EFBFBD> Visente i Sergi');
-    gotoxy(50, 25);
+        gotoxy(50, 25);
-    write('<EFBFBD>ETA 2.2 2/6/99');
+        write('<EFBFBD>ETA 2.2 2/6/99');
-    until teclapuls(keyesc);
+        until teclapuls(keyesc);
-    desinstalarkb;
+        desinstalarkb;
-  ang:
+    ang:
-    = 0;
+        = 0;
-    repeat waitretrace;
+        repeat waitretrace;
-    rota_pol(pol, ang, 0);
+        rota_pol(pol, ang, 0);
-  ang:
+    ang:
-    = ang + 0.031415;
+        = ang + 0.031415;
-    rota_pol(pol, ang, 1);
+        rota_pol(pol, ang, 1);
-    until keypressed;
+        until keypressed;
-    text;
+        text;
-  end.
+    end.

source/main.cpp

@@ -2,17 +2,18 @@
 // © 1999 Visente i Sergi (versió Pascal)
 // © 2025 Port a C++20 amb SDL3
 
-#include "core/system/director.hpp"
 #include <string>
 #include <vector>
 
-int main(int argc, char *argv[]) {
+#include "core/system/director.hpp"
-  // Convertir arguments a std::vector<std::string>
-  std::vector<std::string> args(argv, argv + argc);
 
-  // Crear director (inicialitza sistema, opcions, configuració)
+int main(int argc, char* argv[]) {
-  Director director(args);
+    // Convertir arguments a std::vector<std::string>
+    std::vector<std::string> args(argv, argv + argc);
 
-  // Executar bucle principal del joc
+    // Crear director (inicialitza sistema, opcions, configuració)
-  return director.run();
+    Director director(args);
+
+    // Executar bucle principal del joc
+    return director.run();
 }

todo.txt

@@ -0,0 +1,14 @@
+ORNI TODO:
+- Crear escena titulo: muestra el logo, el copyright, el texto de insert coin o press start y quizas un starfield de fondo
+- Revisar contador de frames: hace cosas raras, hacer que se actualice cada segundo
+- Añadir clase audio -> añadir ruidos a logo, title y game
+- Añadir resource.pack
+- Crear estados en GAME: GET_READY -> GAME -> GAME_OVER -> CONTINUE
+                                           -> STAGE_COMPLETED -> GET_READY (next stage)
+- Añadir nuevos enemigos: cuadrado, ... otras formas (revisar Geometry Wars). Darles fiferente personalidad
+- La bala ha de salir de la punta de la nave, con forma cuadrada, va rotando
+- Pensar si todas las entidades deberian tener dos radios de colision: uno pequeño para colision con bordes o jugador, uno mas grande para colision con balas
+- Revisar que los debris salgan realmente en direccion contraria al centro de la figura
+- Crear progresion: fichero con enemigos para ese nivel. cuando se acaba la lista de niveles -> loop con dificultad aumentada. Pensar si jefe final. Juego no tiene fin
+- Menu de servicio? numero de vidas, numero de continues o free play, controles de audio, controles de video, colores, activar parpadeo o cambiar frecuencia
+- Cuando se destruye un enemigo, salen dos mas pequeños