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

@@ -1,14 +1,16 @@
 #include "ball.h"
+
 #include <stdlib.h>  // for rand
+
 #include <cmath>  // for fabs
+
 #include "defines.h"  // for BALL_SIZE, Color, SCREEN_HEIGHT, GRAVITY_FORCE
 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}) {
-{
     // Convertir velocidades de píxeles/frame a píxeles/segundo (multiplicar por 60)
     vx_ = vx * 60.0f;
     vy_ = vy * 60.0f;
@@ -24,55 +26,45 @@ Ball::Ball(float x, float vx, float vy, Color color, std::shared_ptr<Texture> te
 }
 
 // Actualiza la lógica de la clase
-void Ball::update(float deltaTime)
+void Ball::update(float deltaTime) {
-{
+    if (stopped_) {
-    if (stopped_)
-    {
         return;
     }
 
     // Aplica la gravedad a la velocidad (píxeles/segundo²)
-    if (!on_floor_)
+    if (!on_floor_) {
-    {
         vy_ += gravity_force_ * deltaTime;
     }
 
     // Actualiza la posición en función de la velocidad (píxeles/segundo)
     pos_.x += vx_ * deltaTime;
-    if (!on_floor_)
+    if (!on_floor_) {
-    {
         pos_.y += vy_ * deltaTime;
-    }
+    } else {
-    else
-    {
         // Si está en el suelo, mantenerla ahí
         pos_.y = SCREEN_HEIGHT - pos_.h;
     }
 
     // Comprueba las colisiones con el lateral izquierdo
-    if (pos_.x < 0)
+    if (pos_.x < 0) {
-    {
         pos_.x = 0;
         vx_ = -vx_;
     }
 
     // Comprueba las colisiones con el lateral derecho
-    if (pos_.x + pos_.w > SCREEN_WIDTH)
+    if (pos_.x + pos_.w > SCREEN_WIDTH) {
-    {
         pos_.x = SCREEN_WIDTH - pos_.w;
         vx_ = -vx_;
     }
 
     // Comprueba las colisiones con la parte superior
-    if (pos_.y < 0)
+    if (pos_.y < 0) {
-    {
         pos_.y = 0;
         vy_ = -vy_;
     }
 
     // Comprueba las colisiones con la parte inferior
-    if (pos_.y + pos_.h > SCREEN_HEIGHT)
+    if (pos_.y + pos_.h > SCREEN_HEIGHT) {
-    {
         pos_.y = SCREEN_HEIGHT - pos_.h;
         vy_ = -vy_ * loss_;
         if (std::fabs(vy_) < 6.0f)  // Convertir 0.1f frame-based a 6.0f time-based
@@ -83,8 +75,7 @@ void Ball::update(float deltaTime)
     }
 
     // Aplica rozamiento al rodar por el suelo
-    if (on_floor_)
+    if (on_floor_) {
-    {
         // Convertir rozamiento de frame-based a time-based
         // 0.97f por frame equivale a pow(0.97f, 60 * deltaTime)
         float friction_factor = pow(0.97f, 60.0f * deltaTime);
@@ -103,17 +94,14 @@ void Ball::update(float deltaTime)
 }
 
 // Pinta la clase
-void Ball::render()
+void Ball::render() {
-{
     sprite_->setColor(color_.r, color_.g, color_.b);
     sprite_->render();
 }
 
 // Modifica la velocidad (convierte de frame-based a time-based)
-void Ball::modVel(float vx, float vy)
+void Ball::modVel(float vx, float vy) {
-{
+    if (stopped_) {
-    if (stopped_)
-    {
         vx_ = vx_ + (vx * 60.0f);  // Convertir a píxeles/segundo
     }
     vy_ = vy_ + (vy * 60.0f);  // Convertir a píxeles/segundo
@@ -122,7 +110,6 @@ void Ball::modVel(float vx, float vy)
 }
 
 // Cambia la gravedad (usa la versión convertida)
-void Ball::switchGravity()
+void Ball::switchGravity() {
-{
     gravity_force_ = gravity_force_ == 0.0f ? (GRAVITY_FORCE * 60.0f * 60.0f) : 0.0f;
 }

source/ball.h

@@ -1,14 +1,15 @@
 #pragma once
 
 #include <SDL3/SDL_rect.h>  // for SDL_FRect
+
 #include <memory>  // for shared_ptr, unique_ptr
+
 #include "defines.h"          // for Color
 #include "external/sprite.h"  // for Sprite
 class Texture;
 
-class Ball
+class Ball {
-{
+    private:
-private:
         std::unique_ptr<Sprite> sprite_;  // Sprite para pintar la clase
         SDL_FRect pos_;                   // Posición y tamaño de la pelota
         float vx_, vy_;                   // Velocidad
@@ -18,7 +19,7 @@ private:
         bool stopped_;                    // Indica si la pelota ha terminado de moverse;
         float loss_;                      // Coeficiente de rebote. Pérdida de energía en cada rebote
 
-public:
+    public:
         // Constructor
         Ball(float x, float vx, float vy, Color color, std::shared_ptr<Texture> texture);
 

source/defines.h

@@ -11,7 +11,6 @@ constexpr float GRAVITY_FORCE = 0.2f;
 // DEMO_SPEED eliminado - ya no se usa con delta time
 constexpr Uint64 TEXT_DURATION = 2000;
 
-struct Color
+struct Color {
-{
         int r, g, b;
 };

source/external/dbgtxt.h

@@ -1,24 +1,20 @@
 #pragma once
 
-namespace
+namespace {
-{
+SDL_Texture* dbg_tex = nullptr;
-    SDL_Texture *dbg_tex = nullptr;
+SDL_Renderer* dbg_ren = 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,10 +23,8 @@ void dbg_init(SDL_Renderer *renderer)
             int height = font_surface->h;
 
             // Procesar cada píxel
-            for (int y = 0; y < height; y++)
+            for (int y = 0; y < height; y++) {
-            {
+                for (int x = 0; x < width; x++) {
-                for (int x = 0; x < width; x++)
-                {
                     int byte_index = y * font_surface->pitch + (x / 8);
                     int bit_index = 7 - (x % 8);
 
@@ -40,8 +34,7 @@ void dbg_init(SDL_Renderer *renderer)
                     if (is_white)  // Fondo blanco original -> transparente
                     {
                         dst_pixels[y * width + x] = 0x00000000;  // Transparente
-                    }
+                    } else                                       // Texto negro original -> blanco opaco
-                    else // Texto negro original -> 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)
+    while (text[cc] != 0) {
-    {
+        if (text[cc] != 32) {
-        if (text[cc] != 32)
+            if (text[cc] >= 65) {
-        {
-            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,17 +1,17 @@
 #pragma once
 
 #include <SDL3/SDL_rect.h>  // for SDL_FRect, SDL_FPoint
+
 #include <memory>  // for shared_ptr
 class Texture;
 
-class Sprite
+class Sprite {
-{
+    private:
-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:
+    public:
         // Constructor
         explicit Sprite(std::shared_ptr<Texture> texture);
 

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
 
 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)
+    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()
+void Texture::free() {
-{
+    if (texture_ != nullptr) {
-    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,11 +2,11 @@
 
 #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
+class Texture {
-{
+    private:
-private:
         SDL_Renderer *renderer_;
         SDL_Texture *texture_;
 
@@ -14,7 +14,7 @@ private:
         int width_;
         int height_;
 
-public:
+    public:
         // Inicializa las variables
         explicit Texture(SDL_Renderer *renderer);
         Texture(SDL_Renderer *renderer, const std::string &file_path);
@@ -39,5 +39,5 @@ public:
         void setColor(int r, int g, int b);
 
         // Getter para batch rendering
-    SDL_Texture* getSDLTexture() const { return texture_; }
+        SDL_Texture *getSDLTexture() const { return texture_; }
 };

source/main.cpp

@@ -6,6 +6,7 @@
 #include <SDL3/SDL_stdinc.h>   // for Uint64
 #include <SDL3/SDL_timer.h>    // for SDL_GetTicks
 #include <SDL3/SDL_video.h>    // for SDL_CreateWindow, SDL_DestroyWindow
+
 #include <array>     // for array
 #include <cstdlib>   // for rand, srand
 #include <ctime>     // for time
@@ -13,9 +14,10 @@
 #include <memory>    // for unique_ptr, shared_ptr, make_shared
 #include <string>    // for operator+, string, to_string
 #include <vector>    // for vector
+
 #include "ball.h"              // for Ball
-#include "external/dbgtxt.h"            // for dbg_init, dbg_print
 #include "defines.h"           // for SCREEN_WIDTH, SCREEN_HEIGHT, WINDOW_SIZE
+#include "external/dbgtxt.h"   // for dbg_init, dbg_print
 #include "external/texture.h"  // for Texture
 
 // Variables globales
@@ -72,47 +74,41 @@ struct ThemeColors {
 
 ThemeColors themes[4] = {
     // SUNSET: Naranjas, rojos, amarillos, rosas
-    {
+    {180.0f / 255.0f, 140.0f / 255.0f, 100.0f / 255.0f,  // Fondo superior (naranja suave)
-        180.0f/255.0f, 140.0f/255.0f, 100.0f/255.0f,  // Fondo superior (naranja suave)
+        40.0f / 255.0f,
-        40.0f/255.0f, 20.0f/255.0f, 60.0f/255.0f,     // Fondo inferior (púrpura oscuro)
+        20.0f / 255.0f,
-        {{255, 140, 0}, {255, 69, 0}, {255, 215, 0}, {255, 20, 147},  // Bolas sunset
+        60.0f / 255.0f,  // Fondo inferior (púrpura oscuro)
-         {255, 99, 71}, {255, 165, 0}, {255, 192, 203}, {220, 20, 60}}
+        {{255, 140, 0}, {255, 69, 0}, {255, 215, 0}, {255, 20, 147}, {255, 99, 71}, {255, 165, 0}, {255, 192, 203}, {220, 20, 60}}},
-    },
     // OCEAN: Azules, cianes, verdes agua, blancos
-    {
+    {100.0f / 255.0f, 150.0f / 255.0f, 200.0f / 255.0f,  // Fondo superior (azul cielo)
-        100.0f/255.0f, 150.0f/255.0f, 200.0f/255.0f,  // Fondo superior (azul cielo)
+        20.0f / 255.0f,
-        20.0f/255.0f, 40.0f/255.0f, 80.0f/255.0f,     // Fondo inferior (azul marino)
+        40.0f / 255.0f,
-        {{0, 191, 255}, {0, 255, 255}, {32, 178, 170}, {176, 224, 230},  // Bolas ocean
+        80.0f / 255.0f,  // Fondo inferior (azul marino)
-         {70, 130, 180}, {0, 206, 209}, {240, 248, 255}, {64, 224, 208}}
+        {{0, 191, 255}, {0, 255, 255}, {32, 178, 170}, {176, 224, 230}, {70, 130, 180}, {0, 206, 209}, {240, 248, 255}, {64, 224, 208}}},
-    },
     // NEON: Cian, magenta, verde lima, amarillo vibrante
-    {
+    {20.0f / 255.0f, 20.0f / 255.0f, 40.0f / 255.0f,  // Fondo superior (negro azulado)
-        20.0f/255.0f, 20.0f/255.0f, 40.0f/255.0f,     // Fondo superior (negro azulado)
+        0.0f / 255.0f,
-        0.0f/255.0f, 0.0f/255.0f, 0.0f/255.0f,        // Fondo inferior (negro)
+        0.0f / 255.0f,
-        {{0, 255, 255}, {255, 0, 255}, {50, 205, 50}, {255, 255, 0},    // Bolas neon
+        0.0f / 255.0f,  // Fondo inferior (negro)
-         {255, 20, 147}, {0, 255, 127}, {138, 43, 226}, {255, 69, 0}}
+        {{0, 255, 255}, {255, 0, 255}, {50, 205, 50}, {255, 255, 0}, {255, 20, 147}, {0, 255, 127}, {138, 43, 226}, {255, 69, 0}}},
-    },
     // FOREST: Verdes, marrones, amarillos otoño
-    {
+    {144.0f / 255.0f, 238.0f / 255.0f, 144.0f / 255.0f,  // Fondo superior (verde claro)
-        144.0f/255.0f, 238.0f/255.0f, 144.0f/255.0f,  // Fondo superior (verde claro)
+        101.0f / 255.0f,
-        101.0f/255.0f, 67.0f/255.0f, 33.0f/255.0f,    // Fondo inferior (marrón tierra)
+        67.0f / 255.0f,
-        {{34, 139, 34}, {107, 142, 35}, {154, 205, 50}, {255, 215, 0},   // Bolas forest
+        33.0f / 255.0f,  // Fondo inferior (marrón tierra)
-         {210, 180, 140}, {160, 82, 45}, {218, 165, 32}, {50, 205, 50}}
+        {{34, 139, 34}, {107, 142, 35}, {154, 205, 50}, {255, 215, 0}, {210, 180, 140}, {160, 82, 45}, {218, 165, 32}, {50, 205, 50}}}};
-    }
-};
 
 // Variables para Batch Rendering
 std::vector<SDL_Vertex> batch_vertices;
 std::vector<int> batch_indices;
 
 // Función para renderizar fondo degradado
-void renderGradientBackground()
+void renderGradientBackground() {
-{
     // Crear quad de pantalla completa con degradado
     SDL_Vertex bg_vertices[4];
 
     // Obtener colores del tema actual
-    ThemeColors& theme = themes[static_cast<int>(current_theme)];
+    ThemeColors &theme = themes[static_cast<int>(current_theme)];
 
     float top_r = theme.bg_top_r;
     float top_g = theme.bg_top_g;
@@ -150,8 +146,7 @@ void renderGradientBackground()
 }
 
 // Función para añadir un sprite al batch
-void addSpriteToBatch(float x, float y, float w, float h, Uint8 r, Uint8 g, Uint8 b)
+void addSpriteToBatch(float x, float y, float w, float h, Uint8 r, Uint8 g, Uint8 b) {
-{
     int vertex_index = static_cast<int>(batch_vertices.size());
 
     // Crear 4 vértices para el quad (2 triángulos)
@@ -200,8 +195,7 @@ void addSpriteToBatch(float x, float y, float w, float h, Uint8 r, Uint8 g, Uint
 }
 
 // Establece el texto en pantalla mostrando el número de bolas actuales
-void setText()
+void setText() {
-{
     const std::string TEXT_NUMBER = test[scenario] == 1 ? " PELOTA" : " PELOTAS";
     text = std::to_string(test[scenario]) + TEXT_NUMBER;
     const int TEXT_SIZE = static_cast<int>(text.size() * 8);
@@ -211,17 +205,15 @@ void setText()
 }
 
 // Inicializa las bolas según el escenario seleccionado
-void initBalls(int value)
+void initBalls(int value) {
-{
     balls.clear();
-	for (int i = 0; i < test.at(value); ++i)
+    for (int i = 0; i < test.at(value); ++i) {
-	{
         const int SIGN = ((rand() % 2) * 2) - 1;                             // Genera un signo aleatorio (+ o -)
         const float X = (rand() % (SCREEN_WIDTH / 2)) + (SCREEN_WIDTH / 4);  // Posición inicial en X
         const float VX = (((rand() % 20) + 10) * 0.1f) * SIGN;               // Velocidad en X
         const float VY = ((rand() % 60) - 30) * 0.1f;                        // Velocidad en Y
         // Seleccionar color de la paleta del tema actual
-		ThemeColors& theme = themes[static_cast<int>(current_theme)];
+        ThemeColors &theme = themes[static_cast<int>(current_theme)];
         int color_index = rand() % 8;  // 8 colores por tema
         const Color COLOR = {theme.ball_colors[color_index][0],
             theme.ball_colors[color_index][1],
@@ -232,10 +224,8 @@ void initBalls(int value)
 }
 
 // Aumenta la velocidad vertical de las bolas "hacia arriba"
-void pushUpBalls()
+void pushUpBalls() {
-{
+    for (auto &ball : balls) {
-	for (auto &ball : balls)
-	{
         const int SIGNO = ((rand() % 2) * 2) - 1;
         const float VX = (((rand() % 20) + 10) * 0.1f) * SIGNO;
         const float VY = ((rand() % 40) * 0.1f) + 5;
@@ -244,17 +234,14 @@ void pushUpBalls()
 }
 
 // Cambia la gravedad de todas las bolas
-void switchBallsGravity()
+void switchBallsGravity() {
-{
+    for (auto &ball : balls) {
-	for (auto &ball : balls)
-	{
         ball->switchGravity();
     }
 }
 
 // Alterna el estado del V-Sync
-void toggleVSync()
+void toggleVSync() {
-{
     vsync_enabled = !vsync_enabled;
     vsync_text = vsync_enabled ? "VSYNC ON" : "VSYNC OFF";
 
@@ -263,13 +250,11 @@ void toggleVSync()
 }
 
 // Calcula el delta time entre frames
-void calculateDeltaTime()
+void calculateDeltaTime() {
-{
     Uint64 current_time = SDL_GetTicks();
 
     // En el primer frame, inicializar el tiempo anterior
-	if (last_frame_time == 0)
+    if (last_frame_time == 0) {
-	{
         last_frame_time = current_time;
         delta_time = 1.0f / 60.0f;  // Asumir 60 FPS para el primer frame
         return;
@@ -287,36 +272,26 @@ void calculateDeltaTime()
 }
 
 // Inicializa SDL y configura los componentes principales
-bool init()
+bool init() {
-{
     bool success = true;
 
     // Inicializa SDL
-	if (!SDL_Init(SDL_INIT_VIDEO))
+    if (!SDL_Init(SDL_INIT_VIDEO)) {
-	{
         std::cout << "¡SDL no se pudo inicializar! Error de SDL: " << SDL_GetError() << std::endl;
         success = false;
-	}
+    } else {
-	else
-	{
         // Crear ventana principal
         window = SDL_CreateWindow(WINDOW_CAPTION, SCREEN_WIDTH * WINDOW_SIZE, SCREEN_HEIGHT * WINDOW_SIZE, SDL_WINDOW_OPENGL);
-		if (window == nullptr)
+        if (window == nullptr) {
-		{
             std::cout << "¡No se pudo crear la ventana! Error de SDL: " << SDL_GetError() << std::endl;
             success = false;
-		}
+        } else {
-		else
-		{
             // Crear renderizador
             renderer = SDL_CreateRenderer(window, nullptr);
-			if (renderer == nullptr)
+            if (renderer == nullptr) {
-			{
                 std::cout << "¡No se pudo crear el renderizador! Error de SDL: " << SDL_GetError() << std::endl;
                 success = false;
-			}
+            } else {
-			else
-			{
                 // Establecer color inicial del renderizador
                 SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0xFF, 0xFF);
 
@@ -340,31 +315,25 @@ bool init()
 }
 
 // Limpia todos los recursos y cierra SDL
-void close()
+void close() {
-{
     SDL_DestroyRenderer(renderer);
     SDL_DestroyWindow(window);
     SDL_Quit();
 }
 
 // Verifica los eventos en la cola
-void checkEvents()
+void checkEvents() {
-{
     SDL_Event event;
-	while (SDL_PollEvent(&event) != 0)
+    while (SDL_PollEvent(&event) != 0) {
-	{
         // Evento de salida
-		if (event.type == SDL_EVENT_QUIT)
+        if (event.type == SDL_EVENT_QUIT) {
-		{
             should_exit = true;
             break;
         }
 
         // Procesar eventos de teclado
-		if (event.type == SDL_EVENT_KEY_DOWN && event.key.repeat == 0)
+        if (event.type == SDL_EVENT_KEY_DOWN && event.key.repeat == 0) {
-		{
+            switch (event.key.key) {
-			switch (event.key.key)
-			{
                 case SDLK_ESCAPE:
                     should_exit = true;
                     break;
@@ -456,8 +425,7 @@ void checkEvents()
 }
 
 // Actualiza la lógica del juego
-void update()
+void update() {
-{
     // Calcular FPS
     fps_frame_count++;
     Uint64 current_time = SDL_GetTicks();
@@ -470,21 +438,18 @@ void update()
     }
 
     // ¡DELTA TIME! Actualizar física siempre, usando tiempo transcurrido
-	for (auto &ball : balls)
+    for (auto &ball : balls) {
-	{
         ball->update(delta_time);  // Pasar delta time a cada pelota
     }
 
     // Actualizar texto (sin cambios en la lógica)
-	if (show_text)
+    if (show_text) {
-	{
         show_text = !(SDL_GetTicks() - text_init_time > TEXT_DURATION);
     }
 }
 
 // Renderiza el contenido en la pantalla
-void render()
+void render() {
-{
     // Renderizar fondo degradado en lugar de color sólido
     renderGradientBackground();
 
@@ -493,8 +458,7 @@ void render()
     batch_indices.clear();
 
     // Recopilar datos de todas las bolas para batch rendering
-	for (auto &ball : balls)
+    for (auto &ball : balls) {
-	{
         // En lugar de ball->render(), obtener datos para batch
         SDL_FRect pos = ball->getPosition();
         Color color = ball->getColor();
@@ -502,15 +466,11 @@ void render()
     }
 
     // Renderizar todas las bolas en una sola llamada
-	if (!batch_vertices.empty())
+    if (!batch_vertices.empty()) {
-	{
+        SDL_RenderGeometry(renderer, texture->getSDLTexture(), batch_vertices.data(), static_cast<int>(batch_vertices.size()), batch_indices.data(), static_cast<int>(batch_indices.size()));
-		SDL_RenderGeometry(renderer, texture->getSDLTexture(),
-		                   batch_vertices.data(), static_cast<int>(batch_vertices.size()),
-		                   batch_indices.data(), static_cast<int>(batch_indices.size()));
     }
 
-	if (show_text)
+    if (show_text) {
-	{
         dbg_print(text_pos, 8, text.c_str(), 255, 255, 255);
 
         // Mostrar nombre del tema en castellano debajo del número de pelotas
@@ -527,15 +487,11 @@ void render()
             {100, 255, 100}  // BOSQUE: Verde natural
         };
         int theme_idx = static_cast<int>(current_theme);
-		dbg_print(theme_x, 24, theme_name.c_str(),
+        dbg_print(theme_x, 24, theme_name.c_str(), theme_colors[theme_idx][0], theme_colors[theme_idx][1], theme_colors[theme_idx][2]);
-		         theme_colors[theme_idx][0],
-		         theme_colors[theme_idx][1],
-		         theme_colors[theme_idx][2]);
     }
 
     // Debug display (solo si está activado con tecla H)
-	if (show_debug)
+    if (show_debug) {
-	{
         // Mostrar contador de FPS en esquina superior derecha
         int fps_text_width = static_cast<int>(fps_text.length() * 8);  // 8 píxeles por carácter
         int fps_x = SCREEN_WIDTH - fps_text_width - 8;                 // 8 píxeles de margen
@@ -545,8 +501,7 @@ void render()
         dbg_print(8, 8, vsync_text.c_str(), 0, 255, 255);  // Cian para distinguir
 
         // Debug: Mostrar valores de la primera pelota (si existe)
-		if (!balls.empty())
+        if (!balls.empty()) {
-		{
             // Línea 1: Gravedad (solo números enteros)
             int grav_int = static_cast<int>(balls[0]->getGravityForce());
             std::string grav_text = "GRAV " + std::to_string(grav_int);
@@ -572,16 +527,13 @@ void render()
 }
 
 // Función principal
-int main(int argc, char *args[])
+int main(int argc, char *args[]) {
-{
+    if (!init()) {
-	if (!init())
-	{
         std::cout << "Ocurrió un error durante la inicialización." << std::endl;
         return 1;
     }
 
-	while (!should_exit)
+    while (!should_exit) {
-	{
         // 1. Calcular delta time antes de actualizar la lógica
         calculateDeltaTime();