Refactorizar estilo del proyecto: .h → .hpp, #pragma once, includes desde raíz

Modernizar convenciones de código C++ aplicando las siguientes directivas:

## Cambios principales

**1. Renombrar headers (.h → .hpp)**
- 36 archivos renombrados a extensión .hpp (estándar C++)
- Mantenidos como .h: stb_image.h, stb_image_resize2.h (librerías C externas)

**2. Modernizar include guards (#ifndef → #pragma once)**
- resource_manager.hpp: #ifndef RESOURCE_MANAGER_H → #pragma once
- resource_pack.hpp: #ifndef RESOURCE_PACK_H → #pragma once
- spatial_grid.hpp: #ifndef SPATIAL_GRID_H → #pragma once

**3. Sistema de includes desde raíz del proyecto**
- CMakeLists.txt: añadido include_directories(${CMAKE_SOURCE_DIR}/source)
- Eliminadas rutas relativas (../) en todos los includes
- Includes ahora usan rutas absolutas desde source/

**Antes:**
```cpp
#include "../defines.h"
#include "../text/textrenderer.h"
```

**Ahora:**
```cpp
#include "defines.hpp"
#include "text/textrenderer.hpp"
```

## Archivos afectados

- 1 archivo CMakeLists.txt modificado
- 36 archivos renombrados (.h → .hpp)
- 32 archivos .cpp actualizados (includes)
- 36 archivos .hpp actualizados (includes + guards)
- 1 archivo tools/ actualizado

**Total: 70 archivos modificados**

## Verificación

✅ Proyecto compila sin errores
✅ Todas las rutas de includes correctas
✅ Include guards modernizados
✅ Librerías externas C mantienen extensión .h

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

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

source/boids_mgr/boid_manager.hpp

@@ -0,0 +1,126 @@
+#pragma once
+
+#include <cstddef>  // for size_t
+
+#include "defines.hpp"       // for SimulationMode, AppMode
+#include "spatial_grid.hpp"  // for SpatialGrid
+
+// Forward declarations
+class Engine;
+class SceneManager;
+class UIManager;
+class StateManager;
+class Ball;
+
+/**
+ * @class BoidManager
+ * @brief Gestiona el comportamiento de enjambre (boids)
+ *
+ * Responsabilidad única: Implementación de algoritmo de boids (Reynolds 1987)
+ *
+ * Características:
+ * - Separación: Evitar colisiones con vecinos cercanos
+ * - Alineación: Seguir dirección promedio del grupo
+ * - Cohesión: Moverse hacia el centro de masa del grupo
+ * - Comportamiento emergente sin control centralizado
+ * - Física de steering behavior (velocidad limitada)
+ */
+class BoidManager {
+    public:
+        /**
+         * @brief Constructor
+         */
+        BoidManager();
+
+        /**
+         * @brief Destructor
+         */
+        ~BoidManager();
+
+        /**
+         * @brief Inicializa el BoidManager con referencias a componentes del Engine
+         * @param engine Puntero al Engine (para acceso a recursos)
+         * @param scene_mgr Puntero a SceneManager (acceso a bolas)
+         * @param ui_mgr Puntero a UIManager (notificaciones)
+         * @param state_mgr Puntero a StateManager (estados de aplicación)
+         * @param screen_width Ancho de pantalla actual
+         * @param screen_height Alto de pantalla actual
+         */
+        void initialize(Engine* engine, SceneManager* scene_mgr, UIManager* ui_mgr,
+                        StateManager* state_mgr, int screen_width, int screen_height);
+
+        /**
+         * @brief Actualiza el tamaño de pantalla (llamado en resize/fullscreen)
+         * @param width Nuevo ancho de pantalla
+         * @param height Nuevo alto de pantalla
+         */
+        void updateScreenSize(int width, int height);
+
+        /**
+         * @brief Activa el modo boids
+         */
+        void activateBoids();
+
+        /**
+         * @brief Desactiva el modo boids (vuelve a física normal)
+         * @param force_gravity_on Si debe forzar gravedad ON al salir
+         */
+        void deactivateBoids(bool force_gravity_on = true);
+
+        /**
+         * @brief Toggle entre modo boids y modo física
+         * @param force_gravity_on Si debe forzar gravedad ON al salir de boids
+         */
+        void toggleBoidsMode(bool force_gravity_on = true);
+
+        /**
+         * @brief Actualiza el comportamiento de todas las bolas como boids
+         * @param delta_time Delta time para física
+         */
+        void update(float delta_time);
+
+        /**
+         * @brief Verifica si el modo boids está activo
+         * @return true si modo boids está activo
+         */
+        bool isBoidsActive() const { return boids_active_; }
+
+    private:
+        // Referencias a componentes del Engine
+        Engine* engine_;
+        SceneManager* scene_mgr_;
+        UIManager* ui_mgr_;
+        StateManager* state_mgr_;
+
+        // Tamaño de pantalla
+        int screen_width_;
+        int screen_height_;
+
+        // Estado del modo boids
+        bool boids_active_;
+
+        // Spatial Hash Grid para optimización O(n²) → O(n)
+        // FASE 2: Grid reutilizable para búsquedas de vecinos
+        SpatialGrid spatial_grid_;
+
+        // === Parámetros ajustables en runtime (inicializados con valores de defines.h) ===
+        // Permite modificar comportamiento sin recompilar (para tweaking/debug visual)
+        float separation_radius_;     // Radio de separación (evitar colisiones)
+        float alignment_radius_;      // Radio de alineación (matching de velocidad)
+        float cohesion_radius_;       // Radio de cohesión (centro de masa)
+        float separation_weight_;     // Peso fuerza de separación (aceleración px/s²)
+        float alignment_weight_;      // Peso fuerza de alineación (steering proporcional)
+        float cohesion_weight_;       // Peso fuerza de cohesión (aceleración px/s²)
+        float max_speed_;             // Velocidad máxima (px/s)
+        float min_speed_;             // Velocidad mínima (px/s)
+        float max_force_;             // Fuerza máxima de steering (px/s)
+        float boundary_margin_;       // Margen para repulsión de bordes (px)
+        float boundary_weight_;       // Peso fuerza de repulsión de bordes (aceleración px/s²)
+
+        // Métodos privados para las reglas de Reynolds
+        void applySeparation(Ball* boid, float delta_time);
+        void applyAlignment(Ball* boid, float delta_time);
+        void applyCohesion(Ball* boid, float delta_time);
+        void applyBoundaries(Ball* boid);  // Repulsión de bordes (ya no wrapping)
+        void limitSpeed(Ball* boid);       // Limitar velocidad máxima
+};