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/game/constants.hpp
+1 -1
View File
@@ -26,7 +26,7 @@ constexpr int VELOCITAT_MAX = static_cast<int>(Defaults::Physics::BULLET_SPEED);
constexpr float PI = Defaults::Math::PI;
// Helpers per comprovar límits de zona
inline bool dins_zona_joc(float x, float y) {
inline auto dins_zona_joc(float x, float y) -> bool {
const SDL_FPoint point = {x, y};
return SDL_PointInRectFloat(&point, &Defaults::Zones::PLAYAREA);
}
source/game/effects/debris_manager.cpp
+5 -5
View File
@@ -16,7 +16,7 @@ namespace Effects {
// Helper: transformar point con rotación, scale i traslación
// (Copiat de shape_renderer.cpp:12-34)
static Vec2 transform_point(const Vec2& point, const Vec2& shape_centre, const Vec2& position, float angle, float scale) {
static auto transform_point(const Vec2& point, const Vec2& shape_centre, const Vec2& position, float angle, float scale) -> 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;
@@ -320,7 +320,7 @@ void DebrisManager::draw() const {
}
}
Debris* DebrisManager::findFreeSlot() {
auto DebrisManager::findFreeSlot() -> Debris* {
for (auto& debris : debris_pool_) {
if (!debris.active) {
return &debris;
@@ -329,9 +329,9 @@ Debris* DebrisManager::findFreeSlot() {
return nullptr; // Pool ple
}
Vec2 DebrisManager::computeExplosionDirection(const Vec2& p1,
auto DebrisManager::computeExplosionDirection(const Vec2& p1,
const Vec2& p2,
const Vec2& centre_objecte) const {
const Vec2& centre_objecte) const -> Vec2 {
// 1. Calcular centro del segment
float centro_seg_x = (p1.x + p2.x) / 2.0F;
float centro_seg_y = (p1.y + p2.y) / 2.0F;
@@ -372,7 +372,7 @@ void DebrisManager::reset() {
}
}
int DebrisManager::getActiveCount() const {
auto DebrisManager::getActiveCount() const -> int {
int count = 0;
for (const auto& debris : debris_pool_) {
if (debris.active) {
source/game/effects/debris_manager.hpp
+3 -3
View File
@@ -54,7 +54,7 @@ class DebrisManager {
void reset();
// Obtenir número de fragments active
[[nodiscard]] int getActiveCount() const;
[[nodiscard]] auto getActiveCount() const -> int;
private:
Rendering::Renderer* renderer_;
@@ -67,10 +67,10 @@ class DebrisManager {
std::array<Debris, MAX_DEBRIS> debris_pool_;
// Trobar primer slot inactiu
Debris* findFreeSlot();
auto findFreeSlot() -> Debris*;
// Calcular direcció de explosión (radial, des del centro hacia el segment)
[[nodiscard]] Vec2 computeExplosionDirection(const Vec2& p1, const Vec2& p2, const Vec2& centre_objecte) const;
[[nodiscard]] auto computeExplosionDirection(const Vec2& p1, const Vec2& p2, const Vec2& centre_objecte) const -> Vec2;
};
} // namespace Effects
source/game/effects/floating_score_manager.cpp
+2 -2
View File
@@ -77,7 +77,7 @@ void FloatingScoreManager::reset() {
}
}
int FloatingScoreManager::getActiveCount() const {
auto FloatingScoreManager::getActiveCount() const -> int {
int count = 0;
for (const auto& pf : pool_) {
if (pf.active) {
@@ -87,7 +87,7 @@ int FloatingScoreManager::getActiveCount() const {
return count;
}
FloatingScore* FloatingScoreManager::findFreeSlot() {
auto FloatingScoreManager::findFreeSlot() -> FloatingScore* {
for (auto& pf : pool_) {
if (!pf.active) {
return &pf;
source/game/effects/floating_score_manager.hpp
+2 -2
View File
@@ -37,7 +37,7 @@ class FloatingScoreManager {
void reset();
// Obtenir número active (debug)
[[nodiscard]] int getActiveCount() const;
[[nodiscard]] auto getActiveCount() const -> int;
private:
Graphics::VectorText text_; // Sistema de text vectorial
@@ -49,7 +49,7 @@ class FloatingScoreManager {
std::array<FloatingScore, MAX_PUNTUACIONS> pool_;
// Trobar primer slot inactiu
FloatingScore* findFreeSlot();
auto findFreeSlot() -> FloatingScore*;
};
} // namespace Effects
source/game/entities/bullet.cpp
+2 -4
View File
@@ -23,10 +23,8 @@ constexpr float BULLET_SPEED = 140.0F;
} // namespace
Bullet::Bullet(Rendering::Renderer* renderer)
: Entity(renderer),
esta_(false),
owner_id_(0),
grace_timer_(0.0F) {
: Entity(renderer)
{
// Brightness específico para balas
brightness_ = Defaults::Brightness::BALA;
source/game/entities/enemy.cpp
+3 -9
View File
@@ -40,15 +40,9 @@ auto velocityToAngle(const Vec2& velocity) -> float {
Enemy::Enemy(Rendering::Renderer* renderer)
: Entity(renderer),
drotacio_(0.0F),
rotacio_(0.0F),
esta_(false),
type_(EnemyType::PENTAGON),
tracking_timer_(0.0F),
ship_position_(nullptr),
tracking_strength_(0.5F),
direction_change_timer_(0.0F),
timer_invulnerabilitat_(0.0F) {
tracking_strength_(0.5F)
{
brightness_ = Defaults::Brightness::ENEMIC;
// Configuración del cuerpo físico — defaults para enemy genérico.
source/game/entities/ship.cpp
+2 -3
View File
@@ -20,9 +20,8 @@
#include "game/constants.hpp"
Ship::Ship(Rendering::Renderer* renderer, const char* shape_file)
: Entity(renderer),
is_hit_(false),
invulnerable_timer_(0.0F) {
: Entity(renderer)
{
// Brightness específico para naves
brightness_ = Defaults::Brightness::NAU;
source/game/scenes/game_scene.cpp
+4 -4
View File
@@ -32,8 +32,8 @@ GameScene::GameScene(SDLManager& sdl, SceneContext& context)
context_(context),
debris_manager_(sdl.getRenderer()),
floating_score_manager_(sdl.getRenderer()),
text_(sdl.getRenderer()),
init_hud_rect_sound_played_(false) {
text_(sdl.getRenderer())
{
// Recuperar configuración de match des del context
match_config_ = context_.getMatchConfig();
@@ -748,7 +748,7 @@ void GameScene::dibuixar_marcador() {
text_.renderCentered(text, {.x = centre_x, .y = centre_y}, scale, spacing);
}
std::string GameScene::buildScoreboard() const {
auto GameScene::buildScoreboard() const -> std::string {
// Puntuación P1 (6 dígits) - mostrar zeros si inactiu
std::string score_p1;
std::string vides_p1;
@@ -858,7 +858,7 @@ void GameScene::dibuixar_missatge_stage(const std::string& message) {
// Helper methods for 2-player support
// ========================================
Vec2 GameScene::obtenir_punt_spawn(uint8_t player_id) const {
auto GameScene::obtenir_punt_spawn(uint8_t player_id) const -> Vec2 {
const SDL_FRect& zona = Defaults::Zones::PLAYAREA;
float x_ratio;
source/game/scenes/game_scene.hpp
+3 -3
View File
@@ -82,14 +82,14 @@ class GameScene final : public Scene {
std::unique_ptr<StageSystem::StageManager> stage_manager_;
// Control de sons de animación INIT_HUD
bool init_hud_rect_sound_played_; // Flag para evitar repetir sonido del rectángulo
bool init_hud_rect_sound_played_{false}; // Flag para evitar repetir sonido del rectángulo
// Funciones privades
void tocado(uint8_t player_id);
void dibuixar_marges() const; // Dibuixar vores de la zona de juego
void dibuixar_marcador(); // Dibuixar marcador de puntuación
void disparar_bala(uint8_t player_id); // Shoot bullet from player
[[nodiscard]] Vec2 obtenir_punt_spawn(uint8_t player_id) const; // Get spawn position for player
[[nodiscard]] auto obtenir_punt_spawn(uint8_t player_id) const -> Vec2; // Get spawn position for player
// [NEW] Continue & Join system
void unir_jugador(uint8_t player_id); // Join inactive player mid-game
@@ -99,7 +99,7 @@ class GameScene final : public Scene {
void dibuixar_missatge_stage(const std::string& message);
// [NEW] Función helper del marcador
[[nodiscard]] std::string buildScoreboard() const;
[[nodiscard]] auto buildScoreboard() const -> std::string;
// Sub-pasos de update() (descompuestos en Fase 9d para reducir
// complejidad cognitiva; cada uno es responsable de una sección).
source/game/scenes/logo_scene.cpp
+5 -7
View File
@@ -22,7 +22,7 @@ using Option = SceneContext::Option;
// Helper: calcular el progrés individual de una lletra
// en función del progrés global (efecte seqüencial)
static float calcular_progress_letra(size_t letra_index, size_t num_letras, float global_progress, float threshold) {
static auto calcular_progress_letra(size_t letra_index, size_t num_letras, float global_progress, float threshold) -> float {
if (num_letras == 0) {
return 1.0F;
}
@@ -46,11 +46,9 @@ static float calcular_progress_letra(size_t letra_index, size_t num_letras, floa
LogoScene::LogoScene(SDLManager& sdl, SceneContext& context)
: sdl_(sdl),
context_(context),
estat_actual_(AnimationState::PRE_ANIMATION),
temps_estat_actual_(0.0F),
debris_manager_(std::make_unique<Effects::DebrisManager>(sdl.getRenderer())),
lletra_explosio_index_(0),
temps_des_ultima_explosio_(0.0F) {
debris_manager_(std::make_unique<Effects::DebrisManager>(sdl.getRenderer()))
{
std::cout << "SceneType Logo: Inicialitzant...\n";
// Consumir opciones (LOGO no processa opciones actualment)
@@ -181,7 +179,7 @@ void LogoScene::canviar_estat(AnimationState nou_estat) {
<< "\n";
}
bool LogoScene::totes_lletres_completes() const {
auto LogoScene::totes_lletres_completes() const -> bool {
// Cuando global_progress = 1.0, todas las lletres tenen letra_progress = 1.0
return temps_estat_actual_ >= DURACIO_ZOOM;
}
source/game/scenes/logo_scene.hpp
+5 -5
View File
@@ -42,16 +42,16 @@ class LogoScene final : public Scene {
SDLManager& sdl_;
SceneManager::SceneContext& context_;
AnimationState estat_actual_; // Estat actual de la màquina
AnimationState estat_actual_{AnimationState::PRE_ANIMATION}; // Estat actual de la màquina
float
temps_estat_actual_; // Temps en l'state actual (reset en cada transición)
temps_estat_actual_{0.0F}; // Temps en l'state actual (reset en cada transición)
// Gestor de fragments de explosions
std::unique_ptr<Effects::DebrisManager> debris_manager_;
// Seguiment de explosions seqüencials
size_t lletra_explosio_index_; // Índex de la següent lletra a explode
float temps_des_ultima_explosio_; // Temps desde l'última explosión
size_t lletra_explosio_index_{0}; // Índex de la següent lletra a explode
float temps_des_ultima_explosio_{0.0F}; // Temps desde l'última explosión
std::vector<size_t> ordre_explosio_; // Ordre aleatori de índexs de lletres
// Estructura para cada lletra del logo
@@ -90,5 +90,5 @@ class LogoScene final : public Scene {
// Métodos de gestió de estats
void canviar_estat(AnimationState nou_estat);
[[nodiscard]] bool totes_lletres_completes() const;
[[nodiscard]] auto totes_lletres_completes() const -> bool;
};
source/game/scenes/title_scene.cpp
+2 -7
View File
@@ -25,13 +25,8 @@ using Option = SceneContext::Option;
TitleScene::TitleScene(SDLManager& sdl, SceneContext& context)
: sdl_(sdl),
context_(context),
text_(sdl.getRenderer()),
estat_actual_(TitleState::STARFIELD_FADE_IN),
temps_acumulat_(0.0F),
temps_animacio_(0.0F),
temps_estat_main_(0.0F),
animacio_activa_(false),
factor_lerp_(0.0F) {
text_(sdl.getRenderer())
{
std::cout << "SceneType Titol: Inicialitzant...\n";
// Inicialitzar configuración de match (sin player active per defecte)
source/game/scenes/title_scene.hpp
+6 -6
View File
@@ -62,8 +62,8 @@ class TitleScene final : public Scene {
Graphics::VectorText text_; // Sistema de text vectorial
std::unique_ptr<Graphics::Starfield> starfield_; // Camp de estrelles de fons
std::unique_ptr<Title::ShipAnimator> ship_animator_; // Naves 3D flotantes
TitleState estat_actual_; // Estat actual de la màquina
float temps_acumulat_; // Temps acumulat per l'state INIT
TitleState estat_actual_{TitleState::STARFIELD_FADE_IN}; // Estat actual de la màquina
float temps_acumulat_{0.0F}; // Temps acumulat per l'state INIT
// Lletres del título "ORNI ATTACK!"
std::vector<LetraLogo> lletres_orni_; // Lletres de "ORNI" (línia 1)
@@ -74,14 +74,14 @@ class TitleScene final : public Scene {
std::vector<LetraLogo> lletres_jailgames_;
// Estat de animación del logo
float temps_animacio_; // Temps acumulat per animación orbital
float temps_animacio_{0.0F}; // Temps acumulat per animación orbital
std::vector<Vec2> posicions_originals_orni_; // Posicions originals de "ORNI"
std::vector<Vec2> posicions_originals_attack_; // Posicions originals de "ATTACK!"
// Estat de arrencada de l'animación
float temps_estat_main_; // Temps acumulat en state MAIN
bool animacio_activa_; // Flag: true cuando animación está activa
float factor_lerp_; // Factor de lerp actual (0.0 → 1.0)
float temps_estat_main_{0.0F}; // Temps acumulat en state MAIN
bool animacio_activa_{false}; // Flag: true cuando animación está activa
float factor_lerp_{0.0F}; // Factor de lerp actual (0.0 → 1.0)
// Constants
static constexpr float BRIGHTNESS_STARFIELD = 1.2F; // Brightness del starfield (>1.0 = més brillant)
source/game/stage_system/spawn_controller.cpp
+7 -9
View File
@@ -16,10 +16,8 @@
namespace StageSystem {
SpawnController::SpawnController()
: config_(nullptr),
temps_transcorregut_(0.0F),
index_spawn_actual_(0),
ship_position_(nullptr) {}
{}
void SpawnController::configure(const StageConfig* config) {
config_ = config;
@@ -85,11 +83,11 @@ void SpawnController::update(float delta_time, std::array<Enemy, 15>& orni_array
}
}
bool SpawnController::tots_enemics_spawnejats() const {
auto SpawnController::tots_enemics_spawnejats() const -> bool {
return index_spawn_actual_ >= spawn_queue_.size();
}
bool SpawnController::tots_enemics_destruits(const std::array<Enemy, 15>& orni_array) const {
auto SpawnController::tots_enemics_destruits(const std::array<Enemy, 15>& orni_array) const -> bool {
if (!tots_enemics_spawnejats()) {
return false;
}
@@ -103,7 +101,7 @@ bool SpawnController::tots_enemics_destruits(const std::array<Enemy, 15>& orni_a
return true;
}
uint8_t SpawnController::get_enemics_vius(const std::array<Enemy, 15>& orni_array) const {
auto SpawnController::get_enemics_vius(const std::array<Enemy, 15>& orni_array) const -> uint8_t {
uint8_t count = 0;
for (const auto& enemy : orni_array) {
if (enemy.isActive()) {
@@ -113,7 +111,7 @@ uint8_t SpawnController::get_enemics_vius(const std::array<Enemy, 15>& orni_arra
return count;
}
uint8_t SpawnController::get_enemics_spawnejats() const {
auto SpawnController::get_enemics_spawnejats() const -> uint8_t {
return static_cast<uint8_t>(index_spawn_actual_);
}
@@ -132,7 +130,7 @@ void SpawnController::generar_spawn_events() {
}
}
EnemyType SpawnController::seleccionar_tipus_aleatori() const {
auto SpawnController::seleccionar_tipus_aleatori() const -> EnemyType {
if (config_ == nullptr) {
return EnemyType::PENTAGON;
}
source/game/stage_system/spawn_controller.hpp
+9 -9
View File
@@ -33,26 +33,26 @@ class SpawnController {
void update(float delta_time, std::array<Enemy, 15>& orni_array, bool pausar = false);
// Status queries
[[nodiscard]] bool tots_enemics_spawnejats() const;
[[nodiscard]] bool tots_enemics_destruits(const std::array<Enemy, 15>& orni_array) const;
[[nodiscard]] uint8_t get_enemics_vius(const std::array<Enemy, 15>& orni_array) const;
[[nodiscard]] uint8_t get_enemics_spawnejats() const;
[[nodiscard]] auto tots_enemics_spawnejats() const -> bool;
[[nodiscard]] auto tots_enemics_destruits(const std::array<Enemy, 15>& orni_array) const -> bool;
[[nodiscard]] auto get_enemics_vius(const std::array<Enemy, 15>& orni_array) const -> uint8_t;
[[nodiscard]] auto get_enemics_spawnejats() const -> uint8_t;
// [NEW] Set ship position reference for safe spawn
void setShipPosition(const Vec2* ship_pos) { ship_position_ = ship_pos; }
private:
const StageConfig* config_; // Non-owning pointer to current stage config
const StageConfig* config_{nullptr}; // Non-owning pointer to current stage config
std::vector<SpawnEvent> spawn_queue_;
float temps_transcorregut_; // Elapsed time since stage start
uint8_t index_spawn_actual_; // Next spawn to process
float temps_transcorregut_{0.0F}; // Elapsed time since stage start
uint8_t index_spawn_actual_{0}; // Next spawn to process
// Spawn generation
void generar_spawn_events();
[[nodiscard]] EnemyType seleccionar_tipus_aleatori() const;
[[nodiscard]] auto seleccionar_tipus_aleatori() const -> EnemyType;
void spawn_enemic(Enemy& enemy, EnemyType type, const Vec2* ship_pos = nullptr);
void aplicar_multiplicadors(Enemy& enemy) const;
const Vec2* ship_position_; // [NEW] Non-owning pointer to ship position
const Vec2* ship_position_{nullptr}; // [NEW] Non-owning pointer to ship position
};
} // namespace StageSystem
source/game/stage_system/stage_config.hpp
+2 -2
View File
@@ -55,7 +55,7 @@ struct StageConfig {
MultiplicadorsDificultat multiplicadors;
// Validació
[[nodiscard]] bool es_valid() const {
[[nodiscard]] auto es_valid() const -> bool {
// stage_id es uint8_t: el rango superior (<=255) está garantizado por
// el tipo; basta con confirmar que no es 0 (sentinela "sin asignar").
return stage_id >= 1 &&
@@ -70,7 +70,7 @@ struct StageSystemConfig {
std::vector<StageConfig> stages; // Índex [0] = stage 1
// Obtenir configuración de un stage específic
[[nodiscard]] const StageConfig* obte_stage(uint8_t stage_id) const {
[[nodiscard]] auto obte_stage(uint8_t stage_id) const -> const StageConfig* {
if (stage_id < 1 || stage_id > stages.size()) {
return nullptr;
}
source/game/stage_system/stage_loader.cpp
+8 -8
View File
@@ -19,7 +19,7 @@
namespace StageSystem {
std::unique_ptr<StageSystemConfig> StageLoader::load(const std::string& path) {
auto StageLoader::load(const std::string& path) -> std::unique_ptr<StageSystemConfig> {
try {
// Normalize path: "data/stages/stages.yaml" → "stages/stages.yaml"
std::string normalized = path;
@@ -85,7 +85,7 @@ std::unique_ptr<StageSystemConfig> StageLoader::load(const std::string& path) {
}
}
bool StageLoader::parse_metadata(const fkyaml::node& yaml, MetadataStages& meta) {
auto StageLoader::parse_metadata(const fkyaml::node& yaml, MetadataStages& meta) -> bool {
try {
if (!yaml.contains("version") || !yaml.contains("total_stages")) {
std::cerr << "[StageLoader] Error: metadata incompleta" << '\n';
@@ -105,7 +105,7 @@ bool StageLoader::parse_metadata(const fkyaml::node& yaml, MetadataStages& meta)
}
}
bool StageLoader::parse_stage(const fkyaml::node& yaml, StageConfig& stage) {
auto StageLoader::parse_stage(const fkyaml::node& yaml, StageConfig& stage) -> bool {
try {
if (!yaml.contains("stage_id") || !yaml.contains("total_enemies") ||
!yaml.contains("spawn_config") || !yaml.contains("enemy_distribution") ||
@@ -140,7 +140,7 @@ bool StageLoader::parse_stage(const fkyaml::node& yaml, StageConfig& stage) {
}
}
bool StageLoader::parse_spawn_config(const fkyaml::node& yaml, ConfigSpawn& config) {
auto StageLoader::parse_spawn_config(const fkyaml::node& yaml, ConfigSpawn& config) -> bool {
try {
if (!yaml.contains("mode") || !yaml.contains("initial_delay") ||
!yaml.contains("spawn_interval")) {
@@ -160,7 +160,7 @@ bool StageLoader::parse_spawn_config(const fkyaml::node& yaml, ConfigSpawn& conf
}
}
bool StageLoader::parse_distribution(const fkyaml::node& yaml, DistribucioEnemics& dist) {
auto StageLoader::parse_distribution(const fkyaml::node& yaml, DistribucioEnemics& dist) -> bool {
try {
if (!yaml.contains("pentagon") || !yaml.contains("cuadrado") ||
!yaml.contains("molinillo")) {
@@ -186,7 +186,7 @@ bool StageLoader::parse_distribution(const fkyaml::node& yaml, DistribucioEnemic
}
}
bool StageLoader::parse_multipliers(const fkyaml::node& yaml, MultiplicadorsDificultat& mult) {
auto StageLoader::parse_multipliers(const fkyaml::node& yaml, MultiplicadorsDificultat& mult) -> bool {
try {
if (!yaml.contains("speed_multiplier") || !yaml.contains("rotation_multiplier") ||
!yaml.contains("tracking_strength")) {
@@ -216,7 +216,7 @@ bool StageLoader::parse_multipliers(const fkyaml::node& yaml, MultiplicadorsDifi
}
}
ModeSpawn StageLoader::parse_spawn_mode(const std::string& mode_str) {
auto StageLoader::parse_spawn_mode(const std::string& mode_str) -> ModeSpawn {
if (mode_str == "progressive") {
return ModeSpawn::PROGRESSIVE;
}
@@ -231,7 +231,7 @@ ModeSpawn StageLoader::parse_spawn_mode(const std::string& mode_str) {
return ModeSpawn::PROGRESSIVE;
}
bool StageLoader::validar_config(const StageSystemConfig& config) {
auto StageLoader::validar_config(const StageSystemConfig& config) -> bool {
if (config.stages.empty()) {
std::cerr << "[StageLoader] Error: sin stage carregat" << '\n';
return false;
source/game/stage_system/stage_loader.hpp
+8 -8
View File
@@ -15,19 +15,19 @@ class StageLoader {
public:
// Carregar configuración desde file YAML
// Retorna nullptr si hay errors
static std::unique_ptr<StageSystemConfig> load(const std::string& path);
static auto load(const std::string& path) -> std::unique_ptr<StageSystemConfig>;
private:
// Parsing helpers (implementats en .cpp)
static bool parse_metadata(const fkyaml::node& yaml, MetadataStages& meta);
static bool parse_stage(const fkyaml::node& yaml, StageConfig& stage);
static bool parse_spawn_config(const fkyaml::node& yaml, ConfigSpawn& config);
static bool parse_distribution(const fkyaml::node& yaml, DistribucioEnemics& dist);
static bool parse_multipliers(const fkyaml::node& yaml, MultiplicadorsDificultat& mult);
static ModeSpawn parse_spawn_mode(const std::string& mode_str);
static auto parse_metadata(const fkyaml::node& yaml, MetadataStages& meta) -> bool;
static auto parse_stage(const fkyaml::node& yaml, StageConfig& stage) -> bool;
static auto parse_spawn_config(const fkyaml::node& yaml, ConfigSpawn& config) -> bool;
static auto parse_distribution(const fkyaml::node& yaml, DistribucioEnemics& dist) -> bool;
static auto parse_multipliers(const fkyaml::node& yaml, MultiplicadorsDificultat& mult) -> bool;
static auto parse_spawn_mode(const std::string& mode_str) -> ModeSpawn;
// Validació
static bool validar_config(const StageSystemConfig& config);
static auto validar_config(const StageSystemConfig& config) -> bool;
};
} // namespace StageSystem
source/game/stage_system/stage_manager.cpp
+4 -6
View File
@@ -15,10 +15,8 @@
namespace StageSystem {
StageManager::StageManager(const StageSystemConfig* config)
: config_(config),
estat_(EstatStage::LEVEL_START),
stage_actual_(1),
timer_transicio_(0.0F) {
: config_(config)
{
if (config_ == nullptr) {
std::cerr << "[StageManager] Error: config es null" << '\n';
}
@@ -59,13 +57,13 @@ void StageManager::stage_completat() {
canviar_estat(EstatStage::LEVEL_COMPLETED);
}
bool StageManager::tot_completat() const {
auto StageManager::tot_completat() const -> bool {
return stage_actual_ >= config_->metadata.total_stages &&
estat_ == EstatStage::LEVEL_COMPLETED &&
timer_transicio_ <= 0.0F;
}
const StageConfig* StageManager::get_config_actual() const {
auto StageManager::get_config_actual() const -> const StageConfig* {
return config_->obte_stage(stage_actual_);
}
source/game/stage_system/stage_manager.hpp
+11 -11
View File
@@ -29,26 +29,26 @@ class StageManager {
// Stage progression
void stage_completat(); // Call when all enemies destroyed
[[nodiscard]] bool tot_completat() const; // All 10 stages done?
[[nodiscard]] auto tot_completat() const -> bool; // All 10 stages done?
// Current state queries
[[nodiscard]] EstatStage get_estat() const { return estat_; }
[[nodiscard]] uint8_t get_stage_actual() const { return stage_actual_; }
[[nodiscard]] const StageConfig* get_config_actual() const;
[[nodiscard]] float get_timer_transicio() const { return timer_transicio_; }
[[nodiscard]] const std::string& get_missatge_level_start() const { return missatge_level_start_actual_; }
[[nodiscard]] auto get_estat() const -> EstatStage { return estat_; }
[[nodiscard]] auto get_stage_actual() const -> uint8_t { return stage_actual_; }
[[nodiscard]] auto get_config_actual() const -> const StageConfig*;
[[nodiscard]] auto get_timer_transicio() const -> float { return timer_transicio_; }
[[nodiscard]] auto get_missatge_level_start() const -> const std::string& { return missatge_level_start_actual_; }
// Spawn control (delegate to SpawnController)
SpawnController& getSpawnController() { return spawn_controller_; }
[[nodiscard]] const SpawnController& getSpawnController() const { return spawn_controller_; }
auto getSpawnController() -> SpawnController& { return spawn_controller_; }
[[nodiscard]] auto getSpawnController() const -> const SpawnController& { return spawn_controller_; }
private:
const StageSystemConfig* config_; // Non-owning pointer
SpawnController spawn_controller_;
EstatStage estat_;
uint8_t stage_actual_; // 1-10
float timer_transicio_; // Timer for LEVEL_START/LEVEL_COMPLETED (3.0s → 0.0s)
EstatStage estat_{EstatStage::LEVEL_START};
uint8_t stage_actual_{1}; // 1-10
float timer_transicio_{0.0F}; // Timer for LEVEL_START/LEVEL_COMPLETED (3.0s → 0.0s)
std::string missatge_level_start_actual_; // Missatge seleccionat per al level actual
// State transitions
source/game/title/ship_animator.cpp
+3 -3
View File
@@ -122,7 +122,7 @@ void ShipAnimator::skip_to_floating_state() {
}
}
bool ShipAnimator::is_visible() const {
auto ShipAnimator::is_visible() const -> bool {
// Retorna true si almenys una ship es visible
for (const auto& ship : ships_) {
if (ship.visible) {
@@ -156,7 +156,7 @@ void ShipAnimator::set_visible(bool visible) {
}
}
bool ShipAnimator::is_animation_complete() const {
auto ShipAnimator::is_animation_complete() const -> bool {
// Comprovar si todas las naves són invisibles (han completat l'animación de salida)
for (const auto& ship : ships_) {
if (ship.visible) {
@@ -320,7 +320,7 @@ void ShipAnimator::configurar_nau_p2(TitleShip& ship) {
ship.visible = true;
}
Vec2 ShipAnimator::calcular_posicio_fora_pantalla(float angle_rellotge) const {
auto ShipAnimator::calcular_posicio_fora_pantalla(float angle_rellotge) const -> Vec2 {
using namespace Defaults::Title::Ships;
// Convertir angle del rellotge a radians (per exemple: 240° per clock 8)
source/game/title/ship_animator.hpp
+3 -3
View File
@@ -81,8 +81,8 @@ class ShipAnimator {
// Control de visibilitat
void set_visible(bool visible);
[[nodiscard]] bool is_animation_complete() const;
[[nodiscard]] bool is_visible() const; // Comprova si alguna ship es visible
[[nodiscard]] auto is_animation_complete() const -> bool;
[[nodiscard]] auto is_visible() const -> bool; // Comprova si alguna ship es visible
private:
Rendering::Renderer* renderer_;
@@ -96,7 +96,7 @@ class ShipAnimator {
// Configuración
void configurar_nau_p1(TitleShip& ship);
void configurar_nau_p2(TitleShip& ship);
[[nodiscard]] Vec2 calcular_posicio_fora_pantalla(float angle_rellotge) const;
[[nodiscard]] auto calcular_posicio_fora_pantalla(float angle_rellotge) const -> Vec2;
};
} // namespace Title