Aplicar formato automático con clang-format a todo el código fuente

- Reformatear archivos .cpp y .h según configuración Google personalizada
- Mejorar consistencia en indentación y espaciado
- Reorganizar includes y declaraciones de clases
- Mantener funcionalidad existente sin cambios

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

source/external/dbgtxt.h

@@ -1,24 +1,20 @@
 #pragma once
 
-namespace
-{
-    SDL_Texture *dbg_tex = nullptr;
-    SDL_Renderer *dbg_ren = nullptr;
-}
+namespace {
+SDL_Texture* dbg_tex = nullptr;
+SDL_Renderer* dbg_ren = nullptr;
+}  // namespace
 
-void dbg_init(SDL_Renderer *renderer)
-{
+void dbg_init(SDL_Renderer* renderer) {
     dbg_ren = renderer;
     Uint8 font[448] = {0x42, 0x4D, 0xC0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x12, 0x0B, 0x00, 0x00, 0x12, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x18, 0xF3, 0x83, 0x83, 0xCF, 0x83, 0x87, 0x00, 0x00, 0xF3, 0x39, 0x39, 0xCF, 0x79, 0xF3, 0x00, 0x00, 0x01, 0xF9, 0x39, 0xCF, 0x61, 0xF9, 0x00, 0x00, 0x33, 0xF9, 0x03, 0xE7, 0x87, 0x81, 0x00, 0x00, 0x93, 0x03, 0x3F, 0xF3, 0x1B, 0x39, 0x00, 0x00, 0xC3, 0x3F, 0x9F, 0x39, 0x3B, 0x39, 0x00, 0x41, 0xE3, 0x03, 0xC3, 0x01, 0x87, 0x83, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0xE7, 0x01, 0xC7, 0x81, 0x01, 0x83, 0x00, 0x00, 0xE7, 0x1F, 0x9B, 0xE7, 0x1F, 0x39, 0x00, 0x00, 0xE7, 0x8F, 0x39, 0xE7, 0x87, 0xF9, 0x00, 0x00, 0xC3, 0xC7, 0x39, 0xE7, 0xC3, 0xC3, 0x00, 0x00, 0x99, 0xE3, 0x39, 0xE7, 0xF1, 0xE7, 0x00, 0x00, 0x99, 0xF1, 0xB3, 0xC7, 0x39, 0xF3, 0x00, 0x00, 0x99, 0x01, 0xC7, 0xE7, 0x83, 0x81, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x83, 0xE7, 0x83, 0xEF, 0x39, 0x39, 0x00, 0x00, 0x39, 0xE7, 0x39, 0xC7, 0x11, 0x11, 0x00, 0x00, 0xF9, 0xE7, 0x39, 0x83, 0x01, 0x83, 0x00, 0x00, 0x83, 0xE7, 0x39, 0x11, 0x01, 0xC7, 0x00, 0x00, 0x3F, 0xE7, 0x39, 0x39, 0x29, 0x83, 0x00, 0x00, 0x33, 0xE7, 0x39, 0x39, 0x39, 0x11, 0x00, 0x00, 0x87, 0x81, 0x39, 0x39, 0x39, 0x39, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x39, 0x39, 0x83, 0x3F, 0x85, 0x31, 0x00, 0x00, 0x39, 0x31, 0x39, 0x3F, 0x33, 0x23, 0x00, 0x00, 0x29, 0x21, 0x39, 0x03, 0x21, 0x07, 0x00, 0x00, 0x01, 0x01, 0x39, 0x39, 0x39, 0x31, 0x00, 0x00, 0x01, 0x09, 0x39, 0x39, 0x39, 0x39, 0x00, 0x00, 0x11, 0x19, 0x39, 0x39, 0x39, 0x39, 0x00, 0x00, 0x39, 0x39, 0x83, 0x03, 0x83, 0x03, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0xC1, 0x39, 0x81, 0x83, 0x31, 0x01, 0x00, 0x00, 0x99, 0x39, 0xE7, 0x39, 0x23, 0x3F, 0x00, 0x00, 0x39, 0x39, 0xE7, 0xF9, 0x07, 0x3F, 0x00, 0x00, 0x31, 0x01, 0xE7, 0xF9, 0x0F, 0x3F, 0x00, 0x00, 0x3F, 0x39, 0xE7, 0xF9, 0x27, 0x3F, 0x00, 0x00, 0x9F, 0x39, 0xE7, 0xF9, 0x33, 0x3F, 0x00, 0x00, 0xC1, 0x39, 0x81, 0xF9, 0x39, 0x3F, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x39, 0x03, 0xC3, 0x07, 0x01, 0x3F, 0x00, 0x00, 0x39, 0x39, 0x99, 0x33, 0x3F, 0x3F, 0x00, 0x00, 0x01, 0x39, 0x3F, 0x39, 0x3F, 0x3F, 0x00, 0x00, 0x39, 0x03, 0x3F, 0x39, 0x03, 0x03, 0x00, 0x00, 0x39, 0x39, 0x3F, 0x39, 0x3F, 0x3F, 0x00, 0x00, 0x93, 0x39, 0x99, 0x33, 0x3F, 0x3F, 0x00, 0x00, 0xC7, 0x03, 0xC3, 0x07, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00};
 
     // Cargar surface del bitmap font
     SDL_Surface* font_surface = SDL_LoadBMP_IO(SDL_IOFromMem(font, 448), 1);
-    if (font_surface != nullptr)
-    {
+    if (font_surface != nullptr) {
         // Crear una nueva surface de 32 bits con canal alpha
         SDL_Surface* rgba_surface = SDL_CreateSurface(font_surface->w, font_surface->h, SDL_PIXELFORMAT_RGBA8888);
-        if (rgba_surface != nullptr)
-        {
+        if (rgba_surface != nullptr) {
             // Obtener píxeles de ambas surfaces
             Uint8* src_pixels = (Uint8*)font_surface->pixels;
             Uint32* dst_pixels = (Uint32*)rgba_surface->pixels;
@@ -27,23 +23,20 @@ void dbg_init(SDL_Renderer *renderer)
             int height = font_surface->h;
 
             // Procesar cada píxel
-            for (int y = 0; y < height; y++)
-            {
-                for (int x = 0; x < width; x++)
-                {
+            for (int y = 0; y < height; y++) {
+                for (int x = 0; x < width; x++) {
                     int byte_index = y * font_surface->pitch + (x / 8);
                     int bit_index = 7 - (x % 8);
 
                     // Extraer bit del bitmap monocromo
                     bool is_white = (src_pixels[byte_index] >> bit_index) & 1;
 
-                    if (is_white) // Fondo blanco original -> transparente
+                    if (is_white)  // Fondo blanco original -> transparente
                     {
-                        dst_pixels[y * width + x] = 0x00000000; // Transparente
-                    }
-                    else // Texto negro original -> blanco opaco
+                        dst_pixels[y * width + x] = 0x00000000;  // Transparente
+                    } else                                       // Texto negro original -> blanco opaco
                     {
-                        dst_pixels[y * width + x] = 0xFFFFFFFF; // Blanco opaco
+                        dst_pixels[y * width + x] = 0xFFFFFFFF;  // Blanco opaco
                     }
                 }
             }
@@ -55,31 +48,24 @@ void dbg_init(SDL_Renderer *renderer)
     }
 
     // Configurar filtro nearest neighbor para píxel perfect del texto
-    if (dbg_tex != nullptr)
-    {
+    if (dbg_tex != nullptr) {
         SDL_SetTextureScaleMode(dbg_tex, SDL_SCALEMODE_NEAREST);
         // Configurar blend mode para transparencia normal
         SDL_SetTextureBlendMode(dbg_tex, SDL_BLENDMODE_BLEND);
     }
 }
 
-void dbg_print(int x, int y, const char *text, Uint8 r, Uint8 g, Uint8 b)
-{
+void dbg_print(int x, int y, const char* text, Uint8 r, Uint8 g, Uint8 b) {
     int cc = 0;
     SDL_SetTextureColorMod(dbg_tex, r, g, b);
     SDL_FRect src = {0, 0, 8, 8};
     SDL_FRect dst = {static_cast<float>(x), static_cast<float>(y), 8, 8};
-    while (text[cc] != 0)
-    {
-        if (text[cc] != 32)
-        {
-            if (text[cc] >= 65)
-            {
+    while (text[cc] != 0) {
+        if (text[cc] != 32) {
+            if (text[cc] >= 65) {
                 src.x = ((text[cc] - 65) % 6) * 8;
                 src.y = ((text[cc] - 65) / 6) * 8;
-            }
-            else
-            {
+            } else {
                 src.x = ((text[cc] - 22) % 6) * 8;
                 src.y = ((text[cc] - 22) / 6) * 8;
             }

source/external/sprite.cpp

@@ -1,4 +1,5 @@
 #include "sprite.h"
+
 #include "texture.h"  // for Texture
 
 // Constructor
@@ -8,33 +9,28 @@ Sprite::Sprite(std::shared_ptr<Texture> texture)
       clip_{0.0f, 0.0f, 0.0f, 0.0f} {}
 
 // Establece la posición del sprite
-void Sprite::setPos(SDL_FPoint pos)
-{
+void Sprite::setPos(SDL_FPoint pos) {
     pos_.x = pos.x;
     pos_.y = pos.y;
 }
 
 // Pinta el sprite
-void Sprite::render()
-{
+void Sprite::render() {
     texture_->render(&clip_, &pos_);
 }
 
 // Establece el rectangulo de la textura que se va a pintar
-void Sprite::setClip(SDL_FRect clip)
-{
+void Sprite::setClip(SDL_FRect clip) {
     clip_ = clip;
 }
 
 // Establece el tamaño del sprite
-void Sprite::setSize(float w, float h)
-{
+void Sprite::setSize(float w, float h) {
     pos_.w = w;
     pos_.h = h;
 }
 
 // Modulación de color
-void Sprite::setColor(int r, int g, int b)
-{
+void Sprite::setColor(int r, int g, int b) {
     texture_->setColor(r, g, b);
 }

source/external/sprite.h

@@ -1,35 +1,35 @@
 #pragma once
 
 #include <SDL3/SDL_rect.h>  // for SDL_FRect, SDL_FPoint
-#include <memory>           // for shared_ptr
+
+#include <memory>  // for shared_ptr
 class Texture;
 
-class Sprite
-{
-private:
-    std::shared_ptr<Texture> texture_; // Textura con los gráficos del sprite
-    SDL_FRect pos_;                    // Posición y tamaño del sprite
-    SDL_FRect clip_;                   // Parte de la textura que se va a dibujar
+class Sprite {
+    private:
+        std::shared_ptr<Texture> texture_;  // Textura con los gráficos del sprite
+        SDL_FRect pos_;                     // Posición y tamaño del sprite
+        SDL_FRect clip_;                    // Parte de la textura que se va a dibujar
 
-public:
-    // Constructor
-    explicit Sprite(std::shared_ptr<Texture> texture);
+    public:
+        // Constructor
+        explicit Sprite(std::shared_ptr<Texture> texture);
 
-    // Destructor
-    ~Sprite() = default;
+        // Destructor
+        ~Sprite() = default;
 
-    // Establece la posición del sprite
-    void setPos(SDL_FPoint pos);
+        // Establece la posición del sprite
+        void setPos(SDL_FPoint pos);
 
-    // Pinta el sprite
-    void render();
+        // Pinta el sprite
+        void render();
 
-    // Establece el rectangulo de la textura que se va a pintar
-    void setClip(SDL_FRect clip);
+        // Establece el rectangulo de la textura que se va a pintar
+        void setClip(SDL_FRect clip);
 
-    // Establece el tamaño del sprite
-    void setSize(float w, float h);
+        // Establece el tamaño del sprite
+        void setSize(float w, float h);
 
-    // Modulación de color
-    void setColor(int r, int g, int b);
+        // Modulación de color
+        void setColor(int r, int g, int b);
 };

source/external/texture.cpp

@@ -1,55 +1,55 @@
 #define STB_IMAGE_IMPLEMENTATION
 #include "texture.h"
+
 #include <SDL3/SDL_error.h>    // Para SDL_GetError
 #include <SDL3/SDL_log.h>      // Para SDL_Log
 #include <SDL3/SDL_pixels.h>   // Para SDL_PixelFormat
 #include <SDL3/SDL_surface.h>  // Para SDL_CreateSurfaceFrom, SDL_DestroySurface
 #include <stdio.h>             // Para NULL
 #include <stdlib.h>            // Para exit
-#include <iostream>            // Para basic_ostream, char_traits, operator<<
-#include <string>              // Para operator<<, string
-#include "stb_image.h"         // Para stbi_failure_reason, stbi_image_free
+
+#include <iostream>  // Para basic_ostream, char_traits, operator<<
+#include <string>    // Para operator<<, string
+
+#include "stb_image.h"  // Para stbi_failure_reason, stbi_image_free
 
 Texture::Texture(SDL_Renderer *renderer)
-    : renderer_(renderer), texture_(nullptr), width_(0), height_(0) {}
+    : renderer_(renderer),
+      texture_(nullptr),
+      width_(0),
+      height_(0) {}
 
 Texture::Texture(SDL_Renderer *renderer, const std::string &file_path)
-    : renderer_(renderer), texture_(nullptr), width_(0), height_(0)
-{
+    : renderer_(renderer),
+      texture_(nullptr),
+      width_(0),
+      height_(0) {
     loadFromFile(file_path);
 }
 
-Texture::~Texture()
-{
+Texture::~Texture() {
     free();
 }
 
 // Carga la imagen desde una ruta especificada
-bool Texture::loadFromFile(const std::string &file_path)
-{
+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;
     int width, height, orig_format;
     unsigned char *data = stbi_load(file_path.c_str(), &width, &height, &orig_format, req_format);
-    if (data == nullptr)
-    {
+    if (data == nullptr) {
         SDL_Log("Error al cargar la imagen: %s", stbi_failure_reason());
         exit(1);
-    }
-    else
-    {
+    } else {
         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 línea
+    if (req_format == STBI_rgb) {
+        pitch = 3 * width;  // 3 bytes por pixel * pixels por línea
         pixel_format = SDL_PIXELFORMAT_RGB24;
-    }
-    else
-    { // STBI_rgb_alpha (RGBA)
+    } else {  // STBI_rgb_alpha (RGBA)
         pitch = 4 * width;
         pixel_format = SDL_PIXELFORMAT_RGBA32;
     }
@@ -62,20 +62,14 @@ bool Texture::loadFromFile(const std::string &file_path)
 
     // 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)
-    {
+    if (loaded_surface == nullptr) {
         std::cout << "No se pudo cargar la imagen " << file_path << std::endl;
-    }
-    else
-    {
+    } else {
         // Crea la textura desde los píxeles de la superficie
         new_texture = SDL_CreateTextureFromSurface(renderer_, loaded_surface);
-        if (new_texture == nullptr)
-        {
+        if (new_texture == nullptr) {
             std::cout << "No se pudo crear la textura desde " << file_path << "! Error de SDL: " << SDL_GetError() << std::endl;
-        }
-        else
-        {
+        } else {
             // Obtiene las dimensiones de la imagen
             width_ = loaded_surface->w;
             height_ = loaded_surface->h;
@@ -95,10 +89,8 @@ bool Texture::loadFromFile(const std::string &file_path)
 }
 
 // Libera la textura si existe
-void Texture::free()
-{
-    if (texture_ != nullptr)
-    {
+void Texture::free() {
+    if (texture_ != nullptr) {
         SDL_DestroyTexture(texture_);
         texture_ = nullptr;
         width_ = 0;
@@ -107,25 +99,21 @@ void Texture::free()
 }
 
 // Renderiza la textura en pantalla
-void Texture::render(SDL_FRect *src, SDL_FRect *dst)
-{
+void Texture::render(SDL_FRect *src, SDL_FRect *dst) {
     SDL_RenderTexture(renderer_, texture_, src, dst);
 }
 
 // Obtiene el ancho de la imagen
-int Texture::getWidth()
-{
+int Texture::getWidth() {
     return width_;
 }
 
 // Obtiene la altura de la imagen
-int Texture::getHeight()
-{
+int Texture::getHeight() {
     return height_;
 }
 
 // Modula el color de la textura
-void Texture::setColor(int r, int g, int b)
-{
+void Texture::setColor(int r, int g, int b) {
     SDL_SetTextureColorMod(texture_, r, g, b);
 }

source/external/texture.h

@@ -2,42 +2,42 @@
 
 #include <SDL3/SDL_rect.h>    // Para SDL_FRect
 #include <SDL3/SDL_render.h>  // Para SDL_Renderer, SDL_Texture
-#include <string>             // Para std::string
 
-class Texture
-{
-private:
-    SDL_Renderer *renderer_;
-    SDL_Texture *texture_;
+#include <string>  // Para std::string
 
-    // Dimensiones de la imagen
-    int width_;
-    int height_;
+class Texture {
+    private:
+        SDL_Renderer *renderer_;
+        SDL_Texture *texture_;
 
-public:
-    // Inicializa las variables
-    explicit Texture(SDL_Renderer *renderer);
-    Texture(SDL_Renderer *renderer, const std::string &file_path);
+        // Dimensiones de la imagen
+        int width_;
+        int height_;
 
-    // Libera la memoria
-    ~Texture();
+    public:
+        // Inicializa las variables
+        explicit Texture(SDL_Renderer *renderer);
+        Texture(SDL_Renderer *renderer, const std::string &file_path);
 
-    // Carga una imagen desde la ruta especificada
-    bool loadFromFile(const std::string &path);
+        // Libera la memoria
+        ~Texture();
 
-    // Libera la textura
-    void free();
+        // Carga una imagen desde la ruta especificada
+        bool loadFromFile(const std::string &path);
 
-    // Renderiza la textura en el punto especificado
-    void render(SDL_FRect *src = nullptr, SDL_FRect *dst = nullptr);
+        // Libera la textura
+        void free();
 
-    // Obtiene las dimensiones de la imagen
-    int getWidth();
-    int getHeight();
+        // Renderiza la textura en el punto especificado
+        void render(SDL_FRect *src = nullptr, SDL_FRect *dst = nullptr);
 
-    // Modula el color de la textura
-    void setColor(int r, int g, int b);
+        // Obtiene las dimensiones de la imagen
+        int getWidth();
+        int getHeight();
 
-    // Getter para batch rendering
-    SDL_Texture* getSDLTexture() const { return texture_; }
+        // Modula el color de la textura
+        void setColor(int r, int g, int b);
+
+        // Getter para batch rendering
+        SDL_Texture *getSDLTexture() const { return texture_; }
 };