arreglos d'estil

source/ball.cpp

@@ -6,11 +6,11 @@ class Texture;
 
 // Constructor
 Ball::Ball(float x, float vx, float vy, Color color, std::shared_ptr<Texture> texture)
+    : sprite_(std::make_unique<Sprite>(texture)),
+      pos_({x, 0.0f, BALL_SIZE, BALL_SIZE})
 {
-    pos_ = {x, 0.0f, BALL_SIZE,  BALL_SIZE};
     vx_ = vx;
     vy_ = vy;
-    sprite_ = std::make_unique<Sprite>(texture);
     sprite_->setPos({pos_.x, pos_.y});
     sprite_->setSize(BALL_SIZE, BALL_SIZE);
     sprite_->setClip({0, 0, BALL_SIZE, BALL_SIZE});

source/texture.cpp

@@ -1,19 +1,19 @@
 #define STB_IMAGE_IMPLEMENTATION
 #include "texture.h"
-#include <SDL3/SDL_error.h>    // for SDL_GetError
+#include <SDL3/SDL_error.h>    // Para SDL_GetError
-#include <SDL3/SDL_log.h>      // for SDL_Log
+#include <SDL3/SDL_log.h>      // Para SDL_Log
-#include <SDL3/SDL_pixels.h>   // for SDL_PixelFormat
+#include <SDL3/SDL_pixels.h>   // Para SDL_PixelFormat
-#include <SDL3/SDL_surface.h>  // for SDL_CreateSurfaceFrom, SDL_DestroySurface
+#include <SDL3/SDL_surface.h>  // Para SDL_CreateSurfaceFrom, SDL_DestroySurface
-#include <stdio.h>             // for NULL
+#include <stdio.h>             // Para NULL
-#include <stdlib.h>            // for exit
+#include <stdlib.h>            // Para exit
-#include <iostream>            // for basic_ostream, char_traits, operator<<
+#include <iostream>            // Para basic_ostream, char_traits, operator<<
-#include <string>              // for operator<<, string
+#include <string>              // Para operator<<, string
-#include "stb_image.h"         // for stbi_failure_reason, stbi_image_free
+#include "stb_image.h"         // Para stbi_failure_reason, stbi_image_free
 
 Texture::Texture(SDL_Renderer *renderer)
     : renderer_(renderer), texture_(nullptr), width_(0), height_(0) {}
 
-Texture::Texture(SDL_Renderer *renderer, std::string file_path)
+Texture::Texture(SDL_Renderer *renderer, const std::string &file_path)
     : renderer_(renderer), texture_(nullptr), width_(0), height_(0)
 {
     loadFromFile(file_path);
@@ -24,7 +24,8 @@ Texture::~Texture()
     free();
 }
 
-bool Texture::loadFromFile(std::string file_path)
+// Carga la imagen desde una ruta especificada
+bool Texture::loadFromFile(const std::string &file_path)
 {
     const std::string filename = file_path.substr(file_path.find_last_of("\\/") + 1);
     int req_format = STBI_rgb_alpha;
@@ -32,19 +33,19 @@ bool Texture::loadFromFile(std::string file_path)
     unsigned char *data = stbi_load(file_path.c_str(), &width, &height, &orig_format, req_format);
     if (data == nullptr)
     {
-		SDL_Log("Loading image failed: %s", stbi_failure_reason());
+        SDL_Log("Error al cargar la imagen: %s", stbi_failure_reason());
         exit(1);
     }
     else
     {
-		std::cout << "Image loaded: " << filename.c_str() << std::endl;
+        std::cout << "Imagen cargada: " << filename.c_str() << std::endl;
     }
 
     int pitch;
     SDL_PixelFormat pixel_format;
     if (req_format == STBI_rgb)
     {
-		pitch = 3 * width; // 3 bytes por pixel * pixels por linea
+        pitch = 3 * width; // 3 bytes por pixel * pixels por línea
         pixel_format = SDL_PIXELFORMAT_RGB24;
     }
     else
@@ -53,25 +54,25 @@ bool Texture::loadFromFile(std::string file_path)
         pixel_format = SDL_PIXELFORMAT_RGBA32;
     }
 
-	// Limpia
+    // Libera la memoria previa
     free();
 
     // La textura final
     SDL_Texture *new_texture = nullptr;
 
-	// Carga la imagen desde una ruta específica
+    // Crea la superficie de la imagen desde los datos cargados
     SDL_Surface *loaded_surface = SDL_CreateSurfaceFrom(width, height, pixel_format, (void *)data, pitch);
     if (loaded_surface == nullptr)
     {
-		std::cout << "Unable to load image " << file_path << std::endl;
+        std::cout << "No se pudo cargar la imagen " << file_path << std::endl;
     }
     else
     {
-		// Crea la textura desde los pixels de la surface
+        // Crea la textura desde los píxeles de la superficie
         new_texture = SDL_CreateTextureFromSurface(renderer_, loaded_surface);
         if (new_texture == nullptr)
         {
-			std::cout << "Unable to create texture from " << file_path << "! SDL Error: " << SDL_GetError() << std::endl;
+            std::cout << "No se pudo crear la textura desde " << file_path << "! Error de SDL: " << SDL_GetError() << std::endl;
         }
         else
         {
@@ -80,45 +81,47 @@ bool Texture::loadFromFile(std::string file_path)
             height_ = loaded_surface->h;
         }
 
-		// Elimina la textura cargada
+        // Destruye la superficie cargada
         SDL_DestroySurface(loaded_surface);
     }
 
-	// Return success
+    // Devuelve el resultado del proceso
     stbi_image_free(data);
     texture_ = new_texture;
     return texture_ != nullptr;
 }
 
+// Libera la textura si existe
 void Texture::free()
 {
-	// Free texture if it exists
+    if (texture_ != nullptr)
-	if (texture_ != NULL)
     {
         SDL_DestroyTexture(texture_);
-		texture_ = NULL;
+        texture_ = nullptr;
         width_ = 0;
         height_ = 0;
     }
 }
 
+// Renderiza la textura en pantalla
 void Texture::render(SDL_FRect *src, SDL_FRect *dst)
 {
-	// Render to screen
     SDL_RenderTexture(renderer_, texture_, src, dst);
 }
 
+// Obtiene el ancho de la imagen
 int Texture::getWidth()
 {
     return width_;
 }
 
+// Obtiene la altura de la imagen
 int Texture::getHeight()
 {
     return height_;
 }
 
-// Modulación de color
+// Modula el color de la textura
 void Texture::setColor(int r, int g, int b)
 {
     SDL_SetTextureColorMod(texture_, r, g, b);

source/texture.h

@@ -16,14 +16,14 @@ private:
 
 public:
     // Inicializa las variables
-    Texture(SDL_Renderer *renderer);
+    explicit Texture(SDL_Renderer *renderer);
-    Texture(SDL_Renderer *renderer, std::string file_path);
+    Texture(SDL_Renderer *renderer, const std::string &file_path);
 
     // Libera la memoria
     ~Texture();
 
     // Carga una imagen desde la ruta especificada
-    bool loadFromFile(std::string path);
+    bool loadFromFile(const std::string &path);
 
     // Libera la textura
     void free();