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

Lint: rename de métodos privados (camelBack + traducción al inglés)

Browse Source 
Tanda grande de identifier-naming: 47 métodos privados pasan de
snake_case (en su mayoría catalán/spanish) a camelBack inglés. Solo
afecta a sus archivos hpp+cpp; ningún símbolo cruza fichero (los
públicos quedan para una pasada manual con VS Code).

Renames por clase:

- ShapeLoader: resolve_path → resolvePath.
- VectorText: load_charset → loadCharset, get_shape_filename →
  getShapeFilename.
- Shape: starts_with → startsWith (cuidado de no tocar
  std::string::starts_with que también usaba), extract_value →
  extractValue, parse_center → parseCenter, parse_points → parsePoints.
- Starfield: inicialitzar_estrella → initStar, fora_area →
  isOutsideArea, calcular_escala → computeScale, calcular_brightness →
  computeBrightness.
- TitleScene: actualitzar_animacio_logo → updateLogoAnimation,
  inicialitzar_titol → initTitle.
- LogoScene: inicialitzar_lletres → initLetters, actualitzar_explosions
  → updateExplosions, canviar_estat → changeState,
  totes_lletres_completes → allLettersComplete.
- SpawnController: generar_spawn_events → generateSpawnEvents,
  seleccionar_tipus_aleatori → selectRandomType, spawn_enemic →
  spawnEnemy, aplicar_multiplicadors → applyMultipliers.
- ShipAnimator: actualitzar_entering/floating/exiting →
  updateEntering/Floating/Exiting, configurar_nau_p1/p2 →
  configureShipP1/P2, calcular_posicio_fora_pantalla →
  computeOffscreenPosition.
- GameScene: dibuixar_marges → drawMargins, dibuixar_marcador →
  drawScoreboard, disparar_bala → fireBullet, obtenir_punt_spawn →
  getSpawnPoint, unir_jugador → joinPlayer, dibuixar_continue →
  drawContinue, dibuixar_missatge_stage → drawStageMessage.
- StageLoader: parse_metadata/stage/spawn_config/distribution/multipliers/
  spawn_mode → parseMetadata/Stage/SpawnConfig/Distribution/Multipliers/
  SpawnMode, validar_config → validateConfig.
- StageManager: canviar_estat → changeState,
  processar_init_hud/level_start/playing/level_completed →
  processInitHud/LevelStart/Playing/LevelCompleted, carregar_stage →
  loadStage.

Métodos públicos y funciones libres (cross-file) quedan a propósito sin
tocar — los renombrará el usuario con la herramienta de rename de VS Code.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Sergio Valor
2026-05-20 11:55:21 +02:00
parent c80212adb9
commit 6d0df85e5e
23 changed files with 181 additions and 181 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/core/audio/audio_adapter.cpp
+4 -4
View File
@@ -23,13 +23,13 @@ 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.
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;
static std::unordered_map<std::string, std::unique_ptr<Ja::Music>> cache_;
return cache_;
}
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;
static std::unordered_map<std::string, std::unique_ptr<Ja::Sound>> cache_;
return cache_;
}
// Normaliza el nombre añadiendo la subcarpeta correspondiente si no la trae:
source/core/graphics/shape.cpp
+15 -15
View File
@@ -49,27 +49,27 @@ auto Shape::parseFile(const std::string& contingut) -> bool {
}
// Parse command
if (starts_with(line, "name:")) {
nom_ = trim(extract_value(line));
} else if (starts_with(line, "scale:")) {
if (startsWith(line, "name:")) {
nom_ = trim(extractValue(line));
} else if (startsWith(line, "scale:")) {
try {
escala_defecte_ = std::stof(extract_value(line));
escala_defecte_ = std::stof(extractValue(line));
} catch (...) {
std::cerr << "[Shape] Warning: scale invàlida, usant 1.0" << '\n';
escala_defecte_ = 1.0F;
}
} else if (starts_with(line, "center:")) {
parse_center(extract_value(line));
} else if (starts_with(line, "polyline:")) {
auto points = parse_points(extract_value(line));
} else if (startsWith(line, "center:")) {
parseCenter(extractValue(line));
} else if (startsWith(line, "polyline:")) {
auto points = parsePoints(extractValue(line));
if (points.size() >= 2) {
primitives_.push_back({PrimitiveType::POLYLINE, points});
} else {
std::cerr << "[Shape] Warning: polyline con menys de 2 points ignorada"
<< '\n';
}
} else if (starts_with(line, "line:")) {
auto points = parse_points(extract_value(line));
} else if (startsWith(line, "line:")) {
auto points = parsePoints(extractValue(line));
if (points.size() == 2) {
primitives_.push_back({PrimitiveType::LINE, points});
} else {
@@ -100,8 +100,8 @@ auto Shape::trim(const std::string& str) const -> std::string {
return str.substr(start, end - start + 1);
}
// Helper: starts_with
auto Shape::starts_with(const std::string& str,
// Helper: startsWith
auto Shape::startsWith(const std::string& str,
const std::string& prefix) const -> bool {
if (str.length() < prefix.length()) {
return false;
@@ -110,7 +110,7 @@ auto Shape::starts_with(const std::string& str,
}
// Helper: extract value after ':'
auto Shape::extract_value(const std::string& line) const -> std::string {
auto Shape::extractValue(const std::string& line) const -> std::string {
size_t colon = line.find(':');
if (colon == std::string::npos) {
return "";
@@ -119,7 +119,7 @@ auto Shape::extract_value(const std::string& line) const -> std::string {
}
// Helper: parse center "x, y"
void Shape::parse_center(const std::string& value) {
void Shape::parseCenter(const std::string& value) {
std::string val = trim(value);
size_t comma = val.find(',');
if (comma != std::string::npos) {
@@ -134,7 +134,7 @@ void Shape::parse_center(const std::string& value) {
}
// Helper: parse points "x1,y1 x2,y2 x3,y3"
auto Shape::parse_points(const std::string& str) const -> std::vector<Vec2> {
auto Shape::parsePoints(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
+4 -4
View File
@@ -57,10 +57,10 @@ class Shape {
// Helpers privats per parsejar
[[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]] auto parse_points(const std::string& str) const -> std::vector<Vec2>;
[[nodiscard]] auto startsWith(const std::string& str, const std::string& prefix) const -> bool;
[[nodiscard]] auto extractValue(const std::string& line) const -> std::string;
void parseCenter(const std::string& value);
[[nodiscard]] auto parsePoints(const std::string& str) const -> std::vector<Vec2>;
};
} // namespace Graphics
source/core/graphics/shape_loader.cpp
+1 -1
View File
@@ -68,7 +68,7 @@ void ShapeLoader::clear_cache() {
auto ShapeLoader::get_cache_size() -> size_t { return cache_.size(); }
auto ShapeLoader::resolve_path(const std::string& filename) -> std::string {
auto ShapeLoader::resolvePath(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
+1 -1
View File
@@ -33,7 +33,7 @@ class ShapeLoader {
static std::string base_path_; // "data/shapes/"
// Helpers privats
static auto resolve_path(const std::string& filename) -> std::string;
static auto resolvePath(const std::string& filename) -> std::string;
};
} // namespace Graphics
source/core/graphics/starfield.cpp
+8 -8
View File
@@ -66,7 +66,7 @@ Starfield::Starfield(Rendering::Renderer* renderer,
}
// Inicialitzar una estrella (nueva o regenerada)
void Starfield::inicialitzar_estrella(Estrella& estrella) const {
void Starfield::initStar(Estrella& estrella) const {
// Angle aleatori des del point de fuga hacia fuera
estrella.angle = (static_cast<float>(rand()) / RAND_MAX) * 2.0F * Defaults::Math::PI;
@@ -80,7 +80,7 @@ void Starfield::inicialitzar_estrella(Estrella& estrella) const {
}
// Verificar si una estrella está fuera de l'àrea
auto Starfield::fora_area(const Estrella& estrella) const -> bool {
auto Starfield::isOutsideArea(const Estrella& estrella) const -> bool {
return (estrella.position.x < area_.x ||
estrella.position.x > area_.x + area_.w ||
estrella.position.y < area_.y ||
@@ -88,7 +88,7 @@ auto Starfield::fora_area(const Estrella& estrella) const -> bool {
}
// Calcular scale dinàmica segons distancia del centro
auto Starfield::calcular_escala(const Estrella& estrella) const -> float {
auto Starfield::computeScale(const Estrella& estrella) const -> float {
const CapaConfig& capa = capes_[estrella.capa];
// Interpolació lineal basada en distancia del centro
@@ -98,7 +98,7 @@ auto Starfield::calcular_escala(const Estrella& estrella) const -> float {
}
// Calcular brightness dinàmica segons distancia del centro
auto Starfield::calcular_brightness(const Estrella& estrella) const -> float {
auto Starfield::computeBrightness(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 +
@@ -130,8 +130,8 @@ void Starfield::update(float delta_time) {
estrella.distancia_centre = dist_px / radi_max_;
// Si ha sortit de l'àrea, regenerar-la
if (fora_area(estrella)) {
inicialitzar_estrella(estrella);
if (isOutsideArea(estrella)) {
initStar(estrella);
}
}
}
@@ -149,8 +149,8 @@ void Starfield::draw() {
for (const auto& estrella : estrelles_) {
// Calcular scale i brightness dinàmicament
float scale = calcular_escala(estrella);
float brightness = calcular_brightness(estrella);
float scale = computeScale(estrella);
float brightness = computeBrightness(estrella);
// Renderizar estrella sin rotación
Rendering::render_shape(
source/core/graphics/starfield.hpp
+4 -4
View File
@@ -56,16 +56,16 @@ class Starfield {
};
// Inicialitzar una estrella (nueva o regenerada)
void inicialitzar_estrella(Estrella& estrella) const;
void initStar(Estrella& estrella) const;
// Verificar si una estrella está fuera de l'àrea
[[nodiscard]] auto fora_area(const Estrella& estrella) const -> bool;
[[nodiscard]] auto isOutsideArea(const Estrella& estrella) const -> bool;
// Calcular scale dinàmica segons distancia del centro
[[nodiscard]] auto calcular_escala(const Estrella& estrella) const -> float;
[[nodiscard]] auto computeScale(const Estrella& estrella) const -> float;
// Calcular brightness dinàmica segons distancia del centro
[[nodiscard]] auto calcular_brightness(const Estrella& estrella) const -> float;
[[nodiscard]] auto computeBrightness(const Estrella& estrella) const -> float;
// Dades
std::vector<Estrella> estrelles_;
source/core/graphics/vector_text.cpp
+6 -6
View File
@@ -16,13 +16,13 @@ constexpr float BASE_CHAR_HEIGHT = 40.0F; // Altura base del caràcter
VectorText::VectorText(Rendering::Renderer* renderer)
: renderer_(renderer) {
load_charset();
loadCharset();
}
void VectorText::load_charset() {
void VectorText::loadCharset() {
// Cargar dígitos 0-9
for (char c = '0'; c <= '9'; c++) {
std::string filename = get_shape_filename(c);
std::string filename = getShapeFilename(c);
auto shape = ShapeLoader::load(filename);
if (shape && shape->isValid()) {
@@ -35,7 +35,7 @@ void VectorText::load_charset() {
// Cargar lletres A-Z (majúscules)
for (char c = 'A'; c <= 'Z'; c++) {
std::string filename = get_shape_filename(c);
std::string filename = getShapeFilename(c);
auto shape = ShapeLoader::load(filename);
if (shape && shape->isValid()) {
@@ -50,7 +50,7 @@ void VectorText::load_charset() {
const std::string SYMBOLS[] = {".", ",", "-", ":", "!", "?"};
for (const auto& sym : SYMBOLS) {
char c = sym[0];
std::string filename = get_shape_filename(c);
std::string filename = getShapeFilename(c);
auto shape = ShapeLoader::load(filename);
if (shape && shape->isValid()) {
@@ -79,7 +79,7 @@ void VectorText::load_charset() {
<< '\n';
}
auto VectorText::get_shape_filename(char c) const -> std::string {
auto VectorText::getShapeFilename(char c) const -> std::string {
// Mapeo carácter → nombre de archivo (con prefix "font/").
// Dígitos 0-9 y mayúsculas A-Z comparten el mismo path: la shape se llama
// como el caracter mismo, así que se agrupan en un único case.
source/core/graphics/vector_text.hpp
+2 -2
View File
@@ -50,8 +50,8 @@ class VectorText {
Rendering::Renderer* renderer_;
std::unordered_map<char, std::shared_ptr<Shape>> chars_;
void load_charset();
[[nodiscard]] auto get_shape_filename(char c) const -> std::string;
void loadCharset();
[[nodiscard]] auto getShapeFilename(char c) const -> std::string;
};
} // namespace Graphics
source/game/scenes/game_scene.cpp
+30 -30
View File
@@ -122,7 +122,7 @@ void GameScene::init() {
score_per_player_[1] = 0;
floating_score_manager_.reset();
// DEPRECATED: spawn_position_ ya no s'usa, es calcula dinàmicament con obtenir_punt_spawn(player_id)
// DEPRECATED: spawn_position_ ya no s'usa, es calcula dinàmicament con getSpawnPoint(player_id)
// const SDL_FRect& zona = Defaults::Zones::PLAYAREA;
// spawn_position_.x = zona.x + zona.w * 0.5f;
// spawn_position_.y = zona.y + zona.h * Defaults::Game::INIT_HUD_SHIP_START_Y_RATIO;
@@ -133,7 +133,7 @@ void GameScene::init() {
if (jugador_actiu) {
// Jugador active: init normalment
Vec2 spawn_pos = obtenir_punt_spawn(i);
Vec2 spawn_pos = getSpawnPoint(i);
ships_[i].init(&spawn_pos, false); // No invulnerability at start
// Registrar el cuerpo físico de la nave en el mundo (Fase 6c)
physics_world_.addBody(&ships_[i].getBody());
@@ -213,11 +213,11 @@ void GameScene::stepShootingInput() {
auto* input = Input::get();
if (match_config_.jugador1_actiu &&
input->checkActionPlayer1(InputAction::SHOOT, Input::DO_NOT_ALLOW_REPEAT)) {
disparar_bala(0);
fireBullet(0);
}
if (match_config_.jugador2_actiu &&
input->checkActionPlayer2(InputAction::SHOOT, Input::DO_NOT_ALLOW_REPEAT)) {
disparar_bala(1);
fireBullet(1);
}
}
@@ -248,7 +248,7 @@ void GameScene::stepMidGameJoin() {
? input->checkActionPlayer1(InputAction::START, Input::DO_NOT_ALLOW_REPEAT)
: input->checkActionPlayer2(InputAction::START, Input::DO_NOT_ALLOW_REPEAT);
if (START_PRESSED) {
unir_jugador(pid);
joinPlayer(pid);
}
}
}
@@ -269,7 +269,7 @@ auto GameScene::stepContinueScreen(float delta_time) -> bool {
.hit_timer_per_player = hit_timer_per_player_,
.ships = ships_,
.match_config = match_config_,
.get_spawn_point = [this](uint8_t pid) { return obtenir_punt_spawn(pid); },
.get_spawn_point = [this](uint8_t pid) { return getSpawnPoint(pid); },
};
Systems::ContinueScreen::update(cont_ctx, delta_time);
Systems::ContinueScreen::processInput(cont_ctx);
@@ -326,7 +326,7 @@ void GameScene::stepDeathSequence(float delta_time) {
// *** PHASE 3: RESPAWN OR GAME OVER ***
lives_per_player_[i]--;
if (lives_per_player_[i] > 0) {
Vec2 spawn_pos = obtenir_punt_spawn(i);
Vec2 spawn_pos = getSpawnPoint(i);
ships_[i].init(&spawn_pos, /*activar_invulnerabilitat=*/true);
hit_timer_per_player_[i] = 0.0F;
continue;
@@ -399,10 +399,10 @@ void GameScene::runStageInitHud(float delta_time) {
Defaults::Game::INIT_HUD_SHIP2_RATIO_END);
if (match_config_.jugador1_actiu && SHIP1_P < 1.0F) {
ships_[0].setCenter(Systems::InitHud::computeShipPosition(SHIP1_P, obtenir_punt_spawn(0)));
ships_[0].setCenter(Systems::InitHud::computeShipPosition(SHIP1_P, getSpawnPoint(0)));
}
if (match_config_.jugador2_actiu && SHIP2_P < 1.0F) {
ships_[1].setCenter(Systems::InitHud::computeShipPosition(SHIP2_P, obtenir_punt_spawn(1)));
ships_[1].setCenter(Systems::InitHud::computeShipPosition(SHIP2_P, getSpawnPoint(1)));
}
}
@@ -491,7 +491,7 @@ void GameScene::draw() {
// Handle CONTINUE screen
if (game_over_state_ == GameOverState::CONTINUE) {
// Draw game background elements first
dibuixar_marges();
drawMargins();
for (const auto& enemy : enemies_) {
enemy.draw();
@@ -503,17 +503,17 @@ void GameScene::draw() {
debris_manager_.draw();
floating_score_manager_.draw();
dibuixar_marcador();
drawScoreboard();
// Draw CONTINUE screen overlay
dibuixar_continue();
drawContinue();
return;
}
// Handle final GAME OVER state
if (game_over_state_ == GameOverState::GAME_OVER) {
// Game over: draw enemies, bullets, debris, and "GAME OVER" text
dibuixar_marges();
drawMargins();
for (const auto& enemy : enemies_) {
enemy.draw();
@@ -538,7 +538,7 @@ void GameScene::draw() {
text_.renderCentered(GAME_OVER_TEXT, {.x = centre_x, .y = centre_y}, SCALE, SPACING);
dibuixar_marcador();
drawScoreboard();
return;
}
@@ -601,7 +601,7 @@ void GameScene::draw() {
}
case StageSystem::EstatStage::LEVEL_START:
dibuixar_marges();
drawMargins();
// [NEW] Draw both ships if active and alive
for (uint8_t i = 0; i < 2; i++) {
bool jugador_actiu = (i == 0) ? match_config_.jugador1_actiu : match_config_.jugador2_actiu;
@@ -620,12 +620,12 @@ void GameScene::draw() {
floating_score_manager_.draw();
// [EXISTING] Draw intro message and score
dibuixar_missatge_stage(stage_manager_->get_missatge_level_start());
dibuixar_marcador();
drawStageMessage(stage_manager_->get_missatge_level_start());
drawScoreboard();
break;
case StageSystem::EstatStage::PLAYING:
dibuixar_marges();
drawMargins();
// [EXISTING] Normal rendering - active ships
for (uint8_t i = 0; i < 2; i++) {
@@ -645,11 +645,11 @@ void GameScene::draw() {
debris_manager_.draw();
floating_score_manager_.draw();
dibuixar_marcador();
drawScoreboard();
break;
case StageSystem::EstatStage::LEVEL_COMPLETED:
dibuixar_marges();
drawMargins();
// [NEW] Draw both ships if active and alive
for (uint8_t i = 0; i < 2; i++) {
bool jugador_actiu = (i == 0) ? match_config_.jugador1_actiu : match_config_.jugador2_actiu;
@@ -668,8 +668,8 @@ void GameScene::draw() {
floating_score_manager_.draw();
// [EXISTING] Draw completion message and score
dibuixar_missatge_stage(StageSystem::Constants::MISSATGE_LEVEL_COMPLETED);
dibuixar_marcador();
drawStageMessage(StageSystem::Constants::MISSATGE_LEVEL_COMPLETED);
drawScoreboard();
break;
}
}
@@ -714,7 +714,7 @@ void GameScene::tocado(uint8_t player_id) {
// Phase 3 is handled in update() when hit_timer_per_player_ >= DEATH_DURATION
}
void GameScene::dibuixar_marges() const {
void GameScene::drawMargins() const {
// Dibuixar rectangle de la zona de juego
const SDL_FRect& zona = Defaults::Zones::PLAYAREA;
@@ -731,7 +731,7 @@ void GameScene::dibuixar_marges() const {
Rendering::linea(sdl_.getRenderer(), x2, y1, x2, y2); // Right
}
void GameScene::dibuixar_marcador() {
void GameScene::drawScoreboard() {
// Construir text del marcador
std::string text = buildScoreboard();
@@ -789,7 +789,7 @@ auto GameScene::buildScoreboard() const -> std::string {
// [NEW] Stage system helper methods
void GameScene::dibuixar_missatge_stage(const std::string& message) {
void GameScene::drawStageMessage(const std::string& message) {
constexpr float BASE_SCALE = 1.0F;
constexpr float SPACING = 2.0F;
@@ -858,7 +858,7 @@ void GameScene::dibuixar_missatge_stage(const std::string& message) {
// Helper methods for 2-player support
// ========================================
auto GameScene::obtenir_punt_spawn(uint8_t player_id) const -> Vec2 {
auto GameScene::getSpawnPoint(uint8_t player_id) const -> Vec2 {
const SDL_FRect& zona = Defaults::Zones::PLAYAREA;
float x_ratio;
@@ -877,7 +877,7 @@ auto GameScene::obtenir_punt_spawn(uint8_t player_id) const -> Vec2 {
.y = zona.y + (zona.h * Defaults::Game::SPAWN_Y_RATIO)};
}
void GameScene::disparar_bala(uint8_t player_id) {
void GameScene::fireBullet(uint8_t player_id) {
// Verificar que el player está vivo
if (hit_timer_per_player_[player_id] > 0.0F) {
return;
@@ -908,7 +908,7 @@ void GameScene::disparar_bala(uint8_t player_id) {
}
}
void GameScene::dibuixar_continue() {
void GameScene::drawContinue() {
const SDL_FRect& play_area = Defaults::Zones::PLAYAREA;
constexpr float SPACING = 4.0F;
@@ -943,7 +943,7 @@ void GameScene::dibuixar_continue() {
}
}
void GameScene::unir_jugador(uint8_t player_id) {
void GameScene::joinPlayer(uint8_t player_id) {
// Activate player
if (player_id == 0) {
match_config_.jugador1_actiu = true;
@@ -957,7 +957,7 @@ void GameScene::unir_jugador(uint8_t player_id) {
hit_timer_per_player_[player_id] = 0.0F;
// Spawn with invulnerability
Vec2 spawn_pos = obtenir_punt_spawn(player_id);
Vec2 spawn_pos = getSpawnPoint(player_id);
ships_[player_id].init(&spawn_pos, true);
// No visual message, just spawn (per user requirement)
source/game/scenes/game_scene.hpp
+7 -7
View File
@@ -88,17 +88,17 @@ class GameScene final : public Scene {
// 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]] auto obtenir_punt_spawn(uint8_t player_id) const -> Vec2; // Get spawn position for player
void drawMargins() const; // Dibuixar vores de la zona de juego
void drawScoreboard(); // Dibuixar marcador de puntuación
void fireBullet(uint8_t player_id); // Shoot bullet from player
[[nodiscard]] auto getSpawnPoint(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
void dibuixar_continue(); // Draw continue screen
void joinPlayer(uint8_t player_id); // Join inactive player mid-game
void drawContinue(); // Draw continue screen
// [NEW] Stage system helpers
void dibuixar_missatge_stage(const std::string& message);
void drawStageMessage(const std::string& message);
// [NEW] Función helper del marcador
[[nodiscard]] auto buildScoreboard() const -> std::string;
source/game/scenes/logo_scene.cpp
+11 -11
View File
@@ -56,7 +56,7 @@ LogoScene::LogoScene(SDLManager& sdl, SceneContext& context)
(void)option; // Suprimir warning
so_reproduit_.fill(false); // Inicialitzar seguiment de sons
inicialitzar_lletres();
initLetters();
}
LogoScene::~LogoScene() {
@@ -75,7 +75,7 @@ void LogoScene::handleEvent(const SDL_Event& event) {
(void)event;
}
void LogoScene::inicialitzar_lletres() {
void LogoScene::initLetters() {
using namespace Graphics;
// Llista de archivos .shp (A repetida para las dues A's)
@@ -154,7 +154,7 @@ void LogoScene::inicialitzar_lletres() {
<< " lletres carregades, ancho total: " << ancho_total << " px\n";
}
void LogoScene::canviar_estat(AnimationState nou_estat) {
void LogoScene::changeState(AnimationState nou_estat) {
estat_actual_ = nou_estat;
temps_estat_actual_ = 0.0F; // Reset time
@@ -179,12 +179,12 @@ void LogoScene::canviar_estat(AnimationState nou_estat) {
<< "\n";
}
auto LogoScene::totes_lletres_completes() const -> bool {
auto LogoScene::allLettersComplete() const -> bool {
// Cuando global_progress = 1.0, todas las lletres tenen letra_progress = 1.0
return temps_estat_actual_ >= DURACIO_ZOOM;
}
void LogoScene::actualitzar_explosions(float delta_time) {
void LogoScene::updateExplosions(float delta_time) {
temps_des_ultima_explosio_ += delta_time;
// Comprovar si es el moment de explode la següent lletra
@@ -211,7 +211,7 @@ void LogoScene::actualitzar_explosions(float delta_time) {
temps_des_ultima_explosio_ = 0.0F;
} else {
// Todas las lletres han explotat, transición a POST_EXPLOSION
canviar_estat(AnimationState::POST_EXPLOSION);
changeState(AnimationState::POST_EXPLOSION);
}
}
}
@@ -222,7 +222,7 @@ void LogoScene::update(float delta_time) {
switch (estat_actual_) {
case AnimationState::PRE_ANIMATION:
if (temps_estat_actual_ >= DURACIO_PRE) {
canviar_estat(AnimationState::ANIMATION);
changeState(AnimationState::ANIMATION);
}
break;
@@ -246,20 +246,20 @@ void LogoScene::update(float delta_time) {
}
}
if (totes_lletres_completes()) {
canviar_estat(AnimationState::POST_ANIMATION);
if (allLettersComplete()) {
changeState(AnimationState::POST_ANIMATION);
}
break;
}
case AnimationState::POST_ANIMATION:
if (temps_estat_actual_ >= DURACIO_POST_ANIMATION) {
canviar_estat(AnimationState::EXPLOSION);
changeState(AnimationState::EXPLOSION);
}
break;
case AnimationState::EXPLOSION:
actualitzar_explosions(delta_time);
updateExplosions(delta_time);
break;
case AnimationState::POST_EXPLOSION:
source/game/scenes/logo_scene.hpp
+4 -4
View File
@@ -85,11 +85,11 @@ class LogoScene final : public Scene {
static constexpr float ORIGEN_ZOOM_Y = Defaults::Game::HEIGHT * 0.4F; // Vec2 inicial Y del zoom
// Métodos privats
void inicialitzar_lletres();
void actualitzar_explosions(float delta_time);
void initLetters();
void updateExplosions(float delta_time);
auto checkSkipButtonPressed() -> bool;
// Métodos de gestió de estats
void canviar_estat(AnimationState nou_estat);
[[nodiscard]] auto totes_lletres_completes() const -> bool;
void changeState(AnimationState nou_estat);
[[nodiscard]] auto allLettersComplete() const -> bool;
};
source/game/scenes/title_scene.cpp
+5 -5
View File
@@ -84,7 +84,7 @@ TitleScene::TitleScene(SDLManager& sdl, SceneContext& context)
}
// Inicialitzar lletres del título "ORNI ATTACK!"
inicialitzar_titol();
initTitle();
// Logo JAILGAMES pequeño sobre el copyright inferior.
inicialitzarJailgames();
@@ -100,7 +100,7 @@ TitleScene::~TitleScene() {
Audio::get()->stopMusic();
}
void TitleScene::inicialitzar_titol() {
void TitleScene::initTitle() {
using namespace Graphics;
// === LÍNIA 1: "ORNI" ===
@@ -425,7 +425,7 @@ void TitleScene::update(float delta_time) {
}
// Actualitzar animación del logo
actualitzar_animacio_logo(delta_time);
updateLogoAnimation(delta_time);
break;
}
@@ -433,7 +433,7 @@ void TitleScene::update(float delta_time) {
temps_acumulat_ += delta_time;
// Continuar animación orbital durante la transición
actualitzar_animacio_logo(delta_time);
updateLogoAnimation(delta_time);
// [NOU] Continuar comprovant si l'altre player quiere unir-se durante la transición ("late join")
{
@@ -542,7 +542,7 @@ void TitleScene::update(float delta_time) {
}
}
void TitleScene::actualitzar_animacio_logo(float delta_time) {
void TitleScene::updateLogoAnimation(float delta_time) {
// Solo calcular i aplicar offsets si l'animación está activa
if (animacio_activa_) {
// Acumular time escalat
source/game/scenes/title_scene.hpp
+2 -2
View File
@@ -112,10 +112,10 @@ class TitleScene final : public Scene {
static constexpr float DURACIO_LERP = 2.0F; // 2s per arribar a amplitud completa
// Métodos privats
void actualitzar_animacio_logo(float delta_time); // Actualitza l'animación orbital del logo
void updateLogoAnimation(float delta_time); // Actualitza l'animación orbital del logo
auto checkSkipButtonPressed() -> bool;
auto checkStartGameButtonPressed() -> bool;
void inicialitzar_titol(); // Carrega i posiciona las lletres del título
void initTitle(); // Carrega i posiciona las lletres del título
void inicialitzarJailgames(); // Carrega i posiciona el logo JAILGAMES pequeño
void dibuixarPeuTitol(float spacing) const; // Logo JAILGAMES + línia de copyright
};
source/game/stage_system/spawn_controller.cpp
+8 -8
View File
@@ -28,7 +28,7 @@ void SpawnController::start() {
}
reset();
generar_spawn_events();
generateSpawnEvents();
std::cout << "[SpawnController] Stage " << static_cast<int>(config_->stage_id)
<< ": generats " << spawn_queue_.size() << " spawn events" << '\n';
@@ -63,7 +63,7 @@ void SpawnController::update(float delta_time, std::array<Enemy, 15>& orni_array
// Find first inactive enemy
for (auto& enemy : orni_array) {
if (!enemy.isActive()) {
spawn_enemic(enemy, event.type, ship_position_);
spawnEnemy(enemy, event.type, ship_position_);
event.spawnejat = true;
index_spawn_actual_++;
break;
@@ -113,7 +113,7 @@ auto SpawnController::get_enemics_spawnejats() const -> uint8_t {
return static_cast<uint8_t>(index_spawn_actual_);
}
void SpawnController::generar_spawn_events() {
void SpawnController::generateSpawnEvents() {
if (config_ == nullptr) {
return;
}
@@ -122,13 +122,13 @@ void SpawnController::generar_spawn_events() {
float spawn_time = config_->config_spawn.delay_inicial +
(i * config_->config_spawn.interval_spawn);
EnemyType type = seleccionar_tipus_aleatori();
EnemyType type = selectRandomType();
spawn_queue_.push_back({spawn_time, type, false});
}
}
auto SpawnController::seleccionar_tipus_aleatori() const -> EnemyType {
auto SpawnController::selectRandomType() const -> EnemyType {
if (config_ == nullptr) {
return EnemyType::PENTAGON;
}
@@ -145,15 +145,15 @@ auto SpawnController::seleccionar_tipus_aleatori() const -> EnemyType {
return EnemyType::MOLINILLO;
}
void SpawnController::spawn_enemic(Enemy& enemy, EnemyType type, const Vec2* ship_pos) {
void SpawnController::spawnEnemy(Enemy& enemy, EnemyType type, const Vec2* ship_pos) {
// Initialize enemy (with safe spawn if ship_pos provided)
enemy.init(type, ship_pos);
// Apply difficulty multipliers
aplicar_multiplicadors(enemy);
applyMultipliers(enemy);
}
void SpawnController::aplicar_multiplicadors(Enemy& enemy) const {
void SpawnController::applyMultipliers(Enemy& enemy) const {
if (config_ == nullptr) {
return;
}
source/game/stage_system/spawn_controller.hpp
+4 -4
View File
@@ -48,10 +48,10 @@ class SpawnController {
uint8_t index_spawn_actual_{0}; // Next spawn to process
// Spawn generation
void generar_spawn_events();
[[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;
void generateSpawnEvents();
[[nodiscard]] auto selectRandomType() const -> EnemyType;
void spawnEnemy(Enemy& enemy, EnemyType type, const Vec2* ship_pos = nullptr);
void applyMultipliers(Enemy& enemy) const;
const Vec2* ship_position_{nullptr}; // [NEW] Non-owning pointer to ship position
};
source/game/stage_system/stage_loader.cpp
+14 -14
View File
@@ -47,7 +47,7 @@ auto StageLoader::load(const std::string& path) -> std::unique_ptr<StageSystemCo
std::cerr << "[StageLoader] Error: falta camp 'metadata'" << '\n';
return nullptr;
}
if (!parse_metadata(yaml["metadata"], config->metadata)) {
if (!parseMetadata(yaml["metadata"], config->metadata)) {
return nullptr;
}
@@ -64,14 +64,14 @@ auto StageLoader::load(const std::string& path) -> std::unique_ptr<StageSystemCo
for (const auto& stage_yaml : yaml["stages"]) {
StageConfig stage;
if (!parse_stage(stage_yaml, stage)) {
if (!parseStage(stage_yaml, stage)) {
return nullptr;
}
config->stages.push_back(stage);
}
// Validar configuración
if (!validar_config(*config)) {
if (!validateConfig(*config)) {
return nullptr;
}
@@ -85,7 +85,7 @@ auto StageLoader::load(const std::string& path) -> std::unique_ptr<StageSystemCo
}
}
auto StageLoader::parse_metadata(const fkyaml::node& yaml, MetadataStages& meta) -> bool {
auto StageLoader::parseMetadata(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 @@ auto StageLoader::parse_metadata(const fkyaml::node& yaml, MetadataStages& meta)
}
}
auto StageLoader::parse_stage(const fkyaml::node& yaml, StageConfig& stage) -> bool {
auto StageLoader::parseStage(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") ||
@@ -117,13 +117,13 @@ auto StageLoader::parse_stage(const fkyaml::node& yaml, StageConfig& stage) -> b
stage.stage_id = yaml["stage_id"].get_value<uint8_t>();
stage.total_enemies = yaml["total_enemies"].get_value<uint8_t>();
if (!parse_spawn_config(yaml["spawn_config"], stage.config_spawn)) {
if (!parseSpawnConfig(yaml["spawn_config"], stage.config_spawn)) {
return false;
}
if (!parse_distribution(yaml["enemy_distribution"], stage.distribucio)) {
if (!parseDistribution(yaml["enemy_distribution"], stage.distribucio)) {
return false;
}
if (!parse_multipliers(yaml["difficulty_multipliers"], stage.multiplicadors)) {
if (!parseMultipliers(yaml["difficulty_multipliers"], stage.multiplicadors)) {
return false;
}
@@ -140,7 +140,7 @@ auto StageLoader::parse_stage(const fkyaml::node& yaml, StageConfig& stage) -> b
}
}
auto StageLoader::parse_spawn_config(const fkyaml::node& yaml, ConfigSpawn& config) -> bool {
auto StageLoader::parseSpawnConfig(const fkyaml::node& yaml, ConfigSpawn& config) -> bool {
try {
if (!yaml.contains("mode") || !yaml.contains("initial_delay") ||
!yaml.contains("spawn_interval")) {
@@ -149,7 +149,7 @@ auto StageLoader::parse_spawn_config(const fkyaml::node& yaml, ConfigSpawn& conf
}
auto mode_str = yaml["mode"].get_value<std::string>();
config.mode = parse_spawn_mode(mode_str);
config.mode = parseSpawnMode(mode_str);
config.delay_inicial = yaml["initial_delay"].get_value<float>();
config.interval_spawn = yaml["spawn_interval"].get_value<float>();
@@ -160,7 +160,7 @@ auto StageLoader::parse_spawn_config(const fkyaml::node& yaml, ConfigSpawn& conf
}
}
auto StageLoader::parse_distribution(const fkyaml::node& yaml, DistribucioEnemics& dist) -> bool {
auto StageLoader::parseDistribution(const fkyaml::node& yaml, DistribucioEnemics& dist) -> bool {
try {
if (!yaml.contains("pentagon") || !yaml.contains("cuadrado") ||
!yaml.contains("molinillo")) {
@@ -186,7 +186,7 @@ auto StageLoader::parse_distribution(const fkyaml::node& yaml, DistribucioEnemic
}
}
auto StageLoader::parse_multipliers(const fkyaml::node& yaml, MultiplicadorsDificultat& mult) -> bool {
auto StageLoader::parseMultipliers(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 @@ auto StageLoader::parse_multipliers(const fkyaml::node& yaml, MultiplicadorsDifi
}
}
auto StageLoader::parse_spawn_mode(const std::string& mode_str) -> ModeSpawn {
auto StageLoader::parseSpawnMode(const std::string& mode_str) -> ModeSpawn {
if (mode_str == "progressive") {
return ModeSpawn::PROGRESSIVE;
}
@@ -231,7 +231,7 @@ auto StageLoader::parse_spawn_mode(const std::string& mode_str) -> ModeSpawn {
return ModeSpawn::PROGRESSIVE;
}
auto StageLoader::validar_config(const StageSystemConfig& config) -> bool {
auto StageLoader::validateConfig(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
+7 -7
View File
@@ -19,15 +19,15 @@ class StageLoader {
private:
// Parsing helpers (implementats en .cpp)
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;
static auto parseMetadata(const fkyaml::node& yaml, MetadataStages& meta) -> bool;
static auto parseStage(const fkyaml::node& yaml, StageConfig& stage) -> bool;
static auto parseSpawnConfig(const fkyaml::node& yaml, ConfigSpawn& config) -> bool;
static auto parseDistribution(const fkyaml::node& yaml, DistribucioEnemics& dist) -> bool;
static auto parseMultipliers(const fkyaml::node& yaml, MultiplicadorsDificultat& mult) -> bool;
static auto parseSpawnMode(const std::string& mode_str) -> ModeSpawn;
// Validació
static auto validar_config(const StageSystemConfig& config) -> bool;
static auto validateConfig(const StageSystemConfig& config) -> bool;
};
} // namespace StageSystem
source/game/stage_system/stage_manager.cpp
+17 -17
View File
@@ -24,8 +24,8 @@ StageManager::StageManager(const StageSystemConfig* config)
void StageManager::init() {
stage_actual_ = 1;
carregar_stage(stage_actual_);
canviar_estat(EstatStage::INIT_HUD);
loadStage(stage_actual_);
changeState(EstatStage::INIT_HUD);
std::cout << "[StageManager] Inicialitzat a stage " << static_cast<int>(stage_actual_)
<< '\n';
@@ -34,19 +34,19 @@ void StageManager::init() {
void StageManager::update(float delta_time, bool pause_spawn) {
switch (estat_) {
case EstatStage::INIT_HUD:
processar_init_hud(delta_time);
processInitHud(delta_time);
break;
case EstatStage::LEVEL_START:
processar_level_start(delta_time);
processLevelStart(delta_time);
break;
case EstatStage::PLAYING:
processar_playing(delta_time, pause_spawn);
processPlaying(delta_time, pause_spawn);
break;
case EstatStage::LEVEL_COMPLETED:
processar_level_completed(delta_time);
processLevelCompleted(delta_time);
break;
}
}
@@ -54,7 +54,7 @@ void StageManager::update(float delta_time, bool pause_spawn) {
void StageManager::stage_completat() {
std::cout << "[StageManager] Stage " << static_cast<int>(stage_actual_) << " completat!"
<< '\n';
canviar_estat(EstatStage::LEVEL_COMPLETED);
changeState(EstatStage::LEVEL_COMPLETED);
}
auto StageManager::tot_completat() const -> bool {
@@ -67,7 +67,7 @@ auto StageManager::get_config_actual() const -> const StageConfig* {
return config_->obte_stage(stage_actual_);
}
void StageManager::canviar_estat(EstatStage nou_estat) {
void StageManager::changeState(EstatStage nou_estat) {
estat_ = nou_estat;
// Set timer based on state type
@@ -109,23 +109,23 @@ void StageManager::canviar_estat(EstatStage nou_estat) {
std::cout << '\n';
}
void StageManager::processar_init_hud(float delta_time) {
void StageManager::processInitHud(float delta_time) {
timer_transicio_ -= delta_time;
if (timer_transicio_ <= 0.0F) {
canviar_estat(EstatStage::LEVEL_START);
changeState(EstatStage::LEVEL_START);
}
}
void StageManager::processar_level_start(float delta_time) {
void StageManager::processLevelStart(float delta_time) {
timer_transicio_ -= delta_time;
if (timer_transicio_ <= 0.0F) {
canviar_estat(EstatStage::PLAYING);
changeState(EstatStage::PLAYING);
}
}
void StageManager::processar_playing(float delta_time, bool pause_spawn) {
void StageManager::processPlaying(float delta_time, bool pause_spawn) {
// Update spawn controller (pauses when pause_spawn = true)
// Note: The actual enemy array update happens in GameScene::update()
// This is just for internal timekeeping
@@ -133,7 +133,7 @@ void StageManager::processar_playing(float delta_time, bool pause_spawn) {
(void)pause_spawn; // Passed to spawn_controller_.update() by GameScene
}
void StageManager::processar_level_completed(float delta_time) {
void StageManager::processLevelCompleted(float delta_time) {
timer_transicio_ -= delta_time;
if (timer_transicio_ <= 0.0F) {
@@ -148,12 +148,12 @@ void StageManager::processar_level_completed(float delta_time) {
}
// Load next stage
carregar_stage(stage_actual_);
canviar_estat(EstatStage::LEVEL_START);
loadStage(stage_actual_);
changeState(EstatStage::LEVEL_START);
}
}
void StageManager::carregar_stage(uint8_t stage_id) {
void StageManager::loadStage(uint8_t stage_id) {
const StageConfig* stage_config = config_->obte_stage(stage_id);
if (stage_config == nullptr) {
std::cerr << "[StageManager] Error: no es pot trobar stage " << static_cast<int>(stage_id)
source/game/stage_system/stage_manager.hpp
+6 -6
View File
@@ -52,12 +52,12 @@ class StageManager {
std::string missatge_level_start_actual_; // Missatge seleccionat per al level actual
// State transitions
void canviar_estat(EstatStage nou_estat);
void processar_init_hud(float delta_time);
void processar_level_start(float delta_time);
void processar_playing(float delta_time, bool pause_spawn);
void processar_level_completed(float delta_time);
void carregar_stage(uint8_t stage_id);
void changeState(EstatStage nou_estat);
void processInitHud(float delta_time);
void processLevelStart(float delta_time);
void processPlaying(float delta_time, bool pause_spawn);
void processLevelCompleted(float delta_time);
void loadStage(uint8_t stage_id);
};
} // namespace StageSystem
source/game/title/ship_animator.cpp
+15 -15
View File
@@ -25,12 +25,12 @@ void ShipAnimator::init() {
// Configurar ship P1
ships_[0].player_id = 1;
ships_[0].shape = forma_p1;
configurar_nau_p1(ships_[0]);
configureShipP1(ships_[0]);
// Configurar ship P2
ships_[1].player_id = 2;
ships_[1].shape = forma_p2;
configurar_nau_p2(ships_[1]);
configureShipP2(ships_[1]);
}
void ShipAnimator::update(float delta_time) {
@@ -42,13 +42,13 @@ void ShipAnimator::update(float delta_time) {
switch (ship.state) {
case ShipState::ENTERING:
actualitzar_entering(ship, delta_time);
updateEntering(ship, delta_time);
break;
case ShipState::FLOATING:
actualitzar_floating(ship, delta_time);
updateFloating(ship, delta_time);
break;
case ShipState::EXITING:
actualitzar_exiting(ship, delta_time);
updateExiting(ship, delta_time);
break;
}
}
@@ -79,14 +79,14 @@ void ShipAnimator::start_entry_animation() {
// Configurar ship P1 para l'animación de entrada
ships_[0].state = ShipState::ENTERING;
ships_[0].state_time = 0.0F;
ships_[0].initial_position = calcular_posicio_fora_pantalla(CLOCK_8_ANGLE);
ships_[0].initial_position = computeOffscreenPosition(CLOCK_8_ANGLE);
ships_[0].current_position = ships_[0].initial_position;
ships_[0].current_scale = ships_[0].initial_scale;
// Configurar ship P2 para l'animación de entrada
ships_[1].state = ShipState::ENTERING;
ships_[1].state_time = 0.0F;
ships_[1].initial_position = calcular_posicio_fora_pantalla(CLOCK_4_ANGLE);
ships_[1].initial_position = computeOffscreenPosition(CLOCK_4_ANGLE);
ships_[1].current_position = ships_[1].initial_position;
ships_[1].current_scale = ships_[1].initial_scale;
}
@@ -167,7 +167,7 @@ auto ShipAnimator::is_animation_complete() const -> bool {
}
// Métodos de animación (stubs)
void ShipAnimator::actualitzar_entering(TitleShip& ship, float delta_time) {
void ShipAnimator::updateEntering(TitleShip& ship, float delta_time) {
using namespace Defaults::Title::Ships;
ship.state_time += delta_time;
@@ -202,7 +202,7 @@ void ShipAnimator::actualitzar_entering(TitleShip& ship, float delta_time) {
}
}
void ShipAnimator::actualitzar_floating(TitleShip& ship, float delta_time) {
void ShipAnimator::updateFloating(TitleShip& ship, float delta_time) {
using namespace Defaults::Title::Ships;
// Actualitzar time i fase de oscil·lació
@@ -221,7 +221,7 @@ void ShipAnimator::actualitzar_floating(TitleShip& ship, float delta_time) {
ship.current_scale = ship.target_scale;
}
void ShipAnimator::actualitzar_exiting(TitleShip& ship, float delta_time) {
void ShipAnimator::updateExiting(TitleShip& ship, float delta_time) {
using namespace Defaults::Title::Ships;
ship.state_time += delta_time;
@@ -250,7 +250,7 @@ void ShipAnimator::actualitzar_exiting(TitleShip& ship, float delta_time) {
}
// Configuración
void ShipAnimator::configurar_nau_p1(TitleShip& ship) {
void ShipAnimator::configureShipP1(TitleShip& ship) {
using namespace Defaults::Title::Ships;
// Estat inicial: FLOATING (per test estàtic)
@@ -261,7 +261,7 @@ void ShipAnimator::configurar_nau_p1(TitleShip& ship) {
ship.target_position = {.x = P1_TARGET_X(), .y = P1_TARGET_Y()};
// Calcular posición inicial (fuera de pantalla)
ship.initial_position = calcular_posicio_fora_pantalla(CLOCK_8_ANGLE);
ship.initial_position = computeOffscreenPosition(CLOCK_8_ANGLE);
ship.current_position = ship.initial_position; // Començar fuera de pantalla
// Escales
@@ -285,7 +285,7 @@ void ShipAnimator::configurar_nau_p1(TitleShip& ship) {
ship.visible = true;
}
void ShipAnimator::configurar_nau_p2(TitleShip& ship) {
void ShipAnimator::configureShipP2(TitleShip& ship) {
using namespace Defaults::Title::Ships;
// Estat inicial: FLOATING (per test estàtic)
@@ -296,7 +296,7 @@ void ShipAnimator::configurar_nau_p2(TitleShip& ship) {
ship.target_position = {.x = P2_TARGET_X(), .y = P2_TARGET_Y()};
// Calcular posición inicial (fuera de pantalla)
ship.initial_position = calcular_posicio_fora_pantalla(CLOCK_4_ANGLE);
ship.initial_position = computeOffscreenPosition(CLOCK_4_ANGLE);
ship.current_position = ship.initial_position; // Començar fuera de pantalla
// Escales
@@ -320,7 +320,7 @@ void ShipAnimator::configurar_nau_p2(TitleShip& ship) {
ship.visible = true;
}
auto ShipAnimator::calcular_posicio_fora_pantalla(float angle_rellotge) const -> Vec2 {
auto ShipAnimator::computeOffscreenPosition(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
+6 -6
View File
@@ -90,14 +90,14 @@ class ShipAnimator {
std::array<TitleShip, 2> ships_; // Naves P1 i P2
// Métodos de animación
void actualitzar_entering(TitleShip& ship, float delta_time);
void actualitzar_floating(TitleShip& ship, float delta_time);
void actualitzar_exiting(TitleShip& ship, float delta_time);
void updateEntering(TitleShip& ship, float delta_time);
void updateFloating(TitleShip& ship, float delta_time);
void updateExiting(TitleShip& ship, float delta_time);
// Configuración
void configurar_nau_p1(TitleShip& ship);
void configurar_nau_p2(TitleShip& ship);
[[nodiscard]] auto calcular_posicio_fora_pantalla(float angle_rellotge) const -> Vec2;
void configureShipP1(TitleShip& ship);
void configureShipP2(TitleShip& ship);
[[nodiscard]] auto computeOffscreenPosition(float angle_rellotge) const -> Vec2;
};
} // namespace Title