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

clang-tidy

Browse Source
This commit is contained in:
Sergio
2026-04-07 12:06:41 +02:00
parent 39170a086e
commit 5462b31f96
12 changed files with 63 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
source/core/rendering/text.cpp
View File

@@ -240,7 +240,7 @@ void Text::writeColoredMono(int x, int y, const std::string& text, Uint8 color,
} }
// Obtiene la longitud en pixels de una cadena monoespaciada // Obtiene la longitud en pixels de una cadena monoespaciada
auto Text::lengthMono(const std::string& text, int cell_w) const -> int { auto Text::lengthMono(const std::string& text, int cell_w) -> int {
size_t pos = 0; size_t pos = 0;
int count = 0; int count = 0;
while (pos < text.size()) { while (pos < text.size()) {

2
source/core/rendering/text.hpp
View File

@@ -50,7 +50,7 @@ class Text {
void writeColoredMono(int x, int y, const std::string& text, Uint8 color, int cell_w); // Escribe texto monoespaciado con color void writeColoredMono(int x, int y, const std::string& text, Uint8 color, int cell_w); // Escribe texto monoespaciado con color
[[nodiscard]] auto length(const std::string& text, int kerning = 1) const -> int; // Obtiene la longitud en pixels de una cadena [[nodiscard]] auto length(const std::string& text, int kerning = 1) const -> int; // Obtiene la longitud en pixels de una cadena
[[nodiscard]] auto lengthMono(const std::string& text, int cell_w) const -> int; // Obtiene la longitud en pixels de una cadena monoespaciada [[nodiscard]] static auto lengthMono(const std::string& text, int cell_w) -> int; // Obtiene la longitud en pixels de una cadena monoespaciada
[[nodiscard]] auto getCharacterSize() const -> int; // Devuelve el tamaño del caracter [[nodiscard]] auto getCharacterSize() const -> int; // Devuelve el tamaño del caracter
[[nodiscard]] auto glyphWidth(uint32_t codepoint, int kerning = 0) const -> int; // Devuelve el ancho en pixels de un glifo [[nodiscard]] auto glyphWidth(uint32_t codepoint, int kerning = 0) const -> int; // Devuelve el ancho en pixels de un glifo
[[nodiscard]] auto getGlyphClip(uint32_t codepoint) const -> SDL_FRect; // Devuelve el clip rect del glifo [[nodiscard]] auto getGlyphClip(uint32_t codepoint) const -> SDL_FRect; // Devuelve el clip rect del glifo

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

@@ -223,7 +223,7 @@ void Player::moveHorizontal(float delta_time) {
} }
const auto& tc = room_->getTileCollider(); const auto& tc = room_->getTileCollider();
float new_x = x_ + vx_ * delta_time; float new_x = x_ + (vx_ * delta_time);
// Colisión con paredes // Colisión con paredes
if (vx_ < 0.0F) { if (vx_ < 0.0F) {
@@ -431,9 +431,9 @@ void Player::transitionToState(State state) {
// Bordes de pantalla // Bordes de pantalla
// ============================================================================ // ============================================================================
auto Player::handleBorders() -> Room::Border { auto Player::handleBorders() const -> Room::Border {
const float CENTER_X = x_ + WIDTH / 2.0F; const float CENTER_X = x_ + (WIDTH / 2.0F);
const float CENTER_Y = y_ + HEIGHT / 2.0F; const float CENTER_Y = y_ + (HEIGHT / 2.0F);
if (CENTER_X < PlayArea::LEFT) { return Room::Border::LEFT; } if (CENTER_X < PlayArea::LEFT) { return Room::Border::LEFT; }
if (CENTER_X > PlayArea::RIGHT) { return Room::Border::RIGHT; } if (CENTER_X > PlayArea::RIGHT) { return Room::Border::RIGHT; }

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

@@ -143,7 +143,7 @@ class Player {
void syncSpriteAndCollider(); void syncSpriteAndCollider();
void placeSprite(); void placeSprite();
void animate(float delta_time); void animate(float delta_time);
auto handleBorders() -> Room::Border; auto handleBorders() const -> Room::Border;
// --- Inicialización --- // --- Inicialización ---
void initSprite(const std::string& animations_path); void initSprite(const std::string& animations_path);

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

@@ -12,12 +12,12 @@ class Scoreboard {
public: public:
// Tipos anidados // Tipos anidados
struct Data { struct Data {
int items{0}; // Lleva la cuenta de los objetos recogidos int items{0}; // Lleva la cuenta de los objetos recogidos
int lives{0}; // Lleva la cuenta de las vidas restantes del jugador int lives{0}; // Lleva la cuenta de las vidas restantes del jugador
int rooms{0}; // Lleva la cuenta de las habitaciones visitadas int rooms{0}; // Lleva la cuenta de las habitaciones visitadas
bool music{true}; // Indica si ha de sonar la música durante el juego bool music{true}; // Indica si ha de sonar la música durante el juego
Uint8 color{0}; // Color para escribir el texto del marcador Uint8 color{0}; // Color para escribir el texto del marcador
Uint32 ini_clock{0}; // Tiempo inicial para calcular el tiempo transcurrido Uint32 ini_clock{0}; // Tiempo inicial para calcular el tiempo transcurrido
}; };
// Métodos públicos // Métodos públicos

14
source/game/gameplay/tile_collider.cpp
View File

@@ -14,7 +14,7 @@ auto TileCollider::getTileAt(int tile_x, int tile_y) const -> Tile {
if (tile_x < 0 || tile_x >= MW || tile_y < 0 || tile_y >= MH) { if (tile_x < 0 || tile_x >= MW || tile_y < 0 || tile_y >= MH) {
return Tile::EMPTY; return Tile::EMPTY;
} }
int value = tile_map_[tile_y * MW + tile_x]; int value = tile_map_[(tile_y * MW) + tile_x];
if (value >= 0 && value <= 5) { if (value >= 0 && value <= 5) {
return static_cast<Tile>(value); return static_cast<Tile>(value);
} }
@@ -30,7 +30,7 @@ auto TileCollider::isSolid(int tile_x, int tile_y) const -> bool {
// SLOPE_L (\): alto a la izquierda, bajo a la derecha. surface = bottom - (7 - x_in_tile) // SLOPE_L (\): alto a la izquierda, bajo a la derecha. surface = bottom - (7 - x_in_tile)
// SLOPE_R (/): alto a la derecha, bajo a la izquierda. surface = bottom - x_in_tile // SLOPE_R (/): alto a la derecha, bajo a la izquierda. surface = bottom - x_in_tile
auto TileCollider::getSlopeY(int tile_x, int tile_y, float px) const -> float { auto TileCollider::getSlopeY(int tile_x, int tile_y, float px) const -> float {
float tile_bottom = static_cast<float>((tile_y + 1) * TS - 1); auto tile_bottom = static_cast<float>(((tile_y + 1) * TS) - 1);
float x_in_tile = px - static_cast<float>(tile_x * TS); float x_in_tile = px - static_cast<float>(tile_x * TS);
x_in_tile = std::clamp(x_in_tile, 0.0F, static_cast<float>(TS - 1)); x_in_tile = std::clamp(x_in_tile, 0.0F, static_cast<float>(TS - 1));
@@ -96,6 +96,7 @@ auto TileCollider::checkCeiling(float x, float y, float w) const -> float {
// SLOPE: solo si los pies estaban por encima de la superficie Y el jugador no está // SLOPE: solo si los pies estaban por encima de la superficie Y el jugador no está
// parcialmente dentro de otra slope (evita aterrizar al hacer drop-through // parcialmente dentro de otra slope (evita aterrizar al hacer drop-through
// o al saltar a través de una slope desde abajo). // o al saltar a través de una slope desde abajo).
// NOLINTNEXTLINE(readability-function-cognitive-complexity)
auto TileCollider::checkFloor(float x, float foot_y_current, float w, float foot_y_new) const -> FloorHit { auto TileCollider::checkFloor(float x, float foot_y_current, float w, float foot_y_new) const -> FloorHit {
int start_row = toTile(static_cast<int>(foot_y_current)); int start_row = toTile(static_cast<int>(foot_y_current));
int end_row = toTile(static_cast<int>(foot_y_new)); int end_row = toTile(static_cast<int>(foot_y_new));
@@ -115,7 +116,7 @@ auto TileCollider::checkFloor(float x, float foot_y_current, float w, float foot
if (tile == Tile::WALL) { if (tile == Tile::WALL) {
floor_y = static_cast<float>(row * TS); floor_y = static_cast<float>(row * TS);
} else if (tile == Tile::PASSABLE) { } else if (tile == Tile::PASSABLE) {
float tile_top = static_cast<float>(row * TS); auto tile_top = static_cast<float>(row * TS);
// Solo cuenta como suelo si los pies estaban por encima antes del movimiento // Solo cuenta como suelo si los pies estaban por encima antes del movimiento
if (foot_y_current <= tile_top) { if (foot_y_current <= tile_top) {
floor_y = tile_top; floor_y = tile_top;
@@ -130,7 +131,7 @@ auto TileCollider::checkFloor(float x, float foot_y_current, float w, float foot
} }
if (floor_y != Collision::NONE && (best.y == Collision::NONE || floor_y < best.y)) { if (floor_y != Collision::NONE && (best.y == Collision::NONE || floor_y < best.y)) {
best = {floor_y, tile, col, row}; best = {.y = floor_y, .type = tile, .tile_x = col, .tile_y = row};
} }
} }
} }
@@ -193,6 +194,7 @@ auto TileCollider::isInsideAnySlope(float x, float foot_y, float w) const -> boo
// Busca una slope directamente debajo del jugador (para transición ground→slope). // Busca una slope directamente debajo del jugador (para transición ground→slope).
// Escanea la fila de los pies Y la fila superior: las slopes en escalera siempre // Escanea la fila de los pies Y la fila superior: las slopes en escalera siempre
// tienen el tile de entrada una fila arriba del suelo desde el que se accede. // tienen el tile de entrada una fila arriba del suelo desde el que se accede.
// NOLINTNEXTLINE(readability-function-cognitive-complexity)
auto TileCollider::checkSlopeBelow(float x, float foot_y, float w) const -> SlopeInfo { auto TileCollider::checkSlopeBelow(float x, float foot_y, float w) const -> SlopeInfo {
int foot_row = toTile(static_cast<int>(foot_y)); int foot_row = toTile(static_cast<int>(foot_y));
int left_col = toTile(static_cast<int>(x)); int left_col = toTile(static_cast<int>(x));
@@ -205,14 +207,14 @@ auto TileCollider::checkSlopeBelow(float x, float foot_y, float w) const -> Slop
float foot_x = (col == left_col) ? x : x + w - 1; float foot_x = (col == left_col) ? x : x + w - 1;
float slope_y = getSlopeY(col, row, foot_x); float slope_y = getSlopeY(col, row, foot_x);
if (slope_y <= foot_y && slope_y >= foot_y - TS) { if (slope_y <= foot_y && slope_y >= foot_y - TS) {
return {true, Tile::SLOPE_L, col, row, slope_y}; return {.on_slope = true, .type = Tile::SLOPE_L, .tile_x = col, .tile_y = row, .surface_y = slope_y};
} }
} }
if (tile == Tile::SLOPE_R) { if (tile == Tile::SLOPE_R) {
float foot_x = (col == right_col) ? x + w - 1 : x; float foot_x = (col == right_col) ? x + w - 1 : x;
float slope_y = getSlopeY(col, row, foot_x); float slope_y = getSlopeY(col, row, foot_x);
if (slope_y <= foot_y && slope_y >= foot_y - TS) { if (slope_y <= foot_y && slope_y >= foot_y - TS) {
return {true, Tile::SLOPE_R, col, row, slope_y}; return {.on_slope = true, .type = Tile::SLOPE_R, .tile_x = col, .tile_y = row, .surface_y = slope_y};
} }
} }
} }

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

@@ -71,7 +71,6 @@ Game::Game(Mode mode)
game_backbuffer_surface_ = std::make_shared<Surface>(Options::game.width, Options::game.height); game_backbuffer_surface_ = std::make_shared<Surface>(Options::game.width, Options::game.height);
changeRoom(current_room_); changeRoom(current_room_);
#ifdef _DEBUG #ifdef _DEBUG
Console::get()->setScope("debug"); Console::get()->setScope("debug");
#else #else
@@ -331,7 +330,6 @@ void Game::updatePlaying(float delta_time) {
checkPlayerAndEnemies(); checkPlayerAndEnemies();
checkIfPlayerIsAlive(); checkIfPlayerIsAlive();
// Avanzar transición // Avanzar transición
if (transitioning_) { if (transitioning_) {
transition_timer_ += delta_time; transition_timer_ += delta_time;
@@ -906,7 +904,6 @@ void Game::togglePause() {
scoreboard_->setPaused(paused_); scoreboard_->setPaused(paused_);
} }
// Inicializa al jugador // Inicializa al jugador
void Game::initPlayer(const Player::SpawnData& spawn_point, std::shared_ptr<Room> room) { // NOLINT(readability-convert-member-functions-to-static) void Game::initPlayer(const Player::SpawnData& spawn_point, std::shared_ptr<Room> room) { // NOLINT(readability-convert-member-functions-to-static)
const bool IGNORE_INPUT = player_ != nullptr && player_->getIgnoreInput(); const bool IGNORE_INPUT = player_ != nullptr && player_->getIgnoreInput();

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

@@ -31,9 +31,9 @@ class Title {
}; };
// --- Constantes de tiempo (en segundos) --- // --- Constantes de tiempo (en segundos) ---
static constexpr float FADE_STEP_INTERVAL = 0.05F; // Intervalo entre pasos de fade (antes cada 4 frames) static constexpr float FADE_STEP_INTERVAL = 0.05F; // Intervalo entre pasos de fade (antes cada 4 frames)
static constexpr float POST_FADE_DELAY = 1.0F; // Delay después del fade (pantalla en negro) static constexpr float POST_FADE_DELAY = 1.0F; // Delay después del fade (pantalla en negro)
static constexpr float KEYBOARD_REMAP_DISPLAY_DELAY = 2.0F; // Tiempo mostrando teclas definidas antes de guardar static constexpr float KEYBOARD_REMAP_DISPLAY_DELAY = 2.0F; // Tiempo mostrando teclas definidas antes de guardar
// --- Métodos --- // --- Métodos ---
void handleEvents(); // Comprueba el manejador de eventos void handleEvents(); // Comprueba el manejador de eventos
void handleMainMenuKeyPress(SDL_Keycode key); // Maneja las teclas del menu principal void handleMainMenuKeyPress(SDL_Keycode key); // Maneja las teclas del menu principal

6
source/main.cpp
View File

@@ -13,7 +13,7 @@ Empezado en Castalla el 01/07/2022.
#include "core/system/director.hpp" #include "core/system/director.hpp"
#include "core/system/event_buffer.hpp" #include "core/system/event_buffer.hpp"
SDL_AppResult SDL_AppInit(void** appstate, int argc, char* argv[]) { auto SDL_AppInit(void** appstate, int argc, char* argv[]) -> SDL_AppResult {
(void)argc; (void)argc;
(void)argv; (void)argv;
@@ -22,13 +22,13 @@ SDL_AppResult SDL_AppInit(void** appstate, int argc, char* argv[]) {
return SDL_APP_CONTINUE; return SDL_APP_CONTINUE;
} }
SDL_AppResult SDL_AppEvent(void* appstate, SDL_Event* event) { auto SDL_AppEvent(void* appstate, SDL_Event* event) -> SDL_AppResult {
(void)appstate; (void)appstate;
EventBuffer::events.push_back(*event); EventBuffer::events.push_back(*event);
return SDL_APP_CONTINUE; return SDL_APP_CONTINUE;
} }
SDL_AppResult SDL_AppIterate(void* appstate) { auto SDL_AppIterate(void* appstate) -> SDL_AppResult {
auto* director = static_cast<Director*>(appstate); auto* director = static_cast<Director*>(appstate);
return director->iterate(); return director->iterate();
} }

60
source/utils/color.cpp
View File

@@ -12,39 +12,39 @@ auto Color::fromString(const std::string& name) -> Uint8 {
// Incluye nombres oficiales del CPC y aliases para compatibilidad // Incluye nombres oficiales del CPC y aliases para compatibilidad
static const std::unordered_map<std::string, Uint8> COLOR_MAP = { static const std::unordered_map<std::string, Uint8> COLOR_MAP = {
// Transparente // Transparente
{"transparent", index(Cpc::CLEAR)}, {"transparent", getIndex(Cpc::CLEAR)},
// Colores oficiales Amstrad CPC // Colores oficiales Amstrad CPC
{"black", index(Cpc::BLACK)}, {"black", getIndex(Cpc::BLACK)},
{"blue", index(Cpc::BLUE)}, {"blue", getIndex(Cpc::BLUE)},
{"bright_blue", index(Cpc::BRIGHT_BLUE)}, {"bright_blue", getIndex(Cpc::BRIGHT_BLUE)},
{"red", index(Cpc::RED)}, {"red", getIndex(Cpc::RED)},
{"magenta", index(Cpc::MAGENTA)}, {"magenta", getIndex(Cpc::MAGENTA)},
{"mauve", index(Cpc::MAUVE)}, {"mauve", getIndex(Cpc::MAUVE)},
{"bright_red", index(Cpc::BRIGHT_RED)}, {"bright_red", getIndex(Cpc::BRIGHT_RED)},
{"purple", index(Cpc::PURPLE)}, {"purple", getIndex(Cpc::PURPLE)},
{"bright_magenta", index(Cpc::BRIGHT_MAGENTA)}, {"bright_magenta", getIndex(Cpc::BRIGHT_MAGENTA)},
{"green", index(Cpc::GREEN)}, {"green", getIndex(Cpc::GREEN)},
{"cyan", index(Cpc::CYAN)}, {"cyan", getIndex(Cpc::CYAN)},
{"sky_blue", index(Cpc::SKY_BLUE)}, {"sky_blue", getIndex(Cpc::SKY_BLUE)},
{"yellow", index(Cpc::YELLOW)}, {"yellow", getIndex(Cpc::YELLOW)},
{"white", index(Cpc::WHITE)}, {"white", getIndex(Cpc::WHITE)},
{"pastel_blue", index(Cpc::PASTEL_BLUE)}, {"pastel_blue", getIndex(Cpc::PASTEL_BLUE)},
{"orange", index(Cpc::ORANGE)}, {"orange", getIndex(Cpc::ORANGE)},
{"pink", index(Cpc::PINK)}, {"pink", getIndex(Cpc::PINK)},
{"pastel_magenta", index(Cpc::PASTEL_MAGENTA)}, {"pastel_magenta", getIndex(Cpc::PASTEL_MAGENTA)},
{"bright_green", index(Cpc::BRIGHT_GREEN)}, {"bright_green", getIndex(Cpc::BRIGHT_GREEN)},
{"sea_green", index(Cpc::SEA_GREEN)}, {"sea_green", getIndex(Cpc::SEA_GREEN)},
{"bright_cyan", index(Cpc::BRIGHT_CYAN)}, {"bright_cyan", getIndex(Cpc::BRIGHT_CYAN)},
{"lime", index(Cpc::LIME)}, {"lime", getIndex(Cpc::LIME)},
{"pastel_green", index(Cpc::PASTEL_GREEN)}, {"pastel_green", getIndex(Cpc::PASTEL_GREEN)},
{"pastel_cyan", index(Cpc::PASTEL_CYAN)}, {"pastel_cyan", getIndex(Cpc::PASTEL_CYAN)},
{"bright_yellow", index(Cpc::BRIGHT_YELLOW)}, {"bright_yellow", getIndex(Cpc::BRIGHT_YELLOW)},
{"pastel_yellow", index(Cpc::PASTEL_YELLOW)}, {"pastel_yellow", getIndex(Cpc::PASTEL_YELLOW)},
{"bright_white", index(Cpc::BRIGHT_WHITE)}, {"bright_white", getIndex(Cpc::BRIGHT_WHITE)},
// Aliases para compatibilidad con archivos YAML existentes (Spectrum) // Aliases para compatibilidad con archivos YAML existentes (Spectrum)
{"bright_black", index(Cpc::BLACK)}, // No existe en CPC, mapea a negro {"bright_black", getIndex(Cpc::BLACK)}, // No existe en CPC, mapea a negro
}; };
auto it = COLOR_MAP.find(name); auto it = COLOR_MAP.find(name);
@@ -53,5 +53,5 @@ auto Color::fromString(const std::string& name) -> Uint8 {
} }
// Si no se encuentra, devuelve negro por defecto // Si no se encuentra, devuelve negro por defecto
return index(Cpc::BLACK); return getIndex(Cpc::BLACK);
} }

2
source/utils/color.hpp
View File

@@ -78,7 +78,7 @@ class Color {
* @param color Color del enum Cpc * @param color Color del enum Cpc
* @return Índice de paleta (Uint8) * @return Índice de paleta (Uint8)
*/ */
static constexpr auto index(Cpc color) -> Uint8 { static constexpr auto getIndex(Cpc color) -> Uint8 { // NOLINT(readability-identifier-naming)
return static_cast<Uint8>(color); return static_cast<Uint8>(color);
} }

10
source/utils/utils.hpp
View File

@@ -26,11 +26,11 @@ struct Rgb {
}; };
// COLISIONES Y GEOMETRÍA // COLISIONES Y GEOMETRÍA
auto distanceSquared(int x1, int y1, int x2, int y2) -> double; // Distancia² entre dos puntos auto distanceSquared(int x1, int y1, int x2, int y2) -> double; // Distancia² entre dos puntos
auto checkCollision(const Circle& a, const Circle& b) -> bool; // Colisión círculo-círculo auto checkCollision(const Circle& a, const Circle& b) -> bool; // Colisión círculo-círculo
auto checkCollision(const Circle& a, const SDL_FRect& rect) -> bool; // Colisión círculo-rectángulo auto checkCollision(const Circle& a, const SDL_FRect& rect) -> bool; // Colisión círculo-rectángulo
auto checkCollision(const SDL_FRect& a, const SDL_FRect& b) -> bool; // Colisión rectángulo-rectángulo auto checkCollision(const SDL_FRect& a, const SDL_FRect& b) -> bool; // Colisión rectángulo-rectángulo
auto checkCollision(const SDL_FPoint& p, const SDL_FRect& r) -> bool; // Colisión punto-rectángulo auto checkCollision(const SDL_FPoint& p, const SDL_FRect& r) -> bool; // Colisión punto-rectángulo
// CONVERSIONES DE TIPOS SDL // CONVERSIONES DE TIPOS SDL
auto toSDLRect(const SDL_FRect& frect) -> SDL_Rect; // Convierte SDL_FRect a SDL_Rect auto toSDLRect(const SDL_FRect& frect) -> SDL_Rect; // Convierte SDL_FRect a SDL_Rect
auto toSDLPoint(const SDL_FPoint& fpoint) -> SDL_Point; // Convierte SDL_FPoint a SDL_Point auto toSDLPoint(const SDL_FPoint& fpoint) -> SDL_Point; // Convierte SDL_FPoint a SDL_Point