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/entities/enemy.cpp
+6 -6
View File
@@ -394,9 +394,9 @@ void Enemy::updatePulse(float delta_time) {
animation_.pulse_amplitude = Defaults::Enemies::Animation::PULSE_AMPLITUD_MIN +
((static_cast<float>(std::rand()) / static_cast<float>(RAND_MAX)) * AMP_RANGE);
const float DUR_RANGE = Defaults::Enemies::Animation::PULSE_DURACIO_MAX -
Defaults::Enemies::Animation::PULSE_DURACIO_MIN;
animation_.pulse_time_remaining = Defaults::Enemies::Animation::PULSE_DURACIO_MIN +
const float DUR_RANGE = Defaults::Enemies::Animation::PULSE_DURATION_MAX -
Defaults::Enemies::Animation::PULSE_DURATION_MIN;
animation_.pulse_time_remaining = Defaults::Enemies::Animation::PULSE_DURATION_MIN +
((static_cast<float>(std::rand()) / static_cast<float>(RAND_MAX)) * DUR_RANGE);
}
}
@@ -428,9 +428,9 @@ void Enemy::updateRotationAcceleration(float delta_time) {
((static_cast<float>(std::rand()) / static_cast<float>(RAND_MAX)) * MULT_RANGE);
animation_.rotation_delta_target = animation_.rotation_delta_base * MULTIPLIER;
const float DUR_RANGE = Defaults::Enemies::Animation::ROTATION_ACCEL_DURACIO_MAX -
Defaults::Enemies::Animation::ROTATION_ACCEL_DURACIO_MIN;
animation_.rotation_delta_duration = Defaults::Enemies::Animation::ROTATION_ACCEL_DURACIO_MIN +
const float DUR_RANGE = Defaults::Enemies::Animation::ROTATION_ACCEL_DURATION_MAX -
Defaults::Enemies::Animation::ROTATION_ACCEL_DURATION_MIN;
animation_.rotation_delta_duration = Defaults::Enemies::Animation::ROTATION_ACCEL_DURATION_MIN +
((static_cast<float>(std::rand()) / static_cast<float>(RAND_MAX)) * DUR_RANGE);
}
}
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);
}
}
source/game/scenes/logo_scene.hpp
+19 -19
View File
@@ -42,44 +42,44 @@ class LogoScene final : public Scene {
SDLManager& sdl_;
SceneManager::SceneContext& context_;
AnimationState estat_actual_{AnimationState::PRE_ANIMATION}; // Estat actual de la màquina
AnimationState current_state_{AnimationState::PRE_ANIMATION}; // Estat actual de la màquina
float
temps_estat_actual_{0.0F}; // Temps en l'state actual (reset en cada transición)
temps_current_state_{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_{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
size_t letter_explosion_index_{0}; // Índex de la següent lletra a explode
float time_since_last_explosion_{0.0F}; // Temps desde l'última explosión
std::vector<size_t> explosion_order_; // Ordre aleatori de índexs de lletres
// Estructura para cada lletra del logo
struct LetraLogo {
struct LogoLetter {
std::shared_ptr<Graphics::Shape> shape;
Vec2 position; // Posición final en pantalla
float ancho; // Ancho del bounding box
float offset_centre; // Distancia de min_x a shape_centre.x
float center_offset; // Distancia de min_x a shape_centre.x
};
std::vector<LetraLogo> lletres_; // 9 lletres: J-A-I-L-G-A-M-E-S
std::vector<LogoLetter> letters_; // 9 lletres: J-A-I-L-G-A-M-E-S
// Seguiment de sons de lletres (evitar reproduccions repetides)
std::array<bool, 9> so_reproduit_; // Track si cada lletra ya ha reproduit el so
std::array<bool, 9> sound_played_; // Track si cada lletra ya ha reproduit el so
// Constants de animación
static constexpr float DURACIO_PRE = 1.5F; // Duració PRE_ANIMATION (pantalla negra)
static constexpr float DURACIO_ZOOM = 4.0F; // Duració del zoom (segons)
static constexpr float DURACIO_POST_ANIMATION = 3.0F; // Duració POST_ANIMATION (logo complet)
static constexpr float DURACIO_POST_EXPLOSION = 3.0F; // Duració POST_EXPLOSION (espera final)
static constexpr float DELAY_ENTRE_EXPLOSIONS = 0.1F; // Temps entre explosions de lletres
static constexpr float SPEED_EXPLOSIO = 240.0F; // Velocidad base fragments (px/s)
static constexpr float ESCALA_INICIAL = 0.1F; // Escala inicial (10%)
static constexpr float ESCALA_FINAL = 0.8F; // Escala final (80%)
static constexpr float ESPAI_ENTRE_LLETRES = 10.0F; // Espaiat entre lletres
static constexpr float DURATION_PRE = 1.5F; // Duració PRE_ANIMATION (pantalla negra)
static constexpr float DURATION_ZOOM = 4.0F; // Duració del zoom (segons)
static constexpr float DURATION_POST_ANIMATION = 3.0F; // Duració POST_ANIMATION (logo complet)
static constexpr float DURATION_POST_EXPLOSION = 3.0F; // Duració POST_EXPLOSION (espera final)
static constexpr float DELAY_ENTRE_EXPLOSIONS = 0.1F; // Temps entre explosions de lletres
static constexpr float SPEED_EXPLOSIO = 240.0F; // Velocidad base fragments (px/s)
static constexpr float INITIAL_SCALE = 0.1F; // Escala inicial (10%)
static constexpr float FINAL_SCALE = 0.8F; // Escala final (80%)
static constexpr float LETTER_SPACING = 10.0F; // Espaiat entre lletres
// Constants de animación seqüencial
static constexpr float THRESHOLD_LETRA = 0.6F; // Umbral per activar següent lletra (0.0-1.0)
static constexpr float LETTER_THRESHOLD = 0.6F; // Umbral per activar següent lletra (0.0-1.0)
static constexpr float ORIGEN_ZOOM_X = Defaults::Game::WIDTH * 0.5F; // Vec2 inicial X del zoom
static constexpr float ORIGEN_ZOOM_Y = Defaults::Game::HEIGHT * 0.4F; // Vec2 inicial Y del zoom
source/game/scenes/title_scene.cpp
+94 -94
View File
@@ -43,8 +43,8 @@ TitleScene::TitleScene(SDLManager& sdl, SceneContext& context)
auto option = context_.consumeOption();
if (option == Option::JUMP_TO_TITLE_MAIN) {
std::cout << "SceneType Titol: Opció JUMP_TO_TITLE_MAIN activada\n";
estat_actual_ = TitleState::MAIN;
temps_estat_main_ = 0.0F;
current_state_ = TitleState::MAIN;
state_time_main_ = 0.0F;
}
// Càmera 3D: posicionada a l'origen, mirant cap a +Z, amb Y cap amunt.
@@ -61,7 +61,7 @@ TitleScene::TitleScene(SDLManager& sdl, SceneContext& context)
camera_.get(),
200);
starfield_->setColor(Defaults::Title::Colors::STARFIELD);
if (estat_actual_ == TitleState::MAIN) {
if (current_state_ == TitleState::MAIN) {
starfield_->setBrightness(BRIGHTNESS_STARFIELD);
} else {
starfield_->setBrightness(0.0F);
@@ -125,22 +125,22 @@ void TitleScene::initTitle() {
const float ANCHO = (max_x - min_x) * Defaults::Title::Layout::LOGO_SCALE;
const float ALTURA = (max_y - min_y) * Defaults::Title::Layout::LOGO_SCALE;
const float OFFSET_CENTRE = (shape->getCenter().x - min_x) * Defaults::Title::Layout::LOGO_SCALE;
lletres_orni_.push_back({shape, {.x = 0.0F, .y = 0.0F}, ANCHO, ALTURA, OFFSET_CENTRE});
letters_orni_.push_back({shape, {.x = 0.0F, .y = 0.0F}, ANCHO, ALTURA, OFFSET_CENTRE});
ancho_total_orni += ANCHO;
}
ancho_total_orni += ESPAI_ENTRE_LLETRES * static_cast<float>(lletres_orni_.size() - 1);
ancho_total_orni += LETTER_SPACING * static_cast<float>(letters_orni_.size() - 1);
float x_actual = (Defaults::Game::WIDTH - ancho_total_orni) / 2.0F;
for (auto& lletra : lletres_orni_) {
lletra.position.x = x_actual + lletra.offset_centre;
for (auto& lletra : letters_orni_) {
lletra.position.x = x_actual + lletra.center_offset;
lletra.position.y = Defaults::Game::HEIGHT * Defaults::Title::Layout::LOGO_POS;
x_actual += lletra.ancho + ESPAI_ENTRE_LLETRES;
x_actual += lletra.ancho + LETTER_SPACING;
}
const float ALTURA_ORNI = lletres_orni_.empty() ? 50.0F : lletres_orni_[0].altura;
const float ALTURA_ORNI = letters_orni_.empty() ? 50.0F : letters_orni_[0].altura;
const float Y_ORNI = Defaults::Game::HEIGHT * Defaults::Title::Layout::LOGO_POS;
const float SEPARACION = Defaults::Game::HEIGHT * Defaults::Title::Layout::LOGO_LINE_SPACING;
y_attack_dinamica_ = Y_ORNI + ALTURA_ORNI + SEPARACION;
dynamic_attack_y_ = Y_ORNI + ALTURA_ORNI + SEPARACION;
const std::vector<std::string> FITXERS_ATTACK = {
"title/letra_a.shp",
@@ -173,25 +173,25 @@ void TitleScene::initTitle() {
const float ANCHO = (max_x - min_x) * Defaults::Title::Layout::LOGO_SCALE;
const float ALTURA = (max_y - min_y) * Defaults::Title::Layout::LOGO_SCALE;
const float OFFSET_CENTRE = (shape->getCenter().x - min_x) * Defaults::Title::Layout::LOGO_SCALE;
lletres_attack_.push_back({shape, {.x = 0.0F, .y = 0.0F}, ANCHO, ALTURA, OFFSET_CENTRE});
letters_attack_.push_back({shape, {.x = 0.0F, .y = 0.0F}, ANCHO, ALTURA, OFFSET_CENTRE});
ancho_total_attack += ANCHO;
}
ancho_total_attack += ESPAI_ENTRE_LLETRES * static_cast<float>(lletres_attack_.size() - 1);
ancho_total_attack += LETTER_SPACING * static_cast<float>(letters_attack_.size() - 1);
x_actual = (Defaults::Game::WIDTH - ancho_total_attack) / 2.0F;
for (auto& lletra : lletres_attack_) {
lletra.position.x = x_actual + lletra.offset_centre;
lletra.position.y = y_attack_dinamica_;
x_actual += lletra.ancho + ESPAI_ENTRE_LLETRES;
for (auto& lletra : letters_attack_) {
lletra.position.x = x_actual + lletra.center_offset;
lletra.position.y = dynamic_attack_y_;
x_actual += lletra.ancho + LETTER_SPACING;
}
posicions_originals_orni_.clear();
for (const auto& lletra : lletres_orni_) {
posicions_originals_orni_.push_back(lletra.position);
original_positions_orni_.clear();
for (const auto& lletra : letters_orni_) {
original_positions_orni_.push_back(lletra.position);
}
posicions_originals_attack_.clear();
for (const auto& lletra : lletres_attack_) {
posicions_originals_attack_.push_back(lletra.position);
original_positions_attack_.clear();
for (const auto& lletra : letters_attack_) {
original_positions_attack_.push_back(lletra.position);
}
}
@@ -234,13 +234,13 @@ void TitleScene::inicialitzarJailgames() {
const float ANCHO = (max_x - min_x) * SCALE;
const float ALTURA = (max_y - min_y) * SCALE;
const float OFFSET_CENTRE = (shape->getCenter().x - min_x) * SCALE;
lletres_jailgames_.push_back({shape, {.x = 0.0F, .y = 0.0F}, ANCHO, ALTURA, OFFSET_CENTRE});
letters_jailgames_.push_back({shape, {.x = 0.0F, .y = 0.0F}, ANCHO, ALTURA, OFFSET_CENTRE});
ancho_total += ANCHO;
altura_max = std::max(altura_max, ALTURA);
}
constexpr float ESPAI_JAILGAMES = ESPAI_ENTRE_LLETRES * SCALE;
if (!lletres_jailgames_.empty()) {
ancho_total += ESPAI_JAILGAMES * static_cast<float>(lletres_jailgames_.size() - 1);
constexpr float ESPAI_JAILGAMES = LETTER_SPACING * SCALE;
if (!letters_jailgames_.empty()) {
ancho_total += ESPAI_JAILGAMES * static_cast<float>(letters_jailgames_.size() - 1);
}
const float Y_COPY = Defaults::Game::HEIGHT * Defaults::Title::Layout::COPYRIGHT1_POS;
@@ -249,8 +249,8 @@ void TitleScene::inicialitzarJailgames() {
const float X_INICIAL = (Defaults::Game::WIDTH - ancho_total) / 2.0F;
float x_actual = X_INICIAL;
for (auto& lletra : lletres_jailgames_) {
lletra.position.x = x_actual + lletra.offset_centre;
for (auto& lletra : letters_jailgames_) {
lletra.position.x = x_actual + lletra.center_offset;
lletra.position.y = Y_CENTRE;
x_actual += lletra.ancho + ESPAI_JAILGAMES;
}
@@ -268,7 +268,7 @@ void TitleScene::dibuixarPeuTitol(float spacing) const {
const float COPYRIGHT_S = std::lerp(S::FOOTER_INTRO_SCALE_START, 1.0F, Easing::easeOutQuad(intro_copyright_progress_));
const float JAILGAMES_RENDER_SCALE = Defaults::Title::Layout::JAILGAMES_SCALE * JAILGAMES_S;
for (const auto& lletra : lletres_jailgames_) {
for (const auto& lletra : letters_jailgames_) {
const Vec2 POS{
.x = SCREEN_CENTRE_X + (JAILGAMES_S * (lletra.position.x - SCREEN_CENTRE_X)),
.y = SCREEN_CENTRE_Y + (JAILGAMES_S * (lletra.position.y - SCREEN_CENTRE_Y)),
@@ -297,15 +297,15 @@ void TitleScene::update(float delta_time) {
starfield_->update(delta_time);
}
if (ship_animator_ &&
(estat_actual_ == TitleState::STARFIELD_FADE_IN ||
estat_actual_ == TitleState::STARFIELD ||
estat_actual_ == TitleState::MAIN ||
estat_actual_ == TitleState::PLAYER_JOIN_PHASE)) {
(current_state_ == TitleState::STARFIELD_FADE_IN ||
current_state_ == TitleState::STARFIELD ||
current_state_ == TitleState::MAIN ||
current_state_ == TitleState::PLAYER_JOIN_PHASE)) {
ship_animator_->update(delta_time);
}
updateFlashes(delta_time);
switch (estat_actual_) {
switch (current_state_) {
case TitleState::STARFIELD_FADE_IN:
updateStarfieldFadeInState(delta_time);
break;
@@ -329,10 +329,10 @@ void TitleScene::update(float delta_time) {
void TitleScene::updateStarfieldFadeInState(float delta_time) {
temps_acumulat_ += delta_time;
const float PROGRESS = std::min(1.0F, temps_acumulat_ / DURACIO_FADE_IN);
const float PROGRESS = std::min(1.0F, temps_acumulat_ / DURATION_FADE_IN);
starfield_->setBrightness(PROGRESS * BRIGHTNESS_STARFIELD);
if (temps_acumulat_ >= DURACIO_FADE_IN) {
estat_actual_ = TitleState::STARFIELD;
if (temps_acumulat_ >= DURATION_FADE_IN) {
current_state_ = TitleState::STARFIELD;
temps_acumulat_ = 0.0F;
starfield_->setBrightness(BRIGHTNESS_STARFIELD);
}
@@ -340,16 +340,16 @@ void TitleScene::updateStarfieldFadeInState(float delta_time) {
void TitleScene::updateStarfieldState(float delta_time) {
temps_acumulat_ += delta_time;
if (temps_acumulat_ >= DURACIO_INIT) {
estat_actual_ = TitleState::MAIN;
temps_estat_main_ = 0.0F;
animacio_activa_ = false;
factor_lerp_ = 0.0F;
if (temps_acumulat_ >= DURATION_INIT) {
current_state_ = TitleState::MAIN;
state_time_main_ = 0.0F;
animation_active_ = false;
lerp_factor_ = 0.0F;
}
}
void TitleScene::updateMainState(float delta_time) {
temps_estat_main_ += delta_time;
state_time_main_ += delta_time;
namespace S = Defaults::Title::Sequence;
namespace Sh = Defaults::Title::Ships;
@@ -364,38 +364,38 @@ void TitleScene::updateMainState(float delta_time) {
constexpr float T_SHIPS_LANDED = T_SHIPS_START + Sh::ENTRY_DURATION + Sh::P2_ENTRY_DELAY;
constexpr float T_PRESS_START_VISIBLE = T_SHIPS_LANDED + S::PRESS_START_DELAY_AFTER_SHIPS;
intro_logo_progress_ = std::clamp(temps_estat_main_ / S::LOGO_ENTRY_DURATION, 0.0F, 1.0F);
intro_logo_progress_ = std::clamp(state_time_main_ / S::LOGO_ENTRY_DURATION, 0.0F, 1.0F);
intro_jailgames_progress_ = std::clamp(
(temps_estat_main_ - T_FOOTER_START) / S::JAILGAMES_ENTRY_DURATION,
(state_time_main_ - T_FOOTER_START) / S::JAILGAMES_ENTRY_DURATION,
0.0F,
1.0F);
intro_copyright_progress_ = std::clamp(
(temps_estat_main_ - T_COPY_START) / S::COPYRIGHT_ENTRY_DURATION,
(state_time_main_ - T_COPY_START) / S::COPYRIGHT_ENTRY_DURATION,
0.0F,
1.0F);
if (!ships_intro_launched_ && temps_estat_main_ >= T_SHIPS_START &&
if (!ships_intro_launched_ && state_time_main_ >= T_SHIPS_START &&
ship_animator_ != nullptr) {
ship_animator_->setVisible(true);
ship_animator_->startEntryAnimation();
ships_intro_launched_ = true;
}
if (!press_start_visible_ && temps_estat_main_ >= T_PRESS_START_VISIBLE) {
if (!press_start_visible_ && state_time_main_ >= T_PRESS_START_VISIBLE) {
press_start_visible_ = true;
}
// L'oscil·lació suau del logo arrenca quan el logo ha aterrat. Així
// l'amplitud creix gradualment (lerp) durant la resta de la intro.
if (temps_estat_main_ < S::LOGO_ENTRY_DURATION) {
factor_lerp_ = 0.0F;
animacio_activa_ = false;
} else if (temps_estat_main_ < S::LOGO_ENTRY_DURATION + DURACIO_LERP) {
factor_lerp_ = (temps_estat_main_ - S::LOGO_ENTRY_DURATION) / DURACIO_LERP;
animacio_activa_ = true;
if (state_time_main_ < S::LOGO_ENTRY_DURATION) {
lerp_factor_ = 0.0F;
animation_active_ = false;
} else if (state_time_main_ < S::LOGO_ENTRY_DURATION + DURATION_LERP) {
lerp_factor_ = (state_time_main_ - S::LOGO_ENTRY_DURATION) / DURATION_LERP;
animation_active_ = true;
} else {
factor_lerp_ = 1.0F;
animacio_activa_ = true;
lerp_factor_ = 1.0F;
animation_active_ = true;
}
updateLogoAnimation(delta_time);
}
@@ -414,27 +414,27 @@ void TitleScene::updatePlayerJoinPhaseState(float delta_time) {
temps_acumulat_ = 0.0F;
}
if (temps_acumulat_ >= DURACIO_TRANSITION) {
estat_actual_ = TitleState::BLACK_SCREEN;
if (temps_acumulat_ >= DURATION_TRANSITION) {
current_state_ = TitleState::BLACK_SCREEN;
temps_acumulat_ = 0.0F;
}
}
void TitleScene::updateBlackScreenState(float delta_time) {
temps_acumulat_ += delta_time;
if (temps_acumulat_ >= DURACIO_BLACK_SCREEN) {
if (temps_acumulat_ >= DURATION_BLACK_SCREEN) {
context_.setNextScene(SceneType::GAME);
}
}
void TitleScene::handleSkipInput() {
if (estat_actual_ != TitleState::STARFIELD_FADE_IN && estat_actual_ != TitleState::STARFIELD) {
if (current_state_ != TitleState::STARFIELD_FADE_IN && current_state_ != TitleState::STARFIELD) {
return;
}
if (!checkSkipButtonPressed()) {
return;
}
estat_actual_ = TitleState::MAIN;
current_state_ = TitleState::MAIN;
starfield_->setBrightness(BRIGHTNESS_STARFIELD);
// Saltar la intro coreografiada: deixar tots els elements ja in-place.
@@ -445,7 +445,7 @@ void TitleScene::handleSkipInput() {
S::LOGO_ENTRY_DURATION + S::COPYRIGHT_STAGGER + S::COPYRIGHT_ENTRY_DURATION);
constexpr float T_PRESS_START_VISIBLE = T_FOOTER_END + S::SHIPS_DELAY_AFTER_FOOTER +
Sh::ENTRY_DURATION + Sh::P2_ENTRY_DELAY + S::PRESS_START_DELAY_AFTER_SHIPS;
temps_estat_main_ = T_PRESS_START_VISIBLE;
state_time_main_ = T_PRESS_START_VISIBLE;
intro_logo_progress_ = 1.0F;
intro_jailgames_progress_ = 1.0F;
intro_copyright_progress_ = 1.0F;
@@ -458,7 +458,7 @@ void TitleScene::handleSkipInput() {
}
void TitleScene::handleStartInput() {
if (estat_actual_ != TitleState::MAIN) {
if (current_state_ != TitleState::MAIN) {
return;
}
// No acceptar START fins que la intro coreografiada haja conclòs i el
@@ -479,7 +479,7 @@ void TitleScene::handleStartInput() {
}
context_.setMatchConfig(match_config_);
estat_actual_ = TitleState::PLAYER_JOIN_PHASE;
current_state_ = TitleState::PLAYER_JOIN_PHASE;
temps_acumulat_ = 0.0F;
triggerExitForJoinedPlayers(P1_ABANS, P2_ABANS, "");
@@ -503,44 +503,44 @@ void TitleScene::triggerExitForJoinedPlayers(bool p1_was_active, bool p2_was_act
}
void TitleScene::updateLogoAnimation(float delta_time) {
if (!animacio_activa_) {
if (!animation_active_) {
return;
}
temps_animacio_ += delta_time * factor_lerp_;
animation_time_ += delta_time * lerp_factor_;
const float TWO_PI = 2.0F * Defaults::Math::PI;
const float OFFSET_X = ORBIT_AMPLITUDE_X * std::sin(TWO_PI * ORBIT_FREQUENCY_X * temps_animacio_);
const float OFFSET_Y = ORBIT_AMPLITUDE_Y * std::sin((TWO_PI * ORBIT_FREQUENCY_Y * temps_animacio_) + ORBIT_PHASE_OFFSET);
const float OFFSET_X = ORBIT_AMPLITUDE_X * std::sin(TWO_PI * ORBIT_FREQUENCY_X * animation_time_);
const float OFFSET_Y = ORBIT_AMPLITUDE_Y * std::sin((TWO_PI * ORBIT_FREQUENCY_Y * animation_time_) + ORBIT_PHASE_OFFSET);
for (std::size_t i = 0; i < lletres_orni_.size(); ++i) {
lletres_orni_[i].position.x = posicions_originals_orni_[i].x + std::round(OFFSET_X);
lletres_orni_[i].position.y = posicions_originals_orni_[i].y + std::round(OFFSET_Y);
for (std::size_t i = 0; i < letters_orni_.size(); ++i) {
letters_orni_[i].position.x = original_positions_orni_[i].x + std::round(OFFSET_X);
letters_orni_[i].position.y = original_positions_orni_[i].y + std::round(OFFSET_Y);
}
for (std::size_t i = 0; i < lletres_attack_.size(); ++i) {
lletres_attack_[i].position.x = posicions_originals_attack_[i].x + std::round(OFFSET_X);
lletres_attack_[i].position.y = posicions_originals_attack_[i].y + std::round(OFFSET_Y);
for (std::size_t i = 0; i < letters_attack_.size(); ++i) {
letters_attack_[i].position.x = original_positions_attack_[i].x + std::round(OFFSET_X);
letters_attack_[i].position.y = original_positions_attack_[i].y + std::round(OFFSET_Y);
}
}
void TitleScene::draw() {
if (starfield_ && estat_actual_ != TitleState::BLACK_SCREEN) {
if (starfield_ && current_state_ != TitleState::BLACK_SCREEN) {
starfield_->draw();
}
if (ship_animator_ &&
(estat_actual_ == TitleState::STARFIELD_FADE_IN ||
estat_actual_ == TitleState::STARFIELD ||
estat_actual_ == TitleState::MAIN ||
estat_actual_ == TitleState::PLAYER_JOIN_PHASE)) {
(current_state_ == TitleState::STARFIELD_FADE_IN ||
current_state_ == TitleState::STARFIELD ||
current_state_ == TitleState::MAIN ||
current_state_ == TitleState::PLAYER_JOIN_PHASE)) {
ship_animator_->draw();
}
drawFlashes();
if (estat_actual_ == TitleState::STARFIELD_FADE_IN || estat_actual_ == TitleState::STARFIELD) {
if (current_state_ == TitleState::STARFIELD_FADE_IN || current_state_ == TitleState::STARFIELD) {
return;
}
if (estat_actual_ != TitleState::MAIN && estat_actual_ != TitleState::PLAYER_JOIN_PHASE) {
if (current_state_ != TitleState::MAIN && current_state_ != TitleState::PLAYER_JOIN_PHASE) {
return;
}
@@ -552,40 +552,40 @@ void TitleScene::draw() {
const float SCREEN_CENTRE_Y = Defaults::Game::HEIGHT / 2.0F;
const float LOGO_RENDER_SCALE = Defaults::Title::Layout::LOGO_SCALE * LOGO_S;
if (animacio_activa_) {
float temps_shadow = std::max(0.0F, temps_animacio_ - SHADOW_DELAY);
if (animation_active_) {
float temps_shadow = std::max(0.0F, animation_time_ - SHADOW_DELAY);
const float TWO_PI = 2.0F * Defaults::Math::PI;
const float SHADOW_OX = (ORBIT_AMPLITUDE_X * std::sin(TWO_PI * ORBIT_FREQUENCY_X * temps_shadow)) + SHADOW_OFFSET_X;
const float SHADOW_OY = (ORBIT_AMPLITUDE_Y * std::sin((TWO_PI * ORBIT_FREQUENCY_Y * temps_shadow) + ORBIT_PHASE_OFFSET)) + SHADOW_OFFSET_Y;
for (std::size_t i = 0; i < lletres_orni_.size(); ++i) {
const float BASE_X = posicions_originals_orni_[i].x + std::round(SHADOW_OX);
const float BASE_Y = posicions_originals_orni_[i].y + std::round(SHADOW_OY);
for (std::size_t i = 0; i < letters_orni_.size(); ++i) {
const float BASE_X = original_positions_orni_[i].x + std::round(SHADOW_OX);
const float BASE_Y = original_positions_orni_[i].y + std::round(SHADOW_OY);
const Vec2 POS_SHADOW{
.x = SCREEN_CENTRE_X + (LOGO_S * (BASE_X - SCREEN_CENTRE_X)),
.y = SCREEN_CENTRE_Y + (LOGO_S * (BASE_Y - SCREEN_CENTRE_Y)),
};
Rendering::renderShape(sdl_.getRenderer(), lletres_orni_[i].shape, POS_SHADOW, 0.0F, LOGO_RENDER_SCALE, 1.0F, SHADOW_BRIGHTNESS, Defaults::Title::Colors::LOGO_SHADOW);
Rendering::renderShape(sdl_.getRenderer(), letters_orni_[i].shape, POS_SHADOW, 0.0F, LOGO_RENDER_SCALE, 1.0F, SHADOW_BRIGHTNESS, Defaults::Title::Colors::LOGO_SHADOW);
}
for (std::size_t i = 0; i < lletres_attack_.size(); ++i) {
const float BASE_X = posicions_originals_attack_[i].x + std::round(SHADOW_OX);
const float BASE_Y = posicions_originals_attack_[i].y + std::round(SHADOW_OY);
for (std::size_t i = 0; i < letters_attack_.size(); ++i) {
const float BASE_X = original_positions_attack_[i].x + std::round(SHADOW_OX);
const float BASE_Y = original_positions_attack_[i].y + std::round(SHADOW_OY);
const Vec2 POS_SHADOW{
.x = SCREEN_CENTRE_X + (LOGO_S * (BASE_X - SCREEN_CENTRE_X)),
.y = SCREEN_CENTRE_Y + (LOGO_S * (BASE_Y - SCREEN_CENTRE_Y)),
};
Rendering::renderShape(sdl_.getRenderer(), lletres_attack_[i].shape, POS_SHADOW, 0.0F, LOGO_RENDER_SCALE, 1.0F, SHADOW_BRIGHTNESS, Defaults::Title::Colors::LOGO_SHADOW);
Rendering::renderShape(sdl_.getRenderer(), letters_attack_[i].shape, POS_SHADOW, 0.0F, LOGO_RENDER_SCALE, 1.0F, SHADOW_BRIGHTNESS, Defaults::Title::Colors::LOGO_SHADOW);
}
}
for (const auto& lletra : lletres_orni_) {
for (const auto& lletra : letters_orni_) {
const Vec2 POS{
.x = SCREEN_CENTRE_X + (LOGO_S * (lletra.position.x - SCREEN_CENTRE_X)),
.y = SCREEN_CENTRE_Y + (LOGO_S * (lletra.position.y - SCREEN_CENTRE_Y)),
};
Rendering::renderShape(sdl_.getRenderer(), lletra.shape, POS, 0.0F, LOGO_RENDER_SCALE, 1.0F, 1.0F, Defaults::Title::Colors::LOGO_MAIN);
}
for (const auto& lletra : lletres_attack_) {
for (const auto& lletra : letters_attack_) {
const Vec2 POS{
.x = SCREEN_CENTRE_X + (LOGO_S * (lletra.position.x - SCREEN_CENTRE_X)),
.y = SCREEN_CENTRE_Y + (LOGO_S * (lletra.position.y - SCREEN_CENTRE_Y)),
@@ -597,7 +597,7 @@ void TitleScene::draw() {
if (press_start_visible_) {
bool mostrar_text = true;
if (estat_actual_ == TitleState::PLAYER_JOIN_PHASE) {
if (current_state_ == TitleState::PLAYER_JOIN_PHASE) {
const float FASE = temps_acumulat_ * BLINK_FREQUENCY * 2.0F * std::numbers::pi_v<float>;
mostrar_text = (std::sin(FASE) > 0.0F);
}
source/game/scenes/title_scene.hpp
+19 -19
View File
@@ -48,12 +48,12 @@ class TitleScene final : public Scene {
BLACK_SCREEN,
};
struct LetraLogo {
struct LogoLetter {
std::shared_ptr<Graphics::Shape> shape;
Vec2 position;
float ancho;
float altura;
float offset_centre;
float center_offset;
};
SDLManager& sdl_;
@@ -77,22 +77,22 @@ class TitleScene final : public Scene {
void triggerFlash(Vec2 pos);
void updateFlashes(float delta_time);
void drawFlashes();
TitleState estat_actual_{TitleState::STARFIELD_FADE_IN};
TitleState current_state_{TitleState::STARFIELD_FADE_IN};
float temps_acumulat_{0.0F};
std::vector<LetraLogo> lletres_orni_;
std::vector<LetraLogo> lletres_attack_;
float y_attack_dinamica_{0.0F};
std::vector<LogoLetter> letters_orni_;
std::vector<LogoLetter> letters_attack_;
float dynamic_attack_y_{0.0F};
std::vector<LetraLogo> lletres_jailgames_;
std::vector<LogoLetter> letters_jailgames_;
float temps_animacio_{0.0F};
std::vector<Vec2> posicions_originals_orni_;
std::vector<Vec2> posicions_originals_attack_;
float animation_time_{0.0F};
std::vector<Vec2> original_positions_orni_;
std::vector<Vec2> original_positions_attack_;
float temps_estat_main_{0.0F};
bool animacio_activa_{false};
float factor_lerp_{0.0F};
float state_time_main_{0.0F};
bool animation_active_{false};
float lerp_factor_{0.0F};
// Progresos de la intro coreografiada al state MAIN.
float intro_logo_progress_{0.0F};
@@ -102,12 +102,12 @@ class TitleScene final : public Scene {
bool ships_intro_launched_{false};
static constexpr float BRIGHTNESS_STARFIELD = 1.2F;
static constexpr float DURACIO_FADE_IN = 3.0F;
static constexpr float DURACIO_INIT = 4.0F;
static constexpr float DURACIO_TRANSITION = 2.5F;
static constexpr float ESPAI_ENTRE_LLETRES = 10.0F;
static constexpr float DURATION_FADE_IN = 3.0F;
static constexpr float DURATION_INIT = 4.0F;
static constexpr float DURATION_TRANSITION = 2.5F;
static constexpr float LETTER_SPACING = 10.0F;
static constexpr float BLINK_FREQUENCY = 3.0F;
static constexpr float DURACIO_BLACK_SCREEN = 2.0F;
static constexpr float DURATION_BLACK_SCREEN = 2.0F;
static constexpr int MUSIC_FADE = 1500;
static constexpr float ORBIT_AMPLITUDE_X = 4.0F;
@@ -121,7 +121,7 @@ class TitleScene final : public Scene {
static constexpr float SHADOW_OFFSET_X = 2.0F;
static constexpr float SHADOW_OFFSET_Y = 2.0F;
static constexpr float DURACIO_LERP = 2.0F;
static constexpr float DURATION_LERP = 2.0F;
// Càmera 3D: FOV vertical en radians.
static constexpr float CAMERA_FOV_Y_RAD = 1.0472F; // 60°