afegit nivell de brillo per shape

.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.3.0)
 
 # Info del proyecto
 set(PROJECT_LONG_NAME "Orni Attack")
@@ -45,12 +45,17 @@ set(APP_SOURCES
     source/core/graphics/shape.cpp
     source/core/graphics/shape_loader.cpp
     source/core/graphics/vector_text.cpp
+    source/core/graphics/starfield.cpp
+    source/core/audio/audio.cpp
+    source/core/audio/audio_cache.cpp
     source/game/options.cpp
     source/game/escenes/escena_logo.cpp
+    source/game/escenes/escena_titol.cpp
     source/game/escenes/escena_joc.cpp
     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

@@ -36,6 +36,8 @@ APP_SOURCES := \
     source/main.cpp \
     source/core/system/director.cpp \
     source/core/system/global_events.cpp \
+    source/core/audio/audio.cpp \
+    source/core/audio/audio_cache.cpp \
     source/core/rendering/sdl_manager.cpp \
     source/core/rendering/line_renderer.cpp \
     source/core/rendering/color_oscillator.cpp \
@@ -45,12 +47,15 @@ APP_SOURCES := \
     source/core/graphics/shape.cpp \
     source/core/graphics/shape_loader.cpp \
     source/core/graphics/vector_text.cpp \
+    source/core/graphics/starfield.cpp \
     source/game/options.cpp \
     source/game/escenes/escena_logo.cpp \
+    source/game/escenes/escena_titol.cpp \
     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

data/shapes/font/char_copyright.shp

@@ -0,0 +1,12 @@
+# char_copyright.shp - Símbolo © (copyright)
+# Dimensiones: 20×40 (blocky display)
+
+name: char_copyright
+scale: 1.0
+center: 10, 20
+
+# Círculo exterior (aproximado con 12 puntos)
+polyline: 10,8  13,9  15,11  17,14  18,17  18,23  17,26  15,29  13,31  10,32  7,31  5,29  3,26  2,23  2,17  3,14  5,11  7,9  10,8
+
+# Letra C interior
+polyline: 13,16  9,14  7,16  6,20  7,24  9,26  13,24

data/shapes/star.shp

@@ -0,0 +1,19 @@
+# star.shp - Estrella per a starfield
+# © 2025 Orni Attack
+
+name: star
+scale: 1.0
+center: 0, 0
+
+# Estrella de 4 puntes (diamant/creu)
+# Petita i simple per a l'efecte starfield
+#
+# Punts:
+#   angle=0°:   (0, -3)    Dalt
+#   angle=90°:  (3, 0)     Dreta
+#   angle=180°: (0, 3)     Baix
+#   angle=270°: (-3, 0)    Esquerra
+#
+# Forma de diamant amb línies de centre a puntes
+
+polyline: 0,-3  3,0  0,3  -3,0  0,-3

source/core/rendering/sdl_manager.cpp

@@ -2,19 +2,31 @@
 // © 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),
+      max_width_(1920),
+      max_height_(1080),
+      zoom_factor_(Defaults::Window::BASE_ZOOM),
+      windowed_width_(Defaults::Window::WIDTH),
+      windowed_height_(Defaults::Window::HEIGHT),
+      max_zoom_(1.0f) {
     // Inicialitzar SDL3
     if (!SDL_Init(SDL_INIT_VIDEO)) {
         std::cerr << "Error inicialitzant SDL3: " << SDL_GetError() << std::endl;
@@ -24,9 +36,8 @@ SDLManager::SDLManager()
     // Calcular mida màxima des del display
     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)
     finestra_ =
@@ -41,8 +52,7 @@ SDLManager::SDLManager()
     }
 
     // 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ó
     renderer_ = SDL_CreateRenderer(finestra_, nullptr);
@@ -54,6 +64,9 @@ SDLManager::SDLManager()
         return;
     }
 
+    // Aplicar configuració de V-Sync
+    SDL_SetRenderVSync(renderer_, Options::rendering.vsync);
+
     // CRÍTIC: Configurar viewport scaling
     updateLogicalPresentation();
 
@@ -64,9 +77,20 @@ SDLManager::SDLManager()
 
 // 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),
-      max_height_(1080) {
+      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),
+      zoom_factor_(static_cast<float>(width) / Defaults::Window::WIDTH),
+      windowed_width_(width),
+      windowed_height_(height),
+      max_zoom_(1.0f) {
     // Inicialitzar SDL3
     if (!SDL_Init(SDL_INIT_VIDEO)) {
         std::cerr << "Error inicialitzant SDL3: " << SDL_GetError() << std::endl;
@@ -77,8 +101,7 @@ SDLManager::SDLManager(int width, int height, bool fullscreen)
     calculateMaxWindowSize();
 
     // 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
     SDL_WindowFlags flags = SDL_WINDOW_RESIZABLE;
@@ -87,8 +110,7 @@ SDLManager::SDLManager(int width, int height, bool fullscreen)
     }
 
     // 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_) {
         std::cerr << "Error creant finestra: " << SDL_GetError() << std::endl;
@@ -98,8 +120,7 @@ SDLManager::SDLManager(int width, int height, bool fullscreen)
 
     // Centrar explícitament la finestra (si no és 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ó
@@ -112,6 +133,9 @@ SDLManager::SDLManager(int width, int height, bool fullscreen)
         return;
     }
 
+    // Aplicar configuració de V-Sync
+    SDL_SetRenderVSync(renderer_, Options::rendering.vsync);
+
     // Configurar viewport scaling
     updateLogicalPresentation();
 
@@ -157,6 +181,64 @@ void SDLManager::calculateMaxWindowSize() {
         std::cerr << "No s'ha pogut detectar el display, usant fallback: "
                   << max_width_ << "x" << max_height_ << std::endl;
     }
+
+    // Calculate max zoom immediately after determining max size
+    calculateMaxZoom();
+}
+
+void SDLManager::calculateMaxZoom() {
+    // Maximum zoom limited by BOTH width and height (preserves 4:3)
+    float max_zoom_width = static_cast<float>(max_width_) / Defaults::Window::WIDTH;
+    float max_zoom_height = static_cast<float>(max_height_) / Defaults::Window::HEIGHT;
+
+    // Take smaller constraint
+    float max_zoom_unrounded = std::min(max_zoom_width, max_zoom_height);
+
+    // Round DOWN to nearest 0.1 increment (user preference)
+    max_zoom_ = std::floor(max_zoom_unrounded / Defaults::Window::ZOOM_INCREMENT) * Defaults::Window::ZOOM_INCREMENT;
+
+    // Safety clamp
+    max_zoom_ = std::max(max_zoom_, Defaults::Window::MIN_ZOOM);
+
+    std::cout << "Max zoom: " << max_zoom_ << "x (display: "
+              << max_width_ << "x" << max_height_ << ")" << std::endl;
+}
+
+void SDLManager::applyZoom(float new_zoom) {
+    // Clamp to valid range
+    new_zoom = std::max(Defaults::Window::MIN_ZOOM,
+        std::min(new_zoom, max_zoom_));
+
+    // Round to nearest 0.1 increment
+    new_zoom = std::round(new_zoom / Defaults::Window::ZOOM_INCREMENT) * Defaults::Window::ZOOM_INCREMENT;
+
+    // No change?
+    if (std::abs(new_zoom - zoom_factor_) < 0.01f) {
+        return;
+    }
+
+    zoom_factor_ = new_zoom;
+
+    // Calculate physical dimensions (4:3 maintained automatically)
+    int new_width = static_cast<int>(std::round(
+        Defaults::Window::WIDTH * zoom_factor_));
+    int new_height = static_cast<int>(std::round(
+        Defaults::Window::HEIGHT * zoom_factor_));
+
+    // Apply to window (centers via applyWindowSize)
+    applyWindowSize(new_width, new_height);
+
+    // Update windowed size cache
+    windowed_width_ = new_width;
+    windowed_height_ = new_height;
+
+    // Persist
+    Options::window.width = new_width;
+    Options::window.height = new_height;
+    Options::window.zoom_factor = zoom_factor_;
+
+    std::cout << "Zoom: " << zoom_factor_ << "x ("
+              << new_width << "x" << new_height << ")" << std::endl;
 }
 
 void SDLManager::updateLogicalPresentation() {
@@ -172,48 +254,22 @@ void SDLManager::updateLogicalPresentation() {
 
 void SDLManager::increaseWindowSize() {
     if (is_fullscreen_)
-    return; // No operar en fullscreen
+        return;
 
-  int new_width = current_width_ + Defaults::Window::SIZE_INCREMENT;
+    float new_zoom = zoom_factor_ + Defaults::Window::ZOOM_INCREMENT;
-  int new_height = current_height_ + Defaults::Window::SIZE_INCREMENT;
+    applyZoom(new_zoom);
 
-  // Clamp a màxim
+    std::cout << "F2: Zoom aumentat a " << zoom_factor_ << "x" << std::endl;
-  new_width = std::min(new_width, max_width_);
-  new_height = std::min(new_height, max_height_);
-
-  if (new_width != current_width_ || new_height != current_height_) {
-    applyWindowSize(new_width, new_height);
-
-    // Persistir canvis a Options (es guardarà a config.yaml al tancar)
-    Options::window.width = current_width_;
-    Options::window.height = current_height_;
-
-    std::cout << "F2: Finestra augmentada a " << new_width << "x" << new_height
-              << std::endl;
-  }
 }
 
 void SDLManager::decreaseWindowSize() {
     if (is_fullscreen_)
         return;
 
-  int new_width = current_width_ - Defaults::Window::SIZE_INCREMENT;
+    float new_zoom = zoom_factor_ - Defaults::Window::ZOOM_INCREMENT;
-  int new_height = current_height_ - Defaults::Window::SIZE_INCREMENT;
+    applyZoom(new_zoom);
 
-  // Clamp a mínim
+    std::cout << "F1: Zoom reduït a " << zoom_factor_ << "x" << std::endl;
-  new_width = std::max(new_width, Defaults::Window::MIN_WIDTH);
-  new_height = std::max(new_height, Defaults::Window::MIN_HEIGHT);
-
-  if (new_width != current_width_ || new_height != current_height_) {
-    applyWindowSize(new_width, new_height);
-
-    // Persistir canvis a Options (es guardarà a config.yaml al tancar)
-    Options::window.width = current_width_;
-    Options::window.height = current_height_;
-
-    std::cout << "F1: Finestra reduïda a " << new_width << "x" << new_height
-              << std::endl;
-  }
 }
 
 void SDLManager::applyWindowSize(int new_width, int new_height) {
@@ -249,26 +305,49 @@ void SDLManager::applyWindowSize(int new_width, int new_height) {
 }
 
 void SDLManager::toggleFullscreen() {
-  is_fullscreen_ = !is_fullscreen_;
+    if (!is_fullscreen_) {
-  SDL_SetWindowFullscreen(finestra_, is_fullscreen_);
+        // ENTERING FULLSCREEN
+        windowed_width_ = current_width_;
+        windowed_height_ = current_height_;
+
+        is_fullscreen_ = true;
+        SDL_SetWindowFullscreen(finestra_, true);
+
+        std::cout << "F3: Fullscreen activat (guardada: "
+                  << windowed_width_ << "x" << windowed_height_ << ")" << std::endl;
+    } else {
+        // EXITING FULLSCREEN
+        is_fullscreen_ = false;
+        SDL_SetWindowFullscreen(finestra_, false);
+
+        // CRITICAL: Explicitly restore windowed size
+        applyWindowSize(windowed_width_, windowed_height_);
+
+        std::cout << "F3: Fullscreen desactivat (restaurada: "
+                  << windowed_width_ << "x" << windowed_height_ << ")" << std::endl;
+    }
 
-  // Persistir canvis a Options (es guardarà a config.yaml al tancar)
     Options::window.fullscreen = is_fullscreen_;
-
-  std::cout << "F3: Fullscreen " << (is_fullscreen_ ? "activat" : "desactivat")
-            << std::endl;
-
-  // En fullscreen, SDL gestiona tot automàticament
-  // En sortir, restaura la mida anterior
 }
 
 bool SDLManager::handleWindowEvent(const SDL_Event& event) {
     if (event.type == SDL_EVENT_WINDOW_RESIZED) {
-    // Usuari ha redimensionat manualment (arrossegar vora)
-    // Actualitzar el nostre tracking
         SDL_GetWindowSize(finestra_, &current_width_, &current_height_);
-    std::cout << "Finestra redimensionada manualment a " << current_width_
+
-              << "x" << current_height_ << std::endl;
+        // Calculate zoom from actual size (may not align to 0.1 increments)
+        float new_zoom = static_cast<float>(current_width_) / Defaults::Window::WIDTH;
+        zoom_factor_ = std::max(Defaults::Window::MIN_ZOOM,
+            std::min(new_zoom, max_zoom_));
+
+        // Update windowed cache (if not in fullscreen)
+        if (!is_fullscreen_) {
+            windowed_width_ = current_width_;
+            windowed_height_ = current_height_;
+        }
+
+        std::cout << "Finestra redimensionada: " << current_width_
+                  << "x" << current_height_ << " (zoom ≈" << zoom_factor_ << "x)"
+                  << std::endl;
         return true;
     }
     return false;
@@ -301,3 +380,49 @@ void SDLManager::updateColors(float delta_time) {
     // Actualitzar color global de línies
     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,7 +5,10 @@
 #define SDL_MANAGER_HPP
 
 #include <SDL3/SDL.h>
+
 #include <cstdint>
+#include <string>
+
 #include "core/rendering/color_oscillator.hpp"
 
 class SDLManager {
@@ -23,6 +26,7 @@ public:
         void increaseWindowSize();  // F2: +100px
         void decreaseWindowSize();  // F1: -100px
         void toggleFullscreen();    // F3
+        void toggleVSync();         // F4
         bool
         handleWindowEvent(const SDL_Event& event);  // Per a SDL_EVENT_WINDOW_RESIZED
 
@@ -33,13 +37,24 @@ public:
         // [NUEVO] Actualització de colors (oscil·lació)
         void updateColors(float delta_time);
 
+        // [NUEVO] Actualitzar comptador de FPS
+        void updateFPS(float delta_time);
+
         // Getters
         SDL_Renderer* obte_renderer() { return renderer_; }
 
+        // [NUEVO] Actualitzar títol de la finestra
+        void setWindowTitle(const std::string& title);
+
     private:
         SDL_Window* finestra_;
         SDL_Renderer* renderer_;
 
+        // [NUEVO] Variables FPS
+        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_;
@@ -47,8 +62,16 @@ private:
         int max_width_;  // Calculat des del display
         int max_height_;
 
+        // [ZOOM SYSTEM]
+        float zoom_factor_;    // Current zoom (0.5x to max_zoom_)
+        int windowed_width_;   // Saved size before fullscreen
+        int windowed_height_;  // Saved size before fullscreen
+        float max_zoom_;       // Maximum zoom (calculated from display)
+
         // [NUEVO] Funcions internes
         void calculateMaxWindowSize();                // Llegir resolució del display
+        void calculateMaxZoom();                      // Calculate max zoom from display
+        void applyZoom(float new_zoom);               // Apply zoom and resize window
         void applyWindowSize(int width, int height);  // Canviar mida + centrar
         void updateLogicalPresentation();             // Actualitzar viewport
 

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;
@@ -27,14 +29,32 @@ 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};
-  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;
     max_x = zona.x + zona.w;
     min_y = zona.y;
     max_y = zona.y + zona.h;
 }
+
+// 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,280 @@
+// 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/audio/audio.hpp"
+#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;
+    }
+
+    // Reproducir sonido de explosión
+    Audio::get()->playSound(Defaults::Sound::EXPLOSION, Audio::Group::GAME);
+
+    // 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,16 +3,23 @@
 // © 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/audio/audio.hpp"
-    : renderer_(renderer), centre_({0.0f, 0.0f}), angle_(0.0f),
+#include "core/defaults.hpp"
-      velocitat_(0.0f), esta_(false) {
+#include "core/graphics/shape_loader.hpp"
+#include "core/rendering/shape_renderer.hpp"
+#include "game/constants.hpp"
 
+Bala::Bala(SDL_Renderer* renderer)
+    : renderer_(renderer),
+      centre_({0.0f, 0.0f}),
+      angle_(0.0f),
+      velocitat_(0.0f),
+      esta_(false),
+      brightness_(Defaults::Brightness::BALA) {
     // [NUEVO] Carregar forma compartida des de fitxer
     forma_ = Graphics::ShapeLoader::load("bullet.shp");
 
@@ -46,6 +53,9 @@ void Bala::disparar(const Punt &posicio, float angle) {
     // Velocitat alta (el joc Pascal original usava 7 px/frame)
     // 7 px/frame × 20 FPS = 140 px/s
     velocitat_ = 140.0f;
+
+    // Reproducir sonido de disparo láser
+    Audio::get()->playSound(Defaults::Sound::LASER, Audio::Group::GAME);
 }
 
 void Bala::actualitzar(float delta_time) {
@@ -58,7 +68,7 @@ void Bala::dibuixar() const {
     if (esta_ && forma_) {
         // [NUEVO] Usar render_shape en lloc de rota_pol
         // 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, 1.0f, brightness_);
     }
 }
 
@@ -80,7 +90,16 @@ void Bala::mou(float delta_time) {
     centre_.x += dx;
 
     // 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
+    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,14 +3,17 @@
 // © 2025 Port a C++20 amb SDL3
 
 #pragma once
+#include <SDL3/SDL.h>
+
+#include <memory>
+
 #include "core/graphics/shape.hpp"
 #include "core/types.hpp"
-#include <SDL3/SDL.h>
-#include <memory>
 
 class Bala {
     public:
-  Bala() : renderer_(nullptr) {}
+        Bala()
+            : renderer_(nullptr) {}
         Bala(SDL_Renderer* renderer);
 
         void inicialitzar();
@@ -34,6 +37,7 @@ private:
         float angle_;
         float velocitat_;
         bool esta_;
+        float brightness_;  // Factor de brillantor (0.0-1.0)
 
         void mou(float delta_time);
 };

source/game/entities/enemic.cpp

@@ -3,17 +3,25 @@
 // © 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/defaults.hpp"
-    : renderer_(renderer), centre_({0.0f, 0.0f}), angle_(0.0f),
+#include "core/graphics/shape_loader.hpp"
-      velocitat_(0.0f), drotacio_(0.0f), rotacio_(0.0f), esta_(false) {
+#include "core/rendering/shape_renderer.hpp"
+#include "game/constants.hpp"
 
+Enemic::Enemic(SDL_Renderer* renderer)
+    : renderer_(renderer),
+      centre_({0.0f, 0.0f}),
+      angle_(0.0f),
+      velocitat_(0.0f),
+      drotacio_(0.0f),
+      rotacio_(0.0f),
+      esta_(false),
+      brightness_(Defaults::Brightness::ENEMIC) {
     // [NUEVO] Carregar forma compartida des de fitxer
     forma_ = Graphics::ShapeLoader::load("enemy_pentagon.shp");
 
@@ -27,12 +35,23 @@ void Enemic::inicialitzar() {
     // Inicialitzar enemic (pentàgon)
     // 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
-  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);
+
+    // Spawn aleatori dins dels límits segurs
+    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));
 
     // Angle aleatori de moviment
     angle_ = (std::rand() % 360) * Constants::PI / 180.0f;
@@ -62,7 +81,7 @@ void Enemic::actualitzar(float delta_time) {
 void Enemic::dibuixar() const {
     if (esta_ && forma_) {
         // [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, 1.0f, brightness_);
     }
 }
 
@@ -85,14 +104,19 @@ void Enemic::mou(float delta_time) {
     float new_y = centre_.y + dy;
     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;
-  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
     // 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);
-  if (new_y > min_y && new_y < max_y) {
+    // CORRECCIÓ: Usar inequalitats inclusives (>= i <=) per evitar fugides
+    if (new_y >= min_y && new_y <= max_y) {
         centre_.y = new_y;
     } else {
         // Pequeño ajuste aleatorio: (random(256)/512)*(random(3)-1)
@@ -107,7 +131,8 @@ void Enemic::mou(float delta_time) {
     // 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)
     // 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
+    if (new_x >= min_x && new_x <= max_x) {
         centre_.x = new_x;
     } else {
         float rand1 = (static_cast<float>(std::rand() % 256) / 512.0f);

source/game/entities/enemic.hpp

@@ -3,14 +3,17 @@
 // © 2025 Port a C++20 amb SDL3
 
 #pragma once
+#include <SDL3/SDL.h>
+
+#include <memory>
+
 #include "core/graphics/shape.hpp"
 #include "core/types.hpp"
-#include <SDL3/SDL.h>
-#include <memory>
 
 class Enemic {
     public:
-  Enemic() : renderer_(nullptr) {}
+        Enemic()
+            : renderer_(nullptr) {}
         Enemic(SDL_Renderer* renderer);
 
         void inicialitzar();
@@ -20,6 +23,7 @@ public:
         // Getters (API pública sense canvis)
         bool esta_actiu() const { return esta_; }
         const Punt& get_centre() const { return centre_; }
+        const std::shared_ptr<Graphics::Shape>& get_forma() const { return forma_; }
         void destruir() { esta_ = false; }
 
     private:
@@ -35,6 +39,7 @@ private:
         float drotacio_;    // Delta rotació visual (rad/s)
         float rotacio_;     // Rotació visual acumulada
         bool esta_;
+        float brightness_;  // Factor de brillantor (0.0-1.0)
 
         void mou(float delta_time);
 };

source/game/entities/nau.cpp

@@ -3,18 +3,24 @@
 // © 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)
-    : 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),
+      brightness_(Defaults::Brightness::NAU) {
     // [NUEVO] Carregar forma compartida des de fitxer
     forma_ = Graphics::ShapeLoader::load("ship.shp");
 
@@ -28,12 +34,14 @@ void Nau::inicialitzar() {
     // Basat en el codi Pascal original: lines 380-384
     // 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
     angle_ = 0.0f;
@@ -99,7 +107,7 @@ void Nau::dibuixar() const {
     float velocitat_visual = velocitat_ / 33.33f;
     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, 1.0f, brightness_);
 }
 
 void Nau::aplicar_fisica(float delta_time) {
@@ -116,16 +124,21 @@ void Nau::aplicar_fisica(float delta_time) {
         (velocitat_ * delta_time) * std::cos(angle_ - Constants::PI / 2.0f) +
         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;
-  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 <=)
+    if (dy >= min_y && dy <= max_y) {
         centre_.y = dy;
     }
 
-  if (dx > min_x && dx < max_x) {
+    if (dx >= min_x && dx <= max_x) {
         centre_.x = dx;
     }
 

source/game/entities/nau.hpp

@@ -3,14 +3,17 @@
 // © 2025 Port a C++20 amb SDL3
 
 #pragma once
+#include <SDL3/SDL.h>
+
+#include <memory>
+
 #include "core/graphics/shape.hpp"
 #include "core/types.hpp"
-#include <SDL3/SDL.h>
-#include <memory>
 
 class Nau {
     public:
-  Nau() : renderer_(nullptr) {}
+        Nau()
+            : renderer_(nullptr) {}
         Nau(SDL_Renderer* renderer);
 
         void inicialitzar();
@@ -29,7 +32,8 @@ public:
     private:
         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
+        // per reutilització)
         std::shared_ptr<Graphics::Shape> forma_;
 
         // [NUEVO] Estat de la instància (separat de la geometria)
@@ -37,6 +41,7 @@ private:
         float angle_;       // Angle d'orientació
         float velocitat_;   // Velocitat (px/s)
         bool esta_tocada_;
+        float brightness_;  // Factor de brillantor (0.0-1.0)
 
         void aplicar_fisica(float delta_time);
 };

source/game/escenes/escena_joc.cpp

@@ -3,16 +3,24 @@
 // © 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/audio/audio.hpp"
+#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),
+      debris_manager_(sdl.obte_renderer()),
+      nau_(sdl.obte_renderer()),
+      itocado_(0),
+      text_(sdl.obte_renderer()) {
     // Inicialitzar bales amb renderer
     for (auto& bala : bales_) {
         bala = Bala(sdl.obte_renderer());
@@ -44,6 +52,9 @@ void EscenaJoc::executar() {
             delta_time = 0.05f;
         }
 
+        // Actualitzar comptador de FPS
+        sdl_.updateFPS(delta_time);
+
         // Processar events SDL
         while (SDL_PollEvent(&event)) {
             // Manejo de finestra
@@ -63,6 +74,9 @@ void EscenaJoc::executar() {
         // Actualitzar física del joc amb delta_time real
         actualitzar(delta_time);
 
+        // Actualitzar sistema d'audio
+        Audio::update();
+
         // Actualitzar colors oscil·lats
         sdl_.updateColors(delta_time);
 
@@ -115,6 +129,12 @@ void EscenaJoc::actualitzar(float delta_time) {
     for (auto& bala : bales_) {
         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() {
@@ -134,6 +154,9 @@ void EscenaJoc::dibuixar() {
         bala.dibuixar();
     }
 
+    // Dibuixar fragments d'explosions (després d'altres objectes)
+    debris_manager_.dibuixar();
+
     // Dibuixar marcador
     dibuixar_marcador();
 }
@@ -145,19 +168,40 @@ void EscenaJoc::processar_input(const SDL_Event &event) {
 
     if (event.type == SDL_EVENT_KEY_DOWN) {
         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
+                // El ship.shp té el front a (0, -12) en coordenades locals
+
+                // 1. Calcular posició del front de la nau
+                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(nau_.get_centre(), nau_.get_angle());
+                        bala.disparar(posicio_dispar, ship_angle);
-          break;
+                        break;  // Només una bala per polsació
                     }
                 }
                 break;
+            }
 
             default:
                 break;
@@ -171,7 +215,7 @@ void EscenaJoc::tocado() {
 
 void EscenaJoc::dibuixar_marges() const {
     // Dibuixar rectangle de la zona de joc
-  const SDL_FRect& zona = Defaults::Zones::GAME;
+    const SDL_FRect& zona = Defaults::Zones::PLAYAREA;
 
     // Coordenades dels cantons
     int x1 = static_cast<int>(zona.x);
@@ -188,26 +232,80 @@ void EscenaJoc::dibuixar_marges() const {
 
 void EscenaJoc::dibuixar_marcador() {
     // 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_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;
 
-  // 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
     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,16 +5,19 @@
 #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 {
@@ -31,6 +34,9 @@ public:
     private:
         SDLManager& sdl_;
 
+        // Efectes visuals
+        Effects::DebrisManager debris_manager_;
+
         // Estat del joc
         Nau nau_;
         std::array<Enemic, Constants::MAX_ORNIS> orni_;
@@ -43,6 +49,7 @@ private:
 
         // 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ó
 };

source/game/escenes/escena_logo.cpp

@@ -2,20 +2,22 @@
 // © 2025 Port a C++20
 
 #include "escena_logo.hpp"
-#include "../../core/system/gestor_escenes.hpp"
+
-#include "../../core/system/global_events.hpp"
-#include "../../core/graphics/shape_loader.hpp"
-#include "../../core/rendering/shape_renderer.hpp"
-#include <iostream>
-#include <cfloat>
 #include <algorithm>
+#include <cfloat>
+#include <iostream>
+#include <random>
+#include <set>
+
+#include "core/audio/audio.hpp"
+#include "core/graphics/shape_loader.hpp"
+#include "core/rendering/shape_renderer.hpp"
+#include "core/system/gestor_escenes.hpp"
+#include "core/system/global_events.hpp"
 
 // 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,
-                                     float global_progress,
-                                     float threshold) {
     if (num_letras == 0)
         return 1.0f;
 
@@ -38,8 +40,12 @@ static float calcular_progress_letra(size_t letra_index,
 EscenaLogo::EscenaLogo(SDLManager& sdl)
     : sdl_(sdl),
       estat_actual_(EstatAnimacio::PRE_ANIMATION),
-    temps_estat_actual_(0.0f) {
+      temps_estat_actual_(0.0f),
+      debris_manager_(std::make_unique<Effects::DebrisManager>(sdl.obte_renderer())),
+      lletra_explosio_index_(0),
+      temps_des_ultima_explosio_(0.0f) {
     std::cout << "Escena Logo: Inicialitzant...\n";
+    so_reproduit_.fill(false);  // Inicialitzar seguiment de sons
     inicialitzar_lletres();
 }
 
@@ -58,6 +64,9 @@ void EscenaLogo::executar() {
             delta_time = 0.05f;
         }
 
+        // Actualitzar comptador de FPS
+        sdl_.updateFPS(delta_time);
+
         // Processar events SDL
         while (SDL_PollEvent(&event)) {
             // Manejo de finestra
@@ -92,9 +101,15 @@ void EscenaLogo::inicialitzar_lletres() {
 
     // Llista de fitxers .shp (A repetida per a les dues A's)
     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
     float ancho_total = 0.0f;
@@ -124,12 +139,10 @@ void EscenaLogo::inicialitzar_lletres() {
         float ancho = ancho_sin_escalar * ESCALA_FINAL;
         float offset_centre = (forma->get_centre().x - min_x) * ESCALA_FINAL;
 
-    lletres_.push_back({
+        lletres_.push_back({forma,
-      forma,
             {0.0f, 0.0f},  // Posició es calcularà després
             ancho,
-      offset_centre
+            offset_centre});
-    });
 
         ancho_total += ancho;
     }
@@ -165,7 +178,24 @@ void EscenaLogo::inicialitzar_lletres() {
 void EscenaLogo::canviar_estat(EstatAnimacio nou_estat) {
     estat_actual_ = nou_estat;
     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;
+
+        // Generar ordre aleatori d'explosions
+        ordre_explosio_.clear();
+        for (size_t i = 0; i < lletres_.size(); i++) {
+            ordre_explosio_.push_back(i);
+        }
+        std::random_device rd;
+        std::mt19937 g(rd());
+        std::shuffle(ordre_explosio_.begin(), ordre_explosio_.end(), g);
+    }
+
+    std::cout << "[EscenaLogo] Canvi a estat: " << static_cast<int>(nou_estat)
+              << "\n";
 }
 
 bool EscenaLogo::totes_lletres_completes() const {
@@ -173,6 +203,36 @@ bool EscenaLogo::totes_lletres_completes() const {
     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 (en ordre aleatori)
+            size_t index_actual = ordre_explosio_[lletra_explosio_index_];
+            const auto& lletra = lletres_[index_actual];
+
+            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;
 
@@ -183,18 +243,51 @@ void EscenaLogo::actualitzar(float delta_time) {
             }
             break;
 
-    case EstatAnimacio::ANIMATION:
+        case EstatAnimacio::ANIMATION: {
+            // Reproduir so per cada lletra quan comença a aparèixer
+            float global_progress = std::min(temps_estat_actual_ / DURACIO_ZOOM, 1.0f);
+
+            for (size_t i = 0; i < lletres_.size() && i < so_reproduit_.size(); i++) {
+                if (!so_reproduit_[i]) {
+                    float letra_progress = calcular_progress_letra(
+                        i,
+                        lletres_.size(),
+                        global_progress,
+                        THRESHOLD_LETRA);
+
+                    // Reproduir so quan la lletra comença a aparèixer (progress > 0)
+                    if (letra_progress > 0.0f) {
+                        Audio::get()->playSound("logo.wav", Audio::Group::INTERFACE);
+                        so_reproduit_[i] = true;
+                    }
+                }
+            }
+
             if (totes_lletres_completes()) {
                 canviar_estat(EstatAnimacio::POST_ANIMATION);
             }
             break;
+        }
 
         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;
+
+        case EstatAnimacio::EXPLOSION:
+            actualitzar_explosions(delta_time);
+            break;
+
+        case EstatAnimacio::POST_EXPLOSION:
+            if (temps_estat_actual_ >= DURACIO_POST_EXPLOSION) {
+                GestorEscenes::actual = GestorEscenes::Escena::TITOL;
             }
             break;
     }
+
+    // Actualitzar animacions de debris
+    debris_manager_->actualitzar(delta_time);
 }
 
 void EscenaLogo::dibuixar() {
@@ -207,57 +300,88 @@ void EscenaLogo::dibuixar() {
         return;  // No renderitzar lletres
     }
 
-  // ANIMATION o POST_ANIMATION: Calcular progrés
+    // ANIMATION o POST_ANIMATION: Dibuixar lletres amb animació
-  float global_progress = (estat_actual_ == EstatAnimacio::ANIMATION)
+    if (estat_actual_ == EstatAnimacio::ANIMATION ||
+        estat_actual_ == EstatAnimacio::POST_ANIMATION) {
+        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(
-    float letra_progress = calcular_progress_letra(i, lletres_.size(), global_progress, THRESHOLD_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
             Punt pos_actual;
-    pos_actual.x = ORIGEN_ZOOM.x + (lletra.posicio.x - ORIGEN_ZOOM.x) * letra_progress;
+            pos_actual.x =
-    pos_actual.y = ORIGEN_ZOOM.y + (lletra.posicio.y - ORIGEN_ZOOM.y) * letra_progress;
+                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;
 
-    // Aplicar ease-out quadràtic per suavitat
             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;
 
-    // Interpolar escala amb ease-out: des de ESCALA_INICIAL cap a ESCALA_FINAL
-    float escala_actual = ESCALA_INICIAL + (ESCALA_FINAL - ESCALA_INICIAL) * ease_factor;
-
-    // Renderitzar la lletra
             Rendering::render_shape(
                 sdl_.obte_renderer(),
                 lletra.forma,
-      pos_actual,        // Posició interpolada
+                pos_actual,
-      0.0f,              // Sense rotació
+                0.0f,
-      escala_actual,     // Escala interpolada amb ease-out
+                escala_actual,
-      true,              // Dibuixar
+                true,
-      1.0f               // Progress = 1.0 (lletra completa, sense animació de primitives)
+                1.0f);
-    );
         }
+    }
+
+    // EXPLOSION: Dibuixar només lletres que encara no han explotat
+    if (estat_actual_ == EstatAnimacio::EXPLOSION) {
+        // Crear conjunt de lletres ja explotades
+        std::set<size_t> explotades;
+        for (size_t i = 0; i < lletra_explosio_index_; i++) {
+            explotades.insert(ordre_explosio_[i]);
+        }
+
+        // Dibuixar només lletres que NO han explotat
+        for (size_t i = 0; i < lletres_.size(); i++) {
+            if (explotades.find(i) == explotades.end()) {
+                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 a la pantalla de títol
     if (event.type == SDL_EVENT_KEY_DOWN ||
         event.type == SDL_EVENT_MOUSE_BUTTON_DOWN) {
-    GestorEscenes::actual = GestorEscenes::Escena::JOC;
+        GestorEscenes::actual = GestorEscenes::Escena::TITOL;
     }
 }

source/game/escenes/escena_logo.hpp

@@ -4,12 +4,16 @@
 
 #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:
@@ -21,12 +25,23 @@ private:
         enum class EstatAnimacio {
             PRE_ANIMATION,   // Pantalla negra inicial
             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_;
         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ó)
+
+        // Gestor de fragments d'explosions
+        std::unique_ptr<Effects::DebrisManager> debris_manager_;
+
+        // 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ó
+        std::vector<size_t> ordre_explosio_;  // Ordre aleatori d'índexs de lletres
 
         // Estructura per a cada lletra del logo
         struct LetraLogo {
@@ -38,22 +53,29 @@ private:
 
         std::vector<LetraLogo> lletres_;  // 9 lletres: J-A-I-L-G-A-M-E-S
 
+        // Seguiment de sons de lletres (evitar reproduccions repetides)
+        std::array<bool, 9> so_reproduit_;  // Track si cada lletra ja ha reproduit el so
+
         // Constants d'animació
         static constexpr float DURACIO_PRE = 1.5f;             // Duració PRE_ANIMATION (pantalla negra)
         static constexpr float DURACIO_ZOOM = 4.0f;            // Duració del zoom (segons)
-  static constexpr float DURACIO_POST = 4.0f;              // Duració POST_ANIMATION (logo complet)
+        static constexpr float DURACIO_POST_ANIMATION = 3.0f;  // Duració POST_ANIMATION (logo complet)
+        static constexpr float DURACIO_POST_EXPLOSION = 3.0f;  // Duració POST_EXPLOSION (espera final)
+        static constexpr float DELAY_ENTRE_EXPLOSIONS = 0.1f;  // Temps entre explosions de lletres
+        static constexpr float VELOCITAT_EXPLOSIO = 240.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
 
         // Constants d'animació seqüencial
         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_X = Defaults::Game::WIDTH * 0.5f;   // Punt inicial X del zoom
-  static constexpr float ORIGEN_ZOOM_Y = 480.0f * 0.4f;   // Punt inicial Y del zoom (240)
+        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);
 

source/game/escenes/escena_titol.cpp

@@ -0,0 +1,176 @@
+// escena_titol.cpp - Implementació de l'escena de títol
+// © 2025 Port a C++20
+
+#include "escena_titol.hpp"
+
+#include <iostream>
+#include <string>
+
+#include "../../core/audio/audio.hpp"
+#include "../../core/system/gestor_escenes.hpp"
+#include "../../core/system/global_events.hpp"
+#include "build/project.h"
+
+EscenaTitol::EscenaTitol(SDLManager& sdl)
+    : sdl_(sdl),
+      text_(sdl.obte_renderer()),
+      estat_actual_(EstatTitol::INIT),
+      temps_acumulat_(0.0f) {
+    std::cout << "Escena Titol: Inicialitzant...\n";
+
+    // Crear starfield de fons
+    Punt centre_pantalla{
+        Defaults::Game::WIDTH / 2.0f,
+        Defaults::Game::HEIGHT / 2.0f};
+
+    SDL_FRect area_completa{
+        0, 0,
+        static_cast<float>(Defaults::Game::WIDTH),
+        static_cast<float>(Defaults::Game::HEIGHT)};
+
+    starfield_ = std::make_unique<Graphics::Starfield>(
+        sdl_.obte_renderer(),
+        centre_pantalla,
+        area_completa,
+        150  // densitat: 150 estrelles (50 per capa)
+    );
+}
+
+void EscenaTitol::executar() {
+    SDL_Event event;
+    Uint64 last_time = SDL_GetTicks();
+
+    while (GestorEscenes::actual == GestorEscenes::Escena::TITOL) {
+        // Calcular delta_time real
+        Uint64 current_time = SDL_GetTicks();
+        float delta_time = (current_time - last_time) / 1000.0f;
+        last_time = current_time;
+
+        // Limitar delta_time per evitar grans salts
+        if (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/F4/ESC/QUIT)
+            if (GlobalEvents::handle(event, sdl_)) {
+                continue;
+            }
+
+            // Processar events de l'escena
+            processar_events(event);
+        }
+
+        // Actualitzar lògica
+        actualitzar(delta_time);
+
+        // Actualitzar sistema d'audio
+        Audio::update();
+
+        // Actualitzar colors oscil·lats
+        sdl_.updateColors(delta_time);
+
+        // Netejar pantalla
+        sdl_.neteja(0, 0, 0);
+
+        // Dibuixar
+        dibuixar();
+
+        // Presentar renderer (swap buffers)
+        sdl_.presenta();
+    }
+
+    std::cout << "Escena Titol: Finalitzant...\n";
+}
+
+void EscenaTitol::actualitzar(float delta_time) {
+    // Actualitzar starfield (sempre actiu)
+    if (starfield_) {
+        starfield_->actualitzar(delta_time);
+    }
+
+    switch (estat_actual_) {
+        case EstatTitol::INIT:
+            temps_acumulat_ += delta_time;
+            if (temps_acumulat_ >= DURACIO_INIT) {
+                estat_actual_ = EstatTitol::MAIN;
+            }
+            break;
+        case EstatTitol::MAIN:
+            // No hi ha lògica d'actualització en l'estat MAIN
+            break;
+    }
+}
+
+void EscenaTitol::dibuixar() {
+    // Dibuixar starfield de fons (sempre, en tots els estats)
+    if (starfield_) {
+        starfield_->dibuixar();
+    }
+
+    // En l'estat INIT, només mostrar starfield (sense text)
+    if (estat_actual_ == EstatTitol::INIT) {
+        return;
+    }
+
+    // Estat MAIN: Dibuixar text de títol i copyright (sobre el starfield)
+    if (estat_actual_ == EstatTitol::MAIN) {
+        // Text principal centrat (vertical i horitzontalment)
+        const std::string main_text = "PRESS BUTTON TO PLAY";
+        const float escala_main = 1.0f;
+        const float spacing = 2.0f;
+
+        float text_width = text_.get_text_width(main_text, escala_main, spacing);
+        float text_height = text_.get_text_height(escala_main);
+
+        float x_center = (Defaults::Game::WIDTH - text_width) / 2.0f;
+        float y_center = (Defaults::Game::HEIGHT - text_height) / 2.0f;
+
+        text_.render(main_text, Punt{x_center, y_center}, escala_main, spacing);
+
+        // Copyright a la part inferior (centrat horitzontalment)
+        // Convert to uppercase since VectorText only supports A-Z
+        std::string copyright = Project::COPYRIGHT;
+        for (char& c : copyright) {
+            if (c >= 'a' && c <= 'z') {
+                c = c - 32;  // Convert to uppercase
+            }
+        }
+        const float escala_copy = 0.6f;
+
+        float copy_width = text_.get_text_width(copyright, escala_copy, spacing);
+        float copy_height = text_.get_text_height(escala_copy);
+
+        float x_copy = (Defaults::Game::WIDTH - copy_width) / 2.0f;
+        float y_copy = Defaults::Game::HEIGHT - copy_height - 20.0f;  // 20px des del fons
+
+        text_.render(copyright, Punt{x_copy, y_copy}, escala_copy, spacing);
+    }
+}
+
+void EscenaTitol::processar_events(const SDL_Event& event) {
+    // Qualsevol tecla o clic de ratolí
+    if (event.type == SDL_EVENT_KEY_DOWN ||
+        event.type == SDL_EVENT_MOUSE_BUTTON_DOWN) {
+
+        switch (estat_actual_) {
+            case EstatTitol::INIT:
+                // Saltar a MAIN
+                estat_actual_ = EstatTitol::MAIN;
+                break;
+            case EstatTitol::MAIN:
+                // Anar al joc
+                GestorEscenes::actual = GestorEscenes::Escena::JOC;
+                break;
+        }
+    }
+}

source/game/escenes/escena_titol.hpp

@@ -0,0 +1,41 @@
+// escena_titol.hpp - Pantalla de títol del joc
+// Mostra missatge "PRESS BUTTON TO PLAY" i copyright
+// © 2025 Port a C++20
+
+#pragma once
+
+#include <SDL3/SDL.h>
+
+#include <memory>
+
+#include "../../core/graphics/starfield.hpp"
+#include "../../core/graphics/vector_text.hpp"
+#include "../../core/rendering/sdl_manager.hpp"
+#include "core/defaults.hpp"
+
+class EscenaTitol {
+    public:
+        explicit EscenaTitol(SDLManager& sdl);
+        void executar();  // Bucle principal de l'escena
+
+    private:
+        // Màquina d'estats per la pantalla de títol
+        enum class EstatTitol {
+            INIT,  // Pantalla negra inicial (2 segons)
+            MAIN   // Pantalla de títol amb text
+        };
+
+        SDLManager& sdl_;
+        Graphics::VectorText text_;                   // Sistema de text vectorial
+        std::unique_ptr<Graphics::Starfield> starfield_;  // Camp d'estrelles de fons
+        EstatTitol estat_actual_;                     // Estat actual de la màquina
+        float temps_acumulat_;                        // Temps acumulat per l'estat INIT
+
+        // Constants
+        static constexpr float DURACIO_INIT = 2.0f;  // Duració de l'estat INIT (2 segons)
+
+        // Mètodes privats
+        void actualitzar(float delta_time);
+        void dibuixar();
+        void processar_events(const SDL_Event& event);
+};

source/game/options.cpp

@@ -1,12 +1,13 @@
 #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::
@@ -21,7 +22,7 @@ void init() {
     window.width = Defaults::Window::WIDTH;
     window.height = Defaults::Window::HEIGHT;
     window.fullscreen = false;
-  window.size_increment = Defaults::Window::SIZE_INCREMENT;
+    window.zoom_factor = Defaults::Window::BASE_ZOOM;
 
     // Physics
     physics.rotation_speed = Defaults::Physics::ROTATION_SPEED;
@@ -35,6 +36,17 @@ void init() {
     gameplay.max_enemies = Defaults::Entities::MAX_ORNIS;
     gameplay.max_bullets = Defaults::Entities::MAX_BALES;
 
+    // Rendering
+    rendering.vsync = Defaults::Rendering::VSYNC_DEFAULT;
+
+    // Audio
+    audio.enabled = Defaults::Audio::ENABLED;
+    audio.volume = Defaults::Audio::VOLUME;
+    audio.music.enabled = Defaults::Music::ENABLED;
+    audio.music.volume = Defaults::Music::VOLUME;
+    audio.sound.enabled = Defaults::Sound::ENABLED;
+    audio.sound.volume = Defaults::Sound::VOLUME;
+
     // Version
     version = std::string(Project::VERSION);
 }
@@ -78,14 +90,19 @@ static void loadWindowConfigFromYaml(const fkyaml::node &yaml) {
             }
         }
 
-    if (win.contains("size_increment")) {
+        if (win.contains("zoom_factor")) {
             try {
-        auto val = win["size_increment"].get_value<int>();
+                auto val = win["zoom_factor"].get_value<float>();
-        window.size_increment =
+                window.zoom_factor = (val >= Defaults::Window::MIN_ZOOM && val <= 10.0f)
-            (val > 0) ? val : Defaults::Window::SIZE_INCREMENT;
+                    ? val
+                    : Defaults::Window::BASE_ZOOM;
             } catch (...) {
-        window.size_increment = Defaults::Window::SIZE_INCREMENT;
+                window.zoom_factor = Defaults::Window::BASE_ZOOM;
             }
+        } else {
+            // Legacy config: infer zoom from width
+            window.zoom_factor = static_cast<float>(window.width) / Defaults::Window::WIDTH;
+            window.zoom_factor = std::max(Defaults::Window::MIN_ZOOM, window.zoom_factor);
         }
     }
 }
@@ -180,6 +197,87 @@ static void loadGameplayConfigFromYaml(const fkyaml::node &yaml) {
     }
 }
 
+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;
+            }
+        }
+    }
+}
+
+static void loadAudioConfigFromYaml(const fkyaml::node& yaml) {
+    if (yaml.contains("audio")) {
+        const auto& aud = yaml["audio"];
+
+        if (aud.contains("enabled")) {
+            try {
+                audio.enabled = aud["enabled"].get_value<bool>();
+            } catch (...) {
+                audio.enabled = Defaults::Audio::ENABLED;
+            }
+        }
+
+        if (aud.contains("volume")) {
+            try {
+                float val = aud["volume"].get_value<float>();
+                audio.volume = (val >= 0.0f && val <= 1.0f) ? val : Defaults::Audio::VOLUME;
+            } catch (...) {
+                audio.volume = Defaults::Audio::VOLUME;
+            }
+        }
+
+        if (aud.contains("music")) {
+            const auto& mus = aud["music"];
+
+            if (mus.contains("enabled")) {
+                try {
+                    audio.music.enabled = mus["enabled"].get_value<bool>();
+                } catch (...) {
+                    audio.music.enabled = Defaults::Music::ENABLED;
+                }
+            }
+
+            if (mus.contains("volume")) {
+                try {
+                    float val = mus["volume"].get_value<float>();
+                    audio.music.volume = (val >= 0.0f && val <= 1.0f) ? val : Defaults::Music::VOLUME;
+                } catch (...) {
+                    audio.music.volume = Defaults::Music::VOLUME;
+                }
+            }
+        }
+
+        if (aud.contains("sound")) {
+            const auto& snd = aud["sound"];
+
+            if (snd.contains("enabled")) {
+                try {
+                    audio.sound.enabled = snd["enabled"].get_value<bool>();
+                } catch (...) {
+                    audio.sound.enabled = Defaults::Sound::ENABLED;
+                }
+            }
+
+            if (snd.contains("volume")) {
+                try {
+                    float val = snd["volume"].get_value<float>();
+                    audio.sound.volume = (val >= 0.0f && val <= 1.0f) ? val : Defaults::Sound::VOLUME;
+                } catch (...) {
+                    audio.sound.volume = Defaults::Sound::VOLUME;
+                }
+            }
+        }
+    }
+}
+
 // Carregar configuració des del fitxer YAML
 auto loadFromFile() -> bool {
     const std::string CONFIG_VERSION = std::string(Project::VERSION);
@@ -225,6 +323,8 @@ auto loadFromFile() -> bool {
         loadWindowConfigFromYaml(yaml);
         loadPhysicsConfigFromYaml(yaml);
         loadGameplayConfigFromYaml(yaml);
+        loadRenderingConfigFromYaml(yaml);
+        loadAudioConfigFromYaml(yaml);
 
         if (console) {
             std::cout << "Config carregada correctament des de: " << config_file_path
@@ -265,10 +365,10 @@ auto saveToFile() -> bool {
 
     file << "# FINESTRA\n";
     file << "window:\n";
-  file << "  width: " << window.width << "\n";
+    file << "  width: " << window.width << "   # Calculated from zoom_factor\n";
-  file << "  height: " << window.height << "\n";
+    file << "  height: " << window.height << "   # Calculated from zoom_factor\n";
     file << "  fullscreen: " << (window.fullscreen ? "true" : "false") << "\n";
-  file << "  size_increment: " << window.size_increment << "\n\n";
+    file << "  zoom_factor: " << window.zoom_factor << "   # 0.5x-max (0.1 increments)\n\n";
 
     file << "# FÍSICA (tots els valors en px/s, rad/s, etc.)\n";
     file << "physics:\n";
@@ -284,7 +384,22 @@ auto saveToFile() -> bool {
     file << "# GAMEPLAY\n";
     file << "gameplay:\n";
     file << "  max_enemies: " << gameplay.max_enemies << "\n";
-  file << "  max_bullets: " << gameplay.max_bullets << "\n";
+    file << "  max_bullets: " << gameplay.max_bullets << "\n\n";
+
+    file << "# RENDERITZACIÓ\n";
+    file << "rendering:\n";
+    file << "  vsync: " << rendering.vsync << "   # 0=disabled, 1=enabled\n\n";
+
+    file << "# AUDIO\n";
+    file << "audio:\n";
+    file << "  enabled: " << (audio.enabled ? "true" : "false") << "\n";
+    file << "  volume: " << audio.volume << "   # 0.0 to 1.0\n";
+    file << "  music:\n";
+    file << "    enabled: " << (audio.music.enabled ? "true" : "false") << "\n";
+    file << "    volume: " << audio.music.volume << "   # 0.0 to 1.0\n";
+    file << "  sound:\n";
+    file << "    enabled: " << (audio.sound.enabled ? "true" : "false") << "\n";
+    file << "    volume: " << audio.sound.volume << "   # 0.0 to 1.0\n";
 
     file.close();
 

source/game/options.hpp

@@ -10,7 +10,7 @@ struct Window {
         int width{640};
         int height{480};
         bool fullscreen{false};
-  int size_increment{100}; // Increment per F1/F2
+        float zoom_factor{1.0f};  // Zoom level (0.5x to max_zoom)
 };
 
 struct Physics {
@@ -27,6 +27,27 @@ struct Gameplay {
         int max_bullets{3};
 };
 
+struct Rendering {
+        int vsync{1};  // 0=disabled, 1=enabled
+};
+
+struct Music {
+        bool enabled{true};
+        float volume{0.8f};
+};
+
+struct Sound {
+        bool enabled{true};
+        float volume{1.0f};
+};
+
+struct Audio {
+        Music music{};
+        Sound sound{};
+        bool enabled{true};
+        float volume{1.0f};
+};
+
 // Variables globals (inline per evitar ODR violations)
 
 inline std::string version{};  // Versió del config per validació
@@ -34,6 +55,8 @@ inline bool console{false};   // Eixida de debug
 inline Window window{};
 inline Physics physics{};
 inline Gameplay gameplay{};
+inline Rendering rendering{};
+inline Audio audio{};
 
 inline std::string config_file_path{};  // Establert per setConfigFile()
 

source/legacy/asteroids.cpp

@@ -1,4 +1,5 @@
 #include <SDL2/SDL.h>
+
 #include <string>
 #include <vector>
 

source/main.cpp

@@ -2,10 +2,11 @@
 // © 1999 Visente i Sergi (versió Pascal)
 // © 2025 Port a C++20 amb SDL3
 
-#include "core/system/director.hpp"
 #include <string>
 #include <vector>
 
+#include "core/system/director.hpp"
+
 int main(int argc, char* argv[]) {
     // Convertir arguments a std::vector<std::string>
     std::vector<std::string> args(argv, argv + argc);

todo.txt

@@ -0,0 +1,15 @@
+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
+- El escalado de pantalla hace cosas raras al salir de full screen: permite ventanas no-4:3