Implementar sistema de masa/peso individual por pelota

✨ Nueva característica:
- Cada pelota tiene un factor de masa único que afecta la gravedad
- Simula pelotas de diferente peso/densidad para física más realista

🔧 Implementación:
- GRAVITY_MASS_MIN = 0.7f (pelotas ligeras - 70% gravedad)
- GRAVITY_MASS_MAX = 1.3f (pelotas pesadas - 130% gravedad)
- Factor aleatorio generado por pelota en initBalls()
- Gravedad efectiva = gravity_force × mass_factor × deltaTime

📊 Comportamiento:
- Pelotas ligeras (0.7): Caen 30% más lento, efecto "flotante"
- Pelotas pesadas (1.3): Caen 30% más rápido, más "densas"
- Variabilidad continua entre 0.7-1.3 para cada pelota

🎯 Resultado visual:
- FIN del problema: "todas llegan al mismo tiempo"
- Ahora las pelotas llegan escalonadas al cambiar gravedad
- Física más realista y visualmente interesante

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

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

source/ball.cpp

@@ -22,7 +22,7 @@ float generateLateralLoss() {
 }
 
 // Constructor
-Ball::Ball(float x, float vx, float vy, Color color, std::shared_ptr<Texture> texture, GravityDirection gravity_dir)
+Ball::Ball(float x, float vx, float vy, Color color, std::shared_ptr<Texture> texture, GravityDirection gravity_dir, float mass_factor)
     : sprite_(std::make_unique<Sprite>(texture)),
       pos_({x, 0.0f, BALL_SIZE, BALL_SIZE}) {
     // Convertir velocidades de píxeles/frame a píxeles/segundo (multiplicar por 60)
@@ -34,6 +34,7 @@ Ball::Ball(float x, float vx, float vy, Color color, std::shared_ptr<Texture> te
     color_ = color;
     // Convertir gravedad de píxeles/frame² a píxeles/segundo² (multiplicar por 60²)
     gravity_force_ = GRAVITY_FORCE * 60.0f * 60.0f;
+    gravity_mass_factor_ = mass_factor;  // Factor de masa individual para esta pelota
     gravity_direction_ = gravity_dir;
     on_surface_ = false;
     stopped_ = false;
@@ -49,18 +50,20 @@ void Ball::update(float deltaTime) {
 
     // Aplica la gravedad según la dirección (píxeles/segundo²)
     if (!on_surface_) {
+        // Aplicar gravedad multiplicada por factor de masa individual
+        float effective_gravity = gravity_force_ * gravity_mass_factor_ * deltaTime;
         switch (gravity_direction_) {
             case GravityDirection::DOWN:
-                vy_ += gravity_force_ * deltaTime;
+                vy_ += effective_gravity;
                 break;
             case GravityDirection::UP:
-                vy_ -= gravity_force_ * deltaTime;
+                vy_ -= effective_gravity;
                 break;
             case GravityDirection::LEFT:
-                vx_ -= gravity_force_ * deltaTime;
+                vx_ -= effective_gravity;
                 break;
             case GravityDirection::RIGHT:
-                vx_ += gravity_force_ * deltaTime;
+                vx_ += effective_gravity;
                 break;
         }
     }

source/ball.h

@@ -13,7 +13,8 @@ class Ball {
         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
-        float gravity_force_;             // Gravedad
+        float gravity_force_;             // Gravedad base
+        float gravity_mass_factor_;       // Factor de masa individual (0.7-1.3, afecta gravedad)
         GravityDirection gravity_direction_; // Direcci\u00f3n de la gravedad
         Color color_;                     // Color de la pelota
         bool on_surface_;                 // Indica si la pelota est\u00e1 en la superficie (suelo/techo/pared)
@@ -22,7 +23,7 @@ class Ball {
 
     public:
         // Constructor
-        Ball(float x, float vx, float vy, Color color, std::shared_ptr<Texture> texture, GravityDirection gravity_dir = GravityDirection::DOWN);
+        Ball(float x, float vx, float vy, Color color, std::shared_ptr<Texture> texture, GravityDirection gravity_dir = GravityDirection::DOWN, float mass_factor = 1.0f);
 
         // Destructor
         ~Ball() = default;

source/defines.h

@@ -16,6 +16,10 @@ constexpr float BASE_BOUNCE_COEFFICIENT = 0.75f;   // Coeficiente base IGUAL par
 constexpr float BOUNCE_RANDOM_LOSS_PERCENT = 0.1f; // 0-10% pérdida adicional aleatoria en cada rebote
 constexpr float LATERAL_LOSS_PERCENT = 0.02f;      // ±2% pérdida lateral en rebotes
 
+// Configuración de masa/peso individual por pelota
+constexpr float GRAVITY_MASS_MIN = 0.7f;           // Factor mínimo de masa (pelota ligera - 70% gravedad)
+constexpr float GRAVITY_MASS_MAX = 1.3f;           // Factor máximo de masa (pelota pesada - 130% gravedad)
+
 struct Color {
         int r, g, b;
 };

source/engine.cpp

@@ -350,7 +350,9 @@ void Engine::initBalls(int value) {
         const Color COLOR = {theme.ball_colors[color_index][0],
             theme.ball_colors[color_index][1],
             theme.ball_colors[color_index][2]};
-        balls_.emplace_back(std::make_unique<Ball>(X, VX, VY, COLOR, texture_, current_gravity_));
+        // Generar factor de masa aleatorio (0.7 = ligera, 1.3 = pesada)
+        float mass_factor = GRAVITY_MASS_MIN + (rand() % 1000) / 1000.0f * (GRAVITY_MASS_MAX - GRAVITY_MASS_MIN);
+        balls_.emplace_back(std::make_unique<Ball>(X, VX, VY, COLOR, texture_, current_gravity_, mass_factor));
     }
     setText();  // Actualiza el texto
 }