jaildesigner-jailgames/jaildoctors_dilemma
1
0
Fork 2
Code Issues 1 Pull Requests Projects Releases 20 Wiki Activity

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

Browse Source 
## 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>
This commit is contained in:
Sergio
2025-11-13 09:09:51 +01:00
parent c5ad8041e8
commit 5365d62abc
7 changed files with 334 additions and 191 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@@ -85,6 +85,7 @@ set(APP_SOURCES
source/game/gameplay/room_tracker.cpp
source/game/gameplay/scoreboard.cpp
source/game/gameplay/stats.cpp
source/game/gameplay/tilemap_renderer.cpp
# Game - Scenes
source/game/scenes/credits.cpp

4
source/game/gameplay/collision_map.cpp
View File

@@ -26,13 +26,13 @@ void CollisionMap::initializeSurfaces() {
}
// Devuelve el tipo de tile que hay en ese pixel
auto CollisionMap::getTile(SDL_FPoint point) -> Tile {
auto CollisionMap::getTile(SDL_FPoint point) const -> Tile {
const int POS = ((point.y / TILE_SIZE) * MAP_WIDTH) + (point.x / TILE_SIZE);
return getTile(POS);
}
// Devuelve el tipo de tile que hay en ese indice
auto CollisionMap::getTile(int index) -> Tile {
auto CollisionMap::getTile(int index) const -> Tile {
const bool ON_RANGE = (index > -1) && (index < (int)tile_map_.size());
if (ON_RANGE) {

4
source/game/gameplay/collision_map.hpp
View File

@@ -44,8 +44,8 @@ class CollisionMap {
auto operator=(CollisionMap&&) -> CollisionMap& = delete;
// === Queries de tipo de tile ===
auto getTile(SDL_FPoint point) -> Tile; // Devuelve el tipo de tile en un punto (pixel)
auto getTile(int index) -> Tile; // Devuelve el tipo de tile en un índice del tilemap
auto getTile(SDL_FPoint point) const -> Tile; // Devuelve el tipo de tile en un punto (pixel)
auto getTile(int index) const -> Tile; // Devuelve el tipo de tile en un índice del tilemap
// === Queries de colisión con superficies ===
auto checkRightSurfaces(SDL_FRect& rect) -> int; // Colisión con paredes derechas (retorna X)

172
source/game/gameplay/room.cpp
View File

@@ -18,6 +18,7 @@
#include "game/gameplay/enemy_manager.hpp" // Para EnemyManager
#include "game/gameplay/item_manager.hpp" // Para ItemManager
#include "game/gameplay/item_tracker.hpp" // Para ItemTracker
#include "game/gameplay/tilemap_renderer.hpp" // Para TilemapRenderer
#include "game/gameplay/scoreboard.hpp" // Para Scoreboard::Data
#include "game/options.hpp" // Para Options, OptionsStats, options
#include "utils/defines.hpp" // Para BLOCK, PLAY_AREA_HEIGHT, PLAY_AREA_WIDTH
@@ -37,11 +38,14 @@ Room::Room(const std::string& room_path, std::shared_ptr<Scoreboard::Data> data)
// Crea el mapa de colisiones (necesita tile_map_, tile_set_width_, conveyor_belt_direction_)
collision_map_ = std::make_unique<CollisionMap>(tile_map_, tile_set_width_, conveyor_belt_direction_);
openTheJail(); // Abre la Jail si se da el caso
setAnimatedTiles(); // Busca los tiles animados
map_surface_ = std::make_shared<Surface>(PLAY_AREA_WIDTH, PLAY_AREA_HEIGHT); // Crea la textura para el mapa de tiles de la habitación
fillMapTexture(); // Pinta el mapa de la habitación en la textura
Screen::get()->setBorderColor(stringToColor(border_color_)); // Establece el color del borde
openTheJail(); // Abre la Jail si se da el caso
// Crea el renderizador del tilemap (necesita tile_map_, tile_set_width_, surface_, bg_color_, conveyor_belt_direction_)
tilemap_renderer_ = std::make_unique<TilemapRenderer>(tile_map_, tile_set_width_, surface_, bg_color_,
conveyor_belt_direction_);
tilemap_renderer_->initialize(collision_map_.get()); // Inicializa (crea map_surface, pinta tiles, busca animados)
Screen::get()->setBorderColor(stringToColor(border_color_)); // Establece el color del borde
}
// Destructor
@@ -66,7 +70,6 @@ void Room::initializeRoom(const Data& room) {
surface_ = Resource::Cache::get()->getSurface(room.tile_set_file);
tile_set_width_ = surface_->getWidth() / TILE_SIZE;
is_paused_ = false;
time_accumulator_ = 0.0F;
// Crear los enemigos usando el manager
for (const auto& enemy_data : room.enemies) {
@@ -109,105 +112,9 @@ void Room::openTheJail() {
}
}
// Crea la textura con el mapeado de la habitación
void Room::fillMapTexture() {
const Uint8 COLOR = stringToColor(bg_color_);
auto previuos_renderer = Screen::get()->getRendererSurface();
Screen::get()->setRendererSurface(map_surface_);
map_surface_->clear(COLOR);
// Los tileSetFiles son de 20x20 tiles. El primer tile es el 0. Cuentan hacia la derecha y hacia abajo
SDL_FRect clip = {0, 0, TILE_SIZE, TILE_SIZE};
for (int y = 0; y < MAP_HEIGHT; ++y) {
for (int x = 0; x < MAP_WIDTH; ++x) {
// Tiled pone los tiles vacios del mapa como cero y empieza a contar de 1 a n.
// Al cargar el mapa en memoria, se resta uno, por tanto los tiles vacios son -1
// Tampoco hay que dibujar los tiles animados que estan en la fila 19 (indices)
const int INDEX = (y * MAP_WIDTH) + x;
const bool A = (tile_map_[INDEX] >= 18 * tile_set_width_) && (tile_map_[INDEX] < 19 * tile_set_width_);
const bool B = tile_map_[INDEX] > -1;
if (B && !A) {
clip.x = (tile_map_[INDEX] % tile_set_width_) * TILE_SIZE;
clip.y = (tile_map_[INDEX] / tile_set_width_) * TILE_SIZE;
surface_->render(x * TILE_SIZE, y * TILE_SIZE, &clip);
}
}
}
#ifdef _DEBUG
if (Debug::get()->getEnabled()) {
auto surface = Screen::get()->getRendererSurface();
// BottomSurfaces
{
for (auto l : collision_map_->getBottomFloors()) {
surface->drawLine(l.x1, l.y, l.x2, l.y, static_cast<Uint8>(PaletteColor::BLUE));
}
}
// TopSurfaces
{
for (auto l : collision_map_->getTopFloors()) {
surface->drawLine(l.x1, l.y, l.x2, l.y, static_cast<Uint8>(PaletteColor::RED));
}
}
// LeftSurfaces
{
for (auto l : collision_map_->getLeftWalls()) {
surface->drawLine(l.x, l.y1, l.x, l.y2, static_cast<Uint8>(PaletteColor::GREEN));
}
}
// RightSurfaces
{
for (auto l : collision_map_->getRightWalls()) {
surface->drawLine(l.x, l.y1, l.x, l.y2, static_cast<Uint8>(PaletteColor::MAGENTA));
}
}
// LeftSlopes
{
for (auto l : collision_map_->getLeftSlopes()) {
surface->drawLine(l.x1, l.y1, l.x2, l.y2, static_cast<Uint8>(PaletteColor::CYAN));
}
}
// RightSlopes
{
for (auto l : collision_map_->getRightSlopes()) {
surface->drawLine(l.x1, l.y1, l.x2, l.y2, static_cast<Uint8>(PaletteColor::YELLOW));
}
}
// AutoSurfaces
{
for (auto l : collision_map_->getConveyorBeltFloors()) {
surface->drawLine(l.x1, l.y, l.x2, l.y, static_cast<Uint8>(PaletteColor::WHITE));
}
}
}
#endif // _DEBUG
Screen::get()->setRendererSurface(previuos_renderer);
}
// Dibuja el mapa en pantalla
void Room::renderMap() {
// Dibuja la textura con el mapa en pantalla
SDL_FRect dest = {0, 0, PLAY_AREA_WIDTH, PLAY_AREA_HEIGHT};
map_surface_->render(nullptr, &dest);
// Dibuja los tiles animados
#ifdef _DEBUG
if (!Debug::get()->getEnabled()) {
renderAnimatedTiles();
}
#else
renderAnimatedTiles();
#endif
tilemap_renderer_->render();
}
// Dibuja los enemigos en pantalla
@@ -227,11 +134,8 @@ void Room::update(float delta_time) {
return;
}
// Actualiza el acumulador de tiempo
time_accumulator_ += delta_time;
// Actualiza los tiles animados
updateAnimatedTiles();
// Actualiza los tiles animados usando el renderer
tilemap_renderer_->update(delta_time);
// Actualiza los enemigos usando el manager
enemy_manager_->update(delta_time);
@@ -243,60 +147,10 @@ void Room::update(float delta_time) {
// Pone el mapa en modo pausa
void Room::setPaused(bool value) {
is_paused_ = value;
tilemap_renderer_->setPaused(value);
item_manager_->setPaused(value);
}
// Localiza todos los tiles animados de la habitación
void Room::setAnimatedTiles() {
// Recorre la habitación entera por filas buscando tiles de tipo t_animated
for (int i = 0; i < (int)tile_map_.size(); ++i) {
if (getTile(i) == Tile::ANIMATED) {
// La i es la ubicación
const int X = (i % MAP_WIDTH) * TILE_SIZE;
const int Y = (i / MAP_WIDTH) * TILE_SIZE;
// TileMap[i] es el tile a poner
const int XC = (tile_map_[i] % tile_set_width_) * TILE_SIZE;
const int YC = (tile_map_[i] / tile_set_width_) * TILE_SIZE;
AnimatedTile at;
at.sprite = std::make_shared<SurfaceSprite>(surface_, X, Y, 8, 8);
at.sprite->setClip(XC, YC, 8, 8);
at.x_orig = XC;
animated_tiles_.push_back(at);
}
}
}
// Actualiza los tiles animados
void Room::updateAnimatedTiles() {
const int NUM_FRAMES = 4;
// Calcular frame actual basado en tiempo
const int CURRENT_FRAME = static_cast<int>(time_accumulator_ / CONVEYOR_FRAME_DURATION) % NUM_FRAMES;
// Calcular offset basado en dirección
int offset = 0;
if (conveyor_belt_direction_ == -1) {
offset = CURRENT_FRAME * TILE_SIZE;
} else {
offset = (NUM_FRAMES - 1 - CURRENT_FRAME) * TILE_SIZE;
}
for (auto& a : animated_tiles_) {
SDL_FRect rect = a.sprite->getClip();
rect.x = a.x_orig + offset;
a.sprite->setClip(rect);
}
}
// Pinta los tiles animados en pantalla
void Room::renderAnimatedTiles() {
for (const auto& a : animated_tiles_) {
a.sprite->render();
}
}
// Devuelve la cadena del fichero de la habitación contigua segun el borde
auto Room::getRoom(Border border) -> std::string {
switch (border) {

44
source/game/gameplay/room.hpp
View File

@@ -15,6 +15,7 @@ class Surface; // lines 13-13
class EnemyManager;
class ItemManager;
class CollisionMap;
class TilemapRenderer;
class Room {
public:
@@ -91,25 +92,18 @@ class Room {
static auto loadRoomTileFile(const std::string& file_path, bool verbose = false) -> std::vector<int>; // Carga las variables y texturas desde un fichero de mapa de tiles
private:
// Tipos anidados privados
struct AnimatedTile {
std::shared_ptr<SurfaceSprite> sprite{nullptr}; // SurfaceSprite para dibujar el tile
int x_orig{0}; // Posición X donde se encuentra el primer tile de la animación en la 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 float CONVEYOR_FRAME_DURATION = 0.05F; // Duración de cada frame de conveyor belt (3 frames @ 60fps)
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
// Objetos y punteros
std::unique_ptr<EnemyManager> enemy_manager_; // Gestor de enemigos de la habitación
std::unique_ptr<ItemManager> item_manager_; // Gestor de items de la habitación
std::unique_ptr<CollisionMap> collision_map_; // Mapa de colisiones de la habitación
std::shared_ptr<Surface> surface_; // Textura con los graficos de la habitación
std::shared_ptr<Surface> map_surface_; // Textura para dibujar el mapa de la habitación
std::shared_ptr<Scoreboard::Data> data_; // Puntero a los datos del marcador
std::unique_ptr<EnemyManager> enemy_manager_; // Gestor de enemigos de la habitación
std::unique_ptr<ItemManager> item_manager_; // Gestor de items de la habitación
std::unique_ptr<CollisionMap> collision_map_; // Mapa de colisiones de la habitación
std::unique_ptr<TilemapRenderer> tilemap_renderer_; // Renderizador del mapa de tiles
std::shared_ptr<Surface> surface_; // Textura con los graficos de la habitación
std::shared_ptr<Scoreboard::Data> data_; // Puntero a los datos del marcador
// --- Variables ---
std::string number_; // Numero de la habitación
@@ -122,21 +116,15 @@ class Room {
std::string lower_room_; // Identificador de la habitación que se encuentra abajp
std::string left_room_; // Identificador de la habitación que se encuentra a la izquierda
std::string right_room_; // Identificador de la habitación que se encuentra a la derecha
std::string tile_set_file_; // Imagen con los graficos para la habitación
std::string tile_map_file_; // Fichero con el mapa de indices de tile
std::vector<int> tile_map_; // Indice de los tiles a dibujar en la habitación
int conveyor_belt_direction_{0}; // Sentido en el que arrastran las superficies automáticas de la habitación
float time_accumulator_{0.0F}; // Acumulador de tiempo para animaciones (time-based)
bool is_paused_{false}; // Indica si el mapa esta en modo pausa
std::vector<AnimatedTile> animated_tiles_; // Vector con los indices de tiles animados
int tile_set_width_{0}; // Ancho del tileset en tiles
std::string tile_set_file_; // Imagen con los graficos para la habitación
std::string tile_map_file_; // Fichero con el mapa de indices de tile
std::vector<int> tile_map_; // Indice de los tiles a dibujar en la habitación
int conveyor_belt_direction_{0}; // Sentido en el que arrastran las superficies automáticas de la habitación
bool is_paused_{false}; // Indica si el mapa esta en modo pausa
int tile_set_width_{0}; // Ancho del tileset en tiles
// --- Funciones ---
void initializeRoom(const Data& room); // Inicializa los valores
void fillMapTexture(); // Pinta el mapa de la habitación en la textura
void setAnimatedTiles(); // Localiza todos los tiles animados de la habitación
void updateAnimatedTiles(); // Actualiza los tiles animados
void renderAnimatedTiles(); // Pinta los tiles animados en pantalla
void openTheJail(); // Abre la jail para poder entrar
static auto setRoom(Data& room, const std::string& key, const std::string& value) -> bool; // Asigna variables a una estructura RoomData
static auto setEnemy(Enemy::Data& enemy, const std::string& key, const std::string& value) -> bool; // Asigna variables a una estructura EnemyData

193
source/game/gameplay/tilemap_renderer.cpp Normal file
View File

@@ -0,0 +1,193 @@
#include "tilemap_renderer.hpp"
#include "core/rendering/screen.hpp"
#include "core/rendering/surface.hpp"
#include "core/rendering/surface_sprite.hpp"
#include "core/system/debug.hpp"
#include "game/gameplay/collision_map.hpp"
#include "utils/utils.hpp"
// Constructor
TilemapRenderer::TilemapRenderer(std::vector<int> tile_map, int tile_set_width,
std::shared_ptr<Surface> tileset_surface, std::string bg_color,
int conveyor_belt_direction)
: tile_map_(std::move(tile_map)),
tile_set_width_(tile_set_width),
tileset_surface_(std::move(tileset_surface)),
bg_color_(std::move(bg_color)),
conveyor_belt_direction_(conveyor_belt_direction) {
// Crear la surface del mapa
map_surface_ = std::make_shared<Surface>(PLAY_AREA_WIDTH, PLAY_AREA_HEIGHT);
}
// Inicializa el renderizador
void TilemapRenderer::initialize(const CollisionMap* collision_map) {
setAnimatedTiles(collision_map);
fillMapTexture(collision_map);
}
// Actualiza las animaciones de tiles
void TilemapRenderer::update(float delta_time) {
if (is_paused_) {
return;
}
// Actualiza el acumulador de tiempo
time_accumulator_ += delta_time;
// Actualiza los tiles animados
updateAnimatedTiles();
}
// Renderiza el mapa completo en pantalla
void TilemapRenderer::render() {
// Dibuja la textura con el mapa en pantalla
SDL_FRect dest = {0, 0, PLAY_AREA_WIDTH, PLAY_AREA_HEIGHT};
map_surface_->render(nullptr, &dest);
// Dibuja los tiles animados
#ifdef _DEBUG
if (!Debug::get()->getEnabled()) {
renderAnimatedTiles();
}
#else
renderAnimatedTiles();
#endif
}
// Pinta el mapa estático y debug lines
void TilemapRenderer::fillMapTexture(const CollisionMap* collision_map) {
const Uint8 COLOR = stringToColor(bg_color_);
auto previous_renderer = Screen::get()->getRendererSurface();
Screen::get()->setRendererSurface(map_surface_);
map_surface_->clear(COLOR);
// Los tileSetFiles son de 20x20 tiles. El primer tile es el 0. Cuentan hacia la derecha y hacia abajo
SDL_FRect clip = {0, 0, TILE_SIZE, TILE_SIZE};
for (int y = 0; y < MAP_HEIGHT; ++y) {
for (int x = 0; x < MAP_WIDTH; ++x) {
// Tiled pone los tiles vacios del mapa como cero y empieza a contar de 1 a n.
// Al cargar el mapa en memoria, se resta uno, por tanto los tiles vacios son -1
// Tampoco hay que dibujar los tiles animados que estan en la fila 19 (indices)
const int INDEX = (y * MAP_WIDTH) + x;
const bool A = (tile_map_[INDEX] >= 18 * tile_set_width_) && (tile_map_[INDEX] < 19 * tile_set_width_);
const bool B = tile_map_[INDEX] > -1;
if (B && !A) {
clip.x = (tile_map_[INDEX] % tile_set_width_) * TILE_SIZE;
clip.y = (tile_map_[INDEX] / tile_set_width_) * TILE_SIZE;
tileset_surface_->render(x * TILE_SIZE, y * TILE_SIZE, &clip);
}
}
}
#ifdef _DEBUG
if (Debug::get()->getEnabled()) {
auto surface = Screen::get()->getRendererSurface();
// BottomSurfaces
{
for (auto l : collision_map->getBottomFloors()) {
surface->drawLine(l.x1, l.y, l.x2, l.y, static_cast<Uint8>(PaletteColor::BLUE));
}
}
// TopSurfaces
{
for (auto l : collision_map->getTopFloors()) {
surface->drawLine(l.x1, l.y, l.x2, l.y, static_cast<Uint8>(PaletteColor::RED));
}
}
// LeftSurfaces
{
for (auto l : collision_map->getLeftWalls()) {
surface->drawLine(l.x, l.y1, l.x, l.y2, static_cast<Uint8>(PaletteColor::GREEN));
}
}
// RightSurfaces
{
for (auto l : collision_map->getRightWalls()) {
surface->drawLine(l.x, l.y1, l.x, l.y2, static_cast<Uint8>(PaletteColor::MAGENTA));
}
}
// LeftSlopes
{
for (auto l : collision_map->getLeftSlopes()) {
surface->drawLine(l.x1, l.y1, l.x2, l.y2, static_cast<Uint8>(PaletteColor::CYAN));
}
}
// RightSlopes
{
for (auto l : collision_map->getRightSlopes()) {
surface->drawLine(l.x1, l.y1, l.x2, l.y2, static_cast<Uint8>(PaletteColor::YELLOW));
}
}
// AutoSurfaces
{
for (auto l : collision_map->getConveyorBeltFloors()) {
surface->drawLine(l.x1, l.y, l.x2, l.y, static_cast<Uint8>(PaletteColor::WHITE));
}
}
}
#endif // _DEBUG
Screen::get()->setRendererSurface(previous_renderer);
}
// Localiza todos los tiles animados
void TilemapRenderer::setAnimatedTiles(const CollisionMap* collision_map) {
// Recorre la habitación entera por filas buscando tiles de tipo t_animated
for (int i = 0; i < (int)tile_map_.size(); ++i) {
const auto TILE_TYPE = collision_map->getTile(i);
if (TILE_TYPE == CollisionMap::Tile::ANIMATED) {
// La i es la ubicación
const int X = (i % MAP_WIDTH) * TILE_SIZE;
const int Y = (i / MAP_WIDTH) * TILE_SIZE;
// TileMap[i] es el tile a poner
const int XC = (tile_map_[i] % tile_set_width_) * TILE_SIZE;
const int YC = (tile_map_[i] / tile_set_width_) * TILE_SIZE;
AnimatedTile at;
at.sprite = std::make_shared<SurfaceSprite>(tileset_surface_, X, Y, 8, 8);
at.sprite->setClip(XC, YC, 8, 8);
at.x_orig = XC;
animated_tiles_.push_back(at);
}
}
}
// Actualiza tiles animados
void TilemapRenderer::updateAnimatedTiles() {
const int NUM_FRAMES = 4;
// Calcular frame actual basado en tiempo
const int CURRENT_FRAME = static_cast<int>(time_accumulator_ / CONVEYOR_FRAME_DURATION) % NUM_FRAMES;
// Calcular offset basado en dirección
int offset = 0;
if (conveyor_belt_direction_ == -1) {
offset = CURRENT_FRAME * TILE_SIZE;
} else {
offset = (NUM_FRAMES - 1 - CURRENT_FRAME) * TILE_SIZE;
}
for (auto& a : animated_tiles_) {
SDL_FRect rect = a.sprite->getClip();
rect.x = a.x_orig + offset;
a.sprite->setClip(rect);
}
}
// Renderiza tiles animados
void TilemapRenderer::renderAnimatedTiles() {
for (const auto& a : animated_tiles_) {
a.sprite->render();
}
}

107
source/game/gameplay/tilemap_renderer.hpp Normal file
View File

@@ -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
};