jaildesigner-jailgames/projecte_2026
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

collision map

Browse Source
This commit is contained in:
Sergio
2026-04-06 20:27:35 +02:00
parent ef04500a44
commit 98715ef3a7
36 changed files with 489 additions and 297 deletions
Download Patch File Download Diff File Expand all files Collapse all files

105
source/game/editor/map_editor.cpp
View File

@@ -121,9 +121,10 @@ auto MapEditor::showGrid(bool show) -> std::string {
return show ? "Grid ON" : "Grid OFF";
}
// Parsea un color como índice numérico
static auto parseColor(const std::string& value) -> Uint8 {
return static_cast<Uint8>(safeStoi(value, 0));
auto MapEditor::setEditingCollision(bool collision) -> std::string {
editing_collision_ = collision;
brush_tile_ = NO_BRUSH; // Resetear brush al cambiar de modo
return editing_collision_ ? "Editing: collision" : "Editing: draw";
}
void MapEditor::toggleMiniMap() {
@@ -225,6 +226,12 @@ void MapEditor::enter(std::shared_ptr<Room> room, std::shared_ptr<Player> player
selected_item_ = -1;
brush_tile_ = NO_BRUSH;
painting_ = false;
editing_collision_ = false;
// Asegurar que collision_tile_map tiene el tamaño correcto
if (room_data_.collision_tile_map.size() != static_cast<size_t>(Map::WIDTH * Map::HEIGHT)) {
room_data_.collision_tile_map.resize(Map::WIDTH * Map::HEIGHT, 0);
}
active_ = true;
std::cout << "MapEditor: ON (room " << room_path_ << ")\n";
@@ -332,10 +339,20 @@ void MapEditor::update(float delta_time) {
// Si estamos pintando tiles, pintar en la posición actual del ratón
if (painting_ && brush_tile_ != NO_BRUSH) {
int tile_index = (mouse_tile_y_ * 32) + mouse_tile_x_;
if (tile_index >= 0 && tile_index < static_cast<int>(room_data_.tile_map.size())) {
if (room_data_.tile_map[tile_index] != brush_tile_) {
room_data_.tile_map[tile_index] = brush_tile_;
room_->setTile(tile_index, brush_tile_);
if (editing_collision_) {
// Pintar en el mapa de colisiones
if (tile_index >= 0 && tile_index < static_cast<int>(room_data_.collision_tile_map.size())) {
if (room_data_.collision_tile_map[tile_index] != brush_tile_) {
room_data_.collision_tile_map[tile_index] = brush_tile_;
}
}
} else {
// Pintar en el mapa de dibujo
if (tile_index >= 0 && tile_index < static_cast<int>(room_data_.tile_map.size())) {
if (room_data_.tile_map[tile_index] != brush_tile_) {
room_data_.tile_map[tile_index] = brush_tile_;
room_->setTile(tile_index, brush_tile_);
}
}
}
}
@@ -351,6 +368,28 @@ void MapEditor::update(float delta_time) {
void MapEditor::render() {
// El tilemap ya ha sido renderizado por Game::renderPlaying() antes de llamar aquí
// Si estamos editando colisiones, superponer el mapa de colisiones
if (editing_collision_) {
auto collision_surface = Resource::Cache::get()->getSurface("collision.gif");
if (collision_surface) {
const int TILE_W = Tile::SIZE;
for (int y = 0; y < Map::HEIGHT; ++y) {
for (int x = 0; x < Map::WIDTH; ++x) {
int index = (y * Map::WIDTH) + x;
if (index >= static_cast<int>(room_data_.collision_tile_map.size())) { continue; }
int tile = room_data_.collision_tile_map[index];
if (tile <= 0) { continue; } // 0 = vacío, no dibujar
SDL_FRect clip = {
.x = static_cast<float>(tile * TILE_W),
.y = 0,
.w = static_cast<float>(TILE_W),
.h = static_cast<float>(TILE_W)};
collision_surface->render(x * TILE_W, y * TILE_W, &clip);
}
}
}
}
// Grid (debajo de todo)
if (settings_.grid) {
renderGrid();
@@ -418,22 +457,41 @@ void MapEditor::handleEvent(const SDL_Event& event) { // NOLINT(readability-fun
return;
}
// Click derecho: abrir TilePicker del mapa
// 7: alternar entre draw y collision
if (event.type == SDL_EVENT_KEY_DOWN && event.key.key == SDLK_7 && static_cast<int>(event.key.repeat) == 0) {
setEditingCollision(!editing_collision_);
return;
}
// Click derecho: abrir TilePicker
if (event.type == SDL_EVENT_MOUSE_BUTTON_DOWN && event.button.button == SDL_BUTTON_RIGHT) {
// Deseleccionar entidades
selected_enemy_ = -1;
selected_item_ = -1;
// Tile bajo el cursor como tile actual del picker
int tile_index = (mouse_tile_y_ * 32) + mouse_tile_x_;
int current = (tile_index >= 0 && tile_index < static_cast<int>(room_data_.tile_map.size()))
? room_data_.tile_map[tile_index]
: -1;
if (editing_collision_) {
// Abrir tile picker del collision tileset
int tile_index = (mouse_tile_y_ * 32) + mouse_tile_x_;
int current = (tile_index >= 0 && tile_index < static_cast<int>(room_data_.collision_tile_map.size()))
? room_data_.collision_tile_map[tile_index]
: 0;
tile_picker_.on_select = [this](int tile) {
brush_tile_ = tile;
};
tile_picker_.open(room_->getTileSetFile(), current, room_data_.bg_color);
tile_picker_.on_select = [this](int tile) {
brush_tile_ = tile;
};
tile_picker_.open("collision.gif", current, 0);
} else {
// Abrir tile picker del mapa de dibujo
int tile_index = (mouse_tile_y_ * 32) + mouse_tile_x_;
int current = (tile_index >= 0 && tile_index < static_cast<int>(room_data_.tile_map.size()))
? room_data_.tile_map[tile_index]
: -1;
tile_picker_.on_select = [this](int tile) {
brush_tile_ = tile;
};
tile_picker_.open(room_->getTileSetFile(), current, room_data_.bg_color);
}
return;
}
@@ -463,9 +521,15 @@ void MapEditor::handleEvent(const SDL_Event& event) { // NOLINT(readability-fun
// Pintar tile y entrar en modo painting
painting_ = true;
int tile_index = (mouse_tile_y_ * 32) + mouse_tile_x_;
if (tile_index >= 0 && tile_index < static_cast<int>(room_data_.tile_map.size())) {
room_data_.tile_map[tile_index] = brush_tile_;
room_->setTile(tile_index, brush_tile_);
if (editing_collision_) {
if (tile_index >= 0 && tile_index < static_cast<int>(room_data_.collision_tile_map.size())) {
room_data_.collision_tile_map[tile_index] = brush_tile_;
}
} else {
if (tile_index >= 0 && tile_index < static_cast<int>(room_data_.tile_map.size())) {
room_data_.tile_map[tile_index] = brush_tile_;
room_->setTile(tile_index, brush_tile_);
}
}
return;
}
@@ -1329,6 +1393,7 @@ auto MapEditor::createNewRoom(const std::string& direction) -> std::string { //
new_room.right_room = "0";
new_room.conveyor_belt_direction = 0;
new_room.tile_map.resize(Map::WIDTH * Map::HEIGHT, -1);
new_room.collision_tile_map.resize(Map::WIDTH * Map::HEIGHT, 0);
// Conexión recíproca: la nueva room conecta de vuelta a la actual
if (direction == "UP") {

2
source/game/editor/map_editor.hpp
View File

@@ -50,6 +50,7 @@ class MapEditor {
// Opciones del editor (llamados desde console_commands / teclas)
auto showInfo(bool show) -> std::string;
auto showGrid(bool show) -> std::string;
auto setEditingCollision(bool collision) -> std::string;
[[nodiscard]] auto isGridEnabled() const -> bool { return settings_.grid; }
void toggleMiniMap();
void setReenter(bool value) { reenter_ = value; }
@@ -122,6 +123,7 @@ class MapEditor {
static constexpr int ERASER_BRUSH = -1; // Brush borrador (pinta tile vacío = -1)
int brush_tile_{NO_BRUSH}; // Tile activo para pintar
bool painting_{false}; // true mientras se está pintando con click izquierdo mantenido
bool editing_collision_{false}; // true = editando collision tilemap, false = editando draw tilemap
// Datos de la habitación
Room::Data room_data_;

2
source/game/editor/mini_map.hpp
View File

@@ -86,7 +86,7 @@ class MiniMap {
float view_start_y_{0.0F};
// Constantes
static constexpr int ROOM_W = Map::WIDTH; // Ancho de una room en pixels del minimapa (1 pixel por tile)
static constexpr int ROOM_W = Map::WIDTH; // Ancho de una room en pixels del minimapa (1 pixel por tile)
static constexpr int ROOM_H = Map::HEIGHT; // Alto de una room en pixels del minimapa (1 pixel por tile)
static constexpr int BORDER = 1; // Borde alrededor de cada room
static constexpr int CELL_W = ROOM_W + (BORDER * 2); // Room + borde

26
source/game/editor/room_saver.cpp
View File

@@ -37,7 +37,7 @@ auto RoomSaver::conveyorBeltToString(int direction) -> std::string {
// Genera el YAML completo como texto con formato compacto
auto RoomSaver::buildYAML(const fkyaml::node& original_yaml, const Room::Data& room_data) -> std::string { // NOLINT(readability-function-cognitive-complexity)
(void)original_yaml; // Ya no se usa; mantenido para compatibilidad con la firma de saveYAML
(void)original_yaml; // Ya no se usa; mantenido para compatibilidad con la firma de saveYAML
std::ostringstream out;
// --- Sección room ---
@@ -70,10 +70,13 @@ auto RoomSaver::buildYAML(const fkyaml::node& original_yaml, const Room::Data& r
// --- Tilemap (MAP_HEIGHT filas × MAP_WIDTH columnas, formato flow) ---
out << "\n";
out << "# Tilemap: " << Map::HEIGHT << " filas x " << Map::WIDTH << " columnas @ " << Tile::SIZE << "px/tile\n";
out << "# Índices de tiles (-1 = vacío)\n";
out << "tilemap:\n";
// Mapa de dibujo
out << " # Mapa de dibujo (indices de tiles, -1 = vacio)\n";
out << " draw:\n";
for (int row = 0; row < Map::HEIGHT; ++row) {
out << " - [";
out << " - [";
for (int col = 0; col < Map::WIDTH; ++col) {
int index = (row * Map::WIDTH) + col;
if (index < static_cast<int>(room_data.tile_map.size())) {
@@ -86,6 +89,23 @@ auto RoomSaver::buildYAML(const fkyaml::node& original_yaml, const Room::Data& r
out << "]\n";
}
// Mapa de colisiones
out << " # Mapa de colisiones (0 = vacio, 1 = solido)\n";
out << " collision:\n";
for (int row = 0; row < Map::HEIGHT; ++row) {
out << " - [";
for (int col = 0; col < Map::WIDTH; ++col) {
int index = (row * Map::WIDTH) + col;
if (index < static_cast<int>(room_data.collision_tile_map.size())) {
out << room_data.collision_tile_map[index];
} else {
out << 0;
}
if (col < Map::WIDTH - 1) { out << ", "; }
}
out << "]\n";
}
// --- Enemigos ---
if (!room_data.enemies.empty()) {
out << "\n";

39
source/game/entities/player.cpp
View File

@@ -591,16 +591,16 @@ void Player::updateColliderPoints() {
const float Y1 = y_ + 8;
const float Y2 = y_ + 16;
const float Y3 = y_ + HEIGHT - 1;
collider_points_[0] = {.x = L, .y = Y0};
collider_points_[1] = {.x = M, .y = Y0};
collider_points_[2] = {.x = R, .y = Y0};
collider_points_[3] = {.x = L, .y = Y1};
collider_points_[4] = {.x = M, .y = Y1};
collider_points_[5] = {.x = R, .y = Y1};
collider_points_[6] = {.x = L, .y = Y2};
collider_points_[7] = {.x = M, .y = Y2};
collider_points_[8] = {.x = R, .y = Y2};
collider_points_[9] = {.x = L, .y = Y3};
collider_points_[0] = {.x = L, .y = Y0};
collider_points_[1] = {.x = M, .y = Y0};
collider_points_[2] = {.x = R, .y = Y0};
collider_points_[3] = {.x = L, .y = Y1};
collider_points_[4] = {.x = M, .y = Y1};
collider_points_[5] = {.x = R, .y = Y1};
collider_points_[6] = {.x = L, .y = Y2};
collider_points_[7] = {.x = M, .y = Y2};
collider_points_[8] = {.x = R, .y = Y2};
collider_points_[9] = {.x = L, .y = Y3};
collider_points_[10] = {.x = M, .y = Y3};
collider_points_[11] = {.x = R, .y = Y3};
}
@@ -680,15 +680,24 @@ void Player::updateVelocity(float delta_time) {
target = HORIZONTAL_VELOCITY * room_->getConveyorBeltDirection();
} else {
switch (wanna_go_) {
case Direction::LEFT: target = -HORIZONTAL_VELOCITY; break;
case Direction::RIGHT: target = HORIZONTAL_VELOCITY; break;
default: target = 0.0F; break;
case Direction::LEFT:
target = -HORIZONTAL_VELOCITY;
break;
case Direction::RIGHT:
target = HORIZONTAL_VELOCITY;
break;
default:
target = 0.0F;
break;
}
}
// Orientación del sprite según la dirección deseada (sin cambiar cuando target=0)
if (target > 0.0F) { sprite_->setFlip(Flip::RIGHT); }
else if (target < 0.0F) { sprite_->setFlip(Flip::LEFT); }
if (target > 0.0F) {
sprite_->setFlip(Flip::RIGHT);
} else if (target < 0.0F) {
sprite_->setFlip(Flip::LEFT);
}
// Inercia:
// - En el aire: inercia completa (arranque y frenada graduales)

22
source/game/entities/player.hpp
View File

@@ -33,12 +33,12 @@ class Player {
};
// --- Constantes de física (públicas para permitir cálculos en structs) ---
static constexpr float HORIZONTAL_VELOCITY = 60.0F; // Velocidad horizontal objetivo en pixels/segundo
static constexpr float HORIZONTAL_ACCEL = 500.0F; // Aceleración/deceleración horizontal en pixels/segundo² (inercia ligera)
static constexpr float MAX_VY = 160.0F; // Velocidad vertical máxima en pixels/segundo
static constexpr float JUMP_VELOCITY = -178.5F; // Velocidad inicial del salto en pixels/segundo
static constexpr float GRAVITY_FORCE = 360.0F; // Fuerza de gravedad en pixels/segundo²
static constexpr float LOW_JUMP_GRAVITY_MULT = 3.0F; // Multiplicador de gravedad al soltar el botón de salto (salto variable)
static constexpr float HORIZONTAL_VELOCITY = 60.0F; // Velocidad horizontal objetivo en pixels/segundo
static constexpr float HORIZONTAL_ACCEL = 500.0F; // Aceleración/deceleración horizontal en pixels/segundo² (inercia ligera)
static constexpr float MAX_VY = 160.0F; // Velocidad vertical máxima en pixels/segundo
static constexpr float JUMP_VELOCITY = -178.5F; // Velocidad inicial del salto en pixels/segundo
static constexpr float GRAVITY_FORCE = 360.0F; // Fuerza de gravedad en pixels/segundo²
static constexpr float LOW_JUMP_GRAVITY_MULT = 3.0F; // Multiplicador de gravedad al soltar el botón de salto (salto variable)
struct SpawnData {
float x = 0;
@@ -181,9 +181,9 @@ class Player {
void placeSprite(); // Coloca el sprite en la posición del jugador
// --- Funciones de finalización ---
void animate(float delta_time); // Establece la animación del jugador
auto handleBorders() -> Room::Border; // Comprueba si se halla en alguno de los cuatro bordes
auto handleKillingTiles() -> bool; // Comprueba que el jugador no toque ningun tile de los que matan
void updateVelocity(float delta_time); // Calcula la velocidad en x con inercia ligera
void markAsDead(); // Marca al jugador como muerto
void animate(float delta_time); // Establece la animación del jugador
auto handleBorders() -> Room::Border; // Comprueba si se halla en alguno de los cuatro bordes
auto handleKillingTiles() -> bool; // Comprueba que el jugador no toque ningun tile de los que matan
void updateVelocity(float delta_time); // Calcula la velocidad en x con inercia ligera
void markAsDead(); // Marca al jugador como muerto
};

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

@@ -8,9 +8,8 @@
#include "utils/defines.hpp" // Para Collision
// Constructor
CollisionMap::CollisionMap(std::vector<int> tile_map, int tile_set_width, int conveyor_belt_direction)
: tile_map_(std::move(tile_map)),
tile_set_width_(tile_set_width),
CollisionMap::CollisionMap(std::vector<int> collision_tile_map, int conveyor_belt_direction)
: collision_tile_map_(std::move(collision_tile_map)),
conveyor_belt_direction_(conveyor_belt_direction) {
// Inicializa todas las superficies de colisión
initializeSurfaces();
@@ -35,43 +34,21 @@ auto CollisionMap::getTile(SDL_FPoint point) const -> Tile {
return getTile(POS);
}
// Devuelve el tipo de tile que hay en ese indice
auto CollisionMap::getTile(int index) const -> Tile { // NOLINT(readability-convert-member-functions-to-static)
const bool ON_RANGE = (index > -1) && (index < (int)tile_map_.size());
if (ON_RANGE) {
// Las filas 0-8 son de tiles t_wall
if ((tile_map_[index] >= 0) && (tile_map_[index] < 9 * tile_set_width_)) {
return Tile::WALL;
}
// Las filas 9-17 son de tiles t_passable
if ((tile_map_[index] >= 9 * tile_set_width_) && (tile_map_[index] < 18 * tile_set_width_)) {
return Tile::PASSABLE;
}
// Las filas 18-20 es de tiles t_animated
if ((tile_map_[index] >= 18 * tile_set_width_) && (tile_map_[index] < 21 * tile_set_width_)) {
return Tile::ANIMATED;
}
// La fila 21 es de tiles t_slope_r
if ((tile_map_[index] >= 21 * tile_set_width_) && (tile_map_[index] < 22 * tile_set_width_)) {
return Tile::SLOPE_R;
}
// La fila 22 es de tiles t_slope_l
if ((tile_map_[index] >= 22 * tile_set_width_) && (tile_map_[index] < 23 * tile_set_width_)) {
return Tile::SLOPE_L;
}
// La fila 23 es de tiles t_kill
if ((tile_map_[index] >= 23 * tile_set_width_) && (tile_map_[index] < 24 * tile_set_width_)) {
return Tile::KILL;
}
// Devuelve el tipo de tile que hay en ese indice (lee del collision_tile_map)
auto CollisionMap::getTile(int index) const -> Tile {
if (index < 0 || index >= static_cast<int>(collision_tile_map_.size())) {
return Tile::EMPTY;
}
return Tile::EMPTY;
switch (collision_tile_map_[index]) {
case 1: return Tile::WALL;
case 2: return Tile::PASSABLE;
case 3: return Tile::SLOPE_L;
case 4: return Tile::SLOPE_R;
case 5: return Tile::KILL;
case 6: return Tile::ANIMATED;
default: return Tile::EMPTY;
}
}
// Obten la coordenada de la cuesta a partir de un punto perteneciente a ese tile
@@ -234,7 +211,7 @@ auto CollisionMap::collectBottomTiles() -> std::vector<int> { // NOLINT(readabi
// Busca todos los tiles de tipo muro que no tengan debajo otro muro
// Hay que recorrer la habitación por filas (excepto los de la última fila)
for (int i = 0; i < (int)tile_map_.size() - MAP_WIDTH; ++i) {
for (int i = 0; i < (int)collision_tile_map_.size() - MAP_WIDTH; ++i) {
if (getTile(i) == Tile::WALL && getTile(i + MAP_WIDTH) != Tile::WALL) {
tile.push_back(i);
@@ -256,7 +233,7 @@ auto CollisionMap::collectTopTiles() -> std::vector<int> { // NOLINT(readabilit
// Busca todos los tiles de tipo muro o pasable que no tengan encima un muro
// Hay que recorrer la habitación por filas (excepto los de la primera fila)
for (int i = MAP_WIDTH; i < (int)tile_map_.size(); ++i) {
for (int i = MAP_WIDTH; i < (int)collision_tile_map_.size(); ++i) {
if ((getTile(i) == Tile::WALL || getTile(i) == Tile::PASSABLE) && getTile(i - MAP_WIDTH) != Tile::WALL) {
tile.push_back(i);
@@ -272,13 +249,12 @@ auto CollisionMap::collectTopTiles() -> std::vector<int> { // NOLINT(readabilit
return tile;
}
// Helper: recopila tiles animados (para superficies automaticas/conveyor belts)
auto CollisionMap::collectAnimatedTiles() -> std::vector<int> { // NOLINT(readability-make-member-function-const)
// Helper: recopila tiles conveyor belt
auto CollisionMap::collectConveyorTiles() -> std::vector<int> { // NOLINT(readability-make-member-function-const)
std::vector<int> tile;
// Busca todos los tiles de tipo animado
// Hay que recorrer la habitación por filas (excepto los de la primera fila)
for (int i = MAP_WIDTH; i < (int)tile_map_.size(); ++i) {
// Busca todos los tiles de tipo conveyor
for (int i = MAP_WIDTH; i < (int)collision_tile_map_.size(); ++i) {
if (getTile(i) == Tile::ANIMATED) {
tile.push_back(i);
@@ -437,7 +413,7 @@ void CollisionMap::setRightSurfaces() { // NOLINT(readability-make-member-funct
void CollisionMap::setLeftSlopes() { // NOLINT(readability-make-member-function-const)
// Recorre la habitación entera por filas buscando tiles de tipo t_slope_l
std::vector<int> found;
for (int i = 0; i < (int)tile_map_.size(); ++i) {
for (int i = 0; i < (int)collision_tile_map_.size(); ++i) {
if (getTile(i) == Tile::SLOPE_L) {
found.push_back(i);
}
@@ -472,7 +448,7 @@ void CollisionMap::setLeftSlopes() { // NOLINT(readability-make-member-function
void CollisionMap::setRightSlopes() { // NOLINT(readability-make-member-function-const)
// Recorre la habitación entera por filas buscando tiles de tipo t_slope_r
std::vector<int> found;
for (int i = 0; i < (int)tile_map_.size(); ++i) {
for (int i = 0; i < (int)collision_tile_map_.size(); ++i) {
if (getTile(i) == Tile::SLOPE_R) {
found.push_back(i);
}
@@ -505,6 +481,6 @@ void CollisionMap::setRightSlopes() { // NOLINT(readability-make-member-functio
// Calcula las superficies automaticas (conveyor belts)
void CollisionMap::setAutoSurfaces() {
std::vector<int> tile = collectAnimatedTiles();
std::vector<int> tile = collectConveyorTiles();
buildHorizontalLines(tile, conveyor_belt_floors_, false);
}

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

@@ -5,7 +5,7 @@
#include <vector> // Para vector
#include "utils/defines.hpp" // Para Tile::SIZE, Map::WIDTH, Map::HEIGHT
#include "utils/utils.hpp" // Para LineHorizontal, LineDiagonal, LineVertical
#include "utils/utils.hpp" // Para LineHorizontal, LineDiagonal, LineVertical
/**
* @brief Mapa de colisiones de una habitación
@@ -31,11 +31,10 @@ class CollisionMap {
/**
* @brief Constructor
* @param tile_map Vector con índices de tiles de la habitación
* @param tile_set_width Ancho del tileset en tiles (para calcular tipo de tile)
* @param collision_tile_map Mapa de colisiones por tile (0=vacío, 1=muro, 2=passable, 3=slope_l, 4=slope_r, 5=kill, 6=conveyor)
* @param conveyor_belt_direction Dirección de las cintas transportadoras (-1, 0, +1)
*/
CollisionMap(std::vector<int> tile_map, int tile_set_width, int conveyor_belt_direction);
CollisionMap(std::vector<int> collision_tile_map, int conveyor_belt_direction);
~CollisionMap() = default;
// Prohibir copia y movimiento
@@ -84,14 +83,13 @@ class CollisionMap {
private:
// --- Constantes ---
static constexpr int TILE_SIZE = ::Tile::SIZE; // Tamaño del tile en pixels
static constexpr int MAP_WIDTH = ::Map::WIDTH; // Ancho del mapa en tiles
static constexpr int TILE_SIZE = ::Tile::SIZE; // Tamaño del tile en pixels
static constexpr int MAP_WIDTH = ::Map::WIDTH; // Ancho del mapa en tiles
static constexpr int MAP_HEIGHT = ::Map::HEIGHT; // Alto del mapa en tiles
// --- 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
int conveyor_belt_direction_; // Dirección de conveyor belts
std::vector<int> collision_tile_map_; // Mapa de colisiones por tile
int conveyor_belt_direction_; // Dirección de conveyor belts
// --- Geometría de colisión ---
std::vector<LineHorizontal> bottom_floors_; // Superficies inferiores (suelos)
@@ -108,7 +106,7 @@ class CollisionMap {
// Helpers para recopilar tiles
auto collectBottomTiles() -> std::vector<int>; // Tiles con superficie inferior
auto collectTopTiles() -> std::vector<int>; // Tiles con superficie superior
auto collectAnimatedTiles() -> std::vector<int>; // Tiles animados (conveyor belts)
auto collectConveyorTiles() -> std::vector<int>; // Tiles conveyor belt
// Construcción de geometría
static void buildHorizontalLines(const std::vector<int>& tiles, std::vector<LineHorizontal>& lines, bool is_bottom_surface);

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

@@ -26,8 +26,8 @@ Room::Room(const std::string& room_path, std::shared_ptr<Scoreboard::Data> data)
item_manager_ = std::make_unique<ItemManager>(room->number, data_);
initializeRoom(*room);
// 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_);
// Crea el mapa de colisiones desde el collision_tile_map
collision_map_ = std::make_unique<CollisionMap>(room->collision_tile_map, conveyor_belt_direction_);
// 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_);
@@ -78,7 +78,6 @@ void Room::initializeRoom(const Data& room) {
}
}
// Dibuja el mapa en pantalla
void Room::renderMap() {
tilemap_renderer_->render();

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

@@ -9,7 +9,7 @@
#include "game/entities/enemy.hpp" // Para EnemyData
#include "game/entities/item.hpp" // Para ItemData
#include "game/gameplay/scoreboard.hpp" // Para Scoreboard::Data
#include "utils/defines.hpp" // Para Tile::SIZE, Map::WIDTH, Map::HEIGHT
#include "utils/defines.hpp" // Para Tile::SIZE, Map::WIDTH, Map::HEIGHT
#include "utils/utils.hpp" // Para LineHorizontal, LineDiagonal, LineVertical
class Sprite; // lines 12-12
class Surface; // lines 13-13
@@ -40,20 +40,21 @@ class Room {
};
struct Data {
std::string number; // Numero de la habitación
Uint8 bg_color{0}; // Color de fondo de la habitación
Uint8 border_color{0}; // Color del borde de la pantalla
Uint8 item_color1{12}; // Color 1 para los items de la habitación
Uint8 item_color2{6}; // Color 2 para los items de la habitación
std::string upper_room; // Identificador de la habitación que se encuentra arriba
std::string lower_room; // Identificador de la habitación que se encuentra abajo
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 gráficos para la habitación
int conveyor_belt_direction{0}; // Sentido en el que arrastran las superficies automáticas de la habitación
std::vector<int> tile_map; // Índice de los tiles a dibujar en la habitación (embebido desde YAML)
std::vector<Enemy::Data> enemies; // Listado con los enemigos de la habitación
std::vector<Item::Data> items; // Listado con los items que hay en la habitación
std::string number; // Numero de la habitación
Uint8 bg_color{0}; // Color de fondo de la habitación
Uint8 border_color{0}; // Color del borde de la pantalla
Uint8 item_color1{12}; // Color 1 para los items de la habitación
Uint8 item_color2{6}; // Color 2 para los items de la habitación
std::string upper_room; // Identificador de la habitación que se encuentra arriba
std::string lower_room; // Identificador de la habitación que se encuentra abajo
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 gráficos para la habitación
int conveyor_belt_direction{0}; // Sentido en el que arrastran las superficies automáticas de la habitación
std::vector<int> tile_map; // Índice de los tiles a dibujar en la habitación (embebido desde YAML)
std::vector<int> collision_tile_map; // Mapa de colisiones por tile (0=vacío, 1=sólido)
std::vector<Enemy::Data> enemies; // Listado con los enemigos de la habitación
std::vector<Item::Data> items; // Listado con los items que hay en la habitación
};
// Constructor y destructor
@@ -61,21 +62,21 @@ class Room {
~Room(); // NOLINT(modernize-use-equals-default, performance-trivially-destructible) -- defined in .cpp for unique_ptr with forward declarations
// --- Funciones ---
[[nodiscard]] auto getNumber() const -> const std::string& { return number_; } // Devuelve el numero de la habitación
[[nodiscard]] auto getBGColor() const -> Uint8 { return bg_color_; } // Devuelve el color de la habitación
[[nodiscard]] auto getBorderColor() const -> Uint8 { return border_color_; } // Devuelve el color del borde
void renderMap(); // Dibuja el mapa en pantalla
void renderEnemies(); // Dibuja los enemigos en pantalla
void renderItems(); // Dibuja los objetos en pantalla
[[nodiscard]] auto getNumber() const -> const std::string& { return number_; } // Devuelve el numero de la habitación
[[nodiscard]] auto getBGColor() const -> Uint8 { return bg_color_; } // Devuelve el color de la habitación
[[nodiscard]] auto getBorderColor() const -> Uint8 { return border_color_; } // Devuelve el color del borde
void renderMap(); // Dibuja el mapa en pantalla
void renderEnemies(); // Dibuja los enemigos en pantalla
void renderItems(); // Dibuja los objetos en pantalla
#ifdef _DEBUG
void redrawMap(); // Redibuja el mapa (para actualizar modo debug)
void updateEditorMode(float delta_time); // Actualiza animaciones sin mover enemigos (para editor)
void resetEnemyPositions(const std::vector<Enemy::Data>& enemy_data); // Resetea enemigos a posiciones iniciales
auto getEnemyManager() -> EnemyManager* { return enemy_manager_.get(); } // Acceso al gestor de enemigos (para editor)
auto getItemManager() -> ItemManager* { return item_manager_.get(); } // Acceso al gestor de items (para editor)
void setBgColor(Uint8 color); // Cambia color de fondo y redibuja (para editor)
void setItemColors(Uint8 color1, Uint8 color2); // Cambia colores de items (para editor)
void setTile(int index, int tile_value); // Cambia un tile y redibuja (para editor)
void redrawMap(); // Redibuja el mapa (para actualizar modo debug)
void updateEditorMode(float delta_time); // Actualiza animaciones sin mover enemigos (para editor)
void resetEnemyPositions(const std::vector<Enemy::Data>& enemy_data); // Resetea enemigos a posiciones iniciales
auto getEnemyManager() -> EnemyManager* { return enemy_manager_.get(); } // Acceso al gestor de enemigos (para editor)
auto getItemManager() -> ItemManager* { return item_manager_.get(); } // Acceso al gestor de items (para editor)
void setBgColor(Uint8 color); // Cambia color de fondo y redibuja (para editor)
void setItemColors(Uint8 color1, Uint8 color2); // Cambia colores de items (para editor)
void setTile(int index, int tile_value); // Cambia un tile y redibuja (para editor)
[[nodiscard]] auto getTileSetFile() const -> const std::string& { return tile_set_file_; }
[[nodiscard]] auto getTileSetWidth() const -> int { return tile_set_width_; }
#endif
@@ -107,8 +108,8 @@ class Room {
private:
// Constantes
static constexpr int TILE_SIZE = ::Tile::SIZE; // Ancho del tile en pixels
static constexpr int MAP_WIDTH = ::Map::WIDTH; // Ancho del mapa en tiles
static constexpr int TILE_SIZE = ::Tile::SIZE; // Ancho del tile en pixels
static constexpr int MAP_WIDTH = ::Map::WIDTH; // Ancho del mapa en tiles
static constexpr int MAP_HEIGHT = ::Map::HEIGHT; // Alto del mapa en tiles
// Objetos y punteros

45
source/game/gameplay/room_loader.cpp
View File

@@ -119,20 +119,12 @@ void RoomLoader::parseRoomConnections(const fkyaml::node& conn_node, Room::Data&
: "0";
}
// Parsea el tilemap de la habitación
void RoomLoader::parseTilemap(const fkyaml::node& yaml, Room::Data& room, const std::string& file_name, bool verbose) { // NOLINT(readability-convert-member-functions-to-static)
if (!yaml.contains("tilemap")) {
std::cerr << "Warning: No tilemap found in " << file_name << '\n';
return;
}
const auto& tilemap_node = yaml["tilemap"];
// Read 2D array
// Lee un array 2D de enteros desde un nodo YAML
static auto readTilemap2D(const fkyaml::node& node) -> std::vector<std::vector<int>> {
std::vector<std::vector<int>> tilemap_2d;
tilemap_2d.reserve(Map::HEIGHT);
for (const auto& row_node : tilemap_node) {
for (const auto& row_node : node) {
std::vector<int> row;
row.reserve(Map::WIDTH);
@@ -143,11 +135,36 @@ void RoomLoader::parseTilemap(const fkyaml::node& yaml, Room::Data& room, const
tilemap_2d.push_back(row);
}
// Convert to 1D flat array
room.tile_map = flattenTilemap(tilemap_2d);
return tilemap_2d;
}
// Parsea el tilemap de la habitación
void RoomLoader::parseTilemap(const fkyaml::node& yaml, Room::Data& room, const std::string& file_name, bool verbose) { // NOLINT(readability-convert-member-functions-to-static)
if (!yaml.contains("tilemap")) {
std::cerr << "Warning: No tilemap found in " << file_name << '\n';
return;
}
const auto& tilemap_node = yaml["tilemap"];
// Nuevo formato: tilemap.draw + tilemap.collision
if (tilemap_node.contains("draw")) {
room.tile_map = flattenTilemap(readTilemap2D(tilemap_node["draw"]));
if (tilemap_node.contains("collision")) {
room.collision_tile_map = flattenTilemap(readTilemap2D(tilemap_node["collision"]));
}
} else {
// Formato antiguo: tilemap es directamente el array 2D de dibujo
room.tile_map = flattenTilemap(readTilemap2D(tilemap_node));
}
if (verbose) {
std::cout << "Loaded tilemap: " << room.tile_map.size() << " tiles\n";
std::cout << "Loaded tilemap: " << room.tile_map.size() << " tiles";
if (!room.collision_tile_map.empty()) {
std::cout << " + collision: " << room.collision_tile_map.size() << " tiles";
}
std::cout << '\n';
}
}

8
source/game/gameplay/scoreboard.cpp
View File

@@ -95,9 +95,7 @@ void Scoreboard::fillTexture() {
// Valores formateados
const std::string LIVES_STR = std::to_string(data_->lives);
const std::string ITEMS_STR = std::to_string(data_->items);
const std::string TIME_STR = std::to_string((clock_.minutes % 100) / 10) + std::to_string(clock_.minutes % 10)
+ clock_.separator
+ std::to_string((clock_.seconds % 60) / 10) + std::to_string(clock_.seconds % 10);
const std::string TIME_STR = std::to_string((clock_.minutes % 100) / 10) + std::to_string(clock_.minutes % 10) + clock_.separator + std::to_string((clock_.seconds % 60) / 10) + std::to_string(clock_.seconds % 10);
// --- Línea 1: vides X - objectes X - temps MM:SS (centrada) ---
const std::string LIVES_LABEL = Locale::get()->get("scoreboard.lives");
@@ -105,9 +103,7 @@ void Scoreboard::fillTexture() {
const std::string TIME_LABEL = Locale::get()->get("scoreboard.time");
// Ancho total: labels proporcionales + valores monoespaciados
const int LINE1_W = text->length(LIVES_LABEL) + text->lengthMono(LIVES_STR, MONO_W)
+ text->length(SEP) + text->length(ITEMS_LABEL) + text->lengthMono(ITEMS_STR, MONO_W)
+ text->length(SEP) + text->length(TIME_LABEL) + text->lengthMono(TIME_STR, MONO_W);
const int LINE1_W = text->length(LIVES_LABEL) + text->lengthMono(LIVES_STR, MONO_W) + text->length(SEP) + text->length(ITEMS_LABEL) + text->lengthMono(ITEMS_STR, MONO_W) + text->length(SEP) + text->length(TIME_LABEL) + text->lengthMono(TIME_STR, MONO_W);
int x = (CANVAS_W - LINE1_W) / 2;
text->writeColored(x, LINE1_Y, LIVES_LABEL, LABEL_COLOR);

12
source/game/gameplay/tilemap_renderer.hpp
View File

@@ -92,12 +92,12 @@ class TilemapRenderer {
};
// === Constantes ===
static constexpr int TILE_SIZE = Tile::SIZE; // Ancho del tile en pixels
static constexpr int MAP_WIDTH = Map::WIDTH; // Ancho del mapa en tiles
static constexpr int MAP_HEIGHT = Map::HEIGHT; // Alto del mapa en tiles
static constexpr int PLAY_AREA_WIDTH = PlayArea::WIDTH; // Ancho del área de juego en pixels
static constexpr int PLAY_AREA_HEIGHT = PlayArea::HEIGHT; // Alto del área de juego en pixels
static constexpr float CONVEYOR_FRAME_DURATION = 0.05F; // Duración de cada frame (3 frames @ 60fps)
static constexpr int TILE_SIZE = Tile::SIZE; // Ancho del tile en pixels
static constexpr int MAP_WIDTH = Map::WIDTH; // Ancho del mapa en tiles
static constexpr int MAP_HEIGHT = Map::HEIGHT; // Alto del mapa en tiles
static constexpr int PLAY_AREA_WIDTH = PlayArea::WIDTH; // Ancho del área de juego en pixels
static constexpr int PLAY_AREA_HEIGHT = PlayArea::HEIGHT; // 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

2
source/game/scene_manager.hpp
View File

@@ -25,7 +25,7 @@ namespace SceneManager {
};
// --- Variables de estado globales ---
inline Scene current = Scene::LOGO; // Escena actual (en _DEBUG sobrescrito por Director tras cargar debug.yaml)
inline Scene current = Scene::LOGO; // Escena actual (en _DEBUG sobrescrito por Director tras cargar debug.yaml)
inline Options options = Options::LOGO_TO_TITLE; // Opciones de la escena actual
inline Scene scene_before_restart = Scene::LOGO; // escena a relanzar tras RESTART_CURRENT

4
source/game/scenes/game.cpp
View File

@@ -15,7 +15,7 @@
#include "core/rendering/text.hpp" // Para Text, Text::CENTER_FLAG, Text::COLOR_FLAG
#include "core/resources/resource_cache.hpp" // Para ResourceRoom, Resource
#include "core/resources/resource_list.hpp" // Para Asset
#include "core/system/event_buffer.hpp" // Para EventBuffer
#include "core/system/event_buffer.hpp" // Para EventBuffer
#include "core/system/global_events.hpp" // Para check
#include "game/defaults.hpp" // Para Defaults::Game
#include "game/game_control.hpp" // Para GameControl
@@ -29,7 +29,7 @@
#include "game/ui/console.hpp" // Para Console
#include "game/ui/notifier.hpp" // Para Notifier, NotificationText, CHEEVO_NO...
#include "utils/defines.hpp" // Para Tile::SIZE, PlayArea::HEIGHT, RoomBorder::BOTTOM
#include "utils/easing_functions.hpp" // Para Easing::cubicInOut
#include "utils/easing_functions.hpp" // Para Easing::cubicInOut
#include "utils/utils.hpp"
#ifdef _DEBUG

9
source/game/scenes/game.hpp
View File

@@ -112,15 +112,14 @@ class Game {
float fade_accumulator_{0.0F}; // Acumulador de tiempo para el fade
// Transición animada entre pantallas
bool transitioning_{false}; // Indica si hay una transición en curso
float transition_timer_{0.0F}; // Tiempo transcurrido en la transición
std::shared_ptr<Room> transition_old_room_; // Habitación saliente (se mantiene viva durante la transición)
Room::Border transition_direction_{Room::Border::NONE}; // Dirección de la transición
bool transitioning_{false}; // Indica si hay una transición en curso
float transition_timer_{0.0F}; // Tiempo transcurrido en la transición
std::shared_ptr<Room> transition_old_room_; // Habitación saliente (se mantiene viva durante la transición)
Room::Border transition_direction_{Room::Border::NONE}; // Dirección de la transición
// Variables de demo mode
DemoData demo_; // Variables para el modo demo
#ifdef _DEBUG
// Variables de debug para arrastre con ratón
bool debug_dragging_player_{false}; // Indica si estamos arrastrando al jugador con el ratón

2
source/game/scenes/logo.cpp
View File

@@ -13,7 +13,7 @@
#include "core/rendering/sprite/sprite.hpp" // Para SSprite
#include "core/rendering/surface.hpp" // Para Surface
#include "core/resources/resource_cache.hpp" // Para Resource
#include "core/system/event_buffer.hpp" // Para EventBuffer
#include "core/system/event_buffer.hpp" // Para EventBuffer
#include "core/system/global_events.hpp" // Para check
#include "game/options.hpp" // Para Options, SectionState, options, Section
#include "game/scene_manager.hpp" // Para SceneManager

9
source/game/scenes/title.cpp
View File

@@ -14,7 +14,7 @@
#include "core/rendering/text.hpp" // Para Text, Text::CENTER_FLAG, Text::COLOR_FLAG
#include "core/resources/resource_cache.hpp" // Para Resource
#include "core/resources/resource_list.hpp" // Para Asset
#include "core/system/event_buffer.hpp" // Para EventBuffer
#include "core/system/event_buffer.hpp" // Para EventBuffer
#include "core/system/global_events.hpp" // Para check
#include "game/gameplay/cheevos.hpp" // Para Cheevos, Achievement
#include "game/options.hpp" // Para Options, options, SectionState, Section
@@ -42,9 +42,9 @@ Title::Title()
SceneManager::options = SceneManager::Options::NONE;
// Acciones iniciales
createCheevosTexture(); // Crea y rellena la textura para mostrar los logros
Screen::get()->setBorderColor(0); // Cambia el color del borde
Audio::get()->playMusic("574071_EA_DTV.ogg"); // Inicia la musica
createCheevosTexture(); // Crea y rellena la textura para mostrar los logros
Screen::get()->setBorderColor(0); // Cambia el color del borde
Audio::get()->playMusic("574071_EA_DTV.ogg"); // Inicia la musica
}
// Destructor
@@ -233,7 +233,6 @@ void Title::updateMainMenu(float delta_time) {
// Actualiza el estado CHEEVOS_MENU
void Title::updateCheevosMenu(float delta_time) {
// Determina la velocidad objetivo basada en el input
float target_velocity = 0.0F;
if (Input::get()->checkAction(InputAction::RIGHT, Input::ALLOW_REPEAT)) {

15
source/game/scenes/title.hpp
View File

@@ -5,6 +5,7 @@
#include <array> // Para std::array
#include <memory> // Para shared_ptr
#include <string> // Para string
#include "game/scene_manager.hpp" // Para SceneManager::Scene
#include "utils/delta_timer.hpp" // Para DeltaTimer
class Sprite; // Forward declaration
@@ -68,13 +69,13 @@ class Title {
// --- Variables miembro ---
// Objetos y punteros
std::shared_ptr<Surface> game_logo_surface_; // Textura con los graficos
std::unique_ptr<Sprite> game_logo_sprite_; // SSprite para manejar la surface
std::shared_ptr<Surface> cheevos_surface_; // Textura con la lista de logros
std::unique_ptr<Sprite> cheevos_sprite_; // SSprite para manejar la surface con la lista de logros
std::shared_ptr<Surface> title_surface_; // Surface donde se dibuja toda la clase
std::unique_ptr<DeltaTimer> delta_timer_; // Timer para delta time
std::shared_ptr<Text> menu_text_; // Texto para los menus
std::shared_ptr<Surface> game_logo_surface_; // Textura con los graficos
std::unique_ptr<Sprite> game_logo_sprite_; // SSprite para manejar la surface
std::shared_ptr<Surface> cheevos_surface_; // Textura con la lista de logros
std::unique_ptr<Sprite> cheevos_sprite_; // SSprite para manejar la surface con la lista de logros
std::shared_ptr<Surface> title_surface_; // Surface donde se dibuja toda la clase
std::unique_ptr<DeltaTimer> delta_timer_; // Timer para delta time
std::shared_ptr<Text> menu_text_; // Texto para los menus
// Variables de estado del menú de logros
SDL_FRect cheevos_surface_view_; // Zona visible de la surface con el listado de logros

9
source/game/ui/console_commands.cpp
View File

@@ -707,6 +707,15 @@ static auto cmdEdit(const std::vector<std::string>& args) -> std::string { // N
if (args[1] == "INFO") { return MapEditor::get()->showInfo(show); }
if (args[1] == "GRID") { return MapEditor::get()->showGrid(show); }
}
// EDIT DRAW / EDIT COLLISION
if (args[0] == "DRAW") {
if ((MapEditor::get() == nullptr) || !MapEditor::get()->isActive()) { return "Editor not active"; }
return MapEditor::get()->setEditingCollision(false);
}
if (args[0] == "COLLISION") {
if ((MapEditor::get() == nullptr) || !MapEditor::get()->isActive()) { return "Editor not active"; }
return MapEditor::get()->setEditingCollision(true);
}
// EDIT MAPBG/MAPCONN <color>
if (args[0] == "MAPBG" && args.size() >= 2) {
if ((MapEditor::get() == nullptr) || !MapEditor::get()->isActive()) { return "Editor not active"; }