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

Lint: clang-tidy --fix mecánico (trailing return, default member init, auto, enum size)

Browse Source 
Pase automático de clang-tidy --fix sobre el conjunto de checks que son
puro transform de sintaxis y no rompen API. Invocado con
--format-style=none para que clang-tidy NO arrastre clang-format sobre
las líneas tocadas (evita la regla NamespaceIndentation: All del
.clang-format reformateando solo trozos del archivo).

Checks aplicados:

- modernize-use-trailing-return-type (193 hits): 'int foo()' →
  'auto foo() -> int'. Estilo coherente con la convención del proyecto.
- modernize-use-default-member-init (36 hits): inicialización de
  miembros pasa de la lista del constructor a la declaración. Reduce
  duplicación cuando hay varios constructores con los mismos defaults.
- modernize-use-auto (6 hits): tipos largos sustituidos por auto donde
  el tipo es evidente del contexto (new T, dynamic_cast, etc).
- modernize-use-starts-ends-with (2 hits): s.rfind(x) == 0 →
  s.starts_with(x), aprovechando C++20.
- performance-enum-size (10 hits): enums pequeños declaran tipo
  subyacente (uint8_t / similar) para reducir tamaño y precisar layout.

NO aplicado en este pase (riesgo de cambios semánticos o de API):
- readability-identifier-naming (renames pueden romper callsites parciales)
- readability-convert-member-functions-to-static (cambia firma)
- readability-use-anyofallof (reescribe loops, side effects)
- readability-function-cognitive-complexity (requiere refactor manual)
- bugs reales (bugprone-*, clang-diagnostic-*) → uno a uno

Cambios manuales asociados:
- SDLManager::clear() ahora devuelve bool: propaga el resultado de
  beginFrame al caller para que Director::runFrameLoop salte
  draw+present cuando la swapchain no esté disponible (ventana
  minimizada). Antes la función ignoraba el [[nodiscard]] del
  beginFrame y los vértices se acumulaban en el batch sin nadie que
  los consumiera.
- vector_text.cpp: borrada la línea suelta "// Test pre-commit hook"
  que quedó como cruft.

clang-tidy crashea en LLVM 19.1 con performance-noexcept-move-constructor
(recursión infinita en ExceptionSpecAnalyzer al procesar std::set);
check deshabilitado en .clang-tidy con comentario explicativo.

Build limpio, smoke test OK.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Sergio Valor
2026-05-20 10:59:56 +02:00
parent efbf2457a1
commit c45e524109
62 changed files with 268 additions and 280 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/core/audio/audio_adapter.cpp
+6 -6
View File
@@ -22,12 +22,12 @@ namespace {
// Cachés locales: indexados por nombre lógico ("title.ogg", "effects/laser_shoot.wav", etc.)
// Mantienen ownership con unique_ptr; se liberan al salir del programa.
std::unordered_map<std::string, std::unique_ptr<Ja::Music>>& musicCache() {
auto musicCache() -> std::unordered_map<std::string, std::unique_ptr<Ja::Music>>& {
static std::unordered_map<std::string, std::unique_ptr<Ja::Music>> cache;
return cache;
}
std::unordered_map<std::string, std::unique_ptr<Ja::Sound>>& soundCache() {
auto soundCache() -> std::unordered_map<std::string, std::unique_ptr<Ja::Sound>>& {
static std::unordered_map<std::string, std::unique_ptr<Ja::Sound>> cache;
return cache;
}
@@ -36,12 +36,12 @@ std::unordered_map<std::string, std::unique_ptr<Ja::Sound>>& soundCache() {
// "title.ogg" -> "music/title.ogg"
// "music/title.ogg" -> "music/title.ogg"
// "effects/laser.wav" -> "sounds/effects/laser.wav"
std::string normalizeMusicPath(const std::string& name) {
return (name.rfind("music/", 0) == 0) ? name : "music/" + name;
auto normalizeMusicPath(const std::string& name) -> std::string {
return (name.starts_with("music/")) ? name : "music/" + name;
}
std::string normalizeSoundPath(const std::string& name) {
return (name.rfind("sounds/", 0) == 0) ? name : "sounds/" + name;
auto normalizeSoundPath(const std::string& name) -> std::string {
return (name.starts_with("sounds/")) ? name : "sounds/" + name;
}
} // namespace
source/core/defaults.hpp
+4 -4
View File
@@ -439,16 +439,16 @@ constexpr float CENTER_Y = Game::HEIGHT / 2.0F; // auto-derivado de Game::HEIGH
// Posicions target (calculades dinàmicament des dels parámetros base)
// Nota: std::cos/sin no són constexpr en C++20, pero funcionen en runtime
// Les funciones inline són optimitzades por el compilador (zero overhead)
inline float P1_TARGET_X() {
inline auto P1_TARGET_X() -> float {
return CENTER_X + (CLOCK_RADIUS * std::cos(CLOCK_8_ANGLE));
}
inline float P1_TARGET_Y() {
inline auto P1_TARGET_Y() -> float {
return CENTER_Y + ((Game::HEIGHT / 2.0F) * TARGET_Y_RATIO);
}
inline float P2_TARGET_X() {
inline auto P2_TARGET_X() -> float {
return CENTER_X + (CLOCK_RADIUS * std::cos(CLOCK_4_ANGLE));
}
inline float P2_TARGET_Y() {
inline auto P2_TARGET_Y() -> float {
return CENTER_Y + ((Game::HEIGHT / 2.0F) * TARGET_Y_RATIO);
}
source/core/entities/entity.hpp
+7 -7
View File
@@ -30,21 +30,21 @@ class Entity {
virtual void init() = 0;
virtual void update(float delta_time) = 0;
virtual void draw() const = 0;
[[nodiscard]] virtual bool isActive() const = 0;
[[nodiscard]] virtual auto isActive() const -> bool = 0;
// Sincronización post-física (override opcional).
// Llamado por GameScene tras world.update(). Default: no-op.
virtual void postUpdate(float /*delta_time*/) {}
// Interfaz de colisión (override opcional)
[[nodiscard]] virtual float getCollisionRadius() const { return 0.0F; }
[[nodiscard]] virtual bool isCollidable() const { return false; }
[[nodiscard]] virtual auto getCollisionRadius() const -> float { return 0.0F; }
[[nodiscard]] virtual auto isCollidable() const -> bool { return false; }
// Getters comunes (inline, sin overhead)
[[nodiscard]] const Vec2& getCenter() const { return center_; }
[[nodiscard]] float getAngle() const { return angle_; }
[[nodiscard]] float getBrightness() const { return brightness_; }
[[nodiscard]] const std::shared_ptr<Graphics::Shape>& getShape() const { return shape_; }
[[nodiscard]] auto getCenter() const -> const Vec2& { return center_; }
[[nodiscard]] auto getAngle() const -> float { return angle_; }
[[nodiscard]] auto getBrightness() const -> float { return brightness_; }
[[nodiscard]] auto getShape() const -> const std::shared_ptr<Graphics::Shape>& { return shape_; }
// Acceso al cuerpo físico (Fase 6+). El PhysicsWorld lo registra
// por puntero; la entidad lo configura en init().
source/core/graphics/shape.cpp
+8 -8
View File
@@ -12,12 +12,12 @@ namespace Graphics {
Shape::Shape(const std::string& filepath)
: center_({.x = 0.0F, .y = 0.0F}),
escala_defecte_(1.0F),
nom_("unnamed") {
load(filepath);
}
bool Shape::load(const std::string& filepath) {
auto Shape::load(const std::string& filepath) -> bool {
// Llegir file
std::ifstream file(filepath);
if (!file.is_open()) {
@@ -35,7 +35,7 @@ bool Shape::load(const std::string& filepath) {
return parseFile(contingut);
}
bool Shape::parseFile(const std::string& contingut) {
auto Shape::parseFile(const std::string& contingut) -> bool {
std::istringstream iss(contingut);
std::string line;
@@ -89,7 +89,7 @@ bool Shape::parseFile(const std::string& contingut) {
}
// Helper: trim whitespace
std::string Shape::trim(const std::string& str) const {
auto Shape::trim(const std::string& str) const -> std::string {
const char* whitespace = " \t\n\r";
size_t start = str.find_first_not_of(whitespace);
if (start == std::string::npos) {
@@ -101,8 +101,8 @@ std::string Shape::trim(const std::string& str) const {
}
// Helper: starts_with
bool Shape::starts_with(const std::string& str,
const std::string& prefix) const {
auto Shape::starts_with(const std::string& str,
const std::string& prefix) const -> bool {
if (str.length() < prefix.length()) {
return false;
}
@@ -110,7 +110,7 @@ bool Shape::starts_with(const std::string& str,
}
// Helper: extract value after ':'
std::string Shape::extract_value(const std::string& line) const {
auto Shape::extract_value(const std::string& line) const -> std::string {
size_t colon = line.find(':');
if (colon == std::string::npos) {
return "";
@@ -134,7 +134,7 @@ void Shape::parse_center(const std::string& value) {
}
// Helper: parse points "x1,y1 x2,y2 x3,y3"
std::vector<Vec2> Shape::parse_points(const std::string& str) const {
auto Shape::parse_points(const std::string& str) const -> std::vector<Vec2> {
std::vector<Vec2> points;
std::istringstream iss(trim(str));
std::string pair;
source/core/graphics/shape.hpp
+10 -10
View File
@@ -30,18 +30,18 @@ class Shape {
explicit Shape(const std::string& filepath);
// Carregar shape desde file .shp
bool load(const std::string& filepath);
auto load(const std::string& filepath) -> bool;
// Parsejar shape desde buffer de memòria (per al sistema de recursos)
bool parseFile(const std::string& contingut);
auto parseFile(const std::string& contingut) -> bool;
// Getters
[[nodiscard]] const std::vector<ShapePrimitive>& get_primitives() const {
[[nodiscard]] auto get_primitives() const -> const std::vector<ShapePrimitive>& {
return primitives_;
}
[[nodiscard]] const Vec2& getCenter() const { return center_; }
[[nodiscard]] float get_escala_defecte() const { return escala_defecte_; }
[[nodiscard]] bool isValid() const { return !primitives_.empty(); }
[[nodiscard]] auto getCenter() const -> const Vec2& { return center_; }
[[nodiscard]] auto get_escala_defecte() const -> float { return escala_defecte_; }
[[nodiscard]] auto isValid() const -> bool { return !primitives_.empty(); }
// Info de depuració
[[nodiscard]] auto getName() const -> const std::string& { return nom_; }
@@ -55,11 +55,11 @@ class Shape {
std::string nom_; // Nom de la shape (per depuració)
// Helpers privats per parsejar
[[nodiscard]] std::string trim(const std::string& str) const;
[[nodiscard]] bool starts_with(const std::string& str, const std::string& prefix) const;
[[nodiscard]] std::string extract_value(const std::string& line) const;
[[nodiscard]] auto trim(const std::string& str) const -> std::string;
[[nodiscard]] auto starts_with(const std::string& str, const std::string& prefix) const -> bool;
[[nodiscard]] auto extract_value(const std::string& line) const -> std::string;
void parse_center(const std::string& value);
[[nodiscard]] std::vector<Vec2> parse_points(const std::string& str) const;
[[nodiscard]] auto parse_points(const std::string& str) const -> std::vector<Vec2>;
};
} // namespace Graphics
source/core/graphics/shape_loader.cpp
+3 -3
View File
@@ -13,7 +13,7 @@ namespace Graphics {
std::unordered_map<std::string, std::shared_ptr<Shape>> ShapeLoader::cache_;
std::string ShapeLoader::base_path_ = "data/shapes/";
std::shared_ptr<Shape> ShapeLoader::load(const std::string& filename) {
auto ShapeLoader::load(const std::string& filename) -> std::shared_ptr<Shape> {
// Check cache first
auto it = cache_.find(filename);
if (it != cache_.end()) {
@@ -66,9 +66,9 @@ void ShapeLoader::clear_cache() {
cache_.clear();
}
size_t ShapeLoader::get_cache_size() { return cache_.size(); }
auto ShapeLoader::get_cache_size() -> size_t { return cache_.size(); }
std::string ShapeLoader::resolve_path(const std::string& filename) {
auto ShapeLoader::resolve_path(const std::string& filename) -> std::string {
// Si es un path absolut (comença con '/'), usar-lo directament
if (!filename.empty() && filename[0] == '/') {
return filename;
source/core/graphics/shape_loader.hpp
+3 -3
View File
@@ -20,20 +20,20 @@ class ShapeLoader {
// Carregar shape desde file (con caché)
// Retorna punter compartit (nullptr si error)
// Exemple: load("ship.shp") → busca a "data/shapes/ship.shp"
static std::shared_ptr<Shape> load(const std::string& filename);
static auto load(const std::string& filename) -> std::shared_ptr<Shape>;
// Netejar caché (útil per debug/recàrrega)
static void clear_cache();
// Estadístiques (debug)
static size_t get_cache_size();
static auto get_cache_size() -> size_t;
private:
static std::unordered_map<std::string, std::shared_ptr<Shape>> cache_;
static std::string base_path_; // "data/shapes/"
// Helpers privats
static std::string resolve_path(const std::string& filename);
static auto resolve_path(const std::string& filename) -> std::string;
};
} // namespace Graphics
source/core/graphics/starfield.cpp
+3 -3
View File
@@ -81,7 +81,7 @@ void Starfield::inicialitzar_estrella(Estrella& estrella) const {
}
// Verificar si una estrella está fuera de l'àrea
bool Starfield::fora_area(const Estrella& estrella) const {
auto Starfield::fora_area(const Estrella& estrella) const -> bool {
return (estrella.position.x < area_.x ||
estrella.position.x > area_.x + area_.w ||
estrella.position.y < area_.y ||
@@ -89,7 +89,7 @@ bool Starfield::fora_area(const Estrella& estrella) const {
}
// Calcular scale dinàmica segons distancia del centro
float Starfield::calcular_escala(const Estrella& estrella) const {
auto Starfield::calcular_escala(const Estrella& estrella) const -> float {
const CapaConfig& capa = capes_[estrella.capa];
// Interpolació lineal basada en distancia del centro
@@ -99,7 +99,7 @@ float Starfield::calcular_escala(const Estrella& estrella) const {
}
// Calcular brightness dinàmica segons distancia del centro
float Starfield::calcular_brightness(const Estrella& estrella) const {
auto Starfield::calcular_brightness(const Estrella& estrella) const -> float {
// Interpolació lineal: estrelles properes (vora) més brillants
// distancia_centre: 0.0 (centro, llunyanes) → 1.0 (vora, properes)
float brightness_base = Defaults::Brightness::STARFIELD_MIN +
source/core/graphics/starfield.hpp
+3 -3
View File
@@ -59,13 +59,13 @@ class Starfield {
void inicialitzar_estrella(Estrella& estrella) const;
// Verificar si una estrella está fuera de l'àrea
[[nodiscard]] bool fora_area(const Estrella& estrella) const;
[[nodiscard]] auto fora_area(const Estrella& estrella) const -> bool;
// Calcular scale dinàmica segons distancia del centro
[[nodiscard]] float calcular_escala(const Estrella& estrella) const;
[[nodiscard]] auto calcular_escala(const Estrella& estrella) const -> float;
// Calcular brightness dinàmica segons distancia del centro
[[nodiscard]] float calcular_brightness(const Estrella& estrella) const;
[[nodiscard]] auto calcular_brightness(const Estrella& estrella) const -> float;
// Dades
std::vector<Estrella> estrelles_;
source/core/graphics/vector_text.cpp
+4 -5
View File
@@ -1,6 +1,5 @@
// vector_text.cpp - Implementació del sistema de text vectorial
// © 2026 JailDesigner
// Test pre-commit hook
#include "core/graphics/vector_text.hpp"
@@ -80,7 +79,7 @@ void VectorText::load_charset() {
<< '\n';
}
std::string VectorText::get_shape_filename(char c) const {
auto VectorText::get_shape_filename(char c) const -> std::string {
// Mapeo carácter → nombre de archivo (con prefix "font/")
switch (c) {
case '0':
@@ -177,7 +176,7 @@ std::string VectorText::get_shape_filename(char c) const {
}
}
bool VectorText::is_supported(char c) const {
auto VectorText::is_supported(char c) const -> bool {
return chars_.contains(c);
}
@@ -251,7 +250,7 @@ void VectorText::renderCentered(const std::string& text, const Vec2& centre_punt
render(text, posicio_esquerra, scale, spacing, brightness);
}
float VectorText::get_text_width(const std::string& text, float scale, float spacing) const {
auto VectorText::get_text_width(const std::string& text, float scale, float spacing) const -> float {
if (text.empty()) {
return 0.0F;
}
@@ -278,7 +277,7 @@ float VectorText::get_text_width(const std::string& text, float scale, float spa
return (visual_chars * char_width_scaled) + ((visual_chars - 1) * spacing_scaled);
}
float VectorText::get_text_height(float scale) const {
auto VectorText::get_text_height(float scale) const -> float {
return char_height * scale;
}
source/core/graphics/vector_text.hpp
+4 -4
View File
@@ -38,20 +38,20 @@ class VectorText {
void renderCentered(const std::string& text, const Vec2& centre_punt, float scale = 1.0F, float spacing = 2.0F, float brightness = 1.0F) const;
// Calcular ancho total de un string (útil para centrado)
[[nodiscard]] float get_text_width(const std::string& text, float scale = 1.0F, float spacing = 2.0F) const;
[[nodiscard]] auto get_text_width(const std::string& text, float scale = 1.0F, float spacing = 2.0F) const -> float;
// Calcular altura del texto (útil para centrado vertical)
[[nodiscard]] float get_text_height(float scale = 1.0F) const;
[[nodiscard]] auto get_text_height(float scale = 1.0F) const -> float;
// Verificar si un carácter está soportado
[[nodiscard]] bool is_supported(char c) const;
[[nodiscard]] auto is_supported(char c) const -> bool;
private:
Rendering::Renderer* renderer_;
std::unordered_map<char, std::shared_ptr<Shape>> chars_;
void load_charset();
[[nodiscard]] std::string get_shape_filename(char c) const;
[[nodiscard]] auto get_shape_filename(char c) const -> std::string;
};
} // namespace Graphics
source/core/input/mouse.cpp
+1 -1
View File
@@ -42,7 +42,7 @@ void setForceHidden(bool force) {
}
}
bool isForceHidden() {
auto isForceHidden() -> bool {
return force_hidden;
}
source/core/input/mouse.hpp
+1 -1
View File
@@ -13,5 +13,5 @@ void updateCursorVisibility();
// Control de visibilidad forzada (para modo pantalla completa)
void setForceHidden(bool force); // Activar/desactivar ocultación forzada
bool isForceHidden(); // Consultar estado actual
auto isForceHidden() -> bool; // Consultar estado actual
} // namespace Mouse
source/core/math/easing.hpp
+5 -5
View File
@@ -8,21 +8,21 @@ namespace Easing {
// Ease-out quadratic: empieza rápido, desacelera suavemente
// t = progreso normalizado [0.0 - 1.0]
// retorna value interpolado [0.0 - 1.0]
inline float ease_out_quad(float t) {
inline auto ease_out_quad(float t) -> float {
return 1.0F - ((1.0F - t) * (1.0F - t));
}
// Ease-in quadratic: empieza lento, acelera
// t = progreso normalizado [0.0 - 1.0]
// retorna value interpolado [0.0 - 1.0]
inline float ease_in_quad(float t) {
inline auto ease_in_quad(float t) -> float {
return t * t;
}
// Ease-in-out quadratic: acelera al inicio, desacelera al final
// t = progreso normalizado [0.0 - 1.0]
// retorna value interpolado [0.0 - 1.0]
inline float ease_in_out_quad(float t) {
inline auto ease_in_out_quad(float t) -> float {
return (t < 0.5F)
? 2.0F * t * t
: 1.0F - ((-2.0F * t + 2.0F) * (-2.0F * t + 2.0F) / 2.0F);
@@ -31,13 +31,13 @@ inline float ease_in_out_quad(float t) {
// Ease-out cubic: desaceleración más suave que quadratic
// t = progreso normalizado [0.0 - 1.0]
// retorna value interpolado [0.0 - 1.0]
inline float ease_out_cubic(float t) {
inline auto ease_out_cubic(float t) -> float {
float t1 = 1.0F - t;
return 1.0F - (t1 * t1 * t1);
}
// Interpolación lineal básica (para referencia)
inline float lerp(float start, float end, float t) {
inline auto lerp(float start, float end, float t) -> float {
return start + ((end - start) * t);
}
source/core/physics/collision.hpp
+1 -1
View File
@@ -9,7 +9,7 @@
namespace Physics {
// Comprobación genèrica de colisión entre dues entidades
inline bool check_collision(const Entities::Entity& a, const Entities::Entity& b, float amplifier = 1.0F) {
inline auto check_collision(const Entities::Entity& a, const Entities::Entity& b, float amplifier = 1.0F) -> bool {
// Comprovar si ambdós són col·lisionables
if (!a.isCollidable() || !b.isCollidable()) {
return false;
source/core/rendering/coordinate_transform.hpp
+4 -4
View File
@@ -11,20 +11,20 @@ namespace Rendering {
extern float g_current_scale_factor;
// Transforma coordenada lógica a física con arrodoniment
inline int transform_x(int logical_x, float scale) {
inline auto transform_x(int logical_x, float scale) -> int {
return static_cast<int>(std::round(logical_x * scale));
}
inline int transform_y(int logical_y, float scale) {
inline auto transform_y(int logical_y, float scale) -> int {
return static_cast<int>(std::round(logical_y * scale));
}
// Variant que usa el factor de scale global
inline int transform_x(int logical_x) {
inline auto transform_x(int logical_x) -> int {
return transform_x(logical_x, g_current_scale_factor);
}
inline int transform_y(int logical_y) {
inline auto transform_y(int logical_y) -> int {
return transform_y(logical_y, g_current_scale_factor);
}
source/core/rendering/gpu/gpu_frame_renderer.cpp
+2 -2
View File
@@ -239,8 +239,8 @@ void GpuFrameRenderer::flushBatch() {
SDL_GPUDevice* dev = device_.get();
const uint32_t VBO_SIZE = static_cast<uint32_t>(vertices_.size() * sizeof(LineVertex));
const uint32_t IBO_SIZE = static_cast<uint32_t>(indices_.size() * sizeof(uint16_t));
const auto VBO_SIZE = static_cast<uint32_t>(vertices_.size() * sizeof(LineVertex));
const auto IBO_SIZE = static_cast<uint32_t>(indices_.size() * sizeof(uint16_t));
SDL_GPUBufferCreateInfo vbo_info{};
vbo_info.usage = SDL_GPU_BUFFERUSAGE_VERTEX;
source/core/rendering/line_renderer.cpp
+4 -4
View File
@@ -25,10 +25,10 @@ void linea(Renderer* renderer,
// Coords lógicas (1280×720). El shader hace el mapeo a NDC; el viewport
// del SDLManager hace el letterbox a píxeles físicos.
const float FX1 = static_cast<float>(x1);
const float FY1 = static_cast<float>(y1);
const float FX2 = static_cast<float>(x2);
const float FY2 = static_cast<float>(y2);
const auto FX1 = static_cast<float>(x1);
const auto FY1 = static_cast<float>(y1);
const auto FX2 = static_cast<float>(x2);
const auto FY2 = static_cast<float>(y2);
// color.alpha==0 → usar color global (verde fósforo). alpha>0 → color directo.
const SDL_Color SOURCE = (color.a > 0) ? color : g_current_line_color;
source/core/rendering/sdl_manager.cpp
+6 -2
View File
@@ -316,14 +316,18 @@ auto SDLManager::handleWindowEvent(const SDL_Event& event) -> bool {
return false;
}
void SDLManager::clear(uint8_t r, uint8_t g, uint8_t b) {
auto SDLManager::clear(uint8_t r, uint8_t g, uint8_t b) -> bool {
// El fondo lo dibuja ahora el shader de postpro (background pulse). El
// offscreen se limpia en negro dentro de beginFrame. Los argumentos r/g/b
// se mantienen por compatibilidad de API.
(void)r;
(void)g;
(void)b;
gpu_renderer_.beginFrame(0.0F, 0.0F, 0.0F);
// beginFrame devuelve false si la swapchain no está disponible (ventana
// minimizada, por ejemplo). Propagamos el bool al caller para que pueda
// saltarse draw+present ese frame; si no, los vértices se acumulan en
// el batch interno sin que nadie los consuma.
return gpu_renderer_.beginFrame(0.0F, 0.0F, 0.0F);
}
void SDLManager::present() {
source/core/rendering/sdl_manager.hpp
+4 -2
View File
@@ -31,8 +31,10 @@ class SDLManager {
void toggleVSync(); // F4
auto handleWindowEvent(const SDL_Event& event) -> bool; // Per a SDL_EVENT_WINDOW_RESIZED
// Funciones principals (renderizado)
void clear(uint8_t r = 0, uint8_t g = 0, uint8_t b = 0);
// Funciones principals (renderizado).
// clear() devuelve false si la swapchain no está disponible (p.ej.
// ventana minimizada). El caller debe saltarse draw+present ese frame.
[[nodiscard]] auto clear(uint8_t r = 0, uint8_t g = 0, uint8_t b = 0) -> bool;
void present();
// Getters
source/core/rendering/shape_renderer.cpp
+2 -2
View File
@@ -11,7 +11,7 @@
namespace Rendering {
// Helper: aplicar rotación 3D a un point 2D (assumeix Z=0)
static Vec2 apply_3d_rotation(float x, float y, const Rotation3D& rot) {
static auto apply_3d_rotation(float x, float y, const Rotation3D& rot) -> Vec2 {
float z = 0.0F; // Todos los points 2D comencen a Z=0
// Pitch (rotación eix X): cabeceo arriba/baix
@@ -42,7 +42,7 @@ static Vec2 apply_3d_rotation(float x, float y, const Rotation3D& rot) {
}
// Helper: transformar un point con rotación, scale i traslación
static Vec2 transform_point(const Vec2& point, const Vec2& shape_centre, const Vec2& position, float angle, float scale, const Rotation3D* rotation_3d) {
static auto transform_point(const Vec2& point, const Vec2& shape_centre, const Vec2& position, float angle, float scale, const Rotation3D* rotation_3d) -> Vec2 {
// 1. Centrar el point respecte al centro de la shape
float centered_x = point.x - shape_centre.x;
float centered_y = point.y - shape_centre.y;
source/core/rendering/shape_renderer.hpp
+1 -1
View File
@@ -29,7 +29,7 @@ struct Rotation3D {
yaw(y),
roll(r) {}
[[nodiscard]] bool has_rotation() const {
[[nodiscard]] auto has_rotation() const -> bool {
return pitch != 0.0F || yaw != 0.0F || roll != 0.0F;
}
};
source/core/resources/resource_helper.cpp
+6 -6
View File
@@ -11,12 +11,12 @@
namespace Resource::Helper {
// Inicialitzar el sistema de recursos
bool initializeResourceSystem(const std::string& pack_file, bool fallback) {
auto initializeResourceSystem(const std::string& pack_file, bool fallback) -> bool {
return Loader::get().initialize(pack_file, fallback);
}
// Carregar un file
std::vector<uint8_t> loadFile(const std::string& filepath) {
auto loadFile(const std::string& filepath) -> std::vector<uint8_t> {
// Normalitzar la ruta
std::string normalized = normalizePath(filepath);
@@ -25,14 +25,14 @@ std::vector<uint8_t> loadFile(const std::string& filepath) {
}
// Comprovar si existeix un file
bool fileExists(const std::string& filepath) {
auto fileExists(const std::string& filepath) -> bool {
std::string normalized = normalizePath(filepath);
return Loader::get().resourceExists(normalized);
}
// Obtenir ruta normalitzada per al paquet
// Elimina prefixos "data/", rutes absolutes, etc.
std::string getPackPath(const std::string& asset_path) {
auto getPackPath(const std::string& asset_path) -> std::string {
std::string path = asset_path;
// Eliminar rutes absolutes (detectar / o C:\ al principi)
@@ -69,12 +69,12 @@ std::string getPackPath(const std::string& asset_path) {
}
// Normalitzar ruta (alias de getPackPath)
std::string normalizePath(const std::string& path) {
auto normalizePath(const std::string& path) -> std::string {
return getPackPath(path);
}
// Comprovar si hay paquet carregat
bool isPackLoaded() {
auto isPackLoaded() -> bool {
return Loader::get().isPackLoaded();
}
source/core/resources/resource_helper.hpp
+6 -6
View File
@@ -11,17 +11,17 @@
namespace Resource::Helper {
// Inicialización del sistema
bool initializeResourceSystem(const std::string& pack_file, bool fallback);
auto initializeResourceSystem(const std::string& pack_file, bool fallback) -> bool;
// Càrrega de archivos
std::vector<uint8_t> loadFile(const std::string& filepath);
bool fileExists(const std::string& filepath);
auto loadFile(const std::string& filepath) -> std::vector<uint8_t>;
auto fileExists(const std::string& filepath) -> bool;
// Normalització de rutes
std::string getPackPath(const std::string& asset_path);
std::string normalizePath(const std::string& path);
auto getPackPath(const std::string& asset_path) -> std::string;
auto normalizePath(const std::string& path) -> std::string;
// Estat
bool isPackLoaded();
auto isPackLoaded() -> bool;
} // namespace Resource::Helper
source/core/resources/resource_loader.cpp
+7 -7
View File
@@ -10,13 +10,13 @@
namespace Resource {
// Singleton
Loader& Loader::get() {
auto Loader::get() -> Loader& {
static Loader instance;
return instance;
}
// Inicialitzar el sistema de recursos
bool Loader::initialize(const std::string& pack_file, bool enable_fallback) {
auto Loader::initialize(const std::string& pack_file, bool enable_fallback) -> bool {
fallback_enabled_ = enable_fallback;
// Intentar load el paquet
@@ -39,7 +39,7 @@ bool Loader::initialize(const std::string& pack_file, bool enable_fallback) {
}
// Carregar un recurs
std::vector<uint8_t> Loader::loadResource(const std::string& filename) {
auto Loader::loadResource(const std::string& filename) -> std::vector<uint8_t> {
// Intentar load del paquet primer
if (pack_) {
if (pack_->hasResource(filename)) {
@@ -68,7 +68,7 @@ std::vector<uint8_t> Loader::loadResource(const std::string& filename) {
}
// Comprovar si existeix un recurs
bool Loader::resourceExists(const std::string& filename) {
auto Loader::resourceExists(const std::string& filename) -> bool {
// Comprovar al paquet
if (pack_ && pack_->hasResource(filename)) {
return true;
@@ -84,7 +84,7 @@ bool Loader::resourceExists(const std::string& filename) {
}
// Validar el paquet
bool Loader::validatePack() {
auto Loader::validatePack() -> bool {
if (!pack_) {
std::cerr << "[ResourceLoader] Advertència: no hay paquet carregat per validar\n";
return false;
@@ -94,7 +94,7 @@ bool Loader::validatePack() {
}
// Comprovar si hay paquet carregat
bool Loader::isPackLoaded() const {
auto Loader::isPackLoaded() const -> bool {
return pack_ != nullptr;
}
@@ -110,7 +110,7 @@ auto Loader::getBasePath() const -> const std::string& {
}
// Carregar des del sistema de archivos (fallback)
std::vector<uint8_t> Loader::loadFromFilesystem(const std::string& filename) {
auto Loader::loadFromFilesystem(const std::string& filename) -> std::vector<uint8_t> {
// The filename is already normalized (e.g., "shapes/logo/letra_j.shp")
// We need to prepend base_path + "data/"
std::string fullpath;
source/core/resources/resource_loader.hpp
+8 -8
View File
@@ -16,18 +16,18 @@ namespace Resource {
class Loader {
public:
// Singleton
static Loader& get();
static auto get() -> Loader&;
// Inicialización
bool initialize(const std::string& pack_file, bool enable_fallback);
auto initialize(const std::string& pack_file, bool enable_fallback) -> bool;
// Càrrega de recursos
std::vector<uint8_t> loadResource(const std::string& filename);
bool resourceExists(const std::string& filename);
auto loadResource(const std::string& filename) -> std::vector<uint8_t>;
auto resourceExists(const std::string& filename) -> bool;
// Validació
bool validatePack();
[[nodiscard]] bool isPackLoaded() const;
auto validatePack() -> bool;
[[nodiscard]] auto isPackLoaded() const -> bool;
// Estat
void setBasePath(const std::string& path);
@@ -35,7 +35,7 @@ class Loader {
// No es pot copiar ni moure
Loader(const Loader&) = delete;
Loader& operator=(const Loader&) = delete;
auto operator=(const Loader&) -> Loader& = delete;
private:
Loader() = default;
@@ -47,7 +47,7 @@ class Loader {
std::string base_path_;
// Funciones auxiliars
std::vector<uint8_t> loadFromFilesystem(const std::string& filename);
auto loadFromFilesystem(const std::string& filename) -> std::vector<uint8_t>;
};
} // namespace Resource
source/core/resources/resource_pack.cpp
+11 -11
View File
@@ -11,7 +11,7 @@
namespace Resource {
// Calcular checksum CRC32 simplificat
uint32_t Pack::calculateChecksum(const std::vector<uint8_t>& data) const {
auto Pack::calculateChecksum(const std::vector<uint8_t>& data) const -> uint32_t {
uint32_t checksum = 0x12345678;
for (unsigned char byte : data) {
checksum = ((checksum << 5) + checksum) + byte;
@@ -35,7 +35,7 @@ void Pack::decryptData(std::vector<uint8_t>& data, const std::string& key) {
}
// Llegir file complet a memòria
std::vector<uint8_t> Pack::readFile(const std::string& filepath) {
auto Pack::readFile(const std::string& filepath) -> std::vector<uint8_t> {
std::ifstream file(filepath, std::ios::binary | std::ios::ate);
if (!file) {
std::cerr << "[ResourcePack] Error: no es pot obrir " << filepath << '\n';
@@ -55,7 +55,7 @@ std::vector<uint8_t> Pack::readFile(const std::string& filepath) {
}
// Añadir un file individual al paquet
bool Pack::addFile(const std::string& filepath, const std::string& pack_name) {
auto Pack::addFile(const std::string& filepath, const std::string& pack_name) -> bool {
auto file_data = readFile(filepath);
if (file_data.empty()) {
return false;
@@ -78,8 +78,8 @@ bool Pack::addFile(const std::string& filepath, const std::string& pack_name) {
}
// Añadir todos los archivos de un directori recursivament
bool Pack::addDirectory(const std::string& dir_path,
const std::string& base_path) {
auto Pack::addDirectory(const std::string& dir_path,
const std::string& base_path) -> bool {
namespace fs = std::filesystem;
if (!fs::exists(dir_path) || !fs::is_directory(dir_path)) {
@@ -117,7 +117,7 @@ bool Pack::addDirectory(const std::string& dir_path,
}
// Guardar paquet a disc
bool Pack::savePack(const std::string& pack_file) {
auto Pack::savePack(const std::string& pack_file) -> bool {
std::ofstream file(pack_file, std::ios::binary);
if (!file) {
std::cerr << "[ResourcePack] Error: no es pot crear " << pack_file << '\n';
@@ -161,7 +161,7 @@ bool Pack::savePack(const std::string& pack_file) {
}
// Carregar paquet desde disc
bool Pack::loadPack(const std::string& pack_file) {
auto Pack::loadPack(const std::string& pack_file) -> bool {
std::ifstream file(pack_file, std::ios::binary);
if (!file) {
std::cerr << "[ResourcePack] Error: no es pot obrir " << pack_file << '\n';
@@ -226,7 +226,7 @@ bool Pack::loadPack(const std::string& pack_file) {
}
// Obtenir un recurs del paquet
std::vector<uint8_t> Pack::getResource(const std::string& filename) {
auto Pack::getResource(const std::string& filename) -> std::vector<uint8_t> {
auto it = resources_.find(filename);
if (it == resources_.end()) {
std::cerr << "[ResourcePack] Error: recurs no trobat: " << filename << '\n';
@@ -257,12 +257,12 @@ std::vector<uint8_t> Pack::getResource(const std::string& filename) {
}
// Comprovar si existeix un recurs
bool Pack::hasResource(const std::string& filename) const {
auto Pack::hasResource(const std::string& filename) const -> bool {
return resources_.contains(filename);
}
// Obtenir list de todos los recursos
std::vector<std::string> Pack::getResourceList() const {
auto Pack::getResourceList() const -> std::vector<std::string> {
std::vector<std::string> list;
list.reserve(resources_.size());
@@ -275,7 +275,7 @@ std::vector<std::string> Pack::getResourceList() const {
}
// Validar integritat del paquet
bool Pack::validatePack() const {
auto Pack::validatePack() const -> bool {
bool valid = true;
for (const auto& [name, entry] : resources_) {
source/core/resources/resource_pack.hpp
+10 -10
View File
@@ -32,20 +32,20 @@ class Pack {
~Pack() = default;
// Añadir archivos al paquet
bool addFile(const std::string& filepath, const std::string& pack_name);
bool addDirectory(const std::string& dir_path, const std::string& base_path = "");
auto addFile(const std::string& filepath, const std::string& pack_name) -> bool;
auto addDirectory(const std::string& dir_path, const std::string& base_path = "") -> bool;
// Guardar i load paquets
bool savePack(const std::string& pack_file);
bool loadPack(const std::string& pack_file);
auto savePack(const std::string& pack_file) -> bool;
auto loadPack(const std::string& pack_file) -> bool;
// Accés a recursos
std::vector<uint8_t> getResource(const std::string& filename);
[[nodiscard]] bool hasResource(const std::string& filename) const;
[[nodiscard]] std::vector<std::string> getResourceList() const;
auto getResource(const std::string& filename) -> std::vector<uint8_t>;
[[nodiscard]] auto hasResource(const std::string& filename) const -> bool;
[[nodiscard]] auto getResourceList() const -> std::vector<std::string>;
// Validació
[[nodiscard]] bool validatePack() const;
[[nodiscard]] auto validatePack() const -> bool;
private:
// Constants
@@ -58,8 +58,8 @@ class Pack {
std::vector<uint8_t> data_;
// Funciones auxiliars
std::vector<uint8_t> readFile(const std::string& filepath);
[[nodiscard]] uint32_t calculateChecksum(const std::vector<uint8_t>& data) const;
auto readFile(const std::string& filepath) -> std::vector<uint8_t>;
[[nodiscard]] auto calculateChecksum(const std::vector<uint8_t>& data) const -> uint32_t;
void encryptData(std::vector<uint8_t>& data, const std::string& key);
void decryptData(std::vector<uint8_t>& data, const std::string& key);
};
source/core/system/debug_overlay.cpp
+2 -9
View File
@@ -23,15 +23,8 @@ constexpr float FPS_UPDATE_INTERVAL = 0.5F;
} // namespace
DebugOverlay::DebugOverlay(Rendering::Renderer* renderer)
: text_(renderer),
#ifdef _DEBUG
visible_(true),
#else
visible_(false),
#endif
fps_accumulator_(0.0F),
fps_frame_count_(0),
fps_display_(0) {}
: text_(renderer)
{}
void DebugOverlay::update(float delta_time) {
fps_accumulator_ += delta_time;
source/core/system/debug_overlay.hpp
+4 -4
View File
@@ -27,12 +27,12 @@ class DebugOverlay {
private:
Graphics::VectorText text_;
bool visible_;
bool visible_{true};
// FPS counter — se actualiza cada FPS_UPDATE_INTERVAL segundos.
float fps_accumulator_;
int fps_frame_count_;
int fps_display_;
float fps_accumulator_{0.0F};
int fps_frame_count_{0};
int fps_display_{0};
};
} // namespace System
source/core/system/director.cpp
+6 -1
View File
@@ -327,7 +327,12 @@ void Director::runFrameLoop(Scene& scene, SDLManager& sdl, SceneContext& context
debug_overlay.update(delta_time);
Audio::update();
sdl.clear(0, 0, 0);
// Si la swapchain no está disponible (ventana minimizada, etc.),
// saltarse draw+present ese frame: dibujar dejaría vértices
// colgando en el batch interno sin nadie que los presente.
if (!sdl.clear(0, 0, 0)) {
continue;
}
sdl.updateRenderingContext();
scene.draw();
debug_overlay.draw(); // siempre on top de la escena
source/core/system/game_config.hpp
+5 -5
View File
@@ -19,29 +19,29 @@ struct MatchConfig {
// Métodos auxiliars
// Retorna true si solo hay un player active
[[nodiscard]] bool es_un_jugador() const {
[[nodiscard]] auto es_un_jugador() const -> bool {
return (jugador1_actiu && !jugador2_actiu) ||
(!jugador1_actiu && jugador2_actiu);
}
// Retorna true si hay dos jugadors active
[[nodiscard]] bool son_dos_jugadors() const {
[[nodiscard]] auto son_dos_jugadors() const -> bool {
return jugador1_actiu && jugador2_actiu;
}
// Retorna true si no hay sin player active
[[nodiscard]] bool cap_jugador() const {
[[nodiscard]] auto cap_jugador() const -> bool {
return !jugador1_actiu && !jugador2_actiu;
}
// Compte de jugadors active (0, 1 o 2)
[[nodiscard]] uint8_t compte_jugadors() const {
[[nodiscard]] auto compte_jugadors() const -> uint8_t {
return (jugador1_actiu ? 1 : 0) + (jugador2_actiu ? 1 : 0);
}
// Retorna l'ID de l'únic player active (0 o 1)
// Solo vàlid si es_un_jugador() retorna true
[[nodiscard]] uint8_t id_unic_jugador() const {
[[nodiscard]] auto id_unic_jugador() const -> uint8_t {
if (jugador1_actiu && !jugador2_actiu) {
return 0;
}
source/core/system/global_events.cpp
+1 -1
View File
@@ -16,7 +16,7 @@ using SceneType = SceneContext::SceneType;
namespace GlobalEvents {
bool handle(const SDL_Event& event, SDLManager& sdl, SceneContext& context) {
auto handle(const SDL_Event& event, SDLManager& sdl, SceneContext& context) -> bool {
// 1. Permitir que Input procese el evento (para hotplug de gamepads)
auto event_msg = Input::get()->handleEvent(event);
if (!event_msg.empty()) {
source/core/system/global_events.hpp
+1 -1
View File
@@ -15,5 +15,5 @@ class SceneContext;
namespace GlobalEvents {
// Processa events globals (F1/F2/F3/ESC/QUIT)
// Retorna true si l'event ha state processat y no necesario seguir processant-lo
bool handle(const SDL_Event& event, SDLManager& sdl, SceneManager::SceneContext& context);
auto handle(const SDL_Event& event, SDLManager& sdl, SceneManager::SceneContext& context) -> bool;
} // namespace GlobalEvents
source/core/system/scene_context.hpp
+1 -1
View File
@@ -64,7 +64,7 @@ class SceneContext {
}
// Obtenir configuración de match (consumit per GameScene)
[[nodiscard]] const GameConfig::MatchConfig& getMatchConfig() const {
[[nodiscard]] auto getMatchConfig() const -> const GameConfig::MatchConfig& {
return match_config_;
}
source/core/utils/path_utils.cpp
+4 -4
View File
@@ -37,7 +37,7 @@ void initializePathSystem(const char* argv0) {
}
// Obtenir el directori de l'executable
std::string getExecutableDirectory() {
auto getExecutableDirectory() -> std::string {
if (executable_directory_.empty()) {
std::cerr << "[PathUtils] ADVERTÈNCIA: Sistema de rutes no inicialitzat\n";
return ".";
@@ -46,7 +46,7 @@ std::string getExecutableDirectory() {
}
// Detectar si estem dins un bundle de macOS
bool isMacOSBundle() {
auto isMacOSBundle() -> bool {
#ifdef MACOS_BUNDLE
return true;
#else
@@ -58,7 +58,7 @@ bool isMacOSBundle() {
}
// Obtenir la ruta base dels recursos
std::string getResourceBasePath() {
auto getResourceBasePath() -> std::string {
std::string exe_dir = getExecutableDirectory();
if (isMacOSBundle()) {
@@ -70,7 +70,7 @@ std::string getResourceBasePath() {
}
// Normalitzar ruta (convertir barres, etc.)
std::string normalizePath(const std::string& path) {
auto normalizePath(const std::string& path) -> std::string {
std::string normalized = path;
// Convertir barres invertides a normals
source/core/utils/path_utils.hpp
+4 -4
View File
@@ -12,13 +12,13 @@ namespace Utils {
void initializePathSystem(const char* argv0);
// Obtenció de rutes
std::string getExecutableDirectory();
std::string getResourceBasePath();
auto getExecutableDirectory() -> std::string;
auto getResourceBasePath() -> std::string;
// Detecció de plataforma
bool isMacOSBundle();
auto isMacOSBundle() -> bool;
// Normalització
std::string normalizePath(const std::string& path);
auto normalizePath(const std::string& path) -> std::string;
} // namespace Utils