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/core/defaults/enemies.hpp
+4 -4
View File
@@ -55,8 +55,8 @@ namespace Defaults::Enemies {
namespace Animation { namespace Animation {
// Palpitation // Palpitation
constexpr float PULSE_TRIGGER_PROB = 0.01F; // 1% chance per second constexpr float PULSE_TRIGGER_PROB = 0.01F; // 1% chance per second
constexpr float PULSE_DURACIO_MIN = 1.0F; // Min duration (seconds) constexpr float PULSE_DURATION_MIN = 1.0F; // Min duration (seconds)
constexpr float PULSE_DURACIO_MAX = 3.0F; // Max duration (seconds) constexpr float PULSE_DURATION_MAX = 3.0F; // Max duration (seconds)
constexpr float PULSE_AMPLITUD_MIN = 0.08F; // Min scale variation constexpr float PULSE_AMPLITUD_MIN = 0.08F; // Min scale variation
constexpr float PULSE_AMPLITUD_MAX = 0.20F; // Max scale variation constexpr float PULSE_AMPLITUD_MAX = 0.20F; // Max scale variation
constexpr float PULSE_FREQ_MIN = 1.5F; // Min frequency (Hz) constexpr float PULSE_FREQ_MIN = 1.5F; // Min frequency (Hz)
@@ -64,8 +64,8 @@ namespace Defaults::Enemies {
// Rotation acceleration // Rotation acceleration
constexpr float ROTATION_ACCEL_TRIGGER_PROB = 0.02F; // 2% chance per second [4x more frequent] constexpr float ROTATION_ACCEL_TRIGGER_PROB = 0.02F; // 2% chance per second [4x more frequent]
constexpr float ROTATION_ACCEL_DURACIO_MIN = 3.0F; // Min transition time constexpr float ROTATION_ACCEL_DURATION_MIN = 3.0F; // Min transition time
constexpr float ROTATION_ACCEL_DURACIO_MAX = 8.0F; // Max transition time constexpr float ROTATION_ACCEL_DURATION_MAX = 8.0F; // Max transition time
constexpr float ROTATION_ACCEL_MULTIPLIER_MIN = 0.3F; // Min speed multiplier [more dramatic] constexpr float ROTATION_ACCEL_MULTIPLIER_MIN = 0.3F; // Min speed multiplier [more dramatic]
constexpr float ROTATION_ACCEL_MULTIPLIER_MAX = 4.0F; // Max speed multiplier [more dramatic] constexpr float ROTATION_ACCEL_MULTIPLIER_MAX = 4.0F; // Max speed multiplier [more dramatic]
} // namespace Animation } // namespace Animation
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 + animation_.pulse_amplitude = Defaults::Enemies::Animation::PULSE_AMPLITUD_MIN +
((static_cast<float>(std::rand()) / static_cast<float>(RAND_MAX)) * AMP_RANGE); ((static_cast<float>(std::rand()) / static_cast<float>(RAND_MAX)) * AMP_RANGE);
const float DUR_RANGE = Defaults::Enemies::Animation::PULSE_DURACIO_MAX - const float DUR_RANGE = Defaults::Enemies::Animation::PULSE_DURATION_MAX -
Defaults::Enemies::Animation::PULSE_DURACIO_MIN; Defaults::Enemies::Animation::PULSE_DURATION_MIN;
animation_.pulse_time_remaining = Defaults::Enemies::Animation::PULSE_DURACIO_MIN + animation_.pulse_time_remaining = Defaults::Enemies::Animation::PULSE_DURATION_MIN +
((static_cast<float>(std::rand()) / static_cast<float>(RAND_MAX)) * DUR_RANGE); ((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); ((static_cast<float>(std::rand()) / static_cast<float>(RAND_MAX)) * MULT_RANGE);
animation_.rotation_delta_target = animation_.rotation_delta_base * MULTIPLIER; animation_.rotation_delta_target = animation_.rotation_delta_base * MULTIPLIER;
const float DUR_RANGE = Defaults::Enemies::Animation::ROTATION_ACCEL_DURACIO_MAX - const float DUR_RANGE = Defaults::Enemies::Animation::ROTATION_ACCEL_DURATION_MAX -
Defaults::Enemies::Animation::ROTATION_ACCEL_DURACIO_MIN; Defaults::Enemies::Animation::ROTATION_ACCEL_DURATION_MIN;
animation_.rotation_delta_duration = Defaults::Enemies::Animation::ROTATION_ACCEL_DURACIO_MIN + animation_.rotation_delta_duration = Defaults::Enemies::Animation::ROTATION_ACCEL_DURATION_MIN +
((static_cast<float>(std::rand()) / static_cast<float>(RAND_MAX)) * DUR_RANGE); ((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(); auto option = context_.consumeOption();
(void)option; // Suprimir warning (void)option; // Suprimir warning
so_reproduit_.fill(false); // Inicialitzar seguiment de sons sound_played_.fill(false); // Inicialitzar seguiment de sons
initLetters(); initLetters();
} }
@@ -112,21 +112,21 @@ void LogoScene::initLetters() {
float ancho_sin_escalar = max_x - min_x; 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 // per que las posicions finals coincideixin con la mida real de las lletres
float ancho = ancho_sin_escalar * ESCALA_FINAL; float ancho = ancho_sin_escalar * FINAL_SCALE;
float offset_centre = (shape->getCenter().x - min_x) * ESCALA_FINAL; 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 {.x = 0.0F, .y = 0.0F}, // Posición es calcularà después
ancho, ancho,
offset_centre}); center_offset});
ancho_total += ancho; ancho_total += ancho;
} }
// Pas 2: Añadir espaiat entre lletres // 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) // Pas 3: Calcular posición inicial (centrat horitzontal)
constexpr auto PANTALLA_ANCHO = static_cast<float>(Defaults::Game::WIDTH); constexpr auto PANTALLA_ANCHO = static_cast<float>(Defaults::Game::WIDTH);
@@ -138,38 +138,38 @@ void LogoScene::initLetters() {
// Pas 4: Assignar posicions a cada lletra // Pas 4: Assignar posicions a cada lletra
float x_actual = x_inicial; float x_actual = x_inicial;
for (auto& lletra : lletres_) { for (auto& lletra : letters_) {
// Posicionar el centro de la shape (shape_centre) en pantalla // 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 // 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; lletra.position.y = y_centre;
// Avançar para següent lletra // 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"; << " lletres carregades, ancho total: " << ancho_total << " px\n";
} }
void LogoScene::changeState(AnimationState nou_estat) { void LogoScene::changeState(AnimationState nou_estat) {
estat_actual_ = nou_estat; current_state_ = nou_estat;
temps_estat_actual_ = 0.0F; // Reset time temps_current_state_ = 0.0F; // Reset time
// Inicialitzar state de explosión // Inicialitzar state de explosión
if (nou_estat == AnimationState::EXPLOSION) { if (nou_estat == AnimationState::EXPLOSION) {
lletra_explosio_index_ = 0; letter_explosion_index_ = 0;
temps_des_ultima_explosio_ = 0.0F; time_since_last_explosion_ = 0.0F;
// Generar ordre aleatori de explosions // Generar ordre aleatori de explosions
ordre_explosio_.clear(); explosion_order_.clear();
for (size_t i = 0; i < lletres_.size(); i++) { for (size_t i = 0; i < letters_.size(); i++) {
ordre_explosio_.push_back(i); explosion_order_.push_back(i);
} }
std::random_device rd; std::random_device rd;
std::mt19937 g(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) { } else if (nou_estat == AnimationState::POST_EXPLOSION) {
Audio::get()->playMusic("title.ogg"); Audio::get()->playMusic("title.ogg");
} }
@@ -180,34 +180,34 @@ void LogoScene::changeState(AnimationState nou_estat) {
auto LogoScene::allLettersComplete() const -> bool { auto LogoScene::allLettersComplete() const -> bool {
// Cuando global_progress = 1.0, todas las lletres tenen letra_progress = 1.0 // 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) { 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 // Comprovar si es el moment de explode la següent lletra
if (temps_des_ultima_explosio_ >= DELAY_ENTRE_EXPLOSIONS) { if (time_since_last_explosion_ >= DELAY_ENTRE_EXPLOSIONS) {
if (lletra_explosio_index_ < lletres_.size()) { if (letter_explosion_index_ < letters_.size()) {
// Explotar lletra actual (en ordre aleatori) // Explotar lletra actual (en ordre aleatori)
size_t index_actual = ordre_explosio_[lletra_explosio_index_]; size_t index_actual = explosion_order_[letter_explosion_index_];
const auto& lletra = lletres_[index_actual]; const auto& lletra = letters_[index_actual];
debris_manager_->explode( debris_manager_->explode(
lletra.shape, // Forma a explode lletra.shape, // Forma a explode
lletra.position, // Posición lletra.position, // Posición
0.0F, // Angle (sin rotació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 SPEED_EXPLOSIO, // Velocidad base
1.0F, // Brightness màxim (per defecte) 1.0F, // Brightness màxim (per defecte)
{.x = 0.0F, .y = 0.0F} // Sin velocity (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 // Passar a la següent lletra
lletra_explosio_index_++; letter_explosion_index_++;
temps_des_ultima_explosio_ = 0.0F; time_since_last_explosion_ = 0.0F;
} else { } else {
// Todas las lletres han explotat, transición a POST_EXPLOSION // Todas las lletres han explotat, transición a POST_EXPLOSION
changeState(AnimationState::POST_EXPLOSION); changeState(AnimationState::POST_EXPLOSION);
@@ -216,31 +216,31 @@ void LogoScene::updateExplosions(float delta_time) {
} }
void LogoScene::update(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: case AnimationState::PRE_ANIMATION:
if (temps_estat_actual_ >= DURACIO_PRE) { if (temps_current_state_ >= DURATION_PRE) {
changeState(AnimationState::ANIMATION); changeState(AnimationState::ANIMATION);
} }
break; break;
case AnimationState::ANIMATION: { case AnimationState::ANIMATION: {
// Reproduir so per cada lletra cuando comença a aparèixer // 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++) { for (size_t i = 0; i < letters_.size() && i < sound_played_.size(); i++) {
if (!so_reproduit_[i]) { if (!sound_played_[i]) {
float letra_progress = computeLetterProgress( float letra_progress = computeLetterProgress(
i, i,
lletres_.size(), letters_.size(),
global_progress, global_progress,
THRESHOLD_LETRA); LETTER_THRESHOLD);
// Reproduir so cuando la lletra comença a aparèixer (progress > 0) // Reproduir so cuando la lletra comença a aparèixer (progress > 0)
if (letra_progress > 0.0F) { if (letra_progress > 0.0F) {
Audio::get()->playSound(Defaults::Sound::LOGO, Audio::Group::GAME); 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: case AnimationState::POST_ANIMATION:
if (temps_estat_actual_ >= DURACIO_POST_ANIMATION) { if (temps_current_state_ >= DURATION_POST_ANIMATION) {
changeState(AnimationState::EXPLOSION); changeState(AnimationState::EXPLOSION);
} }
break; break;
@@ -262,7 +262,7 @@ void LogoScene::update(float delta_time) {
break; break;
case AnimationState::POST_EXPLOSION: 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 // Transición a pantalla de título
context_.setNextScene(SceneType::TITLE); context_.setNextScene(SceneType::TITLE);
} }
@@ -282,28 +282,28 @@ void LogoScene::draw() {
// Director ha hecho el clear; aquí solo pintamos lo de la escena. // Director ha hecho el clear; aquí solo pintamos lo de la escena.
// PRE_ANIMATION: Solo pantalla negra (no se pinta nada). // PRE_ANIMATION: Solo pantalla negra (no se pinta nada).
if (estat_actual_ == AnimationState::PRE_ANIMATION) { if (current_state_ == AnimationState::PRE_ANIMATION) {
return; return;
} }
// ANIMATION o POST_ANIMATION: Dibuixar lletres con animación // ANIMATION o POST_ANIMATION: Dibuixar lletres con animación
if (estat_actual_ == AnimationState::ANIMATION || if (current_state_ == AnimationState::ANIMATION ||
estat_actual_ == AnimationState::POST_ANIMATION) { current_state_ == AnimationState::POST_ANIMATION) {
float global_progress = float global_progress =
(estat_actual_ == AnimationState::ANIMATION) (current_state_ == AnimationState::ANIMATION)
? std::min(temps_estat_actual_ / DURACIO_ZOOM, 1.0F) ? std::min(temps_current_state_ / DURATION_ZOOM, 1.0F)
: 1.0F; // POST: mantenir al 100% : 1.0F; // POST: mantenir al 100%
const Vec2 ORIGEN_ZOOM = {.x = ORIGEN_ZOOM_X, .y = ORIGEN_ZOOM_Y}; const Vec2 ORIGEN_ZOOM = {.x = ORIGEN_ZOOM_X, .y = ORIGEN_ZOOM_Y};
for (size_t i = 0; i < lletres_.size(); i++) { for (size_t i = 0; i < letters_.size(); i++) {
const auto& lletra = lletres_[i]; const auto& lletra = letters_[i];
float letra_progress = computeLetterProgress( float letra_progress = computeLetterProgress(
i, i,
lletres_.size(), letters_.size(),
global_progress, global_progress,
THRESHOLD_LETRA); LETTER_THRESHOLD);
if (letra_progress <= 0.0F) { if (letra_progress <= 0.0F) {
continue; continue;
@@ -318,7 +318,7 @@ void LogoScene::draw() {
float t = letra_progress; float t = letra_progress;
float ease_factor = 1.0F - ((1.0F - t) * (1.0F - t)); float ease_factor = 1.0F - ((1.0F - t) * (1.0F - t));
float current_scale = float current_scale =
ESCALA_INICIAL + ((ESCALA_FINAL - ESCALA_INICIAL) * ease_factor); INITIAL_SCALE + ((FINAL_SCALE - INITIAL_SCALE) * ease_factor);
Rendering::renderShape( Rendering::renderShape(
sdl_.getRenderer(), sdl_.getRenderer(),
@@ -331,24 +331,24 @@ void LogoScene::draw() {
} }
// EXPLOSION: Dibuixar solo lletres que aún no han explotat // 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 // Crear conjunt de lletres ya explotades
std::set<size_t> explotades; std::set<size_t> explotades;
for (size_t i = 0; i < lletra_explosio_index_; i++) { for (size_t i = 0; i < letter_explosion_index_; i++) {
explotades.insert(ordre_explosio_[i]); explotades.insert(explosion_order_[i]);
} }
// Dibuixar solo lletres que NO han explotat // 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)) { if (!explotades.contains(i)) {
const auto& lletra = lletres_[i]; const auto& lletra = letters_[i];
Rendering::renderShape( Rendering::renderShape(
sdl_.getRenderer(), sdl_.getRenderer(),
lletra.shape, lletra.shape,
lletra.position, lletra.position,
0.0F, 0.0F,
ESCALA_FINAL, FINAL_SCALE,
1.0F); 1.0F);
} }
} }
source/game/scenes/logo_scene.hpp
+17 -17
View File
@@ -42,44 +42,44 @@ class LogoScene final : public Scene {
SDLManager& sdl_; SDLManager& sdl_;
SceneManager::SceneContext& context_; 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 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 // Gestor de fragments de explosions
std::unique_ptr<Effects::DebrisManager> debris_manager_; std::unique_ptr<Effects::DebrisManager> debris_manager_;
// Seguiment de explosions seqüencials // Seguiment de explosions seqüencials
size_t lletra_explosio_index_{0}; // Índex de la següent lletra a explode size_t letter_explosion_index_{0}; // Índex de la següent lletra a explode
float temps_des_ultima_explosio_{0.0F}; // Temps desde l'última explosión float time_since_last_explosion_{0.0F}; // Temps desde l'última explosión
std::vector<size_t> ordre_explosio_; // Ordre aleatori de índexs de lletres std::vector<size_t> explosion_order_; // Ordre aleatori de índexs de lletres
// Estructura para cada lletra del logo // Estructura para cada lletra del logo
struct LetraLogo { struct LogoLetter {
std::shared_ptr<Graphics::Shape> shape; std::shared_ptr<Graphics::Shape> shape;
Vec2 position; // Posición final en pantalla Vec2 position; // Posición final en pantalla
float ancho; // Ancho del bounding box 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) // 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 // Constants de animación
static constexpr float DURACIO_PRE = 1.5F; // Duració PRE_ANIMATION (pantalla negra) static constexpr float DURATION_PRE = 1.5F; // Duració PRE_ANIMATION (pantalla negra)
static constexpr float DURACIO_ZOOM = 4.0F; // Duració del zoom (segons) static constexpr float DURATION_ZOOM = 4.0F; // Duració del zoom (segons)
static constexpr float DURACIO_POST_ANIMATION = 3.0F; // Duració POST_ANIMATION (logo complet) static constexpr float DURATION_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 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 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 SPEED_EXPLOSIO = 240.0F; // Velocidad base fragments (px/s)
static constexpr float ESCALA_INICIAL = 0.1F; // Escala inicial (10%) static constexpr float INITIAL_SCALE = 0.1F; // Escala inicial (10%)
static constexpr float ESCALA_FINAL = 0.8F; // Escala final (80%) static constexpr float FINAL_SCALE = 0.8F; // Escala final (80%)
static constexpr float ESPAI_ENTRE_LLETRES = 10.0F; // Espaiat entre lletres static constexpr float LETTER_SPACING = 10.0F; // Espaiat entre lletres
// Constants de animación seqüencial // 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_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 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(); auto option = context_.consumeOption();
if (option == Option::JUMP_TO_TITLE_MAIN) { if (option == Option::JUMP_TO_TITLE_MAIN) {
std::cout << "SceneType Titol: Opció JUMP_TO_TITLE_MAIN activada\n"; std::cout << "SceneType Titol: Opció JUMP_TO_TITLE_MAIN activada\n";
estat_actual_ = TitleState::MAIN; current_state_ = TitleState::MAIN;
temps_estat_main_ = 0.0F; state_time_main_ = 0.0F;
} }
// Càmera 3D: posicionada a l'origen, mirant cap a +Z, amb Y cap amunt. // 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(), camera_.get(),
200); 200);
starfield_->setColor(Defaults::Title::Colors::STARFIELD); starfield_->setColor(Defaults::Title::Colors::STARFIELD);
if (estat_actual_ == TitleState::MAIN) { if (current_state_ == TitleState::MAIN) {
starfield_->setBrightness(BRIGHTNESS_STARFIELD); starfield_->setBrightness(BRIGHTNESS_STARFIELD);
} else { } else {
starfield_->setBrightness(0.0F); 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 ANCHO = (max_x - min_x) * Defaults::Title::Layout::LOGO_SCALE;
const float ALTURA = (max_y - min_y) * 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; 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 += 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; float x_actual = (Defaults::Game::WIDTH - ancho_total_orni) / 2.0F;
for (auto& lletra : lletres_orni_) { for (auto& lletra : letters_orni_) {
lletra.position.x = x_actual + lletra.offset_centre; lletra.position.x = x_actual + lletra.center_offset;
lletra.position.y = Defaults::Game::HEIGHT * Defaults::Title::Layout::LOGO_POS; 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 Y_ORNI = Defaults::Game::HEIGHT * Defaults::Title::Layout::LOGO_POS;
const float SEPARACION = Defaults::Game::HEIGHT * Defaults::Title::Layout::LOGO_LINE_SPACING; 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 = { const std::vector<std::string> FITXERS_ATTACK = {
"title/letra_a.shp", "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 ANCHO = (max_x - min_x) * Defaults::Title::Layout::LOGO_SCALE;
const float ALTURA = (max_y - min_y) * 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; 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 += 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; x_actual = (Defaults::Game::WIDTH - ancho_total_attack) / 2.0F;
for (auto& lletra : lletres_attack_) { for (auto& lletra : letters_attack_) {
lletra.position.x = x_actual + lletra.offset_centre; lletra.position.x = x_actual + lletra.center_offset;
lletra.position.y = y_attack_dinamica_; lletra.position.y = dynamic_attack_y_;
x_actual += lletra.ancho + ESPAI_ENTRE_LLETRES; x_actual += lletra.ancho + LETTER_SPACING;
} }
posicions_originals_orni_.clear(); original_positions_orni_.clear();
for (const auto& lletra : lletres_orni_) { for (const auto& lletra : letters_orni_) {
posicions_originals_orni_.push_back(lletra.position); original_positions_orni_.push_back(lletra.position);
} }
posicions_originals_attack_.clear(); original_positions_attack_.clear();
for (const auto& lletra : lletres_attack_) { for (const auto& lletra : letters_attack_) {
posicions_originals_attack_.push_back(lletra.position); original_positions_attack_.push_back(lletra.position);
} }
} }
@@ -234,13 +234,13 @@ void TitleScene::inicialitzarJailgames() {
const float ANCHO = (max_x - min_x) * SCALE; const float ANCHO = (max_x - min_x) * SCALE;
const float ALTURA = (max_y - min_y) * SCALE; const float ALTURA = (max_y - min_y) * SCALE;
const float OFFSET_CENTRE = (shape->getCenter().x - min_x) * 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; ancho_total += ANCHO;
altura_max = std::max(altura_max, ALTURA); altura_max = std::max(altura_max, ALTURA);
} }
constexpr float ESPAI_JAILGAMES = ESPAI_ENTRE_LLETRES * SCALE; constexpr float ESPAI_JAILGAMES = LETTER_SPACING * SCALE;
if (!lletres_jailgames_.empty()) { if (!letters_jailgames_.empty()) {
ancho_total += ESPAI_JAILGAMES * static_cast<float>(lletres_jailgames_.size() - 1); ancho_total += ESPAI_JAILGAMES * static_cast<float>(letters_jailgames_.size() - 1);
} }
const float Y_COPY = Defaults::Game::HEIGHT * Defaults::Title::Layout::COPYRIGHT1_POS; 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; const float X_INICIAL = (Defaults::Game::WIDTH - ancho_total) / 2.0F;
float x_actual = X_INICIAL; float x_actual = X_INICIAL;
for (auto& lletra : lletres_jailgames_) { for (auto& lletra : letters_jailgames_) {
lletra.position.x = x_actual + lletra.offset_centre; lletra.position.x = x_actual + lletra.center_offset;
lletra.position.y = Y_CENTRE; lletra.position.y = Y_CENTRE;
x_actual += lletra.ancho + ESPAI_JAILGAMES; 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 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; 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{ const Vec2 POS{
.x = SCREEN_CENTRE_X + (JAILGAMES_S * (lletra.position.x - SCREEN_CENTRE_X)), .x = SCREEN_CENTRE_X + (JAILGAMES_S * (lletra.position.x - SCREEN_CENTRE_X)),
.y = SCREEN_CENTRE_Y + (JAILGAMES_S * (lletra.position.y - SCREEN_CENTRE_Y)), .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); starfield_->update(delta_time);
} }
if (ship_animator_ && if (ship_animator_ &&
(estat_actual_ == TitleState::STARFIELD_FADE_IN || (current_state_ == TitleState::STARFIELD_FADE_IN ||
estat_actual_ == TitleState::STARFIELD || current_state_ == TitleState::STARFIELD ||
estat_actual_ == TitleState::MAIN || current_state_ == TitleState::MAIN ||
estat_actual_ == TitleState::PLAYER_JOIN_PHASE)) { current_state_ == TitleState::PLAYER_JOIN_PHASE)) {
ship_animator_->update(delta_time); ship_animator_->update(delta_time);
} }
updateFlashes(delta_time); updateFlashes(delta_time);
switch (estat_actual_) { switch (current_state_) {
case TitleState::STARFIELD_FADE_IN: case TitleState::STARFIELD_FADE_IN:
updateStarfieldFadeInState(delta_time); updateStarfieldFadeInState(delta_time);
break; break;
@@ -329,10 +329,10 @@ void TitleScene::update(float delta_time) {
void TitleScene::updateStarfieldFadeInState(float delta_time) { void TitleScene::updateStarfieldFadeInState(float delta_time) {
temps_acumulat_ += 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); starfield_->setBrightness(PROGRESS * BRIGHTNESS_STARFIELD);
if (temps_acumulat_ >= DURACIO_FADE_IN) { if (temps_acumulat_ >= DURATION_FADE_IN) {
estat_actual_ = TitleState::STARFIELD; current_state_ = TitleState::STARFIELD;
temps_acumulat_ = 0.0F; temps_acumulat_ = 0.0F;
starfield_->setBrightness(BRIGHTNESS_STARFIELD); starfield_->setBrightness(BRIGHTNESS_STARFIELD);
} }
@@ -340,16 +340,16 @@ void TitleScene::updateStarfieldFadeInState(float delta_time) {
void TitleScene::updateStarfieldState(float delta_time) { void TitleScene::updateStarfieldState(float delta_time) {
temps_acumulat_ += delta_time; temps_acumulat_ += delta_time;
if (temps_acumulat_ >= DURACIO_INIT) { if (temps_acumulat_ >= DURATION_INIT) {
estat_actual_ = TitleState::MAIN; current_state_ = TitleState::MAIN;
temps_estat_main_ = 0.0F; state_time_main_ = 0.0F;
animacio_activa_ = false; animation_active_ = false;
factor_lerp_ = 0.0F; lerp_factor_ = 0.0F;
} }
} }
void TitleScene::updateMainState(float delta_time) { void TitleScene::updateMainState(float delta_time) {
temps_estat_main_ += delta_time; state_time_main_ += delta_time;
namespace S = Defaults::Title::Sequence; namespace S = Defaults::Title::Sequence;
namespace Sh = Defaults::Title::Ships; 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_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; 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( 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, 0.0F,
1.0F); 1.0F);
intro_copyright_progress_ = std::clamp( 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, 0.0F,
1.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_ != nullptr) {
ship_animator_->setVisible(true); ship_animator_->setVisible(true);
ship_animator_->startEntryAnimation(); ship_animator_->startEntryAnimation();
ships_intro_launched_ = true; 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; press_start_visible_ = true;
} }
// L'oscil·lació suau del logo arrenca quan el logo ha aterrat. Així // L'oscil·lació suau del logo arrenca quan el logo ha aterrat. Així
// l'amplitud creix gradualment (lerp) durant la resta de la intro. // l'amplitud creix gradualment (lerp) durant la resta de la intro.
if (temps_estat_main_ < S::LOGO_ENTRY_DURATION) { if (state_time_main_ < S::LOGO_ENTRY_DURATION) {
factor_lerp_ = 0.0F; lerp_factor_ = 0.0F;
animacio_activa_ = false; animation_active_ = false;
} else if (temps_estat_main_ < S::LOGO_ENTRY_DURATION + DURACIO_LERP) { } else if (state_time_main_ < S::LOGO_ENTRY_DURATION + DURATION_LERP) {
factor_lerp_ = (temps_estat_main_ - S::LOGO_ENTRY_DURATION) / DURACIO_LERP; lerp_factor_ = (state_time_main_ - S::LOGO_ENTRY_DURATION) / DURATION_LERP;
animacio_activa_ = true; animation_active_ = true;
} else { } else {
factor_lerp_ = 1.0F; lerp_factor_ = 1.0F;
animacio_activa_ = true; animation_active_ = true;
} }
updateLogoAnimation(delta_time); updateLogoAnimation(delta_time);
} }
@@ -414,27 +414,27 @@ void TitleScene::updatePlayerJoinPhaseState(float delta_time) {
temps_acumulat_ = 0.0F; temps_acumulat_ = 0.0F;
} }
if (temps_acumulat_ >= DURACIO_TRANSITION) { if (temps_acumulat_ >= DURATION_TRANSITION) {
estat_actual_ = TitleState::BLACK_SCREEN; current_state_ = TitleState::BLACK_SCREEN;
temps_acumulat_ = 0.0F; temps_acumulat_ = 0.0F;
} }
} }
void TitleScene::updateBlackScreenState(float delta_time) { void TitleScene::updateBlackScreenState(float delta_time) {
temps_acumulat_ += delta_time; temps_acumulat_ += delta_time;
if (temps_acumulat_ >= DURACIO_BLACK_SCREEN) { if (temps_acumulat_ >= DURATION_BLACK_SCREEN) {
context_.setNextScene(SceneType::GAME); context_.setNextScene(SceneType::GAME);
} }
} }
void TitleScene::handleSkipInput() { 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; return;
} }
if (!checkSkipButtonPressed()) { if (!checkSkipButtonPressed()) {
return; return;
} }
estat_actual_ = TitleState::MAIN; current_state_ = TitleState::MAIN;
starfield_->setBrightness(BRIGHTNESS_STARFIELD); starfield_->setBrightness(BRIGHTNESS_STARFIELD);
// Saltar la intro coreografiada: deixar tots els elements ja in-place. // 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); 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 + 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; 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_logo_progress_ = 1.0F;
intro_jailgames_progress_ = 1.0F; intro_jailgames_progress_ = 1.0F;
intro_copyright_progress_ = 1.0F; intro_copyright_progress_ = 1.0F;
@@ -458,7 +458,7 @@ void TitleScene::handleSkipInput() {
} }
void TitleScene::handleStartInput() { void TitleScene::handleStartInput() {
if (estat_actual_ != TitleState::MAIN) { if (current_state_ != TitleState::MAIN) {
return; return;
} }
// No acceptar START fins que la intro coreografiada haja conclòs i el // No acceptar START fins que la intro coreografiada haja conclòs i el
@@ -479,7 +479,7 @@ void TitleScene::handleStartInput() {
} }
context_.setMatchConfig(match_config_); context_.setMatchConfig(match_config_);
estat_actual_ = TitleState::PLAYER_JOIN_PHASE; current_state_ = TitleState::PLAYER_JOIN_PHASE;
temps_acumulat_ = 0.0F; temps_acumulat_ = 0.0F;
triggerExitForJoinedPlayers(P1_ABANS, P2_ABANS, ""); 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) { void TitleScene::updateLogoAnimation(float delta_time) {
if (!animacio_activa_) { if (!animation_active_) {
return; return;
} }
temps_animacio_ += delta_time * factor_lerp_; animation_time_ += delta_time * lerp_factor_;
const float TWO_PI = 2.0F * Defaults::Math::PI; 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_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 * temps_animacio_) + ORBIT_PHASE_OFFSET); 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) { for (std::size_t i = 0; i < letters_orni_.size(); ++i) {
lletres_orni_[i].position.x = posicions_originals_orni_[i].x + std::round(OFFSET_X); letters_orni_[i].position.x = original_positions_orni_[i].x + std::round(OFFSET_X);
lletres_orni_[i].position.y = posicions_originals_orni_[i].y + std::round(OFFSET_Y); 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) { for (std::size_t i = 0; i < letters_attack_.size(); ++i) {
lletres_attack_[i].position.x = posicions_originals_attack_[i].x + std::round(OFFSET_X); letters_attack_[i].position.x = original_positions_attack_[i].x + std::round(OFFSET_X);
lletres_attack_[i].position.y = posicions_originals_attack_[i].y + std::round(OFFSET_Y); letters_attack_[i].position.y = original_positions_attack_[i].y + std::round(OFFSET_Y);
} }
} }
void TitleScene::draw() { void TitleScene::draw() {
if (starfield_ && estat_actual_ != TitleState::BLACK_SCREEN) { if (starfield_ && current_state_ != TitleState::BLACK_SCREEN) {
starfield_->draw(); starfield_->draw();
} }
if (ship_animator_ && if (ship_animator_ &&
(estat_actual_ == TitleState::STARFIELD_FADE_IN || (current_state_ == TitleState::STARFIELD_FADE_IN ||
estat_actual_ == TitleState::STARFIELD || current_state_ == TitleState::STARFIELD ||
estat_actual_ == TitleState::MAIN || current_state_ == TitleState::MAIN ||
estat_actual_ == TitleState::PLAYER_JOIN_PHASE)) { current_state_ == TitleState::PLAYER_JOIN_PHASE)) {
ship_animator_->draw(); ship_animator_->draw();
} }
drawFlashes(); drawFlashes();
if (estat_actual_ == TitleState::STARFIELD_FADE_IN || estat_actual_ == TitleState::STARFIELD) { if (current_state_ == TitleState::STARFIELD_FADE_IN || current_state_ == TitleState::STARFIELD) {
return; return;
} }
if (estat_actual_ != TitleState::MAIN && estat_actual_ != TitleState::PLAYER_JOIN_PHASE) { if (current_state_ != TitleState::MAIN && current_state_ != TitleState::PLAYER_JOIN_PHASE) {
return; return;
} }
@@ -552,40 +552,40 @@ void TitleScene::draw() {
const float SCREEN_CENTRE_Y = Defaults::Game::HEIGHT / 2.0F; const float SCREEN_CENTRE_Y = Defaults::Game::HEIGHT / 2.0F;
const float LOGO_RENDER_SCALE = Defaults::Title::Layout::LOGO_SCALE * LOGO_S; const float LOGO_RENDER_SCALE = Defaults::Title::Layout::LOGO_SCALE * LOGO_S;
if (animacio_activa_) { if (animation_active_) {
float temps_shadow = std::max(0.0F, temps_animacio_ - SHADOW_DELAY); float temps_shadow = std::max(0.0F, animation_time_ - SHADOW_DELAY);
const float TWO_PI = 2.0F * Defaults::Math::PI; 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_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; 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) { for (std::size_t i = 0; i < letters_orni_.size(); ++i) {
const float BASE_X = posicions_originals_orni_[i].x + std::round(SHADOW_OX); const float BASE_X = original_positions_orni_[i].x + std::round(SHADOW_OX);
const float BASE_Y = posicions_originals_orni_[i].y + std::round(SHADOW_OY); const float BASE_Y = original_positions_orni_[i].y + std::round(SHADOW_OY);
const Vec2 POS_SHADOW{ const Vec2 POS_SHADOW{
.x = SCREEN_CENTRE_X + (LOGO_S * (BASE_X - SCREEN_CENTRE_X)), .x = SCREEN_CENTRE_X + (LOGO_S * (BASE_X - SCREEN_CENTRE_X)),
.y = SCREEN_CENTRE_Y + (LOGO_S * (BASE_Y - SCREEN_CENTRE_Y)), .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) { for (std::size_t i = 0; i < letters_attack_.size(); ++i) {
const float BASE_X = posicions_originals_attack_[i].x + std::round(SHADOW_OX); const float BASE_X = original_positions_attack_[i].x + std::round(SHADOW_OX);
const float BASE_Y = posicions_originals_attack_[i].y + std::round(SHADOW_OY); const float BASE_Y = original_positions_attack_[i].y + std::round(SHADOW_OY);
const Vec2 POS_SHADOW{ const Vec2 POS_SHADOW{
.x = SCREEN_CENTRE_X + (LOGO_S * (BASE_X - SCREEN_CENTRE_X)), .x = SCREEN_CENTRE_X + (LOGO_S * (BASE_X - SCREEN_CENTRE_X)),
.y = SCREEN_CENTRE_Y + (LOGO_S * (BASE_Y - SCREEN_CENTRE_Y)), .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{ const Vec2 POS{
.x = SCREEN_CENTRE_X + (LOGO_S * (lletra.position.x - SCREEN_CENTRE_X)), .x = SCREEN_CENTRE_X + (LOGO_S * (lletra.position.x - SCREEN_CENTRE_X)),
.y = SCREEN_CENTRE_Y + (LOGO_S * (lletra.position.y - SCREEN_CENTRE_Y)), .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); 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{ const Vec2 POS{
.x = SCREEN_CENTRE_X + (LOGO_S * (lletra.position.x - SCREEN_CENTRE_X)), .x = SCREEN_CENTRE_X + (LOGO_S * (lletra.position.x - SCREEN_CENTRE_X)),
.y = SCREEN_CENTRE_Y + (LOGO_S * (lletra.position.y - SCREEN_CENTRE_Y)), .y = SCREEN_CENTRE_Y + (LOGO_S * (lletra.position.y - SCREEN_CENTRE_Y)),
@@ -597,7 +597,7 @@ void TitleScene::draw() {
if (press_start_visible_) { if (press_start_visible_) {
bool mostrar_text = true; 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>; const float FASE = temps_acumulat_ * BLINK_FREQUENCY * 2.0F * std::numbers::pi_v<float>;
mostrar_text = (std::sin(FASE) > 0.0F); 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, BLACK_SCREEN,
}; };
struct LetraLogo { struct LogoLetter {
std::shared_ptr<Graphics::Shape> shape; std::shared_ptr<Graphics::Shape> shape;
Vec2 position; Vec2 position;
float ancho; float ancho;
float altura; float altura;
float offset_centre; float center_offset;
}; };
SDLManager& sdl_; SDLManager& sdl_;
@@ -77,22 +77,22 @@ class TitleScene final : public Scene {
void triggerFlash(Vec2 pos); void triggerFlash(Vec2 pos);
void updateFlashes(float delta_time); void updateFlashes(float delta_time);
void drawFlashes(); void drawFlashes();
TitleState estat_actual_{TitleState::STARFIELD_FADE_IN}; TitleState current_state_{TitleState::STARFIELD_FADE_IN};
float temps_acumulat_{0.0F}; float temps_acumulat_{0.0F};
std::vector<LetraLogo> lletres_orni_; std::vector<LogoLetter> letters_orni_;
std::vector<LetraLogo> lletres_attack_; std::vector<LogoLetter> letters_attack_;
float y_attack_dinamica_{0.0F}; float dynamic_attack_y_{0.0F};
std::vector<LetraLogo> lletres_jailgames_; std::vector<LogoLetter> letters_jailgames_;
float temps_animacio_{0.0F}; float animation_time_{0.0F};
std::vector<Vec2> posicions_originals_orni_; std::vector<Vec2> original_positions_orni_;
std::vector<Vec2> posicions_originals_attack_; std::vector<Vec2> original_positions_attack_;
float temps_estat_main_{0.0F}; float state_time_main_{0.0F};
bool animacio_activa_{false}; bool animation_active_{false};
float factor_lerp_{0.0F}; float lerp_factor_{0.0F};
// Progresos de la intro coreografiada al state MAIN. // Progresos de la intro coreografiada al state MAIN.
float intro_logo_progress_{0.0F}; float intro_logo_progress_{0.0F};
@@ -102,12 +102,12 @@ class TitleScene final : public Scene {
bool ships_intro_launched_{false}; bool ships_intro_launched_{false};
static constexpr float BRIGHTNESS_STARFIELD = 1.2F; static constexpr float BRIGHTNESS_STARFIELD = 1.2F;
static constexpr float DURACIO_FADE_IN = 3.0F; static constexpr float DURATION_FADE_IN = 3.0F;
static constexpr float DURACIO_INIT = 4.0F; static constexpr float DURATION_INIT = 4.0F;
static constexpr float DURACIO_TRANSITION = 2.5F; static constexpr float DURATION_TRANSITION = 2.5F;
static constexpr float ESPAI_ENTRE_LLETRES = 10.0F; static constexpr float LETTER_SPACING = 10.0F;
static constexpr float BLINK_FREQUENCY = 3.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 int MUSIC_FADE = 1500;
static constexpr float ORBIT_AMPLITUDE_X = 4.0F; 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_X = 2.0F;
static constexpr float SHADOW_OFFSET_Y = 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. // Càmera 3D: FOV vertical en radians.
static constexpr float CAMERA_FOV_Y_RAD = 1.0472F; // 60° static constexpr float CAMERA_FOV_Y_RAD = 1.0472F; // 60°