correccions en el makefile de macos

Las dimensiones en píxeles son enteros por naturaleza. Convertidos los
miembros y constructores a int, y ajustados getWidth()/getHeight() para
devolver int. Eliminados los static_cast<int>(...->width/height) y
static_cast<int>(surface->getWidth/getHeight()) redundantes que sólo
existían para compensar el tipo erróneo.

Los callers que inicializan SDL_FRect directamente con getWidth/getHeight
requieren static_cast<float> explícito (sprite.cpp, animated_sprite.cpp,
notifier.cpp, title.cpp) por las reglas de narrowing de list-init.

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

CMakeLists.txt

@@ -382,6 +382,8 @@ if(CPPCHECK_EXE)
             --inline-suppr
             --suppress=missingIncludeSystem
             --suppress=toomanyconfigs
+            --suppress=*:*/source/external/*
+            --suppress=*:*/source/core/rendering/sdl3gpu/spv/*
             --quiet
             -I ${CMAKE_SOURCE_DIR}/source
             ${CPPCHECK_SOURCES}

Makefile

@@ -186,12 +186,28 @@ _windows_release:
 _macos_release:
 	@echo "Creando release para macOS - Version: $(VERSION)"
 
-# Verificar e instalar create-dmg si es necesario
+# Verifica dependencias necesarias (create-dmg). Si falta, intenta instalarla
-	@which create-dmg > /dev/null || (echo "Instalando create-dmg..." && brew install create-dmg)
+# con brew; si brew tampoco está, indica el comando exacto al usuario.
-
+	@command -v create-dmg >/dev/null 2>&1 || { \
-# Compila la versión para procesadores Intel con cmake (genera shaders y resources.pack)
+		echo ""; \
-	@cmake -S . -B build/intel -DCMAKE_BUILD_TYPE=Release -DCMAKE_OSX_ARCHITECTURES=x86_64 -DCMAKE_OSX_DEPLOYMENT_TARGET=10.15 -DMACOS_BUNDLE=ON -DGIT_HASH=$(GIT_HASH)
+		echo "============================================"; \
-	@cmake --build build/intel
+		echo "  Falta la dependencia: create-dmg"; \
+		echo "============================================"; \
+		if command -v brew >/dev/null 2>&1; then \
+			echo "  Instalando con: brew install create-dmg"; \
+			brew install create-dmg || { \
+				echo ""; \
+				echo "  ERROR: 'brew install create-dmg' ha fallado."; \
+				echo "  Ejecuta el comando manualmente y vuelve a probar."; \
+				exit 1; \
+			}; \
+		else \
+			echo "  Homebrew no está instalado."; \
+			echo "  Instálalo desde https://brew.sh y luego ejecuta:"; \
+			echo "      brew install create-dmg"; \
+			exit 1; \
+		fi; \
+	}
 
 # Elimina datos de compilaciones anteriores
 	$(RMDIR) "$(RELEASE_FOLDER)"
@@ -205,12 +221,11 @@ _macos_release:
 	$(MKDIR) "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/MacOS"
 	$(MKDIR) "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"
 
-# Copia carpetas y ficheros
+# Copia carpetas y ficheros del bundle (resources.pack se generará al compilar)
-	cp resources.pack "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"
-	cp gamecontrollerdb.txt "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"
 	cp -R release/macos/frameworks/SDL3.xcframework/macos-arm64_x86_64/SDL3.framework "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Frameworks"
 	cp release/icons/*.icns "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"
 	cp release/macos/Info.plist "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents"
+	cp gamecontrollerdb.txt "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"
 	cp LICENSE "$(RELEASE_FOLDER)"
 	cp README.md "$(RELEASE_FOLDER)"
 
@@ -220,32 +235,53 @@ _macos_release:
 	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"
 
-# Copia el ejecutable Intel al bundle
+# Compila y empaqueta la versión Intel (best-effort: si falla, se omite el
-	cp "$(TARGET_FILE)" "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/MacOS/$(TARGET_NAME)"
+# DMG Intel y continúa con la build de Apple Silicon).
-
+	@echo ""
-# Firma la aplicación
+	@echo "============================================"
-	codesign --deep --force --sign - --timestamp=none "$(RELEASE_FOLDER)/$(APP_NAME).app"
+	@echo "  Compilando version Intel (x86_64)"
-
+	@echo "============================================"
-# Empaqueta el .dmg de la versión Intel con create-dmg
+	@if cmake -S . -B build/intel -DCMAKE_BUILD_TYPE=Release \
-	@echo "Creando DMG Intel con iconos de 96x96..."
+	          -DCMAKE_OSX_ARCHITECTURES=x86_64 \
-	create-dmg \
+	          -DCMAKE_OSX_DEPLOYMENT_TARGET=10.15 \
-	  --volname "$(APP_NAME)" \
+	          -DMACOS_BUNDLE=ON -DGIT_HASH=$(GIT_HASH) \
-	  --window-pos 200 120 \
+	   && cmake --build build/intel; then \
-	  --window-size 720 300 \
+		cp resources.pack "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"; \
-	  --icon-size 96 \
+		cp "$(TARGET_FILE)" "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/MacOS/$(TARGET_NAME)"; \
-	  --text-size 12 \
+		codesign --deep --force --sign - --timestamp=none "$(RELEASE_FOLDER)/$(APP_NAME).app"; \
-	  --icon "$(APP_NAME).app" 278 102 \
+		echo "Creando DMG Intel con iconos de 96x96..."; \
-	  --icon "LICENSE" 441 102 \
+		create-dmg \
-	  --icon "README.md" 604 102 \
+		  --volname "$(APP_NAME)" \
-	  --app-drop-link 115 102 \
+		  --window-pos 200 120 \
-	  --hide-extension "$(APP_NAME).app" \
+		  --window-size 720 300 \
-	  "$(MACOS_INTEL_RELEASE)" \
+		  --icon-size 96 \
-	  "$(RELEASE_FOLDER)" || true
+		  --text-size 12 \
-	@echo "Release Intel creado: $(MACOS_INTEL_RELEASE)"
+		  --icon "$(APP_NAME).app" 278 102 \
+		  --icon "LICENSE" 441 102 \
+		  --icon "README.md" 604 102 \
+		  --app-drop-link 115 102 \
+		  --hide-extension "$(APP_NAME).app" \
+		  "$(MACOS_INTEL_RELEASE)" \
+		  "$(RELEASE_FOLDER)" || true; \
+		echo "Release Intel creado: $(MACOS_INTEL_RELEASE)"; \
+	else \
+		echo ""; \
+		echo "============================================"; \
+		echo "  WARNING: la build Intel ha fallado."; \
+		echo "  Se omite el DMG Intel y se continúa con"; \
+		echo "  la build de Apple Silicon."; \
+		echo "============================================"; \
+		echo ""; \
+	fi
 
 # Compila la versión para procesadores Apple Silicon con cmake
+	@echo ""
+	@echo "============================================"
+	@echo "  Compilando version Apple Silicon (arm64)"
+	@echo "============================================"
 	@cmake -S . -B build/arm -DCMAKE_BUILD_TYPE=Release -DCMAKE_OSX_ARCHITECTURES=arm64 -DCMAKE_OSX_DEPLOYMENT_TARGET=11.0 -DMACOS_BUNDLE=ON -DGIT_HASH=$(GIT_HASH)
 	@cmake --build build/arm
+	cp resources.pack "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"
 	cp "$(TARGET_FILE)" "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/MacOS/$(TARGET_NAME)"
 
 # Firma la aplicación

source/core/rendering/sprite/animated_sprite.cpp

@@ -219,7 +219,7 @@ AnimatedSprite::AnimatedSprite(std::shared_ptr<Surface> surface, SDL_FRect pos)
     : MovingSprite(std::move(surface), pos) {
     // animations_ queda buit (protegit per el guard de animate())
     if (surface_) {
-        clip_ = {.x = 0, .y = 0, .w = surface_->getWidth(), .h = surface_->getHeight()};
+        clip_ = {.x = 0, .y = 0, .w = static_cast<float>(surface_->getWidth()), .h = static_cast<float>(surface_->getHeight())};
     }
 }
 

source/core/rendering/sprite/dissolve_sprite.cpp

@@ -35,8 +35,8 @@ auto DissolveSprite::computePixelRank(int col, int row, int frame_h, DissolveDir
 DissolveSprite::DissolveSprite(std::shared_ptr<Surface> surface, SDL_FRect pos)
     : AnimatedSprite(std::move(surface), pos) {
     if (surface_) {
-        const int W = static_cast<int>(surface_->getWidth());
+        const int W = surface_->getWidth();
-        const int H = static_cast<int>(surface_->getHeight());
+        const int H = surface_->getHeight();
         surface_display_ = std::make_shared<Surface>(W, H);
         surface_display_->setTransparentColor(surface_->getTransparentColor());
         surface_display_->clear(surface_->getTransparentColor());
@@ -47,8 +47,8 @@ DissolveSprite::DissolveSprite(std::shared_ptr<Surface> surface, SDL_FRect pos)
 DissolveSprite::DissolveSprite(const AnimationResource& data)
     : AnimatedSprite(data) {
     if (surface_) {
-        const int W = static_cast<int>(surface_->getWidth());
+        const int W = surface_->getWidth();
-        const int H = static_cast<int>(surface_->getHeight());
+        const int H = surface_->getHeight();
         surface_display_ = std::make_shared<Surface>(W, H);
         surface_display_->setTransparentColor(surface_->getTransparentColor());
         // Inicialitza tots els píxels com a transparents
@@ -75,8 +75,8 @@ void DissolveSprite::rebuildDisplaySurface() {
     auto src_data = surface_->getSurfaceData();
     auto dst_data = surface_display_->getSurfaceData();
 
-    const int SRC_W = static_cast<int>(src_data->width);
+    const int SRC_W = src_data->width;
-    const int DST_W = static_cast<int>(dst_data->width);
+    const int DST_W = dst_data->width;
     const Uint8 TRANSPARENT = surface_->getTransparentColor();
 
     // Esborra frame anterior si ha canviat

source/core/rendering/sprite/sprite.cpp

@@ -19,7 +19,7 @@ Sprite::Sprite() = default;
 
 Sprite::Sprite(std::shared_ptr<Surface> surface)
     : surface_(std::move(surface)),
-      pos_{0.0F, 0.0F, surface_->getWidth(), surface_->getHeight()},
+      pos_{0.0F, 0.0F, static_cast<float>(surface_->getWidth()), static_cast<float>(surface_->getHeight())},
       clip_(pos_) {}
 
 // Muestra el sprite por pantalla

source/core/rendering/surface.cpp

@@ -104,7 +104,7 @@ Surface::Surface(const std::string& file_path)
 }
 
 // Carga una superficie desde un archivo
-auto Surface::loadSurface(const std::string& file_path) -> SurfaceData {  // NOLINT(readability-convert-member-functions-to-static)
+auto Surface::loadSurface(const std::string& file_path) -> SurfaceData {
     // Load file using ResourceHelper (supports both filesystem and pack)
     std::vector<Uint8> buffer = Resource::Helper::loadFile(file_path);
     if (buffer.empty()) {
@@ -129,7 +129,7 @@ auto Surface::loadSurface(const std::string& file_path) -> SurfaceData {  // NOL
 
     // Crear y devolver directamente el objeto SurfaceData
     printWithDots("Surface : ", file_path.substr(file_path.find_last_of("\\/") + 1), "[ LOADED ]");
-    return {static_cast<float>(w), static_cast<float>(h), pixels};
+    return {static_cast<int>(w), static_cast<int>(h), pixels};
 }
 
 // Carga una paleta desde un archivo
@@ -149,7 +149,7 @@ void Surface::setColor(int index, Uint32 color) {
 
 // Rellena la superficie con un color
 void Surface::clear(Uint8 color) {  // NOLINT(readability-convert-member-functions-to-static)
-    const size_t TOTAL_PIXELS = surface_data_->width * surface_data_->height;
+    const size_t TOTAL_PIXELS = static_cast<size_t>(surface_data_->width) * static_cast<size_t>(surface_data_->height);
     Uint8* data_ptr = surface_data_->data.get();
     std::fill(data_ptr, data_ptr + TOTAL_PIXELS, color);
 }
@@ -165,19 +165,19 @@ void Surface::putPixel(int x, int y, Uint8 color) {  // NOLINT(readability-conve
 }
 
 // Obtiene el color de un pixel de la surface_data
-auto Surface::getPixel(int x, int y) -> Uint8 { return surface_data_->data.get()[x + (y * static_cast<int>(surface_data_->width))]; }
+auto Surface::getPixel(int x, int y) -> Uint8 { return surface_data_->data.get()[x + (y * surface_data_->width)]; }
 
 // Dibuja un rectangulo relleno
 void Surface::fillRect(const SDL_FRect* rect, Uint8 color) {  // NOLINT(readability-convert-member-functions-to-static)
     // Limitar los valores del rectángulo al tamaño de la superficie
     float x_start = std::max(0.0F, rect->x);
     float y_start = std::max(0.0F, rect->y);
-    float x_end = std::min(rect->x + rect->w, surface_data_->width);
+    float x_end = std::min(rect->x + rect->w, static_cast<float>(surface_data_->width));
-    float y_end = std::min(rect->y + rect->h, surface_data_->height);
+    float y_end = std::min(rect->y + rect->h, static_cast<float>(surface_data_->height));
 
     // Rellenar fila a fila con memset (memoria contigua por fila)
     Uint8* data_ptr = surface_data_->data.get();
-    const int SURF_WIDTH = static_cast<int>(surface_data_->width);
+    const int SURF_WIDTH = surface_data_->width;
     const int ROW_WIDTH = static_cast<int>(x_end) - static_cast<int>(x_start);
     for (int y = static_cast<int>(y_start); y < static_cast<int>(y_end); ++y) {
         std::memset(data_ptr + (y * SURF_WIDTH) + static_cast<int>(x_start), color, ROW_WIDTH);
@@ -189,12 +189,12 @@ void Surface::drawRectBorder(const SDL_FRect* rect, Uint8 color) {  // NOLINT(re
     // Limitar los valores del rectángulo al tamaño de la superficie
     float x_start = std::max(0.0F, rect->x);
     float y_start = std::max(0.0F, rect->y);
-    float x_end = std::min(rect->x + rect->w, surface_data_->width);
+    float x_end = std::min(rect->x + rect->w, static_cast<float>(surface_data_->width));
-    float y_end = std::min(rect->y + rect->h, surface_data_->height);
+    float y_end = std::min(rect->y + rect->h, static_cast<float>(surface_data_->height));
 
     // Dibujar bordes horizontales con memset (líneas contiguas en memoria)
     Uint8* data_ptr = surface_data_->data.get();
-    const int SURF_WIDTH = static_cast<int>(surface_data_->width);
+    const int SURF_WIDTH = surface_data_->width;
     const int ROW_WIDTH = static_cast<int>(x_end) - static_cast<int>(x_start);
     std::memset(data_ptr + (static_cast<int>(y_start) * SURF_WIDTH) + static_cast<int>(x_start), color, ROW_WIDTH);
     std::memset(data_ptr + ((static_cast<int>(y_end) - 1) * SURF_WIDTH) + static_cast<int>(x_start), color, ROW_WIDTH);
@@ -211,68 +211,38 @@ void Surface::drawRectBorder(const SDL_FRect* rect, Uint8 color) {  // NOLINT(re
     }
 }
 
-// Dibuja una linea
+// Dibuja una linea (Bresenham en enteros)
 void Surface::drawLine(float x1, float y1, float x2, float y2, Uint8 color) {  // NOLINT(readability-convert-member-functions-to-static)
-    // Calcula las diferencias
+    int ix1 = static_cast<int>(std::lround(x1));
-    float dx = std::abs(x2 - x1);
+    int iy1 = static_cast<int>(std::lround(y1));
-    float dy = std::abs(y2 - y1);
+    const int IX2 = static_cast<int>(std::lround(x2));
+    const int IY2 = static_cast<int>(std::lround(y2));
 
-    // Determina la dirección del incremento
+    const int DX = std::abs(IX2 - ix1);
-    float sx = (x1 < x2) ? 1 : -1;
+    const int DY = std::abs(IY2 - iy1);
-    float sy = (y1 < y2) ? 1 : -1;
+    const int SX = (ix1 < IX2) ? 1 : -1;
+    const int SY = (iy1 < IY2) ? 1 : -1;
 
-    float err = dx - dy;
+    const int SURF_W = surface_data_->width;
+    const int SURF_H = surface_data_->height;
+    Uint8* data_ptr = surface_data_->data.get();
 
+    int err = DX - DY;
     while (true) {
-        // Asegúrate de no dibujar fuera de los límites de la superficie
+        if (ix1 >= 0 && ix1 < SURF_W && iy1 >= 0 && iy1 < SURF_H) {
-        if (x1 >= 0 && x1 < surface_data_->width && y1 >= 0 && y1 < surface_data_->height) {
+            data_ptr[ix1 + (iy1 * SURF_W)] = color;
-            surface_data_->data.get()[static_cast<size_t>(x1 + (y1 * surface_data_->width))] = color;
         }
-
+        if (ix1 == IX2 && iy1 == IY2) {
-        // Si alcanzamos el punto final, salimos
-        if (x1 == x2 && y1 == y2) {
             break;
         }
-
         int e2 = 2 * err;
-        if (e2 > -dy) {
+        if (e2 > -DY) {
-            err -= dy;
+            err -= DY;
-            x1 += sx;
+            ix1 += SX;
         }
-        if (e2 < dx) {
+        if (e2 < DX) {
-            err += dx;
+            err += DX;
-            y1 += sy;
+            iy1 += SY;
-        }
-    }
-}
-
-void Surface::render(float dx, float dy, float sx, float sy, float w, float h) {  // NOLINT(readability-make-member-function-const)
-    auto surface_data = Screen::get()->getRendererSurface()->getSurfaceData();
-
-    // Limitar la región para evitar accesos fuera de rango en origen
-    w = std::min(w, surface_data_->width - sx);
-    h = std::min(h, surface_data_->height - sy);
-
-    // Limitar la región para evitar accesos fuera de rango en destino
-    w = std::min(w, surface_data->width - dx);
-    h = std::min(h, surface_data->height - dy);
-
-    const Uint8* src_ptr = surface_data_->data.get();
-    Uint8* dst_ptr = surface_data->data.get();
-    for (int iy = 0; iy < h; ++iy) {
-        for (int ix = 0; ix < w; ++ix) {
-            // Verificar que las coordenadas de destino están dentro de los límites
-            if (int dest_x = dx + ix; dest_x >= 0 && dest_x < surface_data->width) {
-                if (int dest_y = dy + iy; dest_y >= 0 && dest_y < surface_data->height) {
-                    int src_x = sx + ix;
-                    int src_y = sy + iy;
-
-                    Uint8 color = src_ptr[static_cast<size_t>(src_x + (src_y * surface_data_->width))];
-                    if (color != static_cast<Uint8>(transparent_color_)) {
-                        dst_ptr[static_cast<size_t>(dest_x + (dest_y * surface_data->width))] = sub_palette_[color];
-                    }
-                }
-            }
         }
     }
 }
@@ -283,18 +253,14 @@ void Surface::render(int x, int y, SDL_FRect* src_rect, SDL_FlipMode flip) {  //
     // Determina la región de origen (clip) a renderizar
     float sx = (src_rect != nullptr) ? src_rect->x : 0;
     float sy = (src_rect != nullptr) ? src_rect->y : 0;
-    float w = (src_rect != nullptr) ? src_rect->w : surface_data_->width;
+    float w = (src_rect != nullptr) ? src_rect->w : static_cast<float>(surface_data_->width);
-    float h = (src_rect != nullptr) ? src_rect->h : surface_data_->height;
+    float h = (src_rect != nullptr) ? src_rect->h : static_cast<float>(surface_data_->height);
 
-    // Limitar la región para evitar accesos fuera de rango en origen
+    // Limitar la región para evitar accesos fuera de rango (origen y destino)
-    w = std::min(w, surface_data_->width - sx);
+    w = std::min(w, static_cast<float>(surface_data_->width) - sx);
-    h = std::min(h, surface_data_->height - sy);
+    h = std::min(h, static_cast<float>(surface_data_->height) - sy);
-    w = std::min(w, surface_data_dest->width - x);
+    w = std::min(w, static_cast<float>(surface_data_dest->width - x));
-    h = std::min(h, surface_data_dest->height - y);
+    h = std::min(h, static_cast<float>(surface_data_dest->height - y));
-
-    // Limitar la región para evitar accesos fuera de rango en destino
-    w = std::min(w, surface_data_dest->width - x);
-    h = std::min(h, surface_data_dest->height - y);
 
     // Renderiza píxel por píxel aplicando el flip si es necesario
     const Uint8* src_ptr = surface_data_->data.get();
@@ -322,7 +288,7 @@ void Surface::render(int x, int y, SDL_FRect* src_rect, SDL_FlipMode flip) {  //
 }
 
 // Helper para calcular coordenadas con flip
-void Surface::calculateFlippedCoords(int ix, int iy, float sx, float sy, float w, float h, SDL_FlipMode flip, int& src_x, int& src_y) {
+void Surface::calculateFlippedCoords(int ix, int iy, int sx, int sy, int w, int h, SDL_FlipMode flip, int& src_x, int& src_y) {
     src_x = (flip == SDL_FLIP_HORIZONTAL) ? (sx + w - 1 - ix) : (sx + ix);
     src_y = (flip == SDL_FLIP_VERTICAL) ? (sy + h - 1 - iy) : (sy + iy);
 }
@@ -418,11 +384,11 @@ void Surface::renderWithColorReplace(int x, int y, Uint8 source_color, Uint8 tar
                 continue;  // Saltar píxeles fuera del rango del destino
             }
 
-            // Copia el píxel si no es transparente
+            // Copia el píxel si no es transparente; aplica sub_palette_ como el resto de render*
             Uint8 color = surface_data_->data.get()[static_cast<size_t>(src_x + (src_y * surface_data_->width))];
             if (color != static_cast<Uint8>(transparent_color_)) {
                 surface_data->data[dest_x + (dest_y * surface_data->width)] =
-                    (color == source_color) ? target_color : color;
+                    (color == source_color) ? target_color : sub_palette_[color];
             }
         }
     }
@@ -452,14 +418,14 @@ static auto computeFadeDensity(int screen_y, int fade_h, int canvas_height) -> f
 void Surface::renderWithVerticalFade(int x, int y, int fade_h, int canvas_height, SDL_FRect* src_rect) const {
     const int SX = (src_rect != nullptr) ? static_cast<int>(src_rect->x) : 0;
     const int SY = (src_rect != nullptr) ? static_cast<int>(src_rect->y) : 0;
-    const int SW = (src_rect != nullptr) ? static_cast<int>(src_rect->w) : static_cast<int>(surface_data_->width);
+    const int SW = (src_rect != nullptr) ? static_cast<int>(src_rect->w) : surface_data_->width;
-    const int SH = (src_rect != nullptr) ? static_cast<int>(src_rect->h) : static_cast<int>(surface_data_->height);
+    const int SH = (src_rect != nullptr) ? static_cast<int>(src_rect->h) : surface_data_->height;
 
     auto surface_data_dest = Screen::get()->getRendererSurface()->getSurfaceData();
 
     for (int row = 0; row < SH; row++) {
         const int SCREEN_Y = y + row;
-        if (SCREEN_Y < 0 || SCREEN_Y >= static_cast<int>(surface_data_dest->height)) {
+        if (SCREEN_Y < 0 || SCREEN_Y >= surface_data_dest->height) {
             continue;
         }
 
@@ -467,11 +433,11 @@ void Surface::renderWithVerticalFade(int x, int y, int fade_h, int canvas_height
 
         for (int col = 0; col < SW; col++) {
             const int SCREEN_X = x + col;
-            if (SCREEN_X < 0 || SCREEN_X >= static_cast<int>(surface_data_dest->width)) {
+            if (SCREEN_X < 0 || SCREEN_X >= surface_data_dest->width) {
                 continue;
             }
 
-            const Uint8 COLOR = surface_data_->data[((SY + row) * static_cast<int>(surface_data_->width)) + (SX + col)];
+            const Uint8 COLOR = surface_data_->data[((SY + row) * surface_data_->width) + (SX + col)];
             if (COLOR == static_cast<Uint8>(transparent_color_)) {
                 continue;
             }
@@ -480,7 +446,7 @@ void Surface::renderWithVerticalFade(int x, int y, int fade_h, int canvas_height
                 continue;  // Pixel tapat per la zona de fade
             }
 
-            surface_data_dest->data[SCREEN_X + (SCREEN_Y * static_cast<int>(surface_data_dest->width))] = sub_palette_[COLOR];
+            surface_data_dest->data[SCREEN_X + (SCREEN_Y * surface_data_dest->width)] = sub_palette_[COLOR];
         }
     }
 }
@@ -489,14 +455,14 @@ void Surface::renderWithVerticalFade(int x, int y, int fade_h, int canvas_height
 void Surface::renderWithVerticalFade(int x, int y, int fade_h, int canvas_height, Uint8 source_color, Uint8 target_color, SDL_FRect* src_rect) const {
     const int SX = (src_rect != nullptr) ? static_cast<int>(src_rect->x) : 0;
     const int SY = (src_rect != nullptr) ? static_cast<int>(src_rect->y) : 0;
-    const int SW = (src_rect != nullptr) ? static_cast<int>(src_rect->w) : static_cast<int>(surface_data_->width);
+    const int SW = (src_rect != nullptr) ? static_cast<int>(src_rect->w) : surface_data_->width;
-    const int SH = (src_rect != nullptr) ? static_cast<int>(src_rect->h) : static_cast<int>(surface_data_->height);
+    const int SH = (src_rect != nullptr) ? static_cast<int>(src_rect->h) : surface_data_->height;
 
     auto surface_data_dest = Screen::get()->getRendererSurface()->getSurfaceData();
 
     for (int row = 0; row < SH; row++) {
         const int SCREEN_Y = y + row;
-        if (SCREEN_Y < 0 || SCREEN_Y >= static_cast<int>(surface_data_dest->height)) {
+        if (SCREEN_Y < 0 || SCREEN_Y >= surface_data_dest->height) {
             continue;
         }
 
@@ -504,11 +470,11 @@ void Surface::renderWithVerticalFade(int x, int y, int fade_h, int canvas_height
 
         for (int col = 0; col < SW; col++) {
             const int SCREEN_X = x + col;
-            if (SCREEN_X < 0 || SCREEN_X >= static_cast<int>(surface_data_dest->width)) {
+            if (SCREEN_X < 0 || SCREEN_X >= surface_data_dest->width) {
                 continue;
             }
 
-            const Uint8 COLOR = surface_data_->data[((SY + row) * static_cast<int>(surface_data_->width)) + (SX + col)];
+            const Uint8 COLOR = surface_data_->data[((SY + row) * surface_data_->width) + (SX + col)];
             if (COLOR == static_cast<Uint8>(transparent_color_)) {
                 continue;
             }
@@ -518,7 +484,7 @@ void Surface::renderWithVerticalFade(int x, int y, int fade_h, int canvas_height
             }
 
             const Uint8 OUT_COLOR = (COLOR == source_color) ? target_color : sub_palette_[COLOR];
-            surface_data_dest->data[SCREEN_X + (SCREEN_Y * static_cast<int>(surface_data_dest->width))] = OUT_COLOR;
+            surface_data_dest->data[SCREEN_X + (SCREEN_Y * surface_data_dest->width)] = OUT_COLOR;
         }
     }
 }
@@ -527,8 +493,8 @@ void Surface::renderWithVerticalFade(int x, int y, int fade_h, int canvas_height
 void Surface::toARGBBuffer(Uint32* buffer) const {
     if (!surface_data_ || !surface_data_->data || (buffer == nullptr)) { return; }
 
-    const int WIDTH = static_cast<int>(surface_data_->width);
+    const int WIDTH = surface_data_->width;
-    const int HEIGHT = static_cast<int>(surface_data_->height);
+    const int HEIGHT = surface_data_->height;
     const Uint8* src = surface_data_->data.get();
 
     // Obtenemos el tamaño de la paleta para evitar accesos fuera de rango
@@ -639,11 +605,8 @@ void Surface::copyToTexture(SDL_Renderer* renderer, SDL_Texture* texture, SDL_FR
 
 // Realiza un efecto de fundido en la paleta principal
 auto Surface::fadePalette() -> bool {  // NOLINT(readability-convert-member-functions-to-static)
-    // Verificar que el tamaño mínimo de palette_ sea adecuado
     static constexpr int PALETTE_SIZE = 19;
-    if (sizeof(palette_) / sizeof(palette_[0]) < PALETTE_SIZE) {
+    static_assert(std::tuple_size_v<Palette> >= PALETTE_SIZE, "Palette size is insufficient for fadePalette operation.");
-        throw std::runtime_error("Palette size is insufficient for fadePalette operation.");
-    }
 
     // Desplazar colores (pares e impares)
     for (int i = 18; i > 1; --i) {
@@ -673,11 +636,8 @@ auto Surface::fadeSubPalette(Uint32 delay) -> bool {  // NOLINT(readability-conv
     // Actualizar el último tick
     last_tick_ = current_tick;
 
-    // Verificar que el tamaño mínimo de sub_palette_ sea adecuado
     static constexpr int SUB_PALETTE_SIZE = 19;
-    if (sizeof(sub_palette_) / sizeof(sub_palette_[0]) < SUB_PALETTE_SIZE) {
+    static_assert(std::tuple_size_v<SubPalette> >= SUB_PALETTE_SIZE, "Sub-palette size is insufficient for fadeSubPalette operation.");
-        throw std::runtime_error("Palette size is insufficient for fadePalette operation.");
-    }
 
     // Desplazar colores (pares e impares)
     for (int i = 18; i > 1; --i) {

source/core/rendering/surface.hpp

@@ -22,8 +22,8 @@ auto readPalFile(const std::string& file_path) -> Palette;
 
 struct SurfaceData {
     std::shared_ptr<Uint8[]> data;  // Usa std::shared_ptr para gestión automática
-    float width;                    // Ancho de la imagen
+    int width;                      // Ancho de la imagen
-    float height;                   // Alto de la imagen
+    int height;                     // Alto de la imagen
 
     // Constructor por defecto
     SurfaceData()
@@ -32,13 +32,13 @@ struct SurfaceData {
           height(0) {}
 
     // Constructor que inicializa dimensiones y asigna memoria
-    SurfaceData(float w, float h)
+    SurfaceData(int w, int h)
-        : data(std::shared_ptr<Uint8[]>(new Uint8[static_cast<size_t>(w * h)](), std::default_delete<Uint8[]>())),
+        : data(std::shared_ptr<Uint8[]>(new Uint8[static_cast<size_t>(w) * static_cast<size_t>(h)](), std::default_delete<Uint8[]>())),
           width(w),
           height(h) {}
 
     // Constructor para inicializar directamente con datos
-    SurfaceData(float w, float h, std::shared_ptr<Uint8[]> pixels)
+    SurfaceData(int w, int h, std::shared_ptr<Uint8[]> pixels)
         : data(std::move(pixels)),
           width(w),
           height(h) {}
@@ -56,6 +56,9 @@ struct SurfaceData {
 
 class Surface {
    private:
+    // shared_ptr porque render() accede al SurfaceData propio y al del renderer
+    // surface (ver getRendererSurface()) de forma efímera; con self-blit ambos
+    // pueden alias y el refcount evita free accidental durante el recorrido.
     std::shared_ptr<SurfaceData> surface_data_;  // Datos a dibujar
     Palette palette_;                            // Paleta para volcar la SurfaceData a una Textura
     SubPalette sub_palette_;                     // Paleta para reindexar colores
@@ -77,7 +80,6 @@ class Surface {
     void loadPalette(const Palette& palette);
 
     // Copia una región de la SurfaceData de origen a la SurfaceData de destino
-    void render(float dx, float dy, float sx, float sy, float w, float h);
     void render(int x, int y, SDL_FRect* src_rect = nullptr, SDL_FlipMode flip = SDL_FLIP_NONE);
     void render(SDL_FRect* src_rect = nullptr, SDL_FRect* dst_rect = nullptr, SDL_FlipMode flip = SDL_FLIP_NONE);
 
@@ -127,11 +129,10 @@ class Surface {
 
     // Metodos para gestionar surface_data_
     [[nodiscard]] auto getSurfaceData() const -> std::shared_ptr<SurfaceData> { return surface_data_; }
-    void setSurfaceData(std::shared_ptr<SurfaceData> new_data) { surface_data_ = std::move(new_data); }
 
     // Obtien ancho y alto
-    [[nodiscard]] auto getWidth() const -> float { return surface_data_->width; }
+    [[nodiscard]] auto getWidth() const -> int { return surface_data_->width; }
-    [[nodiscard]] auto getHeight() const -> float { return surface_data_->height; }
+    [[nodiscard]] auto getHeight() const -> int { return surface_data_->height; }
 
     // Color transparente
     [[nodiscard]] auto getTransparentColor() const -> Uint8 { return transparent_color_; }
@@ -146,7 +147,7 @@ class Surface {
 
    private:
     // Helper para calcular coordenadas con flip
-    static void calculateFlippedCoords(int ix, int iy, float sx, float sy, float w, float h, SDL_FlipMode flip, int& src_x, int& src_y);
+    static void calculateFlippedCoords(int ix, int iy, int sx, int sy, int w, int h, SDL_FlipMode flip, int& src_x, int& src_y);
 
     // Helper para copiar un pixel si no es transparente
     void copyPixelIfNotTransparent(Uint8* dest_data, int dest_x, int dest_y, int dest_width, int src_x, int src_y) const;

source/game/editor/mini_map.cpp

@@ -39,9 +39,9 @@ void MiniMap::buildTileColorTable(const std::string& tileset_name) {
     auto tileset = Resource::Cache::get()->getSurface(tileset_name);
     if (!tileset) { return; }
 
-    tileset_width_ = static_cast<int>(tileset->getWidth()) / Tile::SIZE;
+    tileset_width_ = tileset->getWidth() / Tile::SIZE;
     tileset_transparent_ = tileset->getTransparentColor();
-    int tileset_height = static_cast<int>(tileset->getHeight()) / Tile::SIZE;
+    int tileset_height = tileset->getHeight() / Tile::SIZE;
     int total_tiles = tileset_width_ * tileset_height;
 
     tile_colors_.resize(total_tiles, 0);

source/game/editor/tile_picker.cpp

@@ -26,8 +26,8 @@ void TilePicker::open(const std::string& tileset_name, int current_tile, int bg_
 
     // Calcular dimensiones del tileset en tiles (teniendo en cuenta spacing de entrada)
     int src_cell = Tile::SIZE + spacing_in_;
-    tileset_width_ = static_cast<int>(tileset_->getWidth()) / src_cell;
+    tileset_width_ = tileset_->getWidth() / src_cell;
-    tileset_height_ = static_cast<int>(tileset_->getHeight()) / src_cell;
+    tileset_height_ = tileset_->getHeight() / src_cell;
     // Corregir si el último tile cabe sin spacing
     if (tileset_width_ == 0 && tileset_->getWidth() >= Tile::SIZE) { tileset_width_ = 1; }
     if (tileset_height_ == 0 && tileset_->getHeight() >= Tile::SIZE) { tileset_height_ = 1; }

source/game/scenes/title.cpp

@@ -502,7 +502,7 @@ void Title::createCheevosTexture() {  // NOLINT(readability-convert-member-funct
 
     // Crea el sprite para el listado de logros (usa la zona del menu)
     cheevos_sprite_ = std::make_unique<Sprite>(cheevos_surface_, (GameCanvas::WIDTH - cheevos_surface_->getWidth()) / 2, MENU_ZONE_Y, cheevos_surface_->getWidth(), cheevos_surface_->getHeight());
-    cheevos_surface_view_ = {.x = 0, .y = 0, .w = cheevos_surface_->getWidth(), .h = CHEEVOS_TEXTURE_VIEW_HEIGHT};
+    cheevos_surface_view_ = {.x = 0, .y = 0, .w = static_cast<float>(cheevos_surface_->getWidth()), .h = CHEEVOS_TEXTURE_VIEW_HEIGHT};
     cheevos_sprite_->setClip(cheevos_surface_view_);
 }
 

source/game/ui/notifier.cpp

@@ -225,7 +225,7 @@ void Notifier::show(std::vector<std::string> texts, const Style& style, int icon
 
     else if (SHAPE == Shape::SQUARED) {
         n.surface->clear(style.bg_color);
-        SDL_FRect squared_rect = {.x = 0, .y = 0, .w = n.surface->getWidth(), .h = n.surface->getHeight()};
+        SDL_FRect squared_rect = {.x = 0, .y = 0, .w = static_cast<float>(n.surface->getWidth()), .h = static_cast<float>(n.surface->getHeight())};
         n.surface->drawRectBorder(&squared_rect, style.border_color);
     }