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

refactor(scenes): renombra identificadors valencians de logo/title a anglès

Browse Source
This commit is contained in:
Sergio Valor
2026-05-24 08:00:40 +02:00
parent 4cfad053f0
commit 7305d2f5dc
6 changed files with 199 additions and 199 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/game/scenes/logo_scene.cpp
+57 -57
View File
@@ -54,7 +54,7 @@ LogoScene::LogoScene(SDLManager& sdl, SceneContext& context)
auto option = context_.consumeOption();
(void)option; // Suprimir warning
so_reproduit_.fill(false); // Inicialitzar seguiment de sons
sound_played_.fill(false); // Inicialitzar seguiment de sons
initLetters();
}
@@ -112,21 +112,21 @@ void LogoScene::initLetters() {
float ancho_sin_escalar = max_x - min_x;
// IMPORTANT: Escalar ancho i offset con ESCALA_FINAL
// IMPORTANT: Escalar ancho i offset con FINAL_SCALE
// per que las posicions finals coincideixin con la mida real de las lletres
float ancho = ancho_sin_escalar * ESCALA_FINAL;
float offset_centre = (shape->getCenter().x - min_x) * ESCALA_FINAL;
float ancho = ancho_sin_escalar * FINAL_SCALE;
float center_offset = (shape->getCenter().x - min_x) * FINAL_SCALE;
lletres_.push_back({shape,
letters_.push_back({shape,
{.x = 0.0F, .y = 0.0F}, // Posición es calcularà después
ancho,
offset_centre});
center_offset});
ancho_total += ancho;
}
// Pas 2: Añadir espaiat entre lletres
ancho_total += ESPAI_ENTRE_LLETRES * (lletres_.size() - 1);
ancho_total += LETTER_SPACING * (letters_.size() - 1);
// Pas 3: Calcular posición inicial (centrat horitzontal)
constexpr auto PANTALLA_ANCHO = static_cast<float>(Defaults::Game::WIDTH);
@@ -138,38 +138,38 @@ void LogoScene::initLetters() {
// Pas 4: Assignar posicions a cada lletra
float x_actual = x_inicial;
for (auto& lletra : lletres_) {
for (auto& lletra : letters_) {
// Posicionar el centro de la shape (shape_centre) en pantalla
// Usar offset_centre en lloc de ancho/2 perquè shape_centre
// Usar center_offset en lloc de ancho/2 perquè shape_centre
// pot no estar exactament al mig del bounding box
lletra.position.x = x_actual + lletra.offset_centre;
lletra.position.x = x_actual + lletra.center_offset;
lletra.position.y = y_centre;
// Avançar para següent lletra
x_actual += lletra.ancho + ESPAI_ENTRE_LLETRES;
x_actual += lletra.ancho + LETTER_SPACING;
}
std::cout << "[LogoScene] " << lletres_.size()
std::cout << "[LogoScene] " << letters_.size()
<< " lletres carregades, ancho total: " << ancho_total << " px\n";
}
void LogoScene::changeState(AnimationState nou_estat) {
estat_actual_ = nou_estat;
temps_estat_actual_ = 0.0F; // Reset time
current_state_ = nou_estat;
temps_current_state_ = 0.0F; // Reset time
// Inicialitzar state de explosión
if (nou_estat == AnimationState::EXPLOSION) {
lletra_explosio_index_ = 0;
temps_des_ultima_explosio_ = 0.0F;
letter_explosion_index_ = 0;
time_since_last_explosion_ = 0.0F;
// Generar ordre aleatori de explosions
ordre_explosio_.clear();
for (size_t i = 0; i < lletres_.size(); i++) {
ordre_explosio_.push_back(i);
explosion_order_.clear();
for (size_t i = 0; i < letters_.size(); i++) {
explosion_order_.push_back(i);
}
std::random_device rd;
std::mt19937 g(rd());
std::shuffle(ordre_explosio_.begin(), ordre_explosio_.end(), g);
std::shuffle(explosion_order_.begin(), explosion_order_.end(), g);
} else if (nou_estat == AnimationState::POST_EXPLOSION) {
Audio::get()->playMusic("title.ogg");
}
@@ -180,34 +180,34 @@ void LogoScene::changeState(AnimationState nou_estat) {
auto LogoScene::allLettersComplete() const -> bool {
// Cuando global_progress = 1.0, todas las lletres tenen letra_progress = 1.0
return temps_estat_actual_ >= DURACIO_ZOOM;
return temps_current_state_ >= DURATION_ZOOM;
}
void LogoScene::updateExplosions(float delta_time) {
temps_des_ultima_explosio_ += delta_time;
time_since_last_explosion_ += delta_time;
// Comprovar si es el moment de explode la següent lletra
if (temps_des_ultima_explosio_ >= DELAY_ENTRE_EXPLOSIONS) {
if (lletra_explosio_index_ < lletres_.size()) {
if (time_since_last_explosion_ >= DELAY_ENTRE_EXPLOSIONS) {
if (letter_explosion_index_ < letters_.size()) {
// Explotar lletra actual (en ordre aleatori)
size_t index_actual = ordre_explosio_[lletra_explosio_index_];
const auto& lletra = lletres_[index_actual];
size_t index_actual = explosion_order_[letter_explosion_index_];
const auto& lletra = letters_[index_actual];
debris_manager_->explode(
lletra.shape, // Forma a explode
lletra.position, // Posición
0.0F, // Angle (sin rotación)
ESCALA_FINAL, // Escala (lletres a scale final)
FINAL_SCALE, // Escala (lletres a scale final)
SPEED_EXPLOSIO, // Velocidad base
1.0F, // Brightness màxim (per defecte)
{.x = 0.0F, .y = 0.0F} // Sin velocity (per defecte)
);
std::cout << "[LogoScene] Explota lletra " << lletra_explosio_index_ << "\n";
std::cout << "[LogoScene] Explota lletra " << letter_explosion_index_ << "\n";
// Passar a la següent lletra
lletra_explosio_index_++;
temps_des_ultima_explosio_ = 0.0F;
letter_explosion_index_++;
time_since_last_explosion_ = 0.0F;
} else {
// Todas las lletres han explotat, transición a POST_EXPLOSION
changeState(AnimationState::POST_EXPLOSION);
@@ -216,31 +216,31 @@ void LogoScene::updateExplosions(float delta_time) {
}
void LogoScene::update(float delta_time) {
temps_estat_actual_ += delta_time;
temps_current_state_ += delta_time;
switch (estat_actual_) {
switch (current_state_) {
case AnimationState::PRE_ANIMATION:
if (temps_estat_actual_ >= DURACIO_PRE) {
if (temps_current_state_ >= DURATION_PRE) {
changeState(AnimationState::ANIMATION);
}
break;
case AnimationState::ANIMATION: {
// Reproduir so per cada lletra cuando comença a aparèixer
float global_progress = std::min(temps_estat_actual_ / DURACIO_ZOOM, 1.0F);
float global_progress = std::min(temps_current_state_ / DURATION_ZOOM, 1.0F);
for (size_t i = 0; i < lletres_.size() && i < so_reproduit_.size(); i++) {
if (!so_reproduit_[i]) {
for (size_t i = 0; i < letters_.size() && i < sound_played_.size(); i++) {
if (!sound_played_[i]) {
float letra_progress = computeLetterProgress(
i,
lletres_.size(),
letters_.size(),
global_progress,
THRESHOLD_LETRA);
LETTER_THRESHOLD);
// Reproduir so cuando la lletra comença a aparèixer (progress > 0)
if (letra_progress > 0.0F) {
Audio::get()->playSound(Defaults::Sound::LOGO, Audio::Group::GAME);
so_reproduit_[i] = true;
sound_played_[i] = true;
}
}
}
@@ -252,7 +252,7 @@ void LogoScene::update(float delta_time) {
}
case AnimationState::POST_ANIMATION:
if (temps_estat_actual_ >= DURACIO_POST_ANIMATION) {
if (temps_current_state_ >= DURATION_POST_ANIMATION) {
changeState(AnimationState::EXPLOSION);
}
break;
@@ -262,7 +262,7 @@ void LogoScene::update(float delta_time) {
break;
case AnimationState::POST_EXPLOSION:
if (temps_estat_actual_ >= DURACIO_POST_EXPLOSION) {
if (temps_current_state_ >= DURATION_POST_EXPLOSION) {
// Transición a pantalla de título
context_.setNextScene(SceneType::TITLE);
}
@@ -282,28 +282,28 @@ void LogoScene::draw() {
// Director ha hecho el clear; aquí solo pintamos lo de la escena.
// PRE_ANIMATION: Solo pantalla negra (no se pinta nada).
if (estat_actual_ == AnimationState::PRE_ANIMATION) {
if (current_state_ == AnimationState::PRE_ANIMATION) {
return;
}
// ANIMATION o POST_ANIMATION: Dibuixar lletres con animación
if (estat_actual_ == AnimationState::ANIMATION ||
estat_actual_ == AnimationState::POST_ANIMATION) {
if (current_state_ == AnimationState::ANIMATION ||
current_state_ == AnimationState::POST_ANIMATION) {
float global_progress =
(estat_actual_ == AnimationState::ANIMATION)
? std::min(temps_estat_actual_ / DURACIO_ZOOM, 1.0F)
(current_state_ == AnimationState::ANIMATION)
? std::min(temps_current_state_ / DURATION_ZOOM, 1.0F)
: 1.0F; // POST: mantenir al 100%
const Vec2 ORIGEN_ZOOM = {.x = ORIGEN_ZOOM_X, .y = ORIGEN_ZOOM_Y};
for (size_t i = 0; i < lletres_.size(); i++) {
const auto& lletra = lletres_[i];
for (size_t i = 0; i < letters_.size(); i++) {
const auto& lletra = letters_[i];
float letra_progress = computeLetterProgress(
i,
lletres_.size(),
letters_.size(),
global_progress,
THRESHOLD_LETRA);
LETTER_THRESHOLD);
if (letra_progress <= 0.0F) {
continue;
@@ -318,7 +318,7 @@ void LogoScene::draw() {
float t = letra_progress;
float ease_factor = 1.0F - ((1.0F - t) * (1.0F - t));
float current_scale =
ESCALA_INICIAL + ((ESCALA_FINAL - ESCALA_INICIAL) * ease_factor);
INITIAL_SCALE + ((FINAL_SCALE - INITIAL_SCALE) * ease_factor);
Rendering::renderShape(
sdl_.getRenderer(),
@@ -331,24 +331,24 @@ void LogoScene::draw() {
}
// EXPLOSION: Dibuixar solo lletres que aún no han explotat
if (estat_actual_ == AnimationState::EXPLOSION) {
if (current_state_ == AnimationState::EXPLOSION) {
// Crear conjunt de lletres ya explotades
std::set<size_t> explotades;
for (size_t i = 0; i < lletra_explosio_index_; i++) {
explotades.insert(ordre_explosio_[i]);
for (size_t i = 0; i < letter_explosion_index_; i++) {
explotades.insert(explosion_order_[i]);
}
// Dibuixar solo lletres que NO han explotat
for (size_t i = 0; i < lletres_.size(); i++) {
for (size_t i = 0; i < letters_.size(); i++) {
if (!explotades.contains(i)) {
const auto& lletra = lletres_[i];
const auto& lletra = letters_[i];
Rendering::renderShape(
sdl_.getRenderer(),
lletra.shape,
lletra.position,
0.0F,
ESCALA_FINAL,
FINAL_SCALE,
1.0F);
}
}