includes amb ruta absoluta

afegida gestió de ratolí

.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

.gitignore

@@ -58,9 +58,9 @@ _deps/
 *.ilk
 
 # Core dumps
-core
+# core
-core.*
+# core.*
-*.core
+# *.core
 
 # macOS
 .DS_Store

CLAUDE.md

@@ -12,59 +12,98 @@ This is **Orni Attack**, an **Asteroids-style game** originally written in **Tur
 
 ## Build System
 
-Based on `/home/sergio/gitea/pollo` project structure.
+Based on `/home/sergio/gitea/pollo` project structure, now with **CMake as build authority** and **automatic file discovery**.
 
-### Build Commands
+### Basic Build Commands
 
 ```bash
-# Clean + compile
+make           # Compile (delegates to CMake)
-make clean && make
+make debug     # Debug build
+make clean     # Clean artifacts
+./orni         # Run
+```
 
-# Run
+### Release Packaging
-./orni
 
-# Individual targets
+```bash
-make linux    # Linux build
+make macos_release     # macOS .app bundle + .dmg (Apple Silicon)
-make macos    # macOS build
+make linux_release     # Linux .tar.gz
-make windows  # Windows build (MinGW)
+make windows_release   # Windows .zip (requires MinGW on Windows)
+make windows_cross     # Cross-compile Windows from Linux/macOS
+make rpi_release       # Raspberry Pi ARM64 cross-compile
 ```
 
 ### Build Files
 
-- **CMakeLists.txt** - CMake configuration (C++20, SDL3, project metadata)
+- **CMakeLists.txt** - CMake configuration (C++20, SDL3, auto-discovers .cpp files)
-- **Makefile** - Cross-platform wrapper, extracts project info from CMakeLists.txt
+- **Makefile** - Wrapper for compilation + complex packaging recipes
 - **source/project.h.in** - Template for auto-generated project.h
 - **build/project.h** - Auto-generated (by CMake) with project constants
-- **release/** - Platform-specific resources (icons, .rc, .plist)
+- **release/** - Platform-specific resources (icons, .rc, .plist, frameworks, DLLs)
+
+### Architecture: Hybrid CMake + Makefile
+
+**CMake handles**: Compilation (simple, standard, IDE-friendly)
+- Auto-discovers all `.cpp` files in `source/core/` and `source/game/`
+- Excludes `source/legacy/` automatically
+- Generates `build/project.h` from template
+- Links SDL3
+
+**Makefile handles**: Packaging (complex bash scripts)
+- Delegates compilation to CMake (`make` → `cmake --build build`)
+- Contains 5 release packaging targets (macOS, Linux, Windows, RPI, Windows-cross)
+- Includes: code signing, framework symlinks, DMG creation, cross-compilation
 
 ### Project Metadata System
 
-**Auto-generation with CMake**:
+**Single source of truth** in `CMakeLists.txt`:
 
-CMake generates `build/project.h` from `source/project.h.in` template on every compilation:
+```cmake
+project(orni VERSION 0.3.0)
+set(PROJECT_LONG_NAME "Orni Attack")
+set(PROJECT_COPYRIGHT "© 1999 Visente i Sergi, 2025 Port")
+```
+
+**Auto-generated** `build/project.h`:
 
 ```cpp
-// build/project.h (generated automatically)
 namespace Project {
-    constexpr const char* NAME = "orni";              // From project(orni ...)
+    constexpr const char* NAME = "orni";
-    constexpr const char* LONG_NAME = "Orni Attack";  // From PROJECT_LONG_NAME
+    constexpr const char* LONG_NAME = "Orni Attack";
-    constexpr const char* VERSION = "0.1.0";          // From VERSION
+    constexpr const char* VERSION = "0.3.0";
-    constexpr const char* COPYRIGHT = "© 1999...";    // From PROJECT_COPYRIGHT
+    constexpr const char* COPYRIGHT = "© 1999 Visente i Sergi, 2025 Port";
-    constexpr const char* GIT_HASH = "abc1234";       // From git rev-parse
+    constexpr const char* GIT_HASH = "abc1234";  // From git rev-parse
 }
 ```
 
-**Window title format** (dynamic, in sdl_manager.cpp):
+**Window title** (dynamic): `Orni Attack v0.3.0 (© 1999 Visente i Sergi, 2025 Port)`
-```cpp
+
-std::format("{} v{} ({})",
+### File Discovery
-    Project::LONG_NAME,    // "Orni Attack"
+
-    Project::VERSION,      // "0.1.0"
+**Automatic** - no manual maintenance needed:
-    Project::COPYRIGHT)    // "© 1999 Visente i Sergi, 2025 Port"
+
+```cmake
+# CMakeLists.txt automatically finds:
+file(GLOB_RECURSE CORE_SOURCES "source/core/*.cpp")
+file(GLOB_RECURSE GAME_SOURCES "source/game/*.cpp")
+# + source/main.cpp
+# - source/legacy/* (excluded)
 ```
 
-Result: `Orni Attack v0.1.0 (© 1999 Visente i Sergi, 2025 Port)`
+**When you create a new file** like `source/game/entities/asteroide.cpp`:
+1. Just create it in the appropriate directory
+2. Run `make`
+3. CMake automatically detects and compiles it
 
-**Single source of truth**: All project info in CMakeLists.txt, no hardcoded strings.
+**No need to edit** Makefile or CMakeLists.txt!
+
+### Cross-Platform Notes
+
+- **macOS**: Requires `create-dmg` (auto-installed via Homebrew)
+- **Windows**: Compile natively with MinGW or use `make windows_cross` on Linux/macOS
+- **Windows cross**: Requires `x86_64-w64-mingw32-g++` toolchain
+- **RPI cross**: Requires `aarch64-linux-gnu-g++` toolchain
+- **Frameworks**: macOS release includes SDL3.xcframework with symlink recreation
 
 ## Architecture
 

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.1)
 
 # Info del proyecto
 set(PROJECT_LONG_NAME "Orni Attack")
@@ -31,28 +31,23 @@ endif()
 # Configurar archivo de versión
 configure_file(${CMAKE_SOURCE_DIR}/source/project.h.in ${CMAKE_BINARY_DIR}/project.h @ONLY)
 
-# --- LISTA DE FUENTES ---
+# --- LISTA DE FUENTES (AUTO-DESCUBRIMIENTO) ---
+# Buscar automáticamente todos los archivos .cpp en core/, game/ y main.cpp
+file(GLOB_RECURSE CORE_SOURCES "${CMAKE_SOURCE_DIR}/source/core/*.cpp")
+file(GLOB_RECURSE GAME_SOURCES "${CMAKE_SOURCE_DIR}/source/game/*.cpp")
 set(APP_SOURCES
+    ${CORE_SOURCES}
+    ${GAME_SOURCES}
     source/main.cpp
-    source/core/system/director.cpp
-    source/core/system/global_events.cpp
-    source/core/rendering/sdl_manager.cpp
-    source/core/rendering/line_renderer.cpp
-    source/core/rendering/color_oscillator.cpp
-    source/core/rendering/polygon_renderer.cpp
-    source/core/rendering/primitives.cpp
-    source/core/rendering/shape_renderer.cpp
-    source/core/graphics/shape.cpp
-    source/core/graphics/shape_loader.cpp
-    source/core/graphics/vector_text.cpp
-    source/game/options.cpp
-    source/game/escenes/escena_logo.cpp
-    source/game/escenes/escena_joc.cpp
-    source/game/entities/nau.cpp
-    source/game/entities/bala.cpp
-    source/game/entities/enemic.cpp
 )
 
+# Excluir archivos legacy (código Pascal de referencia)
+list(FILTER APP_SOURCES EXCLUDE REGEX ".*/legacy/.*")
+
+# Log de archivos encontrados (útil para debug)
+list(LENGTH APP_SOURCES APP_SOURCES_COUNT)
+message(STATUS "Archivos .cpp encontrados: ${APP_SOURCES_COUNT}")
+
 # Configuración de SDL3
 find_package(SDL3 REQUIRED CONFIG REQUIRED COMPONENTS SDL3)
 message(STATUS "SDL3 encontrado: ${SDL3_INCLUDE_DIRS}")

Makefile

@@ -20,6 +20,15 @@ TARGET_FILE    := $(DIR_BIN)$(TARGET_NAME)
 RELEASE_FOLDER := $(TARGET_NAME)_release
 RELEASE_FILE   := $(RELEASE_FOLDER)/$(TARGET_NAME)
 
+# Release file names
+RAW_VERSION := $(shell echo $(VERSION) | sed 's/^v//')
+WINDOWS_RELEASE := $(TARGET_NAME)-$(VERSION)-windows-x64.zip
+MACOS_ARM_RELEASE := $(TARGET_NAME)-$(VERSION)-macos-arm64.dmg
+MACOS_INTEL_RELEASE := $(TARGET_NAME)-$(VERSION)-macos-x64.dmg
+LINUX_RELEASE := $(TARGET_NAME)-$(VERSION)-linux-x64.tar.gz
+RPI_RELEASE := $(TARGET_NAME)-$(VERSION)-rpi-arm64.tar.gz
+APP_NAME := $(LONG_NAME)
+
 # ==============================================================================
 # VERSION
 # ==============================================================================
@@ -32,70 +41,21 @@ endif
 # ==============================================================================
 # SOURCE FILES
 # ==============================================================================
-APP_SOURCES := \
+# Note: Source files are now auto-discovered by CMake using GLOB_RECURSE
-    source/main.cpp \
+# No need to maintain this list manually anymore!
-    source/core/system/director.cpp \
-    source/core/system/global_events.cpp \
-    source/core/rendering/sdl_manager.cpp \
-    source/core/rendering/line_renderer.cpp \
-    source/core/rendering/color_oscillator.cpp \
-    source/core/rendering/polygon_renderer.cpp \
-    source/core/rendering/primitives.cpp \
-    source/core/rendering/shape_renderer.cpp \
-    source/core/graphics/shape.cpp \
-    source/core/graphics/shape_loader.cpp \
-    source/core/graphics/vector_text.cpp \
-    source/game/options.cpp \
-    source/game/escenes/escena_logo.cpp \
-    source/game/escenes/escena_joc.cpp \
-    source/game/entities/nau.cpp \
-    source/game/entities/bala.cpp \
-    source/game/entities/enemic.cpp
 
 # ==============================================================================
-# INCLUDES
+# PLATFORM-SPECIFIC UTILITIES
 # ==============================================================================
-INCLUDES := -Isource -Ibuild
-
-# ==============================================================================
-# COMPILER FLAGS (OS-specific)
-# ==============================================================================
-CPP_STANDARD := c++20
-
 ifeq ($(OS),Windows_NT)
-    # Windows (MinGW)
+    RMFILE          := del /Q
-    FixPath         = $(subst /,\\,$1)
-    CXX             := g++
-    CXXFLAGS        := -std=$(CPP_STANDARD) -Wall -O2 -ffunction-sections -fdata-sections \
-                       -Wl,--gc-sections -static-libstdc++ -static-libgcc \
-                       -Wl,-subsystem,windows -DWINDOWS_BUILD
-    CXXFLAGS_DEBUG  := -std=$(CPP_STANDARD) -Wall -g -D_DEBUG -DWINDOWS_BUILD
-    LDFLAGS         := -lmingw32 -lSDL3
-    WINDRES         := windres
-    RESOURCE_FILE   := release/orni.res
-    RM              := del /Q
     RMDIR           := rmdir /S /Q
     MKDIR           := mkdir
 else
-    # Unix-like systems (Linux/macOS)
-    FixPath         = $1
-    CXX             := g++
-    CXXFLAGS        := -std=$(CPP_STANDARD) -Wall -O2
-    CXXFLAGS_DEBUG  := -std=$(CPP_STANDARD) -Wall -g -D_DEBUG
-    LDFLAGS         := -lSDL3
     RMFILE          := rm -f
     RMDIR           := rm -rf
     MKDIR           := mkdir -p
-
     UNAME_S         := $(shell uname -s)
-    ifeq ($(UNAME_S),Linux)
-        CXXFLAGS    += -DLINUX_BUILD
-        CXXFLAGS_DEBUG += -DLINUX_BUILD
-    endif
-    ifeq ($(UNAME_S),Darwin)
-        CXXFLAGS    += -arch arm64 -Wno-deprecated -DMACOS_BUILD
-        CXXFLAGS_DEBUG += -arch arm64 -Wno-deprecated -DMACOS_BUILD
-    endif
 endif
 
 # ==============================================================================
@@ -103,72 +63,258 @@ endif
 # ==============================================================================
 .PHONY: all clean debug help backup
 
-# Default target
+# ==============================================================================
+# BUILD TARGETS (delegate to CMake)
+# ==============================================================================
+
+# Default target: build with CMake
 all: $(TARGET_FILE)
 
-# Generate build/project.h from template
+$(TARGET_FILE):
-.PHONY: generate_project_h
+	@cmake -B build -DCMAKE_BUILD_TYPE=Release
-generate_project_h:
+	@cmake --build build
-	@$(MKDIR) build 2>/dev/null || true
+	@echo "Build successful: $(TARGET_FILE)"
-	@echo "Generating build/project.h..."
-ifeq ($(OS),Windows_NT)
-	@powershell -Command \
-		"$$name = '$(TARGET_NAME)'; \
-		$$long = '$(LONG_NAME)'; \
-		$$ver = '$(VERSION)'.TrimStart('v'); \
-		$$copy = (Get-Content CMakeLists.txt | Where-Object {$$_ -match 'PROJECT_COPYRIGHT'} | ForEach-Object {if ($$_ -match '\"(.+)\"') {$$matches[1]}}); \
-		$$hash = try {git rev-parse --short=7 HEAD 2>$$null} catch {'unknown'}; \
-		(Get-Content source/project.h.in) -replace '@PROJECT_NAME@', $$name -replace '@PROJECT_LONG_NAME@', $$long -replace '@PROJECT_VERSION@', $$ver -replace '@PROJECT_COPYRIGHT@', $$copy -replace '@GIT_HASH@', $$hash | Set-Content build/project.h"
-else
-	@PROJECT_COPYRIGHT=$$(grep 'PROJECT_COPYRIGHT' CMakeLists.txt | sed 's/.*"\(.*\)".*/\1/'); \
-	PROJECT_VERSION=$$(echo $(VERSION) | sed 's/^v//'); \
-	GIT_HASH=$$(git rev-parse --short=7 HEAD 2>/dev/null || echo "unknown"); \
-	sed -e "s/@PROJECT_NAME@/$(TARGET_NAME)/g" \
-	    -e "s/@PROJECT_LONG_NAME@/$(LONG_NAME)/g" \
-	    -e "s/@PROJECT_VERSION@/$${PROJECT_VERSION}/g" \
-	    -e "s/@PROJECT_COPYRIGHT@/$${PROJECT_COPYRIGHT}/g" \
-	    -e "s/@GIT_HASH@/$${GIT_HASH}/g" \
-	    source/project.h.in > build/project.h
-endif
-	@echo "build/project.h generated successfully"
-
-# Compile executable
-$(TARGET_FILE): generate_project_h $(APP_SOURCES)
-ifeq ($(OS),Windows_NT)
-	@if not exist build $(MKDIR) build
-	@if not exist release\\orni.res $(WINDRES) release\\orni.rc -O coff -o release\\orni.res
-	$(CXX) $(CXXFLAGS) $(INCLUDES) $(APP_SOURCES) $(RESOURCE_FILE) $(LDFLAGS) -o $(TARGET_FILE).exe
-else
-	@$(MKDIR) build
-	$(CXX) $(CXXFLAGS) $(INCLUDES) $(APP_SOURCES) $(LDFLAGS) -o $(TARGET_FILE)
-endif
-	@echo Compilation successful: $(TARGET_FILE)
 
 # Debug build
-debug: generate_project_h $(APP_SOURCES)
+debug:
-ifeq ($(OS),Windows_NT)
+	@cmake -B build -DCMAKE_BUILD_TYPE=Debug
-	@if not exist build $(MKDIR) build
+	@cmake --build build
-	$(CXX) $(CXXFLAGS_DEBUG) $(INCLUDES) $(APP_SOURCES) $(LDFLAGS) -o $(TARGET_FILE)_debug.exe
+	@echo "Debug build successful: $(TARGET_FILE)_debug"
-else
+
-	@$(MKDIR) build
+# ==============================================================================
-	$(CXX) $(CXXFLAGS_DEBUG) $(INCLUDES) $(APP_SOURCES) $(LDFLAGS) -o $(TARGET_FILE)_debug
+# RELEASE PACKAGING TARGETS
-endif
+# ==============================================================================
-	@echo Debug build successful: $(TARGET_FILE)_debug
+
+# macOS Release (Apple Silicon)
+.PHONY: macos_release
+macos_release:
+	@echo "Creating macOS release - Version: $(VERSION)"
+
+	# Check/install create-dmg
+	@command -v create-dmg >/dev/null || (echo "Installing create-dmg..." && brew install create-dmg)
+
+	# Clean previous releases
+	@$(RMDIR) "$(RELEASE_FOLDER)" 2>/dev/null || true
+	@$(RMDIR) Frameworks 2>/dev/null || true
+	@$(RMFILE) "$(MACOS_ARM_RELEASE)" 2>/dev/null || true
+
+	# Create .app structure
+	@$(MKDIR) "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Frameworks"
+	@$(MKDIR) "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/MacOS"
+	@$(MKDIR) "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"
+	@$(MKDIR) Frameworks
+
+	# Copy resources
+	@cp -r resources "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources/"
+	@ditto release/frameworks/SDL3.xcframework/macos-arm64_x86_64/SDL3.framework "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Frameworks/SDL3.framework"
+	@ditto release/frameworks/SDL3.xcframework/macos-arm64_x86_64/SDL3.framework Frameworks/SDL3.framework
+
+	# Recreate framework symlinks (may be broken)
+	@cd Frameworks/SDL3.framework && rm -f SDL3 Headers Resources && \
+		ln -s Versions/Current/SDL3 SDL3 && \
+		ln -s Versions/Current/Headers Headers && \
+		ln -s Versions/Current/Resources Resources
+	@cd Frameworks/SDL3.framework/Versions && rm -f Current && ln -s A Current
+	@cd "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Frameworks/SDL3.framework" && rm -f SDL3 Headers Resources && \
+		ln -s Versions/Current/SDL3 SDL3 && \
+		ln -s Versions/Current/Headers Headers && \
+		ln -s Versions/Current/Resources Resources
+	@cd "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Frameworks/SDL3.framework/Versions" && rm -f Current && ln -s A Current
+
+	@cp release/icon.icns "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources/"
+	@cp release/Info.plist "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/"
+	@cp LICENSE "$(RELEASE_FOLDER)/" 2>/dev/null || echo "Warning: LICENSE not found"
+	@cp README.md "$(RELEASE_FOLDER)/" 2>/dev/null || echo "Warning: README.md not found"
+
+	# Update Info.plist version
+	@echo "Updating Info.plist with version $(RAW_VERSION)..."
+	@sed -i '' '/<key>CFBundleShortVersionString<\/key>/{n;s|<string>.*</string>|<string>$(RAW_VERSION)</string>|;}' \
+		"$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Info.plist"
+	@sed -i '' '/<key>CFBundleVersion<\/key>/{n;s|<string>.*</string>|<string>$(RAW_VERSION)</string>|;}' \
+		"$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Info.plist"
+
+	# Compile for Apple Silicon using CMake
+	@cmake -B build -DCMAKE_BUILD_TYPE=Release -DCMAKE_OSX_ARCHITECTURES=arm64
+	@cmake --build build
+	@cp $(TARGET_FILE) "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/MacOS/$(TARGET_NAME)"
+
+	# Code sign
+	@codesign --deep --force --sign - --timestamp=none "$(RELEASE_FOLDER)/$(APP_NAME).app" || echo "Warning: Code signing failed"
+
+	# Create DMG
+	@echo "Creating DMG for Apple Silicon..."
+	@create-dmg \
+		--volname "$(APP_NAME)" \
+		--window-pos 200 120 \
+		--window-size 720 300 \
+		--icon-size 96 \
+		--text-size 12 \
+		--icon "$(APP_NAME).app" 278 102 \
+		--app-drop-link 115 102 \
+		--hide-extension "$(APP_NAME).app" \
+		"$(MACOS_ARM_RELEASE)" \
+		"$(RELEASE_FOLDER)" || true
+	@echo "✓ macOS release created: $(MACOS_ARM_RELEASE)"
+
+	# Cleanup
+	@$(RMDIR) Frameworks
+	@$(RMDIR) "$(RELEASE_FOLDER)"
+
+# Linux Release
+.PHONY: linux_release
+linux_release:
+	@echo "Creating Linux release - Version: $(VERSION)"
+
+	# Clean previous
+	@$(RMDIR) "$(RELEASE_FOLDER)"
+	@$(RMFILE) "$(LINUX_RELEASE)"
+
+	# Create folder
+	@$(MKDIR) "$(RELEASE_FOLDER)"
+
+	# Copy resources
+	@cp -r resources "$(RELEASE_FOLDER)/"
+	@cp LICENSE "$(RELEASE_FOLDER)/" 2>/dev/null || echo "Warning: LICENSE not found"
+	@cp README.md "$(RELEASE_FOLDER)/" 2>/dev/null || echo "Warning: README.md not found"
+
+	# Compile with CMake
+	@cmake -B build -DCMAKE_BUILD_TYPE=Release
+	@cmake --build build
+	@cp $(TARGET_FILE) "$(RELEASE_FILE)"
+	@strip -s -R .comment -R .gnu.version "$(RELEASE_FILE)" --strip-unneeded || strip "$(RELEASE_FILE)"
+
+	# Package
+	@tar -czf "$(LINUX_RELEASE)" -C "$(RELEASE_FOLDER)" .
+	@echo "✓ Linux release created: $(LINUX_RELEASE)"
+
+	# Cleanup
+	@$(RMDIR) "$(RELEASE_FOLDER)"
+
+# Windows Release (requires MinGW on Windows or cross-compiler on Linux)
+.PHONY: windows_release
+windows_release:
+	@echo "Creating Windows release - Version: $(VERSION)"
+	@echo "Note: This target should be run on Windows with MinGW or use windows_cross on Linux"
+
+	# Clean previous
+	@$(RMDIR) "$(RELEASE_FOLDER)"
+	@$(RMFILE) "$(WINDOWS_RELEASE)"
+
+	# Create folder
+	@$(MKDIR) "$(RELEASE_FOLDER)"
+
+	# Copy resources
+	@cp -r resources "$(RELEASE_FOLDER)/"
+	@cp release/dll/*.dll "$(RELEASE_FOLDER)/" 2>/dev/null || echo "Warning: DLLs not found"
+	@cp LICENSE "$(RELEASE_FOLDER)/" 2>/dev/null || echo "Warning: LICENSE not found"
+	@cp README.md "$(RELEASE_FOLDER)/" 2>/dev/null || echo "Warning: README.md not found"
+
+	# Compile resource file
+	@windres release/$(TARGET_NAME).rc -O coff -o release/$(TARGET_NAME).res 2>/dev/null || echo "Warning: windres failed"
+
+	# Compile with CMake
+	@cmake -B build -DCMAKE_BUILD_TYPE=Release
+	@cmake --build build
+	@cp $(TARGET_FILE).exe "$(RELEASE_FILE).exe" || cp $(TARGET_FILE) "$(RELEASE_FILE).exe"
+
+	# Package
+	@cd "$(RELEASE_FOLDER)" && zip -r ../$(WINDOWS_RELEASE) *
+	@echo "✓ Windows release created: $(WINDOWS_RELEASE)"
+
+	# Cleanup
+	@$(RMDIR) "$(RELEASE_FOLDER)"
+
+# Raspberry Pi Release (cross-compilation from Linux/macOS)
+.PHONY: rpi_release
+rpi_release:
+	@echo "Creating Raspberry Pi ARM64 release - Version: $(VERSION)"
+	@echo "Note: Requires aarch64-linux-gnu-g++ cross-compiler"
+
+	# Check for cross-compiler
+	@command -v aarch64-linux-gnu-g++ >/dev/null || (echo "Error: aarch64-linux-gnu-g++ not found" && exit 1)
+
+	# Clean previous
+	@$(RMDIR) "$(RELEASE_FOLDER)"
+	@$(RMFILE) "$(RPI_RELEASE)"
+
+	# Create folder
+	@$(MKDIR) "$(RELEASE_FOLDER)"
+
+	# Copy resources
+	@cp -r resources "$(RELEASE_FOLDER)/"
+	@cp LICENSE "$(RELEASE_FOLDER)/" 2>/dev/null || echo "Warning: LICENSE not found"
+	@cp README.md "$(RELEASE_FOLDER)/" 2>/dev/null || echo "Warning: README.md not found"
+
+	# Note: Cross-compilation with CMake is complex, would need toolchain file
+	@echo "Warning: RPI cross-compilation requires manual setup with CMake toolchain file"
+	@echo "Falling back to direct g++ compilation..."
+	@aarch64-linux-gnu-g++ -std=c++20 -Wall -O2 -DLINUX_BUILD -DRPI_BUILD \
+		-Isource -Ibuild \
+		$$(find source/core source/game -name "*.cpp") source/main.cpp \
+		-lSDL3 -o "$(RELEASE_FILE)" || echo "Error: Compilation failed"
+	@aarch64-linux-gnu-strip -s -R .comment -R .gnu.version "$(RELEASE_FILE)" --strip-unneeded || true
+
+	# Package
+	@tar -czf "$(RPI_RELEASE)" -C "$(RELEASE_FOLDER)" .
+	@echo "✓ Raspberry Pi release created: $(RPI_RELEASE)"
+
+	# Cleanup
+	@$(RMDIR) "$(RELEASE_FOLDER)"
+
+# Windows Cross-compilation (from Linux/macOS)
+.PHONY: windows_cross
+windows_cross:
+	@echo "Cross-compiling for Windows from $(UNAME_S) - Version: $(VERSION)"
+
+	# Check for cross-compiler
+	@command -v x86_64-w64-mingw32-g++ >/dev/null || (echo "Error: x86_64-w64-mingw32-g++ not found" && exit 1)
+
+	# Clean previous
+	@$(RMDIR) "$(RELEASE_FOLDER)"
+	@$(RMFILE) "$(WINDOWS_RELEASE)"
+
+	# Create folder
+	@$(MKDIR) "$(RELEASE_FOLDER)"
+
+	# Copy resources
+	@cp -r resources "$(RELEASE_FOLDER)/"
+	@cp release/dll/*.dll "$(RELEASE_FOLDER)/" 2>/dev/null || echo "Warning: DLLs not found in release/dll/"
+	@cp LICENSE "$(RELEASE_FOLDER)/" 2>/dev/null || echo "Warning: LICENSE not found"
+	@cp README.md "$(RELEASE_FOLDER)/" 2>/dev/null || echo "Warning: README.md not found"
+
+	# Compile resource file
+	@x86_64-w64-mingw32-windres release/$(TARGET_NAME).rc -O coff -o release/$(TARGET_NAME).res 2>/dev/null || echo "Warning: windres failed"
+
+	# Cross-compile
+	@echo "Compiling with MinGW cross-compiler..."
+	@x86_64-w64-mingw32-g++ -std=c++20 -Wall -O2 -DWINDOWS_BUILD -DRELEASE_BUILD \
+		-static-libstdc++ -static-libgcc -Wl,-subsystem,windows \
+		-Isource -Ibuild \
+		$$(find source/core source/game -name "*.cpp") source/main.cpp \
+		release/$(TARGET_NAME).res \
+		-lmingw32 -lSDL3 -o "$(RELEASE_FILE).exe" || echo "Error: Compilation failed"
+	@x86_64-w64-mingw32-strip "$(RELEASE_FILE).exe" || true
+
+	# Package
+	@cd "$(RELEASE_FOLDER)" && zip -r ../$(WINDOWS_RELEASE) *
+	@echo "✓ Windows cross-compiled release created: $(WINDOWS_RELEASE)"
+
+	# Cleanup
+	@$(RMDIR) "$(RELEASE_FOLDER)"
 
 # Clean build artifacts
 clean:
 ifeq ($(OS),Windows_NT)
-	@if exist $(call FixPath,$(TARGET_FILE).exe) $(RM) $(call FixPath,$(TARGET_FILE).exe)
+	@if exist $(call FixPath,$(TARGET_FILE).exe) $(RMFILE) $(call FixPath,$(TARGET_FILE).exe)
-	@if exist $(call FixPath,$(TARGET_FILE)_debug.exe) $(RM) $(call FixPath,$(TARGET_FILE)_debug.exe)
+	@if exist $(call FixPath,$(TARGET_FILE)_debug.exe) $(RMFILE) $(call FixPath,$(TARGET_FILE)_debug.exe)
 	@if exist build $(RMDIR) build
 	@if exist $(RELEASE_FOLDER) $(RMDIR) $(RELEASE_FOLDER)
 else
-	@$(RMFILE) $(TARGET_FILE)
+	@$(RMFILE) $(TARGET_FILE) $(TARGET_FILE)_debug
-	@$(RMFILE) $(TARGET_FILE)_debug
+	@$(RMDIR) build $(RELEASE_FOLDER)
-	@$(RMDIR) build
+	@$(RMFILE) *.dmg *.zip *.tar.gz 2>/dev/null || true
-	@$(RMDIR) $(RELEASE_FOLDER)
 endif
-	@echo Clean complete
+	@echo "Clean complete"
 
 # Backup to remote server
 backup:
@@ -186,14 +332,25 @@ backup:
 # Help target
 help:
 	@echo "Available targets:"
-	@echo "  all           - Build the game (default)"
+	@echo ""
-	@echo "  debug         - Build with debug symbols"
+	@echo "Build:"
-	@echo "  clean         - Remove build artifacts"
+	@echo "  all               - Build the game (default, delegates to CMake)"
-	@echo "  backup        - Backup project to remote server"
+	@echo "  debug             - Build with debug symbols"
-	@echo "  help          - Show this help message"
+	@echo "  clean             - Remove build artifacts and release packages"
+	@echo ""
+	@echo "Release Packaging:"
+	@echo "  macos_release     - Create macOS .app bundle + .dmg (Apple Silicon)"
+	@echo "  linux_release     - Create Linux .tar.gz"
+	@echo "  windows_release   - Create Windows .zip (requires MinGW on Windows)"
+	@echo "  windows_cross     - Cross-compile Windows from Linux/macOS (requires MinGW)"
+	@echo "  rpi_release       - Cross-compile for Raspberry Pi ARM64"
+	@echo ""
+	@echo "Other:"
+	@echo "  backup            - Backup project to remote server"
+	@echo "  help              - Show this help message"
 	@echo ""
 	@echo "Current configuration:"
+	@echo "  Project:      $(LONG_NAME)"
 	@echo "  Target:       $(TARGET_NAME)"
 	@echo "  Version:      $(VERSION)"
 	@echo "  Platform:     $(UNAME_S)"
-	@echo "  C++ Standard: $(CPP_STANDARD)"

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/audio/audio.cpp

@@ -0,0 +1,183 @@
+#include "audio.hpp"
+
+#include <SDL3/SDL.h>  // Para SDL_LogInfo, SDL_LogCategory, SDL_G...
+
+#include <algorithm>  // Para clamp
+#include <iostream>   // Para std::cout
+
+// Implementación de stb_vorbis (debe estar ANTES de incluir jail_audio.hpp)
+// clang-format off
+#undef STB_VORBIS_HEADER_ONLY
+#include "external/stb_vorbis.h"
+// clang-format on
+
+#include "core/audio/audio_cache.hpp"  // Para AudioCache
+#include "core/audio/jail_audio.hpp"   // Para JA_FadeOutMusic, JA_Init, JA_PauseM...
+#include "game/options.hpp"            // Para AudioOptions, audio, MusicOptions
+
+// Singleton
+Audio* Audio::instance = nullptr;
+
+// Inicializa la instancia única del singleton
+void Audio::init() { Audio::instance = new Audio(); }
+
+// Libera la instancia
+void Audio::destroy() { delete Audio::instance; }
+
+// Obtiene la instancia
+auto Audio::get() -> Audio* { return Audio::instance; }
+
+// Constructor
+Audio::Audio() { initSDLAudio(); }
+
+// Destructor
+Audio::~Audio() {
+    JA_Quit();
+}
+
+// Método principal
+void Audio::update() {
+    JA_Update();
+}
+
+// Reproduce la música
+void Audio::playMusic(const std::string& name, const int loop) {
+    bool new_loop = (loop != 0);
+
+    // Si ya está sonando exactamente la misma pista y mismo modo loop, no hacemos nada
+    if (music_.state == MusicState::PLAYING && music_.name == name && music_.loop == new_loop) {
+        return;
+    }
+
+    // Intentar obtener recurso; si falla, no tocar estado
+    auto* resource = AudioCache::getMusic(name);
+    if (resource == nullptr) {
+        // manejo de error opcional
+        return;
+    }
+
+    // Si hay algo reproduciéndose, detenerlo primero (si el backend lo requiere)
+    if (music_.state == MusicState::PLAYING) {
+        JA_StopMusic();  // sustituir por la función de stop real del API si tiene otro nombre
+    }
+
+    // Llamada al motor para reproducir la nueva pista
+    JA_PlayMusic(resource, loop);
+
+    // Actualizar estado y metadatos después de iniciar con éxito
+    music_.name = name;
+    music_.loop = new_loop;
+    music_.state = MusicState::PLAYING;
+}
+
+// Pausa la música
+void Audio::pauseMusic() {
+    if (music_enabled_ && music_.state == MusicState::PLAYING) {
+        JA_PauseMusic();
+        music_.state = MusicState::PAUSED;
+    }
+}
+
+// Continua la música pausada
+void Audio::resumeMusic() {
+    if (music_enabled_ && music_.state == MusicState::PAUSED) {
+        JA_ResumeMusic();
+        music_.state = MusicState::PLAYING;
+    }
+}
+
+// Detiene la música
+void Audio::stopMusic() {
+    if (music_enabled_) {
+        JA_StopMusic();
+        music_.state = MusicState::STOPPED;
+    }
+}
+
+// Reproduce un sonido por nombre
+void Audio::playSound(const std::string& name, Group group) const {
+    if (sound_enabled_) {
+        JA_PlaySound(AudioCache::getSound(name), 0, static_cast<int>(group));
+    }
+}
+
+// Reproduce un sonido por puntero directo
+void Audio::playSound(JA_Sound_t* sound, Group group) const {
+    if (sound_enabled_) {
+        JA_PlaySound(sound, 0, static_cast<int>(group));
+    }
+}
+
+// Detiene todos los sonidos
+void Audio::stopAllSounds() const {
+    if (sound_enabled_) {
+        JA_StopChannel(-1);
+    }
+}
+
+// Realiza un fundido de salida de la música
+void Audio::fadeOutMusic(int milliseconds) const {
+    if (music_enabled_ && getRealMusicState() == MusicState::PLAYING) {
+        JA_FadeOutMusic(milliseconds);
+    }
+}
+
+// Consulta directamente el estado real de la música en jailaudio
+auto Audio::getRealMusicState() -> MusicState {
+    JA_Music_state ja_state = JA_GetMusicState();
+    switch (ja_state) {
+        case JA_MUSIC_PLAYING:
+            return MusicState::PLAYING;
+        case JA_MUSIC_PAUSED:
+            return MusicState::PAUSED;
+        case JA_MUSIC_STOPPED:
+        case JA_MUSIC_INVALID:
+        case JA_MUSIC_DISABLED:
+        default:
+            return MusicState::STOPPED;
+    }
+}
+
+// Establece el volumen de los sonidos
+void Audio::setSoundVolume(float sound_volume, Group group) const {
+    if (sound_enabled_) {
+        sound_volume = std::clamp(sound_volume, MIN_VOLUME, MAX_VOLUME);
+        const float CONVERTED_VOLUME = sound_volume * Options::audio.volume;
+        JA_SetSoundVolume(CONVERTED_VOLUME, static_cast<int>(group));
+    }
+}
+
+// Establece el volumen de la música
+void Audio::setMusicVolume(float music_volume) const {
+    if (music_enabled_) {
+        music_volume = std::clamp(music_volume, MIN_VOLUME, MAX_VOLUME);
+        const float CONVERTED_VOLUME = music_volume * Options::audio.volume;
+        JA_SetMusicVolume(CONVERTED_VOLUME);
+    }
+}
+
+// Aplica la configuración
+void Audio::applySettings() {
+    enable(Options::audio.enabled);
+}
+
+// Establecer estado general
+void Audio::enable(bool value) {
+    enabled_ = value;
+
+    setSoundVolume(enabled_ ? Options::audio.sound.volume : MIN_VOLUME);
+    setMusicVolume(enabled_ ? Options::audio.music.volume : MIN_VOLUME);
+}
+
+// Inicializa SDL Audio
+void Audio::initSDLAudio() {
+    if (!SDL_Init(SDL_INIT_AUDIO)) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "SDL_AUDIO could not initialize! SDL Error: %s", SDL_GetError());
+    } else {
+        JA_Init(FREQUENCY, SDL_AUDIO_S16LE, 2);
+        enable(Options::audio.enabled);
+
+        std::cout << "\n** AUDIO SYSTEM **\n";
+        std::cout << "Audio system initialized successfully\n";
+    }
+}

source/core/audio/audio.hpp

@@ -0,0 +1,97 @@
+#pragma once
+
+#include <string>   // Para string
+#include <utility>  // Para move
+
+// --- Clase Audio: gestor de audio (singleton) ---
+class Audio {
+    public:
+        // --- Enums ---
+        enum class Group : int {
+            ALL = -1,      // Todos los grupos
+            GAME = 0,      // Sonidos del juego
+            INTERFACE = 1  // Sonidos de la interfaz
+        };
+
+        enum class MusicState {
+            PLAYING,  // Reproduciendo música
+            PAUSED,   // Música pausada
+            STOPPED,  // Música detenida
+        };
+
+        // --- Constantes ---
+        static constexpr float MAX_VOLUME = 1.0F;  // Volumen máximo
+        static constexpr float MIN_VOLUME = 0.0F;  // Volumen mínimo
+        static constexpr int FREQUENCY = 48000;    // Frecuencia de audio
+
+        // --- Singleton ---
+        static void init();                               // Inicializa el objeto Audio
+        static void destroy();                            // Libera el objeto Audio
+        static auto get() -> Audio*;                      // Obtiene el puntero al objeto Audio
+        Audio(const Audio&) = delete;                     // Evitar copia
+        auto operator=(const Audio&) -> Audio& = delete;  // Evitar asignación
+
+        static void update();  // Actualización del sistema de audio
+
+        // --- Control de música ---
+        void playMusic(const std::string& name, int loop = -1);  // Reproducir música en bucle
+        void pauseMusic();                                       // Pausar reproducción de música
+        void resumeMusic();                                      // Continua la música pausada
+        void stopMusic();                                        // Detener completamente la música
+        void fadeOutMusic(int milliseconds) const;               // Fundido de salida de la música
+
+        // --- Control de sonidos ---
+        void playSound(const std::string& name, Group group = Group::GAME) const;   // Reproducir sonido puntual por nombre
+        void playSound(struct JA_Sound_t* sound, Group group = Group::GAME) const;  // Reproducir sonido puntual por puntero
+        void stopAllSounds() const;                                                 // Detener todos los sonidos
+
+        // --- Control de volumen ---
+        void setSoundVolume(float volume, Group group = Group::ALL) const;  // Ajustar volumen de efectos
+        void setMusicVolume(float volume) const;                            // Ajustar volumen de música
+
+        // --- Configuración general ---
+        void enable(bool value);                        // Establecer estado general
+        void toggleEnabled() { enabled_ = !enabled_; }  // Alternar estado general
+        void applySettings();                           // Aplica la configuración
+
+        // --- Configuración de sonidos ---
+        void enableSound() { sound_enabled_ = true; }             // Habilitar sonidos
+        void disableSound() { sound_enabled_ = false; }           // Deshabilitar sonidos
+        void enableSound(bool value) { sound_enabled_ = value; }  // Establecer estado de sonidos
+        void toggleSound() { sound_enabled_ = !sound_enabled_; }  // Alternar estado de sonidos
+
+        // --- Configuración de música ---
+        void enableMusic() { music_enabled_ = true; }             // Habilitar música
+        void disableMusic() { music_enabled_ = false; }           // Deshabilitar música
+        void enableMusic(bool value) { music_enabled_ = value; }  // Establecer estado de música
+        void toggleMusic() { music_enabled_ = !music_enabled_; }  // Alternar estado de música
+
+        // --- Consultas de estado ---
+        [[nodiscard]] auto isEnabled() const -> bool { return enabled_; }
+        [[nodiscard]] auto isSoundEnabled() const -> bool { return sound_enabled_; }
+        [[nodiscard]] auto isMusicEnabled() const -> bool { return music_enabled_; }
+        [[nodiscard]] auto getMusicState() const -> MusicState { return music_.state; }
+        [[nodiscard]] static auto getRealMusicState() -> MusicState;
+        [[nodiscard]] auto getCurrentMusicName() const -> const std::string& { return music_.name; }
+
+    private:
+        // --- Tipos anidados ---
+        struct Music {
+                MusicState state{MusicState::STOPPED};  // Estado actual de la música
+                std::string name;                       // Última pista de música reproducida
+                bool loop{false};                       // Indica si se reproduce en bucle
+        };
+
+        // --- Métodos ---
+        Audio();              // Constructor privado
+        ~Audio();             // Destructor privado
+        void initSDLAudio();  // Inicializa SDL Audio
+
+        // --- Variables miembro ---
+        static Audio* instance;  // Instancia única de Audio
+
+        Music music_;               // Estado de la música
+        bool enabled_{true};        // Estado general del audio
+        bool sound_enabled_{true};  // Estado de los efectos de sonido
+        bool music_enabled_{true};  // Estado de la música
+};

source/core/audio/audio_cache.cpp

@@ -0,0 +1,118 @@
+// audio_cache.cpp - Implementació del caché de sons i música
+// © 2025 Port a C++20 amb SDL3
+
+#include "core/audio/audio_cache.hpp"
+
+#include <iostream>
+
+// Inicialització de variables estàtiques
+std::unordered_map<std::string, JA_Sound_t*> AudioCache::sounds_;
+std::unordered_map<std::string, JA_Music_t*> AudioCache::musics_;
+std::string AudioCache::sounds_base_path_ = "data/sounds/";
+std::string AudioCache::music_base_path_ = "data/music/";
+
+JA_Sound_t* AudioCache::getSound(const std::string& name) {
+    // Cache hit
+    auto it = sounds_.find(name);
+    if (it != sounds_.end()) {
+        std::cout << "[AudioCache] Sound cache hit: " << name << std::endl;
+        return it->second;
+    }
+
+    // Cache miss - cargar archivo
+    std::string fullpath = resolveSoundPath(name);
+    JA_Sound_t* sound = JA_LoadSound(fullpath.c_str());
+
+    if (sound == nullptr) {
+        std::cerr << "[AudioCache] Error: no s'ha pogut carregar " << fullpath
+                  << std::endl;
+        return nullptr;
+    }
+
+    std::cout << "[AudioCache] Sound loaded: " << name << std::endl;
+    sounds_[name] = sound;
+    return sound;
+}
+
+JA_Music_t* AudioCache::getMusic(const std::string& name) {
+    // Cache hit
+    auto it = musics_.find(name);
+    if (it != musics_.end()) {
+        std::cout << "[AudioCache] Music cache hit: " << name << std::endl;
+        return it->second;
+    }
+
+    // Cache miss - cargar archivo
+    std::string fullpath = resolveMusicPath(name);
+    JA_Music_t* music = JA_LoadMusic(fullpath.c_str());
+
+    if (music == nullptr) {
+        std::cerr << "[AudioCache] Error: no s'ha pogut carregar " << fullpath
+                  << std::endl;
+        return nullptr;
+    }
+
+    std::cout << "[AudioCache] Music loaded: " << name << std::endl;
+    musics_[name] = music;
+    return music;
+}
+
+void AudioCache::clear() {
+    std::cout << "[AudioCache] Clearing cache (" << sounds_.size() << " sounds, "
+              << musics_.size() << " music)" << std::endl;
+
+    // Liberar memoria de sonidos
+    for (auto& [name, sound] : sounds_) {
+        if (sound && sound->buffer) {
+            SDL_free(sound->buffer);
+        }
+        delete sound;
+    }
+    sounds_.clear();
+
+    // Liberar memoria de música
+    for (auto& [name, music] : musics_) {
+        if (music && music->buffer) {
+            SDL_free(music->buffer);
+        }
+        if (music && music->filename) {
+            free(music->filename);
+        }
+        delete music;
+    }
+    musics_.clear();
+}
+
+size_t AudioCache::getSoundCacheSize() { return sounds_.size(); }
+
+size_t AudioCache::getMusicCacheSize() { return musics_.size(); }
+
+std::string AudioCache::resolveSoundPath(const std::string& name) {
+    // Si es un path absoluto (comienza con '/'), usarlo directamente
+    if (!name.empty() && name[0] == '/') {
+        return name;
+    }
+
+    // Si ya contiene el prefix base_path, usarlo directamente
+    if (name.find(sounds_base_path_) == 0) {
+        return name;
+    }
+
+    // Caso contrario, añadir base_path
+    return sounds_base_path_ + name;
+}
+
+std::string AudioCache::resolveMusicPath(const std::string& name) {
+    // Si es un path absoluto (comienza con '/'), usarlo directamente
+    if (!name.empty() && name[0] == '/') {
+        return name;
+    }
+
+    // Si ya contiene el prefix base_path, usarlo directamente
+    if (name.find(music_base_path_) == 0) {
+        return name;
+    }
+
+    // Caso contrario, añadir base_path
+    return music_base_path_ + name;
+}

source/core/audio/audio_cache.hpp

@@ -0,0 +1,42 @@
+// audio_cache.hpp - Caché simplificado de sonidos y música
+// © 2025 Port a C++20 amb SDL3
+
+#pragma once
+
+#include <string>
+#include <unordered_map>
+
+#include "core/audio/jail_audio.hpp"
+
+// Caché estático de sonidos y música
+// Patrón inspirado en Graphics::ShapeLoader
+class AudioCache {
+    public:
+        // No instanciable (todo estático)
+        AudioCache() = delete;
+
+        // Obtener sonido (carga bajo demanda)
+        // Retorna puntero (nullptr si error)
+        static JA_Sound_t* getSound(const std::string& name);
+
+        // Obtener música (carga bajo demanda)
+        // Retorna puntero (nullptr si error)
+        static JA_Music_t* getMusic(const std::string& name);
+
+        // Limpiar caché (útil para debug/recarga)
+        static void clear();
+
+        // Estadísticas (debug)
+        static size_t getSoundCacheSize();
+        static size_t getMusicCacheSize();
+
+    private:
+        static std::unordered_map<std::string, JA_Sound_t*> sounds_;
+        static std::unordered_map<std::string, JA_Music_t*> musics_;
+        static std::string sounds_base_path_;  // "data/sounds/"
+        static std::string music_base_path_;   // "data/music/"
+
+        // Helpers privados
+        static std::string resolveSoundPath(const std::string& name);
+        static std::string resolveMusicPath(const std::string& name);
+};

source/core/audio/jail_audio.hpp

@@ -0,0 +1,482 @@
+#pragma once
+
+// --- Includes ---
+#include <SDL3/SDL.h>
+#include <stdint.h>  // Para uint32_t, uint8_t
+#include <stdio.h>   // Para NULL, fseek, printf, fclose, fopen, fread, ftell, FILE, SEEK_END, SEEK_SET
+#include <stdlib.h>  // Para free, malloc
+#include <string.h>  // Para strcpy, strlen
+
+#define STB_VORBIS_HEADER_ONLY
+#include "external/stb_vorbis.h"  // Para stb_vorbis_decode_memory
+
+// --- Public Enums ---
+enum JA_Channel_state { JA_CHANNEL_INVALID,
+    JA_CHANNEL_FREE,
+    JA_CHANNEL_PLAYING,
+    JA_CHANNEL_PAUSED,
+    JA_SOUND_DISABLED };
+enum JA_Music_state { JA_MUSIC_INVALID,
+    JA_MUSIC_PLAYING,
+    JA_MUSIC_PAUSED,
+    JA_MUSIC_STOPPED,
+    JA_MUSIC_DISABLED };
+
+// --- Struct Definitions ---
+#define JA_MAX_SIMULTANEOUS_CHANNELS 20
+#define JA_MAX_GROUPS 2
+
+struct JA_Sound_t {
+        SDL_AudioSpec spec{SDL_AUDIO_S16, 2, 48000};
+        Uint32 length{0};
+        Uint8* buffer{NULL};
+};
+
+struct JA_Channel_t {
+        JA_Sound_t* sound{nullptr};
+        int pos{0};
+        int times{0};
+        int group{0};
+        SDL_AudioStream* stream{nullptr};
+        JA_Channel_state state{JA_CHANNEL_FREE};
+};
+
+struct JA_Music_t {
+        SDL_AudioSpec spec{SDL_AUDIO_S16, 2, 48000};
+        Uint32 length{0};
+        Uint8* buffer{nullptr};
+        char* filename{nullptr};
+
+        int pos{0};
+        int times{0};
+        SDL_AudioStream* stream{nullptr};
+        JA_Music_state state{JA_MUSIC_INVALID};
+};
+
+// --- Internal Global State ---
+// Marcado 'inline' (C++17) para asegurar una única instancia.
+
+inline JA_Music_t* current_music{nullptr};
+inline JA_Channel_t channels[JA_MAX_SIMULTANEOUS_CHANNELS];
+
+inline SDL_AudioSpec JA_audioSpec{SDL_AUDIO_S16, 2, 48000};
+inline float JA_musicVolume{1.0f};
+inline float JA_soundVolume[JA_MAX_GROUPS];
+inline bool JA_musicEnabled{true};
+inline bool JA_soundEnabled{true};
+inline SDL_AudioDeviceID sdlAudioDevice{0};
+
+inline bool fading{false};
+inline int fade_start_time{0};
+inline int fade_duration{0};
+inline float fade_initial_volume{0.0f};  // Corregido de 'int' a 'float'
+
+// --- Forward Declarations ---
+inline void JA_StopMusic();
+inline void JA_StopChannel(const int channel);
+inline int JA_PlaySoundOnChannel(JA_Sound_t* sound, const int channel, const int loop = 0, const int group = 0);
+
+// --- Core Functions ---
+
+inline void JA_Update() {
+    if (JA_musicEnabled && current_music && current_music->state == JA_MUSIC_PLAYING) {
+        if (fading) {
+            int time = SDL_GetTicks();
+            if (time > (fade_start_time + fade_duration)) {
+                fading = false;
+                JA_StopMusic();
+                return;
+            } else {
+                const int time_passed = time - fade_start_time;
+                const float percent = (float)time_passed / (float)fade_duration;
+                SDL_SetAudioStreamGain(current_music->stream, JA_musicVolume * (1.0 - percent));
+            }
+        }
+
+        if (current_music->times != 0) {
+            if ((Uint32)SDL_GetAudioStreamAvailable(current_music->stream) < (current_music->length / 2)) {
+                SDL_PutAudioStreamData(current_music->stream, current_music->buffer, current_music->length);
+            }
+            if (current_music->times > 0) current_music->times--;
+        } else {
+            if (SDL_GetAudioStreamAvailable(current_music->stream) == 0) JA_StopMusic();
+        }
+    }
+
+    if (JA_soundEnabled) {
+        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; ++i)
+            if (channels[i].state == JA_CHANNEL_PLAYING) {
+                if (channels[i].times != 0) {
+                    if ((Uint32)SDL_GetAudioStreamAvailable(channels[i].stream) < (channels[i].sound->length / 2)) {
+                        SDL_PutAudioStreamData(channels[i].stream, channels[i].sound->buffer, channels[i].sound->length);
+                        if (channels[i].times > 0) channels[i].times--;
+                    }
+                } else {
+                    if (SDL_GetAudioStreamAvailable(channels[i].stream) == 0) JA_StopChannel(i);
+                }
+            }
+    }
+}
+
+inline void JA_Init(const int freq, const SDL_AudioFormat format, const int num_channels) {
+#ifdef _DEBUG
+    SDL_SetLogPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_DEBUG);
+#endif
+
+    JA_audioSpec = {format, num_channels, freq};
+    if (sdlAudioDevice) SDL_CloseAudioDevice(sdlAudioDevice);  // Corregido: !sdlAudioDevice -> sdlAudioDevice
+    sdlAudioDevice = SDL_OpenAudioDevice(SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK, &JA_audioSpec);
+    if (sdlAudioDevice == 0) SDL_Log("Failed to initialize SDL audio!");
+    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; ++i) channels[i].state = JA_CHANNEL_FREE;
+    for (int i = 0; i < JA_MAX_GROUPS; ++i) JA_soundVolume[i] = 0.5f;
+}
+
+inline void JA_Quit() {
+    if (sdlAudioDevice) SDL_CloseAudioDevice(sdlAudioDevice);  // Corregido: !sdlAudioDevice -> sdlAudioDevice
+    sdlAudioDevice = 0;
+}
+
+// --- Music Functions ---
+
+inline JA_Music_t* JA_LoadMusic(const Uint8* buffer, Uint32 length) {
+    JA_Music_t* music = new JA_Music_t();
+
+    int chan, samplerate;
+    short* output;
+    music->length = stb_vorbis_decode_memory(buffer, length, &chan, &samplerate, &output) * chan * 2;
+
+    music->spec.channels = chan;
+    music->spec.freq = samplerate;
+    music->spec.format = SDL_AUDIO_S16;
+    music->buffer = static_cast<Uint8*>(SDL_malloc(music->length));
+    SDL_memcpy(music->buffer, output, music->length);
+    free(output);
+    music->pos = 0;
+    music->state = JA_MUSIC_STOPPED;
+
+    return music;
+}
+
+inline JA_Music_t* JA_LoadMusic(const char* filename) {
+    // [RZC 28/08/22] Carreguem primer el arxiu en memòria i després el descomprimim. Es algo més rapid.
+    FILE* f = fopen(filename, "rb");
+    if (!f) return NULL;  // Añadida comprobación de apertura
+    fseek(f, 0, SEEK_END);
+    long fsize = ftell(f);
+    fseek(f, 0, SEEK_SET);
+    auto* buffer = static_cast<Uint8*>(malloc(fsize + 1));
+    if (!buffer) {  // Añadida comprobación de malloc
+        fclose(f);
+        return NULL;
+    }
+    if (fread(buffer, fsize, 1, f) != 1) {
+        fclose(f);
+        free(buffer);
+        return NULL;
+    }
+    fclose(f);
+
+    JA_Music_t* music = JA_LoadMusic(buffer, fsize);
+    if (music) {  // Comprobar que JA_LoadMusic tuvo éxito
+        music->filename = static_cast<char*>(malloc(strlen(filename) + 1));
+        if (music->filename) {
+            strcpy(music->filename, filename);
+        }
+    }
+
+    free(buffer);
+
+    return music;
+}
+
+inline void JA_PlayMusic(JA_Music_t* music, const int loop = -1) {
+    if (!JA_musicEnabled || !music) return;  // Añadida comprobación de music
+
+    JA_StopMusic();
+
+    current_music = music;
+    current_music->pos = 0;
+    current_music->state = JA_MUSIC_PLAYING;
+    current_music->times = loop;
+
+    current_music->stream = SDL_CreateAudioStream(&current_music->spec, &JA_audioSpec);
+    if (!current_music->stream) {  // Comprobar creación de stream
+        SDL_Log("Failed to create audio stream!");
+        current_music->state = JA_MUSIC_STOPPED;
+        return;
+    }
+    if (!SDL_PutAudioStreamData(current_music->stream, current_music->buffer, current_music->length)) printf("[ERROR] SDL_PutAudioStreamData failed!\n");
+    SDL_SetAudioStreamGain(current_music->stream, JA_musicVolume);
+    if (!SDL_BindAudioStream(sdlAudioDevice, current_music->stream)) printf("[ERROR] SDL_BindAudioStream failed!\n");
+}
+
+inline char* JA_GetMusicFilename(const JA_Music_t* music = nullptr) {
+    if (!music) music = current_music;
+    if (!music) return nullptr;  // Añadida comprobación
+    return music->filename;
+}
+
+inline void JA_PauseMusic() {
+    if (!JA_musicEnabled) return;
+    if (!current_music || current_music->state != JA_MUSIC_PLAYING) return;  // Comprobación mejorada
+
+    current_music->state = JA_MUSIC_PAUSED;
+    SDL_UnbindAudioStream(current_music->stream);
+}
+
+inline void JA_ResumeMusic() {
+    if (!JA_musicEnabled) return;
+    if (!current_music || current_music->state != JA_MUSIC_PAUSED) return;  // Comprobación mejorada
+
+    current_music->state = JA_MUSIC_PLAYING;
+    SDL_BindAudioStream(sdlAudioDevice, current_music->stream);
+}
+
+inline void JA_StopMusic() {
+    if (!current_music || current_music->state == JA_MUSIC_INVALID || current_music->state == JA_MUSIC_STOPPED) return;
+
+    current_music->pos = 0;
+    current_music->state = JA_MUSIC_STOPPED;
+    if (current_music->stream) {
+        SDL_DestroyAudioStream(current_music->stream);
+        current_music->stream = nullptr;
+    }
+    // No liberamos filename aquí, se debería liberar en JA_DeleteMusic
+}
+
+inline void JA_FadeOutMusic(const int milliseconds) {
+    if (!JA_musicEnabled) return;
+    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return;
+
+    fading = true;
+    fade_start_time = SDL_GetTicks();
+    fade_duration = milliseconds;
+    fade_initial_volume = JA_musicVolume;
+}
+
+inline JA_Music_state JA_GetMusicState() {
+    if (!JA_musicEnabled) return JA_MUSIC_DISABLED;
+    if (!current_music) return JA_MUSIC_INVALID;
+
+    return current_music->state;
+}
+
+inline void JA_DeleteMusic(JA_Music_t* music) {
+    if (!music) return;
+    if (current_music == music) {
+        JA_StopMusic();
+        current_music = nullptr;
+    }
+    SDL_free(music->buffer);
+    if (music->stream) SDL_DestroyAudioStream(music->stream);
+    free(music->filename);  // filename se libera aquí
+    delete music;
+}
+
+inline float JA_SetMusicVolume(float volume) {
+    JA_musicVolume = SDL_clamp(volume, 0.0f, 1.0f);
+    if (current_music && current_music->stream) {
+        SDL_SetAudioStreamGain(current_music->stream, JA_musicVolume);
+    }
+    return JA_musicVolume;
+}
+
+inline void JA_SetMusicPosition(float value) {
+    if (!current_music) return;
+    current_music->pos = value * current_music->spec.freq;
+    // Nota: Esta implementación de 'pos' no parece usarse en JA_Update para
+    // el streaming. El streaming siempre parece empezar desde el principio.
+}
+
+inline float JA_GetMusicPosition() {
+    if (!current_music) return 0;
+    return float(current_music->pos) / float(current_music->spec.freq);
+    // Nota: Ver `JA_SetMusicPosition`
+}
+
+inline void JA_EnableMusic(const bool value) {
+    if (!value && current_music && (current_music->state == JA_MUSIC_PLAYING)) JA_StopMusic();
+
+    JA_musicEnabled = value;
+}
+
+// --- Sound Functions ---
+
+inline JA_Sound_t* JA_NewSound(Uint8* buffer, Uint32 length) {
+    JA_Sound_t* sound = new JA_Sound_t();
+    sound->buffer = buffer;
+    sound->length = length;
+    // Nota: spec se queda con los valores por defecto.
+    return sound;
+}
+
+inline JA_Sound_t* JA_LoadSound(uint8_t* buffer, uint32_t size) {
+    JA_Sound_t* sound = new JA_Sound_t();
+    if (!SDL_LoadWAV_IO(SDL_IOFromMem(buffer, size), 1, &sound->spec, &sound->buffer, &sound->length)) {
+        SDL_Log("Failed to load WAV from memory: %s", SDL_GetError());
+        delete sound;
+        return nullptr;
+    }
+    return sound;
+}
+
+inline JA_Sound_t* JA_LoadSound(const char* filename) {
+    JA_Sound_t* sound = new JA_Sound_t();
+    if (!SDL_LoadWAV(filename, &sound->spec, &sound->buffer, &sound->length)) {
+        SDL_Log("Failed to load WAV file: %s", SDL_GetError());
+        delete sound;
+        return nullptr;
+    }
+    return sound;
+}
+
+inline int JA_PlaySound(JA_Sound_t* sound, const int loop = 0, const int group = 0) {
+    if (!JA_soundEnabled || !sound) return -1;
+
+    int channel = 0;
+    while (channel < JA_MAX_SIMULTANEOUS_CHANNELS && channels[channel].state != JA_CHANNEL_FREE) { channel++; }
+    if (channel == JA_MAX_SIMULTANEOUS_CHANNELS) {
+        // No hay canal libre, reemplazamos el primero
+        channel = 0;
+    }
+
+    return JA_PlaySoundOnChannel(sound, channel, loop, group);
+}
+
+inline int JA_PlaySoundOnChannel(JA_Sound_t* sound, const int channel, const int loop, const int group) {
+    if (!JA_soundEnabled || !sound) return -1;
+    if (channel < 0 || channel >= JA_MAX_SIMULTANEOUS_CHANNELS) return -1;
+
+    JA_StopChannel(channel);  // Detiene y limpia el canal si estaba en uso
+
+    channels[channel].sound = sound;
+    channels[channel].times = loop;
+    channels[channel].pos = 0;
+    channels[channel].group = group;  // Asignar grupo
+    channels[channel].state = JA_CHANNEL_PLAYING;
+    channels[channel].stream = SDL_CreateAudioStream(&channels[channel].sound->spec, &JA_audioSpec);
+
+    if (!channels[channel].stream) {
+        SDL_Log("Failed to create audio stream for sound!");
+        channels[channel].state = JA_CHANNEL_FREE;
+        return -1;
+    }
+
+    SDL_PutAudioStreamData(channels[channel].stream, channels[channel].sound->buffer, channels[channel].sound->length);
+    SDL_SetAudioStreamGain(channels[channel].stream, JA_soundVolume[group]);
+    SDL_BindAudioStream(sdlAudioDevice, channels[channel].stream);
+
+    return channel;
+}
+
+inline void JA_DeleteSound(JA_Sound_t* sound) {
+    if (!sound) return;
+    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
+        if (channels[i].sound == sound) JA_StopChannel(i);
+    }
+    SDL_free(sound->buffer);
+    delete sound;
+}
+
+inline void JA_PauseChannel(const int channel) {
+    if (!JA_soundEnabled) return;
+
+    if (channel == -1) {
+        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
+            if (channels[i].state == JA_CHANNEL_PLAYING) {
+                channels[i].state = JA_CHANNEL_PAUSED;
+                SDL_UnbindAudioStream(channels[i].stream);
+            }
+    } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
+        if (channels[channel].state == JA_CHANNEL_PLAYING) {
+            channels[channel].state = JA_CHANNEL_PAUSED;
+            SDL_UnbindAudioStream(channels[channel].stream);
+        }
+    }
+}
+
+inline void JA_ResumeChannel(const int channel) {
+    if (!JA_soundEnabled) return;
+
+    if (channel == -1) {
+        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
+            if (channels[i].state == JA_CHANNEL_PAUSED) {
+                channels[i].state = JA_CHANNEL_PLAYING;
+                SDL_BindAudioStream(sdlAudioDevice, channels[i].stream);
+            }
+    } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
+        if (channels[channel].state == JA_CHANNEL_PAUSED) {
+            channels[channel].state = JA_CHANNEL_PLAYING;
+            SDL_BindAudioStream(sdlAudioDevice, channels[channel].stream);
+        }
+    }
+}
+
+inline void JA_StopChannel(const int channel) {
+    if (channel == -1) {
+        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
+            if (channels[i].state != JA_CHANNEL_FREE) {
+                if (channels[i].stream) SDL_DestroyAudioStream(channels[i].stream);
+                channels[i].stream = nullptr;
+                channels[i].state = JA_CHANNEL_FREE;
+                channels[i].pos = 0;
+                channels[i].sound = NULL;
+            }
+        }
+    } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
+        if (channels[channel].state != JA_CHANNEL_FREE) {
+            if (channels[channel].stream) SDL_DestroyAudioStream(channels[channel].stream);
+            channels[channel].stream = nullptr;
+            channels[channel].state = JA_CHANNEL_FREE;
+            channels[channel].pos = 0;
+            channels[channel].sound = NULL;
+        }
+    }
+}
+
+inline JA_Channel_state JA_GetChannelState(const int channel) {
+    if (!JA_soundEnabled) return JA_SOUND_DISABLED;
+    if (channel < 0 || channel >= JA_MAX_SIMULTANEOUS_CHANNELS) return JA_CHANNEL_INVALID;
+
+    return channels[channel].state;
+}
+
+inline float JA_SetSoundVolume(float volume, const int group = -1)  // -1 para todos los grupos
+{
+    const float v = SDL_clamp(volume, 0.0f, 1.0f);
+
+    if (group == -1) {
+        for (int i = 0; i < JA_MAX_GROUPS; ++i) {
+            JA_soundVolume[i] = v;
+        }
+    } else if (group >= 0 && group < JA_MAX_GROUPS) {
+        JA_soundVolume[group] = v;
+    } else {
+        return v;  // Grupo inválido
+    }
+
+    // Aplicar volumen a canales activos
+    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
+        if ((channels[i].state == JA_CHANNEL_PLAYING) || (channels[i].state == JA_CHANNEL_PAUSED)) {
+            if (group == -1 || channels[i].group == group) {
+                if (channels[i].stream) {
+                    SDL_SetAudioStreamGain(channels[i].stream, JA_soundVolume[channels[i].group]);
+                }
+            }
+        }
+    }
+    return v;
+}
+
+inline void JA_EnableSound(const bool value) {
+    if (!value) {
+        JA_StopChannel(-1);  // Detener todos los canales
+    }
+    JA_soundEnabled = value;
+}
+
+inline float JA_SetVolume(float volume) {
+    float v = JA_SetMusicVolume(volume);
+    JA_SetSoundVolume(v, -1);  // Aplicar a todos los grupos de sonido
+    return v;
+}

source/core/defaults.hpp

@@ -0,0 +1,167 @@
+#pragma once
+#include <SDL3/SDL.h>
+
+#include <cstdint>
+
+namespace Defaults {
+// Configuración de ventana
+namespace Window {
+constexpr int WIDTH = 640;
+constexpr int HEIGHT = 480;
+constexpr int MIN_WIDTH = 320;  // Mínimo: mitad del original
+constexpr int MIN_HEIGHT = 240;
+// Zoom system
+constexpr float BASE_ZOOM = 1.0f;       // 640x480 baseline
+constexpr float MIN_ZOOM = 0.5f;        // 320x240 minimum
+constexpr float ZOOM_INCREMENT = 0.1f;  // 10% steps (F1/F2)
+}  // namespace Window
+
+// Dimensions base del joc (coordenades lògiques)
+namespace Game {
+constexpr int WIDTH = 640;
+constexpr int HEIGHT = 480;
+}  // namespace Game
+
+// Zones del joc (SDL_FRect amb càlculs automàtics)
+namespace Zones {
+// --- CONFIGURACIÓ DE PORCENTATGES ---
+// Basats en valors originals 640x480
+// Ajusta estos valors per canviar proporcions
+
+constexpr float PLAYAREA_MARGIN_HORIZONTAL_PERCENT = 10.0f / Game::WIDTH;
+constexpr float PLAYAREA_MARGIN_VERTICAL_PERCENT = 10.0f / Game::HEIGHT;
+constexpr float SCOREBOARD_HEIGHT_PERCENT = 48.0f / Game::HEIGHT;
+
+// --- CÀLCULS AUTOMÀTICS ---
+// Estos valors es recalculen si canvien Game::WIDTH o Game::HEIGHT
+
+constexpr float PLAYAREA_MARGIN_H =
+    Game::WIDTH * PLAYAREA_MARGIN_HORIZONTAL_PERCENT;
+constexpr float PLAYAREA_MARGIN_V =
+    Game::HEIGHT * PLAYAREA_MARGIN_VERTICAL_PERCENT;
+constexpr float SCOREBOARD_H = Game::HEIGHT * SCOREBOARD_HEIGHT_PERCENT;
+
+// --- ZONES FINALS (SDL_FRect) ---
+
+// Zona de joc principal
+// Ocupa: tot menys marges (dalt, esq, dret) i scoreboard (baix)
+constexpr SDL_FRect PLAYAREA = {
+    PLAYAREA_MARGIN_H,                               // x = 10.0
+    PLAYAREA_MARGIN_V,                               // y = 10.0
+    Game::WIDTH - 2.0f * PLAYAREA_MARGIN_H,          // width = 620.0
+    Game::HEIGHT - PLAYAREA_MARGIN_V - SCOREBOARD_H  // height = 406.0
+};
+
+// Zona de marcador
+// Ocupa: tot l'ample, 64px d'alçada en la part inferior
+constexpr SDL_FRect SCOREBOARD = {
+    0.0f,                             // x = 0.0
+    Game::HEIGHT - SCOREBOARD_H,      // y = 416.0
+    static_cast<float>(Game::WIDTH),  // width = 640.0
+    SCOREBOARD_H                      // height = 64.0
+};
+}  // namespace Zones
+
+// Objetos del juego
+namespace Entities {
+constexpr int MAX_ORNIS = 15;
+constexpr int MAX_BALES = 3;
+constexpr int MAX_IPUNTS = 30;
+
+constexpr float SHIP_RADIUS = 12.0f;
+constexpr float ENEMY_RADIUS = 20.0f;
+constexpr float BULLET_RADIUS = 5.0f;
+}  // namespace Entities
+
+// Física (valores actuales del juego, sincronizados con joc_asteroides.cpp)
+namespace Physics {
+constexpr float ROTATION_SPEED = 3.14f;  // rad/s (~180°/s)
+constexpr float ACCELERATION = 400.0f;   // px/s²
+constexpr float MAX_VELOCITY = 120.0f;   // px/s
+constexpr float FRICTION = 20.0f;        // px/s²
+constexpr float ENEMY_SPEED = 2.0f;      // unidades/frame
+constexpr float BULLET_SPEED = 6.0f;     // unidades/frame
+constexpr float VELOCITY_SCALE = 20.0f;  // factor conversión frame→tiempo
+
+// Explosions (debris physics)
+namespace Debris {
+constexpr float VELOCITAT_BASE = 80.0f;      // Velocitat inicial (px/s)
+constexpr float VARIACIO_VELOCITAT = 40.0f;  // ±variació aleatòria (px/s)
+constexpr float ACCELERACIO = -60.0f;        // Fricció/desacceleració (px/s²)
+constexpr float ROTACIO_MIN = 0.1f;          // Rotació mínima (rad/s ~5.7°/s)
+constexpr float ROTACIO_MAX = 0.3f;          // Rotació màxima (rad/s ~17.2°/s)
+constexpr float TEMPS_VIDA = 2.0f;           // Duració màxima (segons)
+constexpr float SHRINK_RATE = 0.5f;          // Reducció de mida (factor/s)
+}  // namespace Debris
+}  // namespace Physics
+
+// Matemáticas
+namespace Math {
+constexpr float PI = 3.14159265359f;
+}  // namespace Math
+
+// Colores (oscilación para efecto CRT)
+namespace Color {
+// Frecuencia de oscilación
+constexpr float FREQUENCY = 6.0f;  // 1 Hz (1 ciclo/segundo)
+
+// Color de líneas (efecto fósforo verde CRT)
+constexpr uint8_t LINE_MIN_R = 100;  // Verde oscuro
+constexpr uint8_t LINE_MIN_G = 200;
+constexpr uint8_t LINE_MIN_B = 100;
+
+constexpr uint8_t LINE_MAX_R = 100;  // Verde brillante
+constexpr uint8_t LINE_MAX_G = 255;
+constexpr uint8_t LINE_MAX_B = 100;
+
+// Color de fondo (pulso sutil verde oscuro)
+constexpr uint8_t BACKGROUND_MIN_R = 0;  // Negro
+constexpr uint8_t BACKGROUND_MIN_G = 5;
+constexpr uint8_t BACKGROUND_MIN_B = 0;
+
+constexpr uint8_t BACKGROUND_MAX_R = 0;  // Verde muy oscuro
+constexpr uint8_t BACKGROUND_MAX_G = 15;
+constexpr uint8_t BACKGROUND_MAX_B = 0;
+}  // namespace Color
+
+// Brillantor (control de intensitat per cada tipus d'entitat)
+namespace Brightness {
+// Brillantor estàtica per entitats de joc (0.0-1.0)
+constexpr float NAU = 1.0f;     // Màxima visibilitat (jugador)
+constexpr float ENEMIC = 0.7f;  // 30% més tènue (destaca menys)
+constexpr float BALA = 0.9f;    // Destacada però menys que nau
+
+// Starfield: gradient segons distància al centre
+// distancia_centre: 0.0 (centre) → 1.0 (vora pantalla)
+// brightness = MIN + (MAX - MIN) * distancia_centre
+constexpr float STARFIELD_MIN = 0.3f;  // Estrelles llunyanes (prop del centre)
+constexpr float STARFIELD_MAX = 0.8f;  // Estrelles properes (vora pantalla)
+}  // namespace Brightness
+
+// Renderització (V-Sync i altres opcions de render)
+namespace Rendering {
+constexpr int VSYNC_DEFAULT = 1;  // 0=disabled, 1=enabled
+}  // namespace Rendering
+
+// Audio (sistema de so i música)
+namespace Audio {
+constexpr float VOLUME = 1.0F;  // Volumen maestro (0.0 a 1.0)
+constexpr bool ENABLED = true;  // Audio habilitado por defecto
+}  // namespace Audio
+
+// Música (pistas de fondo)
+namespace Music {
+constexpr float VOLUME = 0.8F;                  // Volumen música
+constexpr bool ENABLED = true;                  // Música habilitada
+constexpr const char* GAME_TRACK = "game.ogg";  // Pista de juego
+constexpr int FADE_DURATION_MS = 1000;          // Fade out duration
+}  // namespace Music
+
+// Efectes de so (sons puntuals)
+namespace Sound {
+constexpr float VOLUME = 1.0F;                      // Volumen efectos
+constexpr bool ENABLED = true;                      // Sonidos habilitados
+constexpr const char* EXPLOSION = "explosion.wav";  // Explosión
+constexpr const char* LASER = "laser_shoot.wav";    // Disparo
+}  // namespace Sound
+}  // namespace Defaults

source/core/graphics/shape.cpp

@@ -0,0 +1,155 @@
+// shape.cpp - Implementació del sistema de formes vectorials
+// © 2025 Port a C++20 amb SDL3
+
+#include "core/graphics/shape.hpp"
+
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+
+namespace Graphics {
+
+Shape::Shape(const std::string& filepath)
+    : centre_({0.0f, 0.0f}),
+      escala_defecte_(1.0f),
+      nom_("unnamed") {
+    carregar(filepath);
+}
+
+bool Shape::carregar(const std::string& filepath) {
+    // Llegir fitxer
+    std::ifstream file(filepath);
+    if (!file.is_open()) {
+        std::cerr << "[Shape] Error: no es pot obrir " << filepath << std::endl;
+        return false;
+    }
+
+    // Llegir tot el contingut
+    std::stringstream buffer;
+    buffer << file.rdbuf();
+    std::string contingut = buffer.str();
+    file.close();
+
+    // Parsejar
+    return parsejar_fitxer(contingut);
+}
+
+bool Shape::parsejar_fitxer(const std::string& contingut) {
+    std::istringstream iss(contingut);
+    std::string line;
+
+    while (std::getline(iss, line)) {
+        // Trim whitespace
+        line = trim(line);
+
+        // Skip comments and blanks
+        if (line.empty() || line[0] == '#')
+            continue;
+
+        // Parse command
+        if (starts_with(line, "name:")) {
+            nom_ = trim(extract_value(line));
+        } else if (starts_with(line, "scale:")) {
+            try {
+                escala_defecte_ = std::stof(extract_value(line));
+            } catch (...) {
+                std::cerr << "[Shape] Warning: escala invàlida, usant 1.0" << std::endl;
+                escala_defecte_ = 1.0f;
+            }
+        } else if (starts_with(line, "center:")) {
+            parse_center(extract_value(line));
+        } else if (starts_with(line, "polyline:")) {
+            auto points = parse_points(extract_value(line));
+            if (points.size() >= 2) {
+                primitives_.push_back({PrimitiveType::POLYLINE, points});
+            } else {
+                std::cerr << "[Shape] Warning: polyline amb menys de 2 punts ignorada"
+                          << std::endl;
+            }
+        } else if (starts_with(line, "line:")) {
+            auto points = parse_points(extract_value(line));
+            if (points.size() == 2) {
+                primitives_.push_back({PrimitiveType::LINE, points});
+            } else {
+                std::cerr << "[Shape] Warning: line ha de tenir exactament 2 punts"
+                          << std::endl;
+            }
+        }
+        // Comandes desconegudes ignorades silenciosament
+    }
+
+    if (primitives_.empty()) {
+        std::cerr << "[Shape] Error: cap primitiva carregada" << std::endl;
+        return false;
+    }
+
+    return true;
+}
+
+// Helper: trim whitespace
+std::string Shape::trim(const std::string& str) const {
+    const char* whitespace = " \t\n\r";
+    size_t start = str.find_first_not_of(whitespace);
+    if (start == std::string::npos)
+        return "";
+
+    size_t end = str.find_last_not_of(whitespace);
+    return str.substr(start, end - start + 1);
+}
+
+// Helper: starts_with
+bool Shape::starts_with(const std::string& str,
+    const std::string& prefix) const {
+    if (str.length() < prefix.length())
+        return false;
+    return str.compare(0, prefix.length(), prefix) == 0;
+}
+
+// Helper: extract value after ':'
+std::string Shape::extract_value(const std::string& line) const {
+    size_t colon = line.find(':');
+    if (colon == std::string::npos)
+        return "";
+    return line.substr(colon + 1);
+}
+
+// Helper: parse center "x, y"
+void Shape::parse_center(const std::string& value) {
+    std::string val = trim(value);
+    size_t comma = val.find(',');
+    if (comma != std::string::npos) {
+        try {
+            centre_.x = std::stof(trim(val.substr(0, comma)));
+            centre_.y = std::stof(trim(val.substr(comma + 1)));
+        } catch (...) {
+            std::cerr << "[Shape] Warning: centre invàlid, usant (0,0)" << std::endl;
+            centre_ = {0.0f, 0.0f};
+        }
+    }
+}
+
+// Helper: parse points "x1,y1  x2,y2  x3,y3"
+std::vector<Punt> Shape::parse_points(const std::string& str) const {
+    std::vector<Punt> points;
+    std::istringstream iss(trim(str));
+    std::string pair;
+
+    while (iss >> pair) {  // Whitespace-separated
+        size_t comma = pair.find(',');
+        if (comma != std::string::npos) {
+            try {
+                float x = std::stof(pair.substr(0, comma));
+                float y = std::stof(pair.substr(comma + 1));
+                points.push_back({x, y});
+            } catch (...) {
+                std::cerr << "[Shape] Warning: punt invàlid ignorat: " << pair
+                          << std::endl;
+            }
+        }
+    }
+
+    return points;
+}
+
+}  // namespace Graphics

source/core/graphics/shape.hpp

@@ -0,0 +1,64 @@
+// shape.hpp - Sistema de formes vectorials
+// © 2025 Port a C++20 amb SDL3
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "core/types.hpp"
+
+namespace Graphics {
+
+// Tipus de primitiva dins d'una forma
+enum class PrimitiveType {
+    POLYLINE,  // Seqüència de punts connectats
+    LINE       // Línia individual (2 punts)
+};
+
+// Primitiva individual (polyline o line)
+struct ShapePrimitive {
+        PrimitiveType type;
+        std::vector<Punt> points;  // 2+ punts per polyline, exactament 2 per line
+};
+
+// Classe Shape - representa una forma vectorial carregada des de .shp
+class Shape {
+    public:
+        // Constructors
+        Shape() = default;
+        explicit Shape(const std::string& filepath);
+
+        // Carregar forma des de fitxer .shp
+        bool carregar(const std::string& filepath);
+
+        // Getters
+        const std::vector<ShapePrimitive>& get_primitives() const {
+            return primitives_;
+        }
+        const Punt& get_centre() const { return centre_; }
+        float get_escala_defecte() const { return escala_defecte_; }
+        bool es_valida() const { return !primitives_.empty(); }
+
+        // Info de depuració
+        std::string get_nom() const { return nom_; }
+        size_t get_num_primitives() const { return primitives_.size(); }
+
+    private:
+        std::vector<ShapePrimitive> primitives_;
+        Punt centre_;           // Centre/origen de la forma
+        float escala_defecte_;  // Escala per defecte (normalment 1.0)
+        std::string nom_;       // Nom de la forma (per depuració)
+
+        // Parsejador del fitxer
+        bool parsejar_fitxer(const std::string& contingut);
+
+        // Helpers privats per parsejar
+        std::string trim(const std::string& str) const;
+        bool starts_with(const std::string& str, const std::string& prefix) const;
+        std::string extract_value(const std::string& line) const;
+        void parse_center(const std::string& value);
+        std::vector<Punt> parse_points(const std::string& str) const;
+};
+
+}  // namespace Graphics

source/core/graphics/shape_loader.cpp

@@ -0,0 +1,72 @@
+// shape_loader.cpp - Implementació del carregador amb caché
+// © 2025 Port a C++20 amb SDL3
+
+#include "core/graphics/shape_loader.hpp"
+
+#include <iostream>
+
+namespace Graphics {
+
+// Inicialització de variables estàtiques
+std::unordered_map<std::string, std::shared_ptr<Shape>> ShapeLoader::cache_;
+std::string ShapeLoader::base_path_ = "data/shapes/";
+
+std::shared_ptr<Shape> ShapeLoader::load(const std::string& filename) {
+    // Check cache first
+    auto it = cache_.find(filename);
+    if (it != cache_.end()) {
+        std::cout << "[ShapeLoader] Cache hit: " << filename << std::endl;
+        return it->second;  // Cache hit
+    }
+
+    // Resolve full path
+    std::string fullpath = resolve_path(filename);
+
+    // Create and load shape
+    auto shape = std::make_shared<Shape>();
+    if (!shape->carregar(fullpath)) {
+        std::cerr << "[ShapeLoader] Error: no s'ha pogut carregar " << filename
+                  << std::endl;
+        return nullptr;
+    }
+
+    // Verify shape is valid
+    if (!shape->es_valida()) {
+        std::cerr << "[ShapeLoader] Error: forma invàlida " << filename
+                  << std::endl;
+        return nullptr;
+    }
+
+    // Cache and return
+    std::cout << "[ShapeLoader] Carregat: " << filename << " ("
+              << shape->get_nom() << ", " << shape->get_num_primitives()
+              << " primitives)" << std::endl;
+
+    cache_[filename] = shape;
+    return shape;
+}
+
+void ShapeLoader::clear_cache() {
+    std::cout << "[ShapeLoader] Netejant caché (" << cache_.size() << " formes)"
+              << std::endl;
+    cache_.clear();
+}
+
+size_t ShapeLoader::get_cache_size() { return cache_.size(); }
+
+std::string ShapeLoader::resolve_path(const std::string& filename) {
+    // Si és un path absolut (comença amb '/'), usar-lo directament
+    if (!filename.empty() && filename[0] == '/') {
+        return filename;
+    }
+
+    // Si ja conté el prefix base_path, usar-lo directament
+    if (filename.find(base_path_) == 0) {
+        return filename;
+    }
+
+    // Altrament, afegir base_path (ara suporta subdirectoris)
+    return base_path_ + filename;
+}
+
+}  // namespace Graphics

source/core/graphics/shape_loader.hpp

@@ -0,0 +1,39 @@
+// shape_loader.hpp - Carregador estàtic de formes amb caché
+// © 2025 Port a C++20 amb SDL3
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+#include "core/graphics/shape.hpp"
+
+namespace Graphics {
+
+// Carregador estàtic de formes amb caché
+class ShapeLoader {
+    public:
+        // No instanciable (tot estàtic)
+        ShapeLoader() = delete;
+
+        // Carregar forma des de fitxer (amb caché)
+        // Retorna punter compartit (nullptr si error)
+        // Exemple: load("ship.shp") → busca a "data/shapes/ship.shp"
+        static std::shared_ptr<Shape> load(const std::string& filename);
+
+        // Netejar caché (útil per debug/recàrrega)
+        static void clear_cache();
+
+        // Estadístiques (debug)
+        static size_t get_cache_size();
+
+    private:
+        static std::unordered_map<std::string, std::shared_ptr<Shape>> cache_;
+        static std::string base_path_;  // "data/shapes/"
+
+        // Helpers privats
+        static std::string resolve_path(const std::string& filename);
+};
+
+}  // namespace Graphics

source/core/graphics/starfield.cpp

@@ -0,0 +1,163 @@
+// starfield.cpp - Implementació del sistema d'estrelles de fons
+// © 2025 Orni Attack
+
+#include "core/graphics/starfield.hpp"
+
+#include <cmath>
+#include <cstdlib>
+#include <iostream>
+
+#include "core/defaults.hpp"
+#include "core/rendering/shape_renderer.hpp"
+
+namespace Graphics {
+
+// Constructor
+Starfield::Starfield(SDL_Renderer* renderer,
+    const Punt& punt_fuga,
+    const SDL_FRect& area,
+    int densitat)
+    : renderer_(renderer)
+    , punt_fuga_(punt_fuga)
+    , area_(area)
+    , densitat_(densitat) {
+    // Carregar forma d'estrella
+    shape_estrella_ = std::make_shared<Shape>("data/shapes/star.shp");
+
+    if (!shape_estrella_->es_valida()) {
+        std::cerr << "ERROR: No s'ha pogut carregar data/shapes/star.shp" << std::endl;
+        return;
+    }
+
+    // Configurar 3 capes amb diferents velocitats i escales
+    // Capa 0: Fons llunyà (lenta, petita)
+    capes_.push_back({20.0f, 0.3f, 0.8f, densitat / 3});
+
+    // Capa 1: Profunditat mitjana
+    capes_.push_back({40.0f, 0.5f, 1.2f, densitat / 3});
+
+    // Capa 2: Primer pla (ràpida, gran)
+    capes_.push_back({80.0f, 0.8f, 2.0f, densitat / 3});
+
+    // Calcular radi màxim (distància del centre al racó més llunyà)
+    float dx = std::max(punt_fuga_.x, area_.w - punt_fuga_.x);
+    float dy = std::max(punt_fuga_.y, area_.h - punt_fuga_.y);
+    radi_max_ = std::sqrt(dx * dx + dy * dy);
+
+    // Inicialitzar estrelles amb posicions distribuïdes (pre-omplir pantalla)
+    for (int capa_idx = 0; capa_idx < 3; capa_idx++) {
+        int num = capes_[capa_idx].num_estrelles;
+        for (int i = 0; i < num; i++) {
+            Estrella estrella;
+            estrella.capa = capa_idx;
+
+            // Angle aleatori
+            estrella.angle = (static_cast<float>(rand()) / RAND_MAX) * 2.0f * Defaults::Math::PI;
+
+            // Distància aleatòria (0.0 a 1.0) per omplir tota la pantalla
+            estrella.distancia_centre = static_cast<float>(rand()) / RAND_MAX;
+
+            // Calcular posició des de la distància
+            float radi = estrella.distancia_centre * radi_max_;
+            estrella.posicio.x = punt_fuga_.x + radi * std::cos(estrella.angle);
+            estrella.posicio.y = punt_fuga_.y + radi * std::sin(estrella.angle);
+
+            estrelles_.push_back(estrella);
+        }
+    }
+}
+
+// Inicialitzar una estrella (nova o regenerada)
+void Starfield::inicialitzar_estrella(Estrella& estrella) {
+    // Angle aleatori des del punt de fuga cap a fora
+    estrella.angle = (static_cast<float>(rand()) / RAND_MAX) * 2.0f * Defaults::Math::PI;
+
+    // Distància inicial petita (5% del radi màxim) - neix prop del centre
+    estrella.distancia_centre = 0.05f;
+
+    // Posició inicial: molt prop del punt de fuga
+    float radi = estrella.distancia_centre * radi_max_;
+    estrella.posicio.x = punt_fuga_.x + radi * std::cos(estrella.angle);
+    estrella.posicio.y = punt_fuga_.y + radi * std::sin(estrella.angle);
+}
+
+// Verificar si una estrella està fora de l'àrea
+bool Starfield::fora_area(const Estrella& estrella) const {
+    return (estrella.posicio.x < area_.x ||
+            estrella.posicio.x > area_.x + area_.w ||
+            estrella.posicio.y < area_.y ||
+            estrella.posicio.y > area_.y + area_.h);
+}
+
+// Calcular escala dinàmica segons distància del centre
+float Starfield::calcular_escala(const Estrella& estrella) const {
+    const CapaConfig& capa = capes_[estrella.capa];
+
+    // Interpolació lineal basada en distància del centre
+    // distancia_centre: 0.0 (centre) → 1.0 (vora)
+    return capa.escala_min +
+           (capa.escala_max - capa.escala_min) * estrella.distancia_centre;
+}
+
+// Calcular brightness dinàmica segons distància del centre
+float Starfield::calcular_brightness(const Estrella& estrella) const {
+    // Interpolació lineal: estrelles properes (vora) més brillants
+    // distancia_centre: 0.0 (centre, llunyanes) → 1.0 (vora, properes)
+    return Defaults::Brightness::STARFIELD_MIN +
+           (Defaults::Brightness::STARFIELD_MAX - Defaults::Brightness::STARFIELD_MIN) *
+           estrella.distancia_centre;
+}
+
+// Actualitzar posicions de les estrelles
+void Starfield::actualitzar(float delta_time) {
+    for (auto& estrella : estrelles_) {
+        // Obtenir configuració de la capa
+        const CapaConfig& capa = capes_[estrella.capa];
+
+        // Moure cap a fora des del centre
+        float velocitat = capa.velocitat_base;
+        float dx = velocitat * std::cos(estrella.angle) * delta_time;
+        float dy = velocitat * std::sin(estrella.angle) * delta_time;
+
+        estrella.posicio.x += dx;
+        estrella.posicio.y += dy;
+
+        // Actualitzar distància del centre
+        float dx_centre = estrella.posicio.x - punt_fuga_.x;
+        float dy_centre = estrella.posicio.y - punt_fuga_.y;
+        float dist_px = std::sqrt(dx_centre * dx_centre + dy_centre * dy_centre);
+        estrella.distancia_centre = dist_px / radi_max_;
+
+        // Si ha sortit de l'àrea, regenerar-la
+        if (fora_area(estrella)) {
+            inicialitzar_estrella(estrella);
+        }
+    }
+}
+
+// Dibuixar totes les estrelles
+void Starfield::dibuixar() {
+    if (!shape_estrella_->es_valida()) {
+        return;
+    }
+
+    for (const auto& estrella : estrelles_) {
+        // Calcular escala i brightness dinàmicament
+        float escala = calcular_escala(estrella);
+        float brightness = calcular_brightness(estrella);
+
+        // Renderitzar estrella sense rotació
+        Rendering::render_shape(
+            renderer_,
+            shape_estrella_,
+            estrella.posicio,
+            0.0f,       // angle (les estrelles no giren)
+            escala,     // escala dinàmica
+            true,       // dibuixar
+            1.0f,       // progress (sempre visible)
+            brightness  // brightness dinàmica
+        );
+    }
+}
+
+}  // namespace Graphics

source/core/graphics/starfield.hpp

@@ -0,0 +1,80 @@
+// starfield.hpp - Sistema d'estrelles de fons amb efecte de profunditat
+// © 2025 Orni Attack
+
+#pragma once
+
+#include <SDL3/SDL.h>
+
+#include <memory>
+#include <vector>
+
+#include "core/graphics/shape.hpp"
+#include "core/types.hpp"
+
+namespace Graphics {
+
+// Configuració per cada capa de profunditat
+struct CapaConfig {
+    float velocitat_base;  // Velocitat base d'aquesta capa (px/s)
+    float escala_min;      // Escala mínima prop del centre
+    float escala_max;      // Escala màxima al límit de pantalla
+    int num_estrelles;     // Nombre d'estrelles en aquesta capa
+};
+
+// Classe Starfield - camp d'estrelles animat amb efecte de profunditat
+class Starfield {
+   public:
+    // Constructor
+    // - renderer: SDL renderer
+    // - punt_fuga: punt d'origen/fuga des d'on surten les estrelles
+    // - area: rectangle on actuen les estrelles (SDL_FRect)
+    // - densitat: nombre total d'estrelles (es divideix entre capes)
+    Starfield(SDL_Renderer* renderer,
+        const Punt& punt_fuga,
+        const SDL_FRect& area,
+        int densitat = 150);
+
+    // Actualitzar posicions de les estrelles
+    void actualitzar(float delta_time);
+
+    // Dibuixar totes les estrelles
+    void dibuixar();
+
+    // Setters per ajustar paràmetres en temps real
+    void set_punt_fuga(const Punt& punt) { punt_fuga_ = punt; }
+
+   private:
+    // Estructura interna per cada estrella
+    struct Estrella {
+        Punt posicio;            // Posició actual
+        float angle;             // Angle de moviment (radians)
+        float distancia_centre;  // Distància normalitzada del centre (0.0-1.0)
+        int capa;                // Índex de capa (0=lluny, 1=mitjà, 2=prop)
+    };
+
+    // Inicialitzar una estrella (nova o regenerada)
+    void inicialitzar_estrella(Estrella& estrella);
+
+    // Verificar si una estrella està fora de l'àrea
+    bool fora_area(const Estrella& estrella) const;
+
+    // Calcular escala dinàmica segons distància del centre
+    float calcular_escala(const Estrella& estrella) const;
+
+    // Calcular brightness dinàmica segons distància del centre
+    float calcular_brightness(const Estrella& estrella) const;
+
+    // Dades
+    std::vector<Estrella> estrelles_;
+    std::vector<CapaConfig> capes_;  // Configuració de les 3 capes
+    std::shared_ptr<Shape> shape_estrella_;
+    SDL_Renderer* renderer_;
+
+    // Configuració
+    Punt punt_fuga_;  // Punt d'origen de les estrelles
+    SDL_FRect area_;  // Àrea activa
+    float radi_max_;  // Distància màxima del centre al límit de pantalla
+    int densitat_;    // Nombre total d'estrelles
+};
+
+}  // namespace Graphics

source/core/graphics/vector_text.cpp

@@ -0,0 +1,263 @@
+// vector_text.cpp - Implementació del sistema de text vectorial
+// © 2025 Port a C++20 amb SDL3
+
+#include "core/graphics/vector_text.hpp"
+
+#include <iostream>
+
+#include "core/graphics/shape_loader.hpp"
+#include "core/rendering/shape_renderer.hpp"
+
+namespace Graphics {
+
+// Constants per a mides base dels caràcters
+constexpr float char_width = 20.0f;   // Amplada base del caràcter
+constexpr float char_height = 40.0f;  // Altura base del caràcter
+
+VectorText::VectorText(SDL_Renderer* renderer)
+    : renderer_(renderer) {
+    load_charset();
+}
+
+void VectorText::load_charset() {
+    // Cargar dígitos 0-9
+    for (char c = '0'; c <= '9'; c++) {
+        std::string filename = get_shape_filename(c);
+        auto shape = ShapeLoader::load(filename);
+
+        if (shape && shape->es_valida()) {
+            chars_[c] = shape;
+        } else {
+            std::cerr << "[VectorText] Warning: no s'ha pogut carregar " << filename
+                      << std::endl;
+        }
+    }
+
+    // Cargar lletres A-Z (majúscules)
+    for (char c = 'A'; c <= 'Z'; c++) {
+        std::string filename = get_shape_filename(c);
+        auto shape = ShapeLoader::load(filename);
+
+        if (shape && shape->es_valida()) {
+            chars_[c] = shape;
+        } else {
+            std::cerr << "[VectorText] Warning: no s'ha pogut carregar " << filename
+                      << std::endl;
+        }
+    }
+
+    // Cargar símbolos
+    const std::string symbols[] = {".", ",", "-", ":", "!", "?"};
+    for (const auto& sym : symbols) {
+        char c = sym[0];
+        std::string filename = get_shape_filename(c);
+        auto shape = ShapeLoader::load(filename);
+
+        if (shape && shape->es_valida()) {
+            chars_[c] = shape;
+        } else {
+            std::cerr << "[VectorText] Warning: no s'ha pogut carregar " << filename
+                      << std::endl;
+        }
+    }
+
+    // Cargar símbolo de copyright (©) - UTF-8 U+00A9
+    // Usem el segon byte (0xA9) com a key interna
+    {
+        char c = '\xA9';  // 169 decimal
+        std::string filename = "font/char_copyright.shp";
+        auto shape = ShapeLoader::load(filename);
+
+        if (shape && shape->es_valida()) {
+            chars_[c] = shape;
+        } else {
+            std::cerr << "[VectorText] Warning: no s'ha pogut carregar " << filename
+                      << std::endl;
+        }
+    }
+
+    std::cout << "[VectorText] Carregats " << chars_.size() << " caràcters"
+              << std::endl;
+}
+
+std::string VectorText::get_shape_filename(char c) const {
+    // Mapeo carácter → nombre de archivo (amb prefix "font/")
+    switch (c) {
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7':
+        case '8':
+        case '9':
+            return std::string("font/char_") + c + ".shp";
+
+        // Lletres majúscules A-Z
+        case 'A':
+        case 'B':
+        case 'C':
+        case 'D':
+        case 'E':
+        case 'F':
+        case 'G':
+        case 'H':
+        case 'I':
+        case 'J':
+        case 'K':
+        case 'L':
+        case 'M':
+        case 'N':
+        case 'O':
+        case 'P':
+        case 'Q':
+        case 'R':
+        case 'S':
+        case 'T':
+        case 'U':
+        case 'V':
+        case 'W':
+        case 'X':
+        case 'Y':
+        case 'Z':
+            return std::string("font/char_") + c + ".shp";
+
+        // Lletres minúscules a-z (convertir a majúscules)
+        case 'a':
+        case 'b':
+        case 'c':
+        case 'd':
+        case 'e':
+        case 'f':
+        case 'g':
+        case 'h':
+        case 'i':
+        case 'j':
+        case 'k':
+        case 'l':
+        case 'm':
+        case 'n':
+        case 'o':
+        case 'p':
+        case 'q':
+        case 'r':
+        case 's':
+        case 't':
+        case 'u':
+        case 'v':
+        case 'w':
+        case 'x':
+        case 'y':
+        case 'z':
+            return std::string("font/char_") + char(c - 32) + ".shp";
+
+        // Símbols
+        case '.':
+            return "font/char_dot.shp";
+        case ',':
+            return "font/char_comma.shp";
+        case '-':
+            return "font/char_minus.shp";
+        case ':':
+            return "font/char_colon.shp";
+        case '!':
+            return "font/char_exclamation.shp";
+        case '?':
+            return "font/char_question.shp";
+        case ' ':
+            return "";  // Espai es maneja sense carregar shape
+
+        case '\xA9':  // Copyright symbol (©) - UTF-8 U+00A9
+            return "font/char_copyright.shp";
+
+        default:
+            return "";  // Caràcter no suportat
+    }
+}
+
+bool VectorText::is_supported(char c) const {
+    return chars_.find(c) != chars_.end();
+}
+
+void VectorText::render(const std::string& text, const Punt& posicio, float escala, float spacing) {
+    if (!renderer_) {
+        return;
+    }
+
+    // Ancho de un carácter base (20 px a escala 1.0)
+    const float char_width_scaled = char_width * escala;
+
+    // Spacing escalado
+    const float spacing_scaled = spacing * escala;
+
+    // Altura de un carácter escalado (necesario para ajustar Y)
+    const float char_height_scaled = char_height * escala;
+
+    // Posición actual del centro del carácter (ajustada desde esquina superior
+    // izquierda)
+    float current_x = posicio.x;
+
+    // Iterar sobre cada byte del string (con detecció UTF-8)
+    for (size_t i = 0; i < text.length(); i++) {
+        unsigned char c = static_cast<unsigned char>(text[i]);
+
+        // Detectar copyright UTF-8 (0xC2 0xA9)
+        if (c == 0xC2 && i + 1 < text.length() &&
+            static_cast<unsigned char>(text[i + 1]) == 0xA9) {
+            c = 0xA9;  // Usar segon byte com a key
+            i++;       // Saltar el següent byte
+        }
+
+        // Manejar espacios (avanzar sin dibujar)
+        if (c == ' ') {
+            current_x += char_width_scaled + spacing_scaled;
+            continue;
+        }
+
+        // Verificar si el carácter está soportado
+        auto it = chars_.find(c);
+        if (it != chars_.end()) {
+            // Renderizar carácter
+            // Ajustar Y para que posicio represente esquina superior izquierda
+            // (render_shape espera el centro, así que sumamos la mitad de la altura)
+            Punt char_pos = {current_x, posicio.y + char_height_scaled / 2.0f};
+            Rendering::render_shape(renderer_, it->second, char_pos, 0.0f, escala, true);
+
+            // Avanzar posición
+            current_x += char_width_scaled + spacing_scaled;
+        } else {
+            // Carácter no soportado: saltar (o renderizar '?' en el futuro)
+            std::cerr << "[VectorText] Warning: caràcter no suportat '" << c << "'"
+                      << std::endl;
+            current_x += char_width_scaled + spacing_scaled;
+        }
+    }
+}
+
+float VectorText::get_text_width(const std::string& text, float escala, float spacing) const {
+    if (text.empty()) {
+        return 0.0f;
+    }
+
+    const float char_width_scaled = char_width * escala;
+    const float spacing_scaled = spacing * escala;
+
+    // Ancho total = (número de caracteres × char_width) + (espacios entre
+    // caracteres)
+    float width = text.length() * char_width_scaled;
+
+    // Añadir spacing entre caracteres (n-1 espacios para n caracteres)
+    if (text.length() > 1) {
+        width += (text.length() - 1) * spacing_scaled;
+    }
+
+    return width;
+}
+
+float VectorText::get_text_height(float escala) const {
+    return char_height * escala;
+}
+
+}  // namespace Graphics

source/core/graphics/vector_text.hpp

@@ -0,0 +1,46 @@
+// vector_text.hpp - Sistema de texto vectorial con display de 7-segmentos
+// © 2025 Port a C++20 amb SDL3
+
+#pragma once
+
+#include <SDL3/SDL.h>
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+#include "core/graphics/shape.hpp"
+#include "core/types.hpp"
+
+namespace Graphics {
+
+class VectorText {
+    public:
+        VectorText(SDL_Renderer* renderer);
+
+        // Renderizar string completo
+        // - text: cadena a renderizar (soporta: A-Z, a-z, 0-9, '.', ',', '-', ':',
+        // '!', '?', ' ')
+        // - posicio: posición inicial (esquina superior izquierda)
+        // - escala: factor de escala (1.0 = 20×40 px por carácter)
+        // - spacing: espacio entre caracteres en píxeles (a escala 1.0)
+        void render(const std::string& text, const Punt& posicio, float escala = 1.0f, float spacing = 2.0f);
+
+        // Calcular ancho total de un string (útil para centrado)
+        float get_text_width(const std::string& text, float escala = 1.0f, float spacing = 2.0f) const;
+
+        // Calcular altura del texto (útil para centrado vertical)
+        float get_text_height(float escala = 1.0f) const;
+
+        // Verificar si un carácter está soportado
+        bool is_supported(char c) const;
+
+    private:
+        SDL_Renderer* renderer_;
+        std::unordered_map<char, std::shared_ptr<Shape>> chars_;
+
+        void load_charset();
+        std::string get_shape_filename(char c) const;
+};
+
+}  // namespace Graphics

source/core/input/mouse.cpp

@@ -0,0 +1,63 @@
+#include "core/input/mouse.hpp"
+
+namespace Mouse {
+Uint32 cursor_hide_time = 3000;   // Tiempo en milisegundos para ocultar el cursor
+Uint32 last_mouse_move_time = 0;  // Última vez que el ratón se movió
+bool cursor_visible = true;       // Estado del cursor
+
+// Modo forzado: Usado cuando SDLManager entra en pantalla completa.
+// Cuando está activado, el cursor permanece oculto independientemente del movimiento del ratón.
+// SDLManager controla esto mediante llamadas a setForceHidden().
+bool force_hidden = false;
+
+void setForceHidden(bool force) {
+    force_hidden = force;
+
+    if (force) {
+        // Entrando en modo oculto forzado: ocultar cursor inmediatamente
+        if (cursor_visible) {
+            SDL_HideCursor();
+            cursor_visible = false;
+        }
+    } else {
+        // Saliendo de modo oculto forzado: mostrar cursor y resetear temporizador
+        SDL_ShowCursor();
+        cursor_visible = true;
+        last_mouse_move_time = SDL_GetTicks();  // Resetear temporizador
+    }
+}
+
+bool isForceHidden() {
+    return force_hidden;
+}
+
+void handleEvent(const SDL_Event& event) {
+    // CRÍTICO: Si estamos en modo forzado, ignorar todos los eventos del ratón
+    if (force_hidden) {
+        return;  // Salir temprano - no procesar ningún evento
+    }
+
+    // MODO NORMAL: Mostrar cursor al mover el ratón
+    if (event.type == SDL_EVENT_MOUSE_MOTION) {
+        last_mouse_move_time = SDL_GetTicks();
+        if (!cursor_visible) {
+            SDL_ShowCursor();
+            cursor_visible = true;
+        }
+    }
+}
+
+void updateCursorVisibility() {
+    // CRÍTICO: Si estamos en modo forzado, no aplicar lógica de timeout
+    if (force_hidden) {
+        return;  // Salir temprano - el cursor permanece oculto
+    }
+
+    // MODO NORMAL: Auto-ocultar basado en timeout
+    Uint32 current_time = SDL_GetTicks();
+    if (cursor_visible && (current_time - last_mouse_move_time > cursor_hide_time)) {
+        SDL_HideCursor();
+        cursor_visible = false;
+    }
+}
+}  // namespace Mouse

source/core/input/mouse.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <SDL3/SDL.h>
+
+namespace Mouse {
+extern Uint32 cursor_hide_time;      // Tiempo en milisegundos para ocultar el cursor
+extern Uint32 last_mouse_move_time;  // Última vez que el ratón se movió
+extern bool cursor_visible;          // Estado del cursor
+
+void handleEvent(const SDL_Event& event);
+void updateCursorVisibility();
+
+// Control de visibilidad forzada (para modo pantalla completa)
+void setForceHidden(bool force);  // Activar/desactivar ocultación forzada
+bool isForceHidden();             // Consultar estado actual
+}  // namespace Mouse

source/core/rendering/color_oscillator.cpp

@@ -0,0 +1,68 @@
+// color_oscillator.cpp - Implementació d'oscil·lació de color
+// © 2025 Port a C++20 amb SDL3
+
+#include "core/rendering/color_oscillator.hpp"
+
+#include <cmath>
+
+#include "core/defaults.hpp"
+
+namespace Rendering {
+
+ColorOscillator::ColorOscillator()
+    : accumulated_time_(0.0f) {
+    // Inicialitzar amb el color mínim
+    current_line_color_ = {Defaults::Color::LINE_MIN_R,
+        Defaults::Color::LINE_MIN_G,
+        Defaults::Color::LINE_MIN_B,
+        255};
+    current_background_color_ = {Defaults::Color::BACKGROUND_MIN_R,
+        Defaults::Color::BACKGROUND_MIN_G,
+        Defaults::Color::BACKGROUND_MIN_B,
+        255};
+}
+
+void ColorOscillator::update(float delta_time) {
+    accumulated_time_ += delta_time;
+
+    float factor =
+        calculateOscillationFactor(accumulated_time_, Defaults::Color::FREQUENCY);
+
+    // Interpolar colors de línies
+    SDL_Color line_min = {Defaults::Color::LINE_MIN_R,
+        Defaults::Color::LINE_MIN_G,
+        Defaults::Color::LINE_MIN_B,
+        255};
+    SDL_Color line_max = {Defaults::Color::LINE_MAX_R,
+        Defaults::Color::LINE_MAX_G,
+        Defaults::Color::LINE_MAX_B,
+        255};
+    current_line_color_ = interpolateColor(line_min, line_max, factor);
+
+    // Interpolar colors de fons
+    SDL_Color bg_min = {Defaults::Color::BACKGROUND_MIN_R,
+        Defaults::Color::BACKGROUND_MIN_G,
+        Defaults::Color::BACKGROUND_MIN_B,
+        255};
+    SDL_Color bg_max = {Defaults::Color::BACKGROUND_MAX_R,
+        Defaults::Color::BACKGROUND_MAX_G,
+        Defaults::Color::BACKGROUND_MAX_B,
+        255};
+    current_background_color_ = interpolateColor(bg_min, bg_max, factor);
+}
+
+float ColorOscillator::calculateOscillationFactor(float time, float frequency) {
+    // Oscil·lació senoïdal: sin(t * freq * 2π)
+    // Mapejar de [-1, 1] a [0, 1]
+    float radians = time * frequency * 2.0f * Defaults::Math::PI;
+    return (std::sin(radians) + 1.0f) / 2.0f;
+}
+
+SDL_Color ColorOscillator::interpolateColor(SDL_Color min, SDL_Color max, float factor) {
+    return {static_cast<uint8_t>(min.r + (max.r - min.r) * factor),
+        static_cast<uint8_t>(min.g + (max.g - min.g) * factor),
+        static_cast<uint8_t>(min.b + (max.b - min.b) * factor),
+        255};
+}
+
+}  // namespace Rendering

source/core/rendering/color_oscillator.hpp

@@ -0,0 +1,29 @@
+// color_oscillator.hpp - Sistema d'oscil·lació de color per efecte CRT
+// © 2025 Port a C++20 amb SDL3
+
+#pragma once
+#include <SDL3/SDL.h>
+
+namespace Rendering {
+
+class ColorOscillator {
+    public:
+        ColorOscillator();
+
+        void update(float delta_time);
+
+        SDL_Color getCurrentLineColor() const { return current_line_color_; }
+        SDL_Color getCurrentBackgroundColor() const {
+            return current_background_color_;
+        }
+
+    private:
+        float accumulated_time_;
+        SDL_Color current_line_color_;
+        SDL_Color current_background_color_;
+
+        static float calculateOscillationFactor(float time, float frequency);
+        static SDL_Color interpolateColor(SDL_Color min, SDL_Color max, float factor);
+};
+
+}  // namespace Rendering

source/core/rendering/coordinate_transform.cpp

@@ -0,0 +1,11 @@
+// coordinate_transform.cpp - Inicialització de variables globals
+// © 2025 Port a C++20 amb SDL3
+
+#include "core/rendering/coordinate_transform.hpp"
+
+namespace Rendering {
+
+// Factor d'escala global (inicialitzat a 1.0 per defecte)
+float g_current_scale_factor = 1.0f;
+
+}  // namespace Rendering

source/core/rendering/coordinate_transform.hpp

@@ -0,0 +1,31 @@
+// coordinate_transform.hpp - Transformació de coordenades lògiques a físiques
+// © 2025 Port a C++20 amb SDL3
+
+#pragma once
+
+#include <cmath>
+
+namespace Rendering {
+
+// Factor d'escala global (actualitzat cada frame per SDLManager)
+extern float g_current_scale_factor;
+
+// Transforma coordenada lògica a física amb arrodoniment
+inline int transform_x(int logical_x, float scale) {
+    return static_cast<int>(std::round(logical_x * scale));
+}
+
+inline int transform_y(int logical_y, float scale) {
+    return static_cast<int>(std::round(logical_y * scale));
+}
+
+// Variant que usa el factor d'escala global
+inline int transform_x(int logical_x) {
+    return transform_x(logical_x, g_current_scale_factor);
+}
+
+inline int transform_y(int logical_y) {
+    return transform_y(logical_y, g_current_scale_factor);
+}
+
+}  // namespace Rendering

source/core/rendering/line_renderer.cpp

@@ -0,0 +1,101 @@
+// line_renderer.cpp - Implementació de renderitzat de línies
+// © 1999 Visente i Sergi (versió Pascal)
+// © 2025 Port a C++20 amb SDL3
+
+#include "core/rendering/line_renderer.hpp"
+
+#include <cmath>
+
+#include "core/rendering/coordinate_transform.hpp"
+
+namespace Rendering {
+
+// [NUEVO] Color global compartit (actualitzat per ColorOscillator via
+// SDLManager)
+SDL_Color g_current_line_color = {255, 255, 255, 255};  // Blanc inicial
+
+bool linea(SDL_Renderer* renderer, int x1, int y1, int x2, int y2, bool dibuixar, float brightness) {
+    // Algorisme de Bresenham per dibuixar línies
+    // Basat en el codi Pascal original
+
+    // Helper function: retorna el signe d'un nombre
+    auto sign = [](int x) -> int {
+        if (x < 0)
+            return -1;
+        if (x > 0)
+            return 1;
+        return 0;
+    };
+
+    // Variables per a l'algorisme (no utilitzades fins Fase 10 - detecció de
+    // col·lisions) int x = x1, y = y1; int xs = x2 - x1; int ys = y2 - y1; int
+    // xm = sign(xs); int ym = sign(ys); xs = std::abs(xs); ys = std::abs(ys);
+
+    // Suprimir warning de variable no usada
+    (void)sign;
+
+    // Detecció de col·lisió (TODO per Fase 10)
+    // El codi Pascal original llegia pixels del framebuffer bit-packed
+    // i comptava col·lisions. Per ara, usem SDL_RenderDrawLine i retornem false.
+    bool colisio = false;
+
+    // Dibuixar amb SDL3 (més eficient que Bresenham píxel a píxel)
+    if (dibuixar && renderer) {
+        // Transformar coordenades lògiques (640x480) a físiques (resolució real)
+        float scale = g_current_scale_factor;
+        int px1 = transform_x(x1, scale);
+        int py1 = transform_y(y1, scale);
+        int px2 = transform_x(x2, scale);
+        int py2 = transform_y(y2, scale);
+
+        // Aplicar brightness al color oscil·lat global
+        SDL_Color color_final;
+        color_final.r = static_cast<uint8_t>(g_current_line_color.r * brightness);
+        color_final.g = static_cast<uint8_t>(g_current_line_color.g * brightness);
+        color_final.b = static_cast<uint8_t>(g_current_line_color.b * brightness);
+        color_final.a = 255;
+
+        SDL_SetRenderDrawColor(renderer, color_final.r, color_final.g, color_final.b, 255);
+
+        // Renderitzar amb coordenades físiques
+        SDL_RenderLine(renderer, static_cast<float>(px1), static_cast<float>(py1),
+                              static_cast<float>(px2), static_cast<float>(py2));
+    }
+
+    // Algorisme de Bresenham original (conservat per a futura detecció de
+    // col·lisió)
+    /*
+    if (xs > ys) {
+        // Línia plana (<45 graus)
+        int count = -(xs / 2);
+        while (x != x2) {
+            count = count + ys;
+            x = x + xm;
+            if (count > 0) {
+                y = y + ym;
+                count = count - xs;
+            }
+            // Aquí aniria la detecció de col·lisió píxel a píxel
+        }
+    } else {
+        // Línia pronunciada (>=45 graus)
+        int count = -(ys / 2);
+        while (y != y2) {
+            count = count + xs;
+            y = y + ym;
+            if (count > 0) {
+                x = x + xm;
+                count = count - ys;
+            }
+            // Aquí aniria la detecció de col·lisió píxel a píxel
+        }
+    }
+    */
+
+    return colisio;
+}
+
+// [NUEVO] Establir el color global de les línies
+void setLineColor(SDL_Color color) { g_current_line_color = color; }
+
+}  // namespace Rendering

source/core/rendering/line_renderer.hpp

@@ -0,0 +1,16 @@
+// line_renderer.hpp - Renderitzat de línies
+// © 1999 Visente i Sergi (versió Pascal)
+// © 2025 Port a C++20 amb SDL3
+
+#pragma once
+#include <SDL3/SDL.h>
+
+namespace Rendering {
+// Algorisme de Bresenham per dibuixar línies
+// Retorna true si hi ha col·lisió (per Fase 10)
+// brightness: factor de brillantor (0.0-1.0, default 1.0 = màxima brillantor)
+bool linea(SDL_Renderer* renderer, int x1, int y1, int x2, int y2, bool dibuixar, float brightness = 1.0f);
+
+// [NUEVO] Establir el color global de les línies (oscil·lació)
+void setLineColor(SDL_Color color);
+}  // namespace Rendering

source/core/rendering/polygon_renderer.cpp

@@ -0,0 +1,86 @@
+// polygon_renderer.cpp - Implementació de renderitzat de polígons
+// © 1999 Visente i Sergi (versió Pascal)
+// © 2025 Port a C++20 amb SDL3
+//
+// ==============================================================================
+// DEPRECATED: Use core/rendering/shape_renderer.cpp instead
+// ==============================================================================
+
+#include "core/rendering/polygon_renderer.hpp"
+
+#include <array>
+#include <cmath>
+
+#include "core/defaults.hpp"
+#include "core/rendering/line_renderer.hpp"
+
+namespace Rendering {
+
+void rota_tri(SDL_Renderer* renderer, const Triangle& tri, float angul, float velocitat, bool dibuixar) {
+    // Rotar i dibuixar triangle (nau)
+    // Conversió de coordenades polars a cartesianes amb rotació
+    // Basat en el codi Pascal original: lines 271-284
+
+    // Convertir cada punt polar a cartesià
+    // x = (r + velocitat) * cos(angle_punt + angle_nau) + centre.x
+    // y = (r + velocitat) * sin(angle_punt + angle_nau) + centre.y
+
+    int x1 = static_cast<int>(std::round((tri.p1.r + velocitat) *
+                 std::cos(tri.p1.angle + angul))) +
+        tri.centre.x;
+
+    int y1 = static_cast<int>(std::round((tri.p1.r + velocitat) *
+                 std::sin(tri.p1.angle + angul))) +
+        tri.centre.y;
+
+    int x2 = static_cast<int>(std::round((tri.p2.r + velocitat) *
+                 std::cos(tri.p2.angle + angul))) +
+        tri.centre.x;
+
+    int y2 = static_cast<int>(std::round((tri.p2.r + velocitat) *
+                 std::sin(tri.p2.angle + angul))) +
+        tri.centre.y;
+
+    int x3 = static_cast<int>(std::round((tri.p3.r + velocitat) *
+                 std::cos(tri.p3.angle + angul))) +
+        tri.centre.x;
+
+    int y3 = static_cast<int>(std::round((tri.p3.r + velocitat) *
+                 std::sin(tri.p3.angle + angul))) +
+        tri.centre.y;
+
+    // Dibuixar les 3 línies que formen el triangle
+    linea(renderer, x1, y1, x2, y2, dibuixar);
+    linea(renderer, x1, y1, x3, y3, dibuixar);
+    linea(renderer, x3, y3, x2, y2, dibuixar);
+}
+
+void rota_pol(SDL_Renderer* renderer, const Poligon& pol, float angul, bool dibuixar) {
+    // Rotar i dibuixar polígon (enemics i bales)
+    // Conversió de coordenades polars a cartesianes amb rotació
+    // Basat en el codi Pascal original: lines 286-296
+
+    // Array temporal per emmagatzemar punts convertits a cartesianes
+    std::array<Punt, Defaults::Entities::MAX_IPUNTS> xy;
+
+    // Convertir cada punt polar a cartesià
+    for (uint8_t i = 0; i < pol.n; i++) {
+        xy[i].x = static_cast<int>(std::round(
+                      pol.ipuntx[i].r * std::cos(pol.ipuntx[i].angle + angul))) +
+            pol.centre.x;
+
+        xy[i].y = static_cast<int>(std::round(
+                      pol.ipuntx[i].r * std::sin(pol.ipuntx[i].angle + angul))) +
+            pol.centre.y;
+    }
+
+    // Dibuixar línies entre punts consecutius
+    for (uint8_t i = 0; i < pol.n - 1; i++) {
+        linea(renderer, xy[i].x, xy[i].y, xy[i + 1].x, xy[i + 1].y, dibuixar);
+    }
+
+    // Tancar el polígon (últim punt → primer punt)
+    linea(renderer, xy[pol.n - 1].x, xy[pol.n - 1].y, xy[0].x, xy[0].y, dibuixar);
+}
+
+}  // namespace Rendering

source/core/rendering/polygon_renderer.hpp

@@ -0,0 +1,22 @@
+// polygon_renderer.hpp - Renderitzat de polígons polars
+// © 1999 Visente i Sergi (versió Pascal)
+// © 2025 Port a C++20 amb SDL3
+//
+// ==============================================================================
+// DEPRECATED: Use core/rendering/shape_renderer.hpp instead
+// ==============================================================================
+// This file is kept temporarily for chatarra_cosmica_ (Phase 10: explosions)
+// TODO Phase 10: Replace with particle system or remove completely
+
+#pragma once
+#include <SDL3/SDL.h>
+
+#include "core/types.hpp"
+
+namespace Rendering {
+// Rotar i dibuixar triangle (nau)
+void rota_tri(SDL_Renderer* renderer, const Triangle& tri, float angul, float velocitat, bool dibuixar);
+
+// Rotar i dibuixar polígon (enemics i bales)
+void rota_pol(SDL_Renderer* renderer, const Poligon& pol, float angul, bool dibuixar);
+}  // namespace Rendering

source/core/rendering/primitives.cpp

@@ -0,0 +1,66 @@
+// primitives.cpp - Implementació de funcions geomètriques
+// © 1999 Visente i Sergi (versió Pascal)
+// © 2025 Port a C++20 amb SDL3
+//
+// ==============================================================================
+// DEPRECATED: Use Shape system instead (.shp files + ShapeLoader)
+// ==============================================================================
+
+#include "primitives.hpp"
+
+#include <cmath>
+
+#include "core/defaults.hpp"
+
+float modul(const Punt& p) {
+    // Càlcul de la magnitud d'un vector: sqrt(x² + y²)
+    return std::sqrt(p.x * p.x + p.y * p.y);
+}
+
+void diferencia(const Punt& o, const Punt& d, Punt& p) {
+    // Resta de vectors (origen - destí)
+    p.x = o.x - d.x;
+    p.y = o.y - d.y;
+}
+
+int distancia(const Punt& o, const Punt& d) {
+    // Distància entre dos punts
+    Punt p;
+    diferencia(o, d, p);
+    return static_cast<int>(std::round(modul(p)));
+}
+
+float angle_punt(const Punt& p) {
+    // Càlcul de l'angle d'un punt (arctan)
+    if (p.y != 0) {
+        return std::atan(p.x / p.y);
+    }
+    return 0.0f;
+}
+
+void crear_poligon_regular(Poligon& pol, uint8_t n, float r) {
+    // Crear un polígon regular amb n costats i radi r
+    // Distribueix els punts uniformement al voltant d'un cercle
+
+    float interval = 2.0f * Defaults::Math::PI / n;
+    float act = 0.0f;
+
+    for (uint8_t i = 0; i < n; i++) {
+        pol.ipuntx[i].r = r;
+        pol.ipuntx[i].angle = act;
+        act += interval;
+    }
+
+    // Inicialitzar propietats del polígon
+    pol.centre.x = 320.0f;
+    pol.centre.y = 200.0f;
+    pol.angle = 0.0f;
+    // Convertir velocitat de px/frame a px/s: 2 px/frame × 20 FPS = 40 px/s
+    pol.velocitat = Defaults::Physics::ENEMY_SPEED * 20.0f;
+    pol.n = n;
+    // Convertir rotació de rad/frame a rad/s: 0.0785 rad/frame × 20 FPS = 1.57
+    // rad/s (~90°/s)
+    pol.drotacio = 0.078539816f * 20.0f;
+    pol.rotacio = 0.0f;
+    pol.esta = true;
+}

source/core/rendering/primitives.hpp

@@ -0,0 +1,32 @@
+// primitives.hpp - Funcions geomètriques bàsiques
+// © 1999 Visente i Sergi (versió Pascal)
+// © 2025 Port a C++20 amb SDL3
+//
+// ==============================================================================
+// DEPRECATED: Use Shape system instead (.shp files + ShapeLoader)
+// ==============================================================================
+// This file is kept temporarily for chatarra_cosmica_ (Phase 10: explosions)
+// TODO Phase 10: Replace with particle system or remove completely
+
+#pragma once
+
+#include <cstdint>
+
+#include "core/types.hpp"
+
+// Funcions matemàtiques geomètriques pures (sense dependències d'estat)
+
+// Càlcul de la magnitud d'un vector
+float modul(const Punt& p);
+
+// Diferència entre dos punts (vector origen - destí)
+void diferencia(const Punt& o, const Punt& d, Punt& p);
+
+// Distància entre dos punts
+int distancia(const Punt& o, const Punt& d);
+
+// Càlcul de l'angle d'un punt
+float angle_punt(const Punt& p);
+
+// Creació de polígons regulars
+void crear_poligon_regular(Poligon& pol, uint8_t n, float r);

source/core/rendering/sdl_manager.cpp

@@ -2,302 +2,466 @@
 // © 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/input/mouse.hpp"
+#include "core/rendering/coordinate_transform.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;
+      zoom_factor_(Defaults::Window::BASE_ZOOM),
-    return;
+      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;
+        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),
-      max_height_(1080) {
+      fps_accumulator_(0.0f),
-  // Inicialitzar SDL3
+      fps_frame_count_(0),
-  if (!SDL_Init(SDL_INIT_VIDEO)) {
+      fps_display_(0),
-    std::cerr << "Error inicialitzant SDL3: " << SDL_GetError() << std::endl;
+      current_width_(width),
-    return;
+      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;
+        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;
+
+    // Inicialitzar mòdul Mouse amb l'estat actual de fullscreen
+    Mouse::setForceHidden(is_fullscreen_);
 }
 
 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;
-  }
+    }
+
+    // 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 viewport for new zoom
+    updateViewport();
+
+    // 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() {
-  // AIXÒ ÉS LA MÀGIA: El joc SEMPRE dibuixa en 640x480,
+    // CANVIAT: Ja no usem SDL_SetRenderLogicalPresentation
-  // SDL escala automàticament a la mida física de la finestra
+    // Ara renderitzem directament a resolució física per evitar pixelació irregular
-  SDL_SetRenderLogicalPresentation(
+    // El viewport amb letterbox es configura a updateViewport()
-      renderer_,
+    updateViewport();
-      Defaults::Game::WIDTH,             // 640 (lògic)
+}
-      Defaults::Game::HEIGHT,            // 480 (lògic)
+
-      SDL_LOGICAL_PRESENTATION_LETTERBOX // Mantenir aspect ratio 4:3
+void SDLManager::updateViewport() {
-  );
+    // Calcular dimensions físiques basades en el zoom
+    float scale = zoom_factor_;
+    int scaled_width = static_cast<int>(std::round(Defaults::Game::WIDTH * scale));
+    int scaled_height = static_cast<int>(std::round(Defaults::Game::HEIGHT * scale));
+
+    // Càlcul de letterbox (centrar l'àrea escalada)
+    int offset_x = (current_width_ - scaled_width) / 2;
+    int offset_y = (current_height_ - scaled_height) / 2;
+
+    // Evitar offsets negatius
+    offset_x = std::max(offset_x, 0);
+    offset_y = std::max(offset_y, 0);
+
+    // Configurar viewport per al renderitzat
+    SDL_Rect viewport = {offset_x, offset_y, scaled_width, scaled_height};
+    SDL_SetRenderViewport(renderer_, &viewport);
+
+    std::cout << "Viewport: " << scaled_width << "x" << scaled_height
+              << " @ (" << offset_x << "," << offset_y << ") [scale=" << scale << "]"
+              << std::endl;
+}
+
+void SDLManager::updateRenderingContext() {
+    // Actualitzar el factor d'escala global per a totes les funcions de renderitzat
+    Rendering::g_current_scale_factor = zoom_factor_;
 }
 
 void SDLManager::increaseWindowSize() {
-  if (is_fullscreen_)
+    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_)
+    if (is_fullscreen_)
-    return;
+        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) {
-  // 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í,
+    // Actualitzar viewport després del resize
-  // SDL ho maneja automàticament
+    updateViewport();
 }
 
 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_;
 
-  // Persistir canvis a Options (es guardarà a config.yaml al tancar)
+        is_fullscreen_ = true;
-  Options::window.fullscreen = is_fullscreen_;
+        SDL_SetWindowFullscreen(finestra_, true);
 
-  std::cout << "F3: Fullscreen " << (is_fullscreen_ ? "activat" : "desactivat")
+        std::cout << "F3: Fullscreen activat (guardada: "
-            << std::endl;
+                  << windowed_width_ << "x" << windowed_height_ << ")" << std::endl;
+    } else {
+        // EXITING FULLSCREEN
+        is_fullscreen_ = false;
+        SDL_SetWindowFullscreen(finestra_, false);
 
-  // En fullscreen, SDL gestiona tot automàticament
+        // CRITICAL: Explicitly restore windowed size
-  // En sortir, restaura la mida anterior
+        applyWindowSize(windowed_width_, windowed_height_);
+
+        std::cout << "F3: Fullscreen desactivat (restaurada: "
+                  << windowed_width_ << "x" << windowed_height_ << ")" << std::endl;
+    }
+
+    Options::window.fullscreen = is_fullscreen_;
+
+    // Notificar al mòdul Mouse: Fullscreen requereix ocultació permanent del cursor.
+    // Quan es surt de fullscreen, restaurar el comportament normal d'auto-ocultació.
+    Mouse::setForceHidden(is_fullscreen_);
 }
 
-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)
+        SDL_GetWindowSize(finestra_, &current_width_, &current_height_);
-    // Actualitzar el nostre tracking
+
-    SDL_GetWindowSize(finestra_, &current_width_, &current_height_);
+        // Calculate zoom from actual size (may not align to 0.1 increments)
-    std::cout << "Finestra redimensionada manualment a " << current_width_
+        float new_zoom = static_cast<float>(current_width_) / Defaults::Window::WIDTH;
-              << "x" << current_height_ << std::endl;
+        zoom_factor_ = std::max(Defaults::Window::MIN_ZOOM,
-    return true;
+            std::min(new_zoom, max_zoom_));
-  }
+
-  return false;
+        // Update windowed cache (if not in fullscreen)
+        if (!is_fullscreen_) {
+            windowed_width_ = current_width_;
+            windowed_height_ = current_height_;
+        }
+
+        // Actualitzar viewport després del resize manual
+        updateViewport();
+
+        std::cout << "Finestra redimensionada: " << current_width_
+                  << "x" << current_height_ << " (zoom ≈" << zoom_factor_ << "x)"
+                  << std::endl;
+        return true;
+    }
+    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,83 @@
 #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_;
+        float getScaleFactor() const { return zoom_factor_; }
 
-  // [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
+        // [NUEVO] Actualitzar context de renderitzat (factor d'escala global)
-  void calculateMaxWindowSize();               // Llegir resolució del display
+        void updateRenderingContext();
-  void applyWindowSize(int width, int height); // Canviar mida + centrar
-  void updateLogicalPresentation();            // Actualitzar viewport
 
-  // [NUEVO] Oscil·lador de colors
+    private:
-  Rendering::ColorOscillator color_oscillator_;
+        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_;
+        bool is_fullscreen_;
+        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
+        void updateViewport();                        // Configurar viewport amb letterbox
+
+        // [NUEVO] Oscil·lador de colors
+        Rendering::ColorOscillator color_oscillator_;
 };
 
-#endif // SDL_MANAGER_HPP
+#endif  // SDL_MANAGER_HPP

source/core/rendering/shape_renderer.cpp

@@ -0,0 +1,80 @@
+// shape_renderer.cpp - Implementació del renderitzat de formes
+// © 2025 Port a C++20 amb SDL3
+
+#include "core/rendering/shape_renderer.hpp"
+
+#include <cmath>
+
+#include "core/defaults.hpp"
+#include "core/rendering/line_renderer.hpp"
+
+namespace Rendering {
+
+// Helper: transformar un punt amb rotació, escala i trasllació
+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ó
+    // IMPORTANT: En el sistema original, angle=0 apunta AMUNT (no dreta)
+    // Per això usem (angle - PI/2) per compensar
+    // Però aquí angle ja ve en el sistema correcte del joc
+    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};
+}
+
+void render_shape(SDL_Renderer* renderer,
+    const std::shared_ptr<Graphics::Shape>& shape,
+    const Punt& posicio,
+    float angle,
+    float escala,
+    bool dibuixar,
+    float progress,
+    float brightness) {
+    // Verificar que la forma és vàlida
+    if (!shape || !shape->es_valida()) {
+        return;
+    }
+
+    // Si progress < 1.0, no dibuixar (tot o res)
+    if (progress < 1.0f) {
+        return;
+    }
+
+    // Obtenir el centre de la forma per a transformacions
+    const Punt& shape_centre = shape->get_centre();
+
+    // Iterar sobre totes les primitives
+    for (const auto& primitive : shape->get_primitives()) {
+        if (primitive.type == Graphics::PrimitiveType::POLYLINE) {
+            // POLYLINE: connectar punts consecutius
+            for (size_t i = 0; i < primitive.points.size() - 1; i++) {
+                Punt p1 = transform_point(primitive.points[i], shape_centre, posicio, angle, escala);
+                Punt p2 = transform_point(primitive.points[i + 1], shape_centre, posicio, angle, escala);
+
+                linea(renderer, static_cast<int>(p1.x), static_cast<int>(p1.y), static_cast<int>(p2.x), static_cast<int>(p2.y), dibuixar, brightness);
+            }
+        } else {  // PrimitiveType::LINE
+            // LINE: exactament 2 punts
+            if (primitive.points.size() >= 2) {
+                Punt p1 = transform_point(primitive.points[0], shape_centre, posicio, angle, escala);
+                Punt p2 = transform_point(primitive.points[1], shape_centre, posicio, angle, escala);
+
+                linea(renderer, static_cast<int>(p1.x), static_cast<int>(p1.y), static_cast<int>(p2.x), static_cast<int>(p2.y), dibuixar, brightness);
+            }
+        }
+    }
+}
+
+}  // namespace Rendering

source/core/rendering/shape_renderer.hpp

@@ -0,0 +1,33 @@
+// shape_renderer.hpp - Renderitzat de formes vectorials
+// © 2025 Port a C++20 amb SDL3
+
+#pragma once
+
+#include <SDL3/SDL.h>
+
+#include <memory>
+
+#include "core/graphics/shape.hpp"
+#include "core/types.hpp"
+
+namespace Rendering {
+
+// Renderitzar forma amb transformacions
+// - renderer: SDL renderer
+// - shape: forma vectorial a dibuixar
+// - posicio: posició del centre en coordenades mundials
+// - angle: rotació en radians (0 = amunt, sentit horari)
+// - escala: factor d'escala (1.0 = mida original)
+// - dibuixar: flag per dibuixar (false per col·lisions futures)
+// - progress: progrés de l'animació (0.0-1.0, default 1.0 = tot visible)
+// - brightness: factor de brillantor (0.0-1.0, default 1.0 = màxima brillantor)
+void render_shape(SDL_Renderer* renderer,
+    const std::shared_ptr<Graphics::Shape>& shape,
+    const Punt& posicio,
+    float angle,
+    float escala = 1.0f,
+    bool dibuixar = true,
+    float progress = 1.0f,
+    float brightness = 1.0f);
+
+}  // namespace Rendering

source/core/system/director.cpp

@@ -0,0 +1,191 @@
+#include "director.hpp"
+
+#include <SDL3/SDL.h>
+#include <sys/stat.h>
+
+#include <cerrno>
+#include <cstdlib>
+#include <iostream>
+
+#include "game/escenes/escena_joc.hpp"
+#include "game/escenes/escena_logo.hpp"
+#include "game/escenes/escena_titol.hpp"
+#include "game/options.hpp"
+#include "core/audio/audio.hpp"
+#include "core/defaults.hpp"
+#include "core/rendering/sdl_manager.hpp"
+#include "gestor_escenes.hpp"
+#include "project.h"
+
+#ifndef _WIN32
+#include <pwd.h>
+#include <unistd.h>
+#endif
+
+// Constructor
+Director::Director(std::vector<std::string> const& args) {
+    std::cout << "Orni Attack - Inici\n";
+
+    // Inicialitzar opcions amb valors per defecte
+    Options::init();
+
+    // Comprovar arguments del programa
+    executable_path_ = checkProgramArguments(args);
+
+    // Crear carpetes del sistema
+    createSystemFolder("jailgames");
+    createSystemFolder(std::string("jailgames/") + Project::NAME);
+
+    // Establir ruta del fitxer de configuració
+    Options::setConfigFile(system_folder_ + "/config.yaml");
+
+    // Carregar o crear configuració
+    Options::loadFromFile();
+
+    if (Options::console) {
+        std::cout << "Configuració carregada\n";
+        std::cout << "  Finestra: " << Options::window.width << "×"
+                  << Options::window.height << '\n';
+        std::cout << "  Física: rotation=" << Options::physics.rotation_speed
+                  << " rad/s\n";
+    }
+
+    std::cout << '\n';
+}
+
+Director::~Director() {
+    // Guardar opcions
+    Options::saveToFile();
+
+    // Cleanup audio
+    Audio::destroy();
+
+    // Cleanup SDL
+    SDL_Quit();
+
+    std::cout << "\nAdéu!\n";
+}
+
+// Comprovar arguments del programa
+auto Director::checkProgramArguments(std::vector<std::string> const& args)
+    -> std::string {
+    for (std::size_t i = 1; i < args.size(); ++i) {
+        const std::string& argument = args[i];
+
+        if (argument == "--console") {
+            Options::console = true;
+            std::cout << "Mode consola activat\n";
+        } else if (argument == "--reset-config") {
+            Options::init();
+            Options::saveToFile();
+            std::cout << "Configuració restablida als valors per defecte\n";
+        }
+    }
+
+    return args[0];  // Retornar ruta de l'executable
+}
+
+// Crear carpeta del sistema (específic per plataforma)
+void Director::createSystemFolder(const std::string& folder) {
+#ifdef _WIN32
+    system_folder_ = std::string(getenv("APPDATA")) + "/" + folder;
+#elif __APPLE__
+    struct passwd* pw = getpwuid(getuid());
+    const char* homedir = pw->pw_dir;
+    system_folder_ =
+        std::string(homedir) + "/Library/Application Support/" + folder;
+#elif __linux__
+    struct passwd* pw = getpwuid(getuid());
+    const char* homedir = pw->pw_dir;
+    system_folder_ = std::string(homedir) + "/.config/" + folder;
+
+    // CRÍTIC: Crear ~/.config si no existeix
+    {
+        std::string config_base_folder = std::string(homedir) + "/.config";
+        int ret = mkdir(config_base_folder.c_str(), S_IRWXU);
+        if (ret == -1 && errno != EEXIST) {
+            printf("ERROR: No es pot crear la carpeta ~/.config\n");
+            exit(EXIT_FAILURE);
+        }
+    }
+#endif
+
+    // Comprovar si la carpeta existeix
+    struct stat st = {.st_dev = 0};
+    if (stat(system_folder_.c_str(), &st) == -1) {
+        errno = 0;
+
+#ifdef _WIN32
+        int ret = mkdir(system_folder_.c_str());
+#else
+        int ret = mkdir(system_folder_.c_str(), S_IRWXU);
+#endif
+
+        if (ret == -1) {
+            switch (errno) {
+                case EACCES:
+                    printf("ERROR: Permisos denegats creant %s\n", system_folder_.c_str());
+                    exit(EXIT_FAILURE);
+
+                case EEXIST:
+                    // La carpeta ja existeix (race condition), continuar
+                    break;
+
+                case ENAMETOOLONG:
+                    printf("ERROR: Ruta massa llarga: %s\n", system_folder_.c_str());
+                    exit(EXIT_FAILURE);
+
+                default:
+                    perror("mkdir");
+                    exit(EXIT_FAILURE);
+            }
+        }
+    }
+
+    if (Options::console) {
+        std::cout << "Carpeta del sistema: " << system_folder_ << '\n';
+    }
+}
+
+// Bucle principal del joc
+auto Director::run() -> int {
+    // Calculate initial size from saved zoom_factor
+    int initial_width = static_cast<int>(std::round(
+        Defaults::Window::WIDTH * Options::window.zoom_factor));
+    int initial_height = static_cast<int>(std::round(
+        Defaults::Window::HEIGHT * Options::window.zoom_factor));
+
+    // Crear gestor SDL amb configuració de Options
+    SDLManager sdl(initial_width, initial_height, Options::window.fullscreen);
+
+    // Inicialitzar sistema d'audio
+    Audio::init();
+
+    // Bucle principal de gestió d'escenes
+    while (GestorEscenes::actual != GestorEscenes::Escena::EIXIR) {
+        switch (GestorEscenes::actual) {
+            case GestorEscenes::Escena::LOGO: {
+                EscenaLogo logo(sdl);
+                logo.executar();
+                break;
+            }
+
+            case GestorEscenes::Escena::TITOL: {
+                EscenaTitol titol(sdl);
+                titol.executar();
+                break;
+            }
+
+            case GestorEscenes::Escena::JOC: {
+                EscenaJoc joc(sdl);
+                joc.executar();
+                break;
+            }
+
+            default:
+                break;
+        }
+    }
+
+    return 0;
+}

source/core/system/director.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+class Director {
+    public:
+        explicit Director(std::vector<std::string> const& args);
+        ~Director();
+
+        auto run() -> int;  // Main game loop
+
+    private:
+        std::string executable_path_;
+        std::string system_folder_;
+
+        static auto checkProgramArguments(std::vector<std::string> const& args)
+            -> std::string;
+        void createSystemFolder(const std::string& folder);
+};

source/core/system/gestor_escenes.hpp

@@ -0,0 +1,17 @@
+// gestor_escenes.hpp - Sistema de gestió d'escenes
+// Basat en el patró del projecte "pollo"
+// © 2025 Port a C++20
+
+#pragma once
+
+namespace GestorEscenes {
+enum class Escena {
+    LOGO,   // Pantalla d'inici (2 segons negre)
+    TITOL,  // Pantalla de títol amb menú
+    JOC,    // Joc principal
+    EIXIR   // Sortir del programa
+};
+
+// Variable global inline per gestionar l'escena actual
+inline Escena actual = Escena::LOGO;
+}  // namespace GestorEscenes

source/core/system/global_events.cpp

@@ -0,0 +1,48 @@
+// global_events.cpp - Implementació dels events globals
+// © 2025 Port a C++20
+
+#include "global_events.hpp"
+
+#include "core/rendering/sdl_manager.hpp"
+#include "gestor_escenes.hpp"
+#include "core/input/mouse.hpp"
+
+namespace GlobalEvents {
+
+bool handle(const SDL_Event& event, SDLManager& sdl) {
+    // Tecles globals de finestra (F1/F2/F3)
+    if (event.type == SDL_EVENT_KEY_DOWN) {
+        switch (event.key.key) {
+            case SDLK_F1:
+                sdl.decreaseWindowSize();
+                return true;
+            case SDLK_F2:
+                sdl.increaseWindowSize();
+                return true;
+            case SDLK_F3:
+                sdl.toggleFullscreen();
+                return true;
+            case SDLK_F4:
+                sdl.toggleVSync();
+                return true;
+            case SDLK_ESCAPE:
+                GestorEscenes::actual = GestorEscenes::Escena::EIXIR;
+                return true;
+            default:
+                break;
+        }
+    }
+
+    // Tancar finestra
+    if (event.type == SDL_EVENT_QUIT) {
+        GestorEscenes::actual = GestorEscenes::Escena::EIXIR;
+        return true;
+    }
+
+    // Gestió del ratolí (auto-ocultar)
+    Mouse::handleEvent(event);
+
+    return false;  // Event no processat
+}
+
+}  // namespace GlobalEvents

source/core/system/global_events.hpp

@@ -0,0 +1,16 @@
+// global_events.hpp - Events globals del joc
+// Basat en el patró del projecte "pollo"
+// © 2025 Port a C++20
+
+#pragma once
+
+#include <SDL3/SDL.h>
+
+// Forward declaration
+class SDLManager;
+
+namespace GlobalEvents {
+// Processa events globals (F1/F2/F3/ESC/QUIT)
+// Retorna true si l'event ha estat processat i no cal seguir processant-lo
+bool handle(const SDL_Event& event, SDLManager& sdl);
+}  // namespace GlobalEvents

source/core/types.hpp

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <array>
+#include <cstdint>
+
+#include "core/defaults.hpp"
+
+// Punt polar (coordenades polars)
+struct IPunt {
+        float r;      // Radi
+        float angle;  // Angle en radians
+};
+
+// Punt cartesià
+struct Punt {
+        float x, y;
+};
+
+// ==============================================================================
+// DEPRECATED: Legacy types (replaced by Shape system)
+// ==============================================================================
+// These types are kept temporarily for chatarra_cosmica_ (Phase 10: explosions)
+// TODO Phase 10: Replace with particle system or remove completely
+
+// Nau (triangle) - DEPRECATED: Now using Shape system (ship.shp)
+struct Triangle {
+        IPunt p1, p2, p3;
+        Punt centre;
+        float angle;
+        float velocitat;
+};
+
+// Polígon (enemics i bales) - DEPRECATED: Now using Shape system (.shp files)
+struct Poligon {
+        std::array<IPunt, Defaults::Entities::MAX_IPUNTS> ipuntx;
+        Punt centre;
+        float angle;
+        float velocitat;
+        uint8_t n;
+        float drotacio;
+        float rotacio;
+        bool esta;
+};

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,33 @@ 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,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,84 +3,103 @@
 // © 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"
 
-  // [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),
+      brightness_(Defaults::Brightness::BALA) {
+    // [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;
+
+    // Reproducir sonido de disparo láser
+    Audio::get()->playSound(Defaults::Sound::LASER, Audio::Group::GAME);
 }
 
 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, 1.0f, brightness_);
-  }
+    }
 }
 
 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,41 @@
 // © 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_;
+        float brightness_;  // Factor de brillantor (0.0-1.0)
 
-  void mou(float delta_time);
+        void mou(float delta_time);
 };

source/game/entities/enemic.cpp

@@ -3,117 +3,142 @@
 // © 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"
 
-  // [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),
+      brightness_(Defaults::Brightness::ENEMIC) {
+    // [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, 1.0f, brightness_);
-  }
+    }
 }
 
 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,43 @@
 // © 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_;
+        float brightness_;  // Factor de brillantor (0.0-1.0)
 
-  void mou(float delta_time);
+        void mou(float delta_time);
 };

source/game/entities/nau.cpp

@@ -3,137 +3,150 @@
 // © 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),
+      brightness_(Defaults::Brightness::NAU) {
+    // [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, 1.0f, brightness_);
 }
 
 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,45 @@
 // © 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_;
+        float brightness_;  // Factor de brillantor (0.0-1.0)
 
-  void aplicar_fisica(float delta_time);
+        void aplicar_fisica(float delta_time);
 };

source/game/escenes/escena_joc.cpp

@@ -3,211 +3,316 @@
 // © 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/input/mouse.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),
-  // 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);
+
+        // Actualitzar visibilitat del cursor (auto-ocultar)
+        Mouse::updateCursorVisibility();
+
+        // 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 sistema d'audio
+        Audio::update();
+
+        // Actualitzar colors oscil·lats
+        sdl_.updateColors(delta_time);
+
+        // Netejar pantalla (usa color oscil·lat)
+        sdl_.neteja(0, 0, 0);
+
+        // Actualitzar context de renderitzat (factor d'escala global)
+        sdl_.updateRenderingContext();
+
+        // 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 "../../core/graphics/vector_text.hpp"
-#include "../../core/rendering/sdl_manager.hpp"
-#include "../../core/types.hpp"
-#include "../constants.hpp"
-#include "../entities/bala.hpp"
-#include "../entities/enemic.hpp"
-#include "../entities/nau.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"
+
 // 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,393 @@
 // © 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/input/mouse.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,
+    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";
+    so_reproduit_.fill(false);  // Inicialitzar seguiment de sons
+    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);
+
+        // Actualitzar visibilitat del cursor (auto-ocultar)
+        Mouse::updateCursorVisibility();
+
+        // 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);
+
+        // Actualitzar context de renderitzat (factor d'escala global)
+        sdl_.updateRenderingContext();
+
+        // 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;
+
+        // 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 {
-  // 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 (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;
+    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()) {
+            // Reproduir so per cada lletra quan comença a aparèixer
-        canviar_estat(EstatAnimacio::POST_ANIMATION);
+            float global_progress = std::min(temps_estat_actual_ / DURACIO_ZOOM, 1.0f);
-      }
-      break;
 
-    case EstatAnimacio::POST_ANIMATION:
+            for (size_t i = 0; i < lletres_.size() && i < so_reproduit_.size(); i++) {
-      if (temps_estat_actual_ >= DURACIO_POST) {
+                if (!so_reproduit_[i]) {
-        GestorEscenes::actual = GestorEscenes::Escena::JOC;
+                    float letra_progress = calcular_progress_letra(
-      }
+                        i,
-      break;
+                        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_ANIMATION) {
+                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() {
-  // 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) {
+        // 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 ||
+    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::TITOL;
-  }
+    }
 }

source/game/escenes/escena_logo.hpp

@@ -4,60 +4,82 @@
 
 #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ó
+        std::vector<size_t> ordre_explosio_;  // Ordre aleatori d'índexs de lletres
 
-  // 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
+        // Seguiment de sons de lletres (evitar reproduccions repetides)
-  void inicialitzar_lletres();
+        std::array<bool, 9> so_reproduit_;  // Track si cada lletra ja ha reproduit el so
-  void actualitzar(float delta_time);
-  void dibuixar();
-  void processar_events(const SDL_Event& event);
 
-  // Mètodes de gestió d'estats
+        // Constants d'animació
-  void canviar_estat(EstatAnimacio nou_estat);
+        static constexpr float DURACIO_PRE = 1.5f;             // Duració PRE_ANIMATION (pantalla negra)
-  bool totes_lletres_completes() const;
+        static constexpr float DURACIO_ZOOM = 4.0f;            // Duració del zoom (segons)
+        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 = 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/escenes/escena_titol.cpp

@@ -0,0 +1,183 @@
+// 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/input/mouse.hpp"
+#include "core/system/gestor_escenes.hpp"
+#include "core/system/global_events.hpp"
+#include "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);
+
+        // Actualitzar visibilitat del cursor (auto-ocultar)
+        Mouse::updateCursorVisibility();
+
+        // 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);
+
+        // Actualitzar context de renderitzat (factor d'escala global)
+        sdl_.updateRenderingContext();
+
+        // 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,298 +1,413 @@
 #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.zoom_factor = Defaults::Window::BASE_ZOOM;
 
-  // 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;
+
+    // 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);
 }
 
 // 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("zoom_factor")) {
-      try {
+            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
-      } catch (...) {
+                    : Defaults::Window::BASE_ZOOM;
-        window.size_increment = Defaults::Window::SIZE_INCREMENT;
+            } catch (...) {
-      }
+                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);
+        }
     }
-  }
 }
 
-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;
+            }
+        }
+    }
+}
+
+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);
+    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);
+        loadAudioConfigFromYaml(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 << "   # 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 << "  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 << "# 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\n";
 
-  if (console) {
+    file << "# AUDIO\n";
-    std::cout << "Config guardada a: " << config_file_path << '\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";
 
-  return true;
+    file.close();
+
+    if (console) {
+        std::cout << "Config guardada a: " << config_file_path << '\n';
+    }
+
+    return true;
 }
 
-} // namespace Options
+}  // namespace Options

source/game/options.hpp

@@ -7,42 +7,65 @@ 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
+        float zoom_factor{1.0f};  // Zoom level (0.5x to max_zoom)
 };
 
 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
+};
+
+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ó
+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 Audio audio{};
 
-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,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