Fase 3: Refactorización de Room - Extracción del sistema de renderizado de tilemap

## Cambios principales

### Nuevo componente: TilemapRenderer
- **tilemap_renderer.hpp/cpp**: Nueva clase que encapsula el renderizado del mapa de tiles
- Responsabilidades extraídas de Room:
  - Renderizado del tilemap estático
  - Gestión de tiles animados (conveyor belts)
  - Actualización de animaciones basadas en tiempo
  - Debug visualization de colisiones (en modo DEBUG)
  - Gestión de map_surface y time_accumulator

### Modificaciones en Room
- **room.hpp**:
  - Añadido TilemapRenderer como miembro (unique_ptr)
  - Removida estructura AnimatedTile (ahora privada en TilemapRenderer)
  - Removidos: map_surface_, animated_tiles_, time_accumulator_, CONVEYOR_FRAME_DURATION
  - Removidos 4 métodos privados de renderizado: fillMapTexture, setAnimatedTiles, updateAnimatedTiles, renderAnimatedTiles

- **room.cpp**:
  - Constructor: Inicializa TilemapRenderer con tile_map, tile_set_width, surface, bg_color, conveyor_belt_direction
  - Constructor: Llama a tilemap_renderer_->initialize(collision_map_)
  - Delegación: renderMap() llama a tilemap_renderer_->render()
  - Delegación: update() llama a tilemap_renderer_->update(delta_time)
  - Delegación: setPaused() llama a tilemap_renderer_->setPaused(value)
  - Removida inicialización de time_accumulator_
  - Eliminados ~95 líneas de código de renderizado (incluyendo debug lines)

### Mejoras en CollisionMap
- **collision_map.hpp/cpp**:
  - Marcados getTile(SDL_FPoint) y getTile(int) como const (const correctness)
  - Permite uso desde TilemapRenderer con puntero const

### Build system
- **CMakeLists.txt**: Añadido tilemap_renderer.cpp a las fuentes del proyecto

## Métricas
- **Código eliminado de Room**: ~95 líneas de lógica de renderizado de tilemap
- **Nuevo TilemapRenderer**: 208 líneas (tilemap_renderer.cpp)
- **Reducción en room.cpp**: Continúa la mejora en cohesión y separación de responsabilidades

## Verificación
- ✅ Compilación exitosa sin errores
- ✅ Juego inicia y renderiza correctamente
- ✅ clang-tidy: 1 warning (naming style) corregido
- ✅ cppcheck: 1 suggestion (const correctness) aplicado
- ✅ Const correctness mejorada en CollisionMap

## Próximos pasos
- Fase 4: Extracción del parseo de archivos (RoomLoader)
- Fase 5: Limpieza final y reducción de Room a coordinador ligero

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

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

source/game/gameplay/tilemap_renderer.hpp

@@ -0,0 +1,107 @@
+#pragma once
+
+#include <SDL3/SDL.h>
+
+#include <memory>  // Para shared_ptr
+#include <string>  // Para string
+#include <vector>  // Para vector
+
+class Surface;
+class SurfaceSprite;
+class CollisionMap;
+
+/**
+ * @brief Renderizador de tilemap de una habitación
+ *
+ * Responsabilidades:
+ * - Renderizar el mapa de tiles estático
+ * - Gestionar tiles animados (conveyor belts)
+ * - Actualizar animaciones basadas en tiempo
+ * - Renderizar debug visualization (en modo DEBUG)
+ */
+class TilemapRenderer {
+    public:
+        /**
+         * @brief Constructor
+         * @param tile_map Vector con índices de tiles de la habitación
+         * @param tile_set_width Ancho del tileset en tiles
+         * @param tileset_surface Surface con los gráficos del tileset
+         * @param bg_color Color de fondo de la habitación (como string)
+         * @param conveyor_belt_direction Dirección de las cintas transportadoras (-1, 0, +1)
+         */
+        TilemapRenderer(std::vector<int> tile_map, int tile_set_width, std::shared_ptr<Surface> tileset_surface,
+                        std::string bg_color, int conveyor_belt_direction);
+        ~TilemapRenderer() = default;
+
+        // Prohibir copia y movimiento
+        TilemapRenderer(const TilemapRenderer&) = delete;
+        auto operator=(const TilemapRenderer&) -> TilemapRenderer& = delete;
+        TilemapRenderer(TilemapRenderer&&) = delete;
+        auto operator=(TilemapRenderer&&) -> TilemapRenderer& = delete;
+
+        /**
+         * @brief Inicializa el renderizador
+         * @param collision_map Mapa de colisiones para determinar tiles animados
+         *
+         * Crea la textura del mapa, pinta los tiles estáticos, y localiza tiles animados
+         */
+        void initialize(const CollisionMap* collision_map);
+
+        /**
+         * @brief Actualiza las animaciones de tiles
+         * @param delta_time Tiempo transcurrido desde el último frame (segundos)
+         */
+        void update(float delta_time);
+
+        /**
+         * @brief Renderiza el mapa completo en pantalla
+         *
+         * Dibuja la textura del mapa y los tiles animados
+         */
+        void render();
+
+        /**
+         * @brief Activa/desactiva modo pausa
+         * @param paused true para pausar, false para reanudar
+         *
+         * Nota: Actualmente no afecta al renderizado, pero mantiene consistencia con Room
+         */
+        void setPaused(bool paused) { is_paused_ = paused; }
+
+        // Getter para la surface del mapa (usado por Room para acceso directo si es necesario)
+        [[nodiscard]] auto getMapSurface() const -> std::shared_ptr<Surface> { return map_surface_; }
+
+    private:
+        // Estructura para tiles animados (conveyor belts)
+        struct AnimatedTile {
+                std::shared_ptr<SurfaceSprite> sprite{nullptr};  // SurfaceSprite para dibujar el tile
+                int x_orig{0};                                   // Posición X del primer tile de la animación en tilesheet
+        };
+
+        // === Constantes ===
+        static constexpr int TILE_SIZE = 8;                      // Ancho del tile en pixels
+        static constexpr int MAP_WIDTH = 32;                     // Ancho del mapa en tiles
+        static constexpr int MAP_HEIGHT = 16;                    // Alto del mapa en tiles
+        static constexpr int PLAY_AREA_WIDTH = 256;              // Ancho del área de juego en pixels
+        static constexpr int PLAY_AREA_HEIGHT = 128;             // Alto del área de juego en pixels
+        static constexpr float CONVEYOR_FRAME_DURATION = 0.05F;  // Duración de cada frame (3 frames @ 60fps)
+
+        // === Datos de la habitación ===
+        std::vector<int> tile_map_;                  // Índices de tiles de la habitación
+        int tile_set_width_;                         // Ancho del tileset en tiles
+        std::shared_ptr<Surface> tileset_surface_;   // Gráficos del tileset
+        std::string bg_color_;                       // Color de fondo
+        int conveyor_belt_direction_;                // Dirección de conveyor belts
+
+        // === Renderizado ===
+        std::shared_ptr<Surface> map_surface_;       // Textura para el mapa de la habitación
+        std::vector<AnimatedTile> animated_tiles_;   // Tiles animados (conveyor belts)
+        float time_accumulator_{0.0F};               // Acumulador de tiempo para animaciones
+        bool is_paused_{false};                      // Indica si está en modo pausa
+
+        // === Métodos privados ===
+        void fillMapTexture(const CollisionMap* collision_map);  // Pinta el mapa estático y debug lines
+        void setAnimatedTiles(const CollisionMap* collision_map); // Localiza todos los tiles animados
+        void updateAnimatedTiles();                               // Actualiza tiles animados
+        void renderAnimatedTiles();                               // Renderiza tiles animados
+};